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

package/features/contentModel/CreateModelFrom/CreateModelFromUseCase.js

@@ -0,0 +1,134 @@
+import { Result } from "@webiny/feature/api";
+import { CreateModelFromUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { CreateModelFromRepository } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { ModelBeforeCreateFromEvent } from "./events.js";
+import { ModelAfterCreateFromEvent } from "./events.js";
+import { ModelCreateFromErrorEvent } from "./events.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ModelNotAuthorizedError, ModelValidationError } from "../../../domain/contentModel/errors.js";
+import { createZodError } from "@webiny/utils";
+import { removeUndefinedValues } from "@webiny/utils";
+import { createModelCreateFromValidation } from "../../../domain/contentModel/schemas.js";
+import { GetModelUseCase } from "../GetModel/index.js";
+
+/**
+ * CreateModelFromUseCase - Clone/copy a model from existing model.
+ *
+ * Responsibilities:
+ * - Validate input (Zod)
+ * - Fetch original model
+ * - Create new model preserving fields and layout
+ * - Handle group changes
+ * - Access control checks
+ * - Publish before event
+ * - Delegate to repository for validation and persistence
+ * - Publish after event or error event
+ *
+ * Note: Repository handles domain validations (modelId generation, uniqueness, etc.)
+ */
+class CreateModelFromUseCaseImpl {
+  constructor(getModelUseCase, eventPublisher, repository, accessControl, tenantContext, identityContext) {
+    this.getModelUseCase = getModelUseCase;
+    this.eventPublisher = eventPublisher;
+    this.repository = repository;
+    this.accessControl = accessControl;
+    this.tenantContext = tenantContext;
+    this.identityContext = identityContext;
+  }
+  async execute(modelId, input) {
+    // Initial access control check
+    const canAccess = await this.accessControl.canAccessModel({
+      rwd: "w"
+    });
+    if (!canAccess) {
+      return Result.fail(new ModelNotAuthorizedError());
+    }
+
+    // Get the original model (with access control check)
+    const getResult = await this.getModelUseCase.execute(modelId);
+    if (getResult.isFail()) {
+      return getResult;
+    }
+    const original = getResult.value;
+
+    // Validate input (merge with original description if not provided)
+    const validationResult = await createModelCreateFromValidation().safeParseAsync({
+      ...input,
+      description: input.description || original.description
+    });
+    if (!validationResult.success) {
+      const zodError = createZodError(validationResult.error);
+      return Result.fail(new ModelValidationError(zodError.message));
+    }
+    const data = removeUndefinedValues(validationResult.data);
+
+    // Create new model from original (preserve fields and layout)
+    const identity = this.identityContext.getIdentity();
+    const tenant = this.tenantContext.getTenant();
+    const model = {
+      ...original,
+      isPlugin: undefined,
+      group: input.group || original.group,
+      singularApiName: data.singularApiName,
+      pluralApiName: data.pluralApiName,
+      icon: data.icon,
+      name: data.name,
+      modelId: data.modelId || "",
+      // Will be set by repository
+      description: data.description || "",
+      createdBy: {
+        id: identity.id,
+        displayName: identity.displayName,
+        type: identity.type
+      },
+      createdOn: new Date().toISOString(),
+      savedOn: new Date().toISOString(),
+      tenant: original.tenant || tenant.id
+    };
+
+    // Access control check on the new model
+    const canAccessModel = await this.accessControl.canAccessModel({
+      model,
+      rwd: "w"
+    });
+    if (!canAccessModel) {
+      return Result.fail(ModelNotAuthorizedError.fromModel(model));
+    }
+
+    // Publish before event
+    await this.eventPublisher.publish(new ModelBeforeCreateFromEvent({
+      model,
+      original,
+      input: data
+    }));
+
+    // Persist via repository (repository will validate and set modelId)
+    const result = await this.repository.execute(model);
+    if (result.isFail()) {
+      // Publish error event
+      await this.eventPublisher.publish(new ModelCreateFromErrorEvent({
+        input: data,
+        model,
+        original,
+        error: result.error
+      }));
+      return Result.fail(result.error);
+    }
+
+    // Publish after event
+    await this.eventPublisher.publish(new ModelAfterCreateFromEvent({
+      model,
+      original
+    }));
+    return Result.ok(model);
+  }
+}
+export const CreateModelFromUseCase = UseCaseAbstraction.createImplementation({
+  implementation: CreateModelFromUseCaseImpl,
+  dependencies: [GetModelUseCase, EventPublisher, CreateModelFromRepository, AccessControl, TenantContext, IdentityContext]
+});
+
+//# sourceMappingURL=CreateModelFromUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","CreateModelFromUseCase","UseCaseAbstraction","CreateModelFromRepository","EventPublisher","ModelBeforeCreateFromEvent","ModelAfterCreateFromEvent","ModelCreateFromErrorEvent","AccessControl","TenantContext","IdentityContext","ModelNotAuthorizedError","ModelValidationError","createZodError","removeUndefinedValues","createModelCreateFromValidation","GetModelUseCase","CreateModelFromUseCaseImpl","constructor","getModelUseCase","eventPublisher","repository","accessControl","tenantContext","identityContext","execute","modelId","input","canAccess","canAccessModel","rwd","fail","getResult","isFail","original","value","validationResult","safeParseAsync","description","success","zodError","error","message","data","identity","getIdentity","tenant","getTenant","model","isPlugin","undefined","group","singularApiName","pluralApiName","icon","name","createdBy","id","displayName","type","createdOn","Date","toISOString","savedOn","fromModel","publish","result","ok","createImplementation","implementation","dependencies"],"sources":["CreateModelFromUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CreateModelFromUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { CreateModelFromRepository } from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { ModelBeforeCreateFromEvent } from \"./events.js\";\nimport { ModelAfterCreateFromEvent } from \"./events.js\";\nimport { ModelCreateFromErrorEvent } from \"./events.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { ModelNotAuthorizedError, ModelValidationError } from \"~/domain/contentModel/errors.js\";\nimport { createZodError } from \"@webiny/utils\";\nimport { removeUndefinedValues } from \"@webiny/utils\";\nimport { createModelCreateFromValidation } from \"~/domain/contentModel/schemas.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport type { CmsModelCreateFromInput } from \"~/types/index.js\";\nimport { GetModelUseCase } from \"~/features/contentModel/GetModel/index.js\";\n\n/**\n * CreateModelFromUseCase - Clone/copy a model from existing model.\n *\n * Responsibilities:\n * - Validate input (Zod)\n * - Fetch original model\n * - Create new model preserving fields and layout\n * - Handle group changes\n * - Access control checks\n * - Publish before event\n * - Delegate to repository for validation and persistence\n * - Publish after event or error event\n *\n * Note: Repository handles domain validations (modelId generation, uniqueness, etc.)\n */\nclass CreateModelFromUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private repository: CreateModelFromRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private tenantContext: TenantContext.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    async execute(\n        modelId: string,\n        input: CmsModelCreateFromInput\n    ): Promise<Result<CmsModel, UseCaseAbstraction.Error>> {\n        // Initial access control check\n        const canAccess = await this.accessControl.canAccessModel({ rwd: \"w\" });\n        if (!canAccess) {\n            return Result.fail(new ModelNotAuthorizedError());\n        }\n\n        // Get the original model (with access control check)\n        const getResult = await this.getModelUseCase.execute(modelId);\n        if (getResult.isFail()) {\n            return getResult;\n        }\n\n        const original = getResult.value;\n\n        // Validate input (merge with original description if not provided)\n        const validationResult = await createModelCreateFromValidation().safeParseAsync({\n            ...input,\n            description: input.description || original.description\n        });\n\n        if (!validationResult.success) {\n            const zodError = createZodError(validationResult.error);\n            return Result.fail(new ModelValidationError(zodError.message));\n        }\n\n        const data = removeUndefinedValues(validationResult.data);\n\n        // Create new model from original (preserve fields and layout)\n        const identity = this.identityContext.getIdentity();\n        const tenant = this.tenantContext.getTenant();\n\n        const model: CmsModel = {\n            ...original,\n            isPlugin: undefined,\n            group: input.group || original.group,\n            singularApiName: data.singularApiName,\n            pluralApiName: data.pluralApiName,\n            icon: data.icon,\n            name: data.name,\n            modelId: data.modelId || \"\", // Will be set by repository\n            description: data.description || \"\",\n            createdBy: {\n                id: identity.id,\n                displayName: identity.displayName,\n                type: identity.type\n            },\n            createdOn: new Date().toISOString(),\n            savedOn: new Date().toISOString(),\n            tenant: original.tenant || tenant.id\n        };\n\n        // Access control check on the new model\n        const canAccessModel = await this.accessControl.canAccessModel({ model, rwd: \"w\" });\n        if (!canAccessModel) {\n            return Result.fail(ModelNotAuthorizedError.fromModel(model));\n        }\n\n        // Publish before event\n        await this.eventPublisher.publish(\n            new ModelBeforeCreateFromEvent({ model, original, input: data })\n        );\n\n        // Persist via repository (repository will validate and set modelId)\n        const result = await this.repository.execute(model);\n        if (result.isFail()) {\n            // Publish error event\n            await this.eventPublisher.publish(\n                new ModelCreateFromErrorEvent({\n                    input: data,\n                    model,\n                    original,\n                    error: result.error\n                })\n            );\n            return Result.fail(result.error);\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(new ModelAfterCreateFromEvent({ model, original }));\n\n        return Result.ok(model);\n    }\n}\n\nexport const CreateModelFromUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateModelFromUseCaseImpl,\n    dependencies: [\n        GetModelUseCase,\n        EventPublisher,\n        CreateModelFromRepository,\n        AccessControl,\n        TenantContext,\n        IdentityContext\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,46 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsModel, CmsModelCreateFromInput } from "../../../types/index.js";
+import { ModelAlreadyExistsError, ModelNotAuthorizedError, type ModelNotFoundError, type ModelPersistenceError, type ModelValidationError } from "../../../domain/contentModel/errors.js";
+import { type GroupNotAuthorizedError, type GroupNotFoundError } from "../../../domain/contentModelGroup/errors.js";
+/**
+ * CreateModelFrom Use Case (Clone/Copy Model)
+ */
+export interface ICreateModelFromUseCase {
+    execute(modelId: string, input: CmsModelCreateFromInput): Promise<Result<CmsModel, UseCaseError>>;
+}
+export interface ICreateModelFromUseCaseErrors {
+    notFound: ModelNotFoundError;
+    notAuthorized: ModelNotAuthorizedError;
+    validation: ModelValidationError;
+    alreadyExists: ModelAlreadyExistsError;
+    persistence: ModelPersistenceError;
+    groupNotFound: GroupNotFoundError;
+    groupNotAccessible: GroupNotAuthorizedError;
+}
+type UseCaseError = ICreateModelFromUseCaseErrors[keyof ICreateModelFromUseCaseErrors];
+/** Create a content model by cloning an existing one. */
+export declare const CreateModelFromUseCase: import("@webiny/di").Abstraction<ICreateModelFromUseCase>;
+export declare namespace CreateModelFromUseCase {
+    type Interface = ICreateModelFromUseCase;
+    type Input = CmsModelCreateFromInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<CmsModel, UseCaseError>>;
+}
+/**
+ * CreateModelFromRepository - Validates domain rules and persists cloned model.
+ */
+export interface ICreateModelFromRepository {
+    execute(model: CmsModel): Promise<Result<void, RepositoryError>>;
+}
+export interface ICreateModelFromRepositoryErrors {
+    alreadyExists: ModelAlreadyExistsError;
+    validation: ModelValidationError;
+    persistence: ModelPersistenceError;
+}
+type RepositoryError = ICreateModelFromRepositoryErrors[keyof ICreateModelFromRepositoryErrors];
+export declare const CreateModelFromRepository: import("@webiny/di").Abstraction<ICreateModelFromRepository>;
+export declare namespace CreateModelFromRepository {
+    type Interface = ICreateModelFromRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentModel/CreateModelFrom/abstractions.js

@@ -0,0 +1,16 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * CreateModelFrom Use Case (Clone/Copy Model)
+ */
+
+/** Create a content model by cloning an existing one. */
+export const CreateModelFromUseCase = createAbstraction("CreateModelFromUseCase");
+
+/**
+ * CreateModelFromRepository - Validates domain rules and persists cloned model.
+ */
+
+export const CreateModelFromRepository = createAbstraction("CreateModelFromRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","CreateModelFromUseCase","CreateModelFromRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsModel, CmsModelCreateFromInput } from \"~/types/index.js\";\nimport {\n    ModelAlreadyExistsError,\n    ModelNotAuthorizedError,\n    type ModelNotFoundError,\n    type ModelPersistenceError,\n    type ModelValidationError\n} from \"~/domain/contentModel/errors.js\";\nimport {\n    type GroupNotAuthorizedError,\n    type GroupNotFoundError\n} from \"~/domain/contentModelGroup/errors.js\";\n\n/**\n * CreateModelFrom Use Case (Clone/Copy Model)\n */\nexport interface ICreateModelFromUseCase {\n    execute(\n        modelId: string,\n        input: CmsModelCreateFromInput\n    ): Promise<Result<CmsModel, UseCaseError>>;\n}\n\nexport interface ICreateModelFromUseCaseErrors {\n    notFound: ModelNotFoundError;\n    notAuthorized: ModelNotAuthorizedError;\n    validation: ModelValidationError;\n    alreadyExists: ModelAlreadyExistsError;\n    persistence: ModelPersistenceError;\n    groupNotFound: GroupNotFoundError;\n    groupNotAccessible: GroupNotAuthorizedError;\n}\n\ntype UseCaseError = ICreateModelFromUseCaseErrors[keyof ICreateModelFromUseCaseErrors];\n\n/** Create a content model by cloning an existing one. */\nexport const CreateModelFromUseCase =\n    createAbstraction<ICreateModelFromUseCase>(\"CreateModelFromUseCase\");\n\nexport namespace CreateModelFromUseCase {\n    export type Interface = ICreateModelFromUseCase;\n    export type Input = CmsModelCreateFromInput;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<CmsModel, UseCaseError>>;\n}\n\n/**\n * CreateModelFromRepository - Validates domain rules and persists cloned model.\n */\nexport interface ICreateModelFromRepository {\n    execute(model: CmsModel): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface ICreateModelFromRepositoryErrors {\n    alreadyExists: ModelAlreadyExistsError;\n    validation: ModelValidationError;\n    persistence: ModelPersistenceError;\n}\n\ntype RepositoryError = ICreateModelFromRepositoryErrors[keyof ICreateModelFromRepositoryErrors];\n\nexport const CreateModelFromRepository = createAbstraction<ICreateModelFromRepository>(\n    \"CreateModelFromRepository\"\n);\n\nexport namespace CreateModelFromRepository {\n    export type Interface = ICreateModelFromRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAc/D;AACA;AACA;;AAoBA;AACA,OAAO,MAAMC,sBAAsB,GAC/BD,iBAAiB,CAA0B,wBAAwB,CAAC;;AAUxE;AACA;AACA;;AAaA,OAAO,MAAME,yBAAyB,GAAGF,iBAAiB,CACtD,2BACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,59 @@
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { CmsModel, CmsModelCreateFromInput } from "../../../types/index.js";
+/**
+ * Event payloads
+ */
+export interface ModelBeforeCreateFromEventPayload {
+    model: CmsModel;
+    original: CmsModel;
+    input: CmsModelCreateFromInput;
+}
+export interface ModelAfterCreateFromEventPayload {
+    model: CmsModel;
+    original: CmsModel;
+}
+export interface ModelCreateFromErrorEventPayload {
+    input: CmsModelCreateFromInput;
+    model: CmsModel;
+    original: CmsModel;
+    error: Error;
+}
+/**
+ * ModelBeforeCreateFromEvent - Published before creating a model from existing
+ */
+export declare class ModelBeforeCreateFromEvent extends DomainEvent<ModelBeforeCreateFromEventPayload> {
+    eventType: "Cms/Model/BeforeCreateFrom";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelBeforeCreateFromEvent>>;
+}
+/** Hook into model lifecycle before a model is cloned. */
+export declare const ModelBeforeCreateFromEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelBeforeCreateFromEvent>>;
+export declare namespace ModelBeforeCreateFromEventHandler {
+    type Interface = IEventHandler<ModelBeforeCreateFromEvent>;
+    type Event = ModelBeforeCreateFromEvent;
+}
+/**
+ * ModelAfterCreateFromEvent - Published after creating a model from existing
+ */
+export declare class ModelAfterCreateFromEvent extends DomainEvent<ModelAfterCreateFromEventPayload> {
+    eventType: "Cms/Model/AfterCreateFrom";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelAfterCreateFromEvent>>;
+}
+/** Hook into model lifecycle after a model is cloned. */
+export declare const ModelAfterCreateFromEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelAfterCreateFromEvent>>;
+export declare namespace ModelAfterCreateFromEventHandler {
+    type Interface = IEventHandler<ModelAfterCreateFromEvent>;
+    type Event = ModelAfterCreateFromEvent;
+}
+/**
+ * ModelCreateFromErrorEvent - Published when create from fails
+ */
+export declare class ModelCreateFromErrorEvent extends DomainEvent<ModelCreateFromErrorEventPayload> {
+    eventType: "Cms/Model/CreateFromError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelCreateFromErrorEvent>>;
+}
+export declare const ModelCreateFromErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelCreateFromErrorEvent>>;
+export declare namespace ModelCreateFromErrorEventHandler {
+    type Interface = IEventHandler<ModelCreateFromErrorEvent>;
+    type Event = ModelCreateFromErrorEvent;
+}

package/features/contentModel/CreateModelFrom/events.js

@@ -0,0 +1,43 @@
+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;
+  }
+}
+
+/** 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;
+  }
+}
+
+/** 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;
+  }
+}
+export const ModelCreateFromErrorEventHandler = createAbstraction("ModelCreateFromErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,10 @@
+/**
+ * CreateModelFrom Feature
+ *
+ * Provides functionality for cloning/copying existing content models.
+ * All validation (modelId generation, domain rules, uniqueness) is handled by the repository.
+ */
+export declare const CreateModelFromFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/contentModel/CreateModelFrom/feature.js

@@ -0,0 +1,22 @@
+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();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,2 @@
+export { CreateModelFromUseCase, CreateModelFromRepository } from "./abstractions.js";
+export { ModelAfterCreateFromEventHandler, ModelBeforeCreateFromEventHandler } from "./events.js";

package/features/contentModel/CreateModelFrom/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["CreateModelFromUseCase","CreateModelFromRepository","ModelAfterCreateFromEventHandler","ModelBeforeCreateFromEventHandler"],"sources":["index.ts"],"sourcesContent":["export { CreateModelFromUseCase, CreateModelFromRepository } from \"./abstractions.js\";\nexport { ModelAfterCreateFromEventHandler, ModelBeforeCreateFromEventHandler } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,sBAAsB,EAAEC,yBAAyB;AAC1D,SAASC,gCAAgC,EAAEC,iCAAiC","ignoreList":[]}

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

@@ -0,0 +1,26 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelCache, ModelsFetcher } from "../../../features/contentModel/shared/abstractions.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.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
+ */
+declare class DeleteModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private modelCache;
+    private modelsFetcher;
+    private storageOperations;
+    constructor(modelCache: ModelCache.Interface, modelsFetcher: ModelsFetcher.Interface, storageOperations: StorageOperations.Interface);
+    execute(model: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const DeleteModelRepository: typeof DeleteModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteModelRepository>;
+};
+export {};

package/features/contentModel/DeleteModel/DeleteModelRepository.js

@@ -0,0 +1,51 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteModelRepository as RepositoryAbstraction } 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));
+    }
+  }
+}
+export const DeleteModelRepository = RepositoryAbstraction.createImplementation({
+  implementation: DeleteModelRepositoryImpl,
+  dependencies: [ModelCache, ModelsFetcher, StorageOperations]
+});
+
+//# sourceMappingURL=DeleteModelRepository.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,30 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteModelUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { DeleteModelRepository } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { GetModelUseCase } from "../../../features/contentModel/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
+ */
+declare class DeleteModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getModelUseCase;
+    private eventPublisher;
+    private repository;
+    private accessControl;
+    constructor(getModelUseCase: GetModelUseCase.Interface, eventPublisher: EventPublisher.Interface, repository: DeleteModelRepository.Interface, accessControl: AccessControl.Interface);
+    execute(modelId: string): Promise<Result<void, UseCaseAbstraction.Error>>;
+}
+export declare const DeleteModelUseCase: typeof DeleteModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteModelUseCase>;
+};
+export {};

package/features/contentModel/DeleteModel/DeleteModelUseCase.js

@@ -0,0 +1,84 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteModelUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { DeleteModelRepository } 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 { 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));
+    }
+
+    // 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);
+    }
+
+    // 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]
+});
+
+//# sourceMappingURL=DeleteModelUseCase.js.map

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

@@ -0,0 +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":[]}