@webiny/api-headless-cms 0.0.0-unstable.e6f0dc8ca7 → 0.0.0-unstable.eb81deee7e

package/features/contentModel/DeleteModel/DeleteModelWithEntryCleanup.js

@@ -1,97 +1,82 @@
 import { Result } from "@webiny/feature/api";
 import { DeleteModelUseCase } from "./abstractions.js";
-import { CmsContext } from "../../shared/abstractions.js";
+import { GetModelUseCase } from "../GetModel/index.js";
+import { ListDeletedEntriesUseCase, ListLatestEntriesUseCase } from "../../contentEntry/ListEntries/index.js";
+import { DeleteEntryUseCase } from "../../contentEntry/DeleteEntry/index.js";
 import { CMS_MODEL_SINGLETON_TAG } from "../../../constants.js";
 import { ModelCannotDeleteHasEntriesError, ModelCannotDeleteHasEntriesInTrashError, ModelPersistenceError, ModelValidationError } from "../../../domain/contentModel/errors.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
- */
 class DeleteModelWithEntryCleanupImpl {
-  constructor(cmsContext, decoratee) {
-    this.cmsContext = cmsContext;
-    this.decoratee = decoratee;
-  }
-  async execute(modelId) {
-    // First, get the model through the decorated use case's flow (up to before deletion)
-    // We need to perform validation before the actual deletion happens
-
-    // Get the model from context to check entries
-    const model = await this.cmsContext.cms.getModel(modelId);
-    const tags = Array.isArray(model.tags) ? model.tags : [];
-
-    // Handle singleton models: delete all entries
-    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}`));
-      }
-
-      // Proceed with the actual deletion
-      return this.decoratee.execute(modelId);
+    constructor(getModel, listLatestEntries, listDeletedEntries, deleteEntry, decoratee){
+        this.getModel = getModel;
+        this.listLatestEntries = listLatestEntries;
+        this.listDeletedEntries = listDeletedEntries;
+        this.deleteEntry = deleteEntry;
+        this.decoratee = decoratee;
     }
-
-    // Regular models
-    const canDelete = await this.canDelete(model);
-    if (canDelete.isFail()) {
-      return Result.fail(canDelete.error);
+    async execute(modelId) {
+        const modelResult = await this.getModel.execute(modelId);
+        if (modelResult.isFail()) return Result.fail(modelResult.error);
+        const model = modelResult.value;
+        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);
     }
-
-    // Proceed with the actual deletion
-    return this.decoratee.execute(modelId);
-  }
-  async deleteSingletonEntries(model) {
-    // Delete all latest entries
-    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
-      });
+    async deleteSingletonEntries(model) {
+        const latestEntries = await this.listLatestEntries.execute(model, {
+            limit: 10000
+        });
+        if (latestEntries.isFail()) throw latestEntries.error;
+        await this.deleteEntries(model, latestEntries.value.entries);
+        const deletedEntries = await this.listDeletedEntries.execute(model, {
+            limit: 10000
+        });
+        if (deletedEntries.isFail()) throw deletedEntries.error;
+        await this.deleteEntries(model, deletedEntries.value.entries);
     }
-
-    // Delete all deleted entries (trash)
-    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 deleteEntries(model, entries) {
+        for (const entry of entries){
+            const result = await this.deleteEntry.execute(model, entry.id, {
+                permanently: true
+            });
+            if (result.isFail()) throw result.error;
+        }
     }
-  }
-  async canDelete(model) {
-    try {
-      // Check for latest entries
-      const [latestEntries] = await this.cmsContext.cms.listLatestEntries(model, {
-        limit: 1
-      });
-      if (latestEntries.length > 0) {
-        return Result.fail(new ModelCannotDeleteHasEntriesError(model.modelId));
-      }
-
-      // Check for deleted entries (trash)
-      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));
+    async canDelete(model) {
+        try {
+            const latestEntries = await this.listLatestEntries.execute(model, {
+                limit: 1
+            });
+            if (latestEntries.isFail()) return Result.fail(new ModelPersistenceError(latestEntries.error));
+            if (latestEntries.value.entries.length > 0) return Result.fail(new ModelCannotDeleteHasEntriesError(model.modelId));
+            const deletedEntries = await this.listDeletedEntries.execute(model, {
+                limit: 1
+            });
+            if (deletedEntries.isFail()) return Result.fail(new ModelPersistenceError(deletedEntries.error));
+            if (deletedEntries.value.entries.length > 0) return Result.fail(new ModelCannotDeleteHasEntriesInTrashError(model.modelId));
+            return Result.ok(true);
+        } catch (error) {
+            return Result.fail(new ModelPersistenceError(error));
+        }
     }
-    return Result.ok(true);
-  }
 }
-export const DeleteModelWithEntryCleanup = DeleteModelUseCase.createDecorator({
-  decorator: DeleteModelWithEntryCleanupImpl,
-  dependencies: [CmsContext]
+const DeleteModelWithEntryCleanup = DeleteModelUseCase.createDecorator({
+    decorator: DeleteModelWithEntryCleanupImpl,
+    dependencies: [
+        GetModelUseCase,
+        ListLatestEntriesUseCase,
+        ListDeletedEntriesUseCase,
+        DeleteEntryUseCase
+    ]
 });
+export { DeleteModelWithEntryCleanup };
 
 //# sourceMappingURL=DeleteModelWithEntryCleanup.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["Result","DeleteModelUseCase","CmsContext","CMS_MODEL_SINGLETON_TAG","ModelCannotDeleteHasEntriesError","ModelCannotDeleteHasEntriesInTrashError","ModelPersistenceError","ModelValidationError","DeleteModelWithEntryCleanupImpl","constructor","cmsContext","decoratee","execute","modelId","model","cms","getModel","tags","Array","isArray","includes","deleteSingletonEntries","error","fail","message","canDelete","isFail","latestEntries","listLatestEntries","limit","item","deleteEntry","id","permanently","deletedEntries","listDeletedEntries","length","ok","DeleteModelWithEntryCleanup","createDecorator","decorator","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB;AAC3B,SAASC,UAAU;AACnB,SAASC,uBAAuB;AAChC,SACIC,gCAAgC,EAChCC,uCAAuC,EACvCC,qBAAqB,EACrBC,oBAAoB;AAIxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,+BAA+B,CAAyC;EACnEC,WAAWA,CACNC,UAAgC,EAChCC,SAAuC,EACjD;IAAA,KAFUD,UAAgC,GAAhCA,UAAgC;IAAA,KAChCC,SAAuC,GAAvCA,SAAuC;EAChD;EAEH,MAAMC,OAAOA,CAACC,OAAe,EAAmD;IAC5E;IACA;;IAEA;IACA,MAAMC,KAAK,GAAG,MAAM,IAAI,CAACJ,UAAU,CAACK,GAAG,CAACC,QAAQ,CAACH,OAAO,CAAC;IAEzD,MAAMI,IAAI,GAAGC,KAAK,CAACC,OAAO,CAACL,KAAK,CAACG,IAAI,CAAC,GAAGH,KAAK,CAACG,IAAI,GAAG,EAAE;;IAExD;IACA,IAAIA,IAAI,CAACG,QAAQ,CAACjB,uBAAuB,CAAC,EAAE;MACxC,IAAI;QACA,MAAM,IAAI,CAACkB,sBAAsB,CAACP,KAAK,CAAC;MAC5C,CAAC,CAAC,OAAOQ,KAAK,EAAE;QACZ,OAAOtB,MAAM,CAACuB,IAAI,CACd,IAAIhB,oBAAoB,CACpB,uCAAwCe,KAAK,CAAWE,OAAO,EACnE,CACJ,CAAC;MACL;;MAEA;MACA,OAAO,IAAI,CAACb,SAAS,CAACC,OAAO,CAACC,OAAO,CAAC;IAC1C;;IAEA;IACA,MAAMY,SAAS,GAAG,MAAM,IAAI,CAACA,SAAS,CAACX,KAAK,CAAC;IAC7C,IAAIW,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;MACpB,OAAO1B,MAAM,CAACuB,IAAI,CAACE,SAAS,CAACH,KAAK,CAAC;IACvC;;IAEA;IACA,OAAO,IAAI,CAACX,SAAS,CAACC,OAAO,CAACC,OAAO,CAAC;EAC1C;EAEA,MAAcQ,sBAAsBA,CAACP,KAAU,EAAiB;IAC5D;IACA,MAAM,CAACa,aAAa,CAAC,GAAG,MAAM,IAAI,CAACjB,UAAU,CAACK,GAAG,CAACa,iBAAiB,CAACd,KAAK,EAAE;MACvEe,KAAK,EAAE;IACX,CAAC,CAAC;IAEF,KAAK,MAAMC,IAAI,IAAIH,aAAa,EAAE;MAC9B,MAAM,IAAI,CAACjB,UAAU,CAACK,GAAG,CAACgB,WAAW,CAACjB,KAAK,EAAEgB,IAAI,CAACE,EAAE,EAAE;QAClDC,WAAW,EAAE;MACjB,CAAC,CAAC;IACN;;IAEA;IACA,MAAM,CAACC,cAAc,CAAC,GAAG,MAAM,IAAI,CAACxB,UAAU,CAACK,GAAG,CAACoB,kBAAkB,CAACrB,KAAK,EAAE;MACzEe,KAAK,EAAE;IACX,CAAC,CAAC;IAEF,KAAK,MAAMC,IAAI,IAAII,cAAc,EAAE;MAC/B,MAAM,IAAI,CAACxB,UAAU,CAACK,GAAG,CAACgB,WAAW,CAACjB,KAAK,EAAEgB,IAAI,CAACE,EAAE,EAAE;QAClDC,WAAW,EAAE;MACjB,CAAC,CAAC;IACN;EACJ;EAEA,MAAcR,SAASA,CACnBX,KAAe,EAQjB;IACE,IAAI;MACA;MACA,MAAM,CAACa,aAAa,CAAC,GAAG,MAAM,IAAI,CAACjB,UAAU,CAACK,GAAG,CAACa,iBAAiB,CAACd,KAAK,EAAE;QACvEe,KAAK,EAAE;MACX,CAAC,CAAC;MAEF,IAAIF,aAAa,CAACS,MAAM,GAAG,CAAC,EAAE;QAC1B,OAAOpC,MAAM,CAACuB,IAAI,CAAC,IAAInB,gCAAgC,CAACU,KAAK,CAACD,OAAO,CAAC,CAAC;MAC3E;;MAEA;MACA,MAAM,CAACqB,cAAc,CAAC,GAAG,MAAM,IAAI,CAACxB,UAAU,CAACK,GAAG,CAACoB,kBAAkB,CAACrB,KAAK,EAAE;QACzEe,KAAK,EAAE;MACX,CAAC,CAAC;MAEF,IAAIK,cAAc,CAACE,MAAM,GAAG,CAAC,EAAE;QAC3B,OAAOpC,MAAM,CAACuB,IAAI,CAAC,IAAIlB,uCAAuC,CAACS,KAAK,CAACD,OAAO,CAAC,CAAC;MAClF;IACJ,CAAC,CAAC,OAAOS,KAAK,EAAE;MACZ,OAAOtB,MAAM,CAACuB,IAAI,CAAC,IAAIjB,qBAAqB,CAACgB,KAAK,CAAC,CAAC;IACxD;IAEA,OAAOtB,MAAM,CAACqC,EAAE,CAAC,IAAI,CAAC;EAC1B;AACJ;AAEA,OAAO,MAAMC,2BAA2B,GAAGrC,kBAAkB,CAACsC,eAAe,CAAC;EAC1EC,SAAS,EAAEhC,+BAA+B;EAC1CiC,YAAY,EAAE,CAACvC,UAAU;AAC7B,CAAC,CAAC","ignoreList":[]}
+{"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 { GetModelUseCase } from \"~/features/contentModel/GetModel/index.js\";\nimport {\n    ListDeletedEntriesUseCase,\n    ListLatestEntriesUseCase\n} from \"~/features/contentEntry/ListEntries/index.js\";\nimport { DeleteEntryUseCase } from \"~/features/contentEntry/DeleteEntry/index.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 type { CmsModel } from \"~/types/model.js\";\nimport type { CmsEntry } from \"~/types/index.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 getModel: GetModelUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private listDeletedEntries: ListDeletedEntriesUseCase.Interface,\n        private deleteEntry: DeleteEntryUseCase.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        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return Result.fail(modelResult.error);\n        }\n        const model = modelResult.value;\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: CmsModel): Promise<void> {\n        // Delete all latest entries\n        const latestEntries = await this.listLatestEntries.execute(model, { limit: 10000 });\n        if (latestEntries.isFail()) {\n            throw latestEntries.error;\n        }\n        await this.deleteEntries(model, latestEntries.value.entries);\n\n        // Delete all deleted entries (trash)\n        const deletedEntries = await this.listDeletedEntries.execute(model, { limit: 10000 });\n        if (deletedEntries.isFail()) {\n            throw deletedEntries.error;\n        }\n        await this.deleteEntries(model, deletedEntries.value.entries);\n    }\n\n    private async deleteEntries(model: CmsModel, entries: CmsEntry[]): Promise<void> {\n        for (const entry of entries) {\n            const result = await this.deleteEntry.execute(model, entry.id, { permanently: true });\n            if (result.isFail()) {\n                throw result.error;\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        // The list use cases can also throw (a failed group lookup in access control does), so both\n        // failure paths end up as a persistence error.\n        try {\n            // Check for latest entries\n            const latestEntries = await this.listLatestEntries.execute(model, { limit: 1 });\n            if (latestEntries.isFail()) {\n                return Result.fail(new ModelPersistenceError(latestEntries.error));\n            }\n            if (latestEntries.value.entries.length > 0) {\n                return Result.fail(new ModelCannotDeleteHasEntriesError(model.modelId));\n            }\n\n            // Check for deleted entries (trash)\n            const deletedEntries = await this.listDeletedEntries.execute(model, { limit: 1 });\n            if (deletedEntries.isFail()) {\n                return Result.fail(new ModelPersistenceError(deletedEntries.error));\n            }\n            if (deletedEntries.value.entries.length > 0) {\n                return Result.fail(new ModelCannotDeleteHasEntriesInTrashError(model.modelId));\n            }\n\n            return Result.ok(true);\n        } catch (error) {\n            return Result.fail(new ModelPersistenceError(error));\n        }\n    }\n}\n\nexport const DeleteModelWithEntryCleanup = DeleteModelUseCase.createDecorator({\n    decorator: DeleteModelWithEntryCleanupImpl,\n    dependencies: [\n        GetModelUseCase,\n        ListLatestEntriesUseCase,\n        ListDeletedEntriesUseCase,\n        DeleteEntryUseCase\n    ]\n});\n"],"names":["DeleteModelWithEntryCleanupImpl","getModel","listLatestEntries","listDeletedEntries","deleteEntry","decoratee","modelId","modelResult","Result","model","tags","Array","CMS_MODEL_SINGLETON_TAG","error","ModelValidationError","canDelete","latestEntries","deletedEntries","entries","entry","result","ModelPersistenceError","ModelCannotDeleteHasEntriesError","ModelCannotDeleteHasEntriesInTrashError","DeleteModelWithEntryCleanup","DeleteModelUseCase","GetModelUseCase","ListLatestEntriesUseCase","ListDeletedEntriesUseCase","DeleteEntryUseCase"],"mappings":"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"}

package/features/contentModel/DeleteModel/abstractions.js

@@ -1,16 +1,6 @@
 import { createAbstraction } from "@webiny/feature/api";
-
-/**
- * DeleteModel Use Case
- */
-
-/** Delete a content model. */
-export const DeleteModelUseCase = createAbstraction("DeleteModelUseCase");
-
-/**
- * DeleteModelRepository - Validates and deletes a model from storage.
- */
-
-export const DeleteModelRepository = createAbstraction("DeleteModelRepository");
+const DeleteModelUseCase = createAbstraction("DeleteModelUseCase");
+const DeleteModelRepository = createAbstraction("DeleteModelRepository");
+export { DeleteModelRepository, DeleteModelUseCase };
 
 //# sourceMappingURL=abstractions.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","DeleteModelUseCase","DeleteModelRepository"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAY/D;AACA;AACA;;AAiBA;AACA,OAAO,MAAMC,kBAAkB,GAAGD,iBAAiB,CAAsB,oBAAoB,CAAC;;AAS9F;AACA;AACA;;AAaA,OAAO,MAAME,qBAAqB,GAC9BF,iBAAiB,CAAyB,uBAAuB,CAAC","ignoreList":[]}
+{"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.js

@@ -1,43 +1,32 @@
 import { createAbstraction } from "@webiny/feature/api";
 import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
-
-/**
- * Event payloads
- */
-
-/**
- * ModelBeforeDeleteEvent - Published before deleting a model
- */
-export class ModelBeforeDeleteEvent extends DomainEvent {
-  eventType = "Cms/Model/BeforeDelete";
-  getHandlerAbstraction() {
-    return ModelBeforeDeleteEventHandler;
-  }
+class ModelBeforeDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelBeforeDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/BeforeDelete";
+    }
 }
-
-/** Hook into model lifecycle before a model is deleted. */
-export const ModelBeforeDeleteEventHandler = createAbstraction("ModelBeforeDeleteEventHandler");
-/**
- * ModelAfterDeleteEvent - Published after deleting a model
- */
-export class ModelAfterDeleteEvent extends DomainEvent {
-  eventType = "Cms/Model/AfterDelete";
-  getHandlerAbstraction() {
-    return ModelAfterDeleteEventHandler;
-  }
+const ModelBeforeDeleteEventHandler = createAbstraction("ModelBeforeDeleteEventHandler");
+class ModelAfterDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelAfterDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/AfterDelete";
+    }
 }
-
-/** Hook into model lifecycle after a model is deleted. */
-export const ModelAfterDeleteEventHandler = createAbstraction("ModelAfterDeleteEventHandler");
-/**
- * ModelDeleteErrorEvent - Published when delete fails
- */
-export class ModelDeleteErrorEvent extends DomainEvent {
-  eventType = "Cms/Model/DeleteError";
-  getHandlerAbstraction() {
-    return ModelDeleteErrorEventHandler;
-  }
+const ModelAfterDeleteEventHandler = createAbstraction("ModelAfterDeleteEventHandler");
+class ModelDeleteErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelDeleteErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/DeleteError";
+    }
 }
-export const ModelDeleteErrorEventHandler = createAbstraction("ModelDeleteErrorEventHandler");
+const ModelDeleteErrorEventHandler = createAbstraction("ModelDeleteErrorEventHandler");
+export { ModelAfterDeleteEvent, ModelAfterDeleteEventHandler, ModelBeforeDeleteEvent, ModelBeforeDeleteEventHandler, ModelDeleteErrorEvent, ModelDeleteErrorEventHandler };
 
 //# sourceMappingURL=events.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","DomainEvent","ModelBeforeDeleteEvent","eventType","getHandlerAbstraction","ModelBeforeDeleteEventHandler","ModelAfterDeleteEvent","ModelAfterDeleteEventHandler","ModelDeleteErrorEvent","ModelDeleteErrorEventHandler"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,mDAAmD;;AAG/E;AACA;AACA;;AAcA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,SAASD,WAAW,CAAgC;EACnFE,SAAS,GAAG,wBAAwB;EAEpCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,6BAA6B;EACxC;AACJ;;AAEA;AACA,OAAO,MAAMA,6BAA6B,GAAGL,iBAAiB,CAE5D,+BAA+B,CAAC;AAOlC;AACA;AACA;AACA,OAAO,MAAMM,qBAAqB,SAASL,WAAW,CAA+B;EACjFE,SAAS,GAAG,uBAAuB;EAEnCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,4BAA4B;EACvC;AACJ;;AAEA;AACA,OAAO,MAAMA,4BAA4B,GAAGP,iBAAiB,CACzD,8BACJ,CAAC;AAOD;AACA;AACA;AACA,OAAO,MAAMQ,qBAAqB,SAASP,WAAW,CAA+B;EACjFE,SAAS,GAAG,uBAAuB;EAEnCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,4BAA4B;EACvC;AACJ;AAEA,OAAO,MAAMA,4BAA4B,GAAGT,iBAAiB,CACzD,8BACJ,CAAC","ignoreList":[]}
+{"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.js

@@ -2,25 +2,14 @@ import { createFeature } from "@webiny/feature/api";
 import { DeleteModelUseCase } from "./DeleteModelUseCase.js";
 import { DeleteModelRepository } from "./DeleteModelRepository.js";
 import { DeleteModelWithEntryCleanup } from "./DeleteModelWithEntryCleanup.js";
-
-/**
- * DeleteModel Feature
- *
- * Provides functionality for deleting content models.
- * Includes entry cleanup for singleton models and validation for regular models.
- */
-export const DeleteModelFeature = createFeature({
-  name: "DeleteModel",
-  register(container) {
-    // Register core use case
-    container.register(DeleteModelUseCase);
-
-    // Register repository in singleton scope (shared instance)
-    container.register(DeleteModelRepository).inSingletonScope();
-
-    // Register entry cleanup decorator
-    container.registerDecorator(DeleteModelWithEntryCleanup);
-  }
+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

@@ -1 +1 @@
-{"version":3,"names":["createFeature","DeleteModelUseCase","DeleteModelRepository","DeleteModelWithEntryCleanup","DeleteModelFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,kBAAkB;AAC3B,SAASC,qBAAqB;AAC9B,SAASC,2BAA2B;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kBAAkB,GAAGJ,aAAa,CAAC;EAC5CK,IAAI,EAAE,aAAa;EACnBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACL,kBAAkB,CAAC;;IAEtC;IACAM,SAAS,CAACD,QAAQ,CAACJ,qBAAqB,CAAC,CAACM,gBAAgB,CAAC,CAAC;;IAE5D;IACAD,SAAS,CAACE,iBAAiB,CAACN,2BAA2B,CAAC;EAC5D;AACJ,CAAC,CAAC","ignoreList":[]}
+{"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.js

@@ -1,4 +1,2 @@
-export { DeleteModelUseCase, DeleteModelRepository } from "./abstractions.js";
+export { DeleteModelRepository, DeleteModelUseCase } from "./abstractions.js";
 export { ModelAfterDeleteEventHandler, ModelBeforeDeleteEventHandler } from "./events.js";
-
-//# sourceMappingURL=index.js.map

package/features/contentModel/GetModel/GetModelRepository.js

@@ -1,33 +1,25 @@
 import { Result } from "@webiny/feature/api";
-import { GetModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { GetModelRepository } from "./abstractions.js";
 import { ModelsFetcher } from "../shared/abstractions.js";
 import { ModelNotFoundError } from "../../../domain/contentModel/errors.js";
-/**
- * GetModelRepository - Fetches a single model by ID.
- *
- * Responsibilities:
- * - Use ModelsFetcher to get cached models
- * - Return the model or NotFoundError
- */
 class GetModelRepositoryImpl {
-  constructor(modelsFetcher) {
-    this.modelsFetcher = modelsFetcher;
-  }
-  async execute(modelId) {
-    const result = await this.modelsFetcher.fetchById(modelId);
-    if (result.isFail()) {
-      return result;
+    constructor(modelsFetcher){
+        this.modelsFetcher = modelsFetcher;
     }
-    const model = result.value;
-    if (!model) {
-      return Result.fail(new ModelNotFoundError(modelId));
+    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);
     }
-    return Result.ok(model);
-  }
 }
-export const GetModelRepository = RepositoryAbstraction.createImplementation({
-  implementation: GetModelRepositoryImpl,
-  dependencies: [ModelsFetcher]
+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

@@ -1 +1 @@
-{"version":3,"names":["Result","GetModelRepository","RepositoryAbstraction","ModelsFetcher","ModelNotFoundError","GetModelRepositoryImpl","constructor","modelsFetcher","execute","modelId","result","fetchById","isFail","model","value","fail","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,IAAIC,qBAAqB;AACpD,SAASC,aAAa;AACtB,SAASC,kBAAkB;AAG3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,sBAAsB,CAA4C;EAC7DC,WAAWA,CAASC,aAAsC,EAAE;IAAA,KAAxCA,aAAsC,GAAtCA,aAAsC;EAAG;EAEpE,MAAMC,OAAOA,CAACC,OAAe,EAA0D;IACnF,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACH,aAAa,CAACI,SAAS,CAACF,OAAO,CAAC;IAE1D,IAAIC,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOF,MAAM;IACjB;IAEA,MAAMG,KAAK,GAAGH,MAAM,CAACI,KAAK;IAE1B,IAAI,CAACD,KAAK,EAAE;MACR,OAAOb,MAAM,CAACe,IAAI,CAAC,IAAIX,kBAAkB,CAACK,OAAO,CAAC,CAAC;IACvD;IAEA,OAAOT,MAAM,CAACgB,EAAE,CAACH,KAAK,CAAC;EAC3B;AACJ;AAEA,OAAO,MAAMZ,kBAAkB,GAAGC,qBAAqB,CAACe,oBAAoB,CAAC;EACzEC,cAAc,EAAEb,sBAAsB;EACtCc,YAAY,EAAE,CAAChB,aAAa;AAChC,CAAC,CAAC","ignoreList":[]}
+{"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.js

@@ -1,44 +1,31 @@
 import { Result } from "@webiny/feature/api";
-import { GetModelUseCase as UseCaseAbstraction } from "./abstractions.js";
-import { GetModelRepository } from "./abstractions.js";
+import { GetModelRepository, GetModelUseCase } from "./abstractions.js";
 import { AccessControl } from "../../shared/abstractions.js";
 import { ModelNotAuthorizedError } from "../../../domain/contentModel/errors.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
- */
 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;
+    constructor(repository, accessControl){
+        this.repository = repository;
+        this.accessControl = accessControl;
     }
-    const model = result.value;
-
-    // Model-specific access control check
-    const canAccessModel = await this.accessControl.canAccessModel({
-      model,
-      rwd: "r"
-    });
-    if (!canAccessModel) {
-      return Result.fail(ModelNotAuthorizedError.fromModel(model));
+    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);
     }
-    return Result.ok(model);
-  }
 }
-export const GetModelUseCase = UseCaseAbstraction.createImplementation({
-  implementation: GetModelUseCaseImpl,
-  dependencies: [GetModelRepository, AccessControl]
+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

@@ -1 +1 @@
-{"version":3,"names":["Result","GetModelUseCase","UseCaseAbstraction","GetModelRepository","AccessControl","ModelNotAuthorizedError","GetModelUseCaseImpl","constructor","repository","accessControl","execute","modelId","result","isFail","model","value","canAccessModel","rwd","fail","fromModel","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,IAAIC,kBAAkB;AAC9C,SAASC,kBAAkB;AAC3B,SAASC,aAAa;AAEtB,SAASC,uBAAuB;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mBAAmB,CAAyC;EACvDC,WAAWA,CACNC,UAAwC,EACxCC,aAAsC,EAChD;IAAA,KAFUD,UAAwC,GAAxCA,UAAwC;IAAA,KACxCC,aAAsC,GAAtCA,aAAsC;EAC/C;EAEH,MAAMC,OAAOA,CAACC,OAAe,EAAuD;IAChF,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,UAAU,CAACE,OAAO,CAACC,OAAO,CAAC;IAErD,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOD,MAAM;IACjB;IAEA,MAAME,KAAK,GAAGF,MAAM,CAACG,KAAK;;IAE1B;IACA,MAAMC,cAAc,GAAG,MAAM,IAAI,CAACP,aAAa,CAACO,cAAc,CAAC;MAAEF,KAAK;MAAEG,GAAG,EAAE;IAAI,CAAC,CAAC;IACnF,IAAI,CAACD,cAAc,EAAE;MACjB,OAAOhB,MAAM,CAACkB,IAAI,CAACb,uBAAuB,CAACc,SAAS,CAACL,KAAK,CAAC,CAAC;IAChE;IAEA,OAAOd,MAAM,CAACoB,EAAE,CAACN,KAAK,CAAC;EAC3B;AACJ;AAEA,OAAO,MAAMb,eAAe,GAAGC,kBAAkB,CAACmB,oBAAoB,CAAC;EACnEC,cAAc,EAAEhB,mBAAmB;EACnCiB,YAAY,EAAE,CAACpB,kBAAkB,EAAEC,aAAa;AACpD,CAAC,CAAC","ignoreList":[]}
+{"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.js

@@ -1,16 +1,6 @@
 import { createAbstraction } from "@webiny/feature/api";
-
-/**
- * GetModel Use Case
- */
-
-/** Retrieve a content model. */
-export const GetModelUseCase = createAbstraction("GetModelUseCase");
-
-/**
- * GetModelRepository - Fetches a single model by ID from cache.
- */
-
-export const GetModelRepository = createAbstraction("GetModelRepository");
+const GetModelUseCase = createAbstraction("GetModelUseCase");
+const GetModelRepository = createAbstraction("GetModelRepository");
+export { GetModelRepository, GetModelUseCase };
 
 //# sourceMappingURL=abstractions.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","GetModelUseCase","GetModelRepository"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAQ/D;AACA;AACA;;AAaA;AACA,OAAO,MAAMC,eAAe,GAAGD,iBAAiB,CAAmB,iBAAiB,CAAC;;AASrF;AACA;AACA;;AAYA,OAAO,MAAME,kBAAkB,GAAGF,iBAAiB,CAAsB,oBAAoB,CAAC","ignoreList":[]}
+{"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"}