@softwear/latestcollectioncore 1.0.161 → 1.0.162

package/dist/articleStatus.js

@@ -99,6 +99,28 @@ function buildAggregationEvaluator(aggregationExpression) {
 function prepareSubTotalAggKey(aggKey) {
     return aggKey.split('\t').slice(0, -1).join('\t').concat(' Σ');
 }
+/** Same as filtrex std.coerceBoolean(customProp(...)) for bare join keys on the transaction */
+function coerceJoinKeyValue(v) {
+    return typeof v === 'boolean' ? +v : v;
+}
+function getTrieLeaf(root, transaction, keys) {
+    const nrKeys = keys.length;
+    if (nrKeys === 0)
+        return root;
+    let node = root;
+    for (let i = 0; i < nrKeys; i++) {
+        const k = coerceJoinKeyValue(transaction[keys[i]]);
+        if (!node.children)
+            node.children = new Map();
+        let next = node.children.get(k);
+        if (!next) {
+            next = {};
+            node.children.set(k, next);
+        }
+        node = next;
+    }
+    return node;
+}
 /*
  * A factory function that returns a function that can be used to aggregate transactions
  * The factory function is called once for each aggregationExpression
@@ -122,47 +144,36 @@ function prepareSubTotalAggKey(aggKey) {
  * @returns {Function} - The aggregator function
  */
 function aggregator({ beginTimestamp, endTimestamp, filterExpression, aggregationExpression, rawAggregations, maxRows, totals, subtotalsForOuterGrouper, parentGroupTotals, }) {
-    const filterExpressionCache = {};
     let filter;
-    let filterDependencyEvaluator;
+    let filterGranularity = [];
+    const filterTrieRoot = {};
     if (filterExpression) {
         filter = (0, filtrex_1.compileExpression)(filterExpression, filtrexOptions);
-        // Maintain a cache of evaluated filterExpressions
-        // The granularity of the cache is determined by the joined tables in the filterExpression
-        const filterGranularity = Object.entries(globalJoinableTables)
+        filterGranularity = Object.entries(globalJoinableTables)
             .filter((join) => filterExpression.includes(join[0] + '.'))
             .map((join) => join[1]);
-        filterDependencyEvaluator = (0, filtrex_1.compileExpression)(filterGranularity.join('+'), filtrexOptions);
     }
     const aggregationEvaluator = buildAggregationEvaluator(aggregationExpression);
-    // Maintain a cache of evaluated aggregationExpressions
-    // The granularity of the cache is determined by the joined tables in the aggregationExpression
-    const aggregationExpressionCache = {};
     const aggregationGranularity = Object.entries(globalJoinableTables)
         .filter((join) => aggregationExpression.includes(join[0] + '.'))
         .map((join) => join[1]);
-    let aggregationDependencyExpression = aggregationGranularity.join('+');
-    if (!aggregationDependencyExpression)
-        aggregationDependencyExpression = '"N.A."';
-    const aggregationDependencyEvaluator = (0, filtrex_1.compileExpression)(aggregationDependencyExpression, filtrexOptions);
+    const aggregationTrieRoot = {};
     return function (transaction) {
         if (filter) {
-            const filterDependency = filterDependencyEvaluator(transaction);
-            const filterExpression = filterExpressionCache[filterDependency];
-            if (filterExpression == -1)
+            const filterLeaf = getTrieLeaf(filterTrieRoot, transaction, filterGranularity);
+            if (filterLeaf.filterResult === -1)
                 return;
-            if (!filterExpression) {
-                filterExpressionCache[filterDependency] = filter(transaction) ? 1 : -1;
-                if (filterExpressionCache[filterDependency] == -1)
+            if (filterLeaf.filterResult === undefined) {
+                filterLeaf.filterResult = filter(transaction) ? 1 : -1;
+                if (filterLeaf.filterResult === -1)
                     return;
             }
         }
-        const aggregationDependency = aggregationDependencyEvaluator(transaction);
-        let aggregateKey = aggregationExpressionCache[aggregationDependency];
-        if (!aggregateKey) {
-            aggregateKey = aggregationEvaluator(transaction);
-            aggregationExpressionCache[aggregationDependency] = aggregateKey;
+        const aggregateKeyLeaf = getTrieLeaf(aggregationTrieRoot, transaction, aggregationGranularity);
+        if (!aggregateKeyLeaf.aggregateKey) {
+            aggregateKeyLeaf.aggregateKey = aggregationEvaluator(transaction);
         }
+        const aggregateKey = aggregateKeyLeaf.aggregateKey;
         // Prepare joined values for derived fields
         if (transaction.type == types_1.transactionTypeE.SALE) {
             const sku = globalRelations['sku'][transaction.ean];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softwear/latestcollectioncore",
-  "version": "1.0.161",
+  "version": "1.0.162",
   "description": "Core functions for LatestCollections applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/articleStatus.ts

@@ -167,6 +167,31 @@ function prepareSubTotalAggKey(aggKey) {
   return aggKey.split('\t').slice(0, -1).join('\t').concat(' Σ')
 }
 
+/** Same as filtrex std.coerceBoolean(customProp(...)) for bare join keys on the transaction */
+function coerceJoinKeyValue(v: unknown): unknown {
+  return typeof v === 'boolean' ? +v : v
+}
+
+type AggregateKeyTrieNode = { aggregateKey?: string; children?: Map<unknown, AggregateKeyTrieNode> }
+type FilterResultTrieNode = { filterResult?: 1 | -1; children?: Map<unknown, FilterResultTrieNode> }
+
+function getTrieLeaf<T extends { children?: Map<unknown, T> }>(root: T, transaction: TransactionI, keys: string[]): T {
+  const nrKeys = keys.length
+  if (nrKeys === 0) return root
+  let node = root
+  for (let i = 0; i < nrKeys; i++) {
+    const k = coerceJoinKeyValue(transaction[keys[i] as keyof TransactionI] as unknown)
+    if (!node.children) node.children = new Map()
+    let next = node.children.get(k) as T | undefined
+    if (!next) {
+      next = {} as T
+      node.children.set(k, next)
+    }
+    node = next
+  }
+  return node
+}
+
 /*
  * A factory function that returns a function that can be used to aggregate transactions
  * The factory function is called once for each aggregationExpression
@@ -200,46 +225,35 @@ function aggregator({
   subtotalsForOuterGrouper,
   parentGroupTotals,
 }: AggregatorFnI) {
-  const filterExpressionCache = {}
-
-  let filter
-  let filterDependencyEvaluator
+  let filter: ((transaction: TransactionI) => unknown) | undefined
+  let filterGranularity: string[] = []
+  const filterTrieRoot: FilterResultTrieNode = {}
   if (filterExpression) {
     filter = compileExpression(filterExpression, filtrexOptions)
-    // Maintain a cache of evaluated filterExpressions
-    // The granularity of the cache is determined by the joined tables in the filterExpression
-    const filterGranularity = Object.entries(globalJoinableTables)
+    filterGranularity = Object.entries(globalJoinableTables)
       .filter((join) => filterExpression.includes(join[0] + '.'))
       .map((join) => join[1])
-    filterDependencyEvaluator = compileExpression(filterGranularity.join('+'), filtrexOptions)
   }
   const aggregationEvaluator = buildAggregationEvaluator(aggregationExpression)
-  // Maintain a cache of evaluated aggregationExpressions
-  // The granularity of the cache is determined by the joined tables in the aggregationExpression
-  const aggregationExpressionCache = {}
   const aggregationGranularity = Object.entries(globalJoinableTables)
     .filter((join) => aggregationExpression.includes(join[0] + '.'))
     .map((join) => join[1])
+  const aggregationTrieRoot: AggregateKeyTrieNode = {}
 
-  let aggregationDependencyExpression = aggregationGranularity.join('+')
-  if (!aggregationDependencyExpression) aggregationDependencyExpression = '"N.A."'
-  const aggregationDependencyEvaluator = compileExpression(aggregationDependencyExpression, filtrexOptions)
   return function (transaction: TransactionI): void {
     if (filter) {
-      const filterDependency = filterDependencyEvaluator(transaction)
-      const filterExpression = filterExpressionCache[filterDependency]
-      if (filterExpression == -1) return
-      if (!filterExpression) {
-        filterExpressionCache[filterDependency] = filter(transaction) ? 1 : -1
-        if (filterExpressionCache[filterDependency] == -1) return
+      const filterLeaf = getTrieLeaf<FilterResultTrieNode>(filterTrieRoot, transaction, filterGranularity)
+      if (filterLeaf.filterResult === -1) return
+      if (filterLeaf.filterResult === undefined) {
+        filterLeaf.filterResult = filter(transaction) ? 1 : -1
+        if (filterLeaf.filterResult === -1) return
       }
     }
-    const aggregationDependency = aggregationDependencyEvaluator(transaction)
-    let aggregateKey = aggregationExpressionCache[aggregationDependency]
-    if (!aggregateKey) {
-      aggregateKey = aggregationEvaluator(transaction)
-      aggregationExpressionCache[aggregationDependency] = aggregateKey
+    const aggregateKeyLeaf = getTrieLeaf<AggregateKeyTrieNode>(aggregationTrieRoot, transaction, aggregationGranularity)
+    if (!aggregateKeyLeaf.aggregateKey) {
+      aggregateKeyLeaf.aggregateKey = aggregationEvaluator(transaction) as string
     }
+    const aggregateKey = aggregateKeyLeaf.aggregateKey as string
     // Prepare joined values for derived fields
     if (transaction.type == transactionTypeE.SALE) {
       const sku = globalRelations['sku'][transaction.ean]