@ductape/sdk 0.1.110 → 0.1.114

package/dist/features/features.service.js

@@ -43,9 +43,11 @@ var __importStar = (this && this.__importStar) || (function () {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.featureService = exports.FeatureService = exports.FeatureError = void 0;
+exports.featureService = exports.FeatureCompilationError = exports.FeatureService = exports.FeatureError = void 0;
 const crypto_1 = require("crypto");
+const functions_1 = require("../functions");
 const products_service_1 = __importDefault(require("../products/services/products.service"));
 const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
 const featureApi_service_1 = require("../api/services/featureApi.service");
@@ -55,6 +57,15 @@ const processor_utils_1 = require("../processor/utils/processor.utils");
 const cache_manager_1 = require("../cache/cache.manager");
 const productsBuilder_types_1 = require("../types/productsBuilder.types");
 const feature_executor_1 = require("./feature-executor");
+// Feature compilation/execution used to emit dozens of synchronous console writes
+// on every request. Preserve the diagnostic stream behind DUCTAPE_DEBUG without
+// charging production feature latency for formatting and stdout I/O.
+const featureDebugEnabled = typeof process !== 'undefined' && (((_a = process.env) === null || _a === void 0 ? void 0 : _a.DUCTAPE_DEBUG) === 'true' || ((_b = process.env) === null || _b === void 0 ? void 0 : _b.DUCTAPE_DEBUG) === '1');
+const console = {
+    log: featureDebugEnabled ? globalThis.console.log.bind(globalThis.console) : (..._args) => { },
+    warn: globalThis.console.warn.bind(globalThis.console),
+    error: globalThis.console.error.bind(globalThis.console),
+};
 /**
  * Error class for feature-related errors
  */
@@ -189,6 +200,7 @@ class FeatureService {
             user_id: this.config.user_id,
             token: this.config.token,
             env_type: this.config.env_type,
+            redis_client: this.config.redis_client,
             access_key: this.config.access_key,
             workspace_private_key: this._privateKey || undefined,
         });
@@ -302,7 +314,7 @@ class FeatureService {
         // Persist to backend using ProductBuilder
         const builder = await this.getProductBuilder(productTag);
         console.log('[FeatureService] create calling builder.createFeature', { tag: featureData.tag });
-        await builder.createFeature(featureData);
+        const persisted = await builder.createFeature(featureData);
         // Store locally
         const localConfig = {
             name: featureData.name,
@@ -318,6 +330,12 @@ class FeatureService {
         };
         this.localConfigs.set(featureData.tag, localConfig);
         console.log('[FeatureService] create SUCCESS', { productTag, tag: featureData.tag });
+        return persisted;
+    }
+    /** True only when the remote catalogue read path can observe the feature. */
+    async exists(featureTag, productTag) {
+        const builder = await this.getProductBuilder(productTag);
+        return Boolean(await builder.fetchFeature(featureTag));
     }
     /**
      * Fetch all features for a product
@@ -479,7 +497,16 @@ class FeatureService {
         // If product is specified, create the feature
         if (options.product) {
             console.log('[FeatureService] define creating feature on backend', { product: options.product, tag: schema.tag });
-            await this.create(options.product, schema);
+            const builder = await this.getProductBuilder(options.product);
+            const existing = await builder.fetchFeature(schema.tag);
+            if (existing)
+                await builder.updateFeature(schema.tag, schema);
+            else
+                await builder.createFeature(schema, true);
+            const persisted = await builder.fetchFeature(schema.tag);
+            if (!persisted) {
+                throw new FeatureError(`Feature ${schema.tag} was acknowledged but is absent from the catalogue read path`, 'FEATURE_CATALOGUE_INCONSISTENT');
+            }
         }
         // Store locally
         const localConfig = {
@@ -505,6 +532,56 @@ class FeatureService {
             schema,
         };
     }
+    /** Compile several definitions without performing any remote writes. */
+    async compileMany(definitions) {
+        const tags = definitions.map((definition) => definition.tag);
+        const duplicate = tags.find((tag, index) => tags.indexOf(tag) !== index);
+        if (duplicate)
+            throw FeatureError.validationError(`Duplicate feature tag in batch: ${duplicate}`);
+        return Promise.all(definitions.map((definition) => new FeatureCompiler(definition).compileAsync()));
+    }
+    /**
+     * Publish a definition set with read-back verification. If a write fails, newly
+     * created records are removed and pre-existing records are restored.
+     */
+    async publishMany(productTag, definitions, options = {}) {
+        const schemas = await this.compileMany(definitions);
+        if (options.dryRun)
+            return { product: productTag, dry_run: true, features: schemas };
+        const builder = await this.getProductBuilder(productTag);
+        const previous = new Map();
+        const changed = [];
+        try {
+            for (const schema of schemas) {
+                const existing = await builder.fetchFeature(schema.tag);
+                previous.set(schema.tag, existing);
+                if (existing)
+                    await builder.updateFeature(schema.tag, schema);
+                else
+                    await builder.createFeature(schema, true);
+                const readBack = await builder.fetchFeature(schema.tag);
+                if (!readBack)
+                    throw new Error(`Feature ${schema.tag} is missing after publish`);
+                changed.push(schema.tag);
+            }
+            return { product: productTag, dry_run: false, features: schemas };
+        }
+        catch (error) {
+            for (const tag of changed.reverse()) {
+                const old = previous.get(tag);
+                try {
+                    if (old)
+                        await builder.updateFeature(tag, old);
+                    else
+                        await builder.deleteFeature(tag);
+                }
+                catch (rollbackError) {
+                    console.error('[Ductape] Feature batch rollback failed', { product: productTag, tag, rollbackError });
+                }
+            }
+            throw error;
+        }
+    }
     // ==================== WORKFLOW EXECUTION ====================
     /**
      * Execute a feature
@@ -1512,25 +1589,6 @@ function buildConditionFromScenario(scenario) {
     }
     return parts.length === 0 ? '' : parts.join(' && ');
 }
-/** Create ctx.input that prefers recordInput values (for loops/switch) and falls back to $Input{field} for other keys. */
-function createHybridInputProxy(recordInput, inputProxy) {
-    const base = recordInput !== null && recordInput !== void 0 ? recordInput : {};
-    if (!inputProxy)
-        return base;
-    return new Proxy(base, {
-        get(target, prop) {
-            if (typeof prop !== 'string')
-                return target[prop];
-            if (prop in target && target[prop] !== undefined) {
-                return target[prop];
-            }
-            return inputProxy[prop];
-        },
-        has(target, prop) {
-            return prop in target || (inputProxy && prop in inputProxy);
-        },
-    });
-}
 class RecordingContext {
     constructor(_input, featureTag, featureInputSchema, stepResultOverrides, scenarioCondition, recordInput) {
         this._steps = [];
@@ -1548,7 +1606,6 @@ 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;
-        this._hybridInput = null;
         this._featureTag = featureTag;
         this._inputSchemaKeys = featureInputSchema ? Object.keys(featureInputSchema) : [];
         this._stepResultOverrides = stepResultOverrides !== null && stepResultOverrides !== void 0 ? stepResultOverrides : {};
@@ -1557,12 +1614,17 @@ class RecordingContext {
         if (this._inputSchemaKeys.length > 0) {
             this._inputProxy = createInputProxy(this._inputSchemaKeys);
         }
-        this._hybridInput = createHybridInputProxy(this._recordInput, this._inputProxy);
     }
-    // Readonly feature metadata — prefer recordInput for control flow (loops, switch), fall back to $Input{field}
+    // Runtime input is always represented by operators. Sample recording data must
+    // never be allowed to become a production step literal.
     get input() {
-        var _a, _b;
-        return ((_b = (_a = this._hybridInput) !== null && _a !== void 0 ? _a : this._inputProxy) !== null && _b !== void 0 ? _b : {});
+        var _a;
+        return ((_a = this._inputProxy) !== null && _a !== void 0 ? _a : {});
+    }
+    // Explicit compile-time data for loops and branch discovery.
+    get sampleInput() {
+        var _a;
+        return ((_a = this._recordInput) !== null && _a !== void 0 ? _a : {});
     }
     get feature_id() {
         return `compile-${this._featureTag}`;
@@ -1617,10 +1679,15 @@ class RecordingContext {
         try {
             stepReturn = await handler();
         }
-        catch (e) {
-            // Ignore errors during compilation - we're just tracing
+        catch (error) {
+            throw new FeatureCompilationError(this._featureTag, tag, `The step callback threw while compiling: ${error instanceof Error ? error.message : String(error)}. ` +
+                'Feature callbacks may only use serializable ctx primitives or ctx.functions.');
         }
         this._pendingStep = null;
+        if (!step.event) {
+            throw new FeatureCompilationError(this._featureTag, tag, 'The step did not record a portable operation. Arbitrary application callbacks cannot be serialized. ' +
+                'Use ctx.functions, ctx.action, ctx.database, ctx.events, ctx.storage, ctx.graph, ctx.vector, ctx.quota, or ctx.fallback.');
+        }
         // Parse and store step output in schema (operator strings for downstream $Step{tag}{field} references)
         const valueToCapture = stepReturn !== undefined && stepReturn !== null && typeof stepReturn === 'object' && !Array.isArray(stepReturn)
             ? stepReturn.output !== undefined && stepReturn.process_id !== undefined
@@ -1899,6 +1966,27 @@ class RecordingContext {
             },
         };
     }
+    get functions() {
+        const invoke = async (contract, operation, input) => {
+            const reference = (0, functions_1.referenceFromContract)(contract, operation);
+            this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.FUNCTION, operation, {
+                function_ref: reference,
+                input,
+                options: { timeout: reference.timeout_ms },
+            });
+            return createStepOutputProxy();
+        };
+        return {
+            invoke,
+            use: (contract) => new Proxy({}, {
+                get: (_target, property) => {
+                    if (typeof property !== 'string' || !(property in contract.operations))
+                        return undefined;
+                    return (input) => invoke(contract, property, input);
+                },
+            }),
+        };
+    }
     get transform() {
         return {
             size: (obj) => Object.keys(obj).length,
@@ -2032,6 +2120,8 @@ class RecordingContext {
             step.fallback = data.fallback;
         if (data.feature)
             step.feature = data.feature;
+        if (data.function_ref)
+            step.function_ref = data.function_ref;
         if (data.input) {
             step.input = convertToOperatorInput(data.input, this._inputProxy, this._inputSchemaKeys);
         }
@@ -2150,7 +2240,7 @@ class FeatureCompiler {
      * With recordInput, uses that as ctx.input so loops and control flow see real values.
      */
     async compileAsync() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         const scenarios = this.options.recordScenarios && this.options.recordScenarios.length > 0
             ? this.options.recordScenarios
             : [(_a = this.options.recordInput) !== null && _a !== void 0 ? _a : {}];
@@ -2173,7 +2263,11 @@ class FeatureCompiler {
                 if (out !== undefined && out !== null)
                     handlerOutput = out;
             }
-            catch (_) { }
+            catch (error) {
+                if (error instanceof FeatureCompilationError)
+                    throw error;
+                throw new FeatureCompilationError(this.options.tag, (_c = recordingCtx.current_step) !== null && _c !== void 0 ? _c : '(handler)', error instanceof Error ? error.message : String(error));
+            }
             for (const s of recordingCtx.getSteps()) {
                 const existing = stepsByTag.get(s.tag);
                 if (existing) {
@@ -2193,12 +2287,12 @@ class FeatureCompiler {
         const finalSteps = stepOrder.map((tag) => stepsByTag.get(tag)).filter(Boolean);
         const output = handlerOutput !== undefined && handlerOutput !== null && lastCtx
             ? lastCtx.captureOutput(handlerOutput)
-            : ((_c = this.options.output) !== null && _c !== void 0 ? _c : {});
+            : ((_d = this.options.output) !== null && _d !== void 0 ? _d : {});
         return {
             name: this.options.name,
             tag: this.options.tag,
             description: this.options.description,
-            input: (_d = this.options.input) !== null && _d !== void 0 ? _d : {},
+            input: (_e = this.options.input) !== null && _e !== void 0 ? _e : {},
             output: output,
             steps: finalSteps,
             signals: this.options.signals
@@ -2218,6 +2312,15 @@ class FeatureCompiler {
         };
     }
 }
+class FeatureCompilationError extends Error {
+    constructor(featureTag, stepTag, message) {
+        super(`Feature "${featureTag}", step "${stepTag}": ${message}`);
+        this.featureTag = featureTag;
+        this.stepTag = stepTag;
+        this.name = 'FeatureCompilationError';
+    }
+}
+exports.FeatureCompilationError = FeatureCompilationError;
 // Export singleton instance for convenience
 exports.featureService = new FeatureService();
 // Default export