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

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

@@ -0,0 +1,57 @@
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+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>>;
+}
+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>>;
+}
+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,39 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+
+/**
+ * Event payloads
+ */
+
+/**
+ * ModelBeforeUpdateEvent - Published before updating a model
+ */
+export class ModelBeforeUpdateEvent extends DomainEvent {
+  eventType = "Cms/Model/BeforeUpdate";
+  getHandlerAbstraction() {
+    return ModelBeforeUpdateEventHandler;
+  }
+}
+export const ModelBeforeUpdateEventHandler = createAbstraction("ModelBeforeUpdateEventHandler");
+/**
+ * ModelAfterUpdateEvent - Published after updating a model
+ */
+export class ModelAfterUpdateEvent extends DomainEvent {
+  eventType = "Cms/Model/AfterUpdate";
+  getHandlerAbstraction() {
+    return ModelAfterUpdateEventHandler;
+  }
+}
+export const ModelAfterUpdateEventHandler = createAbstraction("ModelAfterUpdateEventHandler");
+/**
+ * ModelUpdateErrorEvent - Published when update fails
+ */
+export class ModelUpdateErrorEvent extends DomainEvent {
+  eventType = "Cms/Model/UpdateError";
+  getHandlerAbstraction() {
+    return ModelUpdateErrorEventHandler;
+  }
+}
+export const ModelUpdateErrorEventHandler = createAbstraction("ModelUpdateErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","ModelBeforeUpdateEvent","eventType","getHandlerAbstraction","ModelBeforeUpdateEventHandler","ModelAfterUpdateEvent","ModelAfterUpdateEventHandler","ModelUpdateErrorEvent","ModelUpdateErrorEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type { CmsModel, 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\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\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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;;AAGtE;AACA;AACA;;AAmBA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,SAASD,WAAW,CAAgC;EACnFE,SAAS,GAAG,wBAAwB;EAEpCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,6BAA6B;EACxC;AACJ;AAEA,OAAO,MAAMA,6BAA6B,GAAGL,iBAAiB,CAE5D,+BAA+B,CAAC;AAOlC;AACA;AACA;AACA,OAAO,MAAMM,qBAAqB,SAASL,WAAW,CAA+B;EACjFE,SAAS,GAAG,uBAAuB;EAEnCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,4BAA4B;EACvC;AACJ;AAEA,OAAO,MAAMA,4BAA4B,GAAGP,iBAAiB,CACzD,8BACJ,CAAC;AAOD;AACA;AACA;AACA,OAAO,MAAMQ,qBAAqB,SAASP,WAAW,CAA+B;EACjFE,SAAS,GAAG,uBAAuB;EAEnCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,4BAA4B;EACvC;AACJ;AAEA,OAAO,MAAMA,4BAA4B,GAAGT,iBAAiB,CACzD,8BACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,7 @@
+/**
+ * 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: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentModel/UpdateModel/feature.js

@@ -0,0 +1,22 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateModelUseCase } from "./UpdateModelUseCase.js";
+import { UpdateModelRepository } from "./UpdateModelRepository.js";
+
+/**
+ * UpdateModel Feature
+ *
+ * Provides functionality for updating existing content models.
+ * All validation (API name uniqueness, field validation) is handled by the repository.
+ */
+export const UpdateModelFeature = createFeature({
+  name: "UpdateModel",
+  register(container) {
+    // Register core use case
+    container.register(UpdateModelUseCase);
+
+    // Register repository in singleton scope (shared instance)
+    container.register(UpdateModelRepository).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","UpdateModelUseCase","UpdateModelRepository","UpdateModelFeature","name","register","container","inSingletonScope"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,kBAAkB;AAC3B,SAASC,qBAAqB;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kBAAkB,GAAGH,aAAa,CAAC;EAC5CI,IAAI,EAAE,aAAa;EACnBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACJ,kBAAkB,CAAC;;IAEtC;IACAK,SAAS,CAACD,QAAQ,CAACH,qBAAqB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAChE;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/contentModel/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,4 @@
+export { UpdateModelUseCase, UpdateModelRepository } from "./abstractions.js";
+export { ModelAfterUpdateEventHandler, ModelBeforeUpdateEventHandler } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["UpdateModelUseCase","UpdateModelRepository","ModelAfterUpdateEventHandler","ModelBeforeUpdateEventHandler"],"sources":["index.ts"],"sourcesContent":["export { UpdateModelUseCase, UpdateModelRepository } from \"./abstractions.js\";\nexport { ModelAfterUpdateEventHandler, ModelBeforeUpdateEventHandler } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,kBAAkB,EAAEC,qBAAqB;AAClD,SAASC,4BAA4B,EAAEC,6BAA6B","ignoreList":[]}

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

@@ -0,0 +1,29 @@
+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/TenantContext";
+import type { CmsModel } from "../../../types/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 modelCache;
+    private pluginModelsProvider;
+    private storageOperations;
+    private tenantContext;
+    constructor(modelCache: ModelCache.Interface, pluginModelsProvider: PluginModelsProvider.Interface, storageOperations: StorageOperations.Interface, tenantContext: TenantContext.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,86 @@
+import { Result } from "@webiny/feature/api";
+import { ModelCache, ModelsFetcher as FetcherAbstraction } from "./abstractions.js";
+import { PluginModelsProvider } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+import { ModelNotFoundError, ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+import { createCacheKey } from "../../../utils/index.js";
+import { ensureTypeTag } from "../../../domain/contentModel/ensureTypeTag.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
+ */
+class ModelsFetcherImpl {
+  constructor(modelCache, pluginModelsProvider, storageOperations, tenantContext) {
+    this.modelCache = modelCache;
+    this.pluginModelsProvider = pluginModelsProvider;
+    this.storageOperations = storageOperations;
+    this.tenantContext = tenantContext;
+  }
+  async fetchAll() {
+    try {
+      const tenant = this.tenantContext.getTenant();
+
+      // Create a cache key based on tenant + identity
+      const cacheKey = createCacheKey({
+        tenant: tenant.id
+      });
+
+      // Fetch plugin models (with caching and access control)
+      const pluginModels = await this.pluginModelsProvider.list(tenant.id);
+
+      // Try to get from cache first
+      const cached = await this.modelCache.getOrSet(cacheKey, async () => {
+        return this.fetchAndMergeModels(tenant.id);
+      });
+      return Result.ok([...cached, ...pluginModels]);
+    } 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) {
+    // 1. Fetch database models (with caching)
+    const dbCacheKey = createCacheKey({
+      tenant,
+      id: "storage"
+    });
+    const databaseModels = await this.modelCache.getOrSet(dbCacheKey, async () => {
+      return this.storageOperations.models.list({
+        where: {
+          tenant
+        }
+      });
+    });
+
+    // 2. Ensure type tags on database models
+    const taggedDatabaseModels = databaseModels.map(model => {
+      model.tags = ensureTypeTag(model);
+      return model;
+    });
+
+    // 3. Return merged models.
+    return taggedDatabaseModels;
+  }
+}
+export const ModelsFetcher = FetcherAbstraction.createImplementation({
+  implementation: ModelsFetcherImpl,
+  dependencies: [ModelCache, PluginModelsProvider, StorageOperations, TenantContext]
+});
+
+//# sourceMappingURL=ModelsFetcher.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ModelCache","ModelsFetcher","FetcherAbstraction","PluginModelsProvider","StorageOperations","TenantContext","ModelNotFoundError","ModelPersistenceError","createCacheKey","ensureTypeTag","ModelsFetcherImpl","constructor","modelCache","pluginModelsProvider","storageOperations","tenantContext","fetchAll","tenant","getTenant","cacheKey","id","pluginModels","list","cached","getOrSet","fetchAndMergeModels","ok","error","fail","fetchById","modelId","result","isFail","model","value","find","m","dbCacheKey","databaseModels","models","where","taggedDatabaseModels","map","tags","createImplementation","implementation","dependencies"],"sources":["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/TenantContext\";\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\";\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 modelCache: ModelCache.Interface,\n        private pluginModelsProvider: PluginModelsProvider.Interface,\n        private storageOperations: StorageOperations.Interface,\n        private tenantContext: TenantContext.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            // Fetch plugin models (with caching and access control)\n            const pluginModels = await this.pluginModelsProvider.list(tenant.id);\n\n            // Try to get from cache first\n            const cached = await this.modelCache.getOrSet(cacheKey, async () => {\n                return this.fetchAndMergeModels(tenant.id);\n            });\n\n            return Result.ok([...cached, ...pluginModels]);\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            return this.storageOperations.models.list({ where: { tenant } });\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: [ModelCache, PluginModelsProvider, StorageOperations, TenantContext]\n});\n"],"mappings":"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","ignoreList":[]}

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,64 @@
+import { AccessControl, CmsContext } from "../../shared/abstractions.js";
+import { PluginModelsProvider as ProviderAbstraction } from "./abstractions.js";
+import { CmsModelPlugin } from "../../../plugins/CmsModelPlugin.js";
+import { filterAsync } from "../../../utils/filterAsync.js";
+import { ModelsProvider } from "../../modelBuilder/models/abstractions.js";
+
+/**
+ * PluginModelsProvider implementation that fetches models from:
+ * 1. Legacy CmsModelPlugin instances
+ * 2. New ModelBuilder providers (public and private)
+ */
+class PluginModelsProviderImpl {
+  constructor(cmsContext, accessControl, modelsProvider) {
+    this.cmsContext = cmsContext;
+    this.accessControl = accessControl;
+    this.modelsProvider = modelsProvider;
+  }
+  async list(tenant) {
+    // Get models from legacy plugins
+    const modelPlugins = this.cmsContext.plugins.byType(CmsModelPlugin.type);
+    const legacyModels = modelPlugins.filter(plugin => {
+      const {
+        tenant: modelTenant
+      } = plugin.contentModel;
+      // Filter by tenant if specified in plugin
+      if (modelTenant && modelTenant !== tenant) {
+        return false;
+      }
+      return true;
+    }).map(plugin => {
+      return {
+        ...plugin.contentModel,
+        tags: this.ensureTypeTag(plugin.contentModel),
+        tenant
+      };
+    });
+    const allowedLegacyModels = await filterAsync(legacyModels, model => {
+      return this.accessControl.canAccessModel({
+        model
+      });
+    });
+
+    // Get models from new builder providers. These already have access control applied.
+    const builderModels = await this.modelsProvider.list(tenant);
+
+    // Combine both sources
+    return [...allowedLegacyModels, ...builderModels];
+  }
+  ensureTypeTag(model) {
+    // Let's make sure we have a `type` tag assigned.
+    // If `type` tag is not set, set it to a default one (`model`).
+    const tags = model.tags || [];
+    if (!tags.some(tag => tag.startsWith("type:"))) {
+      tags.push("type:model");
+    }
+    return tags;
+  }
+}
+export const PluginModelsProvider = ProviderAbstraction.createImplementation({
+  implementation: PluginModelsProviderImpl,
+  dependencies: [CmsContext, AccessControl, ModelsProvider]
+});
+
+//# sourceMappingURL=PluginModelsProvider.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["AccessControl","CmsContext","PluginModelsProvider","ProviderAbstraction","CmsModelPlugin","filterAsync","ModelsProvider","PluginModelsProviderImpl","constructor","cmsContext","accessControl","modelsProvider","list","tenant","modelPlugins","plugins","byType","type","legacyModels","filter","plugin","modelTenant","contentModel","map","tags","ensureTypeTag","allowedLegacyModels","model","canAccessModel","builderModels","some","tag","startsWith","push","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,EAAEC,UAAU;AAClC,SAASC,oBAAoB,IAAIC,mBAAmB;AAEpD,SAASC,cAAc;AACvB,SAASC,WAAW;AACpB,SACIC,cAAc;;AAIlB;AACA;AACA;AACA;AACA;AACA,MAAMC,wBAAwB,CAA0C;EAC7DC,WAAWA,CACNC,UAAgC,EAChCC,aAAsC,EACtCC,cAA+B,EACzC;IAAA,KAHUF,UAAgC,GAAhCA,UAAgC;IAAA,KAChCC,aAAsC,GAAtCA,aAAsC;IAAA,KACtCC,cAA+B,GAA/BA,cAA+B;EACxC;EAEH,MAAMC,IAAIA,CAACC,MAAc,EAAuB;IAC5C;IACA,MAAMC,YAAY,GAAG,IAAI,CAACL,UAAU,CAACM,OAAO,CAACC,MAAM,CAAiBZ,cAAc,CAACa,IAAI,CAAC;IAExF,MAAMC,YAAY,GAAGJ,YAAY,CAC5BK,MAAM,CAACC,MAAM,IAAI;MACd,MAAM;QAAEP,MAAM,EAAEQ;MAAY,CAAC,GAAGD,MAAM,CAACE,YAAY;MACnD;MACA,IAAID,WAAW,IAAIA,WAAW,KAAKR,MAAM,EAAE;QACvC,OAAO,KAAK;MAChB;MAEA,OAAO,IAAI;IACf,CAAC,CAAC,CACDU,GAAG,CAACH,MAAM,IAAI;MACX,OAAO;QACH,GAAGA,MAAM,CAACE,YAAY;QACtBE,IAAI,EAAE,IAAI,CAACC,aAAa,CAACL,MAAM,CAACE,YAAY,CAAC;QAC7CT;MACJ,CAAC;IACL,CAAC,CAA0B;IAE/B,MAAMa,mBAAmB,GAAG,MAAMrB,WAAW,CAACa,YAAY,EAAES,KAAK,IAAI;MACjE,OAAO,IAAI,CAACjB,aAAa,CAACkB,cAAc,CAAC;QAAED;MAAM,CAAC,CAAC;IACvD,CAAC,CAAC;;IAEF;IACA,MAAME,aAAa,GAAG,MAAM,IAAI,CAAClB,cAAc,CAACC,IAAI,CAACC,MAAM,CAAC;;IAE5D;IACA,OAAO,CAAC,GAAGa,mBAAmB,EAAE,GAAGG,aAAa,CAAC;EACrD;EAEQJ,aAAaA,CAACE,KAA6B,EAAE;IACjD;IACA;IACA,MAAMH,IAAI,GAAGG,KAAK,CAACH,IAAI,IAAI,EAAE;IAC7B,IAAI,CAACA,IAAI,CAACM,IAAI,CAACC,GAAG,IAAIA,GAAG,CAACC,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE;MAC5CR,IAAI,CAACS,IAAI,CAAC,YAAY,CAAC;IAC3B;IAEA,OAAOT,IAAI;EACf;AACJ;AAEA,OAAO,MAAMtB,oBAAoB,GAAGC,mBAAmB,CAAC+B,oBAAoB,CAAC;EACzEC,cAAc,EAAE5B,wBAAwB;EACxC6B,YAAY,EAAE,CAACnC,UAAU,EAAED,aAAa,EAAEM,cAAc;AAC5D,CAAC,CAAC","ignoreList":[]}

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,19 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * PluginModelsProvider provides access to plugin-defined (code) models.
+ */
+
+export const PluginModelsProvider = createAbstraction("PluginModelsProvider");
+export const ModelCache = createAbstraction("ModelCache");
+
+/**
+ * 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 const ModelsFetcher = createAbstraction("ModelsFetcher");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","PluginModelsProvider","ModelCache","ModelsFetcher"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAK/D;AACA;AACA;;AAKA,OAAO,MAAMC,oBAAoB,GAC7BD,iBAAiB,CAAwB,sBAAsB,CAAC;AAMpE,OAAO,MAAME,UAAU,GAAGF,iBAAiB,CAA8B,YAAY,CAAC;;AAMtF;AACA;AACA;AACA;AACA;AACA;;AAsBA,OAAO,MAAMG,aAAa,GAAGH,iBAAiB,CAAiB,eAAe,CAAC","ignoreList":[]}

package/features/contentModelGroup/ContentModelGroupFeature.d.ts

@@ -0,0 +1 @@
+export declare const ContentModelGroupFeature: import("@webiny/feature/api/createFeature").FeatureDefinition<unknown>;

package/features/contentModelGroup/ContentModelGroupFeature.js

@@ -0,0 +1,28 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetGroupFeature } from "./GetGroup/feature.js";
+import { ListGroupsFeature } from "./ListGroups/feature.js";
+import { CreateGroupFeature } from "./CreateGroup/feature.js";
+import { UpdateGroupFeature } from "./UpdateGroup/feature.js";
+import { DeleteGroupFeature } from "./DeleteGroup/feature.js";
+import { GroupCache } from "./shared/abstractions.js";
+import { PluginGroupsProvider } from "./shared/PluginGroupsProvider.js";
+import { createMemoryCache } from "../../utils/index.js";
+export const ContentModelGroupFeature = createFeature({
+  name: "ContentModelGroup",
+  register(container) {
+    // Shared infrastructure (singletons)
+    container.registerInstance(GroupCache, createMemoryCache());
+    container.register(PluginGroupsProvider).inSingletonScope();
+
+    // Query features
+    GetGroupFeature.register(container);
+    ListGroupsFeature.register(container);
+
+    // Command features
+    CreateGroupFeature.register(container);
+    UpdateGroupFeature.register(container);
+    DeleteGroupFeature.register(container);
+  }
+});
+
+//# sourceMappingURL=ContentModelGroupFeature.js.map

package/features/contentModelGroup/ContentModelGroupFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetGroupFeature","ListGroupsFeature","CreateGroupFeature","UpdateGroupFeature","DeleteGroupFeature","GroupCache","PluginGroupsProvider","createMemoryCache","ContentModelGroupFeature","name","register","container","registerInstance","inSingletonScope"],"sources":["ContentModelGroupFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetGroupFeature } from \"~/features/contentModelGroup/GetGroup/feature.js\";\nimport { ListGroupsFeature } from \"~/features/contentModelGroup/ListGroups/feature.js\";\nimport { CreateGroupFeature } from \"~/features/contentModelGroup/CreateGroup/feature.js\";\nimport { UpdateGroupFeature } from \"~/features/contentModelGroup/UpdateGroup/feature.js\";\nimport { DeleteGroupFeature } from \"~/features/contentModelGroup/DeleteGroup/feature.js\";\nimport { GroupCache } from \"~/features/contentModelGroup/shared/abstractions.js\";\nimport { PluginGroupsProvider } from \"~/features/contentModelGroup/shared/PluginGroupsProvider.js\";\nimport { createMemoryCache } from \"~/utils/index.js\";\n\nexport const ContentModelGroupFeature = createFeature({\n    name: \"ContentModelGroup\",\n    register(container) {\n        // Shared infrastructure (singletons)\n        container.registerInstance(GroupCache, createMemoryCache());\n        container.register(PluginGroupsProvider).inSingletonScope();\n\n        // Query features\n        GetGroupFeature.register(container);\n        ListGroupsFeature.register(container);\n\n        // Command features\n        CreateGroupFeature.register(container);\n        UpdateGroupFeature.register(container);\n        DeleteGroupFeature.register(container);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,eAAe;AACxB,SAASC,iBAAiB;AAC1B,SAASC,kBAAkB;AAC3B,SAASC,kBAAkB;AAC3B,SAASC,kBAAkB;AAC3B,SAASC,UAAU;AACnB,SAASC,oBAAoB;AAC7B,SAASC,iBAAiB;AAE1B,OAAO,MAAMC,wBAAwB,GAAGT,aAAa,CAAC;EAClDU,IAAI,EAAE,mBAAmB;EACzBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACC,gBAAgB,CAACP,UAAU,EAAEE,iBAAiB,CAAC,CAAC,CAAC;IAC3DI,SAAS,CAACD,QAAQ,CAACJ,oBAAoB,CAAC,CAACO,gBAAgB,CAAC,CAAC;;IAE3D;IACAb,eAAe,CAACU,QAAQ,CAACC,SAAS,CAAC;IACnCV,iBAAiB,CAACS,QAAQ,CAACC,SAAS,CAAC;;IAErC;IACAT,kBAAkB,CAACQ,QAAQ,CAACC,SAAS,CAAC;IACtCR,kBAAkB,CAACO,QAAQ,CAACC,SAAS,CAAC;IACtCP,kBAAkB,CAACM,QAAQ,CAACC,SAAS,CAAC;EAC1C;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/contentModelGroup/CreateGroup/CreateGroupRepository.d.ts

@@ -0,0 +1,28 @@
+import { Result } from "@webiny/feature/api";
+import { CreateGroupRepository as RepositoryAbstraction } from "./abstractions.js";
+import { GroupCache } from "../../../features/contentModelGroup/shared/abstractions.js";
+import { PluginGroupsProvider } from "../../../features/contentModelGroup/shared/abstractions.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+import type { CmsGroup } from "../../../types/index.js";
+/**
+ * CreateGroupRepository - Validates and persists a new group.
+ *
+ * Responsibilities:
+ * - Validate ID uniqueness (if provided)
+ * - Validate slug uniqueness (or generate unique slug)
+ * - Check for plugin group conflicts
+ * - Persist to storage
+ * - Clear GroupCache after successful create
+ */
+declare class CreateGroupRepositoryImpl implements RepositoryAbstraction.Interface {
+    private groupCache;
+    private pluginGroupsProvider;
+    private storageOperations;
+    private tenantContext;
+    constructor(groupCache: GroupCache.Interface, pluginGroupsProvider: PluginGroupsProvider.Interface, storageOperations: StorageOperations.Interface, tenantContext: TenantContext.Interface);
+    execute(group: CmsGroup): Promise<Result<void, RepositoryAbstraction.Error>>;
+    private isSlugTaken;
+}
+export declare const CreateGroupRepository: import("@webiny/di").Implementation<typeof CreateGroupRepositoryImpl>;
+export {};