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

package/features/contentModel/UpdateModel/UpdateModelUseCase.js

@@ -0,0 +1,90 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateModelRepository, UpdateModelUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { ModelAfterUpdateEvent, ModelBeforeUpdateEvent, ModelUpdateErrorEvent } from "./events.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { ModelNotAuthorizedError, ModelValidationError } from "../../../domain/contentModel/errors.js";
+import { createZodError, removeUndefinedValues } from "@webiny/utils";
+import { createModelUpdateValidation } from "../../../domain/contentModel/schemas.js";
+import { ensureTypeTag } from "../../../domain/contentModel/ensureTypeTag.js";
+import { GetModelUseCase } from "../GetModel/index.js";
+class UpdateModelUseCaseImpl {
+    constructor(getModelUseCase, eventPublisher, repository, accessControl, tenantContext){
+        this.getModelUseCase = getModelUseCase;
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+        this.accessControl = accessControl;
+        this.tenantContext = tenantContext;
+    }
+    async execute(modelId, input) {
+        const canAccess = await this.accessControl.canAccessModel({
+            rwd: "w"
+        });
+        if (!canAccess) return Result.fail(new ModelNotAuthorizedError());
+        const getResult = await this.getModelUseCase.execute(modelId);
+        if (getResult.isFail()) return getResult;
+        const original = structuredClone(getResult.value);
+        const validationResult = await createModelUpdateValidation().safeParseAsync(input);
+        if (!validationResult.success) {
+            const zodError = createZodError(validationResult.error);
+            return Result.fail(new ModelValidationError({
+                message: zodError.message,
+                data: zodError.data
+            }));
+        }
+        const data = removeUndefinedValues(validationResult.data);
+        if (0 === Object.keys(data).length) return Result.ok(original);
+        const tenant = this.tenantContext.getTenant();
+        const model = {
+            ...original,
+            ...data,
+            icon: data.icon ?? original.icon,
+            titleFieldId: void 0 === data.titleFieldId ? original.titleFieldId : data.titleFieldId,
+            descriptionFieldId: void 0 === data.descriptionFieldId ? original.descriptionFieldId : data.descriptionFieldId,
+            imageFieldId: void 0 === data.imageFieldId ? original.imageFieldId : data.imageFieldId,
+            description: data.description || original.description,
+            tenant: original.tenant || tenant.id,
+            savedOn: new Date().toISOString()
+        };
+        const canAccessModel = await this.accessControl.canAccessModel({
+            model,
+            rwd: "w"
+        });
+        if (!canAccessModel) return Result.fail(ModelNotAuthorizedError.fromModel(model));
+        model.tags = ensureTypeTag(model);
+        await this.eventPublisher.publish(new ModelBeforeUpdateEvent({
+            model,
+            original,
+            input: data
+        }));
+        const result = await this.repository.execute(model, original);
+        if (result.isFail()) {
+            await this.eventPublisher.publish(new ModelUpdateErrorEvent({
+                input: data,
+                model,
+                original,
+                error: result.error
+            }));
+            return Result.fail(result.error);
+        }
+        await this.eventPublisher.publish(new ModelAfterUpdateEvent({
+            model,
+            original
+        }));
+        return Result.ok(model);
+    }
+}
+const UpdateModelUseCase_UpdateModelUseCase = UpdateModelUseCase.createImplementation({
+    implementation: UpdateModelUseCaseImpl,
+    dependencies: [
+        GetModelUseCase,
+        EventPublisher,
+        UpdateModelRepository,
+        AccessControl,
+        TenantContext
+    ]
+});
+export { UpdateModelUseCase_UpdateModelUseCase as UpdateModelUseCase };
+
+//# sourceMappingURL=UpdateModelUseCase.js.map

package/features/contentModel/UpdateModel/UpdateModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/UpdateModel/UpdateModelUseCase.js","sources":["../../../../src/features/contentModel/UpdateModel/UpdateModelUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { UpdateModelUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { UpdateModelRepository } from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { ModelBeforeUpdateEvent } from \"./events.js\";\nimport { ModelAfterUpdateEvent } from \"./events.js\";\nimport { ModelUpdateErrorEvent } from \"./events.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { ModelNotAuthorizedError, ModelValidationError } from \"~/domain/contentModel/errors.js\";\nimport { createZodError } from \"@webiny/utils\";\nimport { removeUndefinedValues } from \"@webiny/utils\";\nimport { createModelUpdateValidation } from \"~/domain/contentModel/schemas.js\";\nimport { ensureTypeTag } from \"~/domain/contentModel/ensureTypeTag.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport type { CmsModelUpdateInput } from \"~/types/index.js\";\nimport { GetModelUseCase } from \"~/features/contentModel/GetModel/index.js\";\n\n/**\n * UpdateModelUseCase - Core model update orchestration.\n *\n * Responsibilities:\n * - Validate input (Zod)\n * - Fetch original model\n * - Create updated domain model object\n * - Handle group changes\n * - Handle field ID changes (title, description, image)\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 (API name uniqueness, field validation, etc.)\n */\nclass UpdateModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private repository: UpdateModelRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private tenantContext: TenantContext.Interface\n    ) {}\n\n    async execute(\n        modelId: string,\n        input: CmsModelUpdateInput\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 = structuredClone(getResult.value);\n\n        // Validate input\n        const validationResult = await createModelUpdateValidation().safeParseAsync(input);\n        if (!validationResult.success) {\n            const zodError = createZodError(validationResult.error);\n            return Result.fail(\n                new ModelValidationError({\n                    message: zodError.message,\n                    data: zodError.data\n                })\n            );\n        }\n\n        const data = removeUndefinedValues(validationResult.data);\n\n        // If no changes, return original\n        if (Object.keys(data).length === 0) {\n            return Result.ok(original);\n        }\n\n        // Create updated model\n        const tenant = this.tenantContext.getTenant();\n\n        const model: CmsModel = {\n            ...original,\n            ...data,\n            icon: data.icon ?? original.icon,\n            // Handle optional field IDs explicitly\n            titleFieldId:\n                data.titleFieldId === undefined\n                    ? original.titleFieldId\n                    : (data.titleFieldId as string),\n            descriptionFieldId:\n                data.descriptionFieldId === undefined\n                    ? original.descriptionFieldId\n                    : data.descriptionFieldId,\n            imageFieldId:\n                data.imageFieldId === undefined ? original.imageFieldId : data.imageFieldId,\n            description: data.description || original.description,\n            tenant: original.tenant || tenant.id,\n            savedOn: new Date().toISOString()\n        };\n\n        // Access control check on the updated model\n        const canAccessModel = await this.accessControl.canAccessModel({ model, rwd: \"w\" });\n        if (!canAccessModel) {\n            return Result.fail(ModelNotAuthorizedError.fromModel(model));\n        }\n\n        // Ensure type tags\n        model.tags = ensureTypeTag(model);\n\n        // Publish before event\n        await this.eventPublisher.publish(\n            new ModelBeforeUpdateEvent({ model, original, input: data })\n        );\n\n        // Persist via repository (repository will validate)\n        const result = await this.repository.execute(model, original);\n        if (result.isFail()) {\n            // Publish error event\n            await this.eventPublisher.publish(\n                new ModelUpdateErrorEvent({\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 ModelAfterUpdateEvent({ model, original }));\n\n        return Result.ok(model);\n    }\n}\n\nexport const UpdateModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UpdateModelUseCaseImpl,\n    dependencies: [\n        GetModelUseCase,\n        EventPublisher,\n        UpdateModelRepository,\n        AccessControl,\n        TenantContext\n    ]\n});\n"],"names":["UpdateModelUseCaseImpl","getModelUseCase","eventPublisher","repository","accessControl","tenantContext","modelId","input","canAccess","Result","ModelNotAuthorizedError","getResult","original","structuredClone","validationResult","createModelUpdateValidation","zodError","createZodError","ModelValidationError","data","removeUndefinedValues","Object","tenant","model","undefined","Date","canAccessModel","ensureTypeTag","ModelBeforeUpdateEvent","result","ModelUpdateErrorEvent","ModelAfterUpdateEvent","UpdateModelUseCase","UseCaseAbstraction","GetModelUseCase","EventPublisher","UpdateModelRepository","AccessControl","TenantContext"],"mappings":";;;;;;;;;;;AAkCA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,cAAwC,EACxCC,UAA2C,EAC3CC,aAAsC,EACtCC,aAAsC,CAChD;aALUJ,eAAe,GAAfA;aACAC,cAAc,GAAdA;aACAC,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QACFC,OAAe,EACfC,KAA0B,EACyB;QAEnD,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAE,KAAK;QAAI;QACrE,IAAI,CAACA,WACD,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAI3B,MAAMC,YAAY,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACL;QACrD,IAAIK,UAAU,MAAM,IAChB,OAAOA;QAGX,MAAMC,WAAWC,gBAAgBF,UAAU,KAAK;QAGhD,MAAMG,mBAAmB,MAAMC,8BAA8B,cAAc,CAACR;QAC5E,IAAI,CAACO,iBAAiB,OAAO,EAAE;YAC3B,MAAME,WAAWC,eAAeH,iBAAiB,KAAK;YACtD,OAAOL,OAAO,IAAI,CACd,IAAIS,qBAAqB;gBACrB,SAASF,SAAS,OAAO;gBACzB,MAAMA,SAAS,IAAI;YACvB;QAER;QAEA,MAAMG,OAAOC,sBAAsBN,iBAAiB,IAAI;QAGxD,IAAIO,AAA6B,MAA7BA,OAAO,IAAI,CAACF,MAAM,MAAM,EACxB,OAAOV,OAAO,EAAE,CAACG;QAIrB,MAAMU,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAE3C,MAAMC,QAAkB;YACpB,GAAGX,QAAQ;YACX,GAAGO,IAAI;YACP,MAAMA,KAAK,IAAI,IAAIP,SAAS,IAAI;YAEhC,cACIO,AAAsBK,WAAtBL,KAAK,YAAY,GACXP,SAAS,YAAY,GACpBO,KAAK,YAAY;YAC5B,oBACIA,AAA4BK,WAA5BL,KAAK,kBAAkB,GACjBP,SAAS,kBAAkB,GAC3BO,KAAK,kBAAkB;YACjC,cACIA,AAAsBK,WAAtBL,KAAK,YAAY,GAAiBP,SAAS,YAAY,GAAGO,KAAK,YAAY;YAC/E,aAAaA,KAAK,WAAW,IAAIP,SAAS,WAAW;YACrD,QAAQA,SAAS,MAAM,IAAIU,OAAO,EAAE;YACpC,SAAS,IAAIG,OAAO,WAAW;QACnC;QAGA,MAAMC,iBAAiB,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAEH;YAAO,KAAK;QAAI;QACjF,IAAI,CAACG,gBACD,OAAOjB,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACa;QAIzDA,MAAM,IAAI,GAAGI,cAAcJ;QAG3B,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIK,uBAAuB;YAAEL;YAAOX;YAAU,OAAOO;QAAK;QAI9D,MAAMU,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACN,OAAOX;QACpD,IAAIiB,OAAO,MAAM,IAAI;YAEjB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,sBAAsB;gBACtB,OAAOX;gBACPI;gBACAX;gBACA,OAAOiB,OAAO,KAAK;YACvB;YAEJ,OAAOpB,OAAO,IAAI,CAACoB,OAAO,KAAK;QACnC;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIE,sBAAsB;YAAER;YAAOX;QAAS;QAE9E,OAAOH,OAAO,EAAE,CAACc;IACrB;AACJ;AAEO,MAAMS,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBjC;IAChB,cAAc;QACVkC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,49 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsModel } from "../../../types/index.js";
+import type { CmsModelUpdateInput } from "../../../types/index.js";
+import { type ModelSlugTakenError, ModelNotAuthorizedError, type ModelNotFoundError, type ModelValidationError, type ModelPersistenceError, ModelCannotUpdateCodeModelError } from "../../../domain/contentModel/errors.js";
+import { type GroupNotFoundError, type GroupNotAuthorizedError } from "../../../domain/contentModelGroup/errors.js";
+/**
+ * UpdateModel Use Case
+ */
+export interface IUpdateModelUseCase {
+    execute(modelId: string, input: CmsModelUpdateInput): Promise<Result<CmsModel, UseCaseError>>;
+}
+export interface IUpdateModelUseCaseErrors {
+    notFound: ModelNotFoundError;
+    notAuthorized: ModelNotAuthorizedError;
+    validation: ModelValidationError;
+    alreadyExists: ModelSlugTakenError;
+    persistence: ModelPersistenceError;
+    updateCodeModel: ModelCannotUpdateCodeModelError;
+    groupNotFound: GroupNotFoundError;
+    groupNotAccessible: GroupNotAuthorizedError;
+}
+type UseCaseError = IUpdateModelUseCaseErrors[keyof IUpdateModelUseCaseErrors];
+/** Update a content model. */
+export declare const UpdateModelUseCase: import("@webiny/di").Abstraction<IUpdateModelUseCase>;
+export declare namespace UpdateModelUseCase {
+    type Interface = IUpdateModelUseCase;
+    type Input = CmsModelUpdateInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<CmsModel, UseCaseError>>;
+}
+/**
+ * UpdateModelRepository - Validates domain rules and persists model updates.
+ */
+export interface IUpdateModelRepository {
+    execute(model: CmsModel, original: CmsModel): Promise<Result<void, RepositoryError>>;
+}
+export interface IUpdateModelRepositoryErrors {
+    alreadyExists: ModelSlugTakenError;
+    validation: ModelValidationError;
+    persistence: ModelPersistenceError;
+    updateCodeModel: ModelCannotUpdateCodeModelError;
+}
+type RepositoryError = IUpdateModelRepositoryErrors[keyof IUpdateModelRepositoryErrors];
+export declare const UpdateModelRepository: import("@webiny/di").Abstraction<IUpdateModelRepository>;
+export declare namespace UpdateModelRepository {
+    type Interface = IUpdateModelRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentModel/UpdateModel/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/UpdateModel/abstractions.js","sources":["../../../../src/features/contentModel/UpdateModel/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport type { CmsModelUpdateInput } from \"~/types/index.js\";\nimport {\n    type ModelSlugTakenError,\n    ModelNotAuthorizedError,\n    type ModelNotFoundError,\n    type ModelValidationError,\n    type ModelPersistenceError,\n    ModelCannotUpdateCodeModelError\n} from \"~/domain/contentModel/errors.js\";\nimport {\n    type GroupNotFoundError,\n    type GroupNotAuthorizedError\n} from \"~/domain/contentModelGroup/errors.js\";\n\n/**\n * UpdateModel Use Case\n */\nexport interface IUpdateModelUseCase {\n    execute(modelId: string, input: CmsModelUpdateInput): Promise<Result<CmsModel, UseCaseError>>;\n}\n\nexport interface IUpdateModelUseCaseErrors {\n    notFound: ModelNotFoundError;\n    notAuthorized: ModelNotAuthorizedError;\n    validation: ModelValidationError;\n    alreadyExists: ModelSlugTakenError;\n    persistence: ModelPersistenceError;\n    updateCodeModel: ModelCannotUpdateCodeModelError;\n    groupNotFound: GroupNotFoundError;\n    groupNotAccessible: GroupNotAuthorizedError;\n}\n\ntype UseCaseError = IUpdateModelUseCaseErrors[keyof IUpdateModelUseCaseErrors];\n\n/** Update a content model. */\nexport const UpdateModelUseCase = createAbstraction<IUpdateModelUseCase>(\"UpdateModelUseCase\");\n\nexport namespace UpdateModelUseCase {\n    export type Interface = IUpdateModelUseCase;\n    export type Input = CmsModelUpdateInput;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<CmsModel, UseCaseError>>;\n}\n\n/**\n * UpdateModelRepository - Validates domain rules and persists model updates.\n */\nexport interface IUpdateModelRepository {\n    execute(model: CmsModel, original: CmsModel): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IUpdateModelRepositoryErrors {\n    alreadyExists: ModelSlugTakenError;\n    validation: ModelValidationError;\n    persistence: ModelPersistenceError;\n    updateCodeModel: ModelCannotUpdateCodeModelError;\n}\n\ntype RepositoryError = IUpdateModelRepositoryErrors[keyof IUpdateModelRepositoryErrors];\n\nexport const UpdateModelRepository =\n    createAbstraction<IUpdateModelRepository>(\"UpdateModelRepository\");\n\nexport namespace UpdateModelRepository {\n    export type Interface = IUpdateModelRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["UpdateModelUseCase","createAbstraction","UpdateModelRepository"],"mappings":";AAsCO,MAAMA,qBAAqBC,kBAAuC;AA0BlE,MAAMC,wBACTD,kBAA0C"}

package/features/contentModel/UpdateModel/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, CmsModelUpdateInput } from "../../../types/index.js";
+/**
+ * Event payloads
+ */
+export interface ModelBeforeUpdateEventPayload {
+    model: CmsModel;
+    original: CmsModel;
+    input: CmsModelUpdateInput;
+}
+export interface ModelAfterUpdateEventPayload {
+    model: CmsModel;
+    original: CmsModel;
+}
+export interface ModelUpdateErrorEventPayload {
+    input: CmsModelUpdateInput;
+    model: CmsModel;
+    original: CmsModel;
+    error: Error;
+}
+/**
+ * ModelBeforeUpdateEvent - Published before updating a model
+ */
+export declare class ModelBeforeUpdateEvent extends DomainEvent<ModelBeforeUpdateEventPayload> {
+    eventType: "Cms/Model/BeforeUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelBeforeUpdateEvent>>;
+}
+/** Hook into model lifecycle before a model is updated. */
+export declare const ModelBeforeUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelBeforeUpdateEvent>>;
+export declare namespace ModelBeforeUpdateEventHandler {
+    type Interface = IEventHandler<ModelBeforeUpdateEvent>;
+    type Event = ModelBeforeUpdateEvent;
+}
+/**
+ * ModelAfterUpdateEvent - Published after updating a model
+ */
+export declare class ModelAfterUpdateEvent extends DomainEvent<ModelAfterUpdateEventPayload> {
+    eventType: "Cms/Model/AfterUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelAfterUpdateEvent>>;
+}
+/** Hook into model lifecycle after a model is updated. */
+export declare const ModelAfterUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelAfterUpdateEvent>>;
+export declare namespace ModelAfterUpdateEventHandler {
+    type Interface = IEventHandler<ModelAfterUpdateEvent>;
+    type Event = ModelAfterUpdateEvent;
+}
+/**
+ * ModelUpdateErrorEvent - Published when update fails
+ */
+export declare class ModelUpdateErrorEvent extends DomainEvent<ModelUpdateErrorEventPayload> {
+    eventType: "Cms/Model/UpdateError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelUpdateErrorEvent>>;
+}
+export declare const ModelUpdateErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelUpdateErrorEvent>>;
+export declare namespace ModelUpdateErrorEventHandler {
+    type Interface = IEventHandler<ModelUpdateErrorEvent>;
+    type Event = ModelUpdateErrorEvent;
+}

package/features/contentModel/UpdateModel/events.js

@@ -0,0 +1,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class ModelBeforeUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelBeforeUpdateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/BeforeUpdate";
+    }
+}
+const ModelBeforeUpdateEventHandler = createAbstraction("ModelBeforeUpdateEventHandler");
+class ModelAfterUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelAfterUpdateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/AfterUpdate";
+    }
+}
+const ModelAfterUpdateEventHandler = createAbstraction("ModelAfterUpdateEventHandler");
+class ModelUpdateErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ModelUpdateErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Model/UpdateError";
+    }
+}
+const ModelUpdateErrorEventHandler = createAbstraction("ModelUpdateErrorEventHandler");
+export { ModelAfterUpdateEvent, ModelAfterUpdateEventHandler, ModelBeforeUpdateEvent, ModelBeforeUpdateEventHandler, ModelUpdateErrorEvent, ModelUpdateErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/UpdateModel/events.js","sources":["../../../../src/features/contentModel/UpdateModel/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, CmsModelUpdateInput } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface ModelBeforeUpdateEventPayload {\n    model: CmsModel;\n    original: CmsModel;\n    input: CmsModelUpdateInput;\n}\n\nexport interface ModelAfterUpdateEventPayload {\n    model: CmsModel;\n    original: CmsModel;\n}\n\nexport interface ModelUpdateErrorEventPayload {\n    input: CmsModelUpdateInput;\n    model: CmsModel;\n    original: CmsModel;\n    error: Error;\n}\n\n/**\n * ModelBeforeUpdateEvent - Published before updating a model\n */\nexport class ModelBeforeUpdateEvent extends DomainEvent<ModelBeforeUpdateEventPayload> {\n    eventType = \"Cms/Model/BeforeUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return ModelBeforeUpdateEventHandler;\n    }\n}\n\n/** Hook into model lifecycle before a model is updated. */\nexport const ModelBeforeUpdateEventHandler = createAbstraction<\n    IEventHandler<ModelBeforeUpdateEvent>\n>(\"ModelBeforeUpdateEventHandler\");\n\nexport namespace ModelBeforeUpdateEventHandler {\n    export type Interface = IEventHandler<ModelBeforeUpdateEvent>;\n    export type Event = ModelBeforeUpdateEvent;\n}\n\n/**\n * ModelAfterUpdateEvent - Published after updating a model\n */\nexport class ModelAfterUpdateEvent extends DomainEvent<ModelAfterUpdateEventPayload> {\n    eventType = \"Cms/Model/AfterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return ModelAfterUpdateEventHandler;\n    }\n}\n\n/** Hook into model lifecycle after a model is updated. */\nexport const ModelAfterUpdateEventHandler = createAbstraction<IEventHandler<ModelAfterUpdateEvent>>(\n    \"ModelAfterUpdateEventHandler\"\n);\n\nexport namespace ModelAfterUpdateEventHandler {\n    export type Interface = IEventHandler<ModelAfterUpdateEvent>;\n    export type Event = ModelAfterUpdateEvent;\n}\n\n/**\n * ModelUpdateErrorEvent - Published when update fails\n */\nexport class ModelUpdateErrorEvent extends DomainEvent<ModelUpdateErrorEventPayload> {\n    eventType = \"Cms/Model/UpdateError\" as const;\n\n    getHandlerAbstraction() {\n        return ModelUpdateErrorEventHandler;\n    }\n}\n\nexport const ModelUpdateErrorEventHandler = createAbstraction<IEventHandler<ModelUpdateErrorEvent>>(\n    \"ModelUpdateErrorEventHandler\"\n);\n\nexport namespace ModelUpdateErrorEventHandler {\n    export type Interface = IEventHandler<ModelUpdateErrorEvent>;\n    export type Event = ModelUpdateErrorEvent;\n}\n"],"names":["ModelBeforeUpdateEvent","DomainEvent","ModelBeforeUpdateEventHandler","createAbstraction","ModelAfterUpdateEvent","ModelAfterUpdateEventHandler","ModelUpdateErrorEvent","ModelUpdateErrorEventHandler"],"mappings":";;AA6BO,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/UpdateModel/feature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * UpdateModel Feature
+ *
+ * Provides functionality for updating existing content models.
+ * All validation (API name uniqueness, field validation) is handled by the repository.
+ */
+export declare const UpdateModelFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/contentModel/UpdateModel/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/UpdateModel/feature.js","sources":["../../../../src/features/contentModel/UpdateModel/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateModelUseCase } from \"./UpdateModelUseCase.js\";\nimport { UpdateModelRepository } from \"./UpdateModelRepository.js\";\n\n/**\n * UpdateModel Feature\n *\n * Provides functionality for updating existing content models.\n * All validation (API name uniqueness, field validation) is handled by the repository.\n */\nexport const UpdateModelFeature = createFeature({\n    name: \"UpdateModel\",\n    register(container) {\n        // Register core use case\n        container.register(UpdateModelUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(UpdateModelRepository).inSingletonScope();\n    }\n});\n"],"names":["UpdateModelFeature","createFeature","container","UpdateModelUseCase","UpdateModelRepository"],"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/UpdateModel/index.d.ts

@@ -0,0 +1,2 @@
+export { UpdateModelUseCase, UpdateModelRepository } from "./abstractions.js";
+export { ModelAfterUpdateEventHandler, ModelBeforeUpdateEventHandler } from "./events.js";

package/features/contentModel/UpdateModel/index.js

@@ -0,0 +1,2 @@
+export { UpdateModelRepository, UpdateModelUseCase } from "./abstractions.js";
+export { ModelAfterUpdateEventHandler, ModelBeforeUpdateEventHandler } from "./events.js";

package/features/contentModel/shared/ModelsFetcher.d.ts

@@ -0,0 +1,31 @@
+import { Result } from "@webiny/feature/api";
+import { ModelCache, ModelsFetcher as FetcherAbstraction } from "../../../features/contentModel/shared/abstractions.js";
+import { PluginModelsProvider } from "../../../features/contentModel/shared/abstractions.js";
+import { 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";
+/**
+ * ModelsFetcherImpl - Implementation with multi-level caching.
+ *
+ * Caching strategy:
+ * 1. Plugin models are cached per tenant (with access control applied by PluginModelsProvider)
+ * 2. Database models are cached per tenant (raw from DB)
+ * 3. Filtered database models are cached per tenant + identity (with access control applied)
+ * 4. Final merged list is cached per tenant + identity
+ */
+declare class ModelsFetcherImpl implements FetcherAbstraction.Interface {
+    private readonly modelCache;
+    private readonly pluginModelsProvider;
+    private readonly storageOperations;
+    private readonly tenantContext;
+    private readonly modelFieldCompression;
+    constructor(modelCache: ModelCache.Interface, pluginModelsProvider: PluginModelsProvider.Interface, storageOperations: StorageOperations.Interface, tenantContext: TenantContext.Interface, modelFieldCompression: ModelFieldCompression.Interface);
+    fetchAll(): Promise<Result<CmsModel[], FetcherAbstraction.Error>>;
+    fetchById(modelId: string): Promise<Result<CmsModel, FetcherAbstraction.Error>>;
+    private fetchAndMergeModels;
+}
+export declare const ModelsFetcher: typeof ModelsFetcherImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/contentModel/shared/abstractions.js").IModelsFetcher>;
+};
+export {};

package/features/contentModel/shared/ModelsFetcher.js

@@ -0,0 +1,81 @@
+import { Result } from "@webiny/feature/api";
+import { ModelCache, ModelsFetcher, PluginModelsProvider } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { ModelNotFoundError, ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+import { createCacheKey } from "../../../utils/index.js";
+import { ensureTypeTag } from "../../../domain/contentModel/ensureTypeTag.js";
+import { ModelFieldCompression } from "../ModelFieldCompression/index.js";
+class ModelsFetcherImpl {
+    constructor(modelCache, pluginModelsProvider, storageOperations, tenantContext, modelFieldCompression){
+        this.modelCache = modelCache;
+        this.pluginModelsProvider = pluginModelsProvider;
+        this.storageOperations = storageOperations;
+        this.tenantContext = tenantContext;
+        this.modelFieldCompression = modelFieldCompression;
+    }
+    async fetchAll() {
+        try {
+            const tenant = this.tenantContext.getTenant();
+            const cacheKey = createCacheKey({
+                tenant: tenant.id
+            });
+            const cached = await this.modelCache.getOrSet(cacheKey, async ()=>{
+                const pluginModels = await this.pluginModelsProvider.list(tenant.id);
+                const databaseModels = await this.fetchAndMergeModels(tenant.id);
+                return [
+                    ...pluginModels,
+                    ...databaseModels
+                ];
+            });
+            return Result.ok(cached);
+        } catch (error) {
+            return Result.fail(new ModelPersistenceError(error));
+        }
+    }
+    async fetchById(modelId) {
+        const result = await this.fetchAll();
+        if (result.isFail()) return Result.fail(new ModelPersistenceError(result.error));
+        const model = result.value.find((m)=>m.modelId === modelId);
+        if (!model) return Result.fail(new ModelNotFoundError(modelId));
+        return Result.ok(model);
+    }
+    async fetchAndMergeModels(tenant) {
+        const dbCacheKey = createCacheKey({
+            tenant,
+            id: "storage"
+        });
+        const databaseModels = await this.modelCache.getOrSet(dbCacheKey, async ()=>{
+            const models = await this.storageOperations.models.list({
+                where: {
+                    tenant
+                }
+            });
+            return Promise.all(models.map(async (model)=>{
+                const fields = await this.modelFieldCompression.decompress(model.fields);
+                return {
+                    ...model,
+                    fields
+                };
+            }));
+        });
+        const taggedDatabaseModels = databaseModels.map((model)=>{
+            model.tags = ensureTypeTag(model);
+            return model;
+        });
+        return taggedDatabaseModels;
+    }
+}
+const ModelsFetcher_ModelsFetcher = ModelsFetcher.createImplementation({
+    implementation: ModelsFetcherImpl,
+    dependencies: [
+        ModelCache,
+        PluginModelsProvider,
+        StorageOperations,
+        TenantContext,
+        ModelFieldCompression
+    ]
+});
+export { ModelsFetcher_ModelsFetcher as ModelsFetcher };
+
+//# sourceMappingURL=ModelsFetcher.js.map

package/features/contentModel/shared/ModelsFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/shared/ModelsFetcher.js","sources":["../../../../src/features/contentModel/shared/ModelsFetcher.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    ModelCache,\n    ModelsFetcher as FetcherAbstraction\n} from \"~/features/contentModel/shared/abstractions.js\";\nimport { PluginModelsProvider } from \"~/features/contentModel/shared/abstractions.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { ModelNotFoundError, ModelPersistenceError } from \"~/domain/contentModel/errors.js\";\nimport { createCacheKey } from \"~/utils/index.js\";\nimport { ensureTypeTag } from \"~/domain/contentModel/ensureTypeTag.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { ModelFieldCompression } from \"~/features/contentModel/ModelFieldCompression/index.js\";\n\n/**\n * ModelsFetcherImpl - Implementation with multi-level caching.\n *\n * Caching strategy:\n * 1. Plugin models are cached per tenant (with access control applied by PluginModelsProvider)\n * 2. Database models are cached per tenant (raw from DB)\n * 3. Filtered database models are cached per tenant + identity (with access control applied)\n * 4. Final merged list is cached per tenant + identity\n */\nclass ModelsFetcherImpl implements FetcherAbstraction.Interface {\n    public constructor(\n        private readonly modelCache: ModelCache.Interface,\n        private readonly pluginModelsProvider: PluginModelsProvider.Interface,\n        private readonly storageOperations: StorageOperations.Interface,\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly modelFieldCompression: ModelFieldCompression.Interface\n    ) {}\n\n    async fetchAll(): Promise<Result<CmsModel[], FetcherAbstraction.Error>> {\n        try {\n            const tenant = this.tenantContext.getTenant();\n\n            // Create a cache key based on tenant + identity\n            const cacheKey = createCacheKey({\n                tenant: tenant.id\n            });\n\n            // Try to get from cache first\n            const cached = await this.modelCache.getOrSet(cacheKey, async () => {\n                // Fetch plugin models (with caching and access control)\n                const pluginModels = await this.pluginModelsProvider.list(tenant.id);\n\n                const databaseModels = await this.fetchAndMergeModels(tenant.id);\n\n                return [...pluginModels, ...databaseModels];\n            });\n\n            return Result.ok(cached);\n        } catch (error) {\n            return Result.fail(new ModelPersistenceError(error as Error));\n        }\n    }\n\n    async fetchById(modelId: string): Promise<Result<CmsModel, FetcherAbstraction.Error>> {\n        const result = await this.fetchAll();\n        if (result.isFail()) {\n            return Result.fail(new ModelPersistenceError(result.error));\n        }\n\n        const model = result.value.find(m => m.modelId === modelId);\n        if (!model) {\n            return Result.fail(new ModelNotFoundError(modelId));\n        }\n\n        return Result.ok(model);\n    }\n\n    private async fetchAndMergeModels(tenant: string): Promise<CmsModel[]> {\n        // 1. Fetch database models (with caching)\n        const dbCacheKey = createCacheKey({ tenant, id: \"storage\" });\n        const databaseModels = await this.modelCache.getOrSet(dbCacheKey, async () => {\n            const models = await this.storageOperations.models.list({ where: { tenant } });\n\n            return Promise.all(\n                models.map(async model => {\n                    const fields = await this.modelFieldCompression.decompress(model.fields);\n\n                    return {\n                        ...model,\n                        fields\n                    };\n                })\n            );\n        });\n\n        // 2. Ensure type tags on database models\n        const taggedDatabaseModels = databaseModels.map(model => {\n            model.tags = ensureTypeTag(model);\n            return model;\n        });\n\n        // 3. Return merged models.\n        return taggedDatabaseModels;\n    }\n}\n\nexport const ModelsFetcher = FetcherAbstraction.createImplementation({\n    implementation: ModelsFetcherImpl,\n    dependencies: [\n        ModelCache,\n        PluginModelsProvider,\n        StorageOperations,\n        TenantContext,\n        ModelFieldCompression\n    ]\n});\n"],"names":["ModelsFetcherImpl","modelCache","pluginModelsProvider","storageOperations","tenantContext","modelFieldCompression","tenant","cacheKey","createCacheKey","cached","pluginModels","databaseModels","Result","error","ModelPersistenceError","modelId","result","model","m","ModelNotFoundError","dbCacheKey","models","Promise","fields","taggedDatabaseModels","ensureTypeTag","ModelsFetcher","FetcherAbstraction","ModelCache","PluginModelsProvider","StorageOperations","TenantContext","ModelFieldCompression"],"mappings":";;;;;;;;AAuBA,MAAMA;IACF,YACqBC,UAAgC,EAChCC,oBAAoD,EACpDC,iBAA8C,EAC9CC,aAAsC,EACtCC,qBAAsD,CACzE;aALmBJ,UAAU,GAAVA;aACAC,oBAAoB,GAApBA;aACAC,iBAAiB,GAAjBA;aACAC,aAAa,GAAbA;aACAC,qBAAqB,GAArBA;IAClB;IAEH,MAAM,WAAkE;QACpE,IAAI;YACA,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;YAG3C,MAAMC,WAAWC,eAAe;gBAC5B,QAAQF,OAAO,EAAE;YACrB;YAGA,MAAMG,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAACF,UAAU;gBAEpD,MAAMG,eAAe,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAACJ,OAAO,EAAE;gBAEnE,MAAMK,iBAAiB,MAAM,IAAI,CAAC,mBAAmB,CAACL,OAAO,EAAE;gBAE/D,OAAO;uBAAII;uBAAiBC;iBAAe;YAC/C;YAEA,OAAOC,OAAO,EAAE,CAACH;QACrB,EAAE,OAAOI,OAAO;YACZ,OAAOD,OAAO,IAAI,CAAC,IAAIE,sBAAsBD;QACjD;IACJ;IAEA,MAAM,UAAUE,OAAe,EAAuD;QAClF,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ;QAClC,IAAIA,OAAO,MAAM,IACb,OAAOJ,OAAO,IAAI,CAAC,IAAIE,sBAAsBE,OAAO,KAAK;QAG7D,MAAMC,QAAQD,OAAO,KAAK,CAAC,IAAI,CAACE,CAAAA,IAAKA,EAAE,OAAO,KAAKH;QACnD,IAAI,CAACE,OACD,OAAOL,OAAO,IAAI,CAAC,IAAIO,mBAAmBJ;QAG9C,OAAOH,OAAO,EAAE,CAACK;IACrB;IAEA,MAAc,oBAAoBX,MAAc,EAAuB;QAEnE,MAAMc,aAAaZ,eAAe;YAAEF;YAAQ,IAAI;QAAU;QAC1D,MAAMK,iBAAiB,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAACS,YAAY;YAC9D,MAAMC,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAE,OAAO;oBAAEf;gBAAO;YAAE;YAE5E,OAAOgB,QAAQ,GAAG,CACdD,OAAO,GAAG,CAAC,OAAMJ;gBACb,MAAMM,SAAS,MAAM,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAACN,MAAM,MAAM;gBAEvE,OAAO;oBACH,GAAGA,KAAK;oBACRM;gBACJ;YACJ;QAER;QAGA,MAAMC,uBAAuBb,eAAe,GAAG,CAACM,CAAAA;YAC5CA,MAAM,IAAI,GAAGQ,cAAcR;YAC3B,OAAOA;QACX;QAGA,OAAOO;IACX;AACJ;AAEO,MAAME,8BAAgBC,cAAAA,oBAAuC,CAAC;IACjE,gBAAgB3B;IAChB,cAAc;QACV4B;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/contentModel/shared/PluginModelsProvider.d.ts

@@ -0,0 +1,21 @@
+import { AccessControl, CmsContext } from "../../../features/shared/abstractions.js";
+import { PluginModelsProvider as ProviderAbstraction } from "./abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+import { type IModelsProvider } from "../../../features/modelBuilder/models/abstractions.js";
+/**
+ * PluginModelsProvider implementation that fetches models from:
+ * 1. Legacy CmsModelPlugin instances
+ * 2. New ModelBuilder providers (public and private)
+ */
+declare class PluginModelsProviderImpl implements ProviderAbstraction.Interface {
+    private cmsContext;
+    private accessControl;
+    private modelsProvider;
+    constructor(cmsContext: CmsContext.Interface, accessControl: AccessControl.Interface, modelsProvider: IModelsProvider);
+    list(tenant: string): Promise<CmsModel[]>;
+    private ensureTypeTag;
+}
+export declare const PluginModelsProvider: typeof PluginModelsProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IPluginModelsProvider>;
+};
+export {};

package/features/contentModel/shared/PluginModelsProvider.js

@@ -0,0 +1,48 @@
+import { AccessControl, CmsContext } from "../../shared/abstractions.js";
+import { PluginModelsProvider } from "./abstractions.js";
+import { CmsModelPlugin } from "../../../plugins/CmsModelPlugin.js";
+import { filterAsync } from "../../../utils/filterAsync.js";
+import { ModelsProvider } from "../../modelBuilder/models/abstractions.js";
+class PluginModelsProviderImpl {
+    constructor(cmsContext, accessControl, modelsProvider){
+        this.cmsContext = cmsContext;
+        this.accessControl = accessControl;
+        this.modelsProvider = modelsProvider;
+    }
+    async list(tenant) {
+        const modelPlugins = this.cmsContext.plugins.byType(CmsModelPlugin.type);
+        const legacyModels = modelPlugins.filter((plugin)=>{
+            const { tenant: modelTenant } = plugin.contentModel;
+            if (modelTenant && modelTenant !== tenant) return false;
+            return true;
+        }).map((plugin)=>({
+                ...plugin.contentModel,
+                tags: this.ensureTypeTag(plugin.contentModel),
+                tenant
+            }));
+        const allowedLegacyModels = await filterAsync(legacyModels, (model)=>this.accessControl.canAccessModel({
+                model
+            }));
+        const builderModels = await this.modelsProvider.list(tenant);
+        return [
+            ...allowedLegacyModels,
+            ...builderModels
+        ];
+    }
+    ensureTypeTag(model) {
+        const tags = model.tags || [];
+        if (!tags.some((tag)=>tag.startsWith("type:"))) tags.push("type:model");
+        return tags;
+    }
+}
+const PluginModelsProvider_PluginModelsProvider = PluginModelsProvider.createImplementation({
+    implementation: PluginModelsProviderImpl,
+    dependencies: [
+        CmsContext,
+        AccessControl,
+        ModelsProvider
+    ]
+});
+export { PluginModelsProvider_PluginModelsProvider as PluginModelsProvider };
+
+//# sourceMappingURL=PluginModelsProvider.js.map

package/features/contentModel/shared/PluginModelsProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/shared/PluginModelsProvider.js","sources":["../../../../src/features/contentModel/shared/PluginModelsProvider.ts"],"sourcesContent":["import { AccessControl, CmsContext } from \"~/features/shared/abstractions.js\";\nimport { PluginModelsProvider as ProviderAbstraction } from \"./abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { CmsModelPlugin } from \"~/plugins/CmsModelPlugin.js\";\nimport { filterAsync } from \"~/utils/filterAsync.js\";\nimport {\n    ModelsProvider,\n    type IModelsProvider\n} from \"~/features/modelBuilder/models/abstractions.js\";\n\n/**\n * PluginModelsProvider implementation that fetches models from:\n * 1. Legacy CmsModelPlugin instances\n * 2. New ModelBuilder providers (public and private)\n */\nclass PluginModelsProviderImpl implements ProviderAbstraction.Interface {\n    public constructor(\n        private cmsContext: CmsContext.Interface,\n        private accessControl: AccessControl.Interface,\n        private modelsProvider: IModelsProvider\n    ) {}\n\n    async list(tenant: string): Promise<CmsModel[]> {\n        // Get models from legacy plugins\n        const modelPlugins = this.cmsContext.plugins.byType<CmsModelPlugin>(CmsModelPlugin.type);\n\n        const legacyModels = modelPlugins\n            .filter(plugin => {\n                const { tenant: modelTenant } = plugin.contentModel;\n                // Filter by tenant if specified in plugin\n                if (modelTenant && modelTenant !== tenant) {\n                    return false;\n                }\n\n                return true;\n            })\n            .map(plugin => {\n                return {\n                    ...plugin.contentModel,\n                    tags: this.ensureTypeTag(plugin.contentModel),\n                    tenant\n                };\n            }) as unknown as CmsModel[];\n\n        const allowedLegacyModels = await filterAsync(legacyModels, model => {\n            return this.accessControl.canAccessModel({ model });\n        });\n\n        // Get models from new builder providers. These already have access control applied.\n        const builderModels = await this.modelsProvider.list(tenant);\n\n        // Combine both sources\n        return [...allowedLegacyModels, ...builderModels];\n    }\n\n    private ensureTypeTag(model: Pick<CmsModel, \"tags\">) {\n        // Let's make sure we have a `type` tag assigned.\n        // If `type` tag is not set, set it to a default one (`model`).\n        const tags = model.tags || [];\n        if (!tags.some(tag => tag.startsWith(\"type:\"))) {\n            tags.push(\"type:model\");\n        }\n\n        return tags;\n    }\n}\n\nexport const PluginModelsProvider = ProviderAbstraction.createImplementation({\n    implementation: PluginModelsProviderImpl,\n    dependencies: [CmsContext, AccessControl, ModelsProvider]\n});\n"],"names":["PluginModelsProviderImpl","cmsContext","accessControl","modelsProvider","tenant","modelPlugins","CmsModelPlugin","legacyModels","plugin","modelTenant","allowedLegacyModels","filterAsync","model","builderModels","tags","tag","PluginModelsProvider","ProviderAbstraction","CmsContext","AccessControl","ModelsProvider"],"mappings":";;;;;AAeA,MAAMA;IACF,YACYC,UAAgC,EAChCC,aAAsC,EACtCC,cAA+B,CACzC;aAHUF,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,KAAKC,MAAc,EAAuB;QAE5C,MAAMC,eAAe,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAiBC,eAAe,IAAI;QAEvF,MAAMC,eAAeF,aAChB,MAAM,CAACG,CAAAA;YACJ,MAAM,EAAE,QAAQC,WAAW,EAAE,GAAGD,OAAO,YAAY;YAEnD,IAAIC,eAAeA,gBAAgBL,QAC/B,OAAO;YAGX,OAAO;QACX,GACC,GAAG,CAACI,CAAAA,SACM;gBACH,GAAGA,OAAO,YAAY;gBACtB,MAAM,IAAI,CAAC,aAAa,CAACA,OAAO,YAAY;gBAC5CJ;YACJ;QAGR,MAAMM,sBAAsB,MAAMC,YAAYJ,cAAcK,CAAAA,QACjD,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;gBAAEA;YAAM;QAIrD,MAAMC,gBAAgB,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,CAACT;QAGrD,OAAO;eAAIM;eAAwBG;SAAc;IACrD;IAEQ,cAAcD,KAA6B,EAAE;QAGjD,MAAME,OAAOF,MAAM,IAAI,IAAI,EAAE;QAC7B,IAAI,CAACE,KAAK,IAAI,CAACC,CAAAA,MAAOA,IAAI,UAAU,CAAC,WACjCD,KAAK,IAAI,CAAC;QAGd,OAAOA;IACX;AACJ;AAEO,MAAME,4CAAuBC,qBAAAA,oBAAwC,CAAC;IACzE,gBAAgBjB;IAChB,cAAc;QAACkB;QAAYC;QAAeC;KAAe;AAC7D"}

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

@@ -0,0 +1,49 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsModel } from "../../../types/index.js";
+import type { ICache } from "../../../utils/caching/types.js";
+import { ModelNotFoundError, ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+/**
+ * PluginModelsProvider provides access to plugin-defined (code) models.
+ */
+export interface IPluginModelsProvider {
+    list(tenant: string): Promise<CmsModel[]>;
+}
+export declare const PluginModelsProvider: import("@webiny/di").Abstraction<IPluginModelsProvider>;
+export declare namespace PluginModelsProvider {
+    type Interface = IPluginModelsProvider;
+}
+export declare const ModelCache: import("@webiny/di").Abstraction<ICache<Promise<CmsModel[]>>>;
+export declare namespace ModelCache {
+    type Interface = ICache<Promise<CmsModel[]>>;
+}
+/**
+ * ModelsFetcher - Centralized model fetching with caching.
+ *
+ * This abstraction handles fetching models from both plugins and database,
+ * applies access control filtering, and caches the results for optimal performance.
+ */
+export interface IModelsFetcher {
+    /**
+     * Fetch all accessible models for the current tenant and identity.
+     * Results are cached based on tenant + identity.
+     */
+    fetchAll(): Promise<Result<CmsModel[], ModelsFetcherError>>;
+    /**
+     * Fetch a single model by modelId.
+     * Uses the cached fetchAll result.
+     */
+    fetchById(modelId: string): Promise<Result<CmsModel, ModelsFetcherError>>;
+}
+export interface IModelsFetcherErrors {
+    notFound: ModelNotFoundError;
+    persistence: ModelPersistenceError;
+}
+type ModelsFetcherError = IModelsFetcherErrors[keyof IModelsFetcherErrors];
+export declare const ModelsFetcher: import("@webiny/di").Abstraction<IModelsFetcher>;
+export declare namespace ModelsFetcher {
+    type Interface = IModelsFetcher;
+    type Error = ModelsFetcherError;
+    type FetchAllReturn = Promise<Result<CmsModel[], ModelsFetcherError>>;
+    type FetchByIdReturn = Promise<Result<CmsModel, ModelsFetcherError>>;
+}
+export {};

package/features/contentModel/shared/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/shared/abstractions.js","sources":["../../../../src/features/contentModel/shared/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport type { ICache } from \"~/utils/caching/types.js\";\nimport { ModelNotFoundError, ModelPersistenceError } from \"~/domain/contentModel/errors.js\";\n\n/**\n * PluginModelsProvider provides access to plugin-defined (code) models.\n */\nexport interface IPluginModelsProvider {\n    list(tenant: string): Promise<CmsModel[]>;\n}\n\nexport const PluginModelsProvider =\n    createAbstraction<IPluginModelsProvider>(\"PluginModelsProvider\");\n\nexport namespace PluginModelsProvider {\n    export type Interface = IPluginModelsProvider;\n}\n\nexport const ModelCache = createAbstraction<ICache<Promise<CmsModel[]>>>(\"ModelCache\");\n\nexport namespace ModelCache {\n    export type Interface = ICache<Promise<CmsModel[]>>;\n}\n\n/**\n * ModelsFetcher - Centralized model fetching with caching.\n *\n * This abstraction handles fetching models from both plugins and database,\n * applies access control filtering, and caches the results for optimal performance.\n */\nexport interface IModelsFetcher {\n    /**\n     * Fetch all accessible models for the current tenant and identity.\n     * Results are cached based on tenant + identity.\n     */\n    fetchAll(): Promise<Result<CmsModel[], ModelsFetcherError>>;\n\n    /**\n     * Fetch a single model by modelId.\n     * Uses the cached fetchAll result.\n     */\n    fetchById(modelId: string): Promise<Result<CmsModel, ModelsFetcherError>>;\n}\n\nexport interface IModelsFetcherErrors {\n    notFound: ModelNotFoundError;\n    persistence: ModelPersistenceError;\n}\n\ntype ModelsFetcherError = IModelsFetcherErrors[keyof IModelsFetcherErrors];\n\nexport const ModelsFetcher = createAbstraction<IModelsFetcher>(\"ModelsFetcher\");\n\nexport namespace ModelsFetcher {\n    export type Interface = IModelsFetcher;\n    export type Error = ModelsFetcherError;\n\n    export type FetchAllReturn = Promise<Result<CmsModel[], ModelsFetcherError>>;\n    export type FetchByIdReturn = Promise<Result<CmsModel, ModelsFetcherError>>;\n}\n"],"names":["PluginModelsProvider","createAbstraction","ModelCache","ModelsFetcher"],"mappings":";AAYO,MAAMA,uBACTC,kBAAyC;AAMtC,MAAMC,aAAaD,kBAA+C;AAiClE,MAAME,gBAAgBF,kBAAkC"}

package/features/contentModelGroup/ContentModelGroupFeature.d.ts

@@ -0,0 +1,4 @@
+export declare const ContentModelGroupFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};