@ductape/sdk 0.1.151 → 0.1.153

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;
@@ -1725,19 +1728,28 @@ function convertToOperatorInput(value, inputProxy, schemaKeys) {
  * Recording context that captures step definitions during handler execution.
  * Uses operator strings ($Input{field}, $Sequence{main}{stepTag}{field}) per Ductape operator docs.
  */
-/** Build a step condition from a branch override so the step only runs when the overridden step's output matches (e.g. $Step{validate}{valid} == true). */
+/** Build a condition matching the concrete output used to record a branch. */
 function buildConditionFromOverride(stepTag, override) {
-    if (override === null || override === undefined)
-        return '';
-    if (typeof override !== 'object' || Array.isArray(override)) {
-        return `$Step{${stepTag}}{value} == ${JSON.stringify(override)}`;
-    }
     const parts = [];
-    for (const [key, val] of Object.entries(override)) {
-        if (typeof val !== 'object' || val === null || Array.isArray(val)) {
-            parts.push(`$Step{${stepTag}}{${key}} == ${JSON.stringify(val)}`);
+    const visit = (value, path) => {
+        const reference = `$Step{${stepTag}}{${path || 'value'}}`;
+        if (Array.isArray(value)) {
+            parts.push(`$Step{${stepTag}}{${path ? `${path}.length` : 'length'}} == ${value.length}`);
+            return;
         }
-    }
+        if (value === null || value === undefined) {
+            parts.push(`${reference} == null`);
+            return;
+        }
+        if (typeof value !== 'object') {
+            parts.push(`${reference} == ${JSON.stringify(value)}`);
+            return;
+        }
+        for (const [key, nested] of Object.entries(value)) {
+            visit(nested, path ? `${path}.${key}` : key);
+        }
+    };
+    visit(override, '');
     return parts.length === 0 ? '' : parts.join(' && ');
 }
 /** Build a step condition from a scenario (recordInput) so the step only runs when feature input matches (e.g. $Input{type} == 'a'). */
@@ -1767,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 : {};
@@ -1818,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();
@@ -1880,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;
@@ -2212,18 +2294,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 ====================
@@ -2415,6 +2506,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
@@ -2469,6 +2573,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 : {}];