@webiny/webhooks 6.4.0-beta.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerWebhook/feature.js","sources":["../../../../src/api/features/TriggerWebhook/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TriggerWebhookUseCase } from \"./TriggerWebhookUseCase.js\";\n\nexport const TriggerWebhookFeature = createFeature({\n    name: \"TriggerWebhook\",\n    register(container) {\n        container.register(TriggerWebhookUseCase);\n    }\n});\n"],"names":["TriggerWebhookFeature","createFeature","container","TriggerWebhookUseCase"],"mappings":";;AAGO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/api/features/UpdateWebhook/UpdateWebhookRepository.d.ts

@@ -0,0 +1,21 @@
+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 { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { UpdateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { WebhookTransformer } from "../../../api/features/Transformers/abstractions/WebhookTransformer.js";
+import { UpdateWebhookRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { Webhook } from "../../../api/domain/Webhook.js";
+declare class UpdateWebhookRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly updateEntryDataFactory;
+    private readonly updateEntryRepository;
+    private readonly transformer;
+    constructor(getModelRepository: GetModelRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, updateEntryDataFactory: UpdateEntryDataFactory.Interface, updateEntryRepository: UpdateEntryRepository.Interface, transformer: WebhookTransformer.Interface);
+    execute(webhook: Webhook): Promise<Result<Webhook, RepositoryAbstraction.Error>>;
+}
+export declare const UpdateWebhookRepository: typeof UpdateWebhookRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateWebhookRepository>;
+};
+export {};

package/api/features/UpdateWebhook/UpdateWebhookRepository.js

@@ -0,0 +1,50 @@
+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 { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { UpdateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { WebhookTransformer } from "../Transformers/abstractions/WebhookTransformer.js";
+import { UpdateWebhookRepository } from "./abstractions.js";
+import { WebhookModelNotFoundError, WebhookPersistenceError } from "../../domain/errors.js";
+import { WEBHOOK_MODEL_ID } from "../../domain/constants.js";
+class UpdateWebhookRepositoryImpl {
+    constructor(getModelRepository, getLatestRevisionRepository, updateEntryDataFactory, updateEntryRepository, transformer){
+        this.getModelRepository = getModelRepository;
+        this.getLatestRevisionRepository = getLatestRevisionRepository;
+        this.updateEntryDataFactory = updateEntryDataFactory;
+        this.updateEntryRepository = updateEntryRepository;
+        this.transformer = transformer;
+    }
+    async execute(webhook) {
+        try {
+            const modelResult = await this.getModelRepository.execute(WEBHOOK_MODEL_ID);
+            if (modelResult.isFail()) return Result.fail(new WebhookModelNotFoundError(WEBHOOK_MODEL_ID));
+            const entryResult = await this.getLatestRevisionRepository.execute(modelResult.value, {
+                id: webhook.id
+            });
+            if (entryResult.isFail()) return Result.fail(WebhookPersistenceError.from(entryResult.error));
+            const values = this.transformer.toStorage(webhook);
+            const { entry } = await this.updateEntryDataFactory.create(modelResult.value, {
+                values
+            }, entryResult.value);
+            const updateResult = await this.updateEntryRepository.execute(modelResult.value, entry);
+            if (updateResult.isFail()) return Result.fail(WebhookPersistenceError.from(updateResult.error));
+            return Result.ok(webhook);
+        } catch (error) {
+            return Result.fail(WebhookPersistenceError.from(error));
+        }
+    }
+}
+const UpdateWebhookRepository_UpdateWebhookRepository = UpdateWebhookRepository.createImplementation({
+    implementation: UpdateWebhookRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        GetLatestRevisionByEntryIdRepository,
+        UpdateEntryDataFactory,
+        UpdateEntryRepository,
+        WebhookTransformer
+    ]
+});
+export { UpdateWebhookRepository_UpdateWebhookRepository as UpdateWebhookRepository };
+
+//# sourceMappingURL=UpdateWebhookRepository.js.map

package/api/features/UpdateWebhook/UpdateWebhookRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateWebhook/UpdateWebhookRepository.js","sources":["../../../../src/api/features/UpdateWebhook/UpdateWebhookRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\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 { UpdateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { UpdateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { WebhookTransformer } from \"~/api/features/Transformers/abstractions/WebhookTransformer.js\";\nimport { UpdateWebhookRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { WebhookModelNotFoundError, WebhookPersistenceError } from \"~/api/domain/errors.js\";\nimport { WEBHOOK_MODEL_ID } from \"~/api/domain/constants.js\";\nimport type { Webhook, WebhookCmsEntryValues } from \"~/api/domain/Webhook.js\";\n\nclass UpdateWebhookRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly updateEntryDataFactory: UpdateEntryDataFactory.Interface,\n        private readonly updateEntryRepository: UpdateEntryRepository.Interface,\n        private readonly transformer: WebhookTransformer.Interface\n    ) {}\n\n    async execute(webhook: Webhook): Promise<Result<Webhook, RepositoryAbstraction.Error>> {\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 entryResult =\n                await this.getLatestRevisionRepository.execute<WebhookCmsEntryValues>(\n                    modelResult.value,\n                    { id: webhook.id }\n                );\n            if (entryResult.isFail()) {\n                return Result.fail(WebhookPersistenceError.from(entryResult.error));\n            }\n\n            const values = this.transformer.toStorage(webhook);\n\n            const { entry } = await this.updateEntryDataFactory.create<WebhookCmsEntryValues>(\n                modelResult.value,\n                { values },\n                entryResult.value\n            );\n\n            const updateResult = await this.updateEntryRepository.execute(modelResult.value, entry);\n\n            if (updateResult.isFail()) {\n                return Result.fail(WebhookPersistenceError.from(updateResult.error));\n            }\n\n            return Result.ok(webhook);\n        } catch (error) {\n            return Result.fail(WebhookPersistenceError.from(error));\n        }\n    }\n}\n\nexport const UpdateWebhookRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateWebhookRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetLatestRevisionByEntryIdRepository,\n        UpdateEntryDataFactory,\n        UpdateEntryRepository,\n        WebhookTransformer\n    ]\n});\n"],"names":["UpdateWebhookRepositoryImpl","getModelRepository","getLatestRevisionRepository","updateEntryDataFactory","updateEntryRepository","transformer","webhook","modelResult","WEBHOOK_MODEL_ID","Result","WebhookModelNotFoundError","entryResult","WebhookPersistenceError","values","entry","updateResult","error","UpdateWebhookRepository","RepositoryAbstraction","GetModelRepository","GetLatestRevisionByEntryIdRepository","UpdateEntryDataFactory","UpdateEntryRepository","WebhookTransformer"],"mappings":";;;;;;;;;AAWA,MAAMA;IACF,YACqBC,kBAAgD,EAChDC,2BAA2E,EAC3EC,sBAAwD,EACxDC,qBAAsD,EACtDC,WAAyC,CAC5D;aALmBJ,kBAAkB,GAAlBA;aACAC,2BAA2B,GAA3BA;aACAC,sBAAsB,GAAtBA;aACAC,qBAAqB,GAArBA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAM,QAAQC,OAAgB,EAAyD;QACnF,IAAI;YACA,MAAMC,cAAc,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACC;YAC1D,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CAAC,IAAIC,0BAA0BF;YAGrD,MAAMG,cACF,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAC1CJ,YAAY,KAAK,EACjB;gBAAE,IAAID,QAAQ,EAAE;YAAC;YAEzB,IAAIK,YAAY,MAAM,IAClB,OAAOF,OAAO,IAAI,CAACG,wBAAwB,IAAI,CAACD,YAAY,KAAK;YAGrE,MAAME,SAAS,IAAI,CAAC,WAAW,CAAC,SAAS,CAACP;YAE1C,MAAM,EAAEQ,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACtDP,YAAY,KAAK,EACjB;gBAAEM;YAAO,GACTF,YAAY,KAAK;YAGrB,MAAMI,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACR,YAAY,KAAK,EAAEO;YAEjF,IAAIC,aAAa,MAAM,IACnB,OAAON,OAAO,IAAI,CAACG,wBAAwB,IAAI,CAACG,aAAa,KAAK;YAGtE,OAAON,OAAO,EAAE,CAACH;QACrB,EAAE,OAAOU,OAAO;YACZ,OAAOP,OAAO,IAAI,CAACG,wBAAwB,IAAI,CAACI;QACpD;IACJ;AACJ;AAEO,MAAMC,kDAA0BC,wBAAAA,oBAA0C,CAAC;IAC9E,gBAAgBlB;IAChB,cAAc;QACVmB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/api/features/UpdateWebhook/UpdateWebhookUseCase.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateWebhookUseCase as UseCaseAbstraction, UpdateWebhookRepository } from "./abstractions.js";
+import { GetWebhookRepository } from "../../../api/features/GetWebhook/abstractions.js";
+import { WebhookPermissions } from "../../../api/features/WebhookPermissions/abstractions.js";
+import type { Webhook } from "../../../api/domain/Webhook.js";
+declare class UpdateWebhookUseCaseImpl implements UseCaseAbstraction.Interface {
+    private permissions;
+    private getWebhookRepository;
+    private updateRepository;
+    constructor(permissions: WebhookPermissions.Interface, getWebhookRepository: GetWebhookRepository.Interface, updateRepository: UpdateWebhookRepository.Interface);
+    execute(id: string, input: UseCaseAbstraction.Input): Promise<Result<Webhook, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateWebhookUseCase: typeof UpdateWebhookUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateWebhookUseCase>;
+};
+export {};

package/api/features/UpdateWebhook/UpdateWebhookUseCase.js

@@ -0,0 +1,66 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateWebhookRepository, UpdateWebhookUseCase } from "./abstractions.js";
+import { GetWebhookRepository } from "../GetWebhook/abstractions.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError, WebhookValidationError } from "../../domain/errors.js";
+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 UpdateWebhookUseCaseImpl {
+    constructor(permissions, getWebhookRepository, updateRepository){
+        this.permissions = permissions;
+        this.getWebhookRepository = getWebhookRepository;
+        this.updateRepository = updateRepository;
+    }
+    async execute(id, input) {
+        if (!await this.permissions.canEdit("webhook")) return Result.fail(new WebhookNotAuthorizedError());
+        const getResult = await this.getWebhookRepository.execute(id);
+        if (getResult.isFail()) return Result.fail(getResult.error);
+        const existing = getResult.value;
+        if (input.endpointUrl && !isValidEndpointUrl(input.endpointUrl)) return Result.fail(new WebhookValidationError("Endpoint URL must use HTTPS. HTTP is only allowed for localhost."));
+        if (void 0 !== input.events && 0 === input.events.length) return Result.fail(new WebhookValidationError("At least one event must be selected."));
+        const updated = {
+            ...existing,
+            ...void 0 !== input.name ? {
+                name: input.name
+            } : {},
+            ...void 0 !== input.slug ? {
+                slug: input.slug
+            } : {},
+            ...void 0 !== input.endpointUrl ? {
+                endpointUrl: input.endpointUrl
+            } : {},
+            ...void 0 !== input.description ? {
+                description: input.description
+            } : {},
+            ...void 0 !== input.enabled ? {
+                enabled: input.enabled
+            } : {},
+            ...void 0 !== input.events ? {
+                events: input.events
+            } : {},
+            ...void 0 !== input.signingSecret ? {
+                signingSecret: input.signingSecret
+            } : {}
+        };
+        return this.updateRepository.execute(updated);
+    }
+}
+const UpdateWebhookUseCase_UpdateWebhookUseCase = UpdateWebhookUseCase.createImplementation({
+    implementation: UpdateWebhookUseCaseImpl,
+    dependencies: [
+        WebhookPermissions,
+        GetWebhookRepository,
+        UpdateWebhookRepository
+    ]
+});
+export { UpdateWebhookUseCase_UpdateWebhookUseCase as UpdateWebhookUseCase };
+
+//# sourceMappingURL=UpdateWebhookUseCase.js.map

package/api/features/UpdateWebhook/UpdateWebhookUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateWebhook/UpdateWebhookUseCase.js","sources":["../../../../src/api/features/UpdateWebhook/UpdateWebhookUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    UpdateWebhookUseCase as UseCaseAbstraction,\n    UpdateWebhookRepository\n} from \"./abstractions.js\";\nimport { GetWebhookRepository } from \"~/api/features/GetWebhook/abstractions.js\";\nimport { WebhookPermissions } from \"~/api/features/WebhookPermissions/abstractions.js\";\nimport { WebhookValidationError, WebhookNotAuthorizedError } from \"~/api/domain/errors.js\";\nimport type { Webhook } from \"~/api/domain/Webhook.js\";\n\nconst isValidEndpointUrl = (url: string): boolean => {\n    try {\n        const parsed = new URL(url);\n        if (parsed.protocol === \"https:\") {\n            return true;\n        }\n        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 UpdateWebhookUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private permissions: WebhookPermissions.Interface,\n        private getWebhookRepository: GetWebhookRepository.Interface,\n        private updateRepository: UpdateWebhookRepository.Interface\n    ) {}\n\n    async execute(\n        id: string,\n        input: UseCaseAbstraction.Input\n    ): Promise<Result<Webhook, UseCaseAbstraction.Error>> {\n        if (!(await this.permissions.canEdit(\"webhook\"))) {\n            return Result.fail(new WebhookNotAuthorizedError());\n        }\n\n        const getResult = await this.getWebhookRepository.execute(id);\n        if (getResult.isFail()) {\n            return Result.fail(getResult.error);\n        }\n\n        const existing = getResult.value;\n\n        if (input.endpointUrl && !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 !== undefined && input.events.length === 0) {\n            return Result.fail(new WebhookValidationError(\"At least one event must be selected.\"));\n        }\n\n        const updated: Webhook = {\n            ...existing,\n            ...(input.name !== undefined ? { name: input.name } : {}),\n            ...(input.slug !== undefined ? { slug: input.slug } : {}),\n            ...(input.endpointUrl !== undefined ? { endpointUrl: input.endpointUrl } : {}),\n            ...(input.description !== undefined ? { description: input.description } : {}),\n            ...(input.enabled !== undefined ? { enabled: input.enabled } : {}),\n            ...(input.events !== undefined ? { events: input.events } : {}),\n            ...(input.signingSecret !== undefined ? { signingSecret: input.signingSecret } : {})\n        };\n\n        return this.updateRepository.execute(updated);\n    }\n}\n\nexport const UpdateWebhookUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UpdateWebhookUseCaseImpl,\n    dependencies: [WebhookPermissions, GetWebhookRepository, UpdateWebhookRepository]\n});\n"],"names":["isValidEndpointUrl","url","parsed","URL","UpdateWebhookUseCaseImpl","permissions","getWebhookRepository","updateRepository","id","input","Result","WebhookNotAuthorizedError","getResult","existing","WebhookValidationError","undefined","updated","UpdateWebhookUseCase","UseCaseAbstraction","WebhookPermissions","GetWebhookRepository","UpdateWebhookRepository"],"mappings":";;;;;AAUA,MAAMA,qBAAqB,CAACC;IACxB,IAAI;QACA,MAAMC,SAAS,IAAIC,IAAIF;QACvB,IAAIC,AAAoB,aAApBA,OAAO,QAAQ,EACf,OAAO;QAEX,IACIA,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,oBAAoD,EACpDC,gBAAmD,CAC7D;aAHUF,WAAW,GAAXA;aACAC,oBAAoB,GAApBA;aACAC,gBAAgB,GAAhBA;IACT;IAEH,MAAM,QACFC,EAAU,EACVC,KAA+B,EACmB;QAClD,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,YACjC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,YAAY,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAACJ;QAC1D,IAAII,UAAU,MAAM,IAChB,OAAOF,OAAO,IAAI,CAACE,UAAU,KAAK;QAGtC,MAAMC,WAAWD,UAAU,KAAK;QAEhC,IAAIH,MAAM,WAAW,IAAI,CAACT,mBAAmBS,MAAM,WAAW,GAC1D,OAAOC,OAAO,IAAI,CACd,IAAII,uBACA;QAKZ,IAAIL,AAAiBM,WAAjBN,MAAM,MAAM,IAAkBA,AAAwB,MAAxBA,MAAM,MAAM,CAAC,MAAM,EACjD,OAAOC,OAAO,IAAI,CAAC,IAAII,uBAAuB;QAGlD,MAAME,UAAmB;YACrB,GAAGH,QAAQ;YACX,GAAIJ,AAAeM,WAAfN,MAAM,IAAI,GAAiB;gBAAE,MAAMA,MAAM,IAAI;YAAC,IAAI,CAAC,CAAC;YACxD,GAAIA,AAAeM,WAAfN,MAAM,IAAI,GAAiB;gBAAE,MAAMA,MAAM,IAAI;YAAC,IAAI,CAAC,CAAC;YACxD,GAAIA,AAAsBM,WAAtBN,MAAM,WAAW,GAAiB;gBAAE,aAAaA,MAAM,WAAW;YAAC,IAAI,CAAC,CAAC;YAC7E,GAAIA,AAAsBM,WAAtBN,MAAM,WAAW,GAAiB;gBAAE,aAAaA,MAAM,WAAW;YAAC,IAAI,CAAC,CAAC;YAC7E,GAAIA,AAAkBM,WAAlBN,MAAM,OAAO,GAAiB;gBAAE,SAASA,MAAM,OAAO;YAAC,IAAI,CAAC,CAAC;YACjE,GAAIA,AAAiBM,WAAjBN,MAAM,MAAM,GAAiB;gBAAE,QAAQA,MAAM,MAAM;YAAC,IAAI,CAAC,CAAC;YAC9D,GAAIA,AAAwBM,WAAxBN,MAAM,aAAa,GAAiB;gBAAE,eAAeA,MAAM,aAAa;YAAC,IAAI,CAAC,CAAC;QACvF;QAEA,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACO;IACzC;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBd;IAChB,cAAc;QAACe;QAAoBC;QAAsBC;KAAwB;AACrF"}

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

@@ -0,0 +1,31 @@
+import { type Result } from "@webiny/feature/api";
+import type { Webhook } from "../../../api/domain/Webhook.js";
+import type { WebhookNotFoundError, WebhookValidationError, WebhookPersistenceError, WebhookModelNotFoundError, WebhookNotAuthorizedError } from "../../../api/domain/errors.js";
+export interface IUpdateWebhookInput {
+    name?: string;
+    slug?: string;
+    endpointUrl?: string;
+    description?: string;
+    enabled?: boolean;
+    events?: string[];
+    signingSecret?: string;
+}
+type IError = WebhookNotFoundError | WebhookValidationError | WebhookPersistenceError | WebhookModelNotFoundError | WebhookNotAuthorizedError;
+export interface IUpdateWebhookUseCase {
+    execute(id: string, input: IUpdateWebhookInput): Promise<Result<Webhook, IError>>;
+}
+export declare const UpdateWebhookUseCase: import("@webiny/di").Abstraction<IUpdateWebhookUseCase>;
+export declare namespace UpdateWebhookUseCase {
+    type Interface = IUpdateWebhookUseCase;
+    type Input = IUpdateWebhookInput;
+    type Error = IError;
+}
+export interface IUpdateWebhookRepository {
+    execute(webhook: Webhook): Promise<Result<Webhook, WebhookPersistenceError | WebhookModelNotFoundError>>;
+}
+export declare const UpdateWebhookRepository: import("@webiny/di").Abstraction<IUpdateWebhookRepository>;
+export declare namespace UpdateWebhookRepository {
+    type Interface = IUpdateWebhookRepository;
+    type Error = WebhookPersistenceError | WebhookModelNotFoundError;
+}
+export {};

package/api/features/UpdateWebhook/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateWebhook/abstractions.js","sources":["../../../../src/api/features/UpdateWebhook/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { Webhook } from \"~/api/domain/Webhook.js\";\nimport type {\n    WebhookNotFoundError,\n    WebhookValidationError,\n    WebhookPersistenceError,\n    WebhookModelNotFoundError,\n    WebhookNotAuthorizedError\n} from \"~/api/domain/errors.js\";\n\nexport interface IUpdateWebhookInput {\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    | WebhookNotFoundError\n    | WebhookValidationError\n    | WebhookPersistenceError\n    | WebhookModelNotFoundError\n    | WebhookNotAuthorizedError;\n\nexport interface IUpdateWebhookUseCase {\n    execute(id: string, input: IUpdateWebhookInput): Promise<Result<Webhook, IError>>;\n}\n\nexport const UpdateWebhookUseCase = createAbstraction<IUpdateWebhookUseCase>(\n    \"Webhooks/UpdateWebhookUseCase\"\n);\n\nexport namespace UpdateWebhookUseCase {\n    export type Interface = IUpdateWebhookUseCase;\n    export type Input = IUpdateWebhookInput;\n    export type Error = IError;\n}\n\nexport interface IUpdateWebhookRepository {\n    execute(\n        webhook: Webhook\n    ): Promise<Result<Webhook, WebhookPersistenceError | WebhookModelNotFoundError>>;\n}\n\nexport const UpdateWebhookRepository = createAbstraction<IUpdateWebhookRepository>(\n    \"Webhooks/UpdateWebhookRepository\"\n);\n\nexport namespace UpdateWebhookRepository {\n    export type Interface = IUpdateWebhookRepository;\n    export type Error = WebhookPersistenceError | WebhookModelNotFoundError;\n}\n"],"names":["UpdateWebhookUseCase","createAbstraction","UpdateWebhookRepository"],"mappings":";AA+BO,MAAMA,uBAAuBC,kBAChC;AAeG,MAAMC,0BAA0BD,kBACnC"}

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

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

package/api/features/UpdateWebhook/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateWebhook/feature.js","sources":["../../../../src/api/features/UpdateWebhook/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateWebhookUseCase } from \"./UpdateWebhookUseCase.js\";\nimport { UpdateWebhookRepository } from \"./UpdateWebhookRepository.js\";\n\nexport const UpdateWebhookFeature = createFeature({\n    name: \"UpdateWebhook\",\n    register(container) {\n        container.register(UpdateWebhookUseCase);\n        container.register(UpdateWebhookRepository).inSingletonScope();\n    }\n});\n"],"names":["UpdateWebhookFeature","createFeature","container","UpdateWebhookUseCase","UpdateWebhookRepository"],"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/UpdateWebhookDelivery/UpdateWebhookDeliveryRepository.d.ts

@@ -0,0 +1,22 @@
+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 { UpdateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { WebhookDeliveryTransformer } from "../../../api/features/Transformers/abstractions/WebhookDeliveryTransformer.js";
+import { UpdateWebhookDeliveryRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { IUpdateDeliveryInput } from "./abstractions.js";
+import type { WebhookDelivery } from "../../../api/domain/WebhookDelivery.js";
+declare class UpdateWebhookDeliveryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly updateEntryDataFactory;
+    private readonly updateEntryRepository;
+    private readonly transformer;
+    constructor(getModelRepository: GetModelRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, updateEntryDataFactory: UpdateEntryDataFactory.Interface, updateEntryRepository: UpdateEntryRepository.Interface, transformer: WebhookDeliveryTransformer.Interface);
+    execute(id: string, input: IUpdateDeliveryInput): Promise<Result<WebhookDelivery, RepositoryAbstraction.Error>>;
+}
+export declare const UpdateWebhookDeliveryRepository: typeof UpdateWebhookDeliveryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateWebhookDeliveryRepository>;
+};
+export {};

package/api/features/UpdateWebhookDelivery/UpdateWebhookDeliveryRepository.js

@@ -0,0 +1,62 @@
+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 { UpdateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { WebhookDeliveryTransformer } from "../Transformers/abstractions/WebhookDeliveryTransformer.js";
+import { UpdateWebhookDeliveryRepository } from "./abstractions.js";
+import { WebhookDeliveryNotFoundError, WebhookModelNotFoundError, WebhookPersistenceError } from "../../domain/errors.js";
+import { WEBHOOK_DELIVERY_MODEL_ID } from "../../domain/constants.js";
+class UpdateWebhookDeliveryRepositoryImpl {
+    constructor(getModelRepository, getLatestRevisionRepository, updateEntryDataFactory, updateEntryRepository, transformer){
+        this.getModelRepository = getModelRepository;
+        this.getLatestRevisionRepository = getLatestRevisionRepository;
+        this.updateEntryDataFactory = updateEntryDataFactory;
+        this.updateEntryRepository = updateEntryRepository;
+        this.transformer = transformer;
+    }
+    async execute(id, 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 entryResult = await this.getLatestRevisionRepository.execute(modelResult.value, {
+                id
+            });
+            if (entryResult.isFail()) return Result.fail(new WebhookDeliveryNotFoundError(id));
+            const originalEntry = entryResult.value;
+            const existing = this.transformer.fromStorage(originalEntry);
+            const updated = {
+                ...existing,
+                backgroundTaskId: input.backgroundTaskId ?? existing.backgroundTaskId,
+                status: input.status ?? existing.status,
+                payload: input.payload ?? existing.payload,
+                requestHeaders: input.requestHeaders ?? existing.requestHeaders,
+                responseTime: input.responseTime ?? existing.responseTime,
+                responseStatus: input.responseStatus ?? existing.responseStatus,
+                responseBody: input.responseBody ?? existing.responseBody
+            };
+            const storageValues = this.transformer.toStorage(updated);
+            const { entry } = await this.updateEntryDataFactory.create(modelResult.value, {
+                values: storageValues
+            }, originalEntry);
+            const updateResult = await this.updateEntryRepository.execute(modelResult.value, entry);
+            if (updateResult.isFail()) return Result.fail(WebhookPersistenceError.from(updateResult.error));
+            return Result.ok(updated);
+        } catch (error) {
+            return Result.fail(WebhookPersistenceError.from(error));
+        }
+    }
+}
+const UpdateWebhookDeliveryRepository_UpdateWebhookDeliveryRepository = UpdateWebhookDeliveryRepository.createImplementation({
+    implementation: UpdateWebhookDeliveryRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        GetLatestRevisionByEntryIdRepository,
+        UpdateEntryDataFactory,
+        UpdateEntryRepository,
+        WebhookDeliveryTransformer
+    ]
+});
+export { UpdateWebhookDeliveryRepository_UpdateWebhookDeliveryRepository as UpdateWebhookDeliveryRepository };
+
+//# sourceMappingURL=UpdateWebhookDeliveryRepository.js.map

package/api/features/UpdateWebhookDelivery/UpdateWebhookDeliveryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateWebhookDelivery/UpdateWebhookDeliveryRepository.js","sources":["../../../../src/api/features/UpdateWebhookDelivery/UpdateWebhookDeliveryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\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 { UpdateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { UpdateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { WebhookDeliveryTransformer } from \"~/api/features/Transformers/abstractions/WebhookDeliveryTransformer.js\";\nimport { UpdateWebhookDeliveryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport {\n    WebhookDeliveryNotFoundError,\n    WebhookModelNotFoundError,\n    WebhookPersistenceError\n} from \"~/api/domain/errors.js\";\nimport { WEBHOOK_DELIVERY_MODEL_ID } from \"~/api/domain/constants.js\";\nimport type { IUpdateDeliveryInput } from \"./abstractions.js\";\nimport type {\n    WebhookDelivery,\n    WebhookDeliveryCmsEntryValues\n} from \"~/api/domain/WebhookDelivery.js\";\n\nclass UpdateWebhookDeliveryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly updateEntryDataFactory: UpdateEntryDataFactory.Interface,\n        private readonly updateEntryRepository: UpdateEntryRepository.Interface,\n        private readonly transformer: WebhookDeliveryTransformer.Interface\n    ) {}\n\n    async execute(\n        id: string,\n        input: IUpdateDeliveryInput\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 entryResult =\n                await this.getLatestRevisionRepository.execute<WebhookDeliveryCmsEntryValues>(\n                    modelResult.value,\n                    { id }\n                );\n\n            if (entryResult.isFail()) {\n                return Result.fail(new WebhookDeliveryNotFoundError(id));\n            }\n\n            const originalEntry = entryResult.value;\n            const existing = this.transformer.fromStorage(originalEntry);\n\n            const updated: WebhookDelivery = {\n                ...existing,\n                backgroundTaskId: input.backgroundTaskId ?? existing.backgroundTaskId,\n                status: input.status ?? existing.status,\n                payload: input.payload ?? existing.payload,\n                requestHeaders: input.requestHeaders ?? existing.requestHeaders,\n                responseTime: input.responseTime ?? existing.responseTime,\n                responseStatus: input.responseStatus ?? existing.responseStatus,\n                responseBody: input.responseBody ?? existing.responseBody\n            };\n\n            const storageValues = this.transformer.toStorage(updated);\n\n            const { entry } =\n                await this.updateEntryDataFactory.create<WebhookDeliveryCmsEntryValues>(\n                    modelResult.value,\n                    { values: storageValues },\n                    originalEntry\n                );\n\n            const updateResult = await this.updateEntryRepository.execute(modelResult.value, entry);\n\n            if (updateResult.isFail()) {\n                return Result.fail(WebhookPersistenceError.from(updateResult.error));\n            }\n\n            return Result.ok(updated);\n        } catch (error) {\n            return Result.fail(WebhookPersistenceError.from(error));\n        }\n    }\n}\n\nexport const UpdateWebhookDeliveryRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateWebhookDeliveryRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetLatestRevisionByEntryIdRepository,\n        UpdateEntryDataFactory,\n        UpdateEntryRepository,\n        WebhookDeliveryTransformer\n    ]\n});\n"],"names":["UpdateWebhookDeliveryRepositoryImpl","getModelRepository","getLatestRevisionRepository","updateEntryDataFactory","updateEntryRepository","transformer","id","input","modelResult","WEBHOOK_DELIVERY_MODEL_ID","Result","WebhookModelNotFoundError","entryResult","WebhookDeliveryNotFoundError","originalEntry","existing","updated","storageValues","entry","updateResult","WebhookPersistenceError","error","UpdateWebhookDeliveryRepository","RepositoryAbstraction","GetModelRepository","GetLatestRevisionByEntryIdRepository","UpdateEntryDataFactory","UpdateEntryRepository","WebhookDeliveryTransformer"],"mappings":";;;;;;;;;AAmBA,MAAMA;IACF,YACqBC,kBAAgD,EAChDC,2BAA2E,EAC3EC,sBAAwD,EACxDC,qBAAsD,EACtDC,WAAiD,CACpE;aALmBJ,kBAAkB,GAAlBA;aACAC,2BAA2B,GAA3BA;aACAC,sBAAsB,GAAtBA;aACAC,qBAAqB,GAArBA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAM,QACFC,EAAU,EACVC,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,cACF,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAC1CJ,YAAY,KAAK,EACjB;gBAAEF;YAAG;YAGb,IAAIM,YAAY,MAAM,IAClB,OAAOF,OAAO,IAAI,CAAC,IAAIG,6BAA6BP;YAGxD,MAAMQ,gBAAgBF,YAAY,KAAK;YACvC,MAAMG,WAAW,IAAI,CAAC,WAAW,CAAC,WAAW,CAACD;YAE9C,MAAME,UAA2B;gBAC7B,GAAGD,QAAQ;gBACX,kBAAkBR,MAAM,gBAAgB,IAAIQ,SAAS,gBAAgB;gBACrE,QAAQR,MAAM,MAAM,IAAIQ,SAAS,MAAM;gBACvC,SAASR,MAAM,OAAO,IAAIQ,SAAS,OAAO;gBAC1C,gBAAgBR,MAAM,cAAc,IAAIQ,SAAS,cAAc;gBAC/D,cAAcR,MAAM,YAAY,IAAIQ,SAAS,YAAY;gBACzD,gBAAgBR,MAAM,cAAc,IAAIQ,SAAS,cAAc;gBAC/D,cAAcR,MAAM,YAAY,IAAIQ,SAAS,YAAY;YAC7D;YAEA,MAAME,gBAAgB,IAAI,CAAC,WAAW,CAAC,SAAS,CAACD;YAEjD,MAAM,EAAEE,KAAK,EAAE,GACX,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACpCV,YAAY,KAAK,EACjB;gBAAE,QAAQS;YAAc,GACxBH;YAGR,MAAMK,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACX,YAAY,KAAK,EAAEU;YAEjF,IAAIC,aAAa,MAAM,IACnB,OAAOT,OAAO,IAAI,CAACU,wBAAwB,IAAI,CAACD,aAAa,KAAK;YAGtE,OAAOT,OAAO,EAAE,CAACM;QACrB,EAAE,OAAOK,OAAO;YACZ,OAAOX,OAAO,IAAI,CAACU,wBAAwB,IAAI,CAACC;QACpD;IACJ;AACJ;AAEO,MAAMC,kEAAkCC,gCAAAA,oBAA0C,CAAC;IACtF,gBAAgBvB;IAChB,cAAc;QACVwB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,23 @@
+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, WebhookDeliveryNotFoundError } from "../../../api/domain/errors.js";
+export interface IUpdateDeliveryInput {
+    backgroundTaskId?: string;
+    status?: WebhookDeliveryStatus;
+    payload?: GenericRecord;
+    requestHeaders?: object;
+    responseTime?: number;
+    responseStatus?: number;
+    responseBody?: string;
+}
+type IError = WebhookPersistenceError | WebhookModelNotFoundError | WebhookDeliveryNotFoundError;
+export interface IUpdateWebhookDeliveryRepository {
+    execute(id: string, input: IUpdateDeliveryInput): Promise<Result<WebhookDelivery, IError>>;
+}
+export declare const UpdateWebhookDeliveryRepository: import("@webiny/di").Abstraction<IUpdateWebhookDeliveryRepository>;
+export declare namespace UpdateWebhookDeliveryRepository {
+    type Interface = IUpdateWebhookDeliveryRepository;
+    type Error = IError;
+}
+export {};

package/api/features/UpdateWebhookDelivery/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateWebhookDelivery/abstractions.js","sources":["../../../../src/api/features/UpdateWebhookDelivery/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 {\n    WebhookPersistenceError,\n    WebhookModelNotFoundError,\n    WebhookDeliveryNotFoundError\n} from \"~/api/domain/errors.js\";\n\nexport interface IUpdateDeliveryInput {\n    backgroundTaskId?: string;\n    status?: WebhookDeliveryStatus;\n    payload?: GenericRecord;\n    requestHeaders?: object;\n    responseTime?: number;\n    responseStatus?: number;\n    responseBody?: string;\n}\n\ntype IError = WebhookPersistenceError | WebhookModelNotFoundError | WebhookDeliveryNotFoundError;\n\nexport interface IUpdateWebhookDeliveryRepository {\n    execute(id: string, input: IUpdateDeliveryInput): Promise<Result<WebhookDelivery, IError>>;\n}\n\nexport const UpdateWebhookDeliveryRepository = createAbstraction<IUpdateWebhookDeliveryRepository>(\n    \"Webhooks/UpdateWebhookDeliveryRepository\"\n);\n\nexport namespace UpdateWebhookDeliveryRepository {\n    export type Interface = IUpdateWebhookDeliveryRepository;\n    export type Error = IError;\n}\n"],"names":["UpdateWebhookDeliveryRepository","createAbstraction"],"mappings":";AAyBO,MAAMA,kCAAkCC,kBAC3C"}

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

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

package/api/features/UpdateWebhookDelivery/feature.js

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

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

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

package/api/features/WebhookDispatcher/WebhookDispatcher.d.ts

@@ -0,0 +1,17 @@
+import { WebhookDispatcher as WebhookDispatcherAbstraction, WebhookProvider } from "@webiny/api-core/features/webhooks/index.js";
+import { TaskService } from "@webiny/api-core/exports/api/tasks.js";
+import { ListWebhooksRepository } from "../../../api/features/ListWebhooks/abstractions.js";
+import { CreateWebhookDeliveryRepository } from "../../../api/features/CreateWebhookDelivery/abstractions.js";
+import type { IWebhookDispatcherData } from "@webiny/api-core/features/webhooks/WebhookDispatcher/abstractions.js";
+declare class WebhookDispatcherImpl implements WebhookDispatcherAbstraction.Interface {
+    private readonly listWebhooksRepository;
+    private readonly createDeliveryRepository;
+    private readonly taskService;
+    private readonly provider;
+    constructor(listWebhooksRepository: ListWebhooksRepository.Interface, createDeliveryRepository: CreateWebhookDeliveryRepository.Interface, taskService: TaskService.Interface, provider: WebhookProvider.Interface);
+    dispatch<T extends IWebhookDispatcherData = IWebhookDispatcherData>(eventName: string, payload: T): Promise<void>;
+}
+export declare const WebhookDispatcher: typeof WebhookDispatcherImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/webhooks/WebhookDispatcher/abstractions.js").IWebhookDispatcher>;
+};
+export {};

package/api/features/WebhookDispatcher/WebhookDispatcher.js

@@ -0,0 +1,56 @@
+import { WebhookDispatcher, WebhookProvider } from "@webiny/api-core/features/webhooks/index.js";
+import { TaskService } from "@webiny/api-core/exports/api/tasks.js";
+import { ListWebhooksRepository } from "../ListWebhooks/abstractions.js";
+import { CreateWebhookDeliveryRepository } from "../CreateWebhookDelivery/abstractions.js";
+import { SEND_WEBHOOK_TASK, WEBHOOK_DELIVERY_RETENTION_DAYS } from "../../domain/constants.js";
+class WebhookDispatcherImpl {
+    constructor(listWebhooksRepository, createDeliveryRepository, taskService, provider){
+        this.listWebhooksRepository = listWebhooksRepository;
+        this.createDeliveryRepository = createDeliveryRepository;
+        this.taskService = taskService;
+        this.provider = provider;
+    }
+    async dispatch(eventName, payload) {
+        const events = await this.provider.execute();
+        const event = events.find((event)=>event.eventName === eventName);
+        if (!event) return;
+        const result = await this.listWebhooksRepository.execute({
+            where: {
+                enabled: true,
+                events_contains: eventName
+            }
+        });
+        if (result.isFail()) return;
+        const expiresAt = new Date(Date.now() + 24 * WEBHOOK_DELIVERY_RETENTION_DAYS * 3600000).toISOString();
+        for (const webhook of result.value.items){
+            const deliveryResult = await this.createDeliveryRepository.execute({
+                webhookId: webhook.id,
+                eventType: event.eventName,
+                status: "pending",
+                expiresAt,
+                payload
+            });
+            if (!deliveryResult.isFail()) await this.taskService.trigger({
+                definition: SEND_WEBHOOK_TASK,
+                name: `Webhook: ${webhook.slug} — ${event.eventName}`,
+                input: {
+                    webhookId: webhook.id,
+                    eventName,
+                    deliveryId: deliveryResult.value.id
+                }
+            });
+        }
+    }
+}
+const WebhookDispatcher_WebhookDispatcher = WebhookDispatcher.createImplementation({
+    implementation: WebhookDispatcherImpl,
+    dependencies: [
+        ListWebhooksRepository,
+        CreateWebhookDeliveryRepository,
+        TaskService,
+        WebhookProvider
+    ]
+});
+export { WebhookDispatcher_WebhookDispatcher as WebhookDispatcher };
+
+//# sourceMappingURL=WebhookDispatcher.js.map

package/api/features/WebhookDispatcher/WebhookDispatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WebhookDispatcher/WebhookDispatcher.js","sources":["../../../../src/api/features/WebhookDispatcher/WebhookDispatcher.ts"],"sourcesContent":["import {\n    WebhookDispatcher as WebhookDispatcherAbstraction,\n    WebhookProvider\n} from \"@webiny/api-core/features/webhooks/index.js\";\nimport { TaskService } from \"@webiny/api-core/exports/api/tasks.js\";\nimport { ListWebhooksRepository } from \"~/api/features/ListWebhooks/abstractions.js\";\nimport { CreateWebhookDeliveryRepository } from \"~/api/features/CreateWebhookDelivery/abstractions.js\";\nimport { SEND_WEBHOOK_TASK, WEBHOOK_DELIVERY_RETENTION_DAYS } from \"~/api/domain/constants.js\";\nimport type { IWebhookDispatcherData } from \"@webiny/api-core/features/webhooks/WebhookDispatcher/abstractions.js\";\nimport type { ISendWebhookTaskInput } from \"~/api/features/SendWebhookTask/types.js\";\n\nclass WebhookDispatcherImpl implements WebhookDispatcherAbstraction.Interface {\n    constructor(\n        private readonly listWebhooksRepository: ListWebhooksRepository.Interface,\n        private readonly createDeliveryRepository: CreateWebhookDeliveryRepository.Interface,\n        private readonly taskService: TaskService.Interface,\n        private readonly provider: WebhookProvider.Interface\n    ) {}\n\n    async dispatch<T extends IWebhookDispatcherData = IWebhookDispatcherData>(\n        eventName: string,\n        payload: T\n    ): Promise<void> {\n        /**\n         * Let's first check if there is defined webhook event with the given name.\n         * If not, we can just skip the dispatching process and db query.\n         */\n        const events = await this.provider.execute();\n        const event = events.find(event => {\n            return event.eventName === eventName;\n        });\n        if (!event) {\n            return;\n        }\n        /**\n         * Then we go and find all webhooks that are enabled and have the given event in their events list.\n         */\n        const result = await this.listWebhooksRepository.execute({\n            where: {\n                enabled: true,\n                events_contains: eventName\n            }\n        });\n\n        if (result.isFail()) {\n            return;\n        }\n\n        const expiresAt = new Date(\n            Date.now() + WEBHOOK_DELIVERY_RETENTION_DAYS * 24 * 60 * 60 * 1000\n        ).toISOString();\n\n        for (const webhook of result.value.items) {\n            const deliveryResult = await this.createDeliveryRepository.execute({\n                webhookId: webhook.id,\n                eventType: event.eventName,\n                status: \"pending\",\n                expiresAt,\n                payload\n            });\n\n            if (deliveryResult.isFail()) {\n                continue;\n            }\n\n            await this.taskService.trigger<ISendWebhookTaskInput>({\n                definition: SEND_WEBHOOK_TASK,\n                name: `Webhook: ${webhook.slug} — ${event.eventName}`,\n                input: {\n                    webhookId: webhook.id,\n                    eventName,\n                    deliveryId: deliveryResult.value.id\n                }\n            });\n        }\n    }\n}\n\nexport const WebhookDispatcher = WebhookDispatcherAbstraction.createImplementation({\n    implementation: WebhookDispatcherImpl,\n    dependencies: [\n        ListWebhooksRepository,\n        CreateWebhookDeliveryRepository,\n        TaskService,\n        WebhookProvider\n    ]\n});\n"],"names":["WebhookDispatcherImpl","listWebhooksRepository","createDeliveryRepository","taskService","provider","eventName","payload","events","event","result","expiresAt","Date","WEBHOOK_DELIVERY_RETENTION_DAYS","webhook","deliveryResult","SEND_WEBHOOK_TASK","WebhookDispatcher","WebhookDispatcherAbstraction","ListWebhooksRepository","CreateWebhookDeliveryRepository","TaskService","WebhookProvider"],"mappings":";;;;;AAWA,MAAMA;IACF,YACqBC,sBAAwD,EACxDC,wBAAmE,EACnEC,WAAkC,EAClCC,QAAmC,CACtD;aAJmBH,sBAAsB,GAAtBA;aACAC,wBAAwB,GAAxBA;aACAC,WAAW,GAAXA;aACAC,QAAQ,GAARA;IAClB;IAEH,MAAM,SACFC,SAAiB,EACjBC,OAAU,EACG;QAKb,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO;QAC1C,MAAMC,QAAQD,OAAO,IAAI,CAACC,CAAAA,QACfA,MAAM,SAAS,KAAKH;QAE/B,IAAI,CAACG,OACD;QAKJ,MAAMC,SAAS,MAAM,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC;YACrD,OAAO;gBACH,SAAS;gBACT,iBAAiBJ;YACrB;QACJ;QAEA,IAAII,OAAO,MAAM,IACb;QAGJ,MAAMC,YAAY,IAAIC,KAClBA,KAAK,GAAG,KAAKC,AAAkC,KAAlCA,kCAAAA,SACf,WAAW;QAEb,KAAK,MAAMC,WAAWJ,OAAO,KAAK,CAAC,KAAK,CAAE;YACtC,MAAMK,iBAAiB,MAAM,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC;gBAC/D,WAAWD,QAAQ,EAAE;gBACrB,WAAWL,MAAM,SAAS;gBAC1B,QAAQ;gBACRE;gBACAJ;YACJ;YAEA,KAAIQ,eAAe,MAAM,IAIzB,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAwB;gBAClD,YAAYC;gBACZ,MAAM,CAAC,SAAS,EAAEF,QAAQ,IAAI,CAAC,GAAG,EAAEL,MAAM,SAAS,EAAE;gBACrD,OAAO;oBACH,WAAWK,QAAQ,EAAE;oBACrBR;oBACA,YAAYS,eAAe,KAAK,CAAC,EAAE;gBACvC;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,sCAAoBC,kBAAAA,oBAAiD,CAAC;IAC/E,gBAAgBjB;IAChB,cAAc;QACVkB;QACAC;QACAC;QACAC;KACH;AACL"}

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

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

package/api/features/WebhookDispatcher/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WebhookDispatcher/feature.js","sources":["../../../../src/api/features/WebhookDispatcher/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { WebhookDispatcher } from \"./WebhookDispatcher.js\";\n\nexport const WebhookDispatcherFeature = createFeature({\n    name: \"WebhookDispatcher\",\n    register(container) {\n        container.register(WebhookDispatcher).inSingletonScope();\n    }\n});\n"],"names":["WebhookDispatcherFeature","createFeature","container","WebhookDispatcher"],"mappings":";;AAGO,MAAMA,2BAA2BC,cAAc;IAClD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,mBAAmB,gBAAgB;IAC1D;AACJ"}

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

@@ -0,0 +1,17 @@
+import type { Permissions } from "@webiny/api-core/features/security/permissions/index.js";
+import { WEBHOOK_PERMISSIONS_SCHEMA } from "../../../api/permissions.js";
+export declare const WebhookPermissions: import("@webiny/di").Abstraction<import("@webiny/api-core/features/security/permissions/types").PermissionsTyped<{
+    readonly prefix: "webhooks";
+    readonly fullAccess: true;
+    readonly entities: readonly [{
+        readonly id: "webhook";
+        readonly permission: "webhooks.webhook";
+        readonly scopes: readonly ["full"];
+        readonly actions: readonly [{
+            readonly name: "rwd";
+        }];
+    }];
+}>>;
+export declare namespace WebhookPermissions {
+    type Interface = Permissions<typeof WEBHOOK_PERMISSIONS_SCHEMA>;
+}

package/api/features/WebhookPermissions/abstractions.js

@@ -0,0 +1,6 @@
+import { createPermissionsAbstraction } from "@webiny/api-core/features/security/permissions/index.js";
+import { WEBHOOK_PERMISSIONS_SCHEMA } from "../../permissions.js";
+const WebhookPermissions = createPermissionsAbstraction(WEBHOOK_PERMISSIONS_SCHEMA);
+export { WebhookPermissions };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WebhookPermissions/abstractions.js","sources":["../../../../src/api/features/WebhookPermissions/abstractions.ts"],"sourcesContent":["import { createPermissionsAbstraction } from \"@webiny/api-core/features/security/permissions/index.js\";\nimport type { Permissions } from \"@webiny/api-core/features/security/permissions/index.js\";\nimport { WEBHOOK_PERMISSIONS_SCHEMA } from \"~/api/permissions.js\";\n\nexport const WebhookPermissions = createPermissionsAbstraction(WEBHOOK_PERMISSIONS_SCHEMA);\n\nexport namespace WebhookPermissions {\n    export type Interface = Permissions<typeof WEBHOOK_PERMISSIONS_SCHEMA>;\n}\n"],"names":["WebhookPermissions","createPermissionsAbstraction","WEBHOOK_PERMISSIONS_SCHEMA"],"mappings":";;AAIO,MAAMA,qBAAqBC,6BAA6BC"}

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

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

package/api/features/WebhookPermissions/feature.js

@@ -0,0 +1,7 @@
+import { createPermissionsFeature } from "@webiny/api-core/features/security/permissions/index.js";
+import { WEBHOOK_PERMISSIONS_SCHEMA } from "../../permissions.js";
+import { WebhookPermissions } from "./abstractions.js";
+const WebhookPermissionsFeature = createPermissionsFeature(WEBHOOK_PERMISSIONS_SCHEMA, WebhookPermissions);
+export { WebhookPermissionsFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WebhookPermissions/feature.js","sources":["../../../../src/api/features/WebhookPermissions/feature.ts"],"sourcesContent":["import { createPermissionsFeature } from \"@webiny/api-core/features/security/permissions/index.js\";\nimport { WEBHOOK_PERMISSIONS_SCHEMA } from \"~/api/permissions.js\";\nimport { WebhookPermissions } from \"./abstractions.js\";\n\nexport const WebhookPermissionsFeature = createPermissionsFeature(\n    WEBHOOK_PERMISSIONS_SCHEMA,\n    WebhookPermissions\n);\n"],"names":["WebhookPermissionsFeature","createPermissionsFeature","WEBHOOK_PERMISSIONS_SCHEMA","WebhookPermissions"],"mappings":";;;AAIO,MAAMA,4BAA4BC,yBACrCC,4BACAC"}

package/api/features/WebhookSignPayload/WebhookSignPayload.d.ts

@@ -0,0 +1,8 @@
+import { WebhookSignPayload as WebhookSignPayloadAbstraction } from "@webiny/api-core/features/webhooks/index.js";
+declare class WebhookSignPayloadImpl implements WebhookSignPayloadAbstraction.Interface {
+    sign(msgId: string, timestamp: Date, rawBody: string | Buffer, secret: string): Promise<WebhookSignPayloadAbstraction.Headers>;
+}
+export declare const WebhookSignPayload: typeof WebhookSignPayloadImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/webhooks/WebhookSignPayload/abstractions").IWebhookSignPayload>;
+};
+export {};