@webiny/api-headless-cms 6.3.0-beta.4 → 6.4.0-beta.0

package/features/contentModel/CreateModelFrom/events.js

@@ -1,43 +1,32 @@
 import { createAbstraction } from "@webiny/feature/api";
 import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
-
-/**
- * Event payloads
- */
-
-/**
- * ModelBeforeCreateFromEvent - Published before creating a model from existing
- */
-export class ModelBeforeCreateFromEvent extends DomainEvent {
-  eventType = "Cms/Model/BeforeCreateFrom";
-  getHandlerAbstraction() {
-    return ModelBeforeCreateFromEventHandler;
-  }
+class ModelBeforeCreateFromEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelBeforeCreateFromEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/BeforeCreateFrom";
+    }
 }
-
-/** Hook into model lifecycle before a model is cloned. */
-export const ModelBeforeCreateFromEventHandler = createAbstraction("ModelBeforeCreateFromEventHandler");
-/**
- * ModelAfterCreateFromEvent - Published after creating a model from existing
- */
-export class ModelAfterCreateFromEvent extends DomainEvent {
-  eventType = "Cms/Model/AfterCreateFrom";
-  getHandlerAbstraction() {
-    return ModelAfterCreateFromEventHandler;
-  }
+const ModelBeforeCreateFromEventHandler = createAbstraction("ModelBeforeCreateFromEventHandler");
+class ModelAfterCreateFromEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelAfterCreateFromEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/AfterCreateFrom";
+    }
 }
-
-/** Hook into model lifecycle after a model is cloned. */
-export const ModelAfterCreateFromEventHandler = createAbstraction("ModelAfterCreateFromEventHandler");
-/**
- * ModelCreateFromErrorEvent - Published when create from fails
- */
-export class ModelCreateFromErrorEvent extends DomainEvent {
-  eventType = "Cms/Model/CreateFromError";
-  getHandlerAbstraction() {
-    return ModelCreateFromErrorEventHandler;
-  }
+const ModelAfterCreateFromEventHandler = createAbstraction("ModelAfterCreateFromEventHandler");
+class ModelCreateFromErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelCreateFromErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/CreateFromError";
+    }
 }
-export const ModelCreateFromErrorEventHandler = createAbstraction("ModelCreateFromErrorEventHandler");
+const ModelCreateFromErrorEventHandler = createAbstraction("ModelCreateFromErrorEventHandler");
+export { ModelAfterCreateFromEvent, ModelAfterCreateFromEventHandler, ModelBeforeCreateFromEvent, ModelBeforeCreateFromEventHandler, ModelCreateFromErrorEvent, ModelCreateFromErrorEventHandler };
 
 //# sourceMappingURL=events.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","DomainEvent","ModelBeforeCreateFromEvent","eventType","getHandlerAbstraction","ModelBeforeCreateFromEventHandler","ModelAfterCreateFromEvent","ModelAfterCreateFromEventHandler","ModelCreateFromErrorEvent","ModelCreateFromErrorEventHandler"],"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, CmsModelCreateFromInput } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface ModelBeforeCreateFromEventPayload {\n    model: CmsModel;\n    original: CmsModel;\n    input: CmsModelCreateFromInput;\n}\n\nexport interface ModelAfterCreateFromEventPayload {\n    model: CmsModel;\n    original: CmsModel;\n}\n\nexport interface ModelCreateFromErrorEventPayload {\n    input: CmsModelCreateFromInput;\n    model: CmsModel;\n    original: CmsModel;\n    error: Error;\n}\n\n/**\n * ModelBeforeCreateFromEvent - Published before creating a model from existing\n */\nexport class ModelBeforeCreateFromEvent extends DomainEvent<ModelBeforeCreateFromEventPayload> {\n    eventType = \"Cms/Model/BeforeCreateFrom\" as const;\n\n    getHandlerAbstraction() {\n        return ModelBeforeCreateFromEventHandler;\n    }\n}\n\n/** Hook into model lifecycle before a model is cloned. */\nexport const ModelBeforeCreateFromEventHandler = createAbstraction<\n    IEventHandler<ModelBeforeCreateFromEvent>\n>(\"ModelBeforeCreateFromEventHandler\");\n\nexport namespace ModelBeforeCreateFromEventHandler {\n    export type Interface = IEventHandler<ModelBeforeCreateFromEvent>;\n    export type Event = ModelBeforeCreateFromEvent;\n}\n\n/**\n * ModelAfterCreateFromEvent - Published after creating a model from existing\n */\nexport class ModelAfterCreateFromEvent extends DomainEvent<ModelAfterCreateFromEventPayload> {\n    eventType = \"Cms/Model/AfterCreateFrom\" as const;\n\n    getHandlerAbstraction() {\n        return ModelAfterCreateFromEventHandler;\n    }\n}\n\n/** Hook into model lifecycle after a model is cloned. */\nexport const ModelAfterCreateFromEventHandler = createAbstraction<\n    IEventHandler<ModelAfterCreateFromEvent>\n>(\"ModelAfterCreateFromEventHandler\");\n\nexport namespace ModelAfterCreateFromEventHandler {\n    export type Interface = IEventHandler<ModelAfterCreateFromEvent>;\n    export type Event = ModelAfterCreateFromEvent;\n}\n\n/**\n * ModelCreateFromErrorEvent - Published when create from fails\n */\nexport class ModelCreateFromErrorEvent extends DomainEvent<ModelCreateFromErrorEventPayload> {\n    eventType = \"Cms/Model/CreateFromError\" as const;\n\n    getHandlerAbstraction() {\n        return ModelCreateFromErrorEventHandler;\n    }\n}\n\nexport const ModelCreateFromErrorEventHandler = createAbstraction<\n    IEventHandler<ModelCreateFromErrorEvent>\n>(\"ModelCreateFromErrorEventHandler\");\n\nexport namespace ModelCreateFromErrorEventHandler {\n    export type Interface = IEventHandler<ModelCreateFromErrorEvent>;\n    export type Event = ModelCreateFromErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,mDAAmD;;AAG/E;AACA;AACA;;AAmBA;AACA;AACA;AACA,OAAO,MAAMC,0BAA0B,SAASD,WAAW,CAAoC;EAC3FE,SAAS,GAAG,4BAA4B;EAExCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,iCAAiC;EAC5C;AACJ;;AAEA;AACA,OAAO,MAAMA,iCAAiC,GAAGL,iBAAiB,CAEhE,mCAAmC,CAAC;AAOtC;AACA;AACA;AACA,OAAO,MAAMM,yBAAyB,SAASL,WAAW,CAAmC;EACzFE,SAAS,GAAG,2BAA2B;EAEvCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,gCAAgC;EAC3C;AACJ;;AAEA;AACA,OAAO,MAAMA,gCAAgC,GAAGP,iBAAiB,CAE/D,kCAAkC,CAAC;AAOrC;AACA;AACA;AACA,OAAO,MAAMQ,yBAAyB,SAASP,WAAW,CAAmC;EACzFE,SAAS,GAAG,2BAA2B;EAEvCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,gCAAgC;EAC3C;AACJ;AAEA,OAAO,MAAMA,gCAAgC,GAAGT,iBAAiB,CAE/D,kCAAkC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/contentModel/CreateModelFrom/events.js","sources":["../../../../src/features/contentModel/CreateModelFrom/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, CmsModelCreateFromInput } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface ModelBeforeCreateFromEventPayload {\n    model: CmsModel;\n    original: CmsModel;\n    input: CmsModelCreateFromInput;\n}\n\nexport interface ModelAfterCreateFromEventPayload {\n    model: CmsModel;\n    original: CmsModel;\n}\n\nexport interface ModelCreateFromErrorEventPayload {\n    input: CmsModelCreateFromInput;\n    model: CmsModel;\n    original: CmsModel;\n    error: Error;\n}\n\n/**\n * ModelBeforeCreateFromEvent - Published before creating a model from existing\n */\nexport class ModelBeforeCreateFromEvent extends DomainEvent<ModelBeforeCreateFromEventPayload> {\n    eventType = \"Cms/Model/BeforeCreateFrom\" as const;\n\n    getHandlerAbstraction() {\n        return ModelBeforeCreateFromEventHandler;\n    }\n}\n\n/** Hook into model lifecycle before a model is cloned. */\nexport const ModelBeforeCreateFromEventHandler = createAbstraction<\n    IEventHandler<ModelBeforeCreateFromEvent>\n>(\"ModelBeforeCreateFromEventHandler\");\n\nexport namespace ModelBeforeCreateFromEventHandler {\n    export type Interface = IEventHandler<ModelBeforeCreateFromEvent>;\n    export type Event = ModelBeforeCreateFromEvent;\n}\n\n/**\n * ModelAfterCreateFromEvent - Published after creating a model from existing\n */\nexport class ModelAfterCreateFromEvent extends DomainEvent<ModelAfterCreateFromEventPayload> {\n    eventType = \"Cms/Model/AfterCreateFrom\" as const;\n\n    getHandlerAbstraction() {\n        return ModelAfterCreateFromEventHandler;\n    }\n}\n\n/** Hook into model lifecycle after a model is cloned. */\nexport const ModelAfterCreateFromEventHandler = createAbstraction<\n    IEventHandler<ModelAfterCreateFromEvent>\n>(\"ModelAfterCreateFromEventHandler\");\n\nexport namespace ModelAfterCreateFromEventHandler {\n    export type Interface = IEventHandler<ModelAfterCreateFromEvent>;\n    export type Event = ModelAfterCreateFromEvent;\n}\n\n/**\n * ModelCreateFromErrorEvent - Published when create from fails\n */\nexport class ModelCreateFromErrorEvent extends DomainEvent<ModelCreateFromErrorEventPayload> {\n    eventType = \"Cms/Model/CreateFromError\" as const;\n\n    getHandlerAbstraction() {\n        return ModelCreateFromErrorEventHandler;\n    }\n}\n\nexport const ModelCreateFromErrorEventHandler = createAbstraction<\n    IEventHandler<ModelCreateFromErrorEvent>\n>(\"ModelCreateFromErrorEventHandler\");\n\nexport namespace ModelCreateFromErrorEventHandler {\n    export type Interface = IEventHandler<ModelCreateFromErrorEvent>;\n    export type Event = ModelCreateFromErrorEvent;\n}\n"],"names":["ModelBeforeCreateFromEvent","DomainEvent","ModelBeforeCreateFromEventHandler","createAbstraction","ModelAfterCreateFromEvent","ModelAfterCreateFromEventHandler","ModelCreateFromErrorEvent","ModelCreateFromErrorEventHandler"],"mappings":";;AA6BO,MAAMA,mCAAmCC;IAG5C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,oCAAoCC,kBAE/C;AAUK,MAAMC,kCAAkCH;IAG3C,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,mCAAmCF,kBAE9C;AAUK,MAAMG,kCAAkCL;IAG3C,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,mCAAmCJ,kBAE9C"}

package/features/contentModel/CreateModelFrom/feature.js

@@ -1,22 +1,13 @@
 import { createFeature } from "@webiny/feature/api";
 import { CreateModelFromUseCase } from "./CreateModelFromUseCase.js";
 import { CreateModelFromRepository } from "./CreateModelFromRepository.js";
-
-/**
- * CreateModelFrom Feature
- *
- * Provides functionality for cloning/copying existing content models.
- * All validation (modelId generation, domain rules, uniqueness) is handled by the repository.
- */
-export const CreateModelFromFeature = createFeature({
-  name: "CreateModelFrom",
-  register(container) {
-    // Register core use case
-    container.register(CreateModelFromUseCase);
-
-    // Register repository in singleton scope (shared instance)
-    container.register(CreateModelFromRepository).inSingletonScope();
-  }
+const CreateModelFromFeature = createFeature({
+    name: "CreateModelFrom",
+    register (container) {
+        container.register(CreateModelFromUseCase);
+        container.register(CreateModelFromRepository).inSingletonScope();
+    }
 });
+export { CreateModelFromFeature };
 
 //# sourceMappingURL=feature.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["createFeature","CreateModelFromUseCase","CreateModelFromRepository","CreateModelFromFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateModelFromUseCase } from \"./CreateModelFromUseCase.js\";\nimport { CreateModelFromRepository } from \"./CreateModelFromRepository.js\";\n\n/**\n * CreateModelFrom Feature\n *\n * Provides functionality for cloning/copying existing content models.\n * All validation (modelId generation, domain rules, uniqueness) is handled by the repository.\n */\nexport const CreateModelFromFeature = createFeature({\n    name: \"CreateModelFrom\",\n    register(container) {\n        // Register core use case\n        container.register(CreateModelFromUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(CreateModelFromRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;;AAElC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,GAAGH,aAAa,CAAC;EAChDI,IAAI,EAAE,iBAAiB;EACvBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACJ,sBAAsB,CAAC;;IAE1C;IACAK,SAAS,CAACD,QAAQ,CAACH,yBAAyB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACpE;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/contentModel/CreateModelFrom/feature.js","sources":["../../../../src/features/contentModel/CreateModelFrom/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateModelFromUseCase } from \"./CreateModelFromUseCase.js\";\nimport { CreateModelFromRepository } from \"./CreateModelFromRepository.js\";\n\n/**\n * CreateModelFrom Feature\n *\n * Provides functionality for cloning/copying existing content models.\n * All validation (modelId generation, domain rules, uniqueness) is handled by the repository.\n */\nexport const CreateModelFromFeature = createFeature({\n    name: \"CreateModelFrom\",\n    register(container) {\n        // Register core use case\n        container.register(CreateModelFromUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(CreateModelFromRepository).inSingletonScope();\n    }\n});\n"],"names":["CreateModelFromFeature","createFeature","container","CreateModelFromUseCase","CreateModelFromRepository"],"mappings":";;;AAUO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,2BAA2B,gBAAgB;IAClE;AACJ"}

package/features/contentModel/CreateModelFrom/index.js

@@ -1,4 +1,2 @@
-export { CreateModelFromUseCase, CreateModelFromRepository } from "./abstractions.js";
+export { CreateModelFromRepository, CreateModelFromUseCase } from "./abstractions.js";
 export { ModelAfterCreateFromEventHandler, ModelBeforeCreateFromEventHandler } from "./events.js";
-
-//# sourceMappingURL=index.js.map

package/features/contentModel/DeleteModel/DeleteModelRepository.js

@@ -1,51 +1,37 @@
 import { Result } from "@webiny/feature/api";
-import { DeleteModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { DeleteModelRepository } from "./abstractions.js";
 import { ModelCache, ModelsFetcher } from "../shared/abstractions.js";
 import { ModelCannotDeleteCodeModelError, ModelPersistenceError } from "../../../domain/contentModel/errors.js";
 import { StorageOperations } from "../../shared/abstractions.js";
-/**
- * DeleteModelRepository - Validates and deletes a model from storage.
- *
- * Responsibilities:
- * - Validate model is not defined via plugin (core domain rule)
- * - Delete from storage
- * - Clear ModelCache after successful deletion
- *
- * Note: Entry validation and cleanup is handled by decorator
- */
 class DeleteModelRepositoryImpl {
-  constructor(modelCache, modelsFetcher, storageOperations) {
-    this.modelCache = modelCache;
-    this.modelsFetcher = modelsFetcher;
-    this.storageOperations = storageOperations;
-  }
-  async execute(model) {
-    try {
-      // Check if this is a plugin model
-      const existingModelResult = await this.modelsFetcher.fetchById(model.modelId);
-      if (existingModelResult.isFail()) {
-        return Result.fail(new ModelPersistenceError(existingModelResult.error));
-      }
-      if (existingModelResult.value.isPlugin) {
-        return Result.fail(new ModelCannotDeleteCodeModelError(model.modelId));
-      }
-
-      // Delete from storage
-      await this.storageOperations.models.delete({
-        model
-      });
-
-      // Clear cache
-      this.modelCache.clear();
-      return Result.ok();
-    } catch (error) {
-      return Result.fail(new ModelPersistenceError(error));
+    constructor(modelCache, modelsFetcher, storageOperations){
+        this.modelCache = modelCache;
+        this.modelsFetcher = modelsFetcher;
+        this.storageOperations = storageOperations;
+    }
+    async execute(model) {
+        try {
+            const existingModelResult = await this.modelsFetcher.fetchById(model.modelId);
+            if (existingModelResult.isFail()) return Result.fail(new ModelPersistenceError(existingModelResult.error));
+            if (existingModelResult.value.isPlugin) return Result.fail(new ModelCannotDeleteCodeModelError(model.modelId));
+            await this.storageOperations.models.delete({
+                model
+            });
+            this.modelCache.clear();
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(new ModelPersistenceError(error));
+        }
     }
-  }
 }
-export const DeleteModelRepository = RepositoryAbstraction.createImplementation({
-  implementation: DeleteModelRepositoryImpl,
-  dependencies: [ModelCache, ModelsFetcher, StorageOperations]
+const DeleteModelRepository_DeleteModelRepository = DeleteModelRepository.createImplementation({
+    implementation: DeleteModelRepositoryImpl,
+    dependencies: [
+        ModelCache,
+        ModelsFetcher,
+        StorageOperations
+    ]
 });
+export { DeleteModelRepository_DeleteModelRepository as DeleteModelRepository };
 
 //# sourceMappingURL=DeleteModelRepository.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["Result","DeleteModelRepository","RepositoryAbstraction","ModelCache","ModelsFetcher","ModelCannotDeleteCodeModelError","ModelPersistenceError","StorageOperations","DeleteModelRepositoryImpl","constructor","modelCache","modelsFetcher","storageOperations","execute","model","existingModelResult","fetchById","modelId","isFail","fail","error","value","isPlugin","models","delete","clear","ok","createImplementation","implementation","dependencies"],"sources":["DeleteModelRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { DeleteModelRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelCache, ModelsFetcher } from \"~/features/contentModel/shared/abstractions.js\";\nimport {\n    ModelCannotDeleteCodeModelError,\n    ModelPersistenceError\n} from \"~/domain/contentModel/errors.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\n\n/**\n * DeleteModelRepository - Validates and deletes a model from storage.\n *\n * Responsibilities:\n * - Validate model is not defined via plugin (core domain rule)\n * - Delete from storage\n * - Clear ModelCache after successful deletion\n *\n * Note: Entry validation and cleanup is handled by decorator\n */\nclass DeleteModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private modelCache: ModelCache.Interface,\n        private modelsFetcher: ModelsFetcher.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    async execute(model: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            // Check if this is a plugin model\n            const existingModelResult = await this.modelsFetcher.fetchById(model.modelId);\n            if (existingModelResult.isFail()) {\n                return Result.fail(new ModelPersistenceError(existingModelResult.error));\n            }\n\n            if (existingModelResult.value.isPlugin) {\n                return Result.fail(new ModelCannotDeleteCodeModelError(model.modelId));\n            }\n\n            // Delete from storage\n            await this.storageOperations.models.delete({ model });\n\n            // Clear cache\n            this.modelCache.clear();\n\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new ModelPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const DeleteModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: DeleteModelRepositoryImpl,\n    dependencies: [ModelCache, ModelsFetcher, StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,qBAAqB,IAAIC,qBAAqB;AACvD,SAASC,UAAU,EAAEC,aAAa;AAClC,SACIC,+BAA+B,EAC/BC,qBAAqB;AAEzB,SAASC,iBAAiB;AAG1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,yBAAyB,CAA4C;EAChEC,WAAWA,CACNC,UAAgC,EAChCC,aAAsC,EACtCC,iBAA8C,EACxD;IAAA,KAHUF,UAAgC,GAAhCA,UAAgC;IAAA,KAChCC,aAAsC,GAAtCA,aAAsC;IAAA,KACtCC,iBAA8C,GAA9CA,iBAA8C;EACvD;EAEH,MAAMC,OAAOA,CAACC,KAAe,EAAsD;IAC/E,IAAI;MACA;MACA,MAAMC,mBAAmB,GAAG,MAAM,IAAI,CAACJ,aAAa,CAACK,SAAS,CAACF,KAAK,CAACG,OAAO,CAAC;MAC7E,IAAIF,mBAAmB,CAACG,MAAM,CAAC,CAAC,EAAE;QAC9B,OAAOlB,MAAM,CAACmB,IAAI,CAAC,IAAIb,qBAAqB,CAACS,mBAAmB,CAACK,KAAK,CAAC,CAAC;MAC5E;MAEA,IAAIL,mBAAmB,CAACM,KAAK,CAACC,QAAQ,EAAE;QACpC,OAAOtB,MAAM,CAACmB,IAAI,CAAC,IAAId,+BAA+B,CAACS,KAAK,CAACG,OAAO,CAAC,CAAC;MAC1E;;MAEA;MACA,MAAM,IAAI,CAACL,iBAAiB,CAACW,MAAM,CAACC,MAAM,CAAC;QAAEV;MAAM,CAAC,CAAC;;MAErD;MACA,IAAI,CAACJ,UAAU,CAACe,KAAK,CAAC,CAAC;MAEvB,OAAOzB,MAAM,CAAC0B,EAAE,CAAC,CAAC;IACtB,CAAC,CAAC,OAAON,KAAK,EAAE;MACZ,OAAOpB,MAAM,CAACmB,IAAI,CAAC,IAAIb,qBAAqB,CAACc,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMnB,qBAAqB,GAAGC,qBAAqB,CAACyB,oBAAoB,CAAC;EAC5EC,cAAc,EAAEpB,yBAAyB;EACzCqB,YAAY,EAAE,CAAC1B,UAAU,EAAEC,aAAa,EAAEG,iBAAiB;AAC/D,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/contentModel/DeleteModel/DeleteModelRepository.js","sources":["../../../../src/features/contentModel/DeleteModel/DeleteModelRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { DeleteModelRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelCache, ModelsFetcher } from \"~/features/contentModel/shared/abstractions.js\";\nimport {\n    ModelCannotDeleteCodeModelError,\n    ModelPersistenceError\n} from \"~/domain/contentModel/errors.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\n\n/**\n * DeleteModelRepository - Validates and deletes a model from storage.\n *\n * Responsibilities:\n * - Validate model is not defined via plugin (core domain rule)\n * - Delete from storage\n * - Clear ModelCache after successful deletion\n *\n * Note: Entry validation and cleanup is handled by decorator\n */\nclass DeleteModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private modelCache: ModelCache.Interface,\n        private modelsFetcher: ModelsFetcher.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    async execute(model: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            // Check if this is a plugin model\n            const existingModelResult = await this.modelsFetcher.fetchById(model.modelId);\n            if (existingModelResult.isFail()) {\n                return Result.fail(new ModelPersistenceError(existingModelResult.error));\n            }\n\n            if (existingModelResult.value.isPlugin) {\n                return Result.fail(new ModelCannotDeleteCodeModelError(model.modelId));\n            }\n\n            // Delete from storage\n            await this.storageOperations.models.delete({ model });\n\n            // Clear cache\n            this.modelCache.clear();\n\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new ModelPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const DeleteModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: DeleteModelRepositoryImpl,\n    dependencies: [ModelCache, ModelsFetcher, StorageOperations]\n});\n"],"names":["DeleteModelRepositoryImpl","modelCache","modelsFetcher","storageOperations","model","existingModelResult","Result","ModelPersistenceError","ModelCannotDeleteCodeModelError","error","DeleteModelRepository","RepositoryAbstraction","ModelCache","ModelsFetcher","StorageOperations"],"mappings":";;;;;AAoBA,MAAMA;IACF,YACYC,UAAgC,EAChCC,aAAsC,EACtCC,iBAA8C,CACxD;aAHUF,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,iBAAiB,GAAjBA;IACT;IAEH,MAAM,QAAQC,KAAe,EAAsD;QAC/E,IAAI;YAEA,MAAMC,sBAAsB,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,CAACD,MAAM,OAAO;YAC5E,IAAIC,oBAAoB,MAAM,IAC1B,OAAOC,OAAO,IAAI,CAAC,IAAIC,sBAAsBF,oBAAoB,KAAK;YAG1E,IAAIA,oBAAoB,KAAK,CAAC,QAAQ,EAClC,OAAOC,OAAO,IAAI,CAAC,IAAIE,gCAAgCJ,MAAM,OAAO;YAIxE,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC;gBAAEA;YAAM;YAGnD,IAAI,CAAC,UAAU,CAAC,KAAK;YAErB,OAAOE,OAAO,EAAE;QACpB,EAAE,OAAOG,OAAO;YACZ,OAAOH,OAAO,IAAI,CAAC,IAAIC,sBAAsBE;QACjD;IACJ;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBX;IAChB,cAAc;QAACY;QAAYC;QAAeC;KAAkB;AAChE"}

package/features/contentModel/DeleteModel/DeleteModelUseCase.js

@@ -1,84 +1,56 @@
 import { Result } from "@webiny/feature/api";
-import { DeleteModelUseCase as UseCaseAbstraction } from "./abstractions.js";
-import { DeleteModelRepository } from "./abstractions.js";
+import { DeleteModelRepository, DeleteModelUseCase } from "./abstractions.js";
 import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
-import { ModelBeforeDeleteEvent } from "./events.js";
-import { ModelAfterDeleteEvent } from "./events.js";
-import { ModelDeleteErrorEvent } from "./events.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";
-
-/**
- * DeleteModelUseCase - Core model deletion orchestration.
- *
- * Responsibilities:
- * - Fetch model
- * - Access control checks
- * - Publish before event
- * - Delegate to repository for deletion
- * - Publish after event or error event
- *
- * Note: Validation (e.g., checking for entries, plugin models) should be done in event handlers
- */
 class DeleteModelUseCaseImpl {
-  constructor(getModelUseCase, eventPublisher, repository, accessControl) {
-    this.getModelUseCase = getModelUseCase;
-    this.eventPublisher = eventPublisher;
-    this.repository = repository;
-    this.accessControl = accessControl;
-  }
-  async execute(modelId) {
-    // Initial access control check
-    const canAccess = await this.accessControl.canAccessModel({
-      rwd: "d"
-    });
-    if (!canAccess) {
-      return Result.fail(new ModelNotAuthorizedError());
-    }
-
-    // Get the model (with access control check)
-    const getResult = await this.getModelUseCase.execute(modelId);
-    if (getResult.isFail()) {
-      return Result.fail(getResult.error);
-    }
-    const model = getResult.value;
-
-    // Access control check on the specific model
-    const canAccessModel = await this.accessControl.canAccessModel({
-      model,
-      rwd: "d"
-    });
-    if (!canAccessModel) {
-      return Result.fail(ModelNotAuthorizedError.fromModel(model));
+    constructor(getModelUseCase, eventPublisher, repository, accessControl){
+        this.getModelUseCase = getModelUseCase;
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+        this.accessControl = accessControl;
     }
-
-    // Publish before event
-    await this.eventPublisher.publish(new ModelBeforeDeleteEvent({
-      model
-    }));
-
-    // Delete via repository
-    const result = await this.repository.execute(model);
-    if (result.isFail()) {
-      // Publish error event
-      await this.eventPublisher.publish(new ModelDeleteErrorEvent({
-        model,
-        error: result.error
-      }));
-      return Result.fail(result.error);
+    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();
     }
-
-    // Publish after event
-    await this.eventPublisher.publish(new ModelAfterDeleteEvent({
-      model
-    }));
-    return Result.ok();
-  }
 }
-export const DeleteModelUseCase = UseCaseAbstraction.createImplementation({
-  implementation: DeleteModelUseCaseImpl,
-  dependencies: [GetModelUseCase, EventPublisher, DeleteModelRepository, AccessControl]
+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

@@ -1 +1 @@
-{"version":3,"names":["Result","DeleteModelUseCase","UseCaseAbstraction","DeleteModelRepository","EventPublisher","ModelBeforeDeleteEvent","ModelAfterDeleteEvent","ModelDeleteErrorEvent","AccessControl","ModelNotAuthorizedError","GetModelUseCase","DeleteModelUseCaseImpl","constructor","getModelUseCase","eventPublisher","repository","accessControl","execute","modelId","canAccess","canAccessModel","rwd","fail","getResult","isFail","error","model","value","fromModel","publish","result","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,IAAIC,kBAAkB;AACjD,SAASC,qBAAqB;AAC9B,SAASC,cAAc,QAAQ,mDAAmD;AAClF,SAASC,sBAAsB;AAC/B,SAASC,qBAAqB;AAC9B,SAASC,qBAAqB;AAC9B,SAASC,aAAa;AACtB,SAASC,uBAAuB;AAChC,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,sBAAsB,CAAyC;EAC1DC,WAAWA,CACNC,eAA0C,EAC1CC,cAAwC,EACxCC,UAA2C,EAC3CC,aAAsC,EAChD;IAAA,KAJUH,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,UAA2C,GAA3CA,UAA2C;IAAA,KAC3CC,aAAsC,GAAtCA,aAAsC;EAC/C;EAEH,MAAMC,OAAOA,CAACC,OAAe,EAAmD;IAC5E;IACA,MAAMC,SAAS,GAAG,MAAM,IAAI,CAACH,aAAa,CAACI,cAAc,CAAC;MAAEC,GAAG,EAAE;IAAI,CAAC,CAAC;IACvE,IAAI,CAACF,SAAS,EAAE;MACZ,OAAOnB,MAAM,CAACsB,IAAI,CAAC,IAAIb,uBAAuB,CAAC,CAAC,CAAC;IACrD;;IAEA;IACA,MAAMc,SAAS,GAAG,MAAM,IAAI,CAACV,eAAe,CAACI,OAAO,CAACC,OAAO,CAAC;IAC7D,IAAIK,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;MACpB,OAAOxB,MAAM,CAACsB,IAAI,CAACC,SAAS,CAACE,KAAK,CAAC;IACvC;IAEA,MAAMC,KAAK,GAAGH,SAAS,CAACI,KAAK;;IAE7B;IACA,MAAMP,cAAc,GAAG,MAAM,IAAI,CAACJ,aAAa,CAACI,cAAc,CAAC;MAAEM,KAAK;MAAEL,GAAG,EAAE;IAAI,CAAC,CAAC;IACnF,IAAI,CAACD,cAAc,EAAE;MACjB,OAAOpB,MAAM,CAACsB,IAAI,CAACb,uBAAuB,CAACmB,SAAS,CAACF,KAAK,CAAC,CAAC;IAChE;;IAEA;IACA,MAAM,IAAI,CAACZ,cAAc,CAACe,OAAO,CAAC,IAAIxB,sBAAsB,CAAC;MAAEqB;IAAM,CAAC,CAAC,CAAC;;IAExE;IACA,MAAMI,MAAM,GAAG,MAAM,IAAI,CAACf,UAAU,CAACE,OAAO,CAACS,KAAK,CAAC;IAEnD,IAAII,MAAM,CAACN,MAAM,CAAC,CAAC,EAAE;MACjB;MACA,MAAM,IAAI,CAACV,cAAc,CAACe,OAAO,CAC7B,IAAItB,qBAAqB,CAAC;QACtBmB,KAAK;QACLD,KAAK,EAAEK,MAAM,CAACL;MAClB,CAAC,CACL,CAAC;MACD,OAAOzB,MAAM,CAACsB,IAAI,CAACQ,MAAM,CAACL,KAAK,CAAC;IACpC;;IAEA;IACA,MAAM,IAAI,CAACX,cAAc,CAACe,OAAO,CAAC,IAAIvB,qBAAqB,CAAC;MAAEoB;IAAM,CAAC,CAAC,CAAC;IAEvE,OAAO1B,MAAM,CAAC+B,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAM9B,kBAAkB,GAAGC,kBAAkB,CAAC8B,oBAAoB,CAAC;EACtEC,cAAc,EAAEtB,sBAAsB;EACtCuB,YAAY,EAAE,CAACxB,eAAe,EAAEN,cAAc,EAAED,qBAAqB,EAAEK,aAAa;AACxF,CAAC,CAAC","ignoreList":[]}
+{"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.js

@@ -3,95 +3,62 @@ 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";
-/**
- * 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);
-    }
-
-    // Regular models
-    const canDelete = await this.canDelete(model);
-    if (canDelete.isFail()) {
-      return Result.fail(canDelete.error);
+    constructor(cmsContext, decoratee){
+        this.cmsContext = cmsContext;
+        this.decoratee = decoratee;
     }
-
-    // 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 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);
     }
-
-    // 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 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 {
-      // 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.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);
     }
-    return Result.ok(true);
-  }
 }
-export const DeleteModelWithEntryCleanup = DeleteModelUseCase.createDecorator({
-  decorator: DeleteModelWithEntryCleanupImpl,
-  dependencies: [CmsContext]
+const DeleteModelWithEntryCleanup = DeleteModelUseCase.createDecorator({
+    decorator: DeleteModelWithEntryCleanupImpl,
+    dependencies: [
+        CmsContext
+    ]
 });
+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":"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","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 { 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"}