@ductape/sdk 0.0.3-beta8 → 0.0.4

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

@@ -40,16 +40,18 @@ const update_productNotificationMessage_validator_1 = __importDefault(require(".
 const create_productNotification_validator_1 = require("../validators/joi-validators/create.productNotification.validator");
 const functions_utils_1 = require("../utils/functions.utils");
 const objects_utils_2 = require("../../apps/utils/objects.utils");
+const webhooksApi_service_1 = require("../../api/services/webhooksApi.service");
 class ProductsBuilderService {
-    constructor({ workspace_id, public_key, user_id, token, env_type }) {
+    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client }) {
         this.workspace_id = workspace_id;
         this.public_key = public_key;
         this.user_id = user_id;
         this.token = token;
-        this.userApi = new userApi_service_1.UserApiService(env_type);
-        this.productApi = new productsApi_service_1.ProductsApiService(env_type);
-        this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService(env_type);
-        this.appApi = new appApi_service_1.AppApiService(env_type);
+        this.userApi = new userApi_service_1.UserApiService(env_type, redis_client);
+        this.productApi = new productsApi_service_1.ProductsApiService(env_type, redis_client);
+        this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService(env_type, redis_client);
+        this.webhooksApi = new webhooksApi_service_1.WebhooksApiService(env_type);
+        this.appApi = new appApi_service_1.AppApiService(env_type, redis_client);
         this.inputsService = new inputs_service_1.default();
         this.thirdPartyApps = [];
     }
@@ -190,6 +192,59 @@ class ProductsBuilderService {
         }
         return this.product;
     }
+    async createSession(data) {
+        try {
+            // TODO: figure out a way to check if this has run before, halt if it has
+            if (!this.fetchSession(data.tag)) {
+                await validators_1.CreateProductSessionSchema.validateAsync(data);
+                data.schema_data = (await this.inputsService.parseJson({
+                    data: data.schema,
+                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
+                    category: enums_1.Categories.DATA,
+                }));
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+                await this.initializeProduct(this.product_id);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateSession(tag, data) {
+        try {
+            const auth = this.fetchSession(tag);
+            if (!auth) {
+                throw new Error(`Session ${tag} not found`);
+            }
+            //const { _id } = auth;
+            await validators_1.UpdateProductSessionSchema.validateAsync(data); // Change to update;
+            if (data.tag && this.fetchEnv(data.tag) && data.tag !== tag) {
+                throw new Error(`tag ${data.tag} is in use`); // TODO: also check on the backend
+            }
+            if (!data.tag) {
+                data.tag = tag;
+            }
+            if (data.schema) {
+                data.schema_data = (await this.inputsService.parseJson({
+                    data: data.schema,
+                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
+                    category: enums_1.Categories.DATA,
+                }));
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, Object.assign(Object.assign({}, auth), data)), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+            await this.initializeProduct(this.product_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchSession(tag) {
+        var _a;
+        return (_a = this.product.sessions) === null || _a === void 0 ? void 0 : _a.find((auth) => auth.tag === tag);
+    }
+    fetchSessions() {
+        return this.product.sessions;
+    }
     async createMessageBrokerTopic(data, throwErrorIfExists = false) {
         try {
             if (!data.tag) {
@@ -277,15 +332,15 @@ class ProductsBuilderService {
             throw new Error(`Message Broker ${messageBrokerTag} not found`);
         return messageBroker.topics;
     }
-    async validateQuotaFallbackInputAndOutput(data) {
+    async validateQuotaFallbackInputAndOutput(data, type) {
         const input = data.input;
         await Promise.all(data.options.map(async (d, index) => {
-            await this.validateQuotaFallbackInput(d, input);
+            await this.validateQuotaFallbackInput(d, input, type);
             const pastOutput = index > 0 ? data.options[index - 1].output : null;
-            await this.validateQuotaFallbackOutput(d, pastOutput, input);
+            await this.validateQuotaFallbackOutput(d, pastOutput, input, type);
         }));
     }
-    async validateQuotaFallbackInput(option, input) {
+    async validateQuotaFallbackInput(option, input, type) {
         if (option.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
             const _a = await this.fetchThirdPartyAppByAccessTag(option.app), { version } = _a, appData = __rest(_a, ["version"]);
             if (!appData) {
@@ -297,55 +352,170 @@ class ProductsBuilderService {
             if (!appData) {
                 throw new Error(`Action ${option.event} not found in ${option.app} version ${version}`);
             }
-            await this.validateActionDataInput({ input }, action, option.input, 0, 0);
+            //await this.validateActionDataInput({ input }, action, option.input, 0, 0);
+            // const keyValues = traverseObject(input.option);
+            //query
+            this.checkActionQuotaFallbackInput(action.query, option.input.query, input, 'query');
+            //headers
+            this.checkActionQuotaFallbackInput(action.headers, option.input.headers, input, 'headers');
+            // params
+            this.checkActionQuotaFallbackInput(action.params, option.input.params, input, 'params');
+            //body
+            this.checkActionQuotaFallbackInput(action.body, option.input.body, input, 'body');
         }
         else {
             const feature = this.fetchFeature(option.event);
             if (!feature) {
                 throw new Error(`Feature ${option.event} not found`);
             }
-            (0, objects_utils_2.validateObjectKeys)(feature.input, option.input);
-            const keyValues = (0, objects_utils_1.traverseObject)(option.input);
+            const map = (0, functions_utils_1.convertInputToValueMap)(feature.input);
+            (0, objects_utils_2.validateObjectKeys)(map, option.input, '', 'option input', 'feature input definition');
+        }
+        const keyValues = (0, objects_utils_1.traverseObject)(option.input);
+        this.checkKeyValuesInput(keyValues, input, type);
+        this.isQuotaFallbackInput = false;
+    }
+    checkKeyValuesInput(keyValues, input, type) {
+        for (let keyValue of keyValues) {
+            const { key, value } = keyValue;
+            if (!String(value).startsWith('$')) {
+            }
+            else if (String(value).startsWith('$Auth{')) {
+                // TODO: validate auth input later
+            }
+            else if (String(value).startsWith('$') && !String(value).startsWith('$Input{')) {
+                this.checkFuncArgsForInputs(String(value).trim(), input, type);
+            }
+            else if (!String(value).startsWith('$Input{')) {
+                throw new Error(`Feature input ${value} is invalid, all feature Inputs are expected to start with $Input{}`);
+            }
+            else {
+                this.checkInput(String(value).trim(), input, type);
+            }
+        }
+    }
+    checkActionQuotaFallbackInput(sample, obj, featureInput, type) {
+        const data = (0, objects_utils_1.traverseObject)(obj);
+        //compare obj keys to sample keys
+        (0, objects_utils_2.validateObjectKeys)(sample.sample ? JSON.parse(String(sample.sample)) : {}, obj, '', `action ${type} input`, `action ${type} input sample`);
+        // check if values in data can be found inside featureInput
+        this.checkKeyValuesInput(data, featureInput, type);
+    }
+    checkFuncArgsForInputs(value, input, type) {
+        const isFunc = (0, functions_utils_1.startsWithFunctionAndEndsWithParen)(value);
+        if (!isFunc) {
+            throw new Error(`Invalid function call ${value}`);
+        }
+        const funcArgs = (0, functions_utils_1.extractFunctionAndArgs)(value);
+        if (funcArgs && funcArgs.args.length) {
+            funcArgs.args.map((arg) => {
+                const args = arg.trim().split(',');
+                args.map((argz) => {
+                    const arg = argz.trim();
+                    if (arg.startsWith('$') && !arg.startsWith('$Input{')) {
+                        this.checkFuncArgsForInputs(arg, input, type);
+                    }
+                    else if (arg.startsWith('$Input{')) {
+                        this.checkInput(arg, input, type);
+                    }
+                });
+            });
+        }
+    }
+    checkInput(value, input, type) {
+        const stages = this.extractStages(value);
+        if (stages.length > 1) {
+            throw new Error(`Invalid input ${value}, nested locators not allowed in $Input`);
+        }
+        if (!input[stages[0]]) {
+            throw new Error(`${value} not found in ${type} input definition`);
+        }
+    }
+    async validateQuotaFallbackOutput(option, pastResponse, input, type) {
+        if (pastResponse) {
+            (0, objects_utils_2.validateObjectKeys)(option.output, pastResponse, `previous outputs`, `${option.event} ${type} output`);
+        }
+        if (option.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+            const _a = await this.fetchThirdPartyAppByAccessTag(option.app), { version } = _a, appData = __rest(_a, ["version"]);
+            if (!appData) {
+                throw new Error(`App ${option.app} not found`);
+            }
+            const { actions } = appData.versions.find((data) => data.tag === version);
+            const action = actions.find((data) => data.tag === option.event);
+            if (!appData) {
+                throw new Error(`Action ${event} not found in ${option.app} version ${version}`);
+            }
+            const response = action.responses.find((item) => item.success === true);
+            // fetch success result
+            if (!response) {
+                throw new Error(`event ${event} does not have a success response`);
+            }
+            // validate that each output item starts with response or Input and then validate the stages are valid;
+        }
+        else {
+            // fetch feature
+            const feature = 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('$Input{')) {
-                    //throw new Error(`Feature input ${value} is invalid, all feature Inputs are expected to start with $Input{}`);
+                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);
                 }
             }
         }
-        this.isQuotaFallbackInput = false;
+        // validate that each response matches the expected format
+        /**await this.validateActionResponse(response, res)*/
     }
-    async validateQuotaFallbackOutput(
-    /*app: string,
-    event: string,
-    response: Record<string, unknown>,
-    input: Record<string, IFeatureInput>,*/
-    option, pastResponse, input) {
-        /*const { version, ...appData } = await this.fetchThirdPartyAppByAccessTag(option.app);
-    
-        if (!appData) {
-          throw new Error(`App ${option.app} not found`);
-        }
-    
-        const { actions } = appData.versions.find((data) => data.tag === version);
-    
-        const action = actions.find((data) => data.tag === option.event);
-    
-        if (!appData) {
-          throw new Error(`Action ${event} not found in ${option.app} version ${version}`);
+    checkFuncArgsForResponse(value, output, input, type) {
+        const isFunc = (0, functions_utils_1.startsWithFunctionAndEndsWithParen)(value);
+        if (!isFunc) {
+            throw new Error(`Invalid function call ${value}`);
         }
-        if (pastResponse) {
-          validateObjectKeys(response, pastResponse);
+        const funcArgs = (0, functions_utils_1.extractFunctionAndArgs)(value);
+        if (funcArgs && funcArgs.args.length) {
+            funcArgs.args.map((arg) => {
+                const args = arg.trim().split(',');
+                args.map((argz) => {
+                    const arg = argz.trim();
+                    if (arg.startsWith('$') && !arg.startsWith('$Response{') && !arg.startsWith('$Input{')) {
+                        this.checkFuncArgsForResponse(arg, output, input, type);
+                    }
+                    else if (arg.startsWith('$Response{')) {
+                        this.checkResponse(arg, output, input, type);
+                    }
+                    else if (arg.startsWith('$Input{')) {
+                        this.checkInput(arg, input, type);
+                    }
+                });
+            });
         }
-    
-        const res = action.responses.find((item) => item.success === true);
-        // fetch success result
-    
-        if (!res) {
-          throw new Error(`event ${event} does not have a success response`);
+    }
+    checkResponse(value, output, input, type) {
+        const stages = this.extractStages(value);
+        let current = output;
+        for (const stage of stages) {
+            if (current && typeof current === 'object' && stage in current) {
+                current = current[stage];
+            }
+            else {
+                throw new Error(`${value} not found in ${type} response definition`);
+            }
         }
-    
-        await this.validateActionResponse(response, res)*/
     }
     async createQuota(data) {
         try {
@@ -354,27 +524,32 @@ class ProductsBuilderService {
             }
             if (!this.fetchQuota(data.tag)) {
                 await validators_1.CreateProductQuotaSchema.validateAsync(data);
-                await this.validateQuotaFallbackInputAndOutput(data);
+                await this.validateQuotaFallbackInputAndOutput(data, 'quota');
                 data.total_quota = 0;
                 data.total_init = 0;
                 await Promise.all(data.options.map(async (d) => {
                     data.total_quota += d.quota;
-                    const app = await this.fetchThirdPartyAppByAccessTag(d.app);
-                    if (!app) {
-                        throw new Error(`App with access tag ${d.app} not found`);
-                    }
-                    const version = app.versions.find((version) => version.tag === app.version);
-                    const action = version.actions.find((action) => action.tag === d.event);
-                    if (!action) {
-                        throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`);
-                    }
-                    if (d.healthcheck) {
-                        const action = version.actions.find((action) => action.tag === d.healthcheck);
-                        if (!d.check_interval) {
-                            d.check_interval = 10000;
+                    if (d.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+                        const app = await this.fetchThirdPartyAppByAccessTag(d.app);
+                        if (!app) {
+                            throw new Error(`App with access tag ${d.app} not found`);
                         }
+                        const version = app.versions.find((version) => version.tag === app.version);
+                        const action = version.actions.find((action) => action.tag === d.event);
                         if (!action) {
-                            throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
+                            throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`);
+                        }
+                        if (d.healthcheck) {
+                            const action = version.actions.find((action) => action.tag === d.healthcheck);
+                            if (!d.check_interval) {
+                                d.check_interval = 10000;
+                            }
+                            if (!action) {
+                                throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
+                            }
+                            if (action.headers.data.length > 0 || action.body.data.length > 0 || action.params.data.length > 0 || action.query.data.length > 0) {
+                                throw new Error('Healthcheck action is expected to have no headers, body, params or query');
+                            }
                         }
                     }
                     d.last_checked = new Date();
@@ -383,15 +558,61 @@ class ProductsBuilderService {
                 }));
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.QUOTA, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
             }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateQuota(tag, data) {
+        try {
+            const quota = this.fetchQuota(tag);
+            if (quota) {
+                await validators_1.UpdateProductQuotaSchema.validateAsync(data);
+                if (data.options) {
+                    await this.validateQuotaFallbackInputAndOutput(data, 'quota');
+                    data.total_quota = 0;
+                    data.total_init = 0;
+                    data.tag = tag;
+                    await Promise.all(data.options.map(async (d) => {
+                        data.total_quota += d.quota;
+                        if (d.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+                            const app = await this.fetchThirdPartyAppByAccessTag(d.app);
+                            if (!app) {
+                                throw new Error(`App with access tag ${d.app} not found`);
+                            }
+                            const version = app.versions.find((version) => version.tag === app.version);
+                            const action = version.actions.find((action) => action.tag === d.event);
+                            if (!action) {
+                                throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`);
+                            }
+                            if (d.healthcheck) {
+                                const action = version.actions.find((action) => action.tag === d.healthcheck);
+                                if (!d.check_interval) {
+                                    d.check_interval = 10000;
+                                }
+                                if (!action) {
+                                    throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
+                                }
+                                if (action.headers.data.length > 0 || action.body.data.length > 0 || action.params.data.length > 0 || action.query.data.length > 0) {
+                                    throw new Error('Healthcheck action is expected to have no headers, body, params or query');
+                                }
+                            }
+                        }
+                        d.last_checked = new Date();
+                        d.provider_status = productsBuilder_types_1.ProviderStatus.AVAILABLE;
+                        d.last_available = true;
+                    }));
+                }
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({}, quota), data), { component: enums_1.ProductComponents.QUOTA, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+            }
             else {
-                throw new Error(`Quota with tag ${data.tag} already exists`);
+                throw new Error(`Quota with tag ${data.tag} not found`);
             }
         }
         catch (e) {
             throw e;
         }
     }
-    async updateQuota(tag, data) { }
     fetchQuota(tag) {
         return this.fetchQuotas().find((data) => data.tag === tag);
     }
@@ -403,26 +624,31 @@ class ProductsBuilderService {
             if (!data.tag) {
                 throw new Error('tag field is required');
             }
-            if (!this.fetchQuota(data.tag)) {
+            if (!this.fetchFallback(data.tag)) {
                 await validators_1.CreateProductFallbackSchema.validateAsync(data);
-                await this.validateQuotaFallbackInputAndOutput(data);
+                await this.validateQuotaFallbackInputAndOutput(data, 'fallback');
                 await Promise.all(data.options.map(async (d) => {
-                    const app = await this.fetchThirdPartyAppByAccessTag(d.app);
-                    if (!app) {
-                        throw new Error(`App with access tag ${d.app} not found`);
-                    }
-                    const version = app.versions.find((version) => version.tag === app.version);
-                    const action = version.actions.find((action) => action.tag === d.event);
-                    if (!action) {
-                        throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`);
-                    }
-                    if (d.healthcheck) {
-                        const action = version.actions.find((action) => action.tag === d.healthcheck);
-                        if (!d.check_interval) {
-                            d.check_interval = 10000;
+                    if (d.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+                        const app = await this.fetchThirdPartyAppByAccessTag(d.app);
+                        if (!app) {
+                            throw new Error(`App with access tag ${d.app} not found`);
                         }
+                        const version = app.versions.find((version) => version.tag === app.version);
+                        const action = version.actions.find((action) => action.tag === d.event);
                         if (!action) {
-                            throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
+                            throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`);
+                        }
+                        if (d.healthcheck) {
+                            const action = version.actions.find((action) => action.tag === d.healthcheck);
+                            if (!d.check_interval) {
+                                d.check_interval = 10000;
+                            }
+                            if (!action) {
+                                throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
+                            }
+                            if (action.headers.data.length > 0 || action.body.data.length > 0 || action.params.data.length > 0 || action.query.data.length > 0) {
+                                throw new Error('Healthcheck action is expected to have no headers, body, params or query');
+                            }
                         }
                     }
                     d.last_checked = new Date();
@@ -431,83 +657,57 @@ class ProductsBuilderService {
                 }));
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.FALLBACK, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
             }
-            else {
-                throw new Error(`Quota with tag ${data.tag} already exists`);
-            }
         }
         catch (e) {
             throw e;
         }
     }
     async updateFallback(tag, data) {
-        /*try {
-    
-          if (!data.tag) {
-            throw new Error('tag field is required');
-          }
-    
-          if (this.fetchQuota(tag)) {
-    
-            if(data.tag && tag !== data.tag && this.fetchFallback(data.tag)) {
-              throw new Error(`Fallback with new tag ${data.tag} already exists`)
+        try {
+            const fallback = this.fetchFallback(tag);
+            if (fallback) {
+                await validators_1.UpdateProductFallbackSchema.validateAsync(data);
+                if (data.options) {
+                    await this.validateQuotaFallbackInputAndOutput(data, 'fallback');
+                    data.tag = tag;
+                    await Promise.all(data.options.map(async (d) => {
+                        if (d.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+                            const app = await this.fetchThirdPartyAppByAccessTag(d.app);
+                            if (!app) {
+                                throw new Error(`App with access tag ${d.app} not found`);
+                            }
+                            const version = app.versions.find((version) => version.tag === app.version);
+                            const action = version.actions.find((action) => action.tag === d.event);
+                            if (!action) {
+                                throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`);
+                            }
+                            if (d.healthcheck) {
+                                const action = version.actions.find((action) => action.tag === d.healthcheck);
+                                if (!d.check_interval) {
+                                    d.check_interval = 10000;
+                                }
+                                if (!action) {
+                                    throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
+                                }
+                                if (action.headers.data.length > 0 || action.body.data.length > 0 || action.params.data.length > 0 || action.query.data.length > 0) {
+                                    throw new Error('Healthcheck action is expected to have no headers, body, params or query');
+                                }
+                            }
+                        }
+                        d.last_checked = new Date();
+                        d.provider_status = productsBuilder_types_1.ProviderStatus.AVAILABLE;
+                        d.last_available = true;
+                    }));
+                }
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({}, fallback), data), { component: enums_1.ProductComponents.FALLBACK, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
             }
-    
-            if(!data.tag) {
-              data.tag = tag;
+            else {
+                throw new Error(`Fallback with tag ${data.tag} not found`);
             }
-    
-            await UpdateProductFallbackSchema.validateAsync(data);
-    
-            await this.validateQuotaFallbackInputAndOutput(data);
-    
-            await Promise.all(data.options.map(async (d) => {
-    
-              const app = await this.fetchThirdPartyAppByAccessTag(d.app);
-    
-              if (!app) {
-                throw new Error(`App with access tag ${d.app} not found`)
-              }
-    
-              const version = app.versions.find((version) => version.tag === app.version);
-              const action = version.actions.find((action) => action.tag === d.event)
-    
-              if (!action) {
-                throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`)
-              }
-    
-              if (d.healthcheck) {
-                const action = version.actions.find((action) => action.tag === d.healthcheck)
-    
-                if (!d.check_interval) {
-                  d.check_interval = 10000;
-                }
-    
-                if (!action) {
-                  throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`)
-                }
-              }
-    
-              d.last_checked = new Date();
-              d.provider_status = ProviderStatus.AVAILABLE;
-              d.last_available = true;
-            }))
-    
-            await this.productApi.updateProduct(
-              this.product_id,
-              {
-                ...data,
-                component: ProductComponents.FALLBACK,
-              },
-              this.getUserAccess(),
-            );
-    
-          } else {
-            throw new Error(`Quota with tag ${data.tag} already exists`)
-          }
-    
-        } catch (e) {
-          throw e;
-        }*/
+        }
+        catch (e) {
+            throw e;
+        }
     }
     fetchFallback(tag) {
         return this.fetchFallbacks().find((data) => data.tag === tag);
@@ -960,6 +1160,8 @@ class ProductsBuilderService {
                 throw new Error(`App with access tag ${access_tag} not found`);
             }
             const version = app.versions.find((version) => version.tag === app.version);
+            const status = await this.webhooksApi.fetchWebhooks({ access_tag, app_tag: app.tag, version: app.version }, this.getUserAccess());
+            console.log(status);
             if (!version) {
                 throw new Error(`Required app version not found`);
             }
@@ -1206,7 +1408,7 @@ class ProductsBuilderService {
         if (!notificationTag || !messageTag) {
             throw new Error(`tag is expected to be defined as "notification_tag:message_tag"`);
         }
-        const notification = this.product.notifications.find((data) => data.tag === notificationTag);
+        const notification = this.fetchNotification(notificationTag);
         if (!notification)
             throw new Error(`Notification ${notificationTag} not found`);
         const message = notification.messages.find((data) => data.tag === messageTag);