@softwear/latestcollectioncore 1.0.161 → 1.0.163

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/dist/lcAxios.d.ts

@@ -13,11 +13,15 @@ export interface AxiosRequestConfig<D = any> {
     params?: Record<string, any>;
     headers?: Record<string, string | undefined> | any;
     timeout?: number;
-    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream';
     validateStatus?: (status: number) => boolean;
     transformRequest?: AxiosTransformer | AxiosTransformer[];
     transformResponse?: AxiosTransformer | AxiosTransformer[];
     withCredentials?: boolean;
+    auth?: {
+        username?: string;
+        password?: string;
+    };
     /** Axios-only; ignored — fetch handles Content-Encoding when reading the body */
     decompress?: boolean;
 }

package/dist/lcAxios.js

@@ -15,6 +15,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAxiosError = exports.lcAxios = exports.createAxiosInstance = exports.axiosRetry = exports.exponentialDelay = void 0;
 function isAxiosError(payload) {
@@ -113,6 +132,72 @@ function flattenHeaders(h, method) {
     }
     return out;
 }
+function encodeBase64(input) {
+    if (typeof Buffer !== 'undefined')
+        return Buffer.from(input, 'utf8').toString('base64');
+    if (typeof btoa !== 'undefined')
+        return btoa(input);
+    throw new Error('Base64 encoding unavailable');
+}
+function applyAuthHeader(headers, auth) {
+    if (!auth)
+        return;
+    const username = auth.username || '';
+    const password = auth.password || '';
+    headers['Authorization'] = `Basic ${encodeBase64(`${username}:${password}`)}`;
+}
+function createPipeableStream(body) {
+    return {
+        [Symbol.asyncIterator]() {
+            return __asyncGenerator(this, arguments, function* _a() {
+                if (!body)
+                    return yield __await(void 0);
+                const reader = body.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = yield __await(reader.read());
+                        if (done)
+                            break;
+                        if (value)
+                            yield yield __await(value);
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            });
+        },
+        pipe(destination) {
+            ;
+            (() => __awaiter(this, void 0, void 0, function* () {
+                var _a, e_1, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const chunk = _c;
+                            destination.write(chunk);
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (destination.end)
+                    destination.end();
+            }))();
+            return destination;
+        },
+    };
+}
 function applyTransformRequest(fns, data, headers) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!fns)
@@ -176,7 +261,11 @@ exports.axiosRetry = axiosRetry;
 const defaultValidateStatus = (status) => status >= 200 && status < 300;
 function getDefaultDefaults() {
     return {
-        headers: { common: {} },
+        headers: {
+            common: {
+                Accept: 'application/json, text/plain, */*',
+            },
+        },
         transformRequest: [
             function defaultTransformRequest(data, headers) {
                 var _a, _b;
@@ -221,6 +310,7 @@ function createAxiosInstance(initialDefaults) {
             const method = (merged.method || 'get').toUpperCase();
             const url = buildURL(merged.baseURL, merged.url, merged.params);
             const headers = Object.assign({}, flattenHeaders(merged.headers, method));
+            applyAuthHeader(headers, merged.auth);
             let data = merged.data;
             data = yield applyTransformRequest(merged.transformRequest, data, headers);
             const validateStatus = merged.validateStatus || defaultValidateStatus;
@@ -266,6 +356,9 @@ function createAxiosInstance(initialDefaults) {
             else if (rt === 'arraybuffer') {
                 parsed = yield res.arrayBuffer();
             }
+            else if (rt === 'stream') {
+                parsed = createPipeableStream(res.body || null);
+            }
             else if (rt === 'text') {
                 parsed = yield res.text();
             }
@@ -289,7 +382,9 @@ function createAxiosInstance(initialDefaults) {
                     parsed = text;
                 }
             }
-            parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders);
+            if (rt !== 'stream') {
+                parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders);
+            }
             const response = {
                 data: parsed,
                 status: res.status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softwear/latestcollectioncore",
-  "version": "1.0.161",
+  "version": "1.0.163",
   "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]

package/src/lcAxios.ts

@@ -14,11 +14,15 @@ export interface AxiosRequestConfig<D = any> {
   params?: Record<string, any>
   headers?: Record<string, string | undefined> | any
   timeout?: number
-  responseType?: 'json' | 'text' | 'blob' | 'arraybuffer'
+  responseType?: 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream'
   validateStatus?: (status: number) => boolean
   transformRequest?: AxiosTransformer | AxiosTransformer[]
   transformResponse?: AxiosTransformer | AxiosTransformer[]
   withCredentials?: boolean
+  auth?: {
+    username?: string
+    password?: string
+  }
   /** Axios-only; ignored — fetch handles Content-Encoding when reading the body */
   decompress?: boolean
 }
@@ -129,6 +133,44 @@ function flattenHeaders(h: any, method: string): Record<string, string> {
   return out
 }
 
+function encodeBase64(input: string): string {
+  if (typeof Buffer !== 'undefined') return Buffer.from(input, 'utf8').toString('base64')
+  if (typeof btoa !== 'undefined') return btoa(input)
+  throw new Error('Base64 encoding unavailable')
+}
+
+function applyAuthHeader(headers: Record<string, string>, auth: AxiosRequestConfig['auth']) {
+  if (!auth) return
+  const username = auth.username || ''
+  const password = auth.password || ''
+  headers['Authorization'] = `Basic ${encodeBase64(`${username}:${password}`)}`
+}
+
+function createPipeableStream(body: ReadableStream<Uint8Array> | null) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      if (!body) return
+      const reader = body.getReader()
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+          if (value) yield value
+        }
+      } finally {
+        reader.releaseLock()
+      }
+    },
+    pipe(destination: { write: (chunk: Uint8Array) => any; end?: () => any }) {
+      ;(async () => {
+        for await (const chunk of this) destination.write(chunk)
+        if (destination.end) destination.end()
+      })()
+      return destination
+    },
+  }
+}
+
 async function applyTransformRequest(fns: AxiosTransformer | AxiosTransformer[] | undefined, data: any, headers: any): Promise<any> {
   if (!fns) return data
   const list = Array.isArray(fns) ? fns : [fns]
@@ -193,7 +235,11 @@ const defaultValidateStatus = (status: number) => status >= 200 && status < 300
 
 function getDefaultDefaults(): AxiosRequestConfig {
   return {
-    headers: { common: {} },
+    headers: {
+      common: {
+        Accept: 'application/json, text/plain, */*',
+      },
+    },
     transformRequest: [
       function defaultTransformRequest(data: any, headers: any) {
         if (data == null) return data
@@ -231,6 +277,7 @@ export function createAxiosInstance(initialDefaults?: AxiosRequestConfig): any {
     const method = (merged.method || 'get').toUpperCase()
     const url = buildURL(merged.baseURL, merged.url, merged.params)
     const headers: any = { ...flattenHeaders(merged.headers, method) }
+    applyAuthHeader(headers, merged.auth)
 
     let data = merged.data
     data = await applyTransformRequest(merged.transformRequest, data, headers)
@@ -279,6 +326,8 @@ export function createAxiosInstance(initialDefaults?: AxiosRequestConfig): any {
       parsed = await res.blob()
     } else if (rt === 'arraybuffer') {
       parsed = await res.arrayBuffer()
+    } else if (rt === 'stream') {
+      parsed = createPipeableStream((res.body as ReadableStream<Uint8Array> | null) || null)
     } else if (rt === 'text') {
       parsed = await res.text()
     } else if (ct.includes('application/json')) {
@@ -299,7 +348,9 @@ export function createAxiosInstance(initialDefaults?: AxiosRequestConfig): any {
       }
     }
 
-    parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders)
+    if (rt !== 'stream') {
+      parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders)
+    }
 
     const response: AxiosResponse = {
       data: parsed,

package/test/lcAxios.spec.ts

@@ -10,6 +10,14 @@ function jsonResponse(body: unknown, status = 200) {
   })
 }
 
+function textResponse(body: string, status = 200) {
+  return new Response(body, {
+    status,
+    statusText: status === 200 ? 'OK' : 'Error',
+    headers: { 'Content-Type': 'text/plain' },
+  })
+}
+
 describe('lcAxios', () => {
   beforeEach(() => {
     vi.stubGlobal(
@@ -34,6 +42,26 @@ describe('lcAxios', () => {
     expect(init?.body).toBeUndefined()
   })
 
+  it('GET sends axios-style default Accept header', async () => {
+    const client = axios.create()
+    await client.get('https://api.example.com/accept')
+
+    const [, init] = (fetch as ReturnType<typeof vi.fn>).mock.calls[0]
+    const headers = init?.headers as Record<string, string>
+    expect(headers.Accept).toBe('application/json, text/plain, */*')
+  })
+
+  it('auth config sets Authorization basic header', async () => {
+    const client = axios.create()
+    await client.get('https://api.example.com/auth', {
+      auth: { username: 'aladdin', password: 'opensesame' },
+    })
+
+    const [, init] = (fetch as ReturnType<typeof vi.fn>).mock.calls[0]
+    const headers = init?.headers as Record<string, string>
+    expect(headers.Authorization).toBe('Basic YWxhZGRpbjpvcGVuc2VzYW1l')
+  })
+
   it('GET with decompress: true (axios compat) still works; option not passed to fetch', async () => {
     const client = axios.create()
     await client.get('https://api.example.com/x', { decompress: true })
@@ -131,6 +159,30 @@ describe('lcAxios', () => {
     expect(res.data).toEqual({ missing: true })
   })
 
+  it('responseType stream returns a pipeable async iterable body', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(textResponse('hello stream'))
+
+    const client = axios.create()
+    const response = await client.get('https://api.example.com/stream', {
+      responseType: 'stream',
+    })
+
+    const chunks: Uint8Array[] = []
+    await new Promise<void>((resolve) => {
+      response.data.pipe({
+        write(chunk: Uint8Array) {
+          chunks.push(chunk)
+        },
+        end() {
+          resolve()
+        },
+      })
+    })
+
+    const text = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString('utf8')
+    expect(text).toBe('hello stream')
+  })
+
   it('axiosRetry retries when retryCondition passes and fetch then succeeds', async () => {
     vi.mocked(fetch).mockReset()
     vi.mocked(fetch).mockRejectedValueOnce(new TypeError('Failed to fetch'))