@webiny/webhooks 6.4.0-beta.1

package/api/domain/WebhookDelivery.d.ts

@@ -0,0 +1,36 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+export type WebhookDeliveryStatus = "pending" | "delivering" | "delivered" | "failed";
+export interface WebhookDeliveryCmsEntryValues {
+    webhookId: string;
+    backgroundTaskId: string | null;
+    eventType: string;
+    status: WebhookDeliveryStatus;
+    payload: string;
+    requestHeaders: string | null;
+    responseTime: number | null;
+    responseStatus: number | null;
+    responseHeaders: string | null;
+    responseBody: string | null;
+}
+export interface WebhookDeliveryCmsEntry {
+    id: string;
+    createdOn: string;
+    savedOn: string;
+    expiresAt: string;
+    values: WebhookDeliveryCmsEntryValues;
+}
+export interface WebhookDelivery {
+    id: string;
+    createdOn: string;
+    savedOn: string;
+    webhookId: string;
+    backgroundTaskId: string | null;
+    eventType: string;
+    status: WebhookDeliveryStatus;
+    payload: GenericRecord;
+    requestHeaders: GenericRecord | null;
+    responseTime: number | null;
+    responseStatus: number | null;
+    responseHeaders: GenericRecord | null;
+    responseBody: string | null;
+}

package/api/domain/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const WEBHOOK_MODEL_ID = "webhook";
+export declare const WEBHOOK_DELIVERY_MODEL_ID = "webhookDelivery";
+export declare const SEND_WEBHOOK_TASK = "sendWebhook";
+export declare const WEBHOOK_DELIVERY_RETENTION_DAYS = 90;

package/api/domain/constants.js

@@ -0,0 +1,7 @@
+const WEBHOOK_MODEL_ID = "webhook";
+const WEBHOOK_DELIVERY_MODEL_ID = "webhookDelivery";
+const SEND_WEBHOOK_TASK = "sendWebhook";
+const WEBHOOK_DELIVERY_RETENTION_DAYS = 90;
+export { SEND_WEBHOOK_TASK, WEBHOOK_DELIVERY_MODEL_ID, WEBHOOK_DELIVERY_RETENTION_DAYS, WEBHOOK_MODEL_ID };
+
+//# sourceMappingURL=constants.js.map

package/api/domain/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/constants.js","sources":["../../../src/api/domain/constants.ts"],"sourcesContent":["export const WEBHOOK_MODEL_ID = \"webhook\";\nexport const WEBHOOK_DELIVERY_MODEL_ID = \"webhookDelivery\";\nexport const SEND_WEBHOOK_TASK = \"sendWebhook\";\nexport const WEBHOOK_DELIVERY_RETENTION_DAYS = 90;\n"],"names":["WEBHOOK_MODEL_ID","WEBHOOK_DELIVERY_MODEL_ID","SEND_WEBHOOK_TASK","WEBHOOK_DELIVERY_RETENTION_DAYS"],"mappings":"AAAO,MAAMA,mBAAmB;AACzB,MAAMC,4BAA4B;AAClC,MAAMC,oBAAoB;AAC1B,MAAMC,kCAAkC"}

package/api/domain/errors.d.ts

@@ -0,0 +1,36 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class WebhookNotFoundError extends BaseError {
+    readonly code: "WEBHOOK_NOT_FOUND";
+    constructor(id: string);
+}
+export declare class WebhookDeliveryNotFoundError extends BaseError {
+    readonly code: "WEBHOOK_DELIVERY_NOT_FOUND";
+    constructor(id: string);
+}
+export declare class WebhookValidationError extends BaseError {
+    readonly code: "WEBHOOK_VALIDATION_ERROR";
+    constructor(message: string);
+}
+interface WebhookPersistenceErrorData {
+    originalMessage: string;
+    originalCode?: string;
+    originalData?: unknown;
+}
+export declare class WebhookPersistenceError extends BaseError<WebhookPersistenceErrorData> {
+    readonly code: "WEBHOOK_PERSISTENCE_ERROR";
+    constructor(error: Error);
+    static from(error: unknown): WebhookPersistenceError;
+}
+export declare class WebhookModelNotFoundError extends BaseError {
+    readonly code: "WEBHOOK_MODEL_NOT_FOUND";
+    constructor(modelId: string);
+}
+export declare class WebhookVerificationFailedError extends BaseError {
+    readonly code: "WEBHOOK_VERIFICATION_FAILED";
+    constructor(message: string);
+}
+export declare class WebhookNotAuthorizedError extends BaseError {
+    readonly code: "WEBHOOK_NOT_AUTHORIZED";
+    constructor();
+}
+export {};

package/api/domain/errors.js

@@ -0,0 +1,70 @@
+import { BaseError } from "@webiny/feature/api";
+class WebhookNotFoundError extends BaseError {
+    constructor(id){
+        super({
+            message: `Webhook "${id}" was not found.`
+        }), this.code = "WEBHOOK_NOT_FOUND";
+    }
+}
+class WebhookDeliveryNotFoundError extends BaseError {
+    constructor(id){
+        super({
+            message: `Webhook delivery "${id}" was not found.`
+        }), this.code = "WEBHOOK_DELIVERY_NOT_FOUND";
+    }
+}
+class WebhookValidationError extends BaseError {
+    constructor(message){
+        super({
+            message
+        }), this.code = "WEBHOOK_VALIDATION_ERROR";
+    }
+}
+class WebhookPersistenceError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message,
+            data: {
+                originalMessage: error.message
+            }
+        }), this.code = "WEBHOOK_PERSISTENCE_ERROR";
+    }
+    static from(error) {
+        if (error instanceof Error) {
+            const instance = new WebhookPersistenceError(error);
+            const data = {
+                originalMessage: error.message,
+                originalCode: error.code,
+                originalData: error.data
+            };
+            instance.data = data;
+            instance.stack = error.stack;
+            return instance;
+        }
+        return new WebhookPersistenceError(new Error(String(error)));
+    }
+}
+class WebhookModelNotFoundError extends BaseError {
+    constructor(modelId){
+        super({
+            message: `Webhook model "${modelId}" was not found.`
+        }), this.code = "WEBHOOK_MODEL_NOT_FOUND";
+    }
+}
+class WebhookVerificationFailedError extends BaseError {
+    constructor(message){
+        super({
+            message
+        }), this.code = "WEBHOOK_VERIFICATION_FAILED";
+    }
+}
+class WebhookNotAuthorizedError extends BaseError {
+    constructor(){
+        super({
+            message: "Not authorized!"
+        }), this.code = "WEBHOOK_NOT_AUTHORIZED";
+    }
+}
+export { WebhookDeliveryNotFoundError, WebhookModelNotFoundError, WebhookNotAuthorizedError, WebhookNotFoundError, WebhookPersistenceError, WebhookValidationError, WebhookVerificationFailedError };
+
+//# sourceMappingURL=errors.js.map

package/api/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/errors.js","sources":["../../../src/api/domain/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class WebhookNotFoundError extends BaseError {\n    override readonly code = \"WEBHOOK_NOT_FOUND\" as const;\n\n    constructor(id: string) {\n        super({ message: `Webhook \"${id}\" was not found.` });\n    }\n}\n\nexport class WebhookDeliveryNotFoundError extends BaseError {\n    override readonly code = \"WEBHOOK_DELIVERY_NOT_FOUND\" as const;\n\n    constructor(id: string) {\n        super({ message: `Webhook delivery \"${id}\" was not found.` });\n    }\n}\n\nexport class WebhookValidationError extends BaseError {\n    override readonly code = \"WEBHOOK_VALIDATION_ERROR\" as const;\n\n    constructor(message: string) {\n        super({ message });\n    }\n}\n\ninterface WebhookPersistenceErrorData {\n    originalMessage: string;\n    originalCode?: string;\n    originalData?: unknown;\n}\n\nexport class WebhookPersistenceError extends BaseError<WebhookPersistenceErrorData> {\n    override readonly code = \"WEBHOOK_PERSISTENCE_ERROR\" as const;\n\n    constructor(error: Error) {\n        super({ message: error.message, data: { originalMessage: error.message } });\n    }\n\n    static from(error: unknown): WebhookPersistenceError {\n        if (error instanceof Error) {\n            const instance = new WebhookPersistenceError(error);\n            const data: WebhookPersistenceErrorData = {\n                originalMessage: error.message,\n                originalCode: (error as any).code,\n                originalData: (error as any).data\n            };\n            (instance as any).data = data;\n            instance.stack = error.stack;\n            return instance;\n        }\n\n        return new WebhookPersistenceError(new Error(String(error)));\n    }\n}\n\nexport class WebhookModelNotFoundError extends BaseError {\n    override readonly code = \"WEBHOOK_MODEL_NOT_FOUND\" as const;\n\n    constructor(modelId: string) {\n        super({ message: `Webhook model \"${modelId}\" was not found.` });\n    }\n}\n\nexport class WebhookVerificationFailedError extends BaseError {\n    override readonly code = \"WEBHOOK_VERIFICATION_FAILED\" as const;\n\n    constructor(message: string) {\n        super({ message });\n    }\n}\n\nexport class WebhookNotAuthorizedError extends BaseError {\n    override readonly code = \"WEBHOOK_NOT_AUTHORIZED\" as const;\n\n    constructor() {\n        super({ message: \"Not authorized!\" });\n    }\n}\n"],"names":["WebhookNotFoundError","BaseError","id","WebhookDeliveryNotFoundError","WebhookValidationError","message","WebhookPersistenceError","error","Error","instance","data","String","WebhookModelNotFoundError","modelId","WebhookVerificationFailedError","WebhookNotAuthorizedError"],"mappings":";AAEO,MAAMA,6BAA6BC;IAGtC,YAAYC,EAAU,CAAE;QACpB,KAAK,CAAC;YAAE,SAAS,CAAC,SAAS,EAAEA,GAAG,gBAAgB,CAAC;QAAC,SAHpC,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,qCAAqCF;IAG9C,YAAYC,EAAU,CAAE;QACpB,KAAK,CAAC;YAAE,SAAS,CAAC,kBAAkB,EAAEA,GAAG,gBAAgB,CAAC;QAAC,SAH7C,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAME,+BAA+BH;IAGxC,YAAYI,OAAe,CAAE;QACzB,KAAK,CAAC;YAAEA;QAAQ,SAHF,IAAI,GAAG;IAIzB;AACJ;AAQO,MAAMC,gCAAgCL;IAGzC,YAAYM,KAAY,CAAE;QACtB,KAAK,CAAC;YAAE,SAASA,MAAM,OAAO;YAAE,MAAM;gBAAE,iBAAiBA,MAAM,OAAO;YAAC;QAAE,SAH3D,IAAI,GAAG;IAIzB;IAEA,OAAO,KAAKA,KAAc,EAA2B;QACjD,IAAIA,iBAAiBC,OAAO;YACxB,MAAMC,WAAW,IAAIH,wBAAwBC;YAC7C,MAAMG,OAAoC;gBACtC,iBAAiBH,MAAM,OAAO;gBAC9B,cAAeA,MAAc,IAAI;gBACjC,cAAeA,MAAc,IAAI;YACrC;YACCE,SAAiB,IAAI,GAAGC;YACzBD,SAAS,KAAK,GAAGF,MAAM,KAAK;YAC5B,OAAOE;QACX;QAEA,OAAO,IAAIH,wBAAwB,IAAIE,MAAMG,OAAOJ;IACxD;AACJ;AAEO,MAAMK,kCAAkCX;IAG3C,YAAYY,OAAe,CAAE;QACzB,KAAK,CAAC;YAAE,SAAS,CAAC,eAAe,EAAEA,QAAQ,gBAAgB,CAAC;QAAC,SAH/C,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,uCAAuCb;IAGhD,YAAYI,OAAe,CAAE;QACzB,KAAK,CAAC;YAAEA;QAAQ,SAHF,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMU,kCAAkCd;IAG3C,aAAc;QACV,KAAK,CAAC;YAAE,SAAS;QAAkB,SAHrB,IAAI,GAAG;IAIzB;AACJ"}

package/api/features/CreateWebhook/CreateWebhookRepository.d.ts

@@ -0,0 +1,18 @@
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { CreateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { CreateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { WebhookTransformer } from "../../../api/features/Transformers/abstractions/WebhookTransformer.js";
+import { CreateWebhookRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { WebhookCmsEntryValues } from "../../../api/domain/Webhook.js";
+declare class CreateWebhookRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly createEntryRepository;
+    private readonly createEntryDataFactory;
+    private readonly transformer;
+    constructor(getModelRepository: GetModelRepository.Interface, createEntryRepository: CreateEntryRepository.Interface, createEntryDataFactory: CreateEntryDataFactory.Interface, transformer: WebhookTransformer.Interface);
+    execute(input: WebhookCmsEntryValues): Promise<RepositoryAbstraction.Response>;
+}
+export declare const CreateWebhookRepository: typeof CreateWebhookRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateWebhookRepository>;
+};
+export {};

package/api/features/CreateWebhook/CreateWebhookRepository.js

@@ -0,0 +1,43 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { CreateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { CreateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { WebhookTransformer } from "../Transformers/abstractions/WebhookTransformer.js";
+import { CreateWebhookRepository } from "./abstractions.js";
+import { WebhookModelNotFoundError, WebhookPersistenceError } from "../../domain/errors.js";
+import { WEBHOOK_MODEL_ID } from "../../domain/constants.js";
+class CreateWebhookRepositoryImpl {
+    constructor(getModelRepository, createEntryRepository, createEntryDataFactory, transformer){
+        this.getModelRepository = getModelRepository;
+        this.createEntryRepository = createEntryRepository;
+        this.createEntryDataFactory = createEntryDataFactory;
+        this.transformer = transformer;
+    }
+    async execute(input) {
+        try {
+            const modelResult = await this.getModelRepository.execute(WEBHOOK_MODEL_ID);
+            if (modelResult.isFail()) return Result.fail(new WebhookModelNotFoundError(WEBHOOK_MODEL_ID));
+            const { entry } = await this.createEntryDataFactory.create(modelResult.value, {
+                values: input
+            });
+            const createResult = await this.createEntryRepository.execute(modelResult.value, entry);
+            if (createResult.isFail()) return Result.fail(WebhookPersistenceError.from(createResult.error));
+            const webhook = this.transformer.fromStorage(entry);
+            return Result.ok(webhook);
+        } catch (error) {
+            return Result.fail(WebhookPersistenceError.from(error));
+        }
+    }
+}
+const CreateWebhookRepository_CreateWebhookRepository = CreateWebhookRepository.createImplementation({
+    implementation: CreateWebhookRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        CreateEntryRepository,
+        CreateEntryDataFactory,
+        WebhookTransformer
+    ]
+});
+export { CreateWebhookRepository_CreateWebhookRepository as CreateWebhookRepository };
+
+//# sourceMappingURL=CreateWebhookRepository.js.map

package/api/features/CreateWebhook/CreateWebhookRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateWebhook/CreateWebhookRepository.js","sources":["../../../../src/api/features/CreateWebhook/CreateWebhookRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetModelRepository } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { CreateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { CreateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { WebhookTransformer } from \"~/api/features/Transformers/abstractions/WebhookTransformer.js\";\nimport { CreateWebhookRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { WebhookModelNotFoundError, WebhookPersistenceError } from \"~/api/domain/errors.js\";\nimport { WEBHOOK_MODEL_ID } from \"~/api/domain/constants.js\";\nimport type { WebhookCmsEntryValues } from \"~/api/domain/Webhook.js\";\n\nclass CreateWebhookRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly createEntryRepository: CreateEntryRepository.Interface,\n        private readonly createEntryDataFactory: CreateEntryDataFactory.Interface,\n        private readonly transformer: WebhookTransformer.Interface\n    ) {}\n\n    async execute(input: WebhookCmsEntryValues): Promise<RepositoryAbstraction.Response> {\n        try {\n            const modelResult = await this.getModelRepository.execute(WEBHOOK_MODEL_ID);\n            if (modelResult.isFail()) {\n                return Result.fail(new WebhookModelNotFoundError(WEBHOOK_MODEL_ID));\n            }\n\n            const { entry } = await this.createEntryDataFactory.create<WebhookCmsEntryValues>(\n                modelResult.value,\n                { values: input }\n            );\n\n            const createResult = await this.createEntryRepository.execute(modelResult.value, entry);\n\n            if (createResult.isFail()) {\n                return Result.fail(WebhookPersistenceError.from(createResult.error));\n            }\n\n            const webhook = this.transformer.fromStorage(entry);\n\n            return Result.ok(webhook);\n        } catch (error) {\n            return Result.fail(WebhookPersistenceError.from(error));\n        }\n    }\n}\n\nexport const CreateWebhookRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateWebhookRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        CreateEntryRepository,\n        CreateEntryDataFactory,\n        WebhookTransformer\n    ]\n});\n"],"names":["CreateWebhookRepositoryImpl","getModelRepository","createEntryRepository","createEntryDataFactory","transformer","input","modelResult","WEBHOOK_MODEL_ID","Result","WebhookModelNotFoundError","entry","createResult","WebhookPersistenceError","webhook","error","CreateWebhookRepository","RepositoryAbstraction","GetModelRepository","CreateEntryRepository","CreateEntryDataFactory","WebhookTransformer"],"mappings":";;;;;;;;AAUA,MAAMA;IACF,YACqBC,kBAAgD,EAChDC,qBAAsD,EACtDC,sBAAwD,EACxDC,WAAyC,CAC5D;aAJmBH,kBAAkB,GAAlBA;aACAC,qBAAqB,GAArBA;aACAC,sBAAsB,GAAtBA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAM,QAAQC,KAA4B,EAA2C;QACjF,IAAI;YACA,MAAMC,cAAc,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACC;YAC1D,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CAAC,IAAIC,0BAA0BF;YAGrD,MAAM,EAAEG,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACtDJ,YAAY,KAAK,EACjB;gBAAE,QAAQD;YAAM;YAGpB,MAAMM,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACL,YAAY,KAAK,EAAEI;YAEjF,IAAIC,aAAa,MAAM,IACnB,OAAOH,OAAO,IAAI,CAACI,wBAAwB,IAAI,CAACD,aAAa,KAAK;YAGtE,MAAME,UAAU,IAAI,CAAC,WAAW,CAAC,WAAW,CAACH;YAE7C,OAAOF,OAAO,EAAE,CAACK;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAON,OAAO,IAAI,CAACI,wBAAwB,IAAI,CAACE;QACpD;IACJ;AACJ;AAEO,MAAMC,kDAA0BC,wBAAAA,oBAA0C,CAAC;IAC9E,gBAAgBhB;IAChB,cAAc;QACViB;QACAC;QACAC;QACAC;KACH;AACL"}

package/api/features/CreateWebhook/CreateWebhookUseCase.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "@webiny/feature/api";
+import { CreateWebhookRepository, CreateWebhookUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ListWebhooksRepository } from "../../../api/features/ListWebhooks/abstractions.js";
+import { WebhookPermissions } from "../../../api/features/WebhookPermissions/abstractions.js";
+import type { Webhook } from "../../../api/domain/Webhook.js";
+declare class CreateWebhookUseCaseImpl implements UseCaseAbstraction.Interface {
+    private permissions;
+    private repository;
+    private listWebhooksRepository;
+    constructor(permissions: WebhookPermissions.Interface, repository: CreateWebhookRepository.Interface, listWebhooksRepository: ListWebhooksRepository.Interface);
+    execute(input: UseCaseAbstraction.Input): Promise<Result<Webhook, UseCaseAbstraction.Error>>;
+}
+export declare const CreateWebhookUseCase: typeof CreateWebhookUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateWebhookUseCase>;
+};
+export {};

package/api/features/CreateWebhook/CreateWebhookUseCase.js

@@ -0,0 +1,57 @@
+import { Result } from "@webiny/feature/api";
+import { CreateWebhookRepository, CreateWebhookUseCase } from "./abstractions.js";
+import { ListWebhooksRepository } from "../ListWebhooks/abstractions.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError, WebhookValidationError } from "../../domain/errors.js";
+const generateSlug = (name)=>name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
+const isValidEndpointUrl = (url)=>{
+    try {
+        const parsed = new URL(url);
+        if ("https:" === parsed.protocol) return true;
+        if ("http:" === parsed.protocol && ("localhost" === parsed.hostname || "127.0.0.1" === parsed.hostname)) return true;
+        return false;
+    } catch  {
+        return false;
+    }
+};
+class CreateWebhookUseCaseImpl {
+    constructor(permissions, repository, listWebhooksRepository){
+        this.permissions = permissions;
+        this.repository = repository;
+        this.listWebhooksRepository = listWebhooksRepository;
+    }
+    async execute(input) {
+        if (!await this.permissions.canCreate("webhook")) return Result.fail(new WebhookNotAuthorizedError());
+        if (!isValidEndpointUrl(input.endpointUrl)) return Result.fail(new WebhookValidationError("Endpoint URL must use HTTPS. HTTP is only allowed for localhost."));
+        if (!input.events || 0 === input.events.length) return Result.fail(new WebhookValidationError("At least one event must be selected."));
+        const slug = (input.slug || "").trim() || generateSlug(input.name);
+        const listResult = await this.listWebhooksRepository.execute({
+            where: {
+                slug
+            },
+            limit: 1
+        });
+        if (listResult.isOk() && listResult.value.items.length > 0) return Result.fail(new WebhookValidationError(`Slug "${slug}" is already taken.`));
+        const webhook = {
+            name: input.name,
+            slug,
+            endpointUrl: input.endpointUrl,
+            description: input.description,
+            enabled: input.enabled ?? false,
+            events: input.events,
+            signingSecret: input.signingSecret
+        };
+        return this.repository.execute(webhook);
+    }
+}
+const CreateWebhookUseCase_CreateWebhookUseCase = CreateWebhookUseCase.createImplementation({
+    implementation: CreateWebhookUseCaseImpl,
+    dependencies: [
+        WebhookPermissions,
+        CreateWebhookRepository,
+        ListWebhooksRepository
+    ]
+});
+export { CreateWebhookUseCase_CreateWebhookUseCase as CreateWebhookUseCase };
+
+//# sourceMappingURL=CreateWebhookUseCase.js.map

package/api/features/CreateWebhook/CreateWebhookUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateWebhook/CreateWebhookUseCase.js","sources":["../../../../src/api/features/CreateWebhook/CreateWebhookUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreateWebhookRepository,\n    CreateWebhookUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\nimport { ListWebhooksRepository } from \"~/api/features/ListWebhooks/abstractions.js\";\nimport { WebhookPermissions } from \"~/api/features/WebhookPermissions/abstractions.js\";\nimport { WebhookNotAuthorizedError, WebhookValidationError } from \"~/api/domain/errors.js\";\nimport type { Webhook, WebhookCmsEntryValues } from \"~/api/domain/Webhook.js\";\n\nconst generateSlug = (name: string): string => {\n    return name\n        .toLowerCase()\n        .replace(/[^a-z0-9]+/g, \"-\")\n        .replace(/^-|-$/g, \"\")\n        .slice(0, 64);\n};\n\nconst isValidEndpointUrl = (url: string): boolean => {\n    try {\n        const parsed = new URL(url);\n        if (parsed.protocol === \"https:\") {\n            return true;\n        } else if (\n            parsed.protocol === \"http:\" &&\n            (parsed.hostname === \"localhost\" || parsed.hostname === \"127.0.0.1\")\n        ) {\n            return true;\n        }\n        return false;\n    } catch {\n        return false;\n    }\n};\n\nclass CreateWebhookUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private permissions: WebhookPermissions.Interface,\n        private repository: CreateWebhookRepository.Interface,\n        private listWebhooksRepository: ListWebhooksRepository.Interface\n    ) {}\n\n    async execute(\n        input: UseCaseAbstraction.Input\n    ): Promise<Result<Webhook, UseCaseAbstraction.Error>> {\n        if (!(await this.permissions.canCreate(\"webhook\"))) {\n            return Result.fail(new WebhookNotAuthorizedError());\n        }\n\n        if (!isValidEndpointUrl(input.endpointUrl)) {\n            return Result.fail(\n                new WebhookValidationError(\n                    \"Endpoint URL must use HTTPS. HTTP is only allowed for localhost.\"\n                )\n            );\n        }\n\n        if (!input.events || input.events.length === 0) {\n            return Result.fail(new WebhookValidationError(\"At least one event must be selected.\"));\n        }\n\n        const slug = (input.slug || \"\").trim() || generateSlug(input.name);\n\n        const listResult = await this.listWebhooksRepository.execute({\n            where: {\n                slug\n            },\n            limit: 1\n        });\n        if (listResult.isOk() && listResult.value.items.length > 0) {\n            return Result.fail(new WebhookValidationError(`Slug \"${slug}\" is already taken.`));\n        }\n\n        const webhook: WebhookCmsEntryValues = {\n            name: input.name,\n            slug,\n            endpointUrl: input.endpointUrl,\n            description: input.description,\n            enabled: input.enabled ?? false,\n            events: input.events,\n            signingSecret: input.signingSecret\n        };\n\n        return this.repository.execute(webhook);\n    }\n}\n\nexport const CreateWebhookUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateWebhookUseCaseImpl,\n    dependencies: [WebhookPermissions, CreateWebhookRepository, ListWebhooksRepository]\n});\n"],"names":["generateSlug","name","isValidEndpointUrl","url","parsed","URL","CreateWebhookUseCaseImpl","permissions","repository","listWebhooksRepository","input","Result","WebhookNotAuthorizedError","WebhookValidationError","slug","listResult","webhook","CreateWebhookUseCase","UseCaseAbstraction","WebhookPermissions","CreateWebhookRepository","ListWebhooksRepository"],"mappings":";;;;;AAUA,MAAMA,eAAe,CAACC,OACXA,KACF,WAAW,GACX,OAAO,CAAC,eAAe,KACvB,OAAO,CAAC,UAAU,IAClB,KAAK,CAAC,GAAG;AAGlB,MAAMC,qBAAqB,CAACC;IACxB,IAAI;QACA,MAAMC,SAAS,IAAIC,IAAIF;QACvB,IAAIC,AAAoB,aAApBA,OAAO,QAAQ,EACf,OAAO;QACJ,IACHA,AAAoB,YAApBA,OAAO,QAAQ,IACdA,CAAAA,AAAoB,gBAApBA,OAAO,QAAQ,IAAoBA,AAAoB,gBAApBA,OAAO,QAAQ,AAAe,GAElE,OAAO;QAEX,OAAO;IACX,EAAE,OAAM;QACJ,OAAO;IACX;AACJ;AAEA,MAAME;IACF,YACYC,WAAyC,EACzCC,UAA6C,EAC7CC,sBAAwD,CAClE;aAHUF,WAAW,GAAXA;aACAC,UAAU,GAAVA;aACAC,sBAAsB,GAAtBA;IACT;IAEH,MAAM,QACFC,KAA+B,EACmB;QAClD,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,YACnC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,IAAI,CAACV,mBAAmBQ,MAAM,WAAW,GACrC,OAAOC,OAAO,IAAI,CACd,IAAIE,uBACA;QAKZ,IAAI,CAACH,MAAM,MAAM,IAAIA,AAAwB,MAAxBA,MAAM,MAAM,CAAC,MAAM,EACpC,OAAOC,OAAO,IAAI,CAAC,IAAIE,uBAAuB;QAGlD,MAAMC,OAAQJ,AAAAA,CAAAA,MAAM,IAAI,IAAI,EAAC,EAAG,IAAI,MAAMV,aAAaU,MAAM,IAAI;QAEjE,MAAMK,aAAa,MAAM,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC;YACzD,OAAO;gBACHD;YACJ;YACA,OAAO;QACX;QACA,IAAIC,WAAW,IAAI,MAAMA,WAAW,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,GACrD,OAAOJ,OAAO,IAAI,CAAC,IAAIE,uBAAuB,CAAC,MAAM,EAAEC,KAAK,mBAAmB,CAAC;QAGpF,MAAME,UAAiC;YACnC,MAAMN,MAAM,IAAI;YAChBI;YACA,aAAaJ,MAAM,WAAW;YAC9B,aAAaA,MAAM,WAAW;YAC9B,SAASA,MAAM,OAAO,IAAI;YAC1B,QAAQA,MAAM,MAAM;YACpB,eAAeA,MAAM,aAAa;QACtC;QAEA,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACM;IACnC;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBZ;IAChB,cAAc;QAACa;QAAoBC;QAAyBC;KAAuB;AACvF"}

package/api/features/CreateWebhook/abstractions.d.ts

@@ -0,0 +1,33 @@
+import { type Result } from "@webiny/feature/api";
+import type { Webhook, WebhookCmsEntryValues } from "../../../api/domain/Webhook.js";
+import type { WebhookModelNotFoundError, WebhookNotAuthorizedError, WebhookPersistenceError, WebhookValidationError } from "../../../api/domain/errors.js";
+export interface ICreateWebhookInput {
+    name: string;
+    slug?: string;
+    endpointUrl: string;
+    description?: string;
+    enabled?: boolean;
+    events: string[];
+    signingSecret: string;
+}
+type IError = WebhookValidationError | WebhookPersistenceError | WebhookModelNotFoundError | WebhookNotAuthorizedError;
+export interface ICreateWebhookUseCase {
+    execute(input: ICreateWebhookInput): Promise<Result<Webhook, IError>>;
+}
+export declare const CreateWebhookUseCase: import("@webiny/di").Abstraction<ICreateWebhookUseCase>;
+export declare namespace CreateWebhookUseCase {
+    type Interface = ICreateWebhookUseCase;
+    type Input = ICreateWebhookInput;
+    type Error = IError;
+}
+export type ICreateWebhookRepositoryResponse = Result<Webhook, WebhookPersistenceError | WebhookModelNotFoundError>;
+export interface ICreateWebhookRepository {
+    execute(input: WebhookCmsEntryValues): Promise<ICreateWebhookRepositoryResponse>;
+}
+export declare const CreateWebhookRepository: import("@webiny/di").Abstraction<ICreateWebhookRepository>;
+export declare namespace CreateWebhookRepository {
+    type Interface = ICreateWebhookRepository;
+    type Response = ICreateWebhookRepositoryResponse;
+    type Error = WebhookPersistenceError | WebhookModelNotFoundError;
+}
+export {};

package/api/features/CreateWebhook/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CreateWebhookUseCase = createAbstraction("Webhooks/CreateWebhookUseCase");
+const CreateWebhookRepository = createAbstraction("Webhooks/CreateWebhookRepository");
+export { CreateWebhookRepository, CreateWebhookUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/api/features/CreateWebhook/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateWebhook/abstractions.js","sources":["../../../../src/api/features/CreateWebhook/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { Webhook, WebhookCmsEntryValues } from \"~/api/domain/Webhook.js\";\nimport type {\n    WebhookModelNotFoundError,\n    WebhookNotAuthorizedError,\n    WebhookPersistenceError,\n    WebhookValidationError\n} from \"~/api/domain/errors.js\";\n\nexport interface ICreateWebhookInput {\n    name: string;\n    slug?: string;\n    endpointUrl: string;\n    description?: string;\n    enabled?: boolean;\n    events: string[];\n    signingSecret: string;\n}\n\ntype IError =\n    | WebhookValidationError\n    | WebhookPersistenceError\n    | WebhookModelNotFoundError\n    | WebhookNotAuthorizedError;\n\nexport interface ICreateWebhookUseCase {\n    execute(input: ICreateWebhookInput): Promise<Result<Webhook, IError>>;\n}\n\nexport const CreateWebhookUseCase = createAbstraction<ICreateWebhookUseCase>(\n    \"Webhooks/CreateWebhookUseCase\"\n);\n\nexport namespace CreateWebhookUseCase {\n    export type Interface = ICreateWebhookUseCase;\n    export type Input = ICreateWebhookInput;\n    export type Error = IError;\n}\n\nexport type ICreateWebhookRepositoryResponse = Result<\n    Webhook,\n    WebhookPersistenceError | WebhookModelNotFoundError\n>;\n\nexport interface ICreateWebhookRepository {\n    execute(input: WebhookCmsEntryValues): Promise<ICreateWebhookRepositoryResponse>;\n}\n\nexport const CreateWebhookRepository = createAbstraction<ICreateWebhookRepository>(\n    \"Webhooks/CreateWebhookRepository\"\n);\n\nexport namespace CreateWebhookRepository {\n    export type Interface = ICreateWebhookRepository;\n    export type Response = ICreateWebhookRepositoryResponse;\n    export type Error = WebhookPersistenceError | WebhookModelNotFoundError;\n}\n"],"names":["CreateWebhookUseCase","createAbstraction","CreateWebhookRepository"],"mappings":";AA6BO,MAAMA,uBAAuBC,kBAChC;AAkBG,MAAMC,0BAA0BD,kBACnC"}

package/api/features/CreateWebhook/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const CreateWebhookFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/features/CreateWebhook/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateWebhookUseCase } from "./CreateWebhookUseCase.js";
+import { CreateWebhookRepository } from "./CreateWebhookRepository.js";
+const CreateWebhookFeature = createFeature({
+    name: "CreateWebhook",
+    register (container) {
+        container.register(CreateWebhookUseCase);
+        container.register(CreateWebhookRepository).inSingletonScope();
+    }
+});
+export { CreateWebhookFeature };
+
+//# sourceMappingURL=feature.js.map

package/api/features/CreateWebhook/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateWebhook/feature.js","sources":["../../../../src/api/features/CreateWebhook/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateWebhookUseCase } from \"./CreateWebhookUseCase.js\";\nimport { CreateWebhookRepository } from \"./CreateWebhookRepository.js\";\n\nexport const CreateWebhookFeature = createFeature({\n    name: \"CreateWebhook\",\n    register(container) {\n        container.register(CreateWebhookUseCase);\n        container.register(CreateWebhookRepository).inSingletonScope();\n    }\n});\n"],"names":["CreateWebhookFeature","createFeature","container","CreateWebhookUseCase","CreateWebhookRepository"],"mappings":";;;AAIO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,yBAAyB,gBAAgB;IAChE;AACJ"}

package/api/features/CreateWebhookDelivery/CreateWebhookDeliveryRepository.d.ts

@@ -0,0 +1,20 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { CreateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { CreateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { WebhookDeliveryTransformer } from "../../../api/features/Transformers/abstractions/WebhookDeliveryTransformer.js";
+import { CreateWebhookDeliveryRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { ICreateDeliveryInput } from "./abstractions.js";
+import type { WebhookDelivery } from "../../../api/domain/WebhookDelivery.js";
+declare class CreateWebhookDeliveryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly createEntryDataFactory;
+    private readonly createEntryRepository;
+    private readonly transformer;
+    constructor(getModelRepository: GetModelRepository.Interface, createEntryDataFactory: CreateEntryDataFactory.Interface, createEntryRepository: CreateEntryRepository.Interface, transformer: WebhookDeliveryTransformer.Interface);
+    execute(input: ICreateDeliveryInput): Promise<Result<WebhookDelivery, RepositoryAbstraction.Error>>;
+}
+export declare const CreateWebhookDeliveryRepository: typeof CreateWebhookDeliveryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateWebhookDeliveryRepository>;
+};
+export {};

package/api/features/CreateWebhookDelivery/CreateWebhookDeliveryRepository.js

@@ -0,0 +1,58 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { CreateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { CreateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { WebhookDeliveryTransformer } from "../Transformers/abstractions/WebhookDeliveryTransformer.js";
+import { CreateWebhookDeliveryRepository } from "./abstractions.js";
+import { WebhookModelNotFoundError, WebhookPersistenceError } from "../../domain/errors.js";
+import { WEBHOOK_DELIVERY_MODEL_ID } from "../../domain/constants.js";
+class CreateWebhookDeliveryRepositoryImpl {
+    constructor(getModelRepository, createEntryDataFactory, createEntryRepository, transformer){
+        this.getModelRepository = getModelRepository;
+        this.createEntryDataFactory = createEntryDataFactory;
+        this.createEntryRepository = createEntryRepository;
+        this.transformer = transformer;
+    }
+    async execute(input) {
+        try {
+            const modelResult = await this.getModelRepository.execute(WEBHOOK_DELIVERY_MODEL_ID);
+            if (modelResult.isFail()) return Result.fail(new WebhookModelNotFoundError(WEBHOOK_DELIVERY_MODEL_ID));
+            const storageValues = this.transformer.toStorage({
+                id: "",
+                createdOn: "",
+                savedOn: "",
+                webhookId: input.webhookId,
+                backgroundTaskId: null,
+                eventType: input.eventType,
+                status: input.status,
+                payload: input.payload,
+                requestHeaders: null,
+                responseTime: null,
+                responseStatus: null,
+                responseHeaders: null,
+                responseBody: null
+            });
+            const { entry } = await this.createEntryDataFactory.create(modelResult.value, {
+                values: storageValues
+            });
+            const createResult = await this.createEntryRepository.execute(modelResult.value, entry);
+            if (createResult.isFail()) return Result.fail(WebhookPersistenceError.from(createResult.error));
+            const delivery = this.transformer.fromStorage(entry);
+            return Result.ok(delivery);
+        } catch (error) {
+            return Result.fail(WebhookPersistenceError.from(error));
+        }
+    }
+}
+const CreateWebhookDeliveryRepository_CreateWebhookDeliveryRepository = CreateWebhookDeliveryRepository.createImplementation({
+    implementation: CreateWebhookDeliveryRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        CreateEntryDataFactory,
+        CreateEntryRepository,
+        WebhookDeliveryTransformer
+    ]
+});
+export { CreateWebhookDeliveryRepository_CreateWebhookDeliveryRepository as CreateWebhookDeliveryRepository };
+
+//# sourceMappingURL=CreateWebhookDeliveryRepository.js.map

package/api/features/CreateWebhookDelivery/CreateWebhookDeliveryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateWebhookDelivery/CreateWebhookDeliveryRepository.js","sources":["../../../../src/api/features/CreateWebhookDelivery/CreateWebhookDeliveryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetModelRepository } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { CreateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { CreateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { WebhookDeliveryTransformer } from \"~/api/features/Transformers/abstractions/WebhookDeliveryTransformer.js\";\nimport { CreateWebhookDeliveryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { WebhookModelNotFoundError, WebhookPersistenceError } from \"~/api/domain/errors.js\";\nimport { WEBHOOK_DELIVERY_MODEL_ID } from \"~/api/domain/constants.js\";\nimport type { ICreateDeliveryInput } from \"./abstractions.js\";\nimport type {\n    WebhookDelivery,\n    WebhookDeliveryCmsEntryValues\n} from \"~/api/domain/WebhookDelivery.js\";\n\nclass CreateWebhookDeliveryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly createEntryDataFactory: CreateEntryDataFactory.Interface,\n        private readonly createEntryRepository: CreateEntryRepository.Interface,\n        private readonly transformer: WebhookDeliveryTransformer.Interface\n    ) {}\n\n    async execute(\n        input: ICreateDeliveryInput\n    ): Promise<Result<WebhookDelivery, RepositoryAbstraction.Error>> {\n        try {\n            const modelResult = await this.getModelRepository.execute(WEBHOOK_DELIVERY_MODEL_ID);\n            if (modelResult.isFail()) {\n                return Result.fail(new WebhookModelNotFoundError(WEBHOOK_DELIVERY_MODEL_ID));\n            }\n\n            const storageValues = this.transformer.toStorage({\n                id: \"\",\n                createdOn: \"\",\n                savedOn: \"\",\n                webhookId: input.webhookId,\n                backgroundTaskId: null,\n                eventType: input.eventType,\n                status: input.status,\n                payload: input.payload,\n                requestHeaders: null,\n                responseTime: null,\n                responseStatus: null,\n                responseHeaders: null,\n                responseBody: null\n            });\n\n            const { entry } =\n                await this.createEntryDataFactory.create<WebhookDeliveryCmsEntryValues>(\n                    modelResult.value,\n                    { values: storageValues }\n                );\n\n            const createResult = await this.createEntryRepository.execute(modelResult.value, entry);\n\n            if (createResult.isFail()) {\n                return Result.fail(WebhookPersistenceError.from(createResult.error));\n            }\n\n            const delivery = this.transformer.fromStorage(entry);\n\n            return Result.ok(delivery);\n        } catch (error) {\n            return Result.fail(WebhookPersistenceError.from(error));\n        }\n    }\n}\n\nexport const CreateWebhookDeliveryRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateWebhookDeliveryRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        CreateEntryDataFactory,\n        CreateEntryRepository,\n        WebhookDeliveryTransformer\n    ]\n});\n"],"names":["CreateWebhookDeliveryRepositoryImpl","getModelRepository","createEntryDataFactory","createEntryRepository","transformer","input","modelResult","WEBHOOK_DELIVERY_MODEL_ID","Result","WebhookModelNotFoundError","storageValues","entry","createResult","WebhookPersistenceError","delivery","error","CreateWebhookDeliveryRepository","RepositoryAbstraction","GetModelRepository","CreateEntryDataFactory","CreateEntryRepository","WebhookDeliveryTransformer"],"mappings":";;;;;;;;AAcA,MAAMA;IACF,YACqBC,kBAAgD,EAChDC,sBAAwD,EACxDC,qBAAsD,EACtDC,WAAiD,CACpE;aAJmBH,kBAAkB,GAAlBA;aACAC,sBAAsB,GAAtBA;aACAC,qBAAqB,GAArBA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAM,QACFC,KAA2B,EACkC;QAC7D,IAAI;YACA,MAAMC,cAAc,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACC;YAC1D,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CAAC,IAAIC,0BAA0BF;YAGrD,MAAMG,gBAAgB,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;gBAC7C,IAAI;gBACJ,WAAW;gBACX,SAAS;gBACT,WAAWL,MAAM,SAAS;gBAC1B,kBAAkB;gBAClB,WAAWA,MAAM,SAAS;gBAC1B,QAAQA,MAAM,MAAM;gBACpB,SAASA,MAAM,OAAO;gBACtB,gBAAgB;gBAChB,cAAc;gBACd,gBAAgB;gBAChB,iBAAiB;gBACjB,cAAc;YAClB;YAEA,MAAM,EAAEM,KAAK,EAAE,GACX,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACpCL,YAAY,KAAK,EACjB;gBAAE,QAAQI;YAAc;YAGhC,MAAME,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACN,YAAY,KAAK,EAAEK;YAEjF,IAAIC,aAAa,MAAM,IACnB,OAAOJ,OAAO,IAAI,CAACK,wBAAwB,IAAI,CAACD,aAAa,KAAK;YAGtE,MAAME,WAAW,IAAI,CAAC,WAAW,CAAC,WAAW,CAACH;YAE9C,OAAOH,OAAO,EAAE,CAACM;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOP,OAAO,IAAI,CAACK,wBAAwB,IAAI,CAACE;QACpD;IACJ;AACJ;AAEO,MAAMC,kEAAkCC,gCAAAA,oBAA0C,CAAC;IACtF,gBAAgBjB;IAChB,cAAc;QACVkB;QACAC;QACAC;QACAC;KACH;AACL"}

package/api/features/CreateWebhookDelivery/abstractions.d.ts

@@ -0,0 +1,21 @@
+import { type Result } from "@webiny/feature/api";
+import type { GenericRecord } from "@webiny/api/types.js";
+import type { WebhookDelivery, WebhookDeliveryStatus } from "../../../api/domain/WebhookDelivery.js";
+import type { WebhookPersistenceError, WebhookModelNotFoundError } from "../../../api/domain/errors.js";
+export interface ICreateDeliveryInput {
+    webhookId: string;
+    eventType: string;
+    status: WebhookDeliveryStatus;
+    payload: GenericRecord;
+    expiresAt: string;
+}
+type IError = WebhookPersistenceError | WebhookModelNotFoundError;
+export interface ICreateWebhookDeliveryRepository {
+    execute(input: ICreateDeliveryInput): Promise<Result<WebhookDelivery, IError>>;
+}
+export declare const CreateWebhookDeliveryRepository: import("@webiny/di").Abstraction<ICreateWebhookDeliveryRepository>;
+export declare namespace CreateWebhookDeliveryRepository {
+    type Interface = ICreateWebhookDeliveryRepository;
+    type Error = IError;
+}
+export {};

package/api/features/CreateWebhookDelivery/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CreateWebhookDeliveryRepository = createAbstraction("Webhooks/CreateWebhookDeliveryRepository");
+export { CreateWebhookDeliveryRepository };
+
+//# sourceMappingURL=abstractions.js.map

package/api/features/CreateWebhookDelivery/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateWebhookDelivery/abstractions.js","sources":["../../../../src/api/features/CreateWebhookDelivery/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport type { WebhookDelivery, WebhookDeliveryStatus } from \"~/api/domain/WebhookDelivery.js\";\nimport type { WebhookPersistenceError, WebhookModelNotFoundError } from \"~/api/domain/errors.js\";\n\nexport interface ICreateDeliveryInput {\n    webhookId: string;\n    eventType: string;\n    status: WebhookDeliveryStatus;\n    payload: GenericRecord;\n    expiresAt: string;\n}\n\ntype IError = WebhookPersistenceError | WebhookModelNotFoundError;\n\nexport interface ICreateWebhookDeliveryRepository {\n    execute(input: ICreateDeliveryInput): Promise<Result<WebhookDelivery, IError>>;\n}\n\nexport const CreateWebhookDeliveryRepository = createAbstraction<ICreateWebhookDeliveryRepository>(\n    \"Webhooks/CreateWebhookDeliveryRepository\"\n);\n\nexport namespace CreateWebhookDeliveryRepository {\n    export type Interface = ICreateWebhookDeliveryRepository;\n    export type Error = IError;\n}\n"],"names":["CreateWebhookDeliveryRepository","createAbstraction"],"mappings":";AAmBO,MAAMA,kCAAkCC,kBAC3C"}

package/api/features/CreateWebhookDelivery/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const CreateWebhookDeliveryFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/features/CreateWebhookDelivery/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateWebhookDeliveryRepository } from "./CreateWebhookDeliveryRepository.js";
+const CreateWebhookDeliveryFeature = createFeature({
+    name: "CreateWebhookDelivery",
+    register (container) {
+        container.register(CreateWebhookDeliveryRepository).inSingletonScope();
+    }
+});
+export { CreateWebhookDeliveryFeature };
+
+//# sourceMappingURL=feature.js.map

package/api/features/CreateWebhookDelivery/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateWebhookDelivery/feature.js","sources":["../../../../src/api/features/CreateWebhookDelivery/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateWebhookDeliveryRepository } from \"./CreateWebhookDeliveryRepository.js\";\n\nexport const CreateWebhookDeliveryFeature = createFeature({\n    name: \"CreateWebhookDelivery\",\n    register(container) {\n        container.register(CreateWebhookDeliveryRepository).inSingletonScope();\n    }\n});\n"],"names":["CreateWebhookDeliveryFeature","createFeature","container","CreateWebhookDeliveryRepository"],"mappings":";;AAGO,MAAMA,+BAA+BC,cAAc;IACtD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,iCAAiC,gBAAgB;IACxE;AACJ"}

package/api/features/DeleteWebhook/DeleteWebhookRepository.d.ts

@@ -0,0 +1,19 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetLatestRevisionByEntryIdRepository } from "@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import { ListEntriesRepository } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js";
+import { DeleteEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { DeleteWebhookRepository as RepositoryAbstraction } from "./abstractions.js";
+declare class DeleteWebhookRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly listEntriesRepository;
+    private readonly deleteEntryRepository;
+    constructor(getModelRepository: GetModelRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, listEntriesRepository: ListEntriesRepository.Interface, deleteEntryRepository: DeleteEntryRepository.Interface);
+    execute(id: string): Promise<Result<boolean, RepositoryAbstraction.Error>>;
+    private deleteAllDeliveries;
+}
+export declare const DeleteWebhookRepository: typeof DeleteWebhookRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteWebhookRepository>;
+};
+export {};