@ductape/sdk 0.1.152 → 0.1.154

package/dist/features/features.service.js

@@ -1666,7 +1666,7 @@ function createStepOutputProxy(pathPrefix = '') {
  * - Default delimiter is "" so template literals like `receipts/${ctx.input.orderId}.txt` become receipts/ORD-001.txt not receipts/ ORD-001 .txt.
  * - Recurses into plain objects and arrays; leaves other primitives unchanged.
  */
-const OPERATOR_REF_IN_STRING_REGEX = /(\$Input\{[^}]+\}|\$Sequence\{main\}\{[^}]+\}\{[^}]*\}|\$Now)/g;
+const OPERATOR_REF_IN_STRING_REGEX = /(\$Input\{[^}]+\}|\$Sequence\{main\}\{[^}]+\}\{[^}]*\}|\$Now|\$Uuid)/g;
 function convertStringToConcatIfOperatorRefs(str, delimiter = '') {
     OPERATOR_REF_IN_STRING_REGEX.lastIndex = 0;
     const tokens = str.split(OPERATOR_REF_IN_STRING_REGEX);
@@ -1674,7 +1674,7 @@ function convertStringToConcatIfOperatorRefs(str, delimiter = '') {
     for (const t of tokens) {
         if (!t)
             continue;
-        const isOp = t.startsWith('$Input{') || t.startsWith('$Sequence{') || t === '$Now';
+        const isOp = t.startsWith('$Input{') || t.startsWith('$Sequence{') || t === '$Now' || t === '$Uuid';
         if (isOp) {
             parts.push(t);
         }
@@ -1717,6 +1717,9 @@ function convertToOperatorInput(value, inputProxy, schemaKeys) {
         return out;
     }
     if (typeof value === 'string') {
+        if (/^\$(?:Concat|Substring|Trim|Uppercase|Lowercase|Dateformat|Replace|Split|Join|Pick|Filter|Find|Size|Length|Add|Subtract)\s*[({]/.test(value)) {
+            return value;
+        }
         return convertStringToConcatIfOperatorRefs(value);
     }
     return value;
@@ -1776,6 +1779,8 @@ class RecordingContext {
         /** When set (from recordScenarios), every step we push gets this condition so it only runs when input matches. */
         this._scenarioCondition = null;
         this._recordInput = null;
+        /** Explicit portable control-flow condition inherited by steps in a branch. */
+        this._portableCondition = null;
         this._featureTag = featureTag;
         this._inputSchemaKeys = featureInputSchema ? Object.keys(featureInputSchema) : [];
         this._stepResultOverrides = stepResultOverrides !== null && stepResultOverrides !== void 0 ? stepResultOverrides : {};
@@ -1827,10 +1832,68 @@ class RecordingContext {
     get now() {
         return '$Now';
     }
+    conditionOperand(value) {
+        const converted = convertToOperatorInput(value, this._inputProxy, this._inputSchemaKeys);
+        if (typeof converted === 'string' && converted.startsWith('$'))
+            return converted;
+        return JSON.stringify(converted);
+    }
+    comparison(left, operator, inverseOperator, right) {
+        const lhs = this.conditionOperand(left);
+        const rhs = this.conditionOperand(right);
+        return { expression: `${lhs} ${operator} ${rhs}`, inverse: `${lhs} ${inverseOperator} ${rhs}` };
+    }
+    get when() {
+        return {
+            eq: (left, right) => this.comparison(left, '==', '!=', right),
+            ne: (left, right) => this.comparison(left, '!=', '==', right),
+            gt: (left, right) => this.comparison(left, '>', '<=', right),
+            gte: (left, right) => this.comparison(left, '>=', '<', right),
+            lt: (left, right) => this.comparison(left, '<', '>=', right),
+            lte: (left, right) => this.comparison(left, '<=', '>', right),
+            truthy: (value) => this.comparison(value, '==', '!=', true),
+            falsy: (value) => this.comparison(value, '==', '!=', false),
+            and: (...conditions) => ({
+                expression: conditions.map((condition) => `(${condition.expression})`).join(' && '),
+                inverse: conditions.map((condition) => `(${condition.inverse})`).join(' || '),
+            }),
+            or: (...conditions) => ({
+                expression: conditions.map((condition) => `(${condition.expression})`).join(' || '),
+                inverse: conditions.map((condition) => `(${condition.inverse})`).join(' && '),
+            }),
+        };
+    }
+    async branch(condition, handlers) {
+        if (!(condition === null || condition === void 0 ? void 0 : condition.expression) || !(condition === null || condition === void 0 ? void 0 : condition.inverse)) {
+            throw new FeatureCompilationError(this._featureTag, '(branch)', 'ctx.branch requires a condition created by ctx.when.');
+        }
+        const parent = this._portableCondition;
+        const scoped = (expression) => parent ? `(${parent}) && (${expression})` : expression;
+        try {
+            this._portableCondition = scoped(condition.expression);
+            await handlers.then();
+            if (handlers.else) {
+                this._portableCondition = scoped(condition.inverse);
+                await handlers.else();
+            }
+        }
+        finally {
+            this._portableCondition = parent;
+        }
+    }
+    async each(items, handler) {
+        if (!Array.isArray(items)) {
+            throw new FeatureCompilationError(this._featureTag, '(loop)', 'ctx.each requires a concrete ctx.sampleInput array during compilation. Use ctx.functions for runtime-sized collection logic.');
+        }
+        for (let index = 0; index < items.length; index += 1) {
+            await handler(items[index], index);
+        }
+    }
     /**
      * Record a step definition
      */
     async step(tag, handler, rollback, options) {
+        var _a;
         this._currentStepTag = tag;
         this._stepOrder++;
         this._stepResultDependencies = new Set();
@@ -1889,6 +1952,16 @@ class RecordingContext {
         const condParts = [];
         if (this._scenarioCondition)
             condParts.push(`(${this._scenarioCondition})`);
+        if (this._portableCondition) {
+            condParts.push(`(${this._portableCondition})`);
+            const conditionDependencies = [
+                ...Array.from(this._portableCondition.matchAll(/\$Step\{([^}]+)\}/g), (match) => match[1]),
+                ...Array.from(this._portableCondition.matchAll(/\$Sequence\{main\}\{([^}]+)\}/g), (match) => match[1]),
+            ];
+            if (conditionDependencies.length > 0) {
+                step.depends_on = Array.from(new Set([...((_a = step.depends_on) !== null && _a !== void 0 ? _a : []), ...conditionDependencies]));
+            }
+        }
         if (this._pendingConditionFromOverride) {
             condParts.push(`(${this._pendingConditionFromOverride})`);
             this._pendingConditionFromOverride = null;
@@ -1960,21 +2033,42 @@ class RecordingContext {
             insert: async (options) => {
                 this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.DATABASE_ACTION, 'insert', {
                     database: options.database,
-                    input: { table: options.table, data: options.data },
+                    input: { table: options.table, data: options.data, returning: options.returning },
                 });
                 return createStepOutputProxy();
             },
             update: async (options) => {
                 this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.DATABASE_ACTION, 'update', {
                     database: options.database,
-                    input: { table: options.table, data: options.data, where: options.where },
+                    input: { table: options.table, data: options.data, where: options.where, returning: options.returning },
                 });
                 return createStepOutputProxy();
             },
             delete: async (options) => {
                 this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.DATABASE_ACTION, 'delete', {
                     database: options.database,
-                    input: { table: options.table, where: options.where },
+                    input: { table: options.table, where: options.where, returning: options.returning },
+                });
+                return createStepOutputProxy();
+            },
+            upsert: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.DATABASE_ACTION, 'upsert', {
+                    database: options.database,
+                    input: options,
+                });
+                return createStepOutputProxy();
+            },
+            aggregate: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.DATABASE_ACTION, 'aggregate', {
+                    database: options.database,
+                    input: options,
+                });
+                return createStepOutputProxy();
+            },
+            raw: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.DATABASE_ACTION, 'raw', {
+                    database: options.database,
+                    input: options,
                 });
                 return createStepOutputProxy();
             },
@@ -2221,18 +2315,27 @@ class RecordingContext {
         };
     }
     get transform() {
+        const operator = (value) => {
+            const converted = convertToOperatorInput(value, this._inputProxy, this._inputSchemaKeys);
+            return typeof converted === 'string' && converted.startsWith('$') ? converted : null;
+        };
+        const operand = (value) => { var _a; return (_a = operator(value)) !== null && _a !== void 0 ? _a : JSON.stringify(value); };
         return {
+            concat: (...parts) => `$Concat([${parts.map(operand).join(', ')}], "")`,
             size: (obj) => Object.keys(obj).length,
             length: (arr) => arr.length,
             parseJson: (str) => JSON.parse(str),
             stringify: (obj) => JSON.stringify(obj),
-            upper: (str) => str.toUpperCase(),
-            lower: (str) => str.toLowerCase(),
-            trim: (str) => str.trim(),
+            upper: (str) => operator(str) ? `$Uppercase(${operand(str)})` : str.toUpperCase(),
+            lower: (str) => operator(str) ? `$Lowercase(${operand(str)})` : str.toLowerCase(),
+            trim: (str) => operator(str) ? `$Trim(${operand(str)})` : str.trim(),
             split: (str, separator) => str.split(separator),
             join: (arr, separator) => arr.join(separator),
-            now: () => Date.now(),
-            formatDate: (date, format) => new Date(date).toISOString(),
+            now: () => '$Now',
+            uuid: () => '$Uuid',
+            replace: (str, search, replacement) => operator(str) ? `$Replace(${operand(str)}, ${JSON.stringify(search)}, ${JSON.stringify(replacement)})` : str.split(search).join(replacement),
+            substring: (str, start, end) => operator(str) ? `$Substring(${operand(str)}, ${start}, ${end})` : str.substring(start, end),
+            formatDate: (date, format) => operator(date) ? `$Dateformat(${operand(date)}, ${JSON.stringify(format)})` : new Date(date).toISOString(),
         };
     }
     // ==================== DATA REFERENCES ====================
@@ -2424,6 +2527,19 @@ class FeatureCompiler {
     constructor(options) {
         this.options = options;
     }
+    validatePortableControlFlow() {
+        const source = this.options.handler.toString();
+        if (/\bDate\s*\.\s*now\s*\(/.test(source) || /\bMath\s*\.\s*random\s*\(/.test(source)) {
+            throw new FeatureCompilationError(this.options.tag, '(handler)', 'Date.now() and Math.random() run while the Feature is being compiled and would become frozen literals. ' +
+                'Use ctx.transform.now() for the current runtime timestamp. Generate random or unique values through a portable function or reusable action.');
+        }
+        const containsNullishBranch = /\?\?/.test(source) ||
+            /!==\s*null\s*&&[\s\S]{0,300}!==\s*void\s+0/.test(source);
+        if (containsNullishBranch && !this.options.branchOverrides) {
+            throw new FeatureCompilationError(this.options.tag, '(handler)', 'Nullish branching on a step result cannot be inferred safely. Provide branchOverrides for the step output that records this branch, ' +
+                'or use an explicit portable branch primitive. The Feature was not persisted.');
+        }
+    }
     /**
      * Compile the feature definition to JSON schema
      * Executes the handler with a recording context to capture step definitions
@@ -2478,6 +2594,7 @@ class FeatureCompiler {
      */
     async compileAsync() {
         var _a, _b, _c, _d, _e;
+        this.validatePortableControlFlow();
         const scenarios = this.options.recordScenarios && this.options.recordScenarios.length > 0
             ? this.options.recordScenarios
             : [(_a = this.options.recordInput) !== null && _a !== void 0 ? _a : {}];