@ductape/sdk 0.0.4-v43 → 0.0.4-v45

package/dist/processor/services/processor.service.js

@@ -59,9 +59,7 @@ const handlebars_1 = require("handlebars");
 const functions_utils_1 = require("../../products/services/utils/functions.utils");
 const string_utils_1 = require("../../products/services/utils/string.utils");
 const create_productFeature_validator_1 = require("../../products/validators/joi-validators/create.productFeature.validator");
-const validators_1 = require("../../products/validators");
 const uuid_1 = require("uuid");
-const urls_1 = require("../../api/urls");
 //import { createBrokerService } from './messagebrokers';
 const date_fns_1 = require("date-fns");
 const mongo_repo_1 = require("../repos/mongo.repo");
@@ -292,94 +290,6 @@ class ProcessorService {
             throw new Error("Invalid/Expired token");
         }
     }
-    async registerWebhook(data) {
-        const { product: product_tag, access_tag, webhook_tag, envs } = data;
-        await this.productBuilderService.initializeProductByTag(product_tag);
-        const { version, envs: appEnvs } = await this.productBuilderService.fetchApp(access_tag);
-        const app = await this.productBuilderService.fetchThirdPartyAppByAccessTag(access_tag);
-        const { webhooks } = app.versions.find((data) => data.tag === version);
-        if (!webhooks) {
-            throw new Error(`Webhooks not found for app ${access_tag}`);
-        }
-        await validators_1.RegisterWebhookEnvSchema.validateAsync(envs);
-        const webhook = webhooks.find((data) => data.tag === webhook_tag);
-        if (!webhook) {
-            throw new Error(`Webhook tag ${webhook_tag} not found`);
-        }
-        const productEnvs = await this.productBuilderService.fetchEnvs();
-        productEnvs.map((env) => {
-            const exists = envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
-            if (exists === -1) {
-                throw new Error(`Product env ${env.slug} is not defined, please provide connection details`);
-            }
-        });
-        const dataArray = await Promise.all(envs.map(async (env) => {
-            await this.validateActionDataMappingInput(env.auth, types_1.WebhookEventTypes.WEBHOOK_REGISTER);
-            const productEnvData = productEnvs.find((data) => data.slug === env.slug);
-            if (!productEnvData) {
-                throw new Error(`Error finding product env ${env.slug}`);
-            }
-            const envData = productEnvData.envs.find((productEnvMap) => productEnvMap.product_env_slug === env.slug);
-            if (!envData) {
-                throw new Error(`Error finding env data for ${env.slug}`);
-            }
-            const { app_env_slug: appEnv, product_env_slug: productEnv } = envData;
-            const envWebhookData = webhook.envs.find((webhookEnv) => webhookEnv.slug === appEnv);
-            if (!envWebhookData) {
-                throw new Error(`Error finding webhook registration sample ${webhook_tag} for  env ${env.slug}`);
-            }
-            const uuid = (0, uuid_1.v4)();
-            const url = `${urls_1.WEBHOOK_BASE_URL}/webhooks/v1/process/${uuid}`;
-            let active = false;
-            if (envWebhookData.sample) {
-                const samples = {
-                    query: envWebhookData.sample_data.filter((data) => data.parent_key === 'query'),
-                    params: envWebhookData.sample_data.filter((data) => data.parent_key === 'params'),
-                    body: envWebhookData.sample_data.filter((data) => data.parent_key === 'body'),
-                    headers: envWebhookData.sample_data.filter((data) => data.parent_key === 'headers'),
-                };
-                let payload = (await this.constructJSONDataPayloads(env.auth, {}, samples, {
-                    app: access_tag,
-                    event: '',
-                    input: env.auth,
-                    type: types_1.FeatureEventTypes.ACTION,
-                    retries: 0,
-                    allow_fail: false,
-                }));
-                const { updatedObj, replacedUrl } = (0, processor_utils_1.updateUrlsInObject)(payload, url);
-                if (replacedUrl && replacedUrl !== env.url && replacedUrl) {
-                    throw new Error(`Ductape expects the url ${replacedUrl} in request body to match inputted url ${env.url}`);
-                }
-                const exists = await this.fetchEnv(env.slug, {});
-                if (!exists) {
-                    throw new Error(`Env ${env.slug} does not exist`);
-                }
-                payload = updatedObj;
-                if (!replacedUrl) {
-                    payload.body.url = url;
-                }
-                const parsedUrl = new URL(envWebhookData.registration_url);
-                await this.sendActionRequest(parsedUrl.origin, parsedUrl.pathname, payload, envWebhookData.method, env.slug);
-                active = true;
-            }
-            return {
-                appEnv,
-                productEnv,
-                uuid,
-                url: env.url,
-                method: env.method,
-                access_tag,
-                webhook_tag,
-                version,
-                sender_workspace_id: app.workspace_id,
-                receiver_workspace_id: this.getUserAccess().workspace_id,
-                app_tag: app.tag,
-                product_tag,
-                active,
-            };
-        }));
-        await this.webhookApi.registerWebhooks(dataArray, this.getUserAccess());
-    }
     async generateWebhookLink(data) {
         const { product: product_tag, access_tag, webhook_tag, env: product_env, url, method } = data;
         await this.productBuilderService.initializeProductByTag(product_tag);