@pinelab/vendure-plugin-webhook 0.0.3

package/README.md

@@ -0,0 +1,90 @@
+# Vendure Webhook plugin
+
+![Vendure version](https://img.shields.io/npm/dependency-version/vendure-plugin-webhook/dev/@vendure/core)
+
+Triggers an outgoing webhook based on configured events. Events are specified in `vendure-config` and webhooks are configured per
+channel via the admin UI.
+
+YOu can use this plugin for example to trigger builds when ProductEvents or CollectionEvents occur, or send notifications to external
+platforms when orders are placed by subscribing to OrderPlacedEvents!
+
+## Breaking changes since v7.x
+
+:warning: V7 of this plugin allows you to create multiple webhooks per channel for multiple different events. You have to manually recreate your webhooks after migration! (Don't forget your DB migration):
+
+- Check what URL is triggered for what event in your current environment, and note it down somewhere.
+- Install the new version, migrate, start the server, and go to `Settings > Webhook` in the Admin UI.
+- Create the hook. You can leave the `Transformer` field blank: the plugin will send an empty post without a transfomer.
+
+## Getting started
+
+1. `yarn add vendure-plugin-webhook`
+2. Add the `WebhookPlugin` to your plugins in your `vendure-config.ts`:
+
+```ts
+import { WebhookPlugin } from 'vendure-plugin-webhook';
+
+plugins: [
+  WebhookPlugin.init({
+    /**
+     * Optional: 'delay' waits and deduplicates events for 3000ms.
+     * If 4 events were fired for the same channel within 3 seconds,
+     * only 1 webhook call will be sent
+     */
+    delay: 3000,
+    events: [ProductEvent, ProductVariantEvent],
+    /**
+     * Optional: A requestTransformer allows you to send custom headers
+     * and a custom body with your webhook call.
+     * If no transformers are specified
+     */
+    requestTransformers: [],
+  }),
+  AdminUiPlugin.init({
+    port: 3002,
+    route: 'admin',
+    app: compileUiExtensions({
+      outputPath: path.join(__dirname, '__admin-ui'),
+      // Add the WebhookPlugin's UI to the admin
+      extensions: [WebhookPlugin.ui],
+    }),
+  }),
+];
+```
+
+3. Run a DB migration to create the custom entities.
+4. Start the server and assign the permission `SetWebhook` to administrators who should be able to configure webhooks.
+5. Go to `settings > webhook` to configure webhooks
+
+### Custom transformers
+
+Request transformers are used to create a custom POST body and custom headers for your outgoing webhooks. The example below stringifies the contents of a ProductEvent.
+
+```ts
+import { Logger, ProductEvent } from '@vendure/core';
+import { RequestTransformer } from 'vendure-plugin-webhook';
+
+export const stringifyProductTransformer = new RequestTransformer({
+  name: 'Stringify Product events',
+  supportedEvents: [ProductEvent],
+  transform: (event, injector) => {
+    if (event instanceof ProductEvent) {
+      return {
+        body: JSON.stringify(event),
+        headers: {
+          'x-custom-header': 'custom-example-header',
+          'content-type': 'application/json',
+        },
+      };
+    } else {
+      throw Error(`This transformer is only for ProductEvents!`);
+    }
+  },
+});
+
+// In your vendure-config's plugin array:
+WebhookPlugin.init({
+  events: [ProductEvent],
+  requestTransformers: [stringifyProductTransformer],
+});
+```

package/dist/api/api-extension.d.ts

@@ -0,0 +1 @@
+export declare const adminSchema: import("graphql").DocumentNode;

package/dist/api/api-extension.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminSchema = void 0;
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+exports.adminSchema = (0, graphql_tag_1.default) `
+  input WebhookInput {
+    event: String!
+    url: String!
+    transformerName: String
+  }
+
+  type Webhook {
+    id: ID!
+    event: String!
+    url: String!
+    requestTransformer: WebhookRequestTransformer
+  }
+
+  type WebhookRequestTransformer {
+    name: String!
+    supportedEvents: [String!]!
+  }
+
+  extend type Mutation {
+    """
+    Set all webhooks for the current channel. This will overwrite any existing webhooks.
+    """
+    setWebhooks(webhooks: [WebhookInput!]!): [Webhook!]!
+  }
+
+  extend type Query {
+    """
+    Get all webhooks for the current channel
+    """
+    webhooks: [Webhook!]!
+    """
+    Get all available Vendure events that can be used to trigger webhooks
+    """
+    availableWebhookEvents: [String!]!
+    """
+    "
+    Get all available webhook request transformers
+    """
+    availableWebhookRequestTransformers: [WebhookRequestTransformer!]!
+  }
+`;

package/dist/api/request-transformer.d.ts

@@ -0,0 +1,23 @@
+import { Injector, RequestContext, Type, VendureEvent } from '@vendure/core';
+export type TransformFn<T extends EventWithContext> = (event: T, injector: Injector) => WebhookRequest | Promise<WebhookRequest>;
+export type EventWithContext = VendureEvent & {
+    ctx: RequestContext;
+};
+export interface WebhookRequest {
+    body?: ArrayBuffer | ArrayBufferView | string;
+    headers?: Record<string, string>;
+}
+export declare class RequestTransformer<T extends Array<Type<EventWithContext>>> {
+    private readonly options;
+    readonly name: string;
+    readonly supportedEvents: T;
+    readonly transform: TransformFn<EventWithContext>;
+    constructor(options: {
+        name: string;
+        /**
+         * The events that this transformer supports
+         */
+        supportedEvents: T;
+        transform: TransformFn<EventWithContext>;
+    });
+}

package/dist/api/request-transformer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestTransformer = void 0;
+class RequestTransformer {
+    constructor(options) {
+        this.options = options;
+        this.name = options.name;
+        this.supportedEvents = options.supportedEvents;
+        this.transform = options.transform;
+    }
+}
+exports.RequestTransformer = RequestTransformer;

package/dist/api/webhook.entity.d.ts

@@ -0,0 +1,12 @@
+import { DeepPartial, VendureEntity } from '@vendure/core';
+/**
+ * Each `Webhook` entity represents 1 webhook call for the specified
+ * Event with the specified Url and Transformer
+ */
+export declare class Webhook extends VendureEntity {
+    constructor(input?: DeepPartial<Webhook>);
+    channelId: string;
+    url: string;
+    event: string;
+    transformerName?: string;
+}

package/dist/api/webhook.entity.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhook = void 0;
+const typeorm_1 = require("typeorm");
+const core_1 = require("@vendure/core");
+/**
+ * Each `Webhook` entity represents 1 webhook call for the specified
+ * Event with the specified Url and Transformer
+ */
+let Webhook = class Webhook extends core_1.VendureEntity {
+    constructor(input) {
+        super(input);
+    }
+};
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], Webhook.prototype, "channelId", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], Webhook.prototype, "url", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], Webhook.prototype, "event", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], Webhook.prototype, "transformerName", void 0);
+Webhook = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [Object])
+], Webhook);
+exports.Webhook = Webhook;

package/dist/api/webhook.resolver.d.ts

@@ -0,0 +1,26 @@
+import { PermissionDefinition, RequestContext } from '@vendure/core';
+import { WebhookService } from './webhook.service';
+import { Webhook, WebhookInput, WebhookRequestTransformer } from '../generated/graphql-types';
+import { Webhook as WebhookEntity } from './webhook.entity';
+import { RequestTransformer } from './request-transformer';
+export declare const webhookPermission: PermissionDefinition;
+/**
+ * Graphql resolvers for retrieving and updating webhook for channel
+ */
+export declare class WebhookResolver {
+    private webhookService;
+    constructor(webhookService: WebhookService);
+    setWebhooks(ctx: RequestContext, webhooks: WebhookInput[]): Promise<Webhook[]>;
+    webhooks(ctx: RequestContext): Promise<Webhook[]>;
+    availableWebhookEvents(): Promise<string[]>;
+    availableWebhookRequestTransformers(): Promise<WebhookRequestTransformer[]>;
+}
+export declare class WebhookRequestTransformerResolver {
+    private webhookService;
+    constructor(webhookService: WebhookService);
+    /**
+     * Resolve `webhook.transformerName` to the actual RequestTransformer object
+     */
+    requestTransformer(ctx: RequestContext, webhook: WebhookEntity): Promise<WebhookRequestTransformer | undefined>;
+}
+export declare function mapToGraphqlTransformer(transformer: RequestTransformer<any>): WebhookRequestTransformer;

package/dist/api/webhook.resolver.js

@@ -0,0 +1,121 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToGraphqlTransformer = exports.WebhookRequestTransformerResolver = exports.WebhookResolver = exports.webhookPermission = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const webhook_service_1 = require("./webhook.service");
+const webhook_entity_1 = require("./webhook.entity");
+// Permission needs to be defined first
+exports.webhookPermission = new core_1.PermissionDefinition({
+    name: 'SetWebhook',
+    description: 'Allows setting a webhook URL',
+});
+/**
+ * Graphql resolvers for retrieving and updating webhook for channel
+ */
+let WebhookResolver = class WebhookResolver {
+    constructor(webhookService) {
+        this.webhookService = webhookService;
+    }
+    async setWebhooks(ctx, webhooks) {
+        return this.webhookService.saveWebhooks(ctx, webhooks);
+    }
+    async webhooks(ctx) {
+        return this.webhookService.getAllWebhooks(ctx);
+    }
+    async availableWebhookEvents() {
+        return this.webhookService.getAvailableEvents();
+    }
+    async availableWebhookRequestTransformers() {
+        const transformers = this.webhookService.getAvailableTransformers();
+        return transformers.map(mapToGraphqlTransformer);
+    }
+};
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(exports.webhookPermission.Permission),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('webhooks')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Array]),
+    __metadata("design:returntype", Promise)
+], WebhookResolver.prototype, "setWebhooks", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(exports.webhookPermission.Permission),
+    __param(0, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], WebhookResolver.prototype, "webhooks", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(exports.webhookPermission.Permission),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WebhookResolver.prototype, "availableWebhookEvents", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(exports.webhookPermission.Permission),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WebhookResolver.prototype, "availableWebhookRequestTransformers", null);
+WebhookResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [webhook_service_1.WebhookService])
+], WebhookResolver);
+exports.WebhookResolver = WebhookResolver;
+let WebhookRequestTransformerResolver = class WebhookRequestTransformerResolver {
+    constructor(webhookService) {
+        this.webhookService = webhookService;
+    }
+    /**
+     * Resolve `webhook.transformerName` to the actual RequestTransformer object
+     */
+    async requestTransformer(ctx, webhook) {
+        if (!webhook.transformerName) {
+            return;
+        }
+        const transformers = this.webhookService.getAvailableTransformers();
+        const transformer = transformers.find((t) => t.name === webhook.transformerName);
+        if (!transformer) {
+            return;
+        }
+        return mapToGraphqlTransformer(transformer);
+    }
+};
+__decorate([
+    (0, graphql_1.ResolveField)(),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Parent)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext,
+        webhook_entity_1.Webhook]),
+    __metadata("design:returntype", Promise)
+], WebhookRequestTransformerResolver.prototype, "requestTransformer", null);
+WebhookRequestTransformerResolver = __decorate([
+    (0, graphql_1.Resolver)('Webhook'),
+    __metadata("design:paramtypes", [webhook_service_1.WebhookService])
+], WebhookRequestTransformerResolver);
+exports.WebhookRequestTransformerResolver = WebhookRequestTransformerResolver;
+function mapToGraphqlTransformer(transformer) {
+    return {
+        name: transformer.name,
+        supportedEvents: transformer.supportedEvents.map((event) => event.name),
+    };
+}
+exports.mapToGraphqlTransformer = mapToGraphqlTransformer;

package/dist/api/webhook.service.d.ts

@@ -0,0 +1,61 @@
+import { OnApplicationBootstrap } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { EventBus, ID, RequestContext, TransactionalConnection } from '@vendure/core';
+import { Webhook } from './webhook.entity';
+import { EventWithContext, RequestTransformer } from './request-transformer';
+import { WebhookPluginOptions } from '../webhook.plugin';
+import { WebhookInput } from '../generated/graphql-types';
+/**
+ * Service for updating and retrieving webhooks from db
+ */
+export declare class WebhookService implements OnApplicationBootstrap {
+    private eventBus;
+    private connection;
+    private moduleRef;
+    private options;
+    /**
+     * A queue of unique webhooks to call. This is used to prevent
+     * multiple calls to the same webhook for the same
+     * event within the configured `delay` time
+     */
+    webhookQueue: Map<ID, Webhook>;
+    constructor(eventBus: EventBus, connection: TransactionalConnection, moduleRef: ModuleRef, options: WebhookPluginOptions);
+    /**
+     * Subscribe to events specified in config
+     */
+    onApplicationBootstrap(): Promise<void>;
+    /**
+     * Get the plugin's configured Events.
+     */
+    getAvailableEvents(): string[];
+    /**
+     * Get the plugin's configured Request Transformers.
+     */
+    getAvailableTransformers(): RequestTransformer<any>[];
+    /**
+     * Get all configured webhooks for current channel
+     */
+    getAllWebhooks(ctx: RequestContext): Promise<Webhook[]>;
+    /**
+     * Get configured webhooks for given Event
+     */
+    getWebhooksForEvent<T extends EventWithContext>(event: T): Promise<Webhook[]>;
+    /**
+     * Save set of webhooks for current channel.
+     * Overrides any previously set hooks
+     */
+    saveWebhooks(ctx: RequestContext, inputs: WebhookInput[]): Promise<Webhook[]>;
+    /**
+     * Push the webhooks for the given Event to the queue,
+     * so they can be processed in batch
+     */
+    addWebhookToQueue(event: EventWithContext): Promise<void>;
+    /**
+     * Process all webhooks currently in the queue
+     */
+    processQueue(event: EventWithContext): Promise<void>;
+    /**
+     * Call the actual webhook with the configured Transformer for given Event
+     */
+    callWebhook(webhook: Webhook, event: EventWithContext): Promise<void>;
+}

package/dist/api/webhook.service.js

@@ -0,0 +1,182 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const core_2 = require("@vendure/core");
+const webhook_entity_1 = require("./webhook.entity");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const constants_1 = require("../constants");
+/**
+ * Service for updating and retrieving webhooks from db
+ */
+let WebhookService = class WebhookService {
+    constructor(eventBus, connection, moduleRef, options) {
+        this.eventBus = eventBus;
+        this.connection = connection;
+        this.moduleRef = moduleRef;
+        this.options = options;
+        /**
+         * A queue of unique webhooks to call. This is used to prevent
+         * multiple calls to the same webhook for the same
+         * event within the configured `delay` time
+         */
+        this.webhookQueue = new Map();
+    }
+    /**
+     * Subscribe to events specified in config
+     */
+    async onApplicationBootstrap() {
+        if (!this.options.events || this.options.events.length === 0) {
+            throw Error(`Please specify VendureEvents with Webhook.init() to use this plugin.`);
+        }
+        if (this.options.disabled) {
+            core_2.Logger.info(`Webhook plugin disabled,not listening for events`, constants_1.loggerCtx);
+            return;
+        }
+        // Subscribe to all configured events
+        this.options.events.forEach((configuredEvent) => {
+            this.eventBus.ofType(configuredEvent).subscribe(async (event) => {
+                try {
+                    await this.addWebhookToQueue(event);
+                    // Start processing after the given delay, because
+                    // we might get multiple of the same events within the specified delay
+                    await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+                    await this.processQueue(event);
+                }
+                catch (e) {
+                    core_2.Logger.error(`Failed to call webhook for event ${event.constructor.name} for channel ${event.ctx.channelId}: ${e}`, constants_1.loggerCtx);
+                }
+            });
+            core_2.Logger.info(`Listening for ${configuredEvent.name}`, constants_1.loggerCtx);
+        });
+    }
+    /**
+     * Get the plugin's configured Events.
+     */
+    getAvailableEvents() {
+        return this.options.events.map((eventType) => eventType.name);
+    }
+    /**
+     * Get the plugin's configured Request Transformers.
+     */
+    getAvailableTransformers() {
+        return this.options.requestTransformers || [];
+    }
+    /**
+     * Get all configured webhooks for current channel
+     */
+    async getAllWebhooks(ctx) {
+        return this.connection
+            .getRepository(ctx, webhook_entity_1.Webhook)
+            .find({ where: { channelId: String(ctx.channelId) } });
+    }
+    /**
+     * Get configured webhooks for given Event
+     */
+    async getWebhooksForEvent(event) {
+        const eventName = event.constructor.name;
+        return this.connection.getRepository(event.ctx, webhook_entity_1.Webhook).find({
+            where: { channelId: String(event.ctx.channelId), event: eventName },
+        });
+    }
+    /**
+     * Save set of webhooks for current channel.
+     * Overrides any previously set hooks
+     */
+    async saveWebhooks(ctx, inputs) {
+        const repository = this.connection.getRepository(ctx, webhook_entity_1.Webhook);
+        // Delete all current hooks
+        await repository.delete({ channelId: String(ctx.channelId) });
+        // Recreate all hooks
+        const webhooks = inputs.map((input) => ({
+            channelId: String(ctx.channelId),
+            url: input.url,
+            event: input.event,
+            transformerName: input.transformerName ?? undefined,
+        }));
+        await repository.save(webhooks);
+        return this.getAllWebhooks(ctx);
+    }
+    /**
+     * Push the webhooks for the given Event to the queue,
+     * so they can be processed in batch
+     */
+    async addWebhookToQueue(event) {
+        const webhooks = await this.getWebhooksForEvent(event);
+        webhooks.map((webhook) => {
+            this.webhookQueue.set(webhook.id, webhook);
+        });
+        if (webhooks.length > 0) {
+            core_2.Logger.info(`Added ${webhooks.length} webhooks to the webhook queue for ${event.constructor.name}`, constants_1.loggerCtx);
+        }
+    }
+    /**
+     * Process all webhooks currently in the queue
+     */
+    async processQueue(event) {
+        // Check if queue already handled
+        if (this.webhookQueue.size === 0) {
+            return;
+        }
+        // Copy queue, and empty original
+        const webhooks = [];
+        this.webhookQueue.forEach((webhook) => webhooks.push(webhook));
+        this.webhookQueue.clear();
+        // Start calling the webhooks
+        await Promise.all(webhooks.map(async (webhook) => {
+            try {
+                await this.callWebhook(webhook, event);
+            }
+            catch (e) {
+                core_2.Logger.error(`Failed to call webhook for event ${webhook.event} channel ${webhook.channelId}: ${e}`, constants_1.loggerCtx);
+            }
+        }));
+    }
+    /**
+     * Call the actual webhook with the configured Transformer for given Event
+     */
+    async callWebhook(webhook, event) {
+        if (!webhook.transformerName) {
+            // No transformer, just call webhook without body
+            await (0, node_fetch_1.default)(webhook.url, { method: 'POST' });
+            return core_2.Logger.info(`Successfully triggered webhook for event ${webhook.event} for channel ${webhook.channelId} without transformer`, constants_1.loggerCtx);
+        }
+        // Have the configured transformer construct the request
+        const transformer = this.getAvailableTransformers().find((transformer) => transformer.name === webhook.transformerName);
+        if (!transformer) {
+            throw Error(`Could not find transformer ${webhook.transformerName}`);
+        }
+        const request = await transformer.transform(event, new core_2.Injector(this.moduleRef));
+        // Call the webhook with the constructed request
+        await (0, node_fetch_1.default)(webhook.url, {
+            method: 'POST',
+            headers: request.headers,
+            body: request.body,
+        });
+        core_2.Logger.info(`Successfully triggered webhook for event ${event.constructor.name} for channel ${webhook.channelId} with transformer "${webhook.transformerName}"`, constants_1.loggerCtx);
+    }
+};
+WebhookService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Inject)(constants_1.PLUGIN_INIT_OPTIONS)),
+    __metadata("design:paramtypes", [core_2.EventBus,
+        core_2.TransactionalConnection,
+        core_1.ModuleRef, Object])
+], WebhookService);
+exports.WebhookService = WebhookService;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const loggerCtx = "WebhookPlugin";
+export declare const PLUGIN_INIT_OPTIONS: unique symbol;

package/dist/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_INIT_OPTIONS = exports.loggerCtx = void 0;
+exports.loggerCtx = 'WebhookPlugin';
+exports.PLUGIN_INIT_OPTIONS = Symbol('PLUGIN_INIT_OPTIONS');