1212 lines
37 KiB
JavaScript
1212 lines
37 KiB
JavaScript
/**
|
|
* @file orderAutomat.js
|
|
* @description Manages cached and chunk-paginated company sales orders (`GET /api/order`).
|
|
*
|
|
* Implements a multi-filter chunk cache:
|
|
* - Each filter combination has its own isolated cache entry (total, items array, loadedChunks).
|
|
* - Total chunk capacity across all filter combinations is bounded by a global LRU (Least Recently Used) 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.
|
|
* - UI / Routes: Calls `getItems()`, `requireChunk(chunkIndex)`, `loadChunk(chunkIndex)`, or `reload()`.
|
|
*/
|
|
|
|
import { Automat } from 'react-automat';
|
|
import { order as orderApi } from '../api';
|
|
import authAutomat from './authAutomat';
|
|
|
|
/**
|
|
* @typedef {Object} OrderLine
|
|
* @property {number} id
|
|
* @property {string|null} sku
|
|
* @property {string|null} name
|
|
* @property {number} pu
|
|
* @property {number} amount
|
|
* @property {number} net
|
|
* @property {number} rebate
|
|
* @property {number} taxrate
|
|
* @property {string|null} comment
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} Order
|
|
* @property {number} id Order id.
|
|
* @property {string} number Order number.
|
|
* @property {'order'} type Always `'order'`.
|
|
* @property {number|null} entityId Customer id.
|
|
* @property {string|null} externalNumber External reference.
|
|
* @property {string} date Delivery date (ISO).
|
|
* @property {string} createdAt Creation timestamp (ISO).
|
|
* @property {OrderLine[]} lines Order line items.
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} OrderAutomatState
|
|
* @property {Order[]|null} items Pre-filled array of orders/nulls, initially null.
|
|
* @property {number} total Total unpaged count for pagination calculation.
|
|
* @property {string} filter Search term.
|
|
* @property {boolean} onlyUnpaid Unpaid orders only.
|
|
* @property {boolean} onlyUndelivered Undelivered orders only.
|
|
* @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: '',
|
|
onlyUnpaid: false,
|
|
onlyUndelivered: false,
|
|
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
|
|
// filterCaches: Map<filterKey, FilterCacheEntry>
|
|
const filterCaches = new Map();
|
|
// lruChunks: Map<lruKey, { filterKey, chunkIndex, loadedAt, accessedAt, orderCount }>
|
|
// In JS, Map keys iteration preserves insertion order. Oldest (LRU) is lruChunks.keys().next().value.
|
|
const lruChunks = new Map();
|
|
// inflightChunks: Map<inflightKey, Promise>
|
|
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 onlyUnpaid = Boolean(state.onlyUnpaid);
|
|
const onlyUndelivered = Boolean(state.onlyUndelivered);
|
|
const negativeSeekMonths = (state.negativeSeekMonths != null && Number(state.negativeSeekMonths) < 0)
|
|
? Number(state.negativeSeekMonths)
|
|
: 0;
|
|
return { filter, onlyUnpaid, onlyUndelivered, negativeSeekMonths };
|
|
}
|
|
|
|
export function getFilterKey(state = automat?.state || initialState) {
|
|
const { filter, onlyUnpaid, onlyUndelivered, negativeSeekMonths } = getFilterParams(state);
|
|
return JSON.stringify({ f: filter, u: onlyUnpaid, d: onlyUndelivered, s: negativeSeekMonths });
|
|
}
|
|
|
|
export function formatFilterLabel(filterKeyOrState) {
|
|
let f, u, d, s;
|
|
if (typeof filterKeyOrState === 'string') {
|
|
try {
|
|
const parsed = JSON.parse(filterKeyOrState);
|
|
f = parsed.f;
|
|
u = parsed.u;
|
|
d = parsed.d;
|
|
s = parsed.s;
|
|
} catch {
|
|
return filterKeyOrState;
|
|
}
|
|
} else if (filterKeyOrState && typeof filterKeyOrState === 'object') {
|
|
if ('f' in filterKeyOrState) {
|
|
f = filterKeyOrState.f;
|
|
u = filterKeyOrState.u;
|
|
d = filterKeyOrState.d;
|
|
s = filterKeyOrState.s;
|
|
} else {
|
|
const params = getFilterParams(filterKeyOrState);
|
|
f = params.filter;
|
|
u = params.onlyUnpaid;
|
|
d = params.onlyUndelivered;
|
|
s = params.negativeSeekMonths;
|
|
}
|
|
}
|
|
|
|
const parts = [];
|
|
if (f) parts.push(`Suche: „${f}“`);
|
|
if (u) parts.push('Nur unbezahlt');
|
|
if (d) parts.push('Nur ungeliefert');
|
|
if (s < 0) parts.push(`Seek: ${formatNegativeSeek(s)}`);
|
|
if (parts.length === 0) return 'Standard (Alle Aufträge)';
|
|
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, orderCount = 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,
|
|
orderCount,
|
|
});
|
|
|
|
// 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('[orderAutomat] 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,
|
|
orderCount: info.orderCount,
|
|
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: 'order',
|
|
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 ?? '',
|
|
onlyUnpaid: automat?.state?.onlyUnpaid ?? false,
|
|
onlyUndelivered: automat?.state?.onlyUndelivered ?? false,
|
|
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));
|
|
}
|
|
|
|
// Once active chunks finish loading, prefetch the next lookahead chunk in the background
|
|
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 order helpers
|
|
export function isOrderPaid(order) {
|
|
if (!order) return false;
|
|
return Boolean(order.paid ?? order.payed ?? order.isPaid ?? order.is_paid ?? order.paidAt);
|
|
}
|
|
|
|
export function isOrderDelivered(order) {
|
|
if (!order) return false;
|
|
return Boolean(order.shipped ?? order.delivered ?? order.isDelivered ?? order.is_delivered ?? order.deliveredAt);
|
|
}
|
|
|
|
export function getOrderDate(order) {
|
|
if (!order) return null;
|
|
const raw = order.date || order.createdAt;
|
|
if (!raw) return null;
|
|
const d = new Date(raw);
|
|
return Number.isNaN(d.getTime()) ? null : d;
|
|
}
|
|
|
|
/**
|
|
* Calculates cutoff date for negative seek.
|
|
* @param {number} months Negative integer (e.g. -1 for 1 month ago, -12 for 1 year ago)
|
|
* @returns {Date|null}
|
|
*/
|
|
export function getNegativeSeekCutoff(months) {
|
|
if (!months || months >= 0) return null;
|
|
const d = new Date();
|
|
d.setMonth(d.getMonth() + months);
|
|
d.setHours(23, 59, 59, 999);
|
|
return d;
|
|
}
|
|
|
|
/**
|
|
* Formats negative seek duration in human readable German.
|
|
* @param {number} months
|
|
* @returns {string}
|
|
*/
|
|
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.onlyUnpaid) params.onlyUnpaid = true;
|
|
if (filterParams.onlyUndelivered) params.onlyUndelivered = true;
|
|
if (filterParams.negativeSeekMonths != null && Number(filterParams.negativeSeekMonths) < 0) {
|
|
params.seekMonths = Number(filterParams.negativeSeekMonths);
|
|
}
|
|
return params;
|
|
}
|
|
|
|
// Fetches a single chunk from GET /api/order with server-side filters
|
|
async function fetchOrdersPageFor(filterParams, offset = 0, limit = CHUNK_SIZE) {
|
|
const params = buildQueryParamsFor(filterParams, offset, limit);
|
|
const res = await orderApi.list(params);
|
|
const orders = Array.isArray(res?.orders) ? res.orders : [];
|
|
const total = Number(res?.total ?? orders.length);
|
|
const unfilteredTotal = res?.unfilteredTotal != null ? Number(res.unfilteredTotal) : total;
|
|
return { orders, 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) {
|
|
// CACHE HIT FOR THIS FILTER COMBINATION: restore instantly from RAM!
|
|
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)} Aufträge im RAM)`,
|
|
});
|
|
notifyChunkStats();
|
|
|
|
// If chunk 0 was evicted or not yet loaded in this filter, fetch chunk 0
|
|
if (!cached.loadedChunks.has(0)) {
|
|
void actions.loadChunk(0, queryEpoch, currentKey);
|
|
}
|
|
} else {
|
|
// CACHE MISS: initialize fresh filter entry and load chunk 0
|
|
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 (no prefetch on entry)
|
|
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 initial items are null or immediate requested, bypass debounce and load immediately
|
|
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);
|
|
}
|
|
|
|
// New event tick (drag mousemove / pagination click) replaces previous target position
|
|
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 = fetchOrdersPageFor(filterParams, offset, limit)
|
|
.then(({ orders, 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];
|
|
}
|
|
|
|
// Fill in real received items for this chunk
|
|
for (let i = 0; i < orders.length; i++) {
|
|
const idx = offset + i;
|
|
if (idx < entry.items.length) {
|
|
entry.items[idx] = orders[i];
|
|
}
|
|
}
|
|
|
|
entry.loadedChunks.add(index);
|
|
entry.status = 'ready';
|
|
entry.error = null;
|
|
entry.lastAccessed = Date.now();
|
|
|
|
// Register chunk in global LRU (evicts oldest chunk if > MAX_LRU_CHUNKS)
|
|
registerChunkLRU(targetFilterKey, index, orders.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: orders.length,
|
|
duration,
|
|
message: `Chunk #${index} geladen (${orders.length} Aufträge 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(`[orderAutomat] 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);
|
|
},
|
|
|
|
setOnlyUnpaid(onlyUnpaid) {
|
|
automat.setState({ onlyUnpaid: Boolean(onlyUnpaid) });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
setOnlyUndelivered(onlyUndelivered) {
|
|
automat.setState({ onlyUndelivered: Boolean(onlyUndelivered) });
|
|
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: '',
|
|
onlyUnpaid: false,
|
|
onlyUndelivered: false,
|
|
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) {
|
|
// Invalidate only current filter's cached chunks
|
|
const currentKey = getFilterKey(automat.state);
|
|
actions.clearFilterCache(currentKey);
|
|
} else {
|
|
// Full reload (e.g. after SSE mutation or document deletion): clear all cached data
|
|
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 (optional filterKey, defaults to active)
|
|
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)) {
|
|
// Remove all chunks of this filter from LRU
|
|
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 an order locally across all filter caches
|
|
patchOrder(id, patch) {
|
|
let changed = false;
|
|
for (const entry of filterCaches.values()) {
|
|
if (Array.isArray(entry.items)) {
|
|
entry.items = entry.items.map((o) => {
|
|
if (o && o.id === id) {
|
|
changed = true;
|
|
return { ...o, ...patch };
|
|
}
|
|
return o;
|
|
});
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(automat.state.items)) {
|
|
const items = automat.state.items.map((o) => {
|
|
if (o && o.id === id) {
|
|
changed = true;
|
|
return { ...o, ...patch };
|
|
}
|
|
return o;
|
|
});
|
|
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: 'Order-Automat und sämtliche Caches zurückgesetzt',
|
|
});
|
|
notifyChunkStats();
|
|
automat.setState(initialState);
|
|
},
|
|
};
|
|
|
|
export const orderAutomat = new Automat(initialState, actions, { name: 'order' });
|
|
automat = orderAutomat;
|
|
|
|
// MARK: exported methods for direct invocation
|
|
export function getItems() {
|
|
return actions.getItems();
|
|
}
|
|
|
|
export function requireChunk(chunkIndex, endOrOptions, maybeOptions) {
|
|
return actions.requireChunk(chunkIndex, endOrOptions, maybeOptions);
|
|
}
|
|
|
|
orderAutomat.getItems = getItems;
|
|
orderAutomat.requireChunk = requireChunk;
|
|
orderAutomat.CHUNK_SIZE = CHUNK_SIZE;
|
|
orderAutomat.MAX_LRU_CHUNKS = MAX_LRU_CHUNKS;
|
|
orderAutomat.getChunkStats = getChunkStats;
|
|
orderAutomat.subscribeChunkStats = subscribeChunkStats;
|
|
orderAutomat.evictChunk = actions.evictChunk;
|
|
orderAutomat.clearFilterCache = actions.clearFilterCache;
|
|
orderAutomat.clearCache = actions.clearCache;
|
|
orderAutomat.prefetchAllChunks = actions.prefetchAllChunks;
|
|
orderAutomat.getFilterKey = getFilterKey;
|
|
orderAutomat.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 orders */
|
|
export function selectOrders(state = automat.state) {
|
|
return state.items;
|
|
}
|
|
|
|
/** Selects total unpaged count */
|
|
export function selectOrderTotal(state = automat.state) {
|
|
return state.total;
|
|
}
|
|
|
|
/** Selects unfiltered total count */
|
|
export function selectOrderUnfilteredTotal(state = automat.state) {
|
|
return state.unfilteredTotal ?? 0;
|
|
}
|
|
|
|
/** Selects unpaid filter */
|
|
export function selectOnlyUnpaid(state = automat.state) {
|
|
return state.onlyUnpaid;
|
|
}
|
|
|
|
/** Selects undelivered filter */
|
|
export function selectOnlyUndelivered(state = automat.state) {
|
|
return state.onlyUndelivered;
|
|
}
|
|
|
|
/** 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 selectOrderPagination(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 orderAutomat;
|