@webiny/api-headless-cms 6.0.0-beta.0 → 6.0.0-rc.1

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

@@ -0,0 +1,54 @@
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import type { CmsModel, CmsModelCreateInput } from "../../../types/index.js";
+/**
+ * Event payloads
+ */
+export interface ModelBeforeCreateEventPayload {
+    model: CmsModel;
+    input: CmsModelCreateInput;
+}
+export interface ModelAfterCreateEventPayload {
+    model: CmsModel;
+}
+export interface ModelCreateErrorEventPayload {
+    input: CmsModelCreateInput;
+    model: CmsModel;
+    error: Error;
+}
+/**
+ * ModelBeforeCreateEvent - Published before creating a model
+ */
+export declare class ModelBeforeCreateEvent extends DomainEvent<ModelBeforeCreateEventPayload> {
+    eventType: "Cms/Model/BeforeCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelBeforeCreateEvent>>;
+}
+export declare const ModelBeforeCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelBeforeCreateEvent>>;
+export declare namespace ModelBeforeCreateEventHandler {
+    type Interface = IEventHandler<ModelBeforeCreateEvent>;
+    type Event = ModelBeforeCreateEvent;
+}
+/**
+ * ModelAfterCreateEvent - Published after creating a model
+ */
+export declare class ModelAfterCreateEvent extends DomainEvent<ModelAfterCreateEventPayload> {
+    eventType: "Cms/Model/AfterCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelAfterCreateEvent>>;
+}
+export declare const ModelAfterCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelAfterCreateEvent>>;
+export declare namespace ModelAfterCreateEventHandler {
+    type Interface = IEventHandler<ModelAfterCreateEvent>;
+    type Event = ModelAfterCreateEvent;
+}
+/**
+ * ModelCreateErrorEvent - Published when create fails
+ */
+export declare class ModelCreateErrorEvent extends DomainEvent<ModelCreateErrorEventPayload> {
+    eventType: "Cms/Model/CreateError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelCreateErrorEvent>>;
+}
+export declare const ModelCreateErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelCreateErrorEvent>>;
+export declare namespace ModelCreateErrorEventHandler {
+    type Interface = IEventHandler<ModelCreateErrorEvent>;
+    type Event = ModelCreateErrorEvent;
+}

package/features/contentModel/CreateModel/events.js

@@ -0,0 +1,39 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+
+/**
+ * Event payloads
+ */
+
+/**
+ * ModelBeforeCreateEvent - Published before creating a model
+ */
+export class ModelBeforeCreateEvent extends DomainEvent {
+  eventType = "Cms/Model/BeforeCreate";
+  getHandlerAbstraction() {
+    return ModelBeforeCreateEventHandler;
+  }
+}
+export const ModelBeforeCreateEventHandler = createAbstraction("ModelBeforeCreateEventHandler");
+/**
+ * ModelAfterCreateEvent - Published after creating a model
+ */
+export class ModelAfterCreateEvent extends DomainEvent {
+  eventType = "Cms/Model/AfterCreate";
+  getHandlerAbstraction() {
+    return ModelAfterCreateEventHandler;
+  }
+}
+export const ModelAfterCreateEventHandler = createAbstraction("ModelAfterCreateEventHandler");
+/**
+ * ModelCreateErrorEvent - Published when create fails
+ */
+export class ModelCreateErrorEvent extends DomainEvent {
+  eventType = "Cms/Model/CreateError";
+  getHandlerAbstraction() {
+    return ModelCreateErrorEventHandler;
+  }
+}
+export const ModelCreateErrorEventHandler = createAbstraction("ModelCreateErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","ModelBeforeCreateEvent","eventType","getHandlerAbstraction","ModelBeforeCreateEventHandler","ModelAfterCreateEvent","ModelAfterCreateEventHandler","ModelCreateErrorEvent","ModelCreateErrorEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type { CmsModel, CmsModelCreateInput } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface ModelBeforeCreateEventPayload {\n    model: CmsModel;\n    input: CmsModelCreateInput;\n}\n\nexport interface ModelAfterCreateEventPayload {\n    model: CmsModel;\n}\n\nexport interface ModelCreateErrorEventPayload {\n    input: CmsModelCreateInput;\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * ModelBeforeCreateEvent - Published before creating a model\n */\nexport class ModelBeforeCreateEvent extends DomainEvent<ModelBeforeCreateEventPayload> {\n    eventType = \"Cms/Model/BeforeCreate\" as const;\n\n    getHandlerAbstraction() {\n        return ModelBeforeCreateEventHandler;\n    }\n}\n\nexport const ModelBeforeCreateEventHandler = createAbstraction<\n    IEventHandler<ModelBeforeCreateEvent>\n>(\"ModelBeforeCreateEventHandler\");\n\nexport namespace ModelBeforeCreateEventHandler {\n    export type Interface = IEventHandler<ModelBeforeCreateEvent>;\n    export type Event = ModelBeforeCreateEvent;\n}\n\n/**\n * ModelAfterCreateEvent - Published after creating a model\n */\nexport class ModelAfterCreateEvent extends DomainEvent<ModelAfterCreateEventPayload> {\n    eventType = \"Cms/Model/AfterCreate\" as const;\n\n    getHandlerAbstraction() {\n        return ModelAfterCreateEventHandler;\n    }\n}\n\nexport const ModelAfterCreateEventHandler = createAbstraction<IEventHandler<ModelAfterCreateEvent>>(\n    \"ModelAfterCreateEventHandler\"\n);\n\nexport namespace ModelAfterCreateEventHandler {\n    export type Interface = IEventHandler<ModelAfterCreateEvent>;\n    export type Event = ModelAfterCreateEvent;\n}\n\n/**\n * ModelCreateErrorEvent - Published when create fails\n */\nexport class ModelCreateErrorEvent extends DomainEvent<ModelCreateErrorEventPayload> {\n    eventType = \"Cms/Model/CreateError\" as const;\n\n    getHandlerAbstraction() {\n        return ModelCreateErrorEventHandler;\n    }\n}\n\nexport const ModelCreateErrorEventHandler = createAbstraction<IEventHandler<ModelCreateErrorEvent>>(\n    \"ModelCreateErrorEventHandler\"\n);\n\nexport namespace ModelCreateErrorEventHandler {\n    export type Interface = IEventHandler<ModelCreateErrorEvent>;\n    export type Event = ModelCreateErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;;AAGtE;AACA;AACA;;AAgBA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,SAASD,WAAW,CAAgC;EACnFE,SAAS,GAAG,wBAAwB;EAEpCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,6BAA6B;EACxC;AACJ;AAEA,OAAO,MAAMA,6BAA6B,GAAGL,iBAAiB,CAE5D,+BAA+B,CAAC;AAOlC;AACA;AACA;AACA,OAAO,MAAMM,qBAAqB,SAASL,WAAW,CAA+B;EACjFE,SAAS,GAAG,uBAAuB;EAEnCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,4BAA4B;EACvC;AACJ;AAEA,OAAO,MAAMA,4BAA4B,GAAGP,iBAAiB,CACzD,8BACJ,CAAC;AAOD;AACA;AACA;AACA,OAAO,MAAMQ,qBAAqB,SAASP,WAAW,CAA+B;EACjFE,SAAS,GAAG,uBAAuB;EAEnCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,4BAA4B;EACvC;AACJ;AAEA,OAAO,MAAMA,4BAA4B,GAAGT,iBAAiB,CACzD,8BACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,7 @@
+/**
+ * CreateModel Feature
+ *
+ * Provides functionality for creating new content models.
+ * All validation (modelId generation, domain rules, uniqueness) is handled by the repository.
+ */
+export declare const CreateModelFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentModel/CreateModel/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CreateModelUseCase","CreateModelRepository","CreateModelFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateModelUseCase } from \"./CreateModelUseCase.js\";\nimport { CreateModelRepository } from \"./CreateModelRepository.js\";\n\n/**\n * CreateModel Feature\n *\n * Provides functionality for creating new content models.\n * All validation (modelId generation, domain rules, uniqueness) is handled by the repository.\n */\nexport const CreateModelFeature = createFeature({\n    name: \"CreateModel\",\n    register(container) {\n        // Register core use case\n        container.register(CreateModelUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(CreateModelRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,kBAAkB;AAC3B,SAASC,qBAAqB;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kBAAkB,GAAGH,aAAa,CAAC;EAC5CI,IAAI,EAAE,aAAa;EACnBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACJ,kBAAkB,CAAC;;IAEtC;IACAK,SAAS,CAACD,QAAQ,CAACH,qBAAqB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAChE;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export { CreateModelUseCase } from "./abstractions.js";
+export { ModelBeforeCreateEventHandler, ModelAfterCreateEventHandler, ModelCreateErrorEventHandler } from "./events.js";

package/features/contentModel/CreateModel/index.js

@@ -0,0 +1,4 @@
+export { CreateModelUseCase } from "./abstractions.js";
+export { ModelBeforeCreateEventHandler, ModelAfterCreateEventHandler, ModelCreateErrorEventHandler } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["CreateModelUseCase","ModelBeforeCreateEventHandler","ModelAfterCreateEventHandler","ModelCreateErrorEventHandler"],"sources":["index.ts"],"sourcesContent":["export { CreateModelUseCase } from \"./abstractions.js\";\nexport {\n    ModelBeforeCreateEventHandler,\n    ModelAfterCreateEventHandler,\n    ModelCreateErrorEventHandler\n} from \"./events.js\";\n"],"mappings":"AAAA,SAASA,kBAAkB;AAC3B,SACIC,6BAA6B,EAC7BC,4BAA4B,EAC5BC,4BAA4B","ignoreList":[]}

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

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import { CreateModelFromRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelCache } from "../../../features/contentModel/shared/abstractions.js";
+import { PluginModelsProvider } from "../../../features/contentModel/shared/abstractions.js";
+import { ModelsFetcher } from "../../../features/contentModel/shared/abstractions.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+import { CmsContext } from "../../../features/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * CreateModelFromRepository - Validates domain rules and persists cloned model.
+ *
+ * Responsibilities:
+ * - Generate modelId from input
+ * - Validate modelId is allowed (not in disallowed list)
+ * - Validate API name endings
+ * - Validate modelId uniqueness (database + plugins)
+ * - Validate API name uniqueness (database + plugins)
+ * - Validate plugin conflicts
+ * - Validate model fields
+ * - Persist to storage
+ * - Clear ModelCache after successful create
+ */
+declare class CreateModelFromRepositoryImpl implements RepositoryAbstraction.Interface {
+    private modelCache;
+    private pluginModelsProvider;
+    private modelsFetcher;
+    private storageOperations;
+    private tenantContext;
+    private cmsContext;
+    constructor(modelCache: ModelCache.Interface, pluginModelsProvider: PluginModelsProvider.Interface, modelsFetcher: ModelsFetcher.Interface, storageOperations: StorageOperations.Interface, tenantContext: TenantContext.Interface, cmsContext: CmsContext.Interface);
+    execute(model: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const CreateModelFromRepository: typeof CreateModelFromRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateModelFromRepository>;
+};
+export {};

package/features/contentModel/CreateModelFrom/CreateModelFromRepository.js

@@ -0,0 +1,162 @@
+import camelCase from "lodash/camelCase.js";
+import { Result } from "@webiny/feature/api";
+import { CreateModelFromRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelCache } from "../shared/abstractions.js";
+import { PluginModelsProvider } from "../shared/abstractions.js";
+import { ModelsFetcher } from "../shared/abstractions.js";
+import { ModelAlreadyExistsError } from "../../../domain/contentModel/errors.js";
+import { ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+import { ModelValidationError } from "../../../domain/contentModel/errors.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+import { CmsContext } from "../../shared/abstractions.js";
+import { validateExistingModelId, validateModelIdAllowed } from "../../../crud/contentModel/validate/modelId.js";
+import { validateEndingAllowed } from "../../../crud/contentModel/validate/endingAllowed.js";
+import { validateSingularApiName } from "../../../domain/contentModel/validation/singularApiName.js";
+import { validatePluralApiName } from "../../../domain/contentModel/validation/pluralApiName.js";
+import { validateModelFields } from "../../../domain/contentModel/validation/modelFields.js";
+import { ensureTypeTag } from "../../../domain/contentModel/ensureTypeTag.js";
+
+/**
+ * Generate modelId from model following the exact logic from beforeCreate.ts
+ */
+const getModelId = model => {
+  const {
+    modelId,
+    name
+  } = model;
+  const value = modelId ? modelId.trim() : null;
+  if (value) {
+    const isModelIdValid = camelCase(value).toLowerCase() === value.toLowerCase();
+    if (isModelIdValid) {
+      return value;
+    }
+    return camelCase(value);
+  } else if (name) {
+    return camelCase(name.trim());
+  }
+  throw new ModelValidationError(`There is no "modelId" or "name" passed into the create model from method.`);
+};
+
+/**
+ * CreateModelFromRepository - Validates domain rules and persists cloned model.
+ *
+ * Responsibilities:
+ * - Generate modelId from input
+ * - Validate modelId is allowed (not in disallowed list)
+ * - Validate API name endings
+ * - Validate modelId uniqueness (database + plugins)
+ * - Validate API name uniqueness (database + plugins)
+ * - Validate plugin conflicts
+ * - Validate model fields
+ * - Persist to storage
+ * - Clear ModelCache after successful create
+ */
+class CreateModelFromRepositoryImpl {
+  constructor(modelCache, pluginModelsProvider, modelsFetcher, storageOperations, tenantContext, cmsContext) {
+    this.modelCache = modelCache;
+    this.pluginModelsProvider = pluginModelsProvider;
+    this.modelsFetcher = modelsFetcher;
+    this.storageOperations = storageOperations;
+    this.tenantContext = tenantContext;
+    this.cmsContext = cmsContext;
+  }
+  async execute(model) {
+    try {
+      const tenant = this.tenantContext.getTenant();
+
+      // Generate modelId using the exact logic from beforeCreate.ts
+      const modelId = getModelId(model);
+      model.modelId = modelId;
+
+      // Validate modelId is allowed (not in disallowed list)
+      try {
+        validateModelIdAllowed({
+          model
+        });
+      } catch (error) {
+        return Result.fail(new ModelValidationError(error.message));
+      }
+
+      // Validate API name endings
+      try {
+        validateEndingAllowed({
+          model
+        });
+      } catch (error) {
+        return Result.fail(new ModelValidationError(error.message));
+      }
+
+      // Validate modelId uniqueness (database)
+      const modelsResult = await this.modelsFetcher.fetchAll();
+      if (modelsResult.isFail()) {
+        return Result.fail(new ModelPersistenceError(modelsResult.error));
+      }
+      const existingModel = modelsResult.value.find(m => m.modelId === modelId);
+      if (existingModel) {
+        return Result.fail(new ModelAlreadyExistsError({
+          modelId
+        }));
+      }
+
+      // Check for plugin model conflicts
+      const pluginModels = await this.pluginModelsProvider.list(tenant.id);
+      const pluginModelConflict = pluginModels.find(pm => {
+        return pm.modelId === model.modelId || pm.singularApiName === model.singularApiName || pm.pluralApiName === model.pluralApiName;
+      });
+      if (pluginModelConflict) {
+        return Result.fail(new ModelAlreadyExistsError({
+          modelId,
+          message: `Model "${modelId}" is already registered via a plugin.`
+        }));
+      }
+      const models = modelsResult.value;
+      try {
+        // Validate uniqueness
+        for (const existingModel of models) {
+          validateExistingModelId({
+            existingModel,
+            model
+          });
+          validateSingularApiName({
+            existingModel,
+            model
+          });
+          validatePluralApiName({
+            existingModel,
+            model
+          });
+        }
+
+        // Validate model fields
+        await validateModelFields({
+          models,
+          model,
+          context: this.cmsContext
+        });
+      } catch (error) {
+        return Result.fail(new ModelValidationError(error.message));
+      }
+
+      // Ensure type tags
+      model.tags = ensureTypeTag(model);
+
+      // Persist to storage
+      await this.storageOperations.models.create({
+        model
+      });
+
+      // Clear cache
+      this.modelCache.clear();
+      return Result.ok();
+    } catch (error) {
+      return Result.fail(new ModelPersistenceError(error));
+    }
+  }
+}
+export const CreateModelFromRepository = RepositoryAbstraction.createImplementation({
+  implementation: CreateModelFromRepositoryImpl,
+  dependencies: [ModelCache, PluginModelsProvider, ModelsFetcher, StorageOperations, TenantContext, CmsContext]
+});
+
+//# sourceMappingURL=CreateModelFromRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["camelCase","Result","CreateModelFromRepository","RepositoryAbstraction","ModelCache","PluginModelsProvider","ModelsFetcher","ModelAlreadyExistsError","ModelPersistenceError","ModelValidationError","StorageOperations","TenantContext","CmsContext","validateExistingModelId","validateModelIdAllowed","validateEndingAllowed","validateSingularApiName","validatePluralApiName","validateModelFields","ensureTypeTag","getModelId","model","modelId","name","value","trim","isModelIdValid","toLowerCase","CreateModelFromRepositoryImpl","constructor","modelCache","pluginModelsProvider","modelsFetcher","storageOperations","tenantContext","cmsContext","execute","tenant","getTenant","error","fail","message","modelsResult","fetchAll","isFail","existingModel","find","m","pluginModels","list","id","pluginModelConflict","pm","singularApiName","pluralApiName","models","context","tags","create","clear","ok","createImplementation","implementation","dependencies"],"sources":["CreateModelFromRepository.ts"],"sourcesContent":["import camelCase from \"lodash/camelCase.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { CreateModelFromRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelCache } from \"~/features/contentModel/shared/abstractions.js\";\nimport { PluginModelsProvider } from \"~/features/contentModel/shared/abstractions.js\";\nimport { ModelsFetcher } from \"~/features/contentModel/shared/abstractions.js\";\nimport { ModelAlreadyExistsError } from \"~/domain/contentModel/errors.js\";\nimport { ModelPersistenceError } from \"~/domain/contentModel/errors.js\";\nimport { ModelValidationError } from \"~/domain/contentModel/errors.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/TenantContext\";\nimport { CmsContext } from \"~/features/shared/abstractions.js\";\nimport {\n    validateExistingModelId,\n    validateModelIdAllowed\n} from \"~/crud/contentModel/validate/modelId.js\";\nimport { validateEndingAllowed } from \"~/crud/contentModel/validate/endingAllowed.js\";\nimport { validateSingularApiName } from \"~/domain/contentModel/validation/singularApiName.js\";\nimport { validatePluralApiName } from \"~/domain/contentModel/validation/pluralApiName.js\";\nimport { validateModelFields } from \"~/domain/contentModel/validation/modelFields.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { ensureTypeTag } from \"~/domain/contentModel/ensureTypeTag.js\";\n\n/**\n * Generate modelId from model following the exact logic from beforeCreate.ts\n */\nconst getModelId = (model: { modelId?: string; name?: string }): string => {\n    const { modelId, name } = model;\n    const value = modelId ? modelId.trim() : null;\n    if (value) {\n        const isModelIdValid = camelCase(value).toLowerCase() === value.toLowerCase();\n        if (isModelIdValid) {\n            return value;\n        }\n        return camelCase(value);\n    } else if (name) {\n        return camelCase(name.trim());\n    }\n    throw new ModelValidationError(\n        `There is no \"modelId\" or \"name\" passed into the create model from method.`\n    );\n};\n\n/**\n * CreateModelFromRepository - Validates domain rules and persists cloned model.\n *\n * Responsibilities:\n * - Generate modelId from input\n * - Validate modelId is allowed (not in disallowed list)\n * - Validate API name endings\n * - Validate modelId uniqueness (database + plugins)\n * - Validate API name uniqueness (database + plugins)\n * - Validate plugin conflicts\n * - Validate model fields\n * - Persist to storage\n * - Clear ModelCache after successful create\n */\nclass CreateModelFromRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private modelCache: ModelCache.Interface,\n        private pluginModelsProvider: PluginModelsProvider.Interface,\n        private modelsFetcher: ModelsFetcher.Interface,\n        private storageOperations: StorageOperations.Interface,\n        private tenantContext: TenantContext.Interface,\n        private cmsContext: CmsContext.Interface\n    ) {}\n\n    async execute(model: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            const tenant = this.tenantContext.getTenant();\n\n            // Generate modelId using the exact logic from beforeCreate.ts\n            const modelId = getModelId(model);\n            model.modelId = modelId;\n\n            // Validate modelId is allowed (not in disallowed list)\n            try {\n                validateModelIdAllowed({ model });\n            } catch (error) {\n                return Result.fail(new ModelValidationError((error as Error).message));\n            }\n\n            // Validate API name endings\n            try {\n                validateEndingAllowed({ model });\n            } catch (error) {\n                return Result.fail(new ModelValidationError((error as Error).message));\n            }\n\n            // Validate modelId uniqueness (database)\n            const modelsResult = await this.modelsFetcher.fetchAll();\n            if (modelsResult.isFail()) {\n                return Result.fail(new ModelPersistenceError(modelsResult.error));\n            }\n\n            const existingModel = modelsResult.value.find(m => m.modelId === modelId);\n            if (existingModel) {\n                return Result.fail(new ModelAlreadyExistsError({ modelId }));\n            }\n\n            // Check for plugin model conflicts\n            const pluginModels = await this.pluginModelsProvider.list(tenant.id);\n            const pluginModelConflict = pluginModels.find(pm => {\n                return (\n                    pm.modelId === model.modelId ||\n                    pm.singularApiName === model.singularApiName ||\n                    pm.pluralApiName === model.pluralApiName\n                );\n            });\n\n            if (pluginModelConflict) {\n                return Result.fail(\n                    new ModelAlreadyExistsError({\n                        modelId,\n                        message: `Model \"${modelId}\" is already registered via a plugin.`\n                    })\n                );\n            }\n\n            const models = modelsResult.value;\n\n            try {\n                // Validate uniqueness\n                for (const existingModel of models) {\n                    validateExistingModelId({\n                        existingModel,\n                        model\n                    });\n                    validateSingularApiName({\n                        existingModel,\n                        model\n                    });\n                    validatePluralApiName({\n                        existingModel,\n                        model\n                    });\n                }\n\n                // Validate model fields\n                await validateModelFields({\n                    models,\n                    model,\n                    context: this.cmsContext\n                });\n            } catch (error) {\n                return Result.fail(new ModelValidationError((error as Error).message));\n            }\n\n            // Ensure type tags\n            model.tags = ensureTypeTag(model);\n\n            // Persist to storage\n            await this.storageOperations.models.create({ 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 CreateModelFromRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateModelFromRepositoryImpl,\n    dependencies: [\n        ModelCache,\n        PluginModelsProvider,\n        ModelsFetcher,\n        StorageOperations,\n        TenantContext,\n        CmsContext\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,39 @@
+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";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import type { CmsModel } from "../../../types/index.js";
+import type { CmsModelCreateFromInput } from "../../../types/index.js";
+import { GetModelUseCase } from "../../../features/contentModel/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.)
+ */
+declare class CreateModelFromUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getModelUseCase;
+    private eventPublisher;
+    private repository;
+    private accessControl;
+    private tenantContext;
+    private identityContext;
+    constructor(getModelUseCase: GetModelUseCase.Interface, eventPublisher: EventPublisher.Interface, repository: CreateModelFromRepository.Interface, accessControl: AccessControl.Interface, tenantContext: TenantContext.Interface, identityContext: IdentityContext.Interface);
+    execute(modelId: string, input: CmsModelCreateFromInput): Promise<Result<CmsModel, UseCaseAbstraction.Error>>;
+}
+export declare const CreateModelFromUseCase: typeof CreateModelFromUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateModelFromUseCase>;
+};
+export {};

package/features/contentModel/CreateModelFrom/CreateModelFromUseCase.js

@@ -0,0 +1,133 @@
+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";
+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/TenantContext";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+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,
+      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","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\";\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/TenantContext\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\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            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,45 @@
+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];
+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,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * CreateModelFrom Use Case (Clone/Copy Model)
+ */
+
+export const CreateModelFromUseCase = createAbstraction("CreateModelFromUseCase");
+
+/**
+ * CreateModelFromRepository - Validates domain rules and persists cloned model.
+ */
+
+export const CreateModelFromRepository = createAbstraction("CreateModelFromRepository");
+
+//# sourceMappingURL=abstractions.js.map