@webiny/webhooks 6.4.0-beta.1

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"}

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

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteWebhookUseCase as UseCaseAbstraction, DeleteWebhookRepository } from "./abstractions.js";
+import { GetWebhookRepository } from "../../../api/features/GetWebhook/abstractions.js";
+import { WebhookPermissions } from "../../../api/features/WebhookPermissions/abstractions.js";
+declare class DeleteWebhookUseCaseImpl implements UseCaseAbstraction.Interface {
+    private permissions;
+    private getWebhookRepository;
+    private deleteRepository;
+    constructor(permissions: WebhookPermissions.Interface, getWebhookRepository: GetWebhookRepository.Interface, deleteRepository: DeleteWebhookRepository.Interface);
+    execute(id: string): Promise<Result<boolean, UseCaseAbstraction.Error>>;
+}
+export declare const DeleteWebhookUseCase: typeof DeleteWebhookUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteWebhookUseCase>;
+};
+export {};

package/api/features/DeleteWebhook/DeleteWebhookUseCase.js

@@ -0,0 +1,29 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteWebhookRepository, DeleteWebhookUseCase } from "./abstractions.js";
+import { GetWebhookRepository } from "../GetWebhook/abstractions.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError } from "../../domain/errors.js";
+class DeleteWebhookUseCaseImpl {
+    constructor(permissions, getWebhookRepository, deleteRepository){
+        this.permissions = permissions;
+        this.getWebhookRepository = getWebhookRepository;
+        this.deleteRepository = deleteRepository;
+    }
+    async execute(id) {
+        if (!await this.permissions.canDelete("webhook")) return Result.fail(new WebhookNotAuthorizedError());
+        const getResult = await this.getWebhookRepository.execute(id);
+        if (getResult.isFail()) return Result.fail(getResult.error);
+        return this.deleteRepository.execute(id);
+    }
+}
+const DeleteWebhookUseCase_DeleteWebhookUseCase = DeleteWebhookUseCase.createImplementation({
+    implementation: DeleteWebhookUseCaseImpl,
+    dependencies: [
+        WebhookPermissions,
+        GetWebhookRepository,
+        DeleteWebhookRepository
+    ]
+});
+export { DeleteWebhookUseCase_DeleteWebhookUseCase as DeleteWebhookUseCase };
+
+//# sourceMappingURL=DeleteWebhookUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/DeleteWebhook/DeleteWebhookUseCase.js","sources":["../../../../src/api/features/DeleteWebhook/DeleteWebhookUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    DeleteWebhookUseCase as UseCaseAbstraction,\n    DeleteWebhookRepository\n} from \"./abstractions.js\";\nimport { GetWebhookRepository } from \"~/api/features/GetWebhook/abstractions.js\";\nimport { WebhookPermissions } from \"~/api/features/WebhookPermissions/abstractions.js\";\nimport { WebhookNotAuthorizedError } from \"~/api/domain/errors.js\";\n\nclass DeleteWebhookUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private permissions: WebhookPermissions.Interface,\n        private getWebhookRepository: GetWebhookRepository.Interface,\n        private deleteRepository: DeleteWebhookRepository.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<boolean, UseCaseAbstraction.Error>> {\n        if (!(await this.permissions.canDelete(\"webhook\"))) {\n            return Result.fail(new WebhookNotAuthorizedError());\n        }\n        const getResult = await this.getWebhookRepository.execute(id);\n        if (getResult.isFail()) {\n            return Result.fail(getResult.error);\n        }\n        return this.deleteRepository.execute(id);\n    }\n}\n\nexport const DeleteWebhookUseCase = UseCaseAbstraction.createImplementation({\n    implementation: DeleteWebhookUseCaseImpl,\n    dependencies: [WebhookPermissions, GetWebhookRepository, DeleteWebhookRepository]\n});\n"],"names":["DeleteWebhookUseCaseImpl","permissions","getWebhookRepository","deleteRepository","id","Result","WebhookNotAuthorizedError","getResult","DeleteWebhookUseCase","UseCaseAbstraction","WebhookPermissions","GetWebhookRepository","DeleteWebhookRepository"],"mappings":";;;;;AASA,MAAMA;IACF,YACYC,WAAyC,EACzCC,oBAAoD,EACpDC,gBAAmD,CAC7D;aAHUF,WAAW,GAAXA;aACAC,oBAAoB,GAApBA;aACAC,gBAAgB,GAAhBA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAsD;QAC1E,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,YACnC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAE3B,MAAMC,YAAY,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAACH;QAC1D,IAAIG,UAAU,MAAM,IAChB,OAAOF,OAAO,IAAI,CAACE,UAAU,KAAK;QAEtC,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACH;IACzC;AACJ;AAEO,MAAMI,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBT;IAChB,cAAc;QAACU;QAAoBC;QAAsBC;KAAwB;AACrF"}

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

@@ -0,0 +1,20 @@
+import { type Result } from "@webiny/feature/api";
+import type { WebhookNotFoundError, WebhookPersistenceError, WebhookModelNotFoundError, WebhookNotAuthorizedError } from "../../../api/domain/errors.js";
+type IError = WebhookNotFoundError | WebhookPersistenceError | WebhookModelNotFoundError | WebhookNotAuthorizedError;
+export interface IDeleteWebhookUseCase {
+    execute(id: string): Promise<Result<boolean, IError>>;
+}
+export declare const DeleteWebhookUseCase: import("@webiny/di").Abstraction<IDeleteWebhookUseCase>;
+export declare namespace DeleteWebhookUseCase {
+    type Interface = IDeleteWebhookUseCase;
+    type Error = IError;
+}
+export interface IDeleteWebhookRepository {
+    execute(id: string): Promise<Result<boolean, IError>>;
+}
+export declare const DeleteWebhookRepository: import("@webiny/di").Abstraction<IDeleteWebhookRepository>;
+export declare namespace DeleteWebhookRepository {
+    type Interface = IDeleteWebhookRepository;
+    type Error = IError;
+}
+export {};

package/api/features/DeleteWebhook/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/DeleteWebhook/abstractions.js","sources":["../../../../src/api/features/DeleteWebhook/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type {\n    WebhookNotFoundError,\n    WebhookPersistenceError,\n    WebhookModelNotFoundError,\n    WebhookNotAuthorizedError\n} from \"~/api/domain/errors.js\";\n\ntype IError =\n    | WebhookNotFoundError\n    | WebhookPersistenceError\n    | WebhookModelNotFoundError\n    | WebhookNotAuthorizedError;\n\nexport interface IDeleteWebhookUseCase {\n    execute(id: string): Promise<Result<boolean, IError>>;\n}\n\nexport const DeleteWebhookUseCase = createAbstraction<IDeleteWebhookUseCase>(\n    \"Webhooks/DeleteWebhookUseCase\"\n);\n\nexport namespace DeleteWebhookUseCase {\n    export type Interface = IDeleteWebhookUseCase;\n    export type Error = IError;\n}\n\nexport interface IDeleteWebhookRepository {\n    execute(id: string): Promise<Result<boolean, IError>>;\n}\n\nexport const DeleteWebhookRepository = createAbstraction<IDeleteWebhookRepository>(\n    \"Webhooks/DeleteWebhookRepository\"\n);\n\nexport namespace DeleteWebhookRepository {\n    export type Interface = IDeleteWebhookRepository;\n    export type Error = IError;\n}\n"],"names":["DeleteWebhookUseCase","createAbstraction","DeleteWebhookRepository"],"mappings":";AAkBO,MAAMA,uBAAuBC,kBAChC;AAYG,MAAMC,0BAA0BD,kBACnC"}

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

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

package/api/features/DeleteWebhook/feature.js

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

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

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

@@ -0,0 +1,17 @@
+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 { WebhookTransformer } from "../../../api/features/Transformers/abstractions/WebhookTransformer.js";
+import { GetWebhookRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { Webhook } from "../../../api/domain/Webhook.js";
+declare class GetWebhookRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly transformer;
+    constructor(getModelRepository: GetModelRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, transformer: WebhookTransformer.Interface);
+    execute(id: string): Promise<Result<Webhook, RepositoryAbstraction.Error>>;
+}
+export declare const GetWebhookRepository: typeof GetWebhookRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetWebhookRepository>;
+};
+export {};

package/api/features/GetWebhook/GetWebhookRepository.js

@@ -0,0 +1,39 @@
+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 { WebhookTransformer } from "../Transformers/abstractions/WebhookTransformer.js";
+import { GetWebhookRepository } from "./abstractions.js";
+import { WebhookModelNotFoundError, WebhookNotFoundError, WebhookPersistenceError } from "../../domain/errors.js";
+import { WEBHOOK_MODEL_ID } from "../../domain/constants.js";
+class GetWebhookRepositoryImpl {
+    constructor(getModelRepository, getLatestRevisionRepository, transformer){
+        this.getModelRepository = getModelRepository;
+        this.getLatestRevisionRepository = getLatestRevisionRepository;
+        this.transformer = transformer;
+    }
+    async execute(id) {
+        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
+            });
+            if (entryResult.isFail()) return Result.fail(new WebhookNotFoundError(id));
+            const webhook = this.transformer.fromStorage(entryResult.value);
+            return Result.ok(webhook);
+        } catch (error) {
+            return Result.fail(WebhookPersistenceError.from(error));
+        }
+    }
+}
+const GetWebhookRepository_GetWebhookRepository = GetWebhookRepository.createImplementation({
+    implementation: GetWebhookRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        GetLatestRevisionByEntryIdRepository,
+        WebhookTransformer
+    ]
+});
+export { GetWebhookRepository_GetWebhookRepository as GetWebhookRepository };
+
+//# sourceMappingURL=GetWebhookRepository.js.map

package/api/features/GetWebhook/GetWebhookRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhook/GetWebhookRepository.js","sources":["../../../../src/api/features/GetWebhook/GetWebhookRepository.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 { WebhookTransformer } from \"~/api/features/Transformers/abstractions/WebhookTransformer.js\";\nimport { GetWebhookRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport {\n    WebhookNotFoundError,\n    WebhookModelNotFoundError,\n    WebhookPersistenceError\n} 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 GetWebhookRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly transformer: WebhookTransformer.Interface\n    ) {}\n\n    async execute(id: string): 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 }\n                );\n\n            if (entryResult.isFail()) {\n                return Result.fail(new WebhookNotFoundError(id));\n            }\n\n            const webhook = this.transformer.fromStorage(entryResult.value);\n\n            return Result.ok(webhook);\n        } catch (error) {\n            return Result.fail(WebhookPersistenceError.from(error));\n        }\n    }\n}\n\nexport const GetWebhookRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetWebhookRepositoryImpl,\n    dependencies: [GetModelRepository, GetLatestRevisionByEntryIdRepository, WebhookTransformer]\n});\n"],"names":["GetWebhookRepositoryImpl","getModelRepository","getLatestRevisionRepository","transformer","id","modelResult","WEBHOOK_MODEL_ID","Result","WebhookModelNotFoundError","entryResult","WebhookNotFoundError","webhook","error","WebhookPersistenceError","GetWebhookRepository","RepositoryAbstraction","GetModelRepository","GetLatestRevisionByEntryIdRepository","WebhookTransformer"],"mappings":";;;;;;;AAaA,MAAMA;IACF,YACqBC,kBAAgD,EAChDC,2BAA2E,EAC3EC,WAAyC,CAC5D;aAHmBF,kBAAkB,GAAlBA;aACAC,2BAA2B,GAA3BA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAM,QAAQC,EAAU,EAAyD;QAC7E,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;gBAAED;YAAG;YAGb,IAAIK,YAAY,MAAM,IAClB,OAAOF,OAAO,IAAI,CAAC,IAAIG,qBAAqBN;YAGhD,MAAMO,UAAU,IAAI,CAAC,WAAW,CAAC,WAAW,CAACF,YAAY,KAAK;YAE9D,OAAOF,OAAO,EAAE,CAACI;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOL,OAAO,IAAI,CAACM,wBAAwB,IAAI,CAACD;QACpD;IACJ;AACJ;AAEO,MAAME,4CAAuBC,qBAAAA,oBAA0C,CAAC;IAC3E,gBAAgBf;IAChB,cAAc;QAACgB;QAAoBC;QAAsCC;KAAmB;AAChG"}

package/api/features/GetWebhook/GetWebhookUseCase.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { GetWebhookUseCase as UseCaseAbstraction, GetWebhookRepository } from "./abstractions.js";
+import { WebhookPermissions } from "../../../api/features/WebhookPermissions/abstractions.js";
+import type { Webhook } from "../../../api/domain/Webhook.js";
+declare class GetWebhookUseCaseImpl implements UseCaseAbstraction.Interface {
+    private permissions;
+    private repository;
+    constructor(permissions: WebhookPermissions.Interface, repository: GetWebhookRepository.Interface);
+    execute(id: string): Promise<Result<Webhook, UseCaseAbstraction.Error>>;
+}
+export declare const GetWebhookUseCase: typeof GetWebhookUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetWebhookUseCase>;
+};
+export {};

package/api/features/GetWebhook/GetWebhookUseCase.js

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { GetWebhookRepository, GetWebhookUseCase } from "./abstractions.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError } from "../../domain/errors.js";
+class GetWebhookUseCaseImpl {
+    constructor(permissions, repository){
+        this.permissions = permissions;
+        this.repository = repository;
+    }
+    async execute(id) {
+        if (!await this.permissions.canRead("webhook")) return Result.fail(new WebhookNotAuthorizedError());
+        return this.repository.execute(id);
+    }
+}
+const GetWebhookUseCase_GetWebhookUseCase = GetWebhookUseCase.createImplementation({
+    implementation: GetWebhookUseCaseImpl,
+    dependencies: [
+        WebhookPermissions,
+        GetWebhookRepository
+    ]
+});
+export { GetWebhookUseCase_GetWebhookUseCase as GetWebhookUseCase };
+
+//# sourceMappingURL=GetWebhookUseCase.js.map

package/api/features/GetWebhook/GetWebhookUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhook/GetWebhookUseCase.js","sources":["../../../../src/api/features/GetWebhook/GetWebhookUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetWebhookUseCase as UseCaseAbstraction, GetWebhookRepository } from \"./abstractions.js\";\nimport { WebhookPermissions } from \"~/api/features/WebhookPermissions/abstractions.js\";\nimport { WebhookNotAuthorizedError } from \"~/api/domain/errors.js\";\nimport type { Webhook } from \"~/api/domain/Webhook.js\";\n\nclass GetWebhookUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private permissions: WebhookPermissions.Interface,\n        private repository: GetWebhookRepository.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<Webhook, UseCaseAbstraction.Error>> {\n        if (!(await this.permissions.canRead(\"webhook\"))) {\n            return Result.fail(new WebhookNotAuthorizedError());\n        }\n        return this.repository.execute(id);\n    }\n}\n\nexport const GetWebhookUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetWebhookUseCaseImpl,\n    dependencies: [WebhookPermissions, GetWebhookRepository]\n});\n"],"names":["GetWebhookUseCaseImpl","permissions","repository","id","Result","WebhookNotAuthorizedError","GetWebhookUseCase","UseCaseAbstraction","WebhookPermissions","GetWebhookRepository"],"mappings":";;;;AAMA,MAAMA;IACF,YACYC,WAAyC,EACzCC,UAA0C,CACpD;aAFUD,WAAW,GAAXA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAsD;QAC1E,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,YACjC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAE3B,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACF;IACnC;AACJ;AAEO,MAAMG,sCAAoBC,kBAAAA,oBAAuC,CAAC;IACrE,gBAAgBP;IAChB,cAAc;QAACQ;QAAoBC;KAAqB;AAC5D"}

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

@@ -0,0 +1,21 @@
+import { type Result } from "@webiny/feature/api";
+import type { Webhook } from "../../../api/domain/Webhook.js";
+import type { WebhookNotFoundError, WebhookModelNotFoundError, WebhookPersistenceError, WebhookNotAuthorizedError } from "../../../api/domain/errors.js";
+type IError = WebhookNotFoundError | WebhookModelNotFoundError | WebhookPersistenceError | WebhookNotAuthorizedError;
+export interface IGetWebhookUseCase {
+    execute(id: string): Promise<Result<Webhook, IError>>;
+}
+export declare const GetWebhookUseCase: import("@webiny/di").Abstraction<IGetWebhookUseCase>;
+export declare namespace GetWebhookUseCase {
+    type Interface = IGetWebhookUseCase;
+    type Error = IError;
+}
+export interface IGetWebhookRepository {
+    execute(id: string): Promise<Result<Webhook, IError>>;
+}
+export declare const GetWebhookRepository: import("@webiny/di").Abstraction<IGetWebhookRepository>;
+export declare namespace GetWebhookRepository {
+    type Interface = IGetWebhookRepository;
+    type Error = IError;
+}
+export {};

package/api/features/GetWebhook/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhook/abstractions.js","sources":["../../../../src/api/features/GetWebhook/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { Webhook } from \"~/api/domain/Webhook.js\";\nimport type {\n    WebhookNotFoundError,\n    WebhookModelNotFoundError,\n    WebhookPersistenceError,\n    WebhookNotAuthorizedError\n} from \"~/api/domain/errors.js\";\n\ntype IError =\n    | WebhookNotFoundError\n    | WebhookModelNotFoundError\n    | WebhookPersistenceError\n    | WebhookNotAuthorizedError;\n\nexport interface IGetWebhookUseCase {\n    execute(id: string): Promise<Result<Webhook, IError>>;\n}\n\nexport const GetWebhookUseCase = createAbstraction<IGetWebhookUseCase>(\n    \"Webhooks/GetWebhookUseCase\"\n);\n\nexport namespace GetWebhookUseCase {\n    export type Interface = IGetWebhookUseCase;\n    export type Error = IError;\n}\n\nexport interface IGetWebhookRepository {\n    execute(id: string): Promise<Result<Webhook, IError>>;\n}\n\nexport const GetWebhookRepository = createAbstraction<IGetWebhookRepository>(\n    \"Webhooks/GetWebhookRepository\"\n);\n\nexport namespace GetWebhookRepository {\n    export type Interface = IGetWebhookRepository;\n    export type Error = IError;\n}\n"],"names":["GetWebhookUseCase","createAbstraction","GetWebhookRepository"],"mappings":";AAmBO,MAAMA,oBAAoBC,kBAC7B;AAYG,MAAMC,uBAAuBD,kBAChC"}

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

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

package/api/features/GetWebhook/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhook/feature.js","sources":["../../../../src/api/features/GetWebhook/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetWebhookUseCase } from \"./GetWebhookUseCase.js\";\nimport { GetWebhookRepository } from \"./GetWebhookRepository.js\";\n\nexport const GetWebhookFeature = createFeature({\n    name: \"GetWebhook\",\n    register(container) {\n        container.register(GetWebhookUseCase);\n        container.register(GetWebhookRepository).inSingletonScope();\n    }\n});\n"],"names":["GetWebhookFeature","createFeature","container","GetWebhookUseCase","GetWebhookRepository"],"mappings":";;;AAIO,MAAMA,oBAAoBC,cAAc;IAC3C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,sBAAsB,gBAAgB;IAC7D;AACJ"}

package/api/features/GetWebhookDelivery/GetWebhookDeliveryRepository.d.ts

@@ -0,0 +1,17 @@
+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 { WebhookDeliveryTransformer } from "../../../api/features/Transformers/abstractions/WebhookDeliveryTransformer.js";
+import { GetWebhookDeliveryRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { WebhookDelivery } from "../../../api/domain/WebhookDelivery.js";
+declare class GetWebhookDeliveryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly transformer;
+    constructor(getModelRepository: GetModelRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, transformer: WebhookDeliveryTransformer.Interface);
+    execute(id: string): Promise<Result<WebhookDelivery, RepositoryAbstraction.Error>>;
+}
+export declare const GetWebhookDeliveryRepository: typeof GetWebhookDeliveryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetWebhookDeliveryRepository>;
+};
+export {};

package/api/features/GetWebhookDelivery/GetWebhookDeliveryRepository.js

@@ -0,0 +1,39 @@
+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 { WebhookDeliveryTransformer } from "../Transformers/abstractions/WebhookDeliveryTransformer.js";
+import { GetWebhookDeliveryRepository } from "./abstractions.js";
+import { WebhookDeliveryNotFoundError, WebhookModelNotFoundError, WebhookPersistenceError } from "../../domain/errors.js";
+import { WEBHOOK_DELIVERY_MODEL_ID } from "../../domain/constants.js";
+class GetWebhookDeliveryRepositoryImpl {
+    constructor(getModelRepository, getLatestRevisionRepository, transformer){
+        this.getModelRepository = getModelRepository;
+        this.getLatestRevisionRepository = getLatestRevisionRepository;
+        this.transformer = transformer;
+    }
+    async execute(id) {
+        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 delivery = this.transformer.fromStorage(entryResult.value);
+            return Result.ok(delivery);
+        } catch (error) {
+            return Result.fail(WebhookPersistenceError.from(error));
+        }
+    }
+}
+const GetWebhookDeliveryRepository_GetWebhookDeliveryRepository = GetWebhookDeliveryRepository.createImplementation({
+    implementation: GetWebhookDeliveryRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        GetLatestRevisionByEntryIdRepository,
+        WebhookDeliveryTransformer
+    ]
+});
+export { GetWebhookDeliveryRepository_GetWebhookDeliveryRepository as GetWebhookDeliveryRepository };
+
+//# sourceMappingURL=GetWebhookDeliveryRepository.js.map

package/api/features/GetWebhookDelivery/GetWebhookDeliveryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhookDelivery/GetWebhookDeliveryRepository.js","sources":["../../../../src/api/features/GetWebhookDelivery/GetWebhookDeliveryRepository.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 { WebhookDeliveryTransformer } from \"~/api/features/Transformers/abstractions/WebhookDeliveryTransformer.js\";\nimport { GetWebhookDeliveryRepository 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 {\n    WebhookDelivery,\n    WebhookDeliveryCmsEntryValues\n} from \"~/api/domain/WebhookDelivery.js\";\n\nclass GetWebhookDeliveryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly transformer: WebhookDeliveryTransformer.Interface\n    ) {}\n\n    async execute(id: string): 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 delivery = this.transformer.fromStorage(entryResult.value);\n\n            return Result.ok(delivery);\n        } catch (error) {\n            return Result.fail(WebhookPersistenceError.from(error));\n        }\n    }\n}\n\nexport const GetWebhookDeliveryRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetWebhookDeliveryRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetLatestRevisionByEntryIdRepository,\n        WebhookDeliveryTransformer\n    ]\n});\n"],"names":["GetWebhookDeliveryRepositoryImpl","getModelRepository","getLatestRevisionRepository","transformer","id","modelResult","WEBHOOK_DELIVERY_MODEL_ID","Result","WebhookModelNotFoundError","entryResult","WebhookDeliveryNotFoundError","delivery","error","WebhookPersistenceError","GetWebhookDeliveryRepository","RepositoryAbstraction","GetModelRepository","GetLatestRevisionByEntryIdRepository","WebhookDeliveryTransformer"],"mappings":";;;;;;;AAgBA,MAAMA;IACF,YACqBC,kBAAgD,EAChDC,2BAA2E,EAC3EC,WAAiD,CACpE;aAHmBF,kBAAkB,GAAlBA;aACAC,2BAA2B,GAA3BA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAM,QAAQC,EAAU,EAAiE;QACrF,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;gBAAED;YAAG;YAGb,IAAIK,YAAY,MAAM,IAClB,OAAOF,OAAO,IAAI,CAAC,IAAIG,6BAA6BN;YAGxD,MAAMO,WAAW,IAAI,CAAC,WAAW,CAAC,WAAW,CAACF,YAAY,KAAK;YAE/D,OAAOF,OAAO,EAAE,CAACI;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOL,OAAO,IAAI,CAACM,wBAAwB,IAAI,CAACD;QACpD;IACJ;AACJ;AAEO,MAAME,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgBf;IAChB,cAAc;QACVgB;QACAC;QACAC;KACH;AACL"}

package/api/features/GetWebhookDelivery/GetWebhookDeliveryUseCase.d.ts

@@ -0,0 +1,14 @@
+import { type Result as ResultType } from "@webiny/feature/api";
+import { GetWebhookDeliveryUseCase as UseCaseAbstraction, GetWebhookDeliveryRepository } from "./abstractions.js";
+import { WebhookPermissions } from "../../../api/features/WebhookPermissions/abstractions.js";
+import type { WebhookDelivery } from "../../../api/domain/WebhookDelivery.js";
+declare class GetWebhookDeliveryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private permissions;
+    private repository;
+    constructor(permissions: WebhookPermissions.Interface, repository: GetWebhookDeliveryRepository.Interface);
+    execute(id: string): Promise<ResultType<WebhookDelivery, UseCaseAbstraction.Error>>;
+}
+export declare const GetWebhookDeliveryUseCase: typeof GetWebhookDeliveryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetWebhookDeliveryUseCase>;
+};
+export {};

package/api/features/GetWebhookDelivery/GetWebhookDeliveryUseCase.js

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { GetWebhookDeliveryRepository, GetWebhookDeliveryUseCase } from "./abstractions.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError } from "../../domain/errors.js";
+class GetWebhookDeliveryUseCaseImpl {
+    constructor(permissions, repository){
+        this.permissions = permissions;
+        this.repository = repository;
+    }
+    async execute(id) {
+        if (!await this.permissions.canRead("webhook")) return Result.fail(new WebhookNotAuthorizedError());
+        return this.repository.execute(id);
+    }
+}
+const GetWebhookDeliveryUseCase_GetWebhookDeliveryUseCase = GetWebhookDeliveryUseCase.createImplementation({
+    implementation: GetWebhookDeliveryUseCaseImpl,
+    dependencies: [
+        WebhookPermissions,
+        GetWebhookDeliveryRepository
+    ]
+});
+export { GetWebhookDeliveryUseCase_GetWebhookDeliveryUseCase as GetWebhookDeliveryUseCase };
+
+//# sourceMappingURL=GetWebhookDeliveryUseCase.js.map

package/api/features/GetWebhookDelivery/GetWebhookDeliveryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhookDelivery/GetWebhookDeliveryUseCase.js","sources":["../../../../src/api/features/GetWebhookDelivery/GetWebhookDeliveryUseCase.ts"],"sourcesContent":["import { Result, type Result as ResultType } from \"@webiny/feature/api\";\nimport {\n    GetWebhookDeliveryUseCase as UseCaseAbstraction,\n    GetWebhookDeliveryRepository\n} from \"./abstractions.js\";\nimport { WebhookPermissions } from \"~/api/features/WebhookPermissions/abstractions.js\";\nimport { WebhookNotAuthorizedError } from \"~/api/domain/errors.js\";\nimport type { WebhookDelivery } from \"~/api/domain/WebhookDelivery.js\";\n\nclass GetWebhookDeliveryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private permissions: WebhookPermissions.Interface,\n        private repository: GetWebhookDeliveryRepository.Interface\n    ) {}\n\n    async execute(id: string): Promise<ResultType<WebhookDelivery, UseCaseAbstraction.Error>> {\n        if (!(await this.permissions.canRead(\"webhook\"))) {\n            return Result.fail(new WebhookNotAuthorizedError());\n        }\n        return this.repository.execute(id);\n    }\n}\n\nexport const GetWebhookDeliveryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetWebhookDeliveryUseCaseImpl,\n    dependencies: [WebhookPermissions, GetWebhookDeliveryRepository]\n});\n"],"names":["GetWebhookDeliveryUseCaseImpl","permissions","repository","id","Result","WebhookNotAuthorizedError","GetWebhookDeliveryUseCase","UseCaseAbstraction","WebhookPermissions","GetWebhookDeliveryRepository"],"mappings":";;;;AASA,MAAMA;IACF,YACYC,WAAyC,EACzCC,UAAkD,CAC5D;aAFUD,WAAW,GAAXA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAkE;QACtF,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,YACjC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAE3B,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACF;IACnC;AACJ;AAEO,MAAMG,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBP;IAChB,cAAc;QAACQ;QAAoBC;KAA6B;AACpE"}

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

@@ -0,0 +1,21 @@
+import { type Result } from "@webiny/feature/api";
+import type { WebhookDelivery } from "../../../api/domain/WebhookDelivery.js";
+import type { WebhookDeliveryNotFoundError, WebhookPersistenceError, WebhookModelNotFoundError, WebhookNotAuthorizedError } from "../../../api/domain/errors.js";
+type IError = WebhookDeliveryNotFoundError | WebhookPersistenceError | WebhookModelNotFoundError | WebhookNotAuthorizedError;
+export interface IGetWebhookDeliveryUseCase {
+    execute(id: string): Promise<Result<WebhookDelivery, IError>>;
+}
+export declare const GetWebhookDeliveryUseCase: import("@webiny/di").Abstraction<IGetWebhookDeliveryUseCase>;
+export declare namespace GetWebhookDeliveryUseCase {
+    type Interface = IGetWebhookDeliveryUseCase;
+    type Error = IError;
+}
+export interface IGetWebhookDeliveryRepository {
+    execute(id: string): Promise<Result<WebhookDelivery, IError>>;
+}
+export declare const GetWebhookDeliveryRepository: import("@webiny/di").Abstraction<IGetWebhookDeliveryRepository>;
+export declare namespace GetWebhookDeliveryRepository {
+    type Interface = IGetWebhookDeliveryRepository;
+    type Error = IError;
+}
+export {};

package/api/features/GetWebhookDelivery/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhookDelivery/abstractions.js","sources":["../../../../src/api/features/GetWebhookDelivery/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { WebhookDelivery } from \"~/api/domain/WebhookDelivery.js\";\nimport type {\n    WebhookDeliveryNotFoundError,\n    WebhookPersistenceError,\n    WebhookModelNotFoundError,\n    WebhookNotAuthorizedError\n} from \"~/api/domain/errors.js\";\n\ntype IError =\n    | WebhookDeliveryNotFoundError\n    | WebhookPersistenceError\n    | WebhookModelNotFoundError\n    | WebhookNotAuthorizedError;\n\nexport interface IGetWebhookDeliveryUseCase {\n    execute(id: string): Promise<Result<WebhookDelivery, IError>>;\n}\n\nexport const GetWebhookDeliveryUseCase = createAbstraction<IGetWebhookDeliveryUseCase>(\n    \"Webhooks/GetWebhookDeliveryUseCase\"\n);\n\nexport namespace GetWebhookDeliveryUseCase {\n    export type Interface = IGetWebhookDeliveryUseCase;\n    export type Error = IError;\n}\n\nexport interface IGetWebhookDeliveryRepository {\n    execute(id: string): Promise<Result<WebhookDelivery, IError>>;\n}\n\nexport const GetWebhookDeliveryRepository = createAbstraction<IGetWebhookDeliveryRepository>(\n    \"Webhooks/GetWebhookDeliveryRepository\"\n);\n\nexport namespace GetWebhookDeliveryRepository {\n    export type Interface = IGetWebhookDeliveryRepository;\n    export type Error = IError;\n}\n"],"names":["GetWebhookDeliveryUseCase","createAbstraction","GetWebhookDeliveryRepository"],"mappings":";AAmBO,MAAMA,4BAA4BC,kBACrC;AAYG,MAAMC,+BAA+BD,kBACxC"}

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

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

package/api/features/GetWebhookDelivery/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhookDelivery/feature.js","sources":["../../../../src/api/features/GetWebhookDelivery/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetWebhookDeliveryUseCase } from \"./GetWebhookDeliveryUseCase.js\";\nimport { GetWebhookDeliveryRepository } from \"./GetWebhookDeliveryRepository.js\";\n\nexport const GetWebhookDeliveryFeature = createFeature({\n    name: \"GetWebhookDelivery\",\n    register(container) {\n        container.register(GetWebhookDeliveryUseCase);\n        container.register(GetWebhookDeliveryRepository).inSingletonScope();\n    }\n});\n"],"names":["GetWebhookDeliveryFeature","createFeature","container","GetWebhookDeliveryUseCase","GetWebhookDeliveryRepository"],"mappings":";;;AAIO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,8BAA8B,gBAAgB;IACrE;AACJ"}

package/api/features/ListAvailableWebhookEvents/ListAvailableWebhookEventsUseCase.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { ListAvailableWebhookEventsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { WebhookPermissions } from "../../../api/features/WebhookPermissions/abstractions.js";
+import { WebhookProvider } from "@webiny/api-core/features/webhooks/index.js";
+declare class ListAvailableWebhookEventsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly provider;
+    private readonly permissions;
+    constructor(provider: WebhookProvider.Interface, permissions: WebhookPermissions.Interface);
+    execute(): Promise<Result<WebhookProvider.Response, Error>>;
+}
+export declare const ListAvailableWebhookEventsUseCase: typeof ListAvailableWebhookEventsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListAvailableWebhookEventsUseCase>;
+};
+export {};

package/api/features/ListAvailableWebhookEvents/ListAvailableWebhookEventsUseCase.js

@@ -0,0 +1,30 @@
+import { Result } from "@webiny/feature/api";
+import { ListAvailableWebhookEventsUseCase } from "./abstractions.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError } from "../../domain/errors.js";
+import { WebhookProvider } from "@webiny/api-core/features/webhooks/index.js";
+class ListAvailableWebhookEventsUseCaseImpl {
+    constructor(provider, permissions){
+        this.provider = provider;
+        this.permissions = permissions;
+    }
+    async execute() {
+        if (!await this.permissions.canRead("webhook")) return Result.fail(new WebhookNotAuthorizedError());
+        try {
+            const events = await this.provider.execute();
+            return Result.ok(events);
+        } catch (ex) {
+            return Result.fail(ex);
+        }
+    }
+}
+const ListAvailableWebhookEventsUseCase_ListAvailableWebhookEventsUseCase = ListAvailableWebhookEventsUseCase.createImplementation({
+    implementation: ListAvailableWebhookEventsUseCaseImpl,
+    dependencies: [
+        WebhookProvider,
+        WebhookPermissions
+    ]
+});
+export { ListAvailableWebhookEventsUseCase_ListAvailableWebhookEventsUseCase as ListAvailableWebhookEventsUseCase };
+
+//# sourceMappingURL=ListAvailableWebhookEventsUseCase.js.map