@shushed/helpers 0.0.226-fix-erp-631-20260105165305 → 0.0.226

package/dist/cjs/src-public/runtime.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logging = void 0;
+const lodash_pick_1 = __importDefault(require("lodash.pick"));
 const DEFAULT_BRANCH = 'migratedprod';
 const getCircularReplacer = () => {
     const seen = new WeakSet();
@@ -59,34 +63,50 @@ exports.Logging = Logging;
 class Runtime {
     workflowId;
     triggerId;
+    triggerName;
+    triggerVersion;
     envName;
     pubSubPrefix;
     systemEnvName;
     runtimeUrl;
     logging;
-    workflowRoot = null;
+    triggerDataProperties = undefined;
+    triggerConfigProperties = undefined;
+    triggerConfig = undefined;
+    workflowRoot;
     constructor(opts) {
         if (opts instanceof Runtime) {
             this.workflowRoot = opts.workflowRoot;
             this.workflowId = opts.workflowId;
             this.triggerId = opts.triggerId;
+            this.triggerName = opts.triggerName;
+            this.triggerVersion = opts.triggerVersion;
             this.systemEnvName = opts.systemEnvName;
             this.runtimeUrl = opts.runtimeUrl;
             this.pubSubPrefix = opts.pubSubPrefix;
             this.envName = opts.envName;
             this.logging = opts.logging || new Logging(this.workflowId, this.triggerId, this.systemEnvName);
+            this.triggerName = opts.triggerName;
+            this.triggerVersion = opts.triggerVersion;
+            this.triggerDataProperties = opts.triggerDataProperties;
+            this.triggerConfigProperties = opts.triggerConfigProperties;
+            this.triggerConfig = opts.triggerConfig;
         }
         else {
-            if (opts.root) {
-                this.workflowRoot = opts.root;
-            }
+            this.workflowRoot = opts.root || {};
             this.workflowId = opts.workflowId || opts.workflow?.id || '';
-            this.triggerId = opts.triggerId || opts.trigger?.id || '';
-            if (!this.triggerId && opts.session) {
-                this.triggerId = Object.values(opts.session?.executedNodes || {}).find(e => e.nodeType === 'trigger')?.nodeId ?? 'unknown';
+            if (opts.trigger?.label) {
+                this.triggerId = opts.trigger.id || '00000000-0000-0000-0000-000000000000';
+                this.triggerName = opts.trigger.label.split(/\sv\d/)[0].trim() || this.workflowId;
+                this.triggerVersion = buildSemver((opts.trigger.label.split(/\sv\d/)[1]?.trim() || 'v0').replace(/^v/, ''));
+                this.triggerDataProperties = opts.trigger.data?.properties;
+                this.triggerConfigProperties = opts.trigger.config?.properties;
             }
-            else if (!this.triggerId) {
-                this.triggerId = 'unknown';
+            else {
+                this.triggerId = Object.values(opts.session?.executedNodes || {}).find(e => e.nodeType === 'trigger')?.nodeId ?? '00000000-0000-0000-0000-000000000000';
+                this.triggerName = this.workflowRoot[this.triggerId]?.triggerName || this.workflowId;
+                this.triggerVersion = this.workflowRoot[this.triggerId]?.triggerVersion || '0.0.0';
+                this.triggerConfig = this.workflowRoot[this.triggerId]?.triggerConfig;
             }
             this.systemEnvName = this.getSystemEnvName(opts);
             this.envName = this.systemEnvName === DEFAULT_BRANCH ? 'prod' : this.systemEnvName;
@@ -95,6 +115,18 @@ class Runtime {
             this.logging = opts.logging || new Logging(this.workflowId, this.triggerId, this.systemEnvName);
         }
     }
+    enhanceWorkflowReturn(triggerReturn, triggerConfig) {
+        const keys = Object.keys(this.triggerDataProperties || {});
+        return Object.assign((0, lodash_pick_1.default)({
+            workflowId: this.workflowId,
+            triggerId: this.triggerId,
+            triggerName: this.triggerName,
+            triggerVersion: this.triggerVersion,
+            systemEnvName: this.systemEnvName,
+            envName: this.envName,
+            triggerConfig: (0, lodash_pick_1.default)(triggerConfig, Object.entries(this.triggerConfigProperties || {}).filter(([_, value]) => !value.buildship?.sensitive).map(([key]) => key))
+        }, keys), triggerReturn);
+    }
     getRuntimeUrl(options) {
         if (options.runtimeUrl && this.isDeployment) {
             return options.runtimeUrl;
@@ -143,3 +175,10 @@ class Runtime {
 }
 exports.default = Runtime;
 ;
+function buildSemver(version) {
+    const parts = version.split(/\./).map(x => parseInt(x, 10));
+    for (let i = parts.length; i < 3; i++) {
+        parts.push(0);
+    }
+    return parts.join('.');
+}

package/dist/cjs/src-public/sitoo.js

@@ -0,0 +1,349 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SitooOrderItemType = exports.SitooPaymentState = exports.SitooOrderType = exports.SitooOrderState = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const lodash_groupby_1 = __importDefault(require("lodash.groupby"));
+const env_1 = __importDefault(require("./env"));
+const SITOO_TR_TYPE_MANUAL_IN = 10;
+const SITOO_TR_TYPE_MANUAL_OUT = 20;
+var SitooOrderState;
+(function (SitooOrderState) {
+    SitooOrderState[SitooOrderState["Abandoned"] = -1] = "Abandoned";
+    SitooOrderState[SitooOrderState["Open"] = 0] = "Open";
+    SitooOrderState[SitooOrderState["Closed"] = 10] = "Closed";
+    SitooOrderState[SitooOrderState["Cancelled"] = 20] = "Cancelled";
+})(SitooOrderState || (exports.SitooOrderState = SitooOrderState = {}));
+var SitooOrderType;
+(function (SitooOrderType) {
+    SitooOrderType[SitooOrderType["Order"] = 10] = "Order";
+    SitooOrderType[SitooOrderType["Booking"] = 100] = "Booking";
+    SitooOrderType[SitooOrderType["POSParked"] = 110] = "POSParked";
+})(SitooOrderType || (exports.SitooOrderType = SitooOrderType = {}));
+var SitooPaymentState;
+(function (SitooPaymentState) {
+    SitooPaymentState[SitooPaymentState["None"] = 0] = "None";
+    SitooPaymentState[SitooPaymentState["Pending"] = 10] = "Pending";
+    SitooPaymentState[SitooPaymentState["Reserved"] = 15] = "Reserved";
+    SitooPaymentState[SitooPaymentState["Successful"] = 20] = "Successful";
+    SitooPaymentState[SitooPaymentState["Cancelled"] = 30] = "Cancelled";
+    SitooPaymentState[SitooPaymentState["Failed"] = 40] = "Failed";
+})(SitooPaymentState || (exports.SitooPaymentState = SitooPaymentState = {}));
+var SitooOrderItemType;
+(function (SitooOrderItemType) {
+    SitooOrderItemType[SitooOrderItemType["Product"] = 10] = "Product";
+    SitooOrderItemType[SitooOrderItemType["Discount"] = 20] = "Discount";
+})(SitooOrderItemType || (exports.SitooOrderItemType = SitooOrderItemType = {}));
+const BATCH_SIZE = 900;
+class SitooHelper extends env_1.default {
+    opts;
+    shaToken;
+    baseUrl;
+    siteId;
+    constructor(options, opts) {
+        super(options);
+        this.opts = opts;
+        this.shaToken = crypto_1.default.createHash('sha256').update(opts.accessToken).digest('hex').slice(0, 8);
+        this.baseUrl = opts.sitooBaseUrl.replace(/\/$/, '');
+        this.siteId = opts.sitooSiteId;
+    }
+    async getAllOrders(options) {
+        const allOrders = [];
+        const pageSize = 100;
+        let start = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const queryParams = new URLSearchParams();
+            queryParams.set('num', pageSize.toString());
+            queryParams.set('start', start.toString());
+            queryParams.set('sort', 'orderid');
+            if (options?.fromTimestamp !== undefined) {
+                queryParams.set('orderdatefrom', options.fromTimestamp.toString());
+            }
+            if (options?.untilTimestamp !== undefined) {
+                queryParams.set('orderdateto', options.untilTimestamp.toString());
+            }
+            if (options?.filterByState !== undefined) {
+                queryParams.set('orderstate', options.filterByState.toString());
+            }
+            const url = `${this.baseUrl}/sites/${this.siteId}/orders.json?${queryParams.toString()}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Basic ${this.opts.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new Error(`Sitoo API error: ${response.status} ${response.statusText} - ${errorText}`);
+            }
+            const envelope = await response.json();
+            allOrders.push(...envelope.items);
+            if (envelope.items.length < pageSize) {
+                hasMore = false;
+            }
+            else {
+                start += envelope.items.length;
+            }
+        }
+        return allOrders;
+    }
+    async getSitooWarehouses() {
+        const url = `${this.baseUrl}/sites/${this.siteId}/warehouses.json`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Basic ${this.opts.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'Unknown error');
+            throw new Error(`Sitoo API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const data = await response.json();
+        const nameToId = {};
+        const warehouses = {};
+        for (const warehouse of data.items) {
+            nameToId[warehouse.name] = warehouse.warehouseid;
+            warehouses[warehouse.warehouseid] = warehouse;
+        }
+        return { nameToId, warehouses };
+    }
+    async fetchWarehouseTransactionsWithFilter(params) {
+        const queryParams = new URLSearchParams();
+        queryParams.set('num', (params.num || 100).toString());
+        if (params.transactiontype !== undefined) {
+            queryParams.set('transactiontype', params.transactiontype.toString());
+        }
+        if (params.datecreatedfrom !== undefined) {
+            queryParams.set('datecreatedfrom', params.datecreatedfrom.toString());
+        }
+        if (params.start !== undefined) {
+            queryParams.set('start', params.start.toString());
+        }
+        queryParams.set('sort', params.ascending ? 'warehousetransactionid' : '-warehousetransactionid');
+        const url = `${this.baseUrl}/sites/${this.siteId}/warehouses/${params.warehouseid}/warehousetransactions.json?${queryParams.toString()}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Basic ${this.opts.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'Unknown error');
+            throw new Error(`Sitoo API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        return await response.json();
+    }
+    async searchTransactionsInApi(warehouseId, entryNosToFind, transactionType, datecreatedfrom) {
+        const found = new Map();
+        let lowestTransactionId = undefined;
+        if (entryNosToFind.size === 0) {
+            return { found, lowestTransactionId };
+        }
+        let hasMore = true;
+        const pageSize = 100;
+        const currentDateFrom = datecreatedfrom;
+        let currentStart = 0;
+        while (hasMore && found.size < entryNosToFind.size) {
+            const envelope = await this.fetchWarehouseTransactionsWithFilter({
+                warehouseid: warehouseId,
+                datecreatedfrom: currentDateFrom,
+                transactiontype: transactionType,
+                ascending: false,
+                num: pageSize,
+                start: currentStart,
+            });
+            const transactions = envelope.items;
+            if (transactions.length === 0) {
+                hasMore = false;
+                break;
+            }
+            for (const transaction of transactions) {
+                if (lowestTransactionId === undefined || transaction.warehousetransactionid < lowestTransactionId) {
+                    lowestTransactionId = transaction.warehousetransactionid;
+                }
+                if (transaction.description) {
+                    for (const entryNo of entryNosToFind) {
+                        if (!found.has(entryNo) && transaction.description.includes(`'${entryNo}'`)) {
+                            found.set(entryNo, transaction);
+                        }
+                    }
+                }
+                if (found.size === entryNosToFind.size) {
+                    break;
+                }
+            }
+            currentStart = currentStart ? currentStart + transactions.length : transactions.length;
+            if (transactions.length < pageSize) {
+                hasMore = false;
+            }
+        }
+        return { found, lowestTransactionId };
+    }
+    async batchAddWarehouseTransactions(transactions) {
+        if (transactions.length === 0)
+            return [];
+        if (transactions.length > BATCH_SIZE) {
+            throw new Error(`Batch size exceeds maximum of ${BATCH_SIZE}. Got ${transactions.length}`);
+        }
+        const url = `${this.baseUrl}/sites/${this.siteId}/warehousetransactions.json`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Basic ${this.opts.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(transactions),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'Unknown error');
+            throw new Error(`Sitoo API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const result = await response.json();
+        return result;
+    }
+    async syncWarehouseTransactions(items, options) {
+        if (items.length === 0) {
+            return [];
+        }
+        const locationCodeToWarehouse = (await this.getSitooWarehouses()).nameToId;
+        const foundEntryNos = new Map();
+        const results = {};
+        const entryNoToIdx = {};
+        const entriesByWarehouseAndTransactionType = new Map();
+        for (let i = 0; i < items.length; i++) {
+            const entry = items[i];
+            const warehouseId = locationCodeToWarehouse[entry.location_code];
+            const transactionType = entry.type === 'transfer' ? (entry.quantity > 0 ? SITOO_TR_TYPE_MANUAL_IN : SITOO_TR_TYPE_MANUAL_OUT) : undefined;
+            entryNoToIdx[entry.entry_no] = i;
+            if (transactionType === undefined) {
+                results[i] = {
+                    error: false,
+                    message: `Not supported transaction type: ${entry.type}`,
+                };
+                continue;
+            }
+            if (warehouseId === undefined) {
+                results[i] = {
+                    error: false,
+                    message: `Not supported warehouse in Sitoo: ${entry.location_code}`,
+                };
+                continue;
+            }
+            const key = `${warehouseId}-${transactionType}`;
+            if (!entriesByWarehouseAndTransactionType.has(key)) {
+                entriesByWarehouseAndTransactionType.set(key, []);
+            }
+            entriesByWarehouseAndTransactionType.get(key).push(entry);
+        }
+        for (const [_, warehouseEntries] of entriesByWarehouseAndTransactionType) {
+            if (warehouseEntries.length > 0) {
+                let datecreatedfrom = undefined;
+                for (const entry of warehouseEntries) {
+                    const entryCreatedAt = Math.floor(new Date(entry.created_at).getTime() / 1000);
+                    if (datecreatedfrom === undefined || entryCreatedAt < datecreatedfrom) {
+                        datecreatedfrom = entryCreatedAt;
+                    }
+                }
+                const { found: apiFound } = await this.searchTransactionsInApi(locationCodeToWarehouse[warehouseEntries[0].location_code], new Set(warehouseEntries.map(e => e.entry_no.toString())), warehouseEntries[0].quantity > 0 ? SITOO_TR_TYPE_MANUAL_IN : SITOO_TR_TYPE_MANUAL_OUT, datecreatedfrom);
+                for (const [entryNo, transaction] of apiFound) {
+                    foundEntryNos.set(entryNo, transaction.warehousetransactionid);
+                }
+            }
+        }
+        for (const [entryNo, transactionId] of foundEntryNos) {
+            const idx = entryNoToIdx[entryNo];
+            results[idx] = {
+                error: false,
+                message: `Found transaction in Sitoo: ${transactionId} for the entry ${entryNo}`,
+            };
+        }
+        const batches = [[]];
+        for (const [_, warehouseEntries] of entriesByWarehouseAndTransactionType) {
+            for (let i = 0; i < warehouseEntries.length; i += 1) {
+                if (!foundEntryNos.has(warehouseEntries[i].entry_no)) {
+                    if ((batches[batches.length - 1].length + 1) >= BATCH_SIZE) {
+                        batches.push([]);
+                    }
+                    batches[batches.length - 1].push(warehouseEntries[i]);
+                }
+            }
+        }
+        const hasMissingEntries = batches[0].length > 0;
+        if (!options?.preview && hasMissingEntries) {
+            for (let i = 0; i < batches.length; i++) {
+                const warehouseEntities = (0, lodash_groupby_1.default)(batches[i], e => `${locationCodeToWarehouse[e.location_code]}-${e.quantity > 0 ? 'positive' : 'negative'}`);
+                const entryNosInBatches = {};
+                const transactionsToCreate = [];
+                for (const k in warehouseEntities) {
+                    const entriesToCreate = warehouseEntities[k];
+                    const warehouseId = locationCodeToWarehouse[entriesToCreate[0].location_code];
+                    const entryType = entriesToCreate[0].quantity > 0 ? SITOO_TR_TYPE_MANUAL_IN : SITOO_TR_TYPE_MANUAL_OUT;
+                    entryNosInBatches[transactionsToCreate.length] = entriesToCreate.map(e => e.entry_no);
+                    transactionsToCreate.push({
+                        warehouseid: warehouseId,
+                        transactiontype: entryType,
+                        description: entriesToCreate.map(e => `'${e.entry_no}'`).join(', '),
+                        items: entriesToCreate.map(e => ({
+                            sku: [e.style_id, e.colour_id, e.size_code].filter(Boolean).join('-'),
+                            decimalquantity: `${e.quantity.toFixed(3)}`,
+                            moneypricein: (((e.unit_cost?.value ?? 0) / 100) * e.quantity).toFixed(2),
+                        })),
+                    });
+                }
+                try {
+                    const createdIds = await this.batchAddWarehouseTransactions(transactionsToCreate);
+                    for (let j = 0; j < transactionsToCreate.length; j++) {
+                        const transactionId = createdIds[j];
+                        for (let k = 0; k < entryNosInBatches[j].length; k += 1) {
+                            const entryNo = entryNosInBatches[j][k];
+                            const idx = entryNoToIdx[entryNo];
+                            results[idx] = {
+                                entryNo: entryNo,
+                                transactionId: transactionId,
+                            };
+                        }
+                    }
+                }
+                catch (error) {
+                    for (const entry of batches[i]) {
+                        const idx = entryNoToIdx[entry.entry_no];
+                        results[idx] = error;
+                    }
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < batches.length; i++) {
+                for (let j = 0; j < batches[i].length; j += 1) {
+                    const entry = batches[i][j];
+                    const idx = entryNoToIdx[entry.entry_no];
+                    const warehouseId = locationCodeToWarehouse[entry.location_code];
+                    const transactionType = entry.quantity > 0 ? SITOO_TR_TYPE_MANUAL_IN : SITOO_TR_TYPE_MANUAL_OUT;
+                    results[idx] = {
+                        error: false,
+                        message: `In Preview Mode. ${entry.entry_no} scheduled to be created as transction type: ${transactionType} in the warehouse: ${warehouseId}. Batch: ${i}`
+                    };
+                }
+            }
+        }
+        const resultsAsArray = [];
+        for (let i = 0; i < items.length; i += 1) {
+            const result = results[i];
+            if (!result) {
+                resultsAsArray.push(new Error(`${items[i].entry_no} got missed in processing`));
+            }
+            else {
+                resultsAsArray.push(result);
+            }
+        }
+        return resultsAsArray;
+    }
+}
+exports.default = SitooHelper;

package/dist/cjs/src-public/utils.js

@@ -264,6 +264,9 @@ function setRetryAfterVariable(value, options) {
 global.functionsCache = global.functionsCache || {};
 exports.FUNCTION_EXPR_ERROR = Symbol('function');
 function createFunction(expression) {
+    if (typeof expression === 'function') {
+        return expression;
+    }
     if (!global.functionsCache[expression]) {
         global.functionsCache[expression] = new Function('symbol', 'payload', 'try { return ' + expression + ' } catch (err) { return symbol; }');
     }

package/dist/package.json

@@ -5,6 +5,7 @@
   "license": "UNLICENSED",
   "description": "",
   "dependencies": {
+    "@google-cloud/firestore": "^7.11.1",
     "@hackylabs/deep-redact": "^2.2.1",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
@@ -12,15 +13,15 @@
     "jose": "^6.0.11",
     "lodash.chunk": "^4.2.0",
     "lodash.clonedeep": "^4.5.0",
+    "lodash.groupby": "^4.6.0",
     "lodash.isequal": "^4.5.0",
     "lodash.omit": "^4.5.0",
     "lodash.pick": "^4.4.0",
     "mime-types": "^3.0.1",
     "p-limit": "^7.1.1",
     "rate-limiter-flexible": "^7.2.0",
-    "uuid": "^11.1.0",
     "redis": "^5.6.0",
-    "@google-cloud/firestore": "^7.11.1"
+    "uuid": "^11.1.0"
   },
   "files": [
     "dist"

package/dist/types/contracts/index.d.ts

@@ -10,6 +10,8 @@ export { default as DevelopmentColour } from './development-colour.schema.json';
 export { default as Asset } from './asset.schema.json';
 export { default as CustomerSegment } from './customer-segment.schema.json';
 export { default as MarketingPref } from './marketing-preferences.schema.json';
+export { default as StockMovement } from './stock-movement.schema.json';
+export { default as PurchaseOrderline } from './purchase-orderline.schema.json';
 export * from './order';
 export { default as Order } from './order.schema.json';
 export * from './messages';

package/dist/types/dist-dereferenced/index.d.ts

@@ -10,6 +10,8 @@ export { default as Price } from './price';
 export { default as ProductCategory } from './product-category';
 export { default as ProductDraft } from './product-draft';
 export { default as Product } from './product';
+export { default as PurchaseOrderline } from './purchase-orderline';
+export { default as StockMovement } from './stock-movement';
 export { default as Stock } from './stock';
 export { default as Total } from './total';
 export * as Messages from './messages';