@webiny/webhooks 0.0.0-unstable.7be00a75a9

package/api/domain/errors.js

@@ -0,0 +1,83 @@
+import { BaseError } from "@webiny/feature/api";
+import { parseZodError } from "@webiny/utils";
+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(error){
+        if ("string" == typeof error) super({
+            message: error,
+            data: {
+                issues: []
+            }
+        }), this.code = "WEBHOOK_VALIDATION_ERROR";
+        else {
+            const issues = parseZodError(error);
+            super({
+                message: "Validation failed.",
+                data: {
+                    issues
+                }
+            }), 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\";\nimport type { ZodError } from \"zod\";\nimport { parseZodError } from \"@webiny/utils\";\nimport type { ValidationIssue } from \"@webiny/utils\";\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\ninterface WebhookValidationErrorData {\n    issues: ValidationIssue[];\n}\n\nexport class WebhookValidationError extends BaseError<WebhookValidationErrorData> {\n    override readonly code = \"WEBHOOK_VALIDATION_ERROR\" as const;\n\n    constructor(error: string | ZodError) {\n        if (typeof error === \"string\") {\n            super({ message: error, data: { issues: [] } });\n        } else {\n            const issues = parseZodError(error);\n            super({ message: \"Validation failed.\", data: { issues } });\n        }\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","error","issues","parseZodError","WebhookPersistenceError","Error","instance","data","String","WebhookModelNotFoundError","modelId","WebhookVerificationFailedError","message","WebhookNotAuthorizedError"],"mappings":";;AAKO,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;AAMO,MAAME,+BAA+BH;IAGxC,YAAYI,KAAwB,CAAE;QAClC,IAAI,AAAiB,YAAjB,OAAOA,OACP,KAAK,CAAC;YAAE,SAASA;YAAO,MAAM;gBAAE,QAAQ,EAAE;YAAC;QAAE,SAJnC,IAAI,GAAG;aAKd;YACH,MAAMC,SAASC,cAAcF;YAC7B,KAAK,CAAC;gBAAE,SAAS;gBAAsB,MAAM;oBAAEC;gBAAO;YAAE,SAP9C,IAAI,GAAG;QAQrB;IACJ;AACJ;AAQO,MAAME,gCAAgCP;IAGzC,YAAYI,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,iBAAiBI,OAAO;YACxB,MAAMC,WAAW,IAAIF,wBAAwBH;YAC7C,MAAMM,OAAoC;gBACtC,iBAAiBN,MAAM,OAAO;gBAC9B,cAAeA,MAAc,IAAI;gBACjC,cAAeA,MAAc,IAAI;YACrC;YACCK,SAAiB,IAAI,GAAGC;YACzBD,SAAS,KAAK,GAAGL,MAAM,KAAK;YAC5B,OAAOK;QACX;QAEA,OAAO,IAAIF,wBAAwB,IAAIC,MAAMG,OAAOP;IACxD;AACJ;AAEO,MAAMQ,kCAAkCZ;IAG3C,YAAYa,OAAe,CAAE;QACzB,KAAK,CAAC;YAAE,SAAS,CAAC,eAAe,EAAEA,QAAQ,gBAAgB,CAAC;QAAC,SAH/C,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,uCAAuCd;IAGhD,YAAYe,OAAe,CAAE;QACzB,KAAK,CAAC;YAAEA;QAAQ,SAHF,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,kCAAkChB;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 readonly permissions;
+    private readonly repository;
+    private readonly 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,48 @@
+import { Result } from "@webiny/feature/api";
+import { CreateWebhookRepository, CreateWebhookUseCase } from "./abstractions.js";
+import { CreateWebhookInputSchema } from "./schema.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);
+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());
+        const parsed = CreateWebhookInputSchema.safeParse(input);
+        if (!parsed.success) return Result.fail(new WebhookValidationError(parsed.error));
+        const slug = (parsed.data.slug || "").trim() || generateSlug(parsed.data.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: parsed.data.name,
+            slug,
+            endpointUrl: parsed.data.endpointUrl,
+            description: parsed.data.description,
+            enabled: parsed.data.enabled ?? false,
+            events: parsed.data.events,
+            signingSecret: parsed.data.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 { CreateWebhookInputSchema } from \"./schema.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\nclass CreateWebhookUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private readonly permissions: WebhookPermissions.Interface,\n        private readonly repository: CreateWebhookRepository.Interface,\n        private readonly 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        const parsed = CreateWebhookInputSchema.safeParse(input);\n        if (!parsed.success) {\n            return Result.fail(new WebhookValidationError(parsed.error));\n        }\n\n        const slug = (parsed.data.slug || \"\").trim() || generateSlug(parsed.data.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: parsed.data.name,\n            slug,\n            endpointUrl: parsed.data.endpointUrl,\n            description: parsed.data.description,\n            enabled: parsed.data.enabled ?? false,\n            events: parsed.data.events,\n            signingSecret: parsed.data.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","CreateWebhookUseCaseImpl","permissions","repository","listWebhooksRepository","input","Result","WebhookNotAuthorizedError","parsed","CreateWebhookInputSchema","WebhookValidationError","slug","listResult","webhook","CreateWebhookUseCase","UseCaseAbstraction","WebhookPermissions","CreateWebhookRepository","ListWebhooksRepository"],"mappings":";;;;;;AAWA,MAAMA,eAAe,CAACC,OACXA,KACF,WAAW,GACX,OAAO,CAAC,eAAe,KACvB,OAAO,CAAC,UAAU,IAClB,KAAK,CAAC,GAAG;AAGlB,MAAMC;IACF,YACqBC,WAAyC,EACzCC,UAA6C,EAC7CC,sBAAwD,CAC3E;aAHmBF,WAAW,GAAXA;aACAC,UAAU,GAAVA;aACAC,sBAAsB,GAAtBA;IAClB;IAEH,MAAM,QACFC,KAA+B,EACmB;QAClD,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,YACnC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAASC,yBAAyB,SAAS,CAACJ;QAClD,IAAI,CAACG,OAAO,OAAO,EACf,OAAOF,OAAO,IAAI,CAAC,IAAII,uBAAuBF,OAAO,KAAK;QAG9D,MAAMG,OAAQH,AAAAA,CAAAA,OAAO,IAAI,CAAC,IAAI,IAAI,EAAC,EAAG,IAAI,MAAMT,aAAaS,OAAO,IAAI,CAAC,IAAI;QAE7E,MAAMI,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,OAAON,OAAO,IAAI,CAAC,IAAII,uBAAuB,CAAC,MAAM,EAAEC,KAAK,mBAAmB,CAAC;QAGpF,MAAME,UAAiC;YACnC,MAAML,OAAO,IAAI,CAAC,IAAI;YACtBG;YACA,aAAaH,OAAO,IAAI,CAAC,WAAW;YACpC,aAAaA,OAAO,IAAI,CAAC,WAAW;YACpC,SAASA,OAAO,IAAI,CAAC,OAAO,IAAI;YAChC,QAAQA,OAAO,IAAI,CAAC,MAAM;YAC1B,eAAeA,OAAO,IAAI,CAAC,aAAa,IAAI;QAChD;QAEA,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACK;IACnC;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBd;IAChB,cAAc;QAACe;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/CreateWebhook/schema.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const CreateWebhookInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    endpointUrl: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    events: z.ZodArray<z.ZodString>;
+    signingSecret: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/api/features/CreateWebhook/schema.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { isValidEndpointUrl } from "../../utils/isValidEndpointUrl.js";
+const CreateWebhookInputSchema = z.object({
+    name: z.string().min(1, "Name is required."),
+    slug: z.string().optional(),
+    endpointUrl: z.string().refine(isValidEndpointUrl, {
+        message: "Endpoint URL must use HTTPS. HTTP is only allowed for localhost."
+    }),
+    description: z.string().optional(),
+    enabled: z.boolean().optional(),
+    events: z.array(z.string()).min(1, "At least one event must be selected."),
+    signingSecret: z.string().optional()
+});
+export { CreateWebhookInputSchema };
+
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateWebhook/schema.js","sources":["../../../../src/api/features/CreateWebhook/schema.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { isValidEndpointUrl } from \"~/api/utils/isValidEndpointUrl.js\";\n\nexport const CreateWebhookInputSchema = z.object({\n    name: z.string().min(1, \"Name is required.\"),\n    slug: z.string().optional(),\n    endpointUrl: z.string().refine(isValidEndpointUrl, {\n        message: \"Endpoint URL must use HTTPS. HTTP is only allowed for localhost.\"\n    }),\n    description: z.string().optional(),\n    enabled: z.boolean().optional(),\n    events: z.array(z.string()).min(1, \"At least one event must be selected.\"),\n    signingSecret: z.string().optional()\n});\n"],"names":["CreateWebhookInputSchema","z","isValidEndpointUrl"],"mappings":";;AAGO,MAAMA,2BAA2BC,EAAE,MAAM,CAAC;IAC7C,MAAMA,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;IACxB,MAAMA,EAAE,MAAM,GAAG,QAAQ;IACzB,aAAaA,EAAE,MAAM,GAAG,MAAM,CAACC,oBAAoB;QAC/C,SAAS;IACb;IACA,aAAaD,EAAE,MAAM,GAAG,QAAQ;IAChC,SAASA,EAAE,OAAO,GAAG,QAAQ;IAC7B,QAAQA,EAAE,KAAK,CAACA,EAAE,MAAM,IAAI,GAAG,CAAC,GAAG;IACnC,eAAeA,EAAE,MAAM,GAAG,QAAQ;AACtC"}

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 type { ICreateDeliveryInput } from "./abstractions.js";
+import { CreateWebhookDeliveryRepository as RepositoryAbstraction } 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,60 @@
+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 expiresAt = new Date(input.expiresAt);
+            const { entry } = await this.createEntryDataFactory.create(modelResult.value, {
+                values: storageValues,
+                expiresAt
+            });
+            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 type { ICreateDeliveryInput } from \"./abstractions.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 {\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 expiresAt = new Date(input.expiresAt);\n\n            const { entry } =\n                await this.createEntryDataFactory.create<WebhookDeliveryCmsEntryValues>(\n                    modelResult.value,\n                    {\n                        values: storageValues,\n                        expiresAt\n                    }\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","expiresAt","Date","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,MAAMM,YAAY,IAAIC,KAAKP,MAAM,SAAS;YAE1C,MAAM,EAAEQ,KAAK,EAAE,GACX,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACpCP,YAAY,KAAK,EACjB;gBACI,QAAQI;gBACRC;YACJ;YAGR,MAAMG,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACR,YAAY,KAAK,EAAEO;YAEjF,IAAIC,aAAa,MAAM,IACnB,OAAON,OAAO,IAAI,CAACO,wBAAwB,IAAI,CAACD,aAAa,KAAK;YAGtE,MAAME,WAAW,IAAI,CAAC,WAAW,CAAC,WAAW,CAACH;YAE9C,OAAOL,OAAO,EAAE,CAACQ;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOT,OAAO,IAAI,CAACO,wBAAwB,IAAI,CAACE;QACpD;IACJ;AACJ;AAEO,MAAMC,kEAAkCC,gCAAAA,oBAA0C,CAAC;IACtF,gBAAgBnB;IAChB,cAAc;QACVoB;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: Date;
+}
+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: Date;\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 {};

package/api/features/DeleteWebhook/DeleteWebhookRepository.js

@@ -0,0 +1,66 @@
+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 } from "./abstractions.js";
+import { WebhookModelNotFoundError, WebhookPersistenceError } from "../../domain/errors.js";
+import { WEBHOOK_DELIVERY_MODEL_ID, WEBHOOK_MODEL_ID } from "../../domain/constants.js";
+class DeleteWebhookRepositoryImpl {
+    constructor(getModelRepository, getLatestRevisionRepository, listEntriesRepository, deleteEntryRepository){
+        this.getModelRepository = getModelRepository;
+        this.getLatestRevisionRepository = getLatestRevisionRepository;
+        this.listEntriesRepository = listEntriesRepository;
+        this.deleteEntryRepository = deleteEntryRepository;
+    }
+    async execute(id) {
+        try {
+            const webhookModelResult = await this.getModelRepository.execute(WEBHOOK_MODEL_ID);
+            if (webhookModelResult.isFail()) return Result.fail(new WebhookModelNotFoundError(WEBHOOK_MODEL_ID));
+            const deliveryModelResult = await this.getModelRepository.execute(WEBHOOK_DELIVERY_MODEL_ID);
+            if (!deliveryModelResult.isFail()) try {
+                await this.deleteAllDeliveries(deliveryModelResult.value, id);
+            } catch  {}
+            const entryResult = await this.getLatestRevisionRepository.execute(webhookModelResult.value, {
+                id
+            });
+            if (entryResult.isFail()) return Result.fail(WebhookPersistenceError.from(entryResult.error));
+            const deleteResult = await this.deleteEntryRepository.execute(webhookModelResult.value, entryResult.value);
+            if (deleteResult.isFail()) return Result.fail(WebhookPersistenceError.from(deleteResult.error));
+            return Result.ok(true);
+        } catch (error) {
+            return Result.fail(WebhookPersistenceError.from(error));
+        }
+    }
+    async deleteAllDeliveries(deliveryModel, webhookId) {
+        let cursor;
+        let hasMore = true;
+        while(hasMore){
+            const listResult = await this.listEntriesRepository.execute(deliveryModel, {
+                where: {
+                    values: {
+                        webhookId
+                    }
+                },
+                limit: 100,
+                after: cursor
+            });
+            if (listResult.isFail()) throw listResult.error;
+            for (const entry of listResult.value.entries)await this.deleteEntryRepository.execute(deliveryModel, entry);
+            cursor = listResult.value.meta.cursor ?? void 0;
+            hasMore = !!cursor;
+        }
+    }
+}
+const DeleteWebhookRepository_DeleteWebhookRepository = DeleteWebhookRepository.createImplementation({
+    implementation: DeleteWebhookRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        GetLatestRevisionByEntryIdRepository,
+        ListEntriesRepository,
+        DeleteEntryRepository
+    ]
+});
+export { DeleteWebhookRepository_DeleteWebhookRepository as DeleteWebhookRepository };
+
+//# sourceMappingURL=DeleteWebhookRepository.js.map

package/api/features/DeleteWebhook/DeleteWebhookRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/DeleteWebhook/DeleteWebhookRepository.js","sources":["../../../../src/api/features/DeleteWebhook/DeleteWebhookRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/exports/api/cms/model.js\";\nimport type { CmsEntry } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { GetModelRepository } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { GetLatestRevisionByEntryIdRepository } from \"@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport { ListEntriesRepository } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js\";\nimport { DeleteEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport { DeleteWebhookRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { WebhookModelNotFoundError, WebhookPersistenceError } from \"~/api/domain/errors.js\";\nimport { WEBHOOK_MODEL_ID, WEBHOOK_DELIVERY_MODEL_ID } from \"~/api/domain/constants.js\";\n\nclass DeleteWebhookRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly listEntriesRepository: ListEntriesRepository.Interface,\n        private readonly deleteEntryRepository: DeleteEntryRepository.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<boolean, RepositoryAbstraction.Error>> {\n        try {\n            const webhookModelResult = await this.getModelRepository.execute(WEBHOOK_MODEL_ID);\n            if (webhookModelResult.isFail()) {\n                return Result.fail(new WebhookModelNotFoundError(WEBHOOK_MODEL_ID));\n            }\n\n            const deliveryModelResult =\n                await this.getModelRepository.execute(WEBHOOK_DELIVERY_MODEL_ID);\n            if (!deliveryModelResult.isFail()) {\n                try {\n                    await this.deleteAllDeliveries(deliveryModelResult.value, id);\n                } catch {\n                    /* Delivery cleanup is best-effort; proceed with webhook delete regardless. */\n                }\n            }\n\n            const entryResult = await this.getLatestRevisionRepository.execute(\n                webhookModelResult.value,\n                { id }\n            );\n            if (entryResult.isFail()) {\n                return Result.fail(WebhookPersistenceError.from(entryResult.error));\n            }\n\n            const deleteResult = await this.deleteEntryRepository.execute(\n                webhookModelResult.value,\n                entryResult.value\n            );\n\n            if (deleteResult.isFail()) {\n                return Result.fail(WebhookPersistenceError.from(deleteResult.error));\n            }\n\n            return Result.ok(true);\n        } catch (error) {\n            return Result.fail(WebhookPersistenceError.from(error));\n        }\n    }\n\n    private async deleteAllDeliveries(deliveryModel: CmsModel, webhookId: string): Promise<void> {\n        let cursor: string | undefined = undefined;\n        let hasMore = true;\n        while (hasMore) {\n            /* eslint-disable-next-line @typescript-eslint/no-explicit-any */\n            const listResult: Result<any, any> = await this.listEntriesRepository.execute(\n                deliveryModel,\n                {\n                    where: { values: { webhookId } },\n                    limit: 100,\n                    after: cursor\n                }\n            );\n\n            if (listResult.isFail()) {\n                throw listResult.error;\n            }\n\n            for (const entry of listResult.value.entries as CmsEntry[]) {\n                /* Individual delivery delete failures are best-effort; continue with the rest. */\n                await this.deleteEntryRepository.execute(deliveryModel, entry);\n            }\n\n            cursor = listResult.value.meta.cursor ?? undefined;\n            hasMore = !!cursor;\n        }\n    }\n}\n\nexport const DeleteWebhookRepository = RepositoryAbstraction.createImplementation({\n    implementation: DeleteWebhookRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetLatestRevisionByEntryIdRepository,\n        ListEntriesRepository,\n        DeleteEntryRepository\n    ]\n});\n"],"names":["DeleteWebhookRepositoryImpl","getModelRepository","getLatestRevisionRepository","listEntriesRepository","deleteEntryRepository","id","webhookModelResult","WEBHOOK_MODEL_ID","Result","WebhookModelNotFoundError","deliveryModelResult","WEBHOOK_DELIVERY_MODEL_ID","entryResult","WebhookPersistenceError","deleteResult","error","deliveryModel","webhookId","cursor","hasMore","listResult","entry","undefined","DeleteWebhookRepository","RepositoryAbstraction","GetModelRepository","GetLatestRevisionByEntryIdRepository","ListEntriesRepository","DeleteEntryRepository"],"mappings":";;;;;;;;AAWA,MAAMA;IACF,YACqBC,kBAAgD,EAChDC,2BAA2E,EAC3EC,qBAAsD,EACtDC,qBAAsD,CACzE;aAJmBH,kBAAkB,GAAlBA;aACAC,2BAA2B,GAA3BA;aACAC,qBAAqB,GAArBA;aACAC,qBAAqB,GAArBA;IAClB;IAEH,MAAM,QAAQC,EAAU,EAAyD;QAC7E,IAAI;YACA,MAAMC,qBAAqB,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACC;YACjE,IAAID,mBAAmB,MAAM,IACzB,OAAOE,OAAO,IAAI,CAAC,IAAIC,0BAA0BF;YAGrD,MAAMG,sBACF,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACC;YAC1C,IAAI,CAACD,oBAAoB,MAAM,IAC3B,IAAI;gBACA,MAAM,IAAI,CAAC,mBAAmB,CAACA,oBAAoB,KAAK,EAAEL;YAC9D,EAAE,OAAM,CAER;YAGJ,MAAMO,cAAc,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAC9DN,mBAAmB,KAAK,EACxB;gBAAED;YAAG;YAET,IAAIO,YAAY,MAAM,IAClB,OAAOJ,OAAO,IAAI,CAACK,wBAAwB,IAAI,CAACD,YAAY,KAAK;YAGrE,MAAME,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CACzDR,mBAAmB,KAAK,EACxBM,YAAY,KAAK;YAGrB,IAAIE,aAAa,MAAM,IACnB,OAAON,OAAO,IAAI,CAACK,wBAAwB,IAAI,CAACC,aAAa,KAAK;YAGtE,OAAON,OAAO,EAAE,CAAC;QACrB,EAAE,OAAOO,OAAO;YACZ,OAAOP,OAAO,IAAI,CAACK,wBAAwB,IAAI,CAACE;QACpD;IACJ;IAEA,MAAc,oBAAoBC,aAAuB,EAAEC,SAAiB,EAAiB;QACzF,IAAIC;QACJ,IAAIC,UAAU;QACd,MAAOA,QAAS;YAEZ,MAAMC,aAA+B,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CACzEJ,eACA;gBACI,OAAO;oBAAE,QAAQ;wBAAEC;oBAAU;gBAAE;gBAC/B,OAAO;gBACP,OAAOC;YACX;YAGJ,IAAIE,WAAW,MAAM,IACjB,MAAMA,WAAW,KAAK;YAG1B,KAAK,MAAMC,SAASD,WAAW,KAAK,CAAC,OAAO,CAExC,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACJ,eAAeK;YAG5DH,SAASE,WAAW,KAAK,CAAC,IAAI,CAAC,MAAM,IAAIE;YACzCH,UAAU,CAAC,CAACD;QAChB;IACJ;AACJ;AAEO,MAAMK,kDAA0BC,wBAAAA,oBAA0C,CAAC;IAC9E,gBAAgBxB;IAChB,cAAc;QACVyB;QACAC;QACAC;QACAC;KACH;AACL"}