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

package/features/contentModel/CreateModel/CreateModelRepository.js

@@ -0,0 +1,127 @@
+import camelCase from "lodash/camelCase.js";
+import { Result } from "@webiny/feature/api";
+import { CreateModelRepository } from "./abstractions.js";
+import { ModelCache, PluginModelsProvider } from "../shared/abstractions.js";
+import { ListModelsUseCase } from "../ListModels/index.js";
+import { ModelAlreadyExistsError, ModelPersistenceError, ModelValidationError } from "../../../domain/contentModel/errors.js";
+import { CmsContext, StorageOperations } from "../../shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { validateExistingModelId, validateModelIdAllowed } from "../../../crud/contentModel/validate/modelId.js";
+import { validateEndingAllowed } from "../../../crud/contentModel/validate/endingAllowed.js";
+import { ensureTypeTag } from "../../../domain/contentModel/ensureTypeTag.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 { ModelFieldCompression } from "../ModelFieldCompression/index.js";
+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);
+    }
+    if (name) return camelCase(name.trim());
+    throw new ModelValidationError('There is no "modelId" or "name" passed into the create model method.');
+};
+class CreateModelRepositoryImpl {
+    constructor(modelCache, pluginModelsProvider, listModelsUseCase, storageOperations, tenantContext, cmsContext, modelFieldCompression){
+        this.modelCache = modelCache;
+        this.pluginModelsProvider = pluginModelsProvider;
+        this.listModelsUseCase = listModelsUseCase;
+        this.storageOperations = storageOperations;
+        this.tenantContext = tenantContext;
+        this.cmsContext = cmsContext;
+        this.modelFieldCompression = modelFieldCompression;
+    }
+    async execute(model) {
+        try {
+            const tenant = this.tenantContext.getTenant();
+            const modelId = getModelId(model);
+            model.modelId = modelId;
+            try {
+                validateModelIdAllowed({
+                    model
+                });
+            } catch (error) {
+                return Result.fail(new ModelValidationError({
+                    message: error.message,
+                    data: error.data
+                }));
+            }
+            try {
+                validateEndingAllowed({
+                    model
+                });
+            } catch (error) {
+                return Result.fail(new ModelValidationError({
+                    message: error.message,
+                    data: error.data
+                }));
+            }
+            const pluginModels = await this.pluginModelsProvider.list(tenant.id);
+            const pluginModelConflict = pluginModels.find((pm)=>pm.modelId === model.modelId);
+            if (pluginModelConflict) return Result.fail(new ModelAlreadyExistsError({
+                modelId,
+                message: `Model "${modelId}" is already registered via a plugin.`
+            }));
+            const modelsResult = await this.listModelsUseCase.execute();
+            if (modelsResult.isFail()) return Result.fail(new ModelPersistenceError(modelsResult.error));
+            const models = modelsResult.value;
+            try {
+                for (const existingModel of models){
+                    validateExistingModelId({
+                        existingModel,
+                        model
+                    });
+                    validateSingularApiName({
+                        existingModel,
+                        model
+                    });
+                    validatePluralApiName({
+                        existingModel,
+                        model
+                    });
+                }
+                await validateModelFields({
+                    models,
+                    model,
+                    context: this.cmsContext
+                });
+            } catch (error) {
+                return Result.fail(new ModelValidationError({
+                    message: error.message,
+                    data: error.data
+                }));
+            }
+            model.tags = ensureTypeTag(model);
+            const fields = await this.modelFieldCompression.compress(model.fields);
+            await this.storageOperations.models.create({
+                model: {
+                    ...model,
+                    fields
+                }
+            });
+            this.modelCache.clear();
+            return Result.ok();
+        } catch (error) {
+            console.error(error, error.stack);
+            return Result.fail(new ModelPersistenceError(error));
+        }
+    }
+}
+const CreateModelRepository_CreateModelRepository = CreateModelRepository.createImplementation({
+    implementation: CreateModelRepositoryImpl,
+    dependencies: [
+        ModelCache,
+        PluginModelsProvider,
+        ListModelsUseCase,
+        StorageOperations,
+        TenantContext,
+        CmsContext,
+        ModelFieldCompression
+    ]
+});
+export { CreateModelRepository_CreateModelRepository as CreateModelRepository };
+
+//# sourceMappingURL=CreateModelRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/CreateModel/CreateModelRepository.js","sources":["../../../../src/features/contentModel/CreateModel/CreateModelRepository.ts"],"sourcesContent":["import camelCase from \"lodash/camelCase.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { CreateModelRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelCache, PluginModelsProvider } from \"~/features/contentModel/shared/abstractions.js\";\nimport { ListModelsUseCase } from \"~/features/contentModel/ListModels/index.js\";\nimport {\n    ModelAlreadyExistsError,\n    ModelPersistenceError,\n    ModelValidationError\n} from \"~/domain/contentModel/errors.js\";\nimport { CmsContext, StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport {\n    validateExistingModelId,\n    validateModelIdAllowed\n} from \"~/crud/contentModel/validate/modelId.js\";\nimport { validateEndingAllowed } from \"~/crud/contentModel/validate/endingAllowed.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { ensureTypeTag } from \"~/domain/contentModel/ensureTypeTag.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 { ModelFieldCompression } from \"~/features/contentModel/ModelFieldCompression/index.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 method.`\n    );\n};\n\n/**\n * CreateModelRepository - Validates domain rules and persists a new 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 CreateModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private readonly modelCache: ModelCache.Interface,\n        private readonly pluginModelsProvider: PluginModelsProvider.Interface,\n        private readonly listModelsUseCase: ListModelsUseCase.Interface,\n        private readonly storageOperations: StorageOperations.Interface,\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly cmsContext: CmsContext.Interface,\n        private readonly modelFieldCompression: ModelFieldCompression.Interface\n    ) {}\n\n    async execute(model: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            const tenant = this.tenantContext.getTenant();\n\n            // TODO: this will eventually become part of the Model domain object.\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(\n                    new ModelValidationError({\n                        message: error.message,\n                        data: error.data\n                    })\n                );\n            }\n\n            // Validate API name endings\n            try {\n                validateEndingAllowed({ model });\n            } catch (error) {\n                return Result.fail(\n                    new ModelValidationError({\n                        message: error.message,\n                        data: error.data\n                    })\n                );\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 pm.modelId === model.modelId;\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            // Get all models for further validation\n            const modelsResult = await this.listModelsUseCase.execute();\n\n            if (modelsResult.isFail()) {\n                return Result.fail(new ModelPersistenceError(modelsResult.error));\n            }\n\n            const models = modelsResult.value;\n\n            try {\n                /**\n                 * We need to check for the existence of:\n                 * - modelId\n                 * - singularApiName\n                 * - pluralApiName\n                 */\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                await validateModelFields({\n                    models,\n                    model,\n                    context: this.cmsContext\n                });\n            } catch (error) {\n                return Result.fail(\n                    new ModelValidationError({ message: error.message, data: error.data })\n                );\n            }\n\n            // TODO: ideally, this will eventually be handled by the Model domain object\n            model.tags = ensureTypeTag(model);\n\n            const fields = await this.modelFieldCompression.compress(model.fields);\n\n            // Persist to storage\n            await this.storageOperations.models.create({\n                model: {\n                    ...model,\n                    fields\n                }\n            });\n\n            // Clear cache\n            this.modelCache.clear();\n\n            return Result.ok();\n        } catch (error) {\n            console.error(error, error.stack);\n            return Result.fail(new ModelPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const CreateModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateModelRepositoryImpl,\n    dependencies: [\n        ModelCache,\n        PluginModelsProvider,\n        ListModelsUseCase,\n        StorageOperations,\n        TenantContext,\n        CmsContext,\n        ModelFieldCompression\n    ]\n});\n"],"names":["getModelId","model","modelId","name","value","isModelIdValid","camelCase","ModelValidationError","CreateModelRepositoryImpl","modelCache","pluginModelsProvider","listModelsUseCase","storageOperations","tenantContext","cmsContext","modelFieldCompression","tenant","validateModelIdAllowed","error","Result","validateEndingAllowed","pluginModels","pluginModelConflict","pm","ModelAlreadyExistsError","modelsResult","ModelPersistenceError","models","existingModel","validateExistingModelId","validateSingularApiName","validatePluralApiName","validateModelFields","ensureTypeTag","fields","console","CreateModelRepository","RepositoryAbstraction","ModelCache","PluginModelsProvider","ListModelsUseCase","StorageOperations","TenantContext","CmsContext","ModelFieldCompression"],"mappings":"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"}

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

@@ -0,0 +1,40 @@
+import { Result } from "@webiny/feature/api";
+import { CreateModelUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { CreateModelRepository } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AccessControl } from "../../../features/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 type { CmsModel } from "../../../types/index.js";
+import type { CmsModelCreateInput } from "../../../types/index.js";
+/**
+ * CreateModelUseCase - Core model creation orchestration.
+ *
+ * Responsibilities:
+ * - Validate input (Zod)
+ * - Create domain model object
+ * - Assign default fields if requested
+ * - Access control checks
+ * - Publish before event
+ * - Delegate to repository
+ * - Publish after event or error event
+ *
+ * Note: This use case is decorated by CreateModelValidator which handles:
+ * - ModelId generation
+ * - ModelId allowed validation
+ * - API name ending validation
+ * - Field validation and plugin conflict checks
+ */
+declare class CreateModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private eventPublisher;
+    private repository;
+    private accessControl;
+    private tenantContext;
+    private identityContext;
+    constructor(eventPublisher: EventPublisher.Interface, repository: CreateModelRepository.Interface, accessControl: AccessControl.Interface, tenantContext: TenantContext.Interface, identityContext: IdentityContext.Interface);
+    execute(input: CmsModelCreateInput): Promise<Result<CmsModel, UseCaseAbstraction.Error>>;
+}
+export declare const CreateModelUseCase: typeof CreateModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateModelUseCase>;
+};
+export {};

package/features/contentModel/CreateModel/CreateModelUseCase.js

@@ -0,0 +1,89 @@
+import { Result } from "@webiny/feature/api";
+import { CreateModelRepository, CreateModelUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { ModelAfterCreateEvent, ModelBeforeCreateEvent, ModelCreateErrorEvent } 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, removeUndefinedValues } from "@webiny/utils";
+import { createModelCreateValidation } from "../../../domain/contentModel/schemas.js";
+import { assignModelDefaultFields } from "../../../crud/contentModel/defaultFields.js";
+class CreateModelUseCaseImpl {
+    constructor(eventPublisher, repository, accessControl, tenantContext, identityContext){
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+        this.accessControl = accessControl;
+        this.tenantContext = tenantContext;
+        this.identityContext = identityContext;
+    }
+    async execute(input) {
+        const canAccess = await this.accessControl.canAccessModel({
+            rwd: "w"
+        });
+        if (!canAccess) return Result.fail(new ModelNotAuthorizedError());
+        const validationResult = await createModelCreateValidation().safeParseAsync(input);
+        if (!validationResult.success) {
+            const zodError = createZodError(validationResult.error);
+            return Result.fail(new ModelValidationError(zodError.message));
+        }
+        const { defaultFields, ...data } = removeUndefinedValues(validationResult.data);
+        if (defaultFields) assignModelDefaultFields(data);
+        const identity = this.identityContext.getIdentity();
+        const tenant = this.tenantContext.getTenant();
+        const model = {
+            ...data,
+            icon: data.icon ?? null,
+            modelId: data.modelId ?? "",
+            tenant: tenant.id,
+            createdOn: new Date().toISOString(),
+            savedOn: new Date().toISOString(),
+            createdBy: {
+                id: identity.id,
+                displayName: identity.displayName,
+                type: identity.type
+            },
+            description: data.description || "",
+            fields: data.fields || [],
+            layout: data.layout || [],
+            titleFieldId: data.titleFieldId || "",
+            descriptionFieldId: data.descriptionFieldId,
+            imageFieldId: data.imageFieldId
+        };
+        const canAccessModel = await this.accessControl.canAccessModel({
+            model,
+            rwd: "w"
+        });
+        if (!canAccessModel) return Result.fail(ModelNotAuthorizedError.fromModel(model));
+        await this.eventPublisher.publish(new ModelBeforeCreateEvent({
+            model,
+            input: data
+        }));
+        const result = await this.repository.execute(model);
+        if (result.isFail()) {
+            await this.eventPublisher.publish(new ModelCreateErrorEvent({
+                input,
+                model,
+                error: result.error
+            }));
+            return Result.fail(result.error);
+        }
+        await this.eventPublisher.publish(new ModelAfterCreateEvent({
+            model
+        }));
+        return Result.ok(model);
+    }
+}
+const CreateModelUseCase_CreateModelUseCase = CreateModelUseCase.createImplementation({
+    implementation: CreateModelUseCaseImpl,
+    dependencies: [
+        EventPublisher,
+        CreateModelRepository,
+        AccessControl,
+        TenantContext,
+        IdentityContext
+    ]
+});
+export { CreateModelUseCase_CreateModelUseCase as CreateModelUseCase };
+
+//# sourceMappingURL=CreateModelUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/CreateModel/CreateModelUseCase.js","sources":["../../../../src/features/contentModel/CreateModel/CreateModelUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CreateModelUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { CreateModelRepository } from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { ModelBeforeCreateEvent } from \"./events.js\";\nimport { ModelAfterCreateEvent } from \"./events.js\";\nimport { ModelCreateErrorEvent } 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 { createModelCreateValidation } from \"~/domain/contentModel/schemas.js\";\nimport { assignModelDefaultFields } from \"~/crud/contentModel/defaultFields.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport type { CmsModelCreateInput } from \"~/types/index.js\";\n\n/**\n * CreateModelUseCase - Core model creation orchestration.\n *\n * Responsibilities:\n * - Validate input (Zod)\n * - Create domain model object\n * - Assign default fields if requested\n * - Access control checks\n * - Publish before event\n * - Delegate to repository\n * - Publish after event or error event\n *\n * Note: This use case is decorated by CreateModelValidator which handles:\n * - ModelId generation\n * - ModelId allowed validation\n * - API name ending validation\n * - Field validation and plugin conflict checks\n */\nclass CreateModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private eventPublisher: EventPublisher.Interface,\n        private repository: CreateModelRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private tenantContext: TenantContext.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    async execute(input: CmsModelCreateInput): 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        // Validate input\n        const validationResult = await createModelCreateValidation().safeParseAsync(input);\n        if (!validationResult.success) {\n            const zodError = createZodError(validationResult.error);\n            return Result.fail(new ModelValidationError(zodError.message));\n        }\n\n        // Extract defaultFields flag and remove it from data\n        const { defaultFields, ...data } = removeUndefinedValues(validationResult.data);\n\n        // Assign default fields if requested\n        if (defaultFields) {\n            assignModelDefaultFields(data);\n        }\n\n        // Create the domain model object\n        const identity = this.identityContext.getIdentity();\n        const tenant = this.tenantContext.getTenant();\n\n        const model: CmsModel = {\n            ...data,\n            icon: data.icon ?? null,\n            modelId: data.modelId ?? \"\", // Will be set by repository\n            tenant: tenant.id,\n            createdOn: new Date().toISOString(),\n            savedOn: new Date().toISOString(),\n            createdBy: {\n                id: identity.id,\n                displayName: identity.displayName,\n                type: identity.type\n            },\n            description: data.description || \"\",\n            // Fields and layout from data\n            fields: data.fields || [],\n            layout: data.layout || [],\n            // Title/description/image field IDs\n            titleFieldId: data.titleFieldId || \"\",\n            descriptionFieldId: data.descriptionFieldId,\n            imageFieldId: data.imageFieldId\n        };\n\n        // Access control check on the created 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(new ModelBeforeCreateEvent({ model, input: data }));\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 ModelCreateErrorEvent({\n                    input,\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 ModelAfterCreateEvent({ model }));\n\n        return Result.ok(model);\n    }\n}\n\nexport const CreateModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateModelUseCaseImpl,\n    dependencies: [\n        EventPublisher,\n        CreateModelRepository,\n        AccessControl,\n        TenantContext,\n        IdentityContext\n    ]\n});\n"],"names":["CreateModelUseCaseImpl","eventPublisher","repository","accessControl","tenantContext","identityContext","input","canAccess","Result","ModelNotAuthorizedError","validationResult","createModelCreateValidation","zodError","createZodError","ModelValidationError","defaultFields","data","removeUndefinedValues","assignModelDefaultFields","identity","tenant","model","Date","canAccessModel","ModelBeforeCreateEvent","result","ModelCreateErrorEvent","ModelAfterCreateEvent","CreateModelUseCase","UseCaseAbstraction","EventPublisher","CreateModelRepository","AccessControl","TenantContext","IdentityContext"],"mappings":";;;;;;;;;;;AAoCA,MAAMA;IACF,YACYC,cAAwC,EACxCC,UAA2C,EAC3CC,aAAsC,EACtCC,aAAsC,EACtCC,eAA0C,CACpD;aALUJ,cAAc,GAAdA;aACAC,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,aAAa,GAAbA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAM,QAAQC,KAA0B,EAAuD;QAE3F,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAE,KAAK;QAAI;QACrE,IAAI,CAACA,WACD,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAI3B,MAAMC,mBAAmB,MAAMC,8BAA8B,cAAc,CAACL;QAC5E,IAAI,CAACI,iBAAiB,OAAO,EAAE;YAC3B,MAAME,WAAWC,eAAeH,iBAAiB,KAAK;YACtD,OAAOF,OAAO,IAAI,CAAC,IAAIM,qBAAqBF,SAAS,OAAO;QAChE;QAGA,MAAM,EAAEG,aAAa,EAAE,GAAGC,MAAM,GAAGC,sBAAsBP,iBAAiB,IAAI;QAG9E,IAAIK,eACAG,yBAAyBF;QAI7B,MAAMG,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAE3C,MAAMC,QAAkB;YACpB,GAAGL,IAAI;YACP,MAAMA,KAAK,IAAI,IAAI;YACnB,SAASA,KAAK,OAAO,IAAI;YACzB,QAAQI,OAAO,EAAE;YACjB,WAAW,IAAIE,OAAO,WAAW;YACjC,SAAS,IAAIA,OAAO,WAAW;YAC/B,WAAW;gBACP,IAAIH,SAAS,EAAE;gBACf,aAAaA,SAAS,WAAW;gBACjC,MAAMA,SAAS,IAAI;YACvB;YACA,aAAaH,KAAK,WAAW,IAAI;YAEjC,QAAQA,KAAK,MAAM,IAAI,EAAE;YACzB,QAAQA,KAAK,MAAM,IAAI,EAAE;YAEzB,cAAcA,KAAK,YAAY,IAAI;YACnC,oBAAoBA,KAAK,kBAAkB;YAC3C,cAAcA,KAAK,YAAY;QACnC;QAGA,MAAMO,iBAAiB,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAEF;YAAO,KAAK;QAAI;QACjF,IAAI,CAACE,gBACD,OAAOf,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACY;QAIzD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIG,uBAAuB;YAAEH;YAAO,OAAOL;QAAK;QAGlF,MAAMS,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACJ;QAC7C,IAAII,OAAO,MAAM,IAAI;YAEjB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,sBAAsB;gBACtBpB;gBACAe;gBACA,OAAOI,OAAO,KAAK;YACvB;YAEJ,OAAOjB,OAAO,IAAI,CAACiB,OAAO,KAAK;QACnC;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIE,sBAAsB;YAAEN;QAAM;QAEpE,OAAOb,OAAO,EAAE,CAACa;IACrB;AACJ;AAEO,MAAMO,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgB7B;IAChB,cAAc;QACV8B;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,46 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsModel, CmsModelCreateInput } from "../../../types/index.js";
+import { ModelAlreadyExistsError, ModelNotAuthorizedError, type ModelPersistenceError, type ModelSlugTakenError, type ModelValidationError } from "../../../domain/contentModel/errors.js";
+import { type GroupNotAuthorizedError, type GroupNotFoundError } from "../../../domain/contentModelGroup/errors.js";
+/**
+ * CreateModel Use Case
+ */
+export interface ICreateModelUseCase {
+    execute(input: CmsModelCreateInput): Promise<Result<CmsModel, UseCaseError>>;
+}
+export interface ICreateModelUseCaseErrors {
+    notAuthorized: ModelNotAuthorizedError;
+    validation: ModelValidationError;
+    slugTaken: ModelSlugTakenError;
+    alreadyExists: ModelAlreadyExistsError;
+    persistence: ModelPersistenceError;
+    groupNotFound: GroupNotFoundError;
+    groupNotAccessible: GroupNotAuthorizedError;
+}
+type UseCaseError = ICreateModelUseCaseErrors[keyof ICreateModelUseCaseErrors];
+/** Create a new content model. */
+export declare const CreateModelUseCase: import("@webiny/di").Abstraction<ICreateModelUseCase>;
+export declare namespace CreateModelUseCase {
+    type Interface = ICreateModelUseCase;
+    type Input = CmsModelCreateInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<CmsModel, UseCaseError>>;
+}
+/**
+ * CreateModelRepository - Validates domain rules and persists a new model to storage.
+ */
+export interface ICreateModelRepository {
+    execute(model: CmsModel): Promise<Result<void, RepositoryError>>;
+}
+export interface ICreateModelRepositoryErrors {
+    alreadyExists: ModelAlreadyExistsError;
+    validation: ModelValidationError;
+    persistence: ModelPersistenceError;
+}
+type RepositoryError = ICreateModelRepositoryErrors[keyof ICreateModelRepositoryErrors];
+export declare const CreateModelRepository: import("@webiny/di").Abstraction<ICreateModelRepository>;
+export declare namespace CreateModelRepository {
+    type Interface = ICreateModelRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentModel/CreateModel/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/CreateModel/abstractions.js","sources":["../../../../src/features/contentModel/CreateModel/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsModel, CmsModelCreateInput } from \"~/types/index.js\";\nimport {\n    ModelAlreadyExistsError,\n    ModelNotAuthorizedError,\n    type ModelPersistenceError,\n    type ModelSlugTakenError,\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 * CreateModel Use Case\n */\nexport interface ICreateModelUseCase {\n    execute(input: CmsModelCreateInput): Promise<Result<CmsModel, UseCaseError>>;\n}\n\nexport interface ICreateModelUseCaseErrors {\n    notAuthorized: ModelNotAuthorizedError;\n    validation: ModelValidationError;\n    slugTaken: ModelSlugTakenError;\n    alreadyExists: ModelAlreadyExistsError;\n    persistence: ModelPersistenceError;\n    groupNotFound: GroupNotFoundError; // Reused from Group domain\n    groupNotAccessible: GroupNotAuthorizedError; // Reused from Group domain\n}\n\ntype UseCaseError = ICreateModelUseCaseErrors[keyof ICreateModelUseCaseErrors];\n\n/** Create a new content model. */\nexport const CreateModelUseCase = createAbstraction<ICreateModelUseCase>(\"CreateModelUseCase\");\n\nexport namespace CreateModelUseCase {\n    export type Interface = ICreateModelUseCase;\n    export type Input = CmsModelCreateInput;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<CmsModel, UseCaseError>>;\n}\n\n/**\n * CreateModelRepository - Validates domain rules and persists a new model to storage.\n */\nexport interface ICreateModelRepository {\n    execute(model: CmsModel): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface ICreateModelRepositoryErrors {\n    alreadyExists: ModelAlreadyExistsError;\n    validation: ModelValidationError;\n    persistence: ModelPersistenceError;\n}\n\ntype RepositoryError = ICreateModelRepositoryErrors[keyof ICreateModelRepositoryErrors];\n\nexport const CreateModelRepository =\n    createAbstraction<ICreateModelRepository>(\"CreateModelRepository\");\n\nexport namespace CreateModelRepository {\n    export type Interface = ICreateModelRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["CreateModelUseCase","createAbstraction","CreateModelRepository"],"mappings":";AAkCO,MAAMA,qBAAqBC,kBAAuC;AAyBlE,MAAMC,wBACTD,kBAA0C"}

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

@@ -0,0 +1,56 @@
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+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>>;
+}
+/** Hook into model lifecycle before a model is created. */
+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>>;
+}
+/** Hook into model lifecycle after a model is created. */
+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,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class ModelBeforeCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelBeforeCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/BeforeCreate";
+    }
+}
+const ModelBeforeCreateEventHandler = createAbstraction("ModelBeforeCreateEventHandler");
+class ModelAfterCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelAfterCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/AfterCreate";
+    }
+}
+const ModelAfterCreateEventHandler = createAbstraction("ModelAfterCreateEventHandler");
+class ModelCreateErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelCreateErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/CreateError";
+    }
+}
+const ModelCreateErrorEventHandler = createAbstraction("ModelCreateErrorEventHandler");
+export { ModelAfterCreateEvent, ModelAfterCreateEventHandler, ModelBeforeCreateEvent, ModelBeforeCreateEventHandler, ModelCreateErrorEvent, ModelCreateErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/CreateModel/events.js","sources":["../../../../src/features/contentModel/CreateModel/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, 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\n/** Hook into model lifecycle before a model is created. */\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\n/** Hook into model lifecycle after a model is created. */\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"],"names":["ModelBeforeCreateEvent","DomainEvent","ModelBeforeCreateEventHandler","createAbstraction","ModelAfterCreateEvent","ModelAfterCreateEventHandler","ModelCreateErrorEvent","ModelCreateErrorEventHandler"],"mappings":";;AA0BO,MAAMA,+BAA+BC;IAGxC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,gCAAgCC,kBAE3C;AAUK,MAAMC,8BAA8BH;IAGvC,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,+BAA+BF,kBACxC;AAWG,MAAMG,8BAA8BL;IAGvC,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,+BAA+BJ,kBACxC"}

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

@@ -0,0 +1,10 @@
+/**
+ * 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: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/contentModel/CreateModel/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/CreateModel/feature.js","sources":["../../../../src/features/contentModel/CreateModel/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"],"names":["CreateModelFeature","createFeature","container","CreateModelUseCase","CreateModelRepository"],"mappings":";;;AAUO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;IAC9D;AACJ"}

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,2 @@
+export { CreateModelUseCase } from "./abstractions.js";
+export { ModelAfterCreateEventHandler, ModelBeforeCreateEventHandler, ModelCreateErrorEventHandler } from "./events.js";

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

@@ -0,0 +1,36 @@
+import { Result } from "@webiny/feature/api";
+import { CreateModelFromRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelCache, ModelsFetcher, PluginModelsProvider } from "../../../features/contentModel/shared/abstractions.js";
+import { CmsContext, StorageOperations } from "../../../features/shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import type { CmsModel } from "../../../types/index.js";
+import { ModelFieldCompression } from "../../../features/contentModel/ModelFieldCompression/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 readonly modelCache;
+    private readonly pluginModelsProvider;
+    private readonly modelsFetcher;
+    private readonly storageOperations;
+    private readonly tenantContext;
+    private readonly cmsContext;
+    private readonly modelFieldCompression;
+    constructor(modelCache: ModelCache.Interface, pluginModelsProvider: PluginModelsProvider.Interface, modelsFetcher: ModelsFetcher.Interface, storageOperations: StorageOperations.Interface, tenantContext: TenantContext.Interface, cmsContext: CmsContext.Interface, modelFieldCompression: ModelFieldCompression.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 {};