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

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

@@ -0,0 +1,52 @@
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * Event payloads
+ */
+export interface ModelBeforeDeleteEventPayload {
+    model: CmsModel;
+}
+export interface ModelAfterDeleteEventPayload {
+    model: CmsModel;
+}
+export interface ModelDeleteErrorEventPayload {
+    model: CmsModel;
+    error: Error;
+}
+/**
+ * ModelBeforeDeleteEvent - Published before deleting a model
+ */
+export declare class ModelBeforeDeleteEvent extends DomainEvent<ModelBeforeDeleteEventPayload> {
+    eventType: "Cms/Model/BeforeDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelBeforeDeleteEvent>>;
+}
+export declare const ModelBeforeDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelBeforeDeleteEvent>>;
+export declare namespace ModelBeforeDeleteEventHandler {
+    type Interface = IEventHandler<ModelBeforeDeleteEvent>;
+    type Event = ModelBeforeDeleteEvent;
+}
+/**
+ * ModelAfterDeleteEvent - Published after deleting a model
+ */
+export declare class ModelAfterDeleteEvent extends DomainEvent<ModelAfterDeleteEventPayload> {
+    eventType: "Cms/Model/AfterDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelAfterDeleteEvent>>;
+}
+export declare const ModelAfterDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelAfterDeleteEvent>>;
+export declare namespace ModelAfterDeleteEventHandler {
+    type Interface = IEventHandler<ModelAfterDeleteEvent>;
+    type Event = ModelAfterDeleteEvent;
+}
+/**
+ * ModelDeleteErrorEvent - Published when delete fails
+ */
+export declare class ModelDeleteErrorEvent extends DomainEvent<ModelDeleteErrorEventPayload> {
+    eventType: "Cms/Model/DeleteError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ModelDeleteErrorEvent>>;
+}
+export declare const ModelDeleteErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<ModelDeleteErrorEvent>>;
+export declare namespace ModelDeleteErrorEventHandler {
+    type Interface = IEventHandler<ModelDeleteErrorEvent>;
+    type Event = ModelDeleteErrorEvent;
+}

package/features/contentModel/DeleteModel/events.js

@@ -0,0 +1,39 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+
+/**
+ * Event payloads
+ */
+
+/**
+ * ModelBeforeDeleteEvent - Published before deleting a model
+ */
+export class ModelBeforeDeleteEvent extends DomainEvent {
+  eventType = "Cms/Model/BeforeDelete";
+  getHandlerAbstraction() {
+    return ModelBeforeDeleteEventHandler;
+  }
+}
+export const ModelBeforeDeleteEventHandler = createAbstraction("ModelBeforeDeleteEventHandler");
+/**
+ * ModelAfterDeleteEvent - Published after deleting a model
+ */
+export class ModelAfterDeleteEvent extends DomainEvent {
+  eventType = "Cms/Model/AfterDelete";
+  getHandlerAbstraction() {
+    return ModelAfterDeleteEventHandler;
+  }
+}
+export const ModelAfterDeleteEventHandler = createAbstraction("ModelAfterDeleteEventHandler");
+/**
+ * ModelDeleteErrorEvent - Published when delete fails
+ */
+export class ModelDeleteErrorEvent extends DomainEvent {
+  eventType = "Cms/Model/DeleteError";
+  getHandlerAbstraction() {
+    return ModelDeleteErrorEventHandler;
+  }
+}
+export const ModelDeleteErrorEventHandler = createAbstraction("ModelDeleteErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","ModelBeforeDeleteEvent","eventType","getHandlerAbstraction","ModelBeforeDeleteEventHandler","ModelAfterDeleteEvent","ModelAfterDeleteEventHandler","ModelDeleteErrorEvent","ModelDeleteErrorEventHandler"],"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 } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface ModelBeforeDeleteEventPayload {\n    model: CmsModel;\n}\n\nexport interface ModelAfterDeleteEventPayload {\n    model: CmsModel;\n}\n\nexport interface ModelDeleteErrorEventPayload {\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * ModelBeforeDeleteEvent - Published before deleting a model\n */\nexport class ModelBeforeDeleteEvent extends DomainEvent<ModelBeforeDeleteEventPayload> {\n    eventType = \"Cms/Model/BeforeDelete\" as const;\n\n    getHandlerAbstraction() {\n        return ModelBeforeDeleteEventHandler;\n    }\n}\n\nexport const ModelBeforeDeleteEventHandler = createAbstraction<\n    IEventHandler<ModelBeforeDeleteEvent>\n>(\"ModelBeforeDeleteEventHandler\");\n\nexport namespace ModelBeforeDeleteEventHandler {\n    export type Interface = IEventHandler<ModelBeforeDeleteEvent>;\n    export type Event = ModelBeforeDeleteEvent;\n}\n\n/**\n * ModelAfterDeleteEvent - Published after deleting a model\n */\nexport class ModelAfterDeleteEvent extends DomainEvent<ModelAfterDeleteEventPayload> {\n    eventType = \"Cms/Model/AfterDelete\" as const;\n\n    getHandlerAbstraction() {\n        return ModelAfterDeleteEventHandler;\n    }\n}\n\nexport const ModelAfterDeleteEventHandler = createAbstraction<IEventHandler<ModelAfterDeleteEvent>>(\n    \"ModelAfterDeleteEventHandler\"\n);\n\nexport namespace ModelAfterDeleteEventHandler {\n    export type Interface = IEventHandler<ModelAfterDeleteEvent>;\n    export type Event = ModelAfterDeleteEvent;\n}\n\n/**\n * ModelDeleteErrorEvent - Published when delete fails\n */\nexport class ModelDeleteErrorEvent extends DomainEvent<ModelDeleteErrorEventPayload> {\n    eventType = \"Cms/Model/DeleteError\" as const;\n\n    getHandlerAbstraction() {\n        return ModelDeleteErrorEventHandler;\n    }\n}\n\nexport const ModelDeleteErrorEventHandler = createAbstraction<IEventHandler<ModelDeleteErrorEvent>>(\n    \"ModelDeleteErrorEventHandler\"\n);\n\nexport namespace ModelDeleteErrorEventHandler {\n    export type Interface = IEventHandler<ModelDeleteErrorEvent>;\n    export type Event = ModelDeleteErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;;AAGtE;AACA;AACA;;AAcA;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/DeleteModel/feature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * DeleteModel Feature
+ *
+ * Provides functionality for deleting content models.
+ * Includes entry cleanup for singleton models and validation for regular models.
+ */
+export declare const DeleteModelFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentModel/DeleteModel/feature.js

@@ -0,0 +1,26 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteModelUseCase } from "./DeleteModelUseCase.js";
+import { DeleteModelRepository } from "./DeleteModelRepository.js";
+import { DeleteModelWithEntryCleanup } from "./DeleteModelWithEntryCleanup.js";
+
+/**
+ * DeleteModel Feature
+ *
+ * Provides functionality for deleting content models.
+ * Includes entry cleanup for singleton models and validation for regular models.
+ */
+export const DeleteModelFeature = createFeature({
+  name: "DeleteModel",
+  register(container) {
+    // Register core use case
+    container.register(DeleteModelUseCase);
+
+    // Register repository in singleton scope (shared instance)
+    container.register(DeleteModelRepository).inSingletonScope();
+
+    // Register entry cleanup decorator
+    container.registerDecorator(DeleteModelWithEntryCleanup);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","DeleteModelUseCase","DeleteModelRepository","DeleteModelWithEntryCleanup","DeleteModelFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { DeleteModelUseCase } from \"./DeleteModelUseCase.js\";\nimport { DeleteModelRepository } from \"./DeleteModelRepository.js\";\nimport { DeleteModelWithEntryCleanup } from \"./DeleteModelWithEntryCleanup.js\";\n\n/**\n * DeleteModel Feature\n *\n * Provides functionality for deleting content models.\n * Includes entry cleanup for singleton models and validation for regular models.\n */\nexport const DeleteModelFeature = createFeature({\n    name: \"DeleteModel\",\n    register(container) {\n        // Register core use case\n        container.register(DeleteModelUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(DeleteModelRepository).inSingletonScope();\n\n        // Register entry cleanup decorator\n        container.registerDecorator(DeleteModelWithEntryCleanup);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,kBAAkB;AAC3B,SAASC,qBAAqB;AAC9B,SAASC,2BAA2B;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kBAAkB,GAAGJ,aAAa,CAAC;EAC5CK,IAAI,EAAE,aAAa;EACnBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACL,kBAAkB,CAAC;;IAEtC;IACAM,SAAS,CAACD,QAAQ,CAACJ,qBAAqB,CAAC,CAACM,gBAAgB,CAAC,CAAC;;IAE5D;IACAD,SAAS,CAACE,iBAAiB,CAACN,2BAA2B,CAAC;EAC5D;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export { DeleteModelUseCase, DeleteModelRepository } from "./abstractions.js";
+export { ModelAfterDeleteEventHandler, ModelBeforeDeleteEventHandler } from "./events.js";

package/features/contentModel/DeleteModel/index.js

@@ -0,0 +1,4 @@
+export { DeleteModelUseCase, DeleteModelRepository } from "./abstractions.js";
+export { ModelAfterDeleteEventHandler, ModelBeforeDeleteEventHandler } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

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

package/features/contentModel/GetModel/GetModelRepository.d.ts

@@ -0,0 +1,20 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelsFetcher } from "../../../features/contentModel/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * GetModelRepository - Fetches a single model by ID.
+ *
+ * Responsibilities:
+ * - Use ModelsFetcher to get cached models
+ * - Return the model or NotFoundError
+ */
+declare class GetModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private modelsFetcher;
+    constructor(modelsFetcher: ModelsFetcher.Interface);
+    execute(modelId: string): Promise<Result<CmsModel, RepositoryAbstraction.Error>>;
+}
+export declare const GetModelRepository: typeof GetModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetModelRepository>;
+};
+export {};

package/features/contentModel/GetModel/GetModelRepository.js

@@ -0,0 +1,33 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelsFetcher } from "../shared/abstractions.js";
+import { ModelNotFoundError } from "../../../domain/contentModel/errors.js";
+/**
+ * GetModelRepository - Fetches a single model by ID.
+ *
+ * Responsibilities:
+ * - Use ModelsFetcher to get cached models
+ * - Return the model or NotFoundError
+ */
+class GetModelRepositoryImpl {
+  constructor(modelsFetcher) {
+    this.modelsFetcher = modelsFetcher;
+  }
+  async execute(modelId) {
+    const result = await this.modelsFetcher.fetchById(modelId);
+    if (result.isFail()) {
+      return result;
+    }
+    const model = result.value;
+    if (!model) {
+      return Result.fail(new ModelNotFoundError(modelId));
+    }
+    return Result.ok(model);
+  }
+}
+export const GetModelRepository = RepositoryAbstraction.createImplementation({
+  implementation: GetModelRepositoryImpl,
+  dependencies: [ModelsFetcher]
+});
+
+//# sourceMappingURL=GetModelRepository.js.map

package/features/contentModel/GetModel/GetModelRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetModelRepository","RepositoryAbstraction","ModelsFetcher","ModelNotFoundError","GetModelRepositoryImpl","constructor","modelsFetcher","execute","modelId","result","fetchById","isFail","model","value","fail","ok","createImplementation","implementation","dependencies"],"sources":["GetModelRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetModelRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelsFetcher } from \"~/features/contentModel/shared/abstractions.js\";\nimport { ModelNotFoundError } from \"~/domain/contentModel/errors.js\";\nimport type { CmsModel } from \"~/types/index.js\";\n\n/**\n * GetModelRepository - Fetches a single model by ID.\n *\n * Responsibilities:\n * - Use ModelsFetcher to get cached models\n * - Return the model or NotFoundError\n */\nclass GetModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(private modelsFetcher: ModelsFetcher.Interface) {}\n\n    async execute(modelId: string): Promise<Result<CmsModel, RepositoryAbstraction.Error>> {\n        const result = await this.modelsFetcher.fetchById(modelId);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const model = result.value;\n\n        if (!model) {\n            return Result.fail(new ModelNotFoundError(modelId));\n        }\n\n        return Result.ok(model);\n    }\n}\n\nexport const GetModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetModelRepositoryImpl,\n    dependencies: [ModelsFetcher]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,IAAIC,qBAAqB;AACpD,SAASC,aAAa;AACtB,SAASC,kBAAkB;AAG3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,sBAAsB,CAA4C;EAC7DC,WAAWA,CAASC,aAAsC,EAAE;IAAA,KAAxCA,aAAsC,GAAtCA,aAAsC;EAAG;EAEpE,MAAMC,OAAOA,CAACC,OAAe,EAA0D;IACnF,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACH,aAAa,CAACI,SAAS,CAACF,OAAO,CAAC;IAE1D,IAAIC,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOF,MAAM;IACjB;IAEA,MAAMG,KAAK,GAAGH,MAAM,CAACI,KAAK;IAE1B,IAAI,CAACD,KAAK,EAAE;MACR,OAAOb,MAAM,CAACe,IAAI,CAAC,IAAIX,kBAAkB,CAACK,OAAO,CAAC,CAAC;IACvD;IAEA,OAAOT,MAAM,CAACgB,EAAE,CAACH,KAAK,CAAC;EAC3B;AACJ;AAEA,OAAO,MAAMZ,kBAAkB,GAAGC,qBAAqB,CAACe,oBAAoB,CAAC;EACzEC,cAAc,EAAEb,sBAAsB;EACtCc,YAAY,EAAE,CAAChB,aAAa;AAChC,CAAC,CAAC","ignoreList":[]}

package/features/contentModel/GetModel/GetModelUseCase.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetModelRepository } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * GetModelUseCase - Retrieves a single content model by ID.
+ *
+ * Responsibilities:
+ * - Apply initial access control check
+ * - Delegate to repository (which uses ModelCache for plugin + DB models)
+ * - Apply model-specific access control check
+ * - Return the model or appropriate error
+ */
+declare class GetModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    constructor(repository: GetModelRepository.Interface, accessControl: AccessControl.Interface);
+    execute(modelId: string): Promise<Result<CmsModel, UseCaseAbstraction.Error>>;
+}
+export declare const GetModelUseCase: typeof GetModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetModelUseCase>;
+};
+export {};

package/features/contentModel/GetModel/GetModelUseCase.js

@@ -0,0 +1,44 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetModelRepository } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { ModelNotAuthorizedError } from "../../../domain/contentModel/errors.js";
+
+/**
+ * GetModelUseCase - Retrieves a single content model by ID.
+ *
+ * Responsibilities:
+ * - Apply initial access control check
+ * - Delegate to repository (which uses ModelCache for plugin + DB models)
+ * - Apply model-specific access control check
+ * - Return the model or appropriate error
+ */
+class GetModelUseCaseImpl {
+  constructor(repository, accessControl) {
+    this.repository = repository;
+    this.accessControl = accessControl;
+  }
+  async execute(modelId) {
+    const result = await this.repository.execute(modelId);
+    if (result.isFail()) {
+      return result;
+    }
+    const model = result.value;
+
+    // Model-specific access control check
+    const canAccessModel = await this.accessControl.canAccessModel({
+      model,
+      rwd: "r"
+    });
+    if (!canAccessModel) {
+      return Result.fail(ModelNotAuthorizedError.fromModel(model));
+    }
+    return Result.ok(model);
+  }
+}
+export const GetModelUseCase = UseCaseAbstraction.createImplementation({
+  implementation: GetModelUseCaseImpl,
+  dependencies: [GetModelRepository, AccessControl]
+});
+
+//# sourceMappingURL=GetModelUseCase.js.map

package/features/contentModel/GetModel/GetModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetModelUseCase","UseCaseAbstraction","GetModelRepository","AccessControl","ModelNotAuthorizedError","GetModelUseCaseImpl","constructor","repository","accessControl","execute","modelId","result","isFail","model","value","canAccessModel","rwd","fail","fromModel","ok","createImplementation","implementation","dependencies"],"sources":["GetModelUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetModelUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetModelRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { ModelNotAuthorizedError } from \"~/domain/contentModel/errors.js\";\n\n/**\n * GetModelUseCase - Retrieves a single content model by ID.\n *\n * Responsibilities:\n * - Apply initial access control check\n * - Delegate to repository (which uses ModelCache for plugin + DB models)\n * - Apply model-specific access control check\n * - Return the model or appropriate error\n */\nclass GetModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: GetModelRepository.Interface,\n        private accessControl: AccessControl.Interface\n    ) {}\n\n    async execute(modelId: string): Promise<Result<CmsModel, UseCaseAbstraction.Error>> {\n        const result = await this.repository.execute(modelId);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const model = result.value;\n\n        // Model-specific access control check\n        const canAccessModel = await this.accessControl.canAccessModel({ model, rwd: \"r\" });\n        if (!canAccessModel) {\n            return Result.fail(ModelNotAuthorizedError.fromModel(model));\n        }\n\n        return Result.ok(model);\n    }\n}\n\nexport const GetModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetModelUseCaseImpl,\n    dependencies: [GetModelRepository, AccessControl]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,IAAIC,kBAAkB;AAC9C,SAASC,kBAAkB;AAC3B,SAASC,aAAa;AAEtB,SAASC,uBAAuB;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mBAAmB,CAAyC;EACvDC,WAAWA,CACNC,UAAwC,EACxCC,aAAsC,EAChD;IAAA,KAFUD,UAAwC,GAAxCA,UAAwC;IAAA,KACxCC,aAAsC,GAAtCA,aAAsC;EAC/C;EAEH,MAAMC,OAAOA,CAACC,OAAe,EAAuD;IAChF,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,UAAU,CAACE,OAAO,CAACC,OAAO,CAAC;IAErD,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOD,MAAM;IACjB;IAEA,MAAME,KAAK,GAAGF,MAAM,CAACG,KAAK;;IAE1B;IACA,MAAMC,cAAc,GAAG,MAAM,IAAI,CAACP,aAAa,CAACO,cAAc,CAAC;MAAEF,KAAK;MAAEG,GAAG,EAAE;IAAI,CAAC,CAAC;IACnF,IAAI,CAACD,cAAc,EAAE;MACjB,OAAOhB,MAAM,CAACkB,IAAI,CAACb,uBAAuB,CAACc,SAAS,CAACL,KAAK,CAAC,CAAC;IAChE;IAEA,OAAOd,MAAM,CAACoB,EAAE,CAACN,KAAK,CAAC;EAC3B;AACJ;AAEA,OAAO,MAAMb,eAAe,GAAGC,kBAAkB,CAACmB,oBAAoB,CAAC;EACnEC,cAAc,EAAEhB,mBAAmB;EACnCiB,YAAY,EAAE,CAACpB,kBAAkB,EAAEC,aAAa;AACpD,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsModel } from "../../../types/index.js";
+import { ModelNotAuthorizedError, type ModelNotFoundError, type ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+/**
+ * GetModel Use Case
+ */
+export interface IGetModelUseCase {
+    execute(modelId: string): Promise<Result<CmsModel, UseCaseError>>;
+}
+export interface IGetModelUseCaseErrors {
+    notFound: ModelNotFoundError;
+    notAuthorized: ModelNotAuthorizedError;
+    persistence: ModelPersistenceError;
+}
+type UseCaseError = IGetModelUseCaseErrors[keyof IGetModelUseCaseErrors];
+export declare const GetModelUseCase: import("@webiny/di").Abstraction<IGetModelUseCase>;
+export declare namespace GetModelUseCase {
+    type Interface = IGetModelUseCase;
+    type Error = UseCaseError;
+    type Return = Promise<Result<CmsModel, UseCaseError>>;
+}
+/**
+ * GetModelRepository - Fetches a single model by ID from cache.
+ */
+export interface IGetModelRepository {
+    execute(modelId: string): Promise<Result<CmsModel, RepositoryError>>;
+}
+export interface IGetModelRepositoryErrors {
+    notFound: ModelNotFoundError;
+    persistence: ModelPersistenceError;
+}
+type RepositoryError = IGetModelRepositoryErrors[keyof IGetModelRepositoryErrors];
+export declare const GetModelRepository: import("@webiny/di").Abstraction<IGetModelRepository>;
+export declare namespace GetModelRepository {
+    type Interface = IGetModelRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentModel/GetModel/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetModel Use Case
+ */
+
+export const GetModelUseCase = createAbstraction("GetModelUseCase");
+
+/**
+ * GetModelRepository - Fetches a single model by ID from cache.
+ */
+
+export const GetModelRepository = createAbstraction("GetModelRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetModelUseCase","GetModelRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport {\n    ModelNotAuthorizedError,\n    type ModelNotFoundError,\n    type ModelPersistenceError\n} from \"~/domain/contentModel/errors.js\";\n\n/**\n * GetModel Use Case\n */\nexport interface IGetModelUseCase {\n    execute(modelId: string): Promise<Result<CmsModel, UseCaseError>>;\n}\n\nexport interface IGetModelUseCaseErrors {\n    notFound: ModelNotFoundError;\n    notAuthorized: ModelNotAuthorizedError;\n    persistence: ModelPersistenceError;\n}\n\ntype UseCaseError = IGetModelUseCaseErrors[keyof IGetModelUseCaseErrors];\n\nexport const GetModelUseCase = createAbstraction<IGetModelUseCase>(\"GetModelUseCase\");\n\nexport namespace GetModelUseCase {\n    export type Interface = IGetModelUseCase;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<CmsModel, UseCaseError>>;\n}\n\n/**\n * GetModelRepository - Fetches a single model by ID from cache.\n */\nexport interface IGetModelRepository {\n    execute(modelId: string): Promise<Result<CmsModel, RepositoryError>>;\n}\n\nexport interface IGetModelRepositoryErrors {\n    notFound: ModelNotFoundError;\n    persistence: ModelPersistenceError;\n}\n\ntype RepositoryError = IGetModelRepositoryErrors[keyof IGetModelRepositoryErrors];\n\nexport const GetModelRepository = createAbstraction<IGetModelRepository>(\"GetModelRepository\");\n\nexport namespace GetModelRepository {\n    export type Interface = IGetModelRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAQ/D;AACA;AACA;;AAaA,OAAO,MAAMC,eAAe,GAAGD,iBAAiB,CAAmB,iBAAiB,CAAC;;AASrF;AACA;AACA;;AAYA,OAAO,MAAME,kBAAkB,GAAGF,iBAAiB,CAAsB,oBAAoB,CAAC","ignoreList":[]}

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

@@ -0,0 +1,7 @@
+/**
+ * GetModel Feature
+ *
+ * Provides functionality for retrieving a single content model by ID.
+ * Includes caching, plugin model support, and access control filtering.
+ */
+export declare const GetModelFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentModel/GetModel/feature.js

@@ -0,0 +1,22 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetModelUseCase } from "./GetModelUseCase.js";
+import { GetModelRepository } from "./GetModelRepository.js";
+
+/**
+ * GetModel Feature
+ *
+ * Provides functionality for retrieving a single content model by ID.
+ * Includes caching, plugin model support, and access control filtering.
+ */
+export const GetModelFeature = createFeature({
+  name: "GetModel",
+  register(container) {
+    // Register use case in transient scope (new instance per request)
+    container.register(GetModelUseCase);
+
+    // Register repository in singleton scope (shared instance)
+    container.register(GetModelRepository).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetModelUseCase","GetModelRepository","GetModelFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetModelUseCase } from \"./GetModelUseCase.js\";\nimport { GetModelRepository } from \"./GetModelRepository.js\";\n\n/**\n * GetModel Feature\n *\n * Provides functionality for retrieving a single content model by ID.\n * Includes caching, plugin model support, and access control filtering.\n */\nexport const GetModelFeature = createFeature({\n    name: \"GetModel\",\n    register(container) {\n        // Register use case in transient scope (new instance per request)\n        container.register(GetModelUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(GetModelRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,eAAe;AACxB,SAASC,kBAAkB;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,eAAe,GAAGH,aAAa,CAAC;EACzCI,IAAI,EAAE,UAAU;EAChBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACJ,eAAe,CAAC;;IAEnC;IACAK,SAAS,CAACD,QAAQ,CAACH,kBAAkB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAC7D;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export { GetModelUseCase } from "./abstractions.js";

package/features/contentModel/GetModel/index.js

@@ -0,0 +1,3 @@
+export { GetModelUseCase } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["GetModelUseCase"],"sources":["index.ts"],"sourcesContent":["export { GetModelUseCase } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,eAAe","ignoreList":[]}

package/features/contentModel/ListModels/ListModelsRepository.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { ListModelsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelsFetcher } from "../../../features/contentModel/shared/abstractions.js";
+import type { CmsModel, ICmsModelListParams } from "../../../types/index.js";
+/**
+ * ListModelsRepository - Fetches all models with optional filters.
+ *
+ * Responsibilities:
+ * - Use ModelsFetcher to get cached models
+ * - Apply includePrivate and includePlugins filters
+ * - Return all accessible models
+ */
+declare class ListModelsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private modelsFetcher;
+    constructor(modelsFetcher: ModelsFetcher.Interface);
+    execute(params?: ICmsModelListParams): Promise<Result<CmsModel[], RepositoryAbstraction.Error>>;
+}
+export declare const ListModelsRepository: typeof ListModelsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListModelsRepository>;
+};
+export {};

package/features/contentModel/ListModels/ListModelsRepository.js

@@ -0,0 +1,46 @@
+import { Result } from "@webiny/feature/api";
+import { ListModelsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelsFetcher } from "../shared/abstractions.js";
+import { ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+
+/**
+ * ListModelsRepository - Fetches all models with optional filters.
+ *
+ * Responsibilities:
+ * - Use ModelsFetcher to get cached models
+ * - Apply includePrivate and includePlugins filters
+ * - Return all accessible models
+ */
+class ListModelsRepositoryImpl {
+  constructor(modelsFetcher) {
+    this.modelsFetcher = modelsFetcher;
+  }
+  async execute(params) {
+    // Default params
+    const includePrivate = params?.includePrivate !== false; // defaults to true
+    const includePlugins = params?.includePlugins !== false; // defaults to true
+
+    const result = await this.modelsFetcher.fetchAll();
+    if (result.isFail()) {
+      return Result.fail(new ModelPersistenceError(result.error));
+    }
+    let models = result.value;
+
+    // Filter out plugin models if requested
+    if (!includePlugins) {
+      models = models.filter(model => !model.isPlugin);
+    }
+
+    // Filter out private models if requested
+    if (!includePrivate) {
+      models = models.filter(model => model.isPrivate !== true);
+    }
+    return Result.ok(models);
+  }
+}
+export const ListModelsRepository = RepositoryAbstraction.createImplementation({
+  implementation: ListModelsRepositoryImpl,
+  dependencies: [ModelsFetcher]
+});
+
+//# sourceMappingURL=ListModelsRepository.js.map

package/features/contentModel/ListModels/ListModelsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ListModelsRepository","RepositoryAbstraction","ModelsFetcher","ModelPersistenceError","ListModelsRepositoryImpl","constructor","modelsFetcher","execute","params","includePrivate","includePlugins","result","fetchAll","isFail","fail","error","models","value","filter","model","isPlugin","isPrivate","ok","createImplementation","implementation","dependencies"],"sources":["ListModelsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListModelsRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelsFetcher } from \"~/features/contentModel/shared/abstractions.js\";\nimport type { CmsModel, ICmsModelListParams } from \"~/types/index.js\";\nimport { ModelPersistenceError } from \"~/domain/contentModel/errors.js\";\n\n/**\n * ListModelsRepository - Fetches all models with optional filters.\n *\n * Responsibilities:\n * - Use ModelsFetcher to get cached models\n * - Apply includePrivate and includePlugins filters\n * - Return all accessible models\n */\nclass ListModelsRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(private modelsFetcher: ModelsFetcher.Interface) {}\n\n    async execute(\n        params?: ICmsModelListParams\n    ): Promise<Result<CmsModel[], RepositoryAbstraction.Error>> {\n        // Default params\n        const includePrivate = params?.includePrivate !== false; // defaults to true\n        const includePlugins = params?.includePlugins !== false; // defaults to true\n\n        const result = await this.modelsFetcher.fetchAll();\n\n        if (result.isFail()) {\n            return Result.fail(new ModelPersistenceError(result.error));\n        }\n\n        let models = result.value;\n\n        // Filter out plugin models if requested\n        if (!includePlugins) {\n            models = models.filter(model => !model.isPlugin);\n        }\n\n        // Filter out private models if requested\n        if (!includePrivate) {\n            models = models.filter(model => model.isPrivate !== true);\n        }\n\n        return Result.ok(models);\n    }\n}\n\nexport const ListModelsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListModelsRepositoryImpl,\n    dependencies: [ModelsFetcher]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,IAAIC,qBAAqB;AACtD,SAASC,aAAa;AAEtB,SAASC,qBAAqB;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wBAAwB,CAA4C;EAC/DC,WAAWA,CAASC,aAAsC,EAAE;IAAA,KAAxCA,aAAsC,GAAtCA,aAAsC;EAAG;EAEpE,MAAMC,OAAOA,CACTC,MAA4B,EAC4B;IACxD;IACA,MAAMC,cAAc,GAAGD,MAAM,EAAEC,cAAc,KAAK,KAAK,CAAC,CAAC;IACzD,MAAMC,cAAc,GAAGF,MAAM,EAAEE,cAAc,KAAK,KAAK,CAAC,CAAC;;IAEzD,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACL,aAAa,CAACM,QAAQ,CAAC,CAAC;IAElD,IAAID,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOd,MAAM,CAACe,IAAI,CAAC,IAAIX,qBAAqB,CAACQ,MAAM,CAACI,KAAK,CAAC,CAAC;IAC/D;IAEA,IAAIC,MAAM,GAAGL,MAAM,CAACM,KAAK;;IAEzB;IACA,IAAI,CAACP,cAAc,EAAE;MACjBM,MAAM,GAAGA,MAAM,CAACE,MAAM,CAACC,KAAK,IAAI,CAACA,KAAK,CAACC,QAAQ,CAAC;IACpD;;IAEA;IACA,IAAI,CAACX,cAAc,EAAE;MACjBO,MAAM,GAAGA,MAAM,CAACE,MAAM,CAACC,KAAK,IAAIA,KAAK,CAACE,SAAS,KAAK,IAAI,CAAC;IAC7D;IAEA,OAAOtB,MAAM,CAACuB,EAAE,CAACN,MAAM,CAAC;EAC5B;AACJ;AAEA,OAAO,MAAMhB,oBAAoB,GAAGC,qBAAqB,CAACsB,oBAAoB,CAAC;EAC3EC,cAAc,EAAEpB,wBAAwB;EACxCqB,YAAY,EAAE,CAACvB,aAAa;AAChC,CAAC,CAAC","ignoreList":[]}

package/features/contentModel/ListModels/ListModelsUseCase.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { ListModelsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ListModelsRepository } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+import type { ICmsModelListParams } from "../../../types/index.js";
+/**
+ * ListModelsUseCase - Retrieves all content models.
+ *
+ * Responsibilities:
+ * - Apply initial access control check
+ * - Delegate to repository (which uses ModelCache for plugin + DB models)
+ * - Return all accessible models
+ */
+declare class ListModelsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    constructor(repository: ListModelsRepository.Interface, accessControl: AccessControl.Interface);
+    execute(params?: ICmsModelListParams): Promise<Result<CmsModel[], UseCaseAbstraction.Error>>;
+}
+export declare const ListModelsUseCase: typeof ListModelsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListModelsUseCase>;
+};
+export {};

package/features/contentModel/ListModels/ListModelsUseCase.js

@@ -0,0 +1,52 @@
+import { Result } from "@webiny/feature/api";
+import { ListModelsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ListModelsRepository } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { ModelNotAuthorizedError } from "../../../domain/contentModel/errors.js";
+import { filterAsync } from "../../../utils/filterAsync.js";
+
+/**
+ * ListModelsUseCase - Retrieves all content models.
+ *
+ * Responsibilities:
+ * - Apply initial access control check
+ * - Delegate to repository (which uses ModelCache for plugin + DB models)
+ * - Return all accessible models
+ */
+class ListModelsUseCaseImpl {
+  constructor(repository, accessControl) {
+    this.repository = repository;
+    this.accessControl = accessControl;
+  }
+  async execute(params) {
+    // Initial access control check (no specific model yet)
+    const canAccess = await this.accessControl.canAccessModel({
+      rwd: "r"
+    });
+    if (!canAccess) {
+      return Result.fail(new ModelNotAuthorizedError());
+    }
+
+    // Repository uses ModelCache to fetch all models
+    // ModelCache handles merging plugin + database models and access control
+    const result = await this.repository.execute(params);
+    if (result.isFail()) {
+      return result;
+    }
+
+    // Model-specific access control check
+    const filteredModels = await filterAsync(result.value, model => {
+      return this.accessControl.canAccessModel({
+        model,
+        rwd: "r"
+      });
+    });
+    return Result.ok(filteredModels);
+  }
+}
+export const ListModelsUseCase = UseCaseAbstraction.createImplementation({
+  implementation: ListModelsUseCaseImpl,
+  dependencies: [ListModelsRepository, AccessControl]
+});
+
+//# sourceMappingURL=ListModelsUseCase.js.map

package/features/contentModel/ListModels/ListModelsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ListModelsUseCase","UseCaseAbstraction","ListModelsRepository","AccessControl","ModelNotAuthorizedError","filterAsync","ListModelsUseCaseImpl","constructor","repository","accessControl","execute","params","canAccess","canAccessModel","rwd","fail","result","isFail","filteredModels","value","model","ok","createImplementation","implementation","dependencies"],"sources":["ListModelsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListModelsUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { ListModelsRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport type { ICmsModelListParams } from \"~/types/index.js\";\nimport { ModelNotAuthorizedError } from \"~/domain/contentModel/errors.js\";\nimport { filterAsync } from \"~/utils/filterAsync.js\";\n\n/**\n * ListModelsUseCase - Retrieves all content models.\n *\n * Responsibilities:\n * - Apply initial access control check\n * - Delegate to repository (which uses ModelCache for plugin + DB models)\n * - Return all accessible models\n */\nclass ListModelsUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: ListModelsRepository.Interface,\n        private accessControl: AccessControl.Interface\n    ) {}\n\n    async execute(\n        params?: ICmsModelListParams\n    ): Promise<Result<CmsModel[], UseCaseAbstraction.Error>> {\n        // Initial access control check (no specific model yet)\n        const canAccess = await this.accessControl.canAccessModel({ rwd: \"r\" });\n        if (!canAccess) {\n            return Result.fail(new ModelNotAuthorizedError());\n        }\n\n        // Repository uses ModelCache to fetch all models\n        // ModelCache handles merging plugin + database models and access control\n        const result = await this.repository.execute(params);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        // Model-specific access control check\n        const filteredModels = await filterAsync(result.value, model => {\n            return this.accessControl.canAccessModel({ model, rwd: \"r\" });\n        });\n\n        return Result.ok(filteredModels);\n    }\n}\n\nexport const ListModelsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListModelsUseCaseImpl,\n    dependencies: [ListModelsRepository, AccessControl]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,iBAAiB,IAAIC,kBAAkB;AAChD,SAASC,oBAAoB;AAC7B,SAASC,aAAa;AAGtB,SAASC,uBAAuB;AAChC,SAASC,WAAW;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,qBAAqB,CAAyC;EACzDC,WAAWA,CACNC,UAA0C,EAC1CC,aAAsC,EAChD;IAAA,KAFUD,UAA0C,GAA1CA,UAA0C;IAAA,KAC1CC,aAAsC,GAAtCA,aAAsC;EAC/C;EAEH,MAAMC,OAAOA,CACTC,MAA4B,EACyB;IACrD;IACA,MAAMC,SAAS,GAAG,MAAM,IAAI,CAACH,aAAa,CAACI,cAAc,CAAC;MAAEC,GAAG,EAAE;IAAI,CAAC,CAAC;IACvE,IAAI,CAACF,SAAS,EAAE;MACZ,OAAOb,MAAM,CAACgB,IAAI,CAAC,IAAIX,uBAAuB,CAAC,CAAC,CAAC;IACrD;;IAEA;IACA;IACA,MAAMY,MAAM,GAAG,MAAM,IAAI,CAACR,UAAU,CAACE,OAAO,CAACC,MAAM,CAAC;IAEpD,IAAIK,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOD,MAAM;IACjB;;IAEA;IACA,MAAME,cAAc,GAAG,MAAMb,WAAW,CAACW,MAAM,CAACG,KAAK,EAAEC,KAAK,IAAI;MAC5D,OAAO,IAAI,CAACX,aAAa,CAACI,cAAc,CAAC;QAAEO,KAAK;QAAEN,GAAG,EAAE;MAAI,CAAC,CAAC;IACjE,CAAC,CAAC;IAEF,OAAOf,MAAM,CAACsB,EAAE,CAACH,cAAc,CAAC;EACpC;AACJ;AAEA,OAAO,MAAMlB,iBAAiB,GAAGC,kBAAkB,CAACqB,oBAAoB,CAAC;EACrEC,cAAc,EAAEjB,qBAAqB;EACrCkB,YAAY,EAAE,CAACtB,oBAAoB,EAAEC,aAAa;AACtD,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsModel, ICmsModelListParams } from "../../../types/index.js";
+import { ModelNotAuthorizedError, type ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+/**
+ * ListModels Use Case
+ */
+export interface IListModelsUseCase {
+    execute(params?: ICmsModelListParams): Promise<Result<CmsModel[], UseCaseError>>;
+}
+export interface IListModelsUseCaseErrors {
+    notAuthorized: ModelNotAuthorizedError;
+    persistence: ModelPersistenceError;
+}
+type UseCaseError = IListModelsUseCaseErrors[keyof IListModelsUseCaseErrors];
+export declare const ListModelsUseCase: import("@webiny/di").Abstraction<IListModelsUseCase>;
+export declare namespace ListModelsUseCase {
+    type Interface = IListModelsUseCase;
+    type Params = ICmsModelListParams;
+    type Error = UseCaseError;
+    type Return = Promise<Result<CmsModel[], UseCaseError>>;
+}
+/**
+ * ListModelsRepository - Fetches all models from cache.
+ */
+export interface IListModelsRepository {
+    execute(params?: ICmsModelListParams): Promise<Result<CmsModel[], RepositoryError>>;
+}
+export interface IListModelsRepositoryErrors {
+    persistence: ModelPersistenceError;
+}
+type RepositoryError = IListModelsRepositoryErrors[keyof IListModelsRepositoryErrors];
+export declare const ListModelsRepository: import("@webiny/di").Abstraction<IListModelsRepository>;
+export declare namespace ListModelsRepository {
+    type Interface = IListModelsRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentModel/ListModels/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * ListModels Use Case
+ */
+
+export const ListModelsUseCase = createAbstraction("ListModelsUseCase");
+
+/**
+ * ListModelsRepository - Fetches all models from cache.
+ */
+
+export const ListModelsRepository = createAbstraction("ListModelsRepository");
+
+//# sourceMappingURL=abstractions.js.map