1193 lines
37 KiB
JavaScript
1193 lines
37 KiB
JavaScript
/**
|
|
* @file deliveryAutomat.js
|
|
* @description Manages cached and chunk-paginated company inbound goods receipts / deliveries (`GET /api/delivery`).
|
|
*
|
|
* Implements a multi-filter chunk cache identical to `orderAutomat`:
|
|
* - Each filter combination has its own isolated cache entry (total, unfilteredTotal, items array, loadedChunks).
|
|
* - Total chunk capacity across all filter combinations is bounded by a global LRU limit of 50 chunks.
|
|
* - When filter settings change, previously loaded chunks remain cached in memory up to the 50-chunk limit.
|
|
* - Switching back to a previously used filter is instant with zero network requests if its chunks are in RAM.
|
|
* - Real-time stats and events can be observed via `subscribeChunkStats` or the dev ChunkCacheMonitor.
|
|
*
|
|
* Upstream Triggers:
|
|
* - `authAutomat`: Triggers `actions.reset()` on `'anon'` or when `selectedCompanyId` changes.
|
|
* - `sseAutomat`: Triggers `actions.reload()` on `'delivery'` SSE events.
|
|
* - UI / Routes: Calls `getItems()`, `requireChunk(chunkIndex)`, `loadChunk(chunkIndex)`, or `reload()`.
|
|
*/
|
|
|
|
import { Automat } from 'react-automat';
|
|
import { delivery as deliveryApi } from '../api';
|
|
import authAutomat from './authAutomat';
|
|
|
|
/**
|
|
* @typedef {Object} DeliveryLedgerStatus
|
|
* @property {number} totalPositions
|
|
* @property {number} completelyOnLedgerPositions
|
|
* @property {number} bookedPositions
|
|
* @property {number} unbookedPositions
|
|
* @property {number} totalQuantity
|
|
* @property {number} bookedQuantity
|
|
* @property {number} unbookedQuantity
|
|
* @property {boolean} isBooked
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} DeliveryAttachment
|
|
* @property {number} id
|
|
* @property {number} [fileId]
|
|
* @property {number} [manifestId]
|
|
* @property {string} name
|
|
* @property {string} mimetype
|
|
* @property {number} size
|
|
* @property {string} [thumbavif]
|
|
* @property {string} [skeledash]
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} DeliverySummary
|
|
* @property {number} id Delivery id.
|
|
* @property {string} number Manifest number.
|
|
* @property {'delivery'} type Always `'delivery'`.
|
|
* @property {number|null} supplierId Supplier id.
|
|
* @property {string|null} [supplierName] Supplier name.
|
|
* @property {string|null} externalNumber External reference / delivery note number.
|
|
* @property {string} date Delivery date (ISO).
|
|
* @property {string|null} createdAt Creation timestamp (ISO).
|
|
* @property {number} [positions] Total line positions count.
|
|
* @property {DeliveryLedgerStatus} [ledger] Ledger booking status.
|
|
* @property {DeliveryAttachment[]} [files] Attached files / PDFs.
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} DeliveryAutomatState
|
|
* @property {DeliverySummary[]|null} items Pre-filled array of deliveries/nulls, initially null.
|
|
* @property {number} total Total unpaged count for pagination calculation.
|
|
* @property {number} unfilteredTotal Unfiltered total count.
|
|
* @property {string} filter Search term.
|
|
* @property {boolean} onlyUnbooked Only unbooked deliveries.
|
|
* @property {number|null} supplierId Filter by supplier id.
|
|
* @property {number} seekMonths Seek month count.
|
|
* @property {number} seekYears Seek year count.
|
|
* @property {number} negativeSeekMonths Negative seek months offset.
|
|
* @property {'idle'|'loading'|'ready'|'failed'} status Load lifecycle state.
|
|
* @property {Error|string|null} error Last load error.
|
|
*/
|
|
|
|
export const CHUNK_SIZE = 50;
|
|
export const MAX_LRU_CHUNKS = 50;
|
|
const PREFETCH_CHUNKS = 1;
|
|
const CHUNK_DEBOUNCE_MS = 130;
|
|
|
|
const initialState = {
|
|
items: null,
|
|
total: 0,
|
|
unfilteredTotal: 0,
|
|
filter: '',
|
|
onlyUnbooked: false,
|
|
supplierId: null,
|
|
seekMonths: 0,
|
|
seekYears: 0,
|
|
negativeSeekMonths: 0,
|
|
status: 'idle',
|
|
error: null,
|
|
};
|
|
|
|
let automat;
|
|
let queryEpoch = 0;
|
|
let filterDebounceTimer = null;
|
|
let chunkDebounceTimer = null;
|
|
let currentEventTick = 0;
|
|
let lastRequireChunkTick = -1;
|
|
|
|
const pendingTargetChunks = new Set();
|
|
let pendingChunkPromise = null;
|
|
let pendingChunkResolve = null;
|
|
let pendingChunkReject = null;
|
|
|
|
// Multi-Filter Cache & Global LRU Management
|
|
const filterCaches = new Map();
|
|
const lruChunks = new Map();
|
|
const inflightChunks = new Map();
|
|
|
|
// Dev / Observability: Chunk event history and subscriber registry
|
|
const MAX_CHUNK_EVENTS = 150;
|
|
let nextEventId = 0;
|
|
const chunkEvents = [];
|
|
const chunkStatsListeners = new Set();
|
|
|
|
export function makeLruKey(filterKey, chunkIndex) {
|
|
return `${filterKey}:::${chunkIndex}`;
|
|
}
|
|
|
|
export function parseLruKey(key) {
|
|
const [filterKey, chunkStr] = key.split(':::');
|
|
return { filterKey, chunkIndex: Number(chunkStr) };
|
|
}
|
|
|
|
// MARK: pure filter helpers
|
|
export function getFilterParams(state = automat?.state || initialState) {
|
|
const filter = String(state.filter ?? '').trim();
|
|
const onlyUnbooked = Boolean(state.onlyUnbooked);
|
|
const supplierId = state.supplierId != null && state.supplierId !== '' ? Number(state.supplierId) : null;
|
|
const negativeSeekMonths = (state.negativeSeekMonths != null && Number(state.negativeSeekMonths) < 0)
|
|
? Number(state.negativeSeekMonths)
|
|
: 0;
|
|
return { filter, onlyUnbooked, supplierId, negativeSeekMonths };
|
|
}
|
|
|
|
export function getFilterKey(state = automat?.state || initialState) {
|
|
const { filter, onlyUnbooked, supplierId, negativeSeekMonths } = getFilterParams(state);
|
|
return JSON.stringify({ f: filter, u: onlyUnbooked, s: supplierId, m: negativeSeekMonths });
|
|
}
|
|
|
|
export function formatFilterLabel(filterKeyOrState) {
|
|
let f, u, s, m;
|
|
if (typeof filterKeyOrState === 'string') {
|
|
try {
|
|
const parsed = JSON.parse(filterKeyOrState);
|
|
f = parsed.f;
|
|
u = parsed.u;
|
|
s = parsed.s;
|
|
m = parsed.m;
|
|
} catch {
|
|
return filterKeyOrState;
|
|
}
|
|
} else if (filterKeyOrState && typeof filterKeyOrState === 'object') {
|
|
if ('f' in filterKeyOrState) {
|
|
f = filterKeyOrState.f;
|
|
u = filterKeyOrState.u;
|
|
s = filterKeyOrState.s;
|
|
m = filterKeyOrState.m;
|
|
} else {
|
|
const params = getFilterParams(filterKeyOrState);
|
|
f = params.filter;
|
|
u = params.onlyUnbooked;
|
|
s = params.supplierId;
|
|
m = params.negativeSeekMonths;
|
|
}
|
|
}
|
|
|
|
const parts = [];
|
|
if (f) parts.push(`Suche: „${f}“`);
|
|
if (u) parts.push('Nur ungebucht');
|
|
if (s) parts.push(`Lieferant #${s}`);
|
|
if (m < 0) parts.push(`Seek: ${formatNegativeSeek(m)}`);
|
|
if (parts.length === 0) return 'Standard (Alle Lieferungen)';
|
|
return parts.join(' · ');
|
|
}
|
|
|
|
function countNonNullItems(items) {
|
|
if (!Array.isArray(items)) return 0;
|
|
let count = 0;
|
|
for (let i = 0; i < items.length; i++) {
|
|
if (items[i] != null) count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
function getOrCreateFilterCache(filterKey, filterState = automat?.state || initialState) {
|
|
let entry = filterCaches.get(filterKey);
|
|
if (!entry) {
|
|
const params = getFilterParams(filterState);
|
|
entry = {
|
|
key: filterKey,
|
|
label: formatFilterLabel(params),
|
|
params,
|
|
total: 0,
|
|
unfilteredTotal: automat?.state?.unfilteredTotal || 0,
|
|
items: null,
|
|
loadedChunks: new Set(),
|
|
status: 'idle',
|
|
error: null,
|
|
lastAccessed: Date.now(),
|
|
epoch: queryEpoch,
|
|
};
|
|
filterCaches.set(filterKey, entry);
|
|
}
|
|
return entry;
|
|
}
|
|
|
|
// Touch an existing chunk in the global LRU cache to mark it as Most Recently Used
|
|
function touchChunkLRU(filterKey, chunkIndex) {
|
|
const key = makeLruKey(filterKey, chunkIndex);
|
|
const existing = lruChunks.get(key);
|
|
if (existing) {
|
|
lruChunks.delete(key);
|
|
lruChunks.set(key, { ...existing, accessedAt: Date.now() });
|
|
}
|
|
}
|
|
|
|
// Register a newly loaded chunk into the LRU cache and evict the oldest if limit exceeded
|
|
function registerChunkLRU(filterKey, chunkIndex, deliveryCount = 0) {
|
|
const key = makeLruKey(filterKey, chunkIndex);
|
|
if (lruChunks.has(key)) {
|
|
lruChunks.delete(key);
|
|
}
|
|
const now = Date.now();
|
|
lruChunks.set(key, {
|
|
filterKey,
|
|
chunkIndex,
|
|
loadedAt: now,
|
|
accessedAt: now,
|
|
deliveryCount,
|
|
});
|
|
|
|
// Enforce global MAX_LRU_CHUNKS limit across all filter caches
|
|
while (lruChunks.size > MAX_LRU_CHUNKS) {
|
|
const oldestKey = lruChunks.keys().next().value;
|
|
const oldestInfo = lruChunks.get(oldestKey);
|
|
lruChunks.delete(oldestKey);
|
|
if (oldestInfo) {
|
|
evictChunkFromMemory(oldestInfo.filterKey, oldestInfo.chunkIndex, 'lru');
|
|
}
|
|
}
|
|
}
|
|
|
|
// Evicts a chunk from memory: sets items back to null in the filter cache and removes from loadedChunks
|
|
function evictChunkFromMemory(filterKey, chunkIndex, reason = 'manual') {
|
|
const entry = filterCaches.get(filterKey);
|
|
if (!entry) return;
|
|
|
|
if (entry.loadedChunks.has(chunkIndex)) {
|
|
entry.loadedChunks.delete(chunkIndex);
|
|
if (Array.isArray(entry.items)) {
|
|
const offset = chunkIndex * CHUNK_SIZE;
|
|
for (let i = offset; i < offset + CHUNK_SIZE && i < entry.items.length; i++) {
|
|
entry.items[i] = null;
|
|
}
|
|
}
|
|
|
|
const currentKey = getFilterKey(automat.state);
|
|
if (filterKey === currentKey) {
|
|
automat.setState({ items: [...entry.items] });
|
|
}
|
|
|
|
const eventType = reason === 'lru' ? 'lru_evict' : 'evict';
|
|
const msg = reason === 'lru'
|
|
? `LRU-Eviction: Chunk #${chunkIndex} von Filter "${entry.label}" verworfen (${lruChunks.size}/${MAX_LRU_CHUNKS} im Cache)`
|
|
: `Chunk #${chunkIndex} von Filter "${entry.label}" verworfen`;
|
|
|
|
recordChunkEvent({
|
|
type: eventType,
|
|
chunkIndex,
|
|
filterKey,
|
|
message: msg,
|
|
});
|
|
notifyChunkStats();
|
|
}
|
|
}
|
|
|
|
function recordChunkEvent(entry) {
|
|
const event = {
|
|
id: ++nextEventId,
|
|
time: Date.now(),
|
|
epoch: queryEpoch,
|
|
filterKey: entry.filterKey ?? getFilterKey(automat?.state),
|
|
...entry,
|
|
};
|
|
chunkEvents.push(event);
|
|
if (chunkEvents.length > MAX_CHUNK_EVENTS) {
|
|
chunkEvents.shift();
|
|
}
|
|
notifyChunkStats();
|
|
}
|
|
|
|
function notifyChunkStats() {
|
|
if (chunkStatsListeners.size === 0) return;
|
|
const stats = getChunkStats();
|
|
for (const listener of chunkStatsListeners) {
|
|
try {
|
|
listener(stats);
|
|
} catch (e) {
|
|
console.error('[deliveryAutomat] chunkStatsListener error', e);
|
|
}
|
|
}
|
|
}
|
|
|
|
export function getChunkStats() {
|
|
const currentKey = getFilterKey(automat?.state);
|
|
const activeEntry = filterCaches.get(currentKey);
|
|
|
|
const total = activeEntry?.total ?? automat?.state?.total ?? 0;
|
|
const activeLoaded = activeEntry?.loadedChunks ?? new Set();
|
|
const chunkCount = total > 0 ? Math.ceil(total / CHUNK_SIZE) : (activeLoaded.size > 0 ? Math.max(...activeLoaded) + 1 : 0);
|
|
const items = activeEntry?.items ?? automat?.state?.items;
|
|
const loadedItemsCount = countNonNullItems(items);
|
|
|
|
// Summarize all cached filter combinations
|
|
const cachedFiltersSummary = Array.from(filterCaches.values()).map((entry) => ({
|
|
key: entry.key,
|
|
label: entry.label,
|
|
params: entry.params,
|
|
total: entry.total,
|
|
loadedChunksCount: entry.loadedChunks.size,
|
|
loadedChunks: Array.from(entry.loadedChunks).sort((a, b) => a - b),
|
|
chunkCount: entry.total > 0 ? Math.ceil(entry.total / CHUNK_SIZE) : (entry.loadedChunks.size > 0 ? Math.max(...entry.loadedChunks) + 1 : 0),
|
|
loadedItemsCount: countNonNullItems(entry.items),
|
|
lastAccessed: entry.lastAccessed,
|
|
isActive: entry.key === currentKey,
|
|
status: entry.status,
|
|
items: entry.items,
|
|
}));
|
|
|
|
// LRU queue list from oldest (1) to newest (50)
|
|
const lruEntries = Array.from(lruChunks.entries()).map(([key, info], idx) => ({
|
|
lruKey: key,
|
|
filterKey: info.filterKey,
|
|
filterLabel: filterCaches.get(info.filterKey)?.label || info.filterKey,
|
|
chunkIndex: info.chunkIndex,
|
|
loadedAt: info.loadedAt,
|
|
accessedAt: info.accessedAt,
|
|
deliveryCount: info.deliveryCount,
|
|
lruRank: idx + 1,
|
|
}));
|
|
|
|
// Active filter's inflight chunks
|
|
const activeInflight = [];
|
|
for (const key of inflightChunks.keys()) {
|
|
if (key.startsWith(`${currentKey}:::`)) {
|
|
const parsed = parseLruKey(key);
|
|
activeInflight.push(parsed.chunkIndex);
|
|
}
|
|
}
|
|
|
|
return {
|
|
automatName: 'delivery',
|
|
chunkSize: CHUNK_SIZE,
|
|
maxLruChunks: MAX_LRU_CHUNKS,
|
|
lruChunksCount: lruChunks.size,
|
|
total,
|
|
chunkCount,
|
|
loadedChunks: Array.from(activeLoaded).sort((a, b) => a - b),
|
|
inflightChunks: activeInflight.sort((a, b) => a - b),
|
|
pendingChunks: Array.from(pendingTargetChunks).sort((a, b) => a - b),
|
|
loadedItemsCount,
|
|
status: automat?.state?.status ?? 'idle',
|
|
queryEpoch,
|
|
filter: automat?.state?.filter ?? '',
|
|
onlyUnbooked: automat?.state?.onlyUnbooked ?? false,
|
|
supplierId: automat?.state?.supplierId ?? null,
|
|
negativeSeekMonths: automat?.state?.negativeSeekMonths ?? 0,
|
|
items,
|
|
activeFilterKey: currentKey,
|
|
activeFilterLabel: formatFilterLabel(currentKey),
|
|
filterCaches: cachedFiltersSummary,
|
|
lruEntries,
|
|
events: [...chunkEvents],
|
|
};
|
|
}
|
|
|
|
export function subscribeChunkStats(listener) {
|
|
chunkStatsListeners.add(listener);
|
|
try {
|
|
listener(getChunkStats());
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
return () => {
|
|
chunkStatsListeners.delete(listener);
|
|
};
|
|
}
|
|
|
|
// Clears pending debounced chunk requests
|
|
function clearChunkDebounce() {
|
|
if (chunkDebounceTimer) {
|
|
clearTimeout(chunkDebounceTimer);
|
|
chunkDebounceTimer = null;
|
|
}
|
|
if (pendingTargetChunks.size > 0) {
|
|
pendingTargetChunks.clear();
|
|
notifyChunkStats();
|
|
}
|
|
pendingChunkPromise = null;
|
|
pendingChunkResolve = null;
|
|
pendingChunkReject = null;
|
|
}
|
|
|
|
// Executes chunk loading for the standstill target and prefetches lookahead chunks
|
|
function _executeRequiredChunks(chunks, targetEpoch, prefetch = true, targetFilterKey = getFilterKey(automat.state)) {
|
|
if (targetEpoch !== queryEpoch) {
|
|
return Promise.resolve(automat.state.items);
|
|
}
|
|
|
|
const chunkList = Array.from(chunks).sort((a, b) => a - b);
|
|
if (chunkList.length === 0) {
|
|
return Promise.resolve(automat.state.items);
|
|
}
|
|
|
|
recordChunkEvent({
|
|
type: 'execute',
|
|
chunks: chunkList,
|
|
filterKey: targetFilterKey,
|
|
message: `Lade Chunks [${chunkList.join(', ')}] für "${formatFilterLabel(targetFilterKey)}" (Epoch ${targetEpoch})`,
|
|
});
|
|
|
|
const promises = [];
|
|
for (const c of chunkList) {
|
|
promises.push(actions.loadChunk(c, targetEpoch, targetFilterKey));
|
|
}
|
|
|
|
return Promise.all(promises).then(() => {
|
|
if (targetEpoch !== queryEpoch) return automat.state.items;
|
|
if (prefetch) {
|
|
const maxChunk = chunkList[chunkList.length - 1];
|
|
const entry = filterCaches.get(targetFilterKey);
|
|
const total = entry?.total || automat.state.total || 0;
|
|
for (let c = maxChunk + 1; c <= maxChunk + PREFETCH_CHUNKS; c++) {
|
|
if (total > 0 && c * CHUNK_SIZE >= total) {
|
|
break;
|
|
}
|
|
recordChunkEvent({
|
|
type: 'prefetch',
|
|
chunkIndex: c,
|
|
filterKey: targetFilterKey,
|
|
message: `Prefetch Chunk #${c} für "${formatFilterLabel(targetFilterKey)}"`,
|
|
});
|
|
void actions.loadChunk(c, targetEpoch, targetFilterKey);
|
|
}
|
|
}
|
|
return automat.state.items;
|
|
});
|
|
}
|
|
|
|
// MARK: pure delivery helpers
|
|
export function isDeliveryBooked(delivery) {
|
|
if (!delivery) return false;
|
|
const ledger = delivery.ledger;
|
|
if (!ledger) return false;
|
|
if (ledger.isBooked !== undefined) return Boolean(ledger.isBooked);
|
|
const total = Number(ledger.totalPositions ?? ledger.total ?? delivery.positions ?? 0);
|
|
const booked = Number(ledger.completelyOnLedgerPositions ?? ledger.bookedPositions ?? 0);
|
|
return total > 0 && booked >= total;
|
|
}
|
|
|
|
export function getDeliveryUnbookedCount(delivery) {
|
|
if (!delivery) return 0;
|
|
const ledger = delivery.ledger;
|
|
if (!ledger) return 0;
|
|
if (ledger.unbookedPositions !== undefined) return Number(ledger.unbookedPositions);
|
|
const total = Number(ledger.totalPositions ?? ledger.total ?? delivery.positions ?? 0);
|
|
const booked = Number(ledger.completelyOnLedgerPositions ?? ledger.bookedPositions ?? 0);
|
|
return Math.max(0, total - booked);
|
|
}
|
|
|
|
export function formatNegativeSeek(months) {
|
|
if (!months || months >= 0) return '';
|
|
const total = Math.abs(months);
|
|
const years = Math.floor(total / 12);
|
|
const remMonths = total % 12;
|
|
const parts = [];
|
|
if (years > 0) {
|
|
parts.push(`${years} ${years === 1 ? 'Jahr' : 'Jahre'}`);
|
|
}
|
|
if (remMonths > 0) {
|
|
parts.push(`${remMonths} ${remMonths === 1 ? 'Monat' : 'Monate'}`);
|
|
}
|
|
return `-${parts.join(' ')}`;
|
|
}
|
|
|
|
// Builds server query parameters from filter params
|
|
function buildQueryParamsFor(filterParams, offset = 0, limit = CHUNK_SIZE) {
|
|
const params = { offset, limit };
|
|
const trimmed = String(filterParams.filter ?? '').trim();
|
|
if (trimmed) params.search = trimmed;
|
|
if (filterParams.onlyUnbooked) params.onlyUnbooked = true;
|
|
if (filterParams.supplierId != null) params.supplierId = filterParams.supplierId;
|
|
if (filterParams.negativeSeekMonths != null && Number(filterParams.negativeSeekMonths) < 0) {
|
|
params.seekMonths = Number(filterParams.negativeSeekMonths);
|
|
}
|
|
return params;
|
|
}
|
|
|
|
// Fetches a single chunk from GET /api/delivery with server-side filters
|
|
async function fetchDeliveriesPageFor(filterParams, offset = 0, limit = CHUNK_SIZE) {
|
|
const params = buildQueryParamsFor(filterParams, offset, limit);
|
|
const res = await deliveryApi.list(params);
|
|
const deliveries = Array.isArray(res?.deliveries) ? res.deliveries : (Array.isArray(res) ? res : []);
|
|
const total = Number(res?.total ?? deliveries.length);
|
|
const unfilteredTotal = res?.unfilteredTotal != null ? Number(res.unfilteredTotal) : total;
|
|
return { deliveries, total, unfilteredTotal };
|
|
}
|
|
|
|
function onFilterChange(immediate = false) {
|
|
if (filterDebounceTimer) {
|
|
clearTimeout(filterDebounceTimer);
|
|
filterDebounceTimer = null;
|
|
}
|
|
if (immediate) {
|
|
applyFilterReload();
|
|
} else {
|
|
filterDebounceTimer = setTimeout(() => {
|
|
filterDebounceTimer = null;
|
|
applyFilterReload();
|
|
}, 200);
|
|
}
|
|
}
|
|
|
|
// Invoked when active filters change: switches to the matching filter cache without wiping!
|
|
function applyFilterReload() {
|
|
queryEpoch++;
|
|
clearChunkDebounce();
|
|
|
|
const currentKey = getFilterKey(automat.state);
|
|
const cached = filterCaches.get(currentKey);
|
|
|
|
if (cached && cached.items !== null) {
|
|
cached.lastAccessed = Date.now();
|
|
for (const c of cached.loadedChunks) {
|
|
touchChunkLRU(currentKey, c);
|
|
}
|
|
|
|
automat.setState({
|
|
items: cached.items,
|
|
total: cached.total,
|
|
unfilteredTotal: cached.unfilteredTotal ?? automat.state.unfilteredTotal ?? 0,
|
|
status: cached.status || 'ready',
|
|
error: cached.error || null,
|
|
});
|
|
|
|
recordChunkEvent({
|
|
type: 'filter_hit',
|
|
epoch: queryEpoch,
|
|
filterKey: currentKey,
|
|
message: `Filter gewechselt: "${cached.label}" (Cache-Hit: ${cached.loadedChunks.size} Chunks / ${countNonNullItems(cached.items)} Lieferungen im RAM)`,
|
|
});
|
|
notifyChunkStats();
|
|
|
|
if (!cached.loadedChunks.has(0)) {
|
|
void actions.loadChunk(0, queryEpoch, currentKey);
|
|
}
|
|
} else {
|
|
const entry = getOrCreateFilterCache(currentKey, automat.state);
|
|
entry.lastAccessed = Date.now();
|
|
|
|
automat.setState({
|
|
items: null,
|
|
total: 0,
|
|
unfilteredTotal: automat.state.unfilteredTotal ?? 0,
|
|
status: 'loading',
|
|
error: null,
|
|
});
|
|
|
|
recordChunkEvent({
|
|
type: 'filter_miss',
|
|
epoch: queryEpoch,
|
|
filterKey: currentKey,
|
|
message: `Filter gewechselt: "${entry.label}" (Cache-Miss: Lade Chunk #0)`,
|
|
});
|
|
notifyChunkStats();
|
|
|
|
void actions.loadChunk(0, queryEpoch, currentKey);
|
|
}
|
|
}
|
|
|
|
const actions = {
|
|
// MARK: returns current items and triggers chunk 0 if not loaded
|
|
getItems() {
|
|
if (automat.state.items === null) {
|
|
void actions.requireChunk(0, 0, { prefetch: false, immediate: true });
|
|
return null;
|
|
}
|
|
return automat.state.items;
|
|
},
|
|
|
|
// MARK: ensures chunkIndex and lookahead chunks are loaded/loading (debounced)
|
|
requireChunk(chunkIndex, endOrOptions = chunkIndex, maybeOptions = {}) {
|
|
let start;
|
|
let end;
|
|
let options = {};
|
|
|
|
if (Array.isArray(chunkIndex)) {
|
|
start = chunkIndex[0] ?? 0;
|
|
end = chunkIndex[chunkIndex.length - 1] ?? start;
|
|
if (typeof endOrOptions === 'object' && endOrOptions !== null) {
|
|
options = endOrOptions;
|
|
}
|
|
} else {
|
|
start = Number(chunkIndex) || 0;
|
|
if (typeof endOrOptions === 'object' && endOrOptions !== null) {
|
|
end = start;
|
|
options = endOrOptions;
|
|
} else {
|
|
end = Number(endOrOptions ?? start) || start;
|
|
if (typeof maybeOptions === 'object' && maybeOptions !== null) {
|
|
options = maybeOptions;
|
|
}
|
|
}
|
|
}
|
|
|
|
start = Math.max(0, Math.floor(start));
|
|
end = Math.max(start, Math.floor(end));
|
|
const prefetch = options.prefetch !== false;
|
|
const currentKey = getFilterKey(automat.state);
|
|
|
|
if (options.immediate || automat.state.items === null) {
|
|
clearChunkDebounce();
|
|
const chunks = new Set();
|
|
for (let c = start; c <= end; c++) chunks.add(c);
|
|
recordChunkEvent({
|
|
type: 'require_immediate',
|
|
chunks: Array.from(chunks),
|
|
filterKey: currentKey,
|
|
message: `Sofortige Anforderung: Chunks ${start}..${end} (${formatFilterLabel(currentKey)})`,
|
|
});
|
|
return _executeRequiredChunks(chunks, queryEpoch, prefetch, currentKey);
|
|
}
|
|
|
|
if (lastRequireChunkTick !== currentEventTick) {
|
|
pendingTargetChunks.clear();
|
|
lastRequireChunkTick = currentEventTick;
|
|
if (typeof queueMicrotask === 'function') {
|
|
queueMicrotask(() => {
|
|
currentEventTick++;
|
|
});
|
|
} else {
|
|
Promise.resolve().then(() => {
|
|
currentEventTick++;
|
|
});
|
|
}
|
|
}
|
|
|
|
for (let c = start; c <= end; c++) {
|
|
pendingTargetChunks.add(c);
|
|
}
|
|
recordChunkEvent({
|
|
type: 'pending',
|
|
chunks: Array.from(pendingTargetChunks),
|
|
filterKey: currentKey,
|
|
message: `Debounce vorgemerkt (${CHUNK_DEBOUNCE_MS}ms): Chunks [${Array.from(pendingTargetChunks).join(', ')}]`,
|
|
});
|
|
notifyChunkStats();
|
|
|
|
if (chunkDebounceTimer) {
|
|
clearTimeout(chunkDebounceTimer);
|
|
chunkDebounceTimer = null;
|
|
}
|
|
|
|
if (!pendingChunkPromise) {
|
|
pendingChunkPromise = new Promise((resolve, reject) => {
|
|
pendingChunkResolve = resolve;
|
|
pendingChunkReject = reject;
|
|
});
|
|
}
|
|
|
|
const captureEpoch = queryEpoch;
|
|
chunkDebounceTimer = setTimeout(() => {
|
|
chunkDebounceTimer = null;
|
|
const chunksToLoad = new Set(pendingTargetChunks);
|
|
pendingTargetChunks.clear();
|
|
notifyChunkStats();
|
|
|
|
const resolve = pendingChunkResolve;
|
|
const reject = pendingChunkReject;
|
|
pendingChunkPromise = null;
|
|
pendingChunkResolve = null;
|
|
pendingChunkReject = null;
|
|
|
|
recordChunkEvent({
|
|
type: 'debounce_fire',
|
|
chunks: Array.from(chunksToLoad),
|
|
filterKey: currentKey,
|
|
message: `Debounce abgelaufen: Starte Chunks [${Array.from(chunksToLoad).join(', ')}]`,
|
|
});
|
|
|
|
_executeRequiredChunks(chunksToLoad, captureEpoch, true, currentKey)
|
|
.then((res) => resolve?.(res))
|
|
.catch((err) => reject?.(err));
|
|
}, CHUNK_DEBOUNCE_MS);
|
|
|
|
return pendingChunkPromise;
|
|
},
|
|
|
|
// MARK: fetches a single chunk and populates the filter cache and prefilled array
|
|
loadChunk(chunkIndex, targetEpoch = queryEpoch, targetFilterKey = getFilterKey(automat.state)) {
|
|
const index = Math.max(0, Number(chunkIndex) || 0);
|
|
const entry = getOrCreateFilterCache(targetFilterKey, automat.state);
|
|
|
|
if (targetEpoch !== queryEpoch && targetFilterKey !== getFilterKey(automat.state)) {
|
|
return Promise.resolve(entry.items);
|
|
}
|
|
|
|
if (entry.loadedChunks.has(index)) {
|
|
touchChunkLRU(targetFilterKey, index);
|
|
recordChunkEvent({
|
|
type: 'hit',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
message: `Cache-Hit: Chunk #${index} für Filter "${entry.label}" bereits im Speicher`,
|
|
});
|
|
return Promise.resolve(targetFilterKey === getFilterKey(automat.state) ? automat.state.items : entry.items);
|
|
}
|
|
|
|
const inflightKey = makeLruKey(targetFilterKey, index);
|
|
if (inflightChunks.has(inflightKey)) {
|
|
recordChunkEvent({
|
|
type: 'inflight_hit',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
message: `Inflight-Hit: Chunk #${index} für Filter "${entry.label}" lädt bereits`,
|
|
});
|
|
return inflightChunks.get(inflightKey);
|
|
}
|
|
|
|
const offset = index * CHUNK_SIZE;
|
|
const limit = CHUNK_SIZE;
|
|
const isActiveFilter = targetFilterKey === getFilterKey(automat.state);
|
|
|
|
if (index === 0 && (entry.items === null || (isActiveFilter && automat.state.items === null))) {
|
|
entry.status = 'loading';
|
|
entry.error = null;
|
|
if (isActiveFilter) {
|
|
automat.setState({ status: 'loading', error: null });
|
|
}
|
|
}
|
|
|
|
const startTime = Date.now();
|
|
recordChunkEvent({
|
|
type: 'start',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
message: `Netzwerk-Request: Lade Chunk #${index} (Offset ${offset}..${offset + limit - 1}) für "${entry.label}"`,
|
|
});
|
|
|
|
const filterParams = entry.params || getFilterParams(automat.state);
|
|
const promise = fetchDeliveriesPageFor(filterParams, offset, limit)
|
|
.then(({ deliveries, total, unfilteredTotal }) => {
|
|
const currentTotal = total > 0 ? total : 0;
|
|
entry.total = currentTotal;
|
|
entry.unfilteredTotal = unfilteredTotal;
|
|
|
|
if (entry.items === null || entry.items.length !== currentTotal) {
|
|
entry.items = new Array(currentTotal).fill(null);
|
|
} else {
|
|
entry.items = [...entry.items];
|
|
}
|
|
|
|
for (let i = 0; i < deliveries.length; i++) {
|
|
const idx = offset + i;
|
|
if (idx < entry.items.length) {
|
|
entry.items[idx] = deliveries[i];
|
|
}
|
|
}
|
|
|
|
entry.loadedChunks.add(index);
|
|
entry.status = 'ready';
|
|
entry.error = null;
|
|
entry.lastAccessed = Date.now();
|
|
|
|
registerChunkLRU(targetFilterKey, index, deliveries.length);
|
|
|
|
const currentActive = targetFilterKey === getFilterKey(automat.state);
|
|
if (currentActive) {
|
|
automat.setState({
|
|
items: [...entry.items],
|
|
total: currentTotal,
|
|
unfilteredTotal,
|
|
status: 'ready',
|
|
error: null,
|
|
});
|
|
}
|
|
|
|
const duration = Date.now() - startTime;
|
|
recordChunkEvent({
|
|
type: 'loaded',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
count: deliveries.length,
|
|
duration,
|
|
message: `Chunk #${index} geladen (${deliveries.length} Lieferungen in ${duration}ms) für "${entry.label}"`,
|
|
});
|
|
|
|
return currentActive ? automat.state.items : entry.items;
|
|
})
|
|
.catch((err) => {
|
|
entry.status = 'failed';
|
|
entry.error = err;
|
|
const currentActive = targetFilterKey === getFilterKey(automat.state);
|
|
if (currentActive) {
|
|
if (index === 0 && automat.state.items === null) {
|
|
automat.setState({ status: 'failed', error: err });
|
|
}
|
|
}
|
|
const duration = Date.now() - startTime;
|
|
console.error(`[deliveryAutomat] loadChunk(${index}, ${targetFilterKey}) error:`, err);
|
|
recordChunkEvent({
|
|
type: 'error',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
duration,
|
|
error: err?.message || String(err),
|
|
message: `Fehler bei Chunk #${index} ("${entry.label}"): ${err?.message || err}`,
|
|
});
|
|
throw err;
|
|
})
|
|
.finally(() => {
|
|
inflightChunks.delete(inflightKey);
|
|
notifyChunkStats();
|
|
});
|
|
|
|
inflightChunks.set(inflightKey, promise);
|
|
notifyChunkStats();
|
|
return promise;
|
|
},
|
|
|
|
// MARK: server-side filter actions
|
|
filter(query) {
|
|
automat.setState({ filter: String(query ?? '') });
|
|
onFilterChange(false);
|
|
},
|
|
|
|
setOnlyUnbooked(onlyUnbooked) {
|
|
automat.setState({ onlyUnbooked: Boolean(onlyUnbooked) });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
setSupplierId(supplierId) {
|
|
const parsed = supplierId != null && supplierId !== '' ? Number(supplierId) : null;
|
|
automat.setState({ supplierId: parsed });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
addSeekMonth() {
|
|
const seekMonths = (automat.state.seekMonths ?? 0) + 1;
|
|
const seekYears = automat.state.seekYears ?? 0;
|
|
const totalMonths = -(seekMonths + seekYears * 12);
|
|
automat.setState({ seekMonths, negativeSeekMonths: totalMonths });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
addSeekYear() {
|
|
const seekMonths = automat.state.seekMonths ?? 0;
|
|
const seekYears = (automat.state.seekYears ?? 0) + 1;
|
|
const totalMonths = -(seekMonths + seekYears * 12);
|
|
automat.setState({ seekYears, negativeSeekMonths: totalMonths });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
addNegativeSeek(months) {
|
|
if (months === -12) {
|
|
actions.addSeekYear();
|
|
} else if (months === -1) {
|
|
actions.addSeekMonth();
|
|
} else {
|
|
const current = Math.min(0, Number(automat.state.negativeSeekMonths ?? 0));
|
|
const next = current + months;
|
|
automat.setState({ negativeSeekMonths: Math.min(0, next) });
|
|
onFilterChange(true);
|
|
}
|
|
},
|
|
|
|
resetNegativeSeek() {
|
|
automat.setState({ seekMonths: 0, seekYears: 0, negativeSeekMonths: 0 });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
resetFilters() {
|
|
automat.setState({
|
|
filter: '',
|
|
onlyUnbooked: false,
|
|
supplierId: null,
|
|
seekMonths: 0,
|
|
seekYears: 0,
|
|
negativeSeekMonths: 0,
|
|
});
|
|
onFilterChange(true);
|
|
},
|
|
|
|
// MARK: initial load
|
|
load() {
|
|
return actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
|
|
},
|
|
|
|
// MARK: ensure loaded
|
|
ensureLoaded() {
|
|
if (automat.state.items !== null) {
|
|
return Promise.resolve(automat.state.items);
|
|
}
|
|
return actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
|
|
},
|
|
|
|
// MARK: reload active filter or invalidate all
|
|
async reload(onlyCurrent = false) {
|
|
queryEpoch++;
|
|
clearChunkDebounce();
|
|
|
|
if (onlyCurrent) {
|
|
const currentKey = getFilterKey(automat.state);
|
|
actions.clearFilterCache(currentKey);
|
|
} else {
|
|
actions.clearCache();
|
|
}
|
|
|
|
await actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
|
|
return automat.state.items;
|
|
},
|
|
|
|
// MARK: replace items directly
|
|
replace(items) {
|
|
clearChunkDebounce();
|
|
const currentKey = getFilterKey(automat.state);
|
|
actions.clearFilterCache(currentKey);
|
|
|
|
const count = Array.isArray(items) ? items.length : 0;
|
|
const entry = getOrCreateFilterCache(currentKey, automat.state);
|
|
entry.items = items;
|
|
entry.total = count;
|
|
entry.status = 'ready';
|
|
entry.error = null;
|
|
|
|
recordChunkEvent({
|
|
type: 'replace',
|
|
filterKey: currentKey,
|
|
message: `Items ersetzt (${count} Einträge)`,
|
|
});
|
|
notifyChunkStats();
|
|
automat.setState({
|
|
items,
|
|
total: count,
|
|
status: 'ready',
|
|
error: null,
|
|
});
|
|
return items;
|
|
},
|
|
|
|
// MARK: evicts a specific chunk from cache
|
|
evictChunk(chunkIndex, filterKey = getFilterKey(automat.state)) {
|
|
const index = Math.max(0, Number(chunkIndex) || 0);
|
|
const key = makeLruKey(filterKey, index);
|
|
if (lruChunks.has(key)) {
|
|
lruChunks.delete(key);
|
|
}
|
|
evictChunkFromMemory(filterKey, index, 'manual');
|
|
return automat.state.items;
|
|
},
|
|
|
|
// MARK: clears a specific filter cache and removes its chunks from LRU
|
|
clearFilterCache(filterKey = getFilterKey(automat.state)) {
|
|
for (const [lruKey, info] of Array.from(lruChunks.entries())) {
|
|
if (info.filterKey === filterKey) {
|
|
lruChunks.delete(lruKey);
|
|
}
|
|
}
|
|
|
|
const entry = filterCaches.get(filterKey);
|
|
if (entry) {
|
|
entry.loadedChunks.clear();
|
|
entry.items = null;
|
|
entry.total = 0;
|
|
entry.status = 'idle';
|
|
entry.error = null;
|
|
}
|
|
|
|
if (filterKey === getFilterKey(automat.state)) {
|
|
automat.setState({
|
|
items: null,
|
|
total: 0,
|
|
status: 'idle',
|
|
error: null,
|
|
});
|
|
}
|
|
|
|
recordChunkEvent({
|
|
type: 'clear_filter',
|
|
filterKey,
|
|
message: `Filter-Cache für "${formatFilterLabel(filterKey)}" geleert`,
|
|
});
|
|
notifyChunkStats();
|
|
return automat.state.items;
|
|
},
|
|
|
|
// MARK: clears all loaded chunks and filter caches from RAM
|
|
clearCache() {
|
|
clearChunkDebounce();
|
|
lruChunks.clear();
|
|
inflightChunks.clear();
|
|
|
|
for (const entry of filterCaches.values()) {
|
|
entry.loadedChunks.clear();
|
|
entry.items = null;
|
|
entry.total = 0;
|
|
entry.status = 'idle';
|
|
entry.error = null;
|
|
}
|
|
|
|
automat.setState({
|
|
items: null,
|
|
total: 0,
|
|
status: 'idle',
|
|
error: null,
|
|
});
|
|
|
|
recordChunkEvent({
|
|
type: 'clear',
|
|
message: 'Gesamter LRU-Cache und alle Filter-Caches geleert',
|
|
});
|
|
notifyChunkStats();
|
|
return automat.state.items;
|
|
},
|
|
|
|
// MARK: prefetches all remaining chunks for a filter (bounded by MAX_LRU_CHUNKS)
|
|
prefetchAllChunks(filterKey = getFilterKey(automat.state)) {
|
|
const entry = getOrCreateFilterCache(filterKey, automat.state);
|
|
const total = entry.total || automat.state.total || 0;
|
|
const chunkCount = Math.ceil(total / CHUNK_SIZE);
|
|
|
|
recordChunkEvent({
|
|
type: 'prefetch_all',
|
|
filterKey,
|
|
message: `Starte Prefetch aller ${chunkCount} Chunks für "${entry.label}"`,
|
|
});
|
|
|
|
for (let c = 0; c < chunkCount; c++) {
|
|
const inflightKey = makeLruKey(filterKey, c);
|
|
if (!entry.loadedChunks.has(c) && !inflightChunks.has(inflightKey)) {
|
|
void actions.loadChunk(c, queryEpoch, filterKey);
|
|
}
|
|
}
|
|
notifyChunkStats();
|
|
},
|
|
|
|
// MARK: patches a delivery locally across all filter caches
|
|
patchDelivery(id, patch) {
|
|
let changed = false;
|
|
for (const entry of filterCaches.values()) {
|
|
if (Array.isArray(entry.items)) {
|
|
entry.items = entry.items.map((d) => {
|
|
if (d && d.id === id) {
|
|
changed = true;
|
|
return { ...d, ...patch };
|
|
}
|
|
return d;
|
|
});
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(automat.state.items)) {
|
|
const items = automat.state.items.map((d) => {
|
|
if (d && d.id === id) {
|
|
changed = true;
|
|
return { ...d, ...patch };
|
|
}
|
|
return d;
|
|
});
|
|
if (changed) {
|
|
automat.setState({ items });
|
|
}
|
|
}
|
|
return automat.state.items;
|
|
},
|
|
|
|
// MARK: resets state and all caches completely (e.g. on logout / company switch)
|
|
reset() {
|
|
queryEpoch++;
|
|
if (filterDebounceTimer) {
|
|
clearTimeout(filterDebounceTimer);
|
|
filterDebounceTimer = null;
|
|
}
|
|
clearChunkDebounce();
|
|
filterCaches.clear();
|
|
lruChunks.clear();
|
|
inflightChunks.clear();
|
|
|
|
recordChunkEvent({
|
|
type: 'reset',
|
|
message: 'Delivery-Automat und sämtliche Caches zurückgesetzt',
|
|
});
|
|
notifyChunkStats();
|
|
automat.setState(initialState);
|
|
},
|
|
};
|
|
|
|
export const deliveryAutomat = new Automat(initialState, actions, { name: 'delivery' });
|
|
automat = deliveryAutomat;
|
|
|
|
// MARK: exported methods for direct invocation
|
|
export function getItems() {
|
|
return actions.getItems();
|
|
}
|
|
|
|
export function requireChunk(chunkIndex, endOrOptions, maybeOptions) {
|
|
return actions.requireChunk(chunkIndex, endOrOptions, maybeOptions);
|
|
}
|
|
|
|
deliveryAutomat.getItems = getItems;
|
|
deliveryAutomat.requireChunk = requireChunk;
|
|
deliveryAutomat.CHUNK_SIZE = CHUNK_SIZE;
|
|
deliveryAutomat.MAX_LRU_CHUNKS = MAX_LRU_CHUNKS;
|
|
deliveryAutomat.getChunkStats = getChunkStats;
|
|
deliveryAutomat.subscribeChunkStats = subscribeChunkStats;
|
|
deliveryAutomat.evictChunk = actions.evictChunk;
|
|
deliveryAutomat.clearFilterCache = actions.clearFilterCache;
|
|
deliveryAutomat.clearCache = actions.clearCache;
|
|
deliveryAutomat.prefetchAllChunks = actions.prefetchAllChunks;
|
|
deliveryAutomat.getFilterKey = getFilterKey;
|
|
deliveryAutomat.formatFilterLabel = formatFilterLabel;
|
|
|
|
// Reset on logout or company change
|
|
let lastCompanyId = null;
|
|
authAutomat.subscribe((auth) => {
|
|
const companyId = auth.user?.selectedCompanyId ?? null;
|
|
if (auth.status === 'anon') {
|
|
actions.reset();
|
|
lastCompanyId = null;
|
|
return;
|
|
}
|
|
if (lastCompanyId !== null && companyId !== lastCompanyId) {
|
|
actions.reset();
|
|
}
|
|
if (auth.status === 'authed' && companyId != null) {
|
|
lastCompanyId = companyId;
|
|
}
|
|
});
|
|
|
|
/** Selects current deliveries */
|
|
export function selectDeliveries(state = automat.state) {
|
|
return state.items;
|
|
}
|
|
|
|
/** Selects total unpaged count */
|
|
export function selectDeliveryTotal(state = automat.state) {
|
|
return state.total;
|
|
}
|
|
|
|
/** Selects unfiltered total count */
|
|
export function selectDeliveryUnfilteredTotal(state = automat.state) {
|
|
return state.unfilteredTotal ?? 0;
|
|
}
|
|
|
|
/** Selects onlyUnbooked filter */
|
|
export function selectOnlyUnbooked(state = automat.state) {
|
|
return state.onlyUnbooked;
|
|
}
|
|
|
|
/** Selects negative seek offset in months */
|
|
export function selectNegativeSeekMonths(state = automat.state) {
|
|
return state.negativeSeekMonths;
|
|
}
|
|
|
|
/** Selects seek month count */
|
|
export function selectSeekMonths(state = automat.state) {
|
|
return state.seekMonths ?? 0;
|
|
}
|
|
|
|
/** Selects seek year count */
|
|
export function selectSeekYears(state = automat.state) {
|
|
return state.seekYears ?? 0;
|
|
}
|
|
|
|
/**
|
|
* Calculates client pagination metadata.
|
|
*/
|
|
export function selectDeliveryPagination(state = automat.state) {
|
|
const total = state.total ?? 0;
|
|
return {
|
|
total,
|
|
offset: 0,
|
|
limit: CHUNK_SIZE,
|
|
currentPage: 1,
|
|
pageCount: Math.max(1, Math.ceil(total / CHUNK_SIZE)),
|
|
};
|
|
}
|
|
|
|
export default deliveryAutomat;
|