@ductape/sdk 0.1.25 → 0.1.27

package/dist/products/services/products.service.js

@@ -265,10 +265,10 @@ class ProductsBuilderService {
             option.check_interval = 10000;
         }
     }
-    /** Validate a quota/fallback action provider (app action or product workflow). */
+    /** Validate a quota/fallback action provider (app action or product feature). */
     async validateQuotaFallbackProvider(option) {
         var _a;
-        if (option.type !== productsBuilder_types_1.FeatureEventTypes.ACTION)
+        if (option.type !== productsBuilder_types_1.StepEventTypes.ACTION)
             return;
         if ((_a = option.app) === null || _a === void 0 ? void 0 : _a.trim()) {
             const app = await this.fetchThirdPartyAppByAccessTag(option.app);
@@ -282,9 +282,9 @@ class ProductsBuilderService {
             }
         }
         else {
-            const workflow = await this.fetchWorkflow(option.event);
-            if (!workflow) {
-                throw new Error(`Workflow ${option.event} not found on product`);
+            const feature = await this.fetchFeature(option.event);
+            if (!feature) {
+                throw new Error(`Feature  not found on product`);
             }
         }
         if (option.healthcheck) {
@@ -309,7 +309,7 @@ class ProductsBuilderService {
     /**
      * Create a healthcheck from a schema (e.g. from resilience health.define/create).
      * Persists as product component so processor healthcheck workers and health.list/fetch see it.
-     * Env inputs (probe/action/workflow input) are encrypted with the product private key using
+     * Env inputs (probe/action/feature input) are encrypted with the product private key using
      * SHA-256 key derivation + AES (see processor.utils encrypt/decrypt).
      */
     async createHealthcheckFromSchema(schema) {
@@ -372,13 +372,13 @@ class ProductsBuilderService {
         let size = 2;
         let data;
         switch (type) {
-            case productsBuilder_types_1.FeatureEventTypes.DB_ACTION:
+            case productsBuilder_types_1.StepEventTypes.DB_ACTION:
                 const action = await this.fetchDatabaseAction(tag);
                 if (!action)
                     throw new Error(`DB Action ${tag} not found`);
                 data = useData ? action.data : action.filterData;
                 break;
-            case productsBuilder_types_1.FeatureEventTypes.NOTIFICATION:
+            case productsBuilder_types_1.StepEventTypes.NOTIFICATION:
                 size = 3;
                 const stage3Str = String(stages[3]);
                 if (!stages[3] || (stage3Str !== 'push' && stage3Str !== 'callback' && stage3Str !== 'email')) {
@@ -400,8 +400,8 @@ class ProductsBuilderService {
             default:
                 throw new Error(`Type ${type} not handled`);
         }
-        if (selector.startsWith('$Filter') && type !== productsBuilder_types_1.FeatureEventTypes.DB_ACTION) {
-            throw new Error(`Filter cannot be used for ${type} in ${selector} only usable in ${productsBuilder_types_1.FeatureEventTypes.DB_ACTION}`);
+        if (selector.startsWith('$Filter') && type !== productsBuilder_types_1.StepEventTypes.DB_ACTION) {
+            throw new Error(`Filter cannot be used for ${type} in ${selector} only usable in ${productsBuilder_types_1.StepEventTypes.DB_ACTION}`);
         }
         const selectorArray = stages.slice(size);
         let parent_key = '';
@@ -607,13 +607,13 @@ class ProductsBuilderService {
         }
     }
     /**
-     * Bootstrap workflow - fetch all action/notification/storage data for multiple steps in one API call
+     * Bootstrap feature - fetch all action/notification/storage data for multiple steps in one API call
      */
-    async bootstrapWorkflow(params) {
+    async bootstrapFeature(params) {
         try {
             const auth = this.getUserAccess();
-            return await this.cachedBootstrap('workflow', [params.product_tag, params.env_slug, (0, bootstrap_cache_1.hashWorkflowSteps)(params.steps)], async () => {
-                const result = await this.productApi.bootstrapWorkflow(Object.assign(Object.assign({}, params), { workspace_id: auth.workspace_id }), auth);
+            return await this.cachedBootstrap('workflow', [params.product_tag, params.env_slug, (0, bootstrap_cache_1.hashFeatureSteps)(params.steps)], async () => {
+                const result = await this.productApi.bootstrapFeature(Object.assign(Object.assign({}, params), { workspace_id: auth.workspace_id }), auth);
                 if (result && typeof result === 'object') {
                     for (const stepTag of Object.keys(result)) {
                         const data = result[stepTag];
@@ -1007,7 +1007,7 @@ class ProductsBuilderService {
         }));
     }
     async validateQuotaFallbackInput(option, input, type) {
-        if (option.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+        if (option.type === productsBuilder_types_1.StepEventTypes.ACTION) {
             const _a = await this.fetchThirdPartyAppByAccessTag(option.app), { version } = _a, appData = __rest(_a, ["version"]);
             if (!appData) {
                 throw new Error(`App ${option.app} not found`);
@@ -1030,12 +1030,7 @@ class ProductsBuilderService {
             this.checkActionQuotaFallbackInput(action.body, option.input.body, input, 'body');
         }
         else {
-            const feature = await this.fetchFeature(option.event);
-            if (!feature) {
-                throw new Error(`Feature ${option.event} not found`);
-            }
-            const map = (0, functions_utils_1.convertInputToValueMap)(feature.input);
-            (0, objects_utils_2.validateObjectKeys)(map, option.input, '', 'option input', 'feature input definition');
+            throw new Error(`Unsupported quota/fallback option type for event ${option.event}: only ${productsBuilder_types_1.StepEventTypes.ACTION} is supported`);
         }
         const keyValues = (0, objects_utils_1.traverseObject)(option.input);
         this.checkKeyValuesInput(keyValues, input, type);
@@ -1101,7 +1096,7 @@ class ProductsBuilderService {
         if (pastResponse) {
             (0, objects_utils_2.validateObjectKeys)(option.output, pastResponse, `previous outputs`, `${option.event} ${type} output`);
         }
-        if (option.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+        if (option.type === productsBuilder_types_1.StepEventTypes.ACTION) {
             const _a = await this.fetchThirdPartyAppByAccessTag(option.app), { version } = _a, appData = __rest(_a, ["version"]);
             if (!appData) {
                 throw new Error(`App ${option.app} not found`);
@@ -1119,30 +1114,7 @@ class ProductsBuilderService {
             // validate that each output item starts with response or Input and then validate the stages are valid;
         }
         else {
-            // fetch feature
-            const feature = await this.fetchFeature(option.event);
-            if (!feature) {
-                throw new Error(`Feature ${option.event} not found`);
-            }
-            const { output } = feature;
-            const keyValues = (0, objects_utils_1.traverseObject)(option.output);
-            for (let keyValue of keyValues) {
-                const { key, value } = keyValue;
-                if (!value.startsWith('$')) {
-                }
-                else if (value.startsWith('$') && !value.startsWith('$Response{') && !value.startsWith('$Input')) {
-                    this.checkFuncArgsForResponse(value.trim(), output, input, type);
-                }
-                else if (!value.startsWith('$Response{') && !value.startsWith('$Input{')) {
-                    throw new Error(`Feature output ${value} is invalid, all feature outputs for ${type} are expected to start with $Response or $Input{}`);
-                }
-                else if (value.startsWith('$Response')) {
-                    this.checkResponse(value.trim(), output, input, type);
-                }
-                else if (value.startsWith('$Input')) {
-                    this.checkInput(value, input, type);
-                }
-            }
+            throw new Error(`Unsupported quota/fallback option type for event ${option.event}: only ${productsBuilder_types_1.StepEventTypes.ACTION} is supported`);
         }
         // validate that each response matches the expected format
         /**await this.validateActionResponse(response, res)*/
@@ -3279,71 +3251,6 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    validateFeatureSequence(array) {
-        // Validate uniqueness of sequence_tag
-        const uniqueTags = new Set();
-        for (const item of array) {
-            if (uniqueTags.has(item.tag)) {
-                throw new Error(`Duplicate sequence_tag found: ${item.tag}`);
-            }
-            uniqueTags.add(item.tag);
-        }
-        // Validate levels are in order starting from 0
-        /*let expectedLevel = 0;
-            for (const item of array) {
-                if (item.level !== expectedLevel) {
-                    throw new Error(`Invalid level found: expected ${expectedLevel}, found ${item.level}`);
-                }
-                expectedLevel++;
-            }*/
-    }
-    validateUniqueEventTags(data) {
-        // TODO: this might not be necessary o
-        const eventTagsSet = new Set(); // TODO: this might have to be moved to line 658
-        data.sequence.forEach((sequence) => {
-            sequence.events.forEach((data) => {
-                const { event } = data;
-                if (eventTagsSet.has(event)) {
-                    throw new Error(`Duplicate event_tag found: ${event}`);
-                }
-                eventTagsSet.add(event);
-            });
-        });
-    }
-    async validateFeatureData(data) {
-        const { sequence } = data;
-        this.validateUniqueEventTags(data); // TODO: this might be unnecessary
-        this.validateFeatureSequence(sequence);
-        const promises = sequence.map((obj, sequence_index) => {
-            const { events, parents } = obj;
-            if (parents && parents.length) {
-                this.validateSequenceParents(parents, sequence_index, sequence);
-            }
-            return Promise.all(events.map((event, event_index) => this.validateEvent(data, sequence_index, event, event_index)));
-        });
-        const results = await Promise.allSettled(promises.flat());
-        const errors = results
-            .filter((result) => result.status === 'rejected')
-            .map((result) => result.reason);
-        if (errors.length > 0) {
-            //throw new Error(`Validation errors: ${errors.join(', ')}`);
-            errors.map((error) => {
-                //console.log(error);
-                throw error;
-            });
-        }
-    }
-    validateSequenceParents(parents, sequence_index, sequence) {
-        const map = new Map();
-        for (let i = 0; i < sequence_index; i++) {
-            map.set(sequence[i].tag, i);
-        }
-        for (let i = 0; i < parents.length; i++) {
-            if (map.get(parents[i]) === undefined) {
-                throw new Error(`Invalid parent ${parents[i]} in sequence ${sequence[sequence_index].tag}, parents have to be declared before their children`);
-            }
-        }
-    }
     validateSequenceInputParents(parent, sequence_index, sequence) {
         let found = false;
         const parents = sequence[sequence_index].parents;
@@ -3356,112 +3263,6 @@ class ProductsBuilderService {
         if (!found)
             throw new Error(`Parents array needs to contain parent sequence ${parent} in ${sequence[sequence_index].tag}`);
     }
-    async checkAndValidateActionDataInput(data, sequence_index, event, event_index) {
-        /*const application = this.fetchThirdPartyAppByAccessTag(event.a)
-    
-        if (!application) {
-          throw new Error(`App ${event.app} does not exist`);
-        }
-    
-        const { version, ...app } = application;
-        const { access_tag } = app;*/
-        // validate action_tag
-        const app = await this.fetchThirdPartyAppByAccessTag(event.app);
-        const { versions, version } = app;
-        const versionExists = versions.find((data) => data.tag === version);
-        if (!versionExists) {
-            throw new Error(`Version ${version} does not exist on app ${event.app}`);
-        }
-        const { actions } = versionExists;
-        const action = this.fetchThirdPartyAppActionByTag(actions, event.event);
-        await this.validateActionDataInput(data, action, event.input, event_index, sequence_index);
-    }
-    async checkAndValidateFunctionDataInput(data, sequence_index, event, event_index) {
-        const func = (await this.fetchFunction(event.event));
-        await this.validateActionDataInput(data, func, event.input, event_index, sequence_index);
-    }
-    async checkAndValidateDBActionDataInput(data, sequence_index, event, event_index) {
-        console.log('EVENTY', event.event);
-        const { filterData, data: dbData, filterTemplate, template } = await this.fetchDatabaseAction(event.event);
-        await this.validateDBActionDataInput(data, { filterData, data: dbData, template, filter: filterTemplate }, event.input, event_index, sequence_index);
-    }
-    async checkAndValidateFeatureDataInput(data, sequence_index, event, event_index) {
-        const feature = await this.fetchFeature(event.event);
-        if (!feature)
-            throw new Error(`Feature ${event.event} not found`);
-        const { input } = feature;
-        await this.validateFeatureDataInput(data, input, event.input, event_index, sequence_index);
-    }
-    async checkAndValidateNotificationDataInput(data, sequence_index, event, event_index) {
-        const { callback_data: callback, push_notification_data: notification, email_data: email, sms_data: sms, } = await this.fetchNotificationMessage(event.event);
-        await this.validateNotificationDataInput(data, { callback, notification, email, sms }, event.input, event_index, sequence_index);
-    }
-    async checkAndValidatePublishDataInput(data, sequence_index, event, event_index) {
-        const topic = await this.fetchMessageBrokerTopic(event.event);
-        if (!topic) {
-            throw new Error(`Topic ${event.event} not registered`);
-        }
-        const { data: topicData } = topic;
-        //await this.validatePublishTopicDataInput(data, { data: topicData }, event.input, event_index, sequence_index)
-    }
-    async checkAndValidateStorageDataInput(data, sequence_index, event, event_index) {
-        const storage = await this.fetchStorage(event.event);
-        if (!storage) {
-            throw new Error(`Storage ${event.event} does not exist`);
-        }
-        //await this.validateStorageDataInput(data, {}, event.input, event_index, sequence_index);
-    }
-    async checkAndValidateJobDataInput(data, sequence_index, event, event_index) {
-        const job = await this.fetchJob(event.event);
-        if (job.type === productsBuilder_types_1.JobEventTypes.ACTION) {
-            await this.checkAndValidateActionDataInput(data, sequence_index, event, event_index);
-        }
-        if (job.type === productsBuilder_types_1.JobEventTypes.DATABASE_ACTION) {
-            await this.checkAndValidateDBActionDataInput(data, sequence_index, event, event_index);
-        }
-        if (job.type === productsBuilder_types_1.JobEventTypes.NOTIFICATION) {
-            await this.checkAndValidateNotificationDataInput(data, sequence_index, event, event_index);
-        }
-        if (job.type === productsBuilder_types_1.JobEventTypes.STORAGE) {
-            await this.checkAndValidateStorageDataInput(data, sequence_index, event, event_index);
-        }
-        if (job.type === productsBuilder_types_1.JobEventTypes.PUBLISH) {
-            await this.checkAndValidatePublishDataInput(data, sequence_index, event, event_index);
-        }
-    }
-    async checkAndValidateFallbackDataInput(data, sequence_index, event, event_index) { }
-    async validateEvent(data, sequence_index, event, event_index) {
-        this.validateConditional(event, data, sequence_index, event_index);
-        if (event.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
-            await this.checkAndValidateActionDataInput(data, sequence_index, event, event_index);
-            // validate input
-        }
-        if (event.type === productsBuilder_types_1.FeatureEventTypes.DB_ACTION) {
-            await this.checkAndValidateDBActionDataInput(data, sequence_index, event, event_index);
-        }
-        if (event.type === productsBuilder_types_1.FeatureEventTypes.FEATURE) {
-            await this.checkAndValidateFeatureDataInput(data, sequence_index, event, event_index);
-        }
-        if (event.type === productsBuilder_types_1.FeatureEventTypes.NOTIFICATION) {
-            await this.checkAndValidateNotificationDataInput(data, sequence_index, event, event_index);
-        }
-        if (event.type === productsBuilder_types_1.FeatureEventTypes.PUBLISH) {
-            await this.checkAndValidatePublishDataInput(data, sequence_index, event, event_index);
-        }
-        /*if (event.type === FeatureEventTypes.SUBSCRIBE) {
-          const topic = await this.fetchMessageBrokerTopic(event.event);
-    
-          if(!topic) {
-            throw new Error(`Topic ${event.event} not registered`);
-          }
-        }*/
-        if (event.type === productsBuilder_types_1.FeatureEventTypes.STORAGE) {
-            await this.checkAndValidateStorageDataInput(data, sequence_index, event, event_index);
-        }
-        if (event.type === productsBuilder_types_1.FeatureEventTypes.JOB) {
-            await this.checkAndValidateJobDataInput(data, sequence_index, event, event_index);
-        }
-    }
     async validateDBActionDataInput(data, action, event_input, event_index, sequence_index) {
         // const {data: dataInput, filter: filter} = event_input;
         const indexes = {
@@ -3489,9 +3290,6 @@ class ProductsBuilderService {
             indexes: indexes,
         }, true);
     }
-    async validateFeatureDataInput(data, featureInput, input, event_index, sequence_index) {
-        (0, processor_utils_1.validateFeatureJSONInput)(input, featureInput);
-    }
     async validateNotificationDataInput(data, action, event_input, event_index, sequence_index) {
         // const {data: dataInput, filter: filter} = event_input;
         const indexes = {
@@ -3738,93 +3536,6 @@ class ProductsBuilderService {
             index++;
         }
     }
-    validateConditional(event, feature, sequence_index, event_index) {
-        const sequence = feature.sequence[sequence_index];
-        const input = feature.input;
-        const { condition } = event;
-        // Define valid operators
-        // Check if condition exists
-        if (condition && condition.check) {
-            // Split the check into parts: initiator, operator, and value
-            const parts = (0, string_utils_1.extractConditionalParts)(condition.check);
-            if (!parts) {
-                throw new Error(`event ${event.event} in ${sequence.tag} has an invalid check format. 
-          Ensure it follows the pattern: initiator operator value (e.g., $Index < 10)
-          Valid operators are: ${productsBuilder_types_1.ValidOperators.join(', ')}`);
-            }
-            const [, initiator, operator, value] = parts;
-            if (condition.type === productsBuilder_types_1.Conditions.LOOP && initiator !== '$Index') {
-                throw new Error(`invalid index ${initiator} in event ${event.event} in ${sequence.tag}, loop indexes are expected to be defined as $Index`);
-            }
-            // Validate operator
-            if (!productsBuilder_types_1.ValidOperators.includes(operator)) {
-                throw new Error(`event ${event.event} in ${sequence.tag} has an invalid operator "${operator}" for "${condition.type}" condition
-          Valid operators are: ${productsBuilder_types_1.ValidOperators.join(', ')}`);
-            }
-            if (condition.type === productsBuilder_types_1.Conditions.LOOP && condition.iter) {
-                // check if value is an integer
-                throw new Error(`event ${event.event} in ${sequence.tag} has an invalid loop iter "${condition.iter}" is expected to be an integer .`);
-            }
-            // check if value is an integer
-            if (condition.type === productsBuilder_types_1.Conditions.LOOP && condition.init && !Number.isInteger(condition.init)) {
-                throw new Error(`event ${event.event} in ${sequence.tag} has an invalid loop init "${condition.init}" is expected to be an integer .`);
-            }
-            // check if value is not numeric but points towards a value
-            if (condition.type === productsBuilder_types_1.Conditions.LOOP && !(0, string_utils_1.isNumeric)(value)) {
-                //console.log(1, value);
-                if (!value.startsWith('$')) {
-                    throw new Error(`event ${event.event} in ${sequence.tag} has an invalid operator "${operator}".`);
-                }
-                const payload = {
-                    datapoint: {
-                        key: 'condition-value',
-                        required: true,
-                        maxLength: 0,
-                        minLength: 0,
-                        type: enums_1.DataTypes.INTEGER, // value is expected to be a number
-                    },
-                    value,
-                    input: input,
-                    stages: this.extractStages(value),
-                };
-                const meta = { compare: true, feature, sequence_index, event_index, type: enums_1.Categories.CONDITIONAL };
-                this.parseInputString(payload, meta);
-            }
-            if (condition.type === productsBuilder_types_1.Conditions.CHECK) {
-                this.parseInputString({
-                    datapoint: {
-                        key: 'condition-initiator',
-                        required: true,
-                        maxLength: 0,
-                        minLength: 0,
-                        type: enums_1.DataTypes.STRING,
-                    },
-                    value: initiator,
-                    input: input,
-                    stages: this.extractStages(initiator),
-                }, { compare: false, feature, sequence_index, event_index, type: enums_1.Categories.CONDITIONAL });
-                //console.log(2, value);
-                if (value.startsWith('$')) {
-                    this.parseInputString({
-                        datapoint: {
-                            key: 'condition-value',
-                            required: true,
-                            maxLength: 0,
-                            minLength: 0,
-                            type: enums_1.DataTypes.STRING,
-                        },
-                        value,
-                        input: input,
-                        stages: this.extractStages(value),
-                    }, { compare: false, feature, sequence_index, event_index, type: enums_1.Categories.CONDITIONAL });
-                }
-            }
-        }
-        // Check if the condition is a CHECK and allow_fail is true
-        if (condition && condition.type === productsBuilder_types_1.Conditions.CHECK && event.allow_fail) {
-            throw new Error(`event ${event.event} cannot set allow_fail: true as it is a check conditional`);
-        }
-    }
     async parseActionEventInput(data) {
         const datapoint = this.validateActionKeyPlacement(data);
         let stages, input;
@@ -4028,7 +3739,7 @@ class ProductsBuilderService {
                         throw new Error(`event ${stage} not found in sequence ${sequence.tag}`);
                     }
                     let { type, app: access_tag, event: event_tag } = event;
-                    if (type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+                    if (type === productsBuilder_types_1.StepEventTypes.ACTION) {
                         const _b = await this.fetchThirdPartyAppByAccessTag(access_tag), { version } = _b, app = __rest(_b, ["version"]);
                         const { actions } = app.versions.find((data) => data.tag === version);
                         const { responses } = this.fetchThirdPartyAppActionByTag(actions, event_tag);
@@ -4038,13 +3749,13 @@ class ProductsBuilderService {
                             throw new Error(`event ${stage} does not have a success response`);
                         }
                     }
-                    if (type === productsBuilder_types_1.FeatureEventTypes.DB_ACTION) {
+                    if (type === productsBuilder_types_1.StepEventTypes.DB_ACTION) {
                         // TODO:
                     }
-                    if (type === productsBuilder_types_1.FeatureEventTypes.JOB) {
+                    if (type === productsBuilder_types_1.StepEventTypes.JOB) {
                         // TODO:
                     }
-                    if (type === productsBuilder_types_1.FeatureEventTypes.NOTIFICATION) {
+                    if (type === productsBuilder_types_1.StepEventTypes.NOTIFICATION) {
                         // TODO:
                     }
                     //TODO: handle other types
@@ -4312,70 +4023,6 @@ class ProductsBuilderService {
         }
         return action;
     }
-    async createFeature(data, throwErrorIfExists = false) {
-        try {
-            if (!(await this.fetchFeature(data.tag))) {
-                await validators_1.CreateProductFeatureSchema.validateAsync(data);
-                try {
-                    await this.validateFeatureData(data);
-                    await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.FEATURE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                }
-                catch (e) {
-                    throw e;
-                }
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Feature ${data.tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateFeature(tag, data) {
-        try {
-            const feature = await this.fetchFeature(tag);
-            if (!feature) {
-                throw new Error(`Feature ${tag} not found`);
-            }
-            const { _id } = feature;
-            await validators_1.UpdateProductFeatureSchema.validateAsync(data); // Change to update;
-            await this.validateFeatureData(Object.assign({ tag }, data));
-            if (data.tag && this.fetchFeature(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-            }
-            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id,
-                tag }, data), { component: enums_1.ProductComponents.FEATURE, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async fetchFeatures() {
-        const components = await this.productApi.fetchProductComponents(this.product_id, 'feature', this.getUserAccess());
-        return components;
-    }
-    async fetchFeature(tag) {
-        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'feature', tag, this.getUserAccess());
-        return component;
-    }
-    async deleteFeature(tag) {
-        try {
-            const feature = await this.fetchFeature(tag);
-            if (!feature) {
-                throw new Error(`Feature with tag: ${tag} not found`);
-            }
-            await this.productApi.updateProduct(this.product_id, {
-                tag,
-                component: enums_1.ProductComponents.FEATURE,
-                action: enums_1.RequestAction.DELETE,
-            }, this.getUserAccess());
-        }
-        catch (e) {
-            throw e;
-        }
-    }
     async createDatabase(data, throwErrorIfExists = false) {
         try {
             if (!(await this.fetchDatabase(data.tag))) {
@@ -5326,12 +4973,12 @@ class ProductsBuilderService {
         }
     }
     // ==================== WORKFLOW CRUD METHODS ====================
-    async createWorkflow(data, throwErrorIfExists = false) {
+    async createFeature(data, throwErrorIfExists = false) {
         try {
-            if (!(await this.fetchWorkflow(data.tag))) {
+            if (!(await this.fetchFeature(data.tag))) {
                 // Validate required fields
                 if (!data.name || !data.tag) {
-                    throw new Error('Workflow requires name and tag');
+                    throw new Error('Feature requires name and tag');
                 }
                 // Validate envs if provided
                 if (data.envs && data.envs.length > 0) {
@@ -5342,25 +4989,25 @@ class ProductsBuilderService {
                         }
                     }
                 }
-                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.WORKFLOW, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.FEATURE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
             }
             else {
                 if (throwErrorIfExists)
-                    throw new Error(`Workflow ${data.tag} already exists`);
+                    throw new Error(`Feature  already exists`);
             }
         }
         catch (e) {
             throw e;
         }
     }
-    async updateWorkflow(tag, data) {
+    async updateFeature(tag, data) {
         try {
-            const workflow = await this.fetchWorkflow(tag);
-            if (!workflow) {
-                throw new Error(`Workflow ${tag} not found`);
+            const feature = await this.fetchFeature(tag);
+            if (!feature) {
+                throw new Error(`Feature  not found`);
             }
-            const { _id } = workflow;
-            if (data.tag && data.tag !== tag && (await this.fetchWorkflow(data.tag))) {
+            const { _id } = feature;
+            if (data.tag && data.tag !== tag && (await this.fetchFeature(data.tag))) {
                 throw new Error(`tag ${data.tag} is in use`);
             }
             // Validate envs if provided
@@ -5372,29 +5019,29 @@ class ProductsBuilderService {
                     }
                 }
             }
-            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id }, data), { tag, component: enums_1.ProductComponents.WORKFLOW, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id }, data), { tag, component: enums_1.ProductComponents.FEATURE, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
         }
         catch (e) {
             throw e;
         }
     }
-    async fetchWorkflows() {
-        const components = await this.productApi.fetchProductComponents(this.product_id, 'workflow', this.getUserAccess());
+    async fetchFeatures() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'feature', this.getUserAccess());
         return components;
     }
-    async fetchWorkflow(tag) {
-        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'workflow', tag, this.getUserAccess());
+    async fetchFeature(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'feature', tag, this.getUserAccess());
         return component;
     }
-    async deleteWorkflow(tag) {
+    async deleteFeature(tag) {
         try {
-            const workflow = await this.fetchWorkflow(tag);
-            if (!workflow) {
-                throw new Error(`Workflow with tag: ${tag} not found`);
+            const feature = await this.fetchFeature(tag);
+            if (!feature) {
+                throw new Error(`Feature with tag:  not found`);
             }
             await this.productApi.updateProduct(this.product_id, {
                 tag,
-                component: enums_1.ProductComponents.WORKFLOW,
+                component: enums_1.ProductComponents.FEATURE,
                 action: enums_1.RequestAction.DELETE,
             }, this.getUserAccess());
         }
@@ -6179,7 +5826,7 @@ class ProductsBuilderService {
         }
     }
 }
-/** Only log when DUCTAPE_DEBUG is set (avoids sync I/O cost in workflow hot path) */
+/** Only log when DUCTAPE_DEBUG is set (avoids sync I/O cost in feature hot path) */
 ProductsBuilderService._debug = 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');
 exports.default = ProductsBuilderService;
 //# sourceMappingURL=products.service.js.map