@webiny/api-headless-cms 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/features/contentModel/DeleteModel/DeleteModelUseCase.js

@@ -0,0 +1,56 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteModelRepository, DeleteModelUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { ModelAfterDeleteEvent, ModelBeforeDeleteEvent, ModelDeleteErrorEvent } from "./events.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { ModelNotAuthorizedError } from "../../../domain/contentModel/errors.js";
+import { GetModelUseCase } from "../GetModel/index.js";
+class DeleteModelUseCaseImpl {
+    constructor(getModelUseCase, eventPublisher, repository, accessControl){
+        this.getModelUseCase = getModelUseCase;
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+        this.accessControl = accessControl;
+    }
+    async execute(modelId) {
+        const canAccess = await this.accessControl.canAccessModel({
+            rwd: "d"
+        });
+        if (!canAccess) return Result.fail(new ModelNotAuthorizedError());
+        const getResult = await this.getModelUseCase.execute(modelId);
+        if (getResult.isFail()) return Result.fail(getResult.error);
+        const model = getResult.value;
+        const canAccessModel = await this.accessControl.canAccessModel({
+            model,
+            rwd: "d"
+        });
+        if (!canAccessModel) return Result.fail(ModelNotAuthorizedError.fromModel(model));
+        await this.eventPublisher.publish(new ModelBeforeDeleteEvent({
+            model
+        }));
+        const result = await this.repository.execute(model);
+        if (result.isFail()) {
+            await this.eventPublisher.publish(new ModelDeleteErrorEvent({
+                model,
+                error: result.error
+            }));
+            return Result.fail(result.error);
+        }
+        await this.eventPublisher.publish(new ModelAfterDeleteEvent({
+            model
+        }));
+        return Result.ok();
+    }
+}
+const DeleteModelUseCase_DeleteModelUseCase = DeleteModelUseCase.createImplementation({
+    implementation: DeleteModelUseCaseImpl,
+    dependencies: [
+        GetModelUseCase,
+        EventPublisher,
+        DeleteModelRepository,
+        AccessControl
+    ]
+});
+export { DeleteModelUseCase_DeleteModelUseCase as DeleteModelUseCase };
+
+//# sourceMappingURL=DeleteModelUseCase.js.map

package/features/contentModel/DeleteModel/DeleteModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/DeleteModel/DeleteModelUseCase.js","sources":["../../../../src/features/contentModel/DeleteModel/DeleteModelUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { DeleteModelUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { DeleteModelRepository } from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { ModelBeforeDeleteEvent } from \"./events.js\";\nimport { ModelAfterDeleteEvent } from \"./events.js\";\nimport { ModelDeleteErrorEvent } from \"./events.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { ModelNotAuthorizedError } from \"~/domain/contentModel/errors.js\";\nimport { GetModelUseCase } from \"~/features/contentModel/GetModel/index.js\";\n\n/**\n * DeleteModelUseCase - Core model deletion orchestration.\n *\n * Responsibilities:\n * - Fetch model\n * - Access control checks\n * - Publish before event\n * - Delegate to repository for deletion\n * - Publish after event or error event\n *\n * Note: Validation (e.g., checking for entries, plugin models) should be done in event handlers\n */\nclass DeleteModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private repository: DeleteModelRepository.Interface,\n        private accessControl: AccessControl.Interface\n    ) {}\n\n    async execute(modelId: string): Promise<Result<void, UseCaseAbstraction.Error>> {\n        // Initial access control check\n        const canAccess = await this.accessControl.canAccessModel({ rwd: \"d\" });\n        if (!canAccess) {\n            return Result.fail(new ModelNotAuthorizedError());\n        }\n\n        // Get the model (with access control check)\n        const getResult = await this.getModelUseCase.execute(modelId);\n        if (getResult.isFail()) {\n            return Result.fail(getResult.error);\n        }\n\n        const model = getResult.value;\n\n        // Access control check on the specific model\n        const canAccessModel = await this.accessControl.canAccessModel({ model, rwd: \"d\" });\n        if (!canAccessModel) {\n            return Result.fail(ModelNotAuthorizedError.fromModel(model));\n        }\n\n        // Publish before event\n        await this.eventPublisher.publish(new ModelBeforeDeleteEvent({ model }));\n\n        // Delete via repository\n        const result = await this.repository.execute(model);\n\n        if (result.isFail()) {\n            // Publish error event\n            await this.eventPublisher.publish(\n                new ModelDeleteErrorEvent({\n                    model,\n                    error: result.error\n                })\n            );\n            return Result.fail(result.error);\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(new ModelAfterDeleteEvent({ model }));\n\n        return Result.ok();\n    }\n}\n\nexport const DeleteModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: DeleteModelUseCaseImpl,\n    dependencies: [GetModelUseCase, EventPublisher, DeleteModelRepository, AccessControl]\n});\n"],"names":["DeleteModelUseCaseImpl","getModelUseCase","eventPublisher","repository","accessControl","modelId","canAccess","Result","ModelNotAuthorizedError","getResult","model","canAccessModel","ModelBeforeDeleteEvent","result","ModelDeleteErrorEvent","ModelAfterDeleteEvent","DeleteModelUseCase","UseCaseAbstraction","GetModelUseCase","EventPublisher","DeleteModelRepository","AccessControl"],"mappings":";;;;;;;AAuBA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,cAAwC,EACxCC,UAA2C,EAC3CC,aAAsC,CAChD;aAJUH,eAAe,GAAfA;aACAC,cAAc,GAAdA;aACAC,UAAU,GAAVA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,OAAe,EAAmD;QAE5E,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAE,KAAK;QAAI;QACrE,IAAI,CAACA,WACD,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAI3B,MAAMC,YAAY,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACJ;QACrD,IAAII,UAAU,MAAM,IAChB,OAAOF,OAAO,IAAI,CAACE,UAAU,KAAK;QAGtC,MAAMC,QAAQD,UAAU,KAAK;QAG7B,MAAME,iBAAiB,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAED;YAAO,KAAK;QAAI;QACjF,IAAI,CAACC,gBACD,OAAOJ,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACE;QAIzD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIE,uBAAuB;YAAEF;QAAM;QAGrE,MAAMG,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACH;QAE7C,IAAIG,OAAO,MAAM,IAAI;YAEjB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,sBAAsB;gBACtBJ;gBACA,OAAOG,OAAO,KAAK;YACvB;YAEJ,OAAON,OAAO,IAAI,CAACM,OAAO,KAAK;QACnC;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIE,sBAAsB;YAAEL;QAAM;QAEpE,OAAOH,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMS,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBjB;IAChB,cAAc;QAACkB;QAAiBC;QAAgBC;QAAuBC;KAAc;AACzF"}

package/features/contentModel/DeleteModel/DeleteModelWithEntryCleanup.d.ts

@@ -0,0 +1,23 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteModelUseCase } from "./abstractions.js";
+import { CmsContext } from "../../../features/shared/abstractions.js";
+/**
+ * DeleteModelWithEntryCleanup - Decorator that handles entry cleanup/validation before deletion.
+ *
+ * Responsibilities:
+ * 1. For singleton models: Delete all entries (latest + deleted)
+ * 2. For regular models: Check if there are any entries - if yes, throw error
+ * 3. Only proceed to the base use case if validations pass
+ */
+declare class DeleteModelWithEntryCleanupImpl implements DeleteModelUseCase.Interface {
+    private cmsContext;
+    private decoratee;
+    constructor(cmsContext: CmsContext.Interface, decoratee: DeleteModelUseCase.Interface);
+    execute(modelId: string): Promise<Result<void, DeleteModelUseCase.Error>>;
+    private deleteSingletonEntries;
+    private canDelete;
+}
+export declare const DeleteModelWithEntryCleanup: typeof DeleteModelWithEntryCleanupImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteModelUseCase>;
+};
+export {};

package/features/contentModel/DeleteModel/DeleteModelWithEntryCleanup.js

@@ -0,0 +1,64 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteModelUseCase } from "./abstractions.js";
+import { CmsContext } from "../../shared/abstractions.js";
+import { CMS_MODEL_SINGLETON_TAG } from "../../../constants.js";
+import { ModelCannotDeleteHasEntriesError, ModelCannotDeleteHasEntriesInTrashError, ModelPersistenceError, ModelValidationError } from "../../../domain/contentModel/errors.js";
+class DeleteModelWithEntryCleanupImpl {
+    constructor(cmsContext, decoratee){
+        this.cmsContext = cmsContext;
+        this.decoratee = decoratee;
+    }
+    async execute(modelId) {
+        const model = await this.cmsContext.cms.getModel(modelId);
+        const tags = Array.isArray(model.tags) ? model.tags : [];
+        if (tags.includes(CMS_MODEL_SINGLETON_TAG)) {
+            try {
+                await this.deleteSingletonEntries(model);
+            } catch (error) {
+                return Result.fail(new ModelValidationError(`Failed to delete singleton entries: ${error.message}`));
+            }
+            return this.decoratee.execute(modelId);
+        }
+        const canDelete = await this.canDelete(model);
+        if (canDelete.isFail()) return Result.fail(canDelete.error);
+        return this.decoratee.execute(modelId);
+    }
+    async deleteSingletonEntries(model) {
+        const [latestEntries] = await this.cmsContext.cms.listLatestEntries(model, {
+            limit: 10000
+        });
+        for (const item of latestEntries)await this.cmsContext.cms.deleteEntry(model, item.id, {
+            permanently: true
+        });
+        const [deletedEntries] = await this.cmsContext.cms.listDeletedEntries(model, {
+            limit: 10000
+        });
+        for (const item of deletedEntries)await this.cmsContext.cms.deleteEntry(model, item.id, {
+            permanently: true
+        });
+    }
+    async canDelete(model) {
+        try {
+            const [latestEntries] = await this.cmsContext.cms.listLatestEntries(model, {
+                limit: 1
+            });
+            if (latestEntries.length > 0) return Result.fail(new ModelCannotDeleteHasEntriesError(model.modelId));
+            const [deletedEntries] = await this.cmsContext.cms.listDeletedEntries(model, {
+                limit: 1
+            });
+            if (deletedEntries.length > 0) return Result.fail(new ModelCannotDeleteHasEntriesInTrashError(model.modelId));
+        } catch (error) {
+            return Result.fail(new ModelPersistenceError(error));
+        }
+        return Result.ok(true);
+    }
+}
+const DeleteModelWithEntryCleanup = DeleteModelUseCase.createDecorator({
+    decorator: DeleteModelWithEntryCleanupImpl,
+    dependencies: [
+        CmsContext
+    ]
+});
+export { DeleteModelWithEntryCleanup };
+
+//# sourceMappingURL=DeleteModelWithEntryCleanup.js.map

package/features/contentModel/DeleteModel/DeleteModelWithEntryCleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/DeleteModel/DeleteModelWithEntryCleanup.js","sources":["../../../../src/features/contentModel/DeleteModel/DeleteModelWithEntryCleanup.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { DeleteModelUseCase } from \"./abstractions.js\";\nimport { CmsContext } from \"~/features/shared/abstractions.js\";\nimport { CMS_MODEL_SINGLETON_TAG } from \"~/constants.js\";\nimport {\n    ModelCannotDeleteHasEntriesError,\n    ModelCannotDeleteHasEntriesInTrashError,\n    ModelPersistenceError,\n    ModelValidationError\n} from \"~/domain/contentModel/errors.js\";\nimport { CmsModel } from \"~/types/model.js\";\n\n/**\n * DeleteModelWithEntryCleanup - Decorator that handles entry cleanup/validation before deletion.\n *\n * Responsibilities:\n * 1. For singleton models: Delete all entries (latest + deleted)\n * 2. For regular models: Check if there are any entries - if yes, throw error\n * 3. Only proceed to the base use case if validations pass\n */\nclass DeleteModelWithEntryCleanupImpl implements DeleteModelUseCase.Interface {\n    public constructor(\n        private cmsContext: CmsContext.Interface,\n        private decoratee: DeleteModelUseCase.Interface\n    ) {}\n\n    async execute(modelId: string): Promise<Result<void, DeleteModelUseCase.Error>> {\n        // First, get the model through the decorated use case's flow (up to before deletion)\n        // We need to perform validation before the actual deletion happens\n\n        // Get the model from context to check entries\n        const model = await this.cmsContext.cms.getModel(modelId);\n\n        const tags = Array.isArray(model.tags) ? model.tags : [];\n\n        // Handle singleton models: delete all entries\n        if (tags.includes(CMS_MODEL_SINGLETON_TAG)) {\n            try {\n                await this.deleteSingletonEntries(model);\n            } catch (error) {\n                return Result.fail(\n                    new ModelValidationError(\n                        `Failed to delete singleton entries: ${(error as Error).message}`\n                    )\n                );\n            }\n\n            // Proceed with the actual deletion\n            return this.decoratee.execute(modelId);\n        }\n\n        // Regular models\n        const canDelete = await this.canDelete(model);\n        if (canDelete.isFail()) {\n            return Result.fail(canDelete.error);\n        }\n\n        // Proceed with the actual deletion\n        return this.decoratee.execute(modelId);\n    }\n\n    private async deleteSingletonEntries(model: any): Promise<void> {\n        // Delete all latest entries\n        const [latestEntries] = await this.cmsContext.cms.listLatestEntries(model, {\n            limit: 10000\n        });\n\n        for (const item of latestEntries) {\n            await this.cmsContext.cms.deleteEntry(model, item.id, {\n                permanently: true\n            });\n        }\n\n        // Delete all deleted entries (trash)\n        const [deletedEntries] = await this.cmsContext.cms.listDeletedEntries(model, {\n            limit: 10000\n        });\n\n        for (const item of deletedEntries) {\n            await this.cmsContext.cms.deleteEntry(model, item.id, {\n                permanently: true\n            });\n        }\n    }\n\n    private async canDelete(\n        model: CmsModel\n    ): Promise<\n        Result<\n            boolean,\n            | ModelCannotDeleteHasEntriesError\n            | ModelCannotDeleteHasEntriesInTrashError\n            | ModelPersistenceError\n        >\n    > {\n        try {\n            // Check for latest entries\n            const [latestEntries] = await this.cmsContext.cms.listLatestEntries(model, {\n                limit: 1\n            });\n\n            if (latestEntries.length > 0) {\n                return Result.fail(new ModelCannotDeleteHasEntriesError(model.modelId));\n            }\n\n            // Check for deleted entries (trash)\n            const [deletedEntries] = await this.cmsContext.cms.listDeletedEntries(model, {\n                limit: 1\n            });\n\n            if (deletedEntries.length > 0) {\n                return Result.fail(new ModelCannotDeleteHasEntriesInTrashError(model.modelId));\n            }\n        } catch (error) {\n            return Result.fail(new ModelPersistenceError(error));\n        }\n\n        return Result.ok(true);\n    }\n}\n\nexport const DeleteModelWithEntryCleanup = DeleteModelUseCase.createDecorator({\n    decorator: DeleteModelWithEntryCleanupImpl,\n    dependencies: [CmsContext]\n});\n"],"names":["DeleteModelWithEntryCleanupImpl","cmsContext","decoratee","modelId","model","tags","Array","CMS_MODEL_SINGLETON_TAG","error","Result","ModelValidationError","canDelete","latestEntries","item","deletedEntries","ModelCannotDeleteHasEntriesError","ModelCannotDeleteHasEntriesInTrashError","ModelPersistenceError","DeleteModelWithEntryCleanup","DeleteModelUseCase","CmsContext"],"mappings":";;;;;AAoBA,MAAMA;IACF,YACYC,UAAgC,EAChCC,SAAuC,CACjD;aAFUD,UAAU,GAAVA;aACAC,SAAS,GAATA;IACT;IAEH,MAAM,QAAQC,OAAe,EAAmD;QAK5E,MAAMC,QAAQ,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAACD;QAEjD,MAAME,OAAOC,MAAM,OAAO,CAACF,MAAM,IAAI,IAAIA,MAAM,IAAI,GAAG,EAAE;QAGxD,IAAIC,KAAK,QAAQ,CAACE,0BAA0B;YACxC,IAAI;gBACA,MAAM,IAAI,CAAC,sBAAsB,CAACH;YACtC,EAAE,OAAOI,OAAO;gBACZ,OAAOC,OAAO,IAAI,CACd,IAAIC,qBACA,CAAC,oCAAoC,EAAGF,MAAgB,OAAO,EAAE;YAG7E;YAGA,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAACL;QAClC;QAGA,MAAMQ,YAAY,MAAM,IAAI,CAAC,SAAS,CAACP;QACvC,IAAIO,UAAU,MAAM,IAChB,OAAOF,OAAO,IAAI,CAACE,UAAU,KAAK;QAItC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAACR;IAClC;IAEA,MAAc,uBAAuBC,KAAU,EAAiB;QAE5D,MAAM,CAACQ,cAAc,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAACR,OAAO;YACvE,OAAO;QACX;QAEA,KAAK,MAAMS,QAAQD,cACf,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,WAAW,CAACR,OAAOS,KAAK,EAAE,EAAE;YAClD,aAAa;QACjB;QAIJ,MAAM,CAACC,eAAe,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAACV,OAAO;YACzE,OAAO;QACX;QAEA,KAAK,MAAMS,QAAQC,eACf,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,WAAW,CAACV,OAAOS,KAAK,EAAE,EAAE;YAClD,aAAa;QACjB;IAER;IAEA,MAAc,UACVT,KAAe,EAQjB;QACE,IAAI;YAEA,MAAM,CAACQ,cAAc,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAACR,OAAO;gBACvE,OAAO;YACX;YAEA,IAAIQ,cAAc,MAAM,GAAG,GACvB,OAAOH,OAAO,IAAI,CAAC,IAAIM,iCAAiCX,MAAM,OAAO;YAIzE,MAAM,CAACU,eAAe,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAACV,OAAO;gBACzE,OAAO;YACX;YAEA,IAAIU,eAAe,MAAM,GAAG,GACxB,OAAOL,OAAO,IAAI,CAAC,IAAIO,wCAAwCZ,MAAM,OAAO;QAEpF,EAAE,OAAOI,OAAO;YACZ,OAAOC,OAAO,IAAI,CAAC,IAAIQ,sBAAsBT;QACjD;QAEA,OAAOC,OAAO,EAAE,CAAC;IACrB;AACJ;AAEO,MAAMS,8BAA8BC,mBAAmB,eAAe,CAAC;IAC1E,WAAWnB;IACX,cAAc;QAACoB;KAAW;AAC9B"}

package/features/contentModel/DeleteModel/abstractions.d.ts

@@ -0,0 +1,44 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsModel } from "../../../types/index.js";
+import { ModelCannotDeleteCodeModelError, ModelCannotDeleteHasEntriesError, ModelCannotDeleteHasEntriesInTrashError, ModelNotAuthorizedError, type ModelNotFoundError, type ModelPersistenceError, type ModelValidationError } from "../../../domain/contentModel/errors.js";
+/**
+ * DeleteModel Use Case
+ */
+export interface IDeleteModelUseCase {
+    execute(modelId: string): Promise<Result<void, UseCaseError>>;
+}
+export interface IDeleteModelUseCaseErrors {
+    notFound: ModelNotFoundError;
+    notAuthorized: ModelNotAuthorizedError;
+    persistence: ModelPersistenceError;
+    validation: ModelValidationError;
+    codeModel: ModelCannotDeleteCodeModelError;
+    hasEntries: ModelCannotDeleteHasEntriesError;
+    hasEntriesInTrash: ModelCannotDeleteHasEntriesInTrashError;
+}
+type UseCaseError = IDeleteModelUseCaseErrors[keyof IDeleteModelUseCaseErrors];
+/** Delete a content model. */
+export declare const DeleteModelUseCase: import("@webiny/di").Abstraction<IDeleteModelUseCase>;
+export declare namespace DeleteModelUseCase {
+    type Interface = IDeleteModelUseCase;
+    type Error = UseCaseError;
+    type Return = Promise<Result<void, UseCaseError>>;
+}
+/**
+ * DeleteModelRepository - Validates and deletes a model from storage.
+ */
+export interface IDeleteModelRepository {
+    execute(model: CmsModel): Promise<Result<void, RepositoryError>>;
+}
+export interface IDeleteModelRepositoryErrors {
+    validation: ModelValidationError;
+    persistence: ModelPersistenceError;
+    codeModel: ModelCannotDeleteCodeModelError;
+}
+type RepositoryError = IDeleteModelRepositoryErrors[keyof IDeleteModelRepositoryErrors];
+export declare const DeleteModelRepository: import("@webiny/di").Abstraction<IDeleteModelRepository>;
+export declare namespace DeleteModelRepository {
+    type Interface = IDeleteModelRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentModel/DeleteModel/abstractions.js

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

package/features/contentModel/DeleteModel/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/DeleteModel/abstractions.js","sources":["../../../../src/features/contentModel/DeleteModel/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport {\n    ModelCannotDeleteCodeModelError,\n    ModelCannotDeleteHasEntriesError,\n    ModelCannotDeleteHasEntriesInTrashError,\n    ModelNotAuthorizedError,\n    type ModelNotFoundError,\n    type ModelPersistenceError,\n    type ModelValidationError\n} from \"~/domain/contentModel/errors.js\";\n\n/**\n * DeleteModel Use Case\n */\nexport interface IDeleteModelUseCase {\n    execute(modelId: string): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IDeleteModelUseCaseErrors {\n    notFound: ModelNotFoundError;\n    notAuthorized: ModelNotAuthorizedError;\n    persistence: ModelPersistenceError;\n    validation: ModelValidationError;\n    codeModel: ModelCannotDeleteCodeModelError;\n    hasEntries: ModelCannotDeleteHasEntriesError;\n    hasEntriesInTrash: ModelCannotDeleteHasEntriesInTrashError;\n}\n\ntype UseCaseError = IDeleteModelUseCaseErrors[keyof IDeleteModelUseCaseErrors];\n\n/** Delete a content model. */\nexport const DeleteModelUseCase = createAbstraction<IDeleteModelUseCase>(\"DeleteModelUseCase\");\n\nexport namespace DeleteModelUseCase {\n    export type Interface = IDeleteModelUseCase;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<void, UseCaseError>>;\n}\n\n/**\n * DeleteModelRepository - Validates and deletes a model from storage.\n */\nexport interface IDeleteModelRepository {\n    execute(model: CmsModel): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IDeleteModelRepositoryErrors {\n    validation: ModelValidationError;\n    persistence: ModelPersistenceError;\n    codeModel: ModelCannotDeleteCodeModelError;\n}\n\ntype RepositoryError = IDeleteModelRepositoryErrors[keyof IDeleteModelRepositoryErrors];\n\nexport const DeleteModelRepository =\n    createAbstraction<IDeleteModelRepository>(\"DeleteModelRepository\");\n\nexport namespace DeleteModelRepository {\n    export type Interface = IDeleteModelRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["DeleteModelUseCase","createAbstraction","DeleteModelRepository"],"mappings":";AAgCO,MAAMA,qBAAqBC,kBAAuC;AAwBlE,MAAMC,wBACTD,kBAA0C"}

package/features/contentModel/DeleteModel/events.d.ts

@@ -0,0 +1,54 @@
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * Event payloads
+ */
+export interface ModelBeforeDeleteEventPayload {
+    model: CmsModel;
+}
+export interface ModelAfterDeleteEventPayload {
+    model: CmsModel;
+}
+export interface ModelDeleteErrorEventPayload {
+    model: CmsModel;
+    error: Error;
+}
+/**
+ * ModelBeforeDeleteEvent - Published before deleting a model
+ */
+export declare class ModelBeforeDeleteEvent extends DomainEvent<ModelBeforeDeleteEventPayload> {
+    eventType: "Cms/Model/BeforeDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelBeforeDeleteEvent>>;
+}
+/** Hook into model lifecycle before a model is deleted. */
+export declare const ModelBeforeDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelBeforeDeleteEvent>>;
+export declare namespace ModelBeforeDeleteEventHandler {
+    type Interface = IEventHandler<ModelBeforeDeleteEvent>;
+    type Event = ModelBeforeDeleteEvent;
+}
+/**
+ * ModelAfterDeleteEvent - Published after deleting a model
+ */
+export declare class ModelAfterDeleteEvent extends DomainEvent<ModelAfterDeleteEventPayload> {
+    eventType: "Cms/Model/AfterDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelAfterDeleteEvent>>;
+}
+/** Hook into model lifecycle after a model is deleted. */
+export declare const ModelAfterDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelAfterDeleteEvent>>;
+export declare namespace ModelAfterDeleteEventHandler {
+    type Interface = IEventHandler<ModelAfterDeleteEvent>;
+    type Event = ModelAfterDeleteEvent;
+}
+/**
+ * ModelDeleteErrorEvent - Published when delete fails
+ */
+export declare class ModelDeleteErrorEvent extends DomainEvent<ModelDeleteErrorEventPayload> {
+    eventType: "Cms/Model/DeleteError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelDeleteErrorEvent>>;
+}
+export declare const ModelDeleteErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelDeleteErrorEvent>>;
+export declare namespace ModelDeleteErrorEventHandler {
+    type Interface = IEventHandler<ModelDeleteErrorEvent>;
+    type Event = ModelDeleteErrorEvent;
+}

package/features/contentModel/DeleteModel/events.js

@@ -0,0 +1,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class ModelBeforeDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelBeforeDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/BeforeDelete";
+    }
+}
+const ModelBeforeDeleteEventHandler = createAbstraction("ModelBeforeDeleteEventHandler");
+class ModelAfterDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelAfterDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/AfterDelete";
+    }
+}
+const ModelAfterDeleteEventHandler = createAbstraction("ModelAfterDeleteEventHandler");
+class ModelDeleteErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelDeleteErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/DeleteError";
+    }
+}
+const ModelDeleteErrorEventHandler = createAbstraction("ModelDeleteErrorEventHandler");
+export { ModelAfterDeleteEvent, ModelAfterDeleteEventHandler, ModelBeforeDeleteEvent, ModelBeforeDeleteEventHandler, ModelDeleteErrorEvent, ModelDeleteErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/contentModel/DeleteModel/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/DeleteModel/events.js","sources":["../../../../src/features/contentModel/DeleteModel/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { CmsModel } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface ModelBeforeDeleteEventPayload {\n    model: CmsModel;\n}\n\nexport interface ModelAfterDeleteEventPayload {\n    model: CmsModel;\n}\n\nexport interface ModelDeleteErrorEventPayload {\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * ModelBeforeDeleteEvent - Published before deleting a model\n */\nexport class ModelBeforeDeleteEvent extends DomainEvent<ModelBeforeDeleteEventPayload> {\n    eventType = \"Cms/Model/BeforeDelete\" as const;\n\n    getHandlerAbstraction() {\n        return ModelBeforeDeleteEventHandler;\n    }\n}\n\n/** Hook into model lifecycle before a model is deleted. */\nexport const ModelBeforeDeleteEventHandler = createAbstraction<\n    IEventHandler<ModelBeforeDeleteEvent>\n>(\"ModelBeforeDeleteEventHandler\");\n\nexport namespace ModelBeforeDeleteEventHandler {\n    export type Interface = IEventHandler<ModelBeforeDeleteEvent>;\n    export type Event = ModelBeforeDeleteEvent;\n}\n\n/**\n * ModelAfterDeleteEvent - Published after deleting a model\n */\nexport class ModelAfterDeleteEvent extends DomainEvent<ModelAfterDeleteEventPayload> {\n    eventType = \"Cms/Model/AfterDelete\" as const;\n\n    getHandlerAbstraction() {\n        return ModelAfterDeleteEventHandler;\n    }\n}\n\n/** Hook into model lifecycle after a model is deleted. */\nexport const ModelAfterDeleteEventHandler = createAbstraction<IEventHandler<ModelAfterDeleteEvent>>(\n    \"ModelAfterDeleteEventHandler\"\n);\n\nexport namespace ModelAfterDeleteEventHandler {\n    export type Interface = IEventHandler<ModelAfterDeleteEvent>;\n    export type Event = ModelAfterDeleteEvent;\n}\n\n/**\n * ModelDeleteErrorEvent - Published when delete fails\n */\nexport class ModelDeleteErrorEvent extends DomainEvent<ModelDeleteErrorEventPayload> {\n    eventType = \"Cms/Model/DeleteError\" as const;\n\n    getHandlerAbstraction() {\n        return ModelDeleteErrorEventHandler;\n    }\n}\n\nexport const ModelDeleteErrorEventHandler = createAbstraction<IEventHandler<ModelDeleteErrorEvent>>(\n    \"ModelDeleteErrorEventHandler\"\n);\n\nexport namespace ModelDeleteErrorEventHandler {\n    export type Interface = IEventHandler<ModelDeleteErrorEvent>;\n    export type Event = ModelDeleteErrorEvent;\n}\n"],"names":["ModelBeforeDeleteEvent","DomainEvent","ModelBeforeDeleteEventHandler","createAbstraction","ModelAfterDeleteEvent","ModelAfterDeleteEventHandler","ModelDeleteErrorEvent","ModelDeleteErrorEventHandler"],"mappings":";;AAwBO,MAAMA,+BAA+BC;IAGxC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,gCAAgCC,kBAE3C;AAUK,MAAMC,8BAA8BH;IAGvC,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,+BAA+BF,kBACxC;AAWG,MAAMG,8BAA8BL;IAGvC,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,+BAA+BJ,kBACxC"}

package/features/contentModel/DeleteModel/feature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * DeleteModel Feature
+ *
+ * Provides functionality for deleting content models.
+ * Includes entry cleanup for singleton models and validation for regular models.
+ */
+export declare const DeleteModelFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/contentModel/DeleteModel/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteModelUseCase } from "./DeleteModelUseCase.js";
+import { DeleteModelRepository } from "./DeleteModelRepository.js";
+import { DeleteModelWithEntryCleanup } from "./DeleteModelWithEntryCleanup.js";
+const DeleteModelFeature = createFeature({
+    name: "DeleteModel",
+    register (container) {
+        container.register(DeleteModelUseCase);
+        container.register(DeleteModelRepository).inSingletonScope();
+        container.registerDecorator(DeleteModelWithEntryCleanup);
+    }
+});
+export { DeleteModelFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/contentModel/DeleteModel/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/DeleteModel/feature.js","sources":["../../../../src/features/contentModel/DeleteModel/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { DeleteModelUseCase } from \"./DeleteModelUseCase.js\";\nimport { DeleteModelRepository } from \"./DeleteModelRepository.js\";\nimport { DeleteModelWithEntryCleanup } from \"./DeleteModelWithEntryCleanup.js\";\n\n/**\n * DeleteModel Feature\n *\n * Provides functionality for deleting content models.\n * Includes entry cleanup for singleton models and validation for regular models.\n */\nexport const DeleteModelFeature = createFeature({\n    name: \"DeleteModel\",\n    register(container) {\n        // Register core use case\n        container.register(DeleteModelUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(DeleteModelRepository).inSingletonScope();\n\n        // Register entry cleanup decorator\n        container.registerDecorator(DeleteModelWithEntryCleanup);\n    }\n});\n"],"names":["DeleteModelFeature","createFeature","container","DeleteModelUseCase","DeleteModelRepository","DeleteModelWithEntryCleanup"],"mappings":";;;;AAWO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;QAG1DF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

package/features/contentModel/DeleteModel/index.d.ts

@@ -0,0 +1,2 @@
+export { DeleteModelUseCase, DeleteModelRepository } from "./abstractions.js";
+export { ModelAfterDeleteEventHandler, ModelBeforeDeleteEventHandler } from "./events.js";

package/features/contentModel/DeleteModel/index.js

@@ -0,0 +1,2 @@
+export { DeleteModelRepository, DeleteModelUseCase } from "./abstractions.js";
+export { ModelAfterDeleteEventHandler, ModelBeforeDeleteEventHandler } from "./events.js";

package/features/contentModel/GetModel/GetModelRepository.d.ts

@@ -0,0 +1,20 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelsFetcher } from "../../../features/contentModel/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * GetModelRepository - Fetches a single model by ID.
+ *
+ * Responsibilities:
+ * - Use ModelsFetcher to get cached models
+ * - Return the model or NotFoundError
+ */
+declare class GetModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private modelsFetcher;
+    constructor(modelsFetcher: ModelsFetcher.Interface);
+    execute(modelId: string): Promise<Result<CmsModel, RepositoryAbstraction.Error>>;
+}
+export declare const GetModelRepository: typeof GetModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetModelRepository>;
+};
+export {};

package/features/contentModel/GetModel/GetModelRepository.js

@@ -0,0 +1,25 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository } from "./abstractions.js";
+import { ModelsFetcher } from "../shared/abstractions.js";
+import { ModelNotFoundError } from "../../../domain/contentModel/errors.js";
+class GetModelRepositoryImpl {
+    constructor(modelsFetcher){
+        this.modelsFetcher = modelsFetcher;
+    }
+    async execute(modelId) {
+        const result = await this.modelsFetcher.fetchById(modelId);
+        if (result.isFail()) return result;
+        const model = result.value;
+        if (!model) return Result.fail(new ModelNotFoundError(modelId));
+        return Result.ok(model);
+    }
+}
+const GetModelRepository_GetModelRepository = GetModelRepository.createImplementation({
+    implementation: GetModelRepositoryImpl,
+    dependencies: [
+        ModelsFetcher
+    ]
+});
+export { GetModelRepository_GetModelRepository as GetModelRepository };
+
+//# sourceMappingURL=GetModelRepository.js.map

package/features/contentModel/GetModel/GetModelRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/GetModel/GetModelRepository.js","sources":["../../../../src/features/contentModel/GetModel/GetModelRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetModelRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelsFetcher } from \"~/features/contentModel/shared/abstractions.js\";\nimport { ModelNotFoundError } from \"~/domain/contentModel/errors.js\";\nimport type { CmsModel } from \"~/types/index.js\";\n\n/**\n * GetModelRepository - Fetches a single model by ID.\n *\n * Responsibilities:\n * - Use ModelsFetcher to get cached models\n * - Return the model or NotFoundError\n */\nclass GetModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(private modelsFetcher: ModelsFetcher.Interface) {}\n\n    async execute(modelId: string): Promise<Result<CmsModel, RepositoryAbstraction.Error>> {\n        const result = await this.modelsFetcher.fetchById(modelId);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const model = result.value;\n\n        if (!model) {\n            return Result.fail(new ModelNotFoundError(modelId));\n        }\n\n        return Result.ok(model);\n    }\n}\n\nexport const GetModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetModelRepositoryImpl,\n    dependencies: [ModelsFetcher]\n});\n"],"names":["GetModelRepositoryImpl","modelsFetcher","modelId","result","model","Result","ModelNotFoundError","GetModelRepository","RepositoryAbstraction","ModelsFetcher"],"mappings":";;;;AAaA,MAAMA;IACF,YAA2BC,aAAsC,CAAE;aAAxCA,aAAa,GAAbA;IAAyC;IAEpE,MAAM,QAAQC,OAAe,EAA0D;QACnF,MAAMC,SAAS,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,CAACD;QAElD,IAAIC,OAAO,MAAM,IACb,OAAOA;QAGX,MAAMC,QAAQD,OAAO,KAAK;QAE1B,IAAI,CAACC,OACD,OAAOC,OAAO,IAAI,CAAC,IAAIC,mBAAmBJ;QAG9C,OAAOG,OAAO,EAAE,CAACD;IACrB;AACJ;AAEO,MAAMG,wCAAqBC,mBAAAA,oBAA0C,CAAC;IACzE,gBAAgBR;IAChB,cAAc;QAACS;KAAc;AACjC"}

package/features/contentModel/GetModel/GetModelUseCase.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetModelRepository } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * GetModelUseCase - Retrieves a single content model by ID.
+ *
+ * Responsibilities:
+ * - Apply initial access control check
+ * - Delegate to repository (which uses ModelCache for plugin + DB models)
+ * - Apply model-specific access control check
+ * - Return the model or appropriate error
+ */
+declare class GetModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    constructor(repository: GetModelRepository.Interface, accessControl: AccessControl.Interface);
+    execute(modelId: string): Promise<Result<CmsModel, UseCaseAbstraction.Error>>;
+}
+export declare const GetModelUseCase: typeof GetModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetModelUseCase>;
+};
+export {};

package/features/contentModel/GetModel/GetModelUseCase.js

@@ -0,0 +1,31 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository, GetModelUseCase } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { ModelNotAuthorizedError } from "../../../domain/contentModel/errors.js";
+class GetModelUseCaseImpl {
+    constructor(repository, accessControl){
+        this.repository = repository;
+        this.accessControl = accessControl;
+    }
+    async execute(modelId) {
+        const result = await this.repository.execute(modelId);
+        if (result.isFail()) return result;
+        const model = result.value;
+        const canAccessModel = await this.accessControl.canAccessModel({
+            model,
+            rwd: "r"
+        });
+        if (!canAccessModel) return Result.fail(ModelNotAuthorizedError.fromModel(model));
+        return Result.ok(model);
+    }
+}
+const GetModelUseCase_GetModelUseCase = GetModelUseCase.createImplementation({
+    implementation: GetModelUseCaseImpl,
+    dependencies: [
+        GetModelRepository,
+        AccessControl
+    ]
+});
+export { GetModelUseCase_GetModelUseCase as GetModelUseCase };
+
+//# sourceMappingURL=GetModelUseCase.js.map

package/features/contentModel/GetModel/GetModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/GetModel/GetModelUseCase.js","sources":["../../../../src/features/contentModel/GetModel/GetModelUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetModelUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetModelRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { ModelNotAuthorizedError } from \"~/domain/contentModel/errors.js\";\n\n/**\n * GetModelUseCase - Retrieves a single content model by ID.\n *\n * Responsibilities:\n * - Apply initial access control check\n * - Delegate to repository (which uses ModelCache for plugin + DB models)\n * - Apply model-specific access control check\n * - Return the model or appropriate error\n */\nclass GetModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: GetModelRepository.Interface,\n        private accessControl: AccessControl.Interface\n    ) {}\n\n    async execute(modelId: string): Promise<Result<CmsModel, UseCaseAbstraction.Error>> {\n        const result = await this.repository.execute(modelId);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const model = result.value;\n\n        // Model-specific access control check\n        const canAccessModel = await this.accessControl.canAccessModel({ model, rwd: \"r\" });\n        if (!canAccessModel) {\n            return Result.fail(ModelNotAuthorizedError.fromModel(model));\n        }\n\n        return Result.ok(model);\n    }\n}\n\nexport const GetModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetModelUseCaseImpl,\n    dependencies: [GetModelRepository, AccessControl]\n});\n"],"names":["GetModelUseCaseImpl","repository","accessControl","modelId","result","model","canAccessModel","Result","ModelNotAuthorizedError","GetModelUseCase","UseCaseAbstraction","GetModelRepository","AccessControl"],"mappings":";;;;AAgBA,MAAMA;IACF,YACYC,UAAwC,EACxCC,aAAsC,CAChD;aAFUD,UAAU,GAAVA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,OAAe,EAAuD;QAChF,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACD;QAE7C,IAAIC,OAAO,MAAM,IACb,OAAOA;QAGX,MAAMC,QAAQD,OAAO,KAAK;QAG1B,MAAME,iBAAiB,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAED;YAAO,KAAK;QAAI;QACjF,IAAI,CAACC,gBACD,OAAOC,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACH;QAGzD,OAAOE,OAAO,EAAE,CAACF;IACrB;AACJ;AAEO,MAAMI,kCAAkBC,gBAAAA,oBAAuC,CAAC;IACnE,gBAAgBV;IAChB,cAAc;QAACW;QAAoBC;KAAc;AACrD"}

package/features/contentModel/GetModel/abstractions.d.ts

@@ -0,0 +1,39 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsModel } from "../../../types/index.js";
+import { ModelNotAuthorizedError, type ModelNotFoundError, type ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+/**
+ * GetModel Use Case
+ */
+export interface IGetModelUseCase {
+    execute(modelId: string): Promise<Result<CmsModel, UseCaseError>>;
+}
+export interface IGetModelUseCaseErrors {
+    notFound: ModelNotFoundError;
+    notAuthorized: ModelNotAuthorizedError;
+    persistence: ModelPersistenceError;
+}
+type UseCaseError = IGetModelUseCaseErrors[keyof IGetModelUseCaseErrors];
+/** Retrieve a content model. */
+export declare const GetModelUseCase: import("@webiny/di").Abstraction<IGetModelUseCase>;
+export declare namespace GetModelUseCase {
+    type Interface = IGetModelUseCase;
+    type Error = UseCaseError;
+    type Return = Promise<Result<CmsModel, UseCaseError>>;
+}
+/**
+ * GetModelRepository - Fetches a single model by ID from cache.
+ */
+export interface IGetModelRepository {
+    execute(modelId: string): Promise<Result<CmsModel, RepositoryError>>;
+}
+export interface IGetModelRepositoryErrors {
+    notFound: ModelNotFoundError;
+    persistence: ModelPersistenceError;
+}
+type RepositoryError = IGetModelRepositoryErrors[keyof IGetModelRepositoryErrors];
+export declare const GetModelRepository: import("@webiny/di").Abstraction<IGetModelRepository>;
+export declare namespace GetModelRepository {
+    type Interface = IGetModelRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentModel/GetModel/abstractions.js

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

package/features/contentModel/GetModel/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/GetModel/abstractions.js","sources":["../../../../src/features/contentModel/GetModel/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport {\n    ModelNotAuthorizedError,\n    type ModelNotFoundError,\n    type ModelPersistenceError\n} from \"~/domain/contentModel/errors.js\";\n\n/**\n * GetModel Use Case\n */\nexport interface IGetModelUseCase {\n    execute(modelId: string): Promise<Result<CmsModel, UseCaseError>>;\n}\n\nexport interface IGetModelUseCaseErrors {\n    notFound: ModelNotFoundError;\n    notAuthorized: ModelNotAuthorizedError;\n    persistence: ModelPersistenceError;\n}\n\ntype UseCaseError = IGetModelUseCaseErrors[keyof IGetModelUseCaseErrors];\n\n/** Retrieve a content model. */\nexport const GetModelUseCase = createAbstraction<IGetModelUseCase>(\"GetModelUseCase\");\n\nexport namespace GetModelUseCase {\n    export type Interface = IGetModelUseCase;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<CmsModel, UseCaseError>>;\n}\n\n/**\n * GetModelRepository - Fetches a single model by ID from cache.\n */\nexport interface IGetModelRepository {\n    execute(modelId: string): Promise<Result<CmsModel, RepositoryError>>;\n}\n\nexport interface IGetModelRepositoryErrors {\n    notFound: ModelNotFoundError;\n    persistence: ModelPersistenceError;\n}\n\ntype RepositoryError = IGetModelRepositoryErrors[keyof IGetModelRepositoryErrors];\n\nexport const GetModelRepository = createAbstraction<IGetModelRepository>(\"GetModelRepository\");\n\nexport namespace GetModelRepository {\n    export type Interface = IGetModelRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["GetModelUseCase","createAbstraction","GetModelRepository"],"mappings":";AAwBO,MAAMA,kBAAkBC,kBAAoC;AAuB5D,MAAMC,qBAAqBD,kBAAuC"}

package/features/contentModel/GetModel/feature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * GetModel Feature
+ *
+ * Provides functionality for retrieving a single content model by ID.
+ * Includes caching, plugin model support, and access control filtering.
+ */
+export declare const GetModelFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/contentModel/GetModel/feature.js

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

package/features/contentModel/GetModel/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/GetModel/feature.js","sources":["../../../../src/features/contentModel/GetModel/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetModelUseCase } from \"./GetModelUseCase.js\";\nimport { GetModelRepository } from \"./GetModelRepository.js\";\n\n/**\n * GetModel Feature\n *\n * Provides functionality for retrieving a single content model by ID.\n * Includes caching, plugin model support, and access control filtering.\n */\nexport const GetModelFeature = createFeature({\n    name: \"GetModel\",\n    register(container) {\n        // Register use case in transient scope (new instance per request)\n        container.register(GetModelUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(GetModelRepository).inSingletonScope();\n    }\n});\n"],"names":["GetModelFeature","createFeature","container","GetModelUseCase","GetModelRepository"],"mappings":";;;AAUO,MAAMA,kBAAkBC,cAAc;IACzC,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,oBAAoB,gBAAgB;IAC3D;AACJ"}

package/features/contentModel/GetModel/index.d.ts

@@ -0,0 +1 @@
+export { GetModelUseCase, GetModelRepository } from "./abstractions.js";

package/features/contentModel/GetModel/index.js

@@ -0,0 +1 @@
+export { GetModelRepository, GetModelUseCase } from "./abstractions.js";

package/features/contentModel/ListModels/ListModelsRepository.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { ListModelsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelsFetcher } from "../../../features/contentModel/shared/abstractions.js";
+import type { CmsModel, ICmsModelListParams } from "../../../types/index.js";
+/**
+ * ListModelsRepository - Fetches all models with optional filters.
+ *
+ * Responsibilities:
+ * - Use ModelsFetcher to get cached models
+ * - Apply includePrivate and includePlugins filters
+ * - Return all accessible models
+ */
+declare class ListModelsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private modelsFetcher;
+    constructor(modelsFetcher: ModelsFetcher.Interface);
+    execute(params?: ICmsModelListParams): Promise<Result<CmsModel[], RepositoryAbstraction.Error>>;
+}
+export declare const ListModelsRepository: typeof ListModelsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListModelsRepository>;
+};
+export {};