@webiny/webhooks 0.0.0-unstable.7be00a75a9

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 readonly permissions;
+    private readonly getWebhookRepository;
+    private readonly 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,34 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteWebhookRepository, DeleteWebhookUseCase } from "./abstractions.js";
+import { DeleteWebhookInputSchema } from "./schema.js";
+import { GetWebhookRepository } from "../GetWebhook/abstractions.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError, WebhookValidationError } 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 parsed = DeleteWebhookInputSchema.safeParse({
+            id
+        });
+        if (!parsed.success) return Result.fail(new WebhookValidationError(parsed.error));
+        const getResult = await this.getWebhookRepository.execute(parsed.data.id);
+        if (getResult.isFail()) return Result.fail(getResult.error);
+        return this.deleteRepository.execute(parsed.data.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 { DeleteWebhookInputSchema } from \"./schema.js\";\nimport { GetWebhookRepository } from \"~/api/features/GetWebhook/abstractions.js\";\nimport { WebhookPermissions } from \"~/api/features/WebhookPermissions/abstractions.js\";\nimport { WebhookNotAuthorizedError, WebhookValidationError } from \"~/api/domain/errors.js\";\n\nclass DeleteWebhookUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private readonly permissions: WebhookPermissions.Interface,\n        private readonly getWebhookRepository: GetWebhookRepository.Interface,\n        private readonly 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\n        const parsed = DeleteWebhookInputSchema.safeParse({ id });\n        if (!parsed.success) {\n            return Result.fail(new WebhookValidationError(parsed.error));\n        }\n\n        const getResult = await this.getWebhookRepository.execute(parsed.data.id);\n        if (getResult.isFail()) {\n            return Result.fail(getResult.error);\n        }\n\n        return this.deleteRepository.execute(parsed.data.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","parsed","DeleteWebhookInputSchema","WebhookValidationError","getResult","DeleteWebhookUseCase","UseCaseAbstraction","WebhookPermissions","GetWebhookRepository","DeleteWebhookRepository"],"mappings":";;;;;;AAUA,MAAMA;IACF,YACqBC,WAAyC,EACzCC,oBAAoD,EACpDC,gBAAmD,CACtE;aAHmBF,WAAW,GAAXA;aACAC,oBAAoB,GAApBA;aACAC,gBAAgB,GAAhBA;IAClB;IAEH,MAAM,QAAQC,EAAU,EAAsD;QAC1E,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,YACnC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAASC,yBAAyB,SAAS,CAAC;YAAEJ;QAAG;QACvD,IAAI,CAACG,OAAO,OAAO,EACf,OAAOF,OAAO,IAAI,CAAC,IAAII,uBAAuBF,OAAO,KAAK;QAG9D,MAAMG,YAAY,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAACH,OAAO,IAAI,CAAC,EAAE;QACxE,IAAIG,UAAU,MAAM,IAChB,OAAOL,OAAO,IAAI,CAACK,UAAU,KAAK;QAGtC,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACH,OAAO,IAAI,CAAC,EAAE;IACvD;AACJ;AAEO,MAAMI,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBZ;IAChB,cAAc;QAACa;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, WebhookValidationError } from "../../../api/domain/errors.js";
+type IError = WebhookNotFoundError | WebhookPersistenceError | WebhookModelNotFoundError | WebhookNotAuthorizedError | WebhookValidationError;
+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    WebhookValidationError\n} from \"~/api/domain/errors.js\";\n\ntype IError =\n    | WebhookNotFoundError\n    | WebhookPersistenceError\n    | WebhookModelNotFoundError\n    | WebhookNotAuthorizedError\n    | WebhookValidationError;\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":";AAoBO,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/DeleteWebhook/schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const DeleteWebhookInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;

package/api/features/DeleteWebhook/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+const DeleteWebhookInputSchema = z.object({
+    id: z.string().min(1, "Webhook ID is required.")
+});
+export { DeleteWebhookInputSchema };
+
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/DeleteWebhook/schema.js","sources":["../../../../src/api/features/DeleteWebhook/schema.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const DeleteWebhookInputSchema = z.object({\n    id: z.string().min(1, \"Webhook ID is required.\")\n});\n"],"names":["DeleteWebhookInputSchema","z"],"mappings":";AAEO,MAAMA,2BAA2BC,EAAE,MAAM,CAAC;IAC7C,IAAIA,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;AAC1B"}

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 readonly permissions;
+    private readonly 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,29 @@
+import { Result } from "@webiny/feature/api";
+import { GetWebhookRepository, GetWebhookUseCase } from "./abstractions.js";
+import { GetWebhookInputSchema } from "./schema.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError, WebhookValidationError } 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());
+        const parsed = GetWebhookInputSchema.safeParse({
+            id
+        });
+        if (!parsed.success) return Result.fail(new WebhookValidationError(parsed.error));
+        return this.repository.execute(parsed.data.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 { GetWebhookInputSchema } from \"./schema.js\";\nimport { WebhookPermissions } from \"~/api/features/WebhookPermissions/abstractions.js\";\nimport { WebhookNotAuthorizedError, WebhookValidationError } from \"~/api/domain/errors.js\";\nimport type { Webhook } from \"~/api/domain/Webhook.js\";\n\nclass GetWebhookUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private readonly permissions: WebhookPermissions.Interface,\n        private readonly 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\n        const parsed = GetWebhookInputSchema.safeParse({ id });\n        if (!parsed.success) {\n            return Result.fail(new WebhookValidationError(parsed.error));\n        }\n\n        return this.repository.execute(parsed.data.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","parsed","GetWebhookInputSchema","WebhookValidationError","GetWebhookUseCase","UseCaseAbstraction","WebhookPermissions","GetWebhookRepository"],"mappings":";;;;;AAOA,MAAMA;IACF,YACqBC,WAAyC,EACzCC,UAA0C,CAC7D;aAFmBD,WAAW,GAAXA;aACAC,UAAU,GAAVA;IAClB;IAEH,MAAM,QAAQC,EAAU,EAAsD;QAC1E,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,YACjC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAASC,sBAAsB,SAAS,CAAC;YAAEJ;QAAG;QACpD,IAAI,CAACG,OAAO,OAAO,EACf,OAAOF,OAAO,IAAI,CAAC,IAAII,uBAAuBF,OAAO,KAAK;QAG9D,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA,OAAO,IAAI,CAAC,EAAE;IACjD;AACJ;AAEO,MAAMG,sCAAoBC,kBAAAA,oBAAuC,CAAC;IACrE,gBAAgBV;IAChB,cAAc;QAACW;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, WebhookValidationError } from "../../../api/domain/errors.js";
+type IError = WebhookNotFoundError | WebhookModelNotFoundError | WebhookPersistenceError | WebhookNotAuthorizedError | WebhookValidationError;
+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    WebhookValidationError\n} from \"~/api/domain/errors.js\";\n\ntype IError =\n    | WebhookNotFoundError\n    | WebhookModelNotFoundError\n    | WebhookPersistenceError\n    | WebhookNotAuthorizedError\n    | WebhookValidationError;\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":";AAqBO,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/GetWebhook/schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const GetWebhookInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;

package/api/features/GetWebhook/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+const GetWebhookInputSchema = z.object({
+    id: z.string().min(1, "Webhook ID is required.")
+});
+export { GetWebhookInputSchema };
+
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhook/schema.js","sources":["../../../../src/api/features/GetWebhook/schema.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const GetWebhookInputSchema = z.object({\n    id: z.string().min(1, \"Webhook ID is required.\")\n});\n"],"names":["GetWebhookInputSchema","z"],"mappings":";AAEO,MAAMA,wBAAwBC,EAAE,MAAM,CAAC;IAC1C,IAAIA,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;AAC1B"}

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 readonly permissions;
+    private readonly 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,29 @@
+import { Result } from "@webiny/feature/api";
+import { GetWebhookDeliveryRepository, GetWebhookDeliveryUseCase } from "./abstractions.js";
+import { GetWebhookDeliveryInputSchema } from "./schema.js";
+import { WebhookPermissions } from "../WebhookPermissions/abstractions.js";
+import { WebhookNotAuthorizedError, WebhookValidationError } 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());
+        const parsed = GetWebhookDeliveryInputSchema.safeParse({
+            id
+        });
+        if (!parsed.success) return Result.fail(new WebhookValidationError(parsed.error));
+        return this.repository.execute(parsed.data.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 { GetWebhookDeliveryInputSchema } from \"./schema.js\";\nimport { WebhookPermissions } from \"~/api/features/WebhookPermissions/abstractions.js\";\nimport { WebhookNotAuthorizedError, WebhookValidationError } from \"~/api/domain/errors.js\";\nimport type { WebhookDelivery } from \"~/api/domain/WebhookDelivery.js\";\n\nclass GetWebhookDeliveryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private readonly permissions: WebhookPermissions.Interface,\n        private readonly 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\n        const parsed = GetWebhookDeliveryInputSchema.safeParse({ id });\n        if (!parsed.success) {\n            return Result.fail(new WebhookValidationError(parsed.error));\n        }\n\n        return this.repository.execute(parsed.data.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","parsed","GetWebhookDeliveryInputSchema","WebhookValidationError","GetWebhookDeliveryUseCase","UseCaseAbstraction","WebhookPermissions","GetWebhookDeliveryRepository"],"mappings":";;;;;AAUA,MAAMA;IACF,YACqBC,WAAyC,EACzCC,UAAkD,CACrE;aAFmBD,WAAW,GAAXA;aACAC,UAAU,GAAVA;IAClB;IAEH,MAAM,QAAQC,EAAU,EAAkE;QACtF,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,YACjC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAASC,8BAA8B,SAAS,CAAC;YAAEJ;QAAG;QAC5D,IAAI,CAACG,OAAO,OAAO,EACf,OAAOF,OAAO,IAAI,CAAC,IAAII,uBAAuBF,OAAO,KAAK;QAG9D,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA,OAAO,IAAI,CAAC,EAAE;IACjD;AACJ;AAEO,MAAMG,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBV;IAChB,cAAc;QAACW;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, WebhookValidationError } from "../../../api/domain/errors.js";
+type IError = WebhookDeliveryNotFoundError | WebhookPersistenceError | WebhookModelNotFoundError | WebhookNotAuthorizedError | WebhookValidationError;
+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    WebhookValidationError\n} from \"~/api/domain/errors.js\";\n\ntype IError =\n    | WebhookDeliveryNotFoundError\n    | WebhookPersistenceError\n    | WebhookModelNotFoundError\n    | WebhookNotAuthorizedError\n    | WebhookValidationError;\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":";AAqBO,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/GetWebhookDelivery/schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const GetWebhookDeliveryInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;

package/api/features/GetWebhookDelivery/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+const GetWebhookDeliveryInputSchema = z.object({
+    id: z.string().min(1, "Delivery ID is required.")
+});
+export { GetWebhookDeliveryInputSchema };
+
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetWebhookDelivery/schema.js","sources":["../../../../src/api/features/GetWebhookDelivery/schema.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const GetWebhookDeliveryInputSchema = z.object({\n    id: z.string().min(1, \"Delivery ID is required.\")\n});\n"],"names":["GetWebhookDeliveryInputSchema","z"],"mappings":";AAEO,MAAMA,gCAAgCC,EAAE,MAAM,CAAC;IAClD,IAAIA,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG;AAC1B"}

package/api/features/GetWebhookSettings/GetWebhookSettingsRepository.d.ts

@@ -0,0 +1,19 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetLatestRevisionByEntryIdRepository } from "@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import { CreateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { CreateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { GetWebhookSettingsRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { IWebhookSettings } from "../../../api/domain/WebhookSettings.js";
+declare class GetWebhookSettingsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly createEntryRepository;
+    private readonly createEntryDataFactory;
+    constructor(getModelRepository: GetModelRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, createEntryRepository: CreateEntryRepository.Interface, createEntryDataFactory: CreateEntryDataFactory.Interface);
+    execute(): Promise<Result<IWebhookSettings, RepositoryAbstraction.Error>>;
+}
+export declare const GetWebhookSettingsRepository: typeof GetWebhookSettingsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetWebhookSettingsRepository>;
+};
+export {};