@webiny/api-headless-cms 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/features/contentModel/ListModels/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/ListModels/feature.js","sources":["../../../../src/features/contentModel/ListModels/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListModelsUseCase } from \"./ListModelsUseCase.js\";\nimport { ListModelsRepository } from \"./ListModelsRepository.js\";\n\n/**\n * ListModels Feature\n *\n * Provides functionality for retrieving all content models.\n * Includes caching, plugin model support, access control filtering,\n * and options to include/exclude private models and plugin models.\n */\nexport const ListModelsFeature = createFeature({\n    name: \"ListModels\",\n    register(container) {\n        // Register use case in transient scope (new instance per request)\n        container.register(ListModelsUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(ListModelsRepository).inSingletonScope();\n    }\n});\n"],"names":["ListModelsFeature","createFeature","container","ListModelsUseCase","ListModelsRepository"],"mappings":";;;AAWO,MAAMA,oBAAoBC,cAAc;IAC3C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,sBAAsB,gBAAgB;IAC7D;AACJ"}

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

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

package/features/contentModel/ListModels/index.js

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

package/features/contentModel/ModelFieldCompression/ModelFieldCompression.d.ts

@@ -0,0 +1,15 @@
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+import { ModelFieldCompression as ModelFieldCompressionAbstraction } from "./abstractions.js";
+import type { CmsModelField } from "../../../types/index.js";
+import { BuildParams } from "@webiny/api-core/features/buildParams/index.js";
+declare class ModelFieldCompressionImpl implements ModelFieldCompressionAbstraction.Interface {
+    private readonly compressionHandler;
+    private readonly buildParams;
+    constructor(compressionHandler: CompressionHandler.Interface, buildParams: BuildParams.Interface);
+    compress(fields: CmsModelField[]): ModelFieldCompressionAbstraction.CompressResponse;
+    decompress(data: ModelFieldCompressionAbstraction.DecompressParams): ModelFieldCompressionAbstraction.DecompressResponse;
+}
+export declare const ModelFieldCompression: typeof ModelFieldCompressionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IModelFieldCompression>;
+};
+export {};

package/features/contentModel/ModelFieldCompression/ModelFieldCompression.js

@@ -0,0 +1,27 @@
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+import { ModelFieldCompression } from "./abstractions.js";
+import { BuildParams } from "@webiny/api-core/features/buildParams/index.js";
+class ModelFieldCompressionImpl {
+    constructor(compressionHandler, buildParams){
+        this.compressionHandler = compressionHandler;
+        this.buildParams = buildParams;
+    }
+    async compress(fields) {
+        if (!this.buildParams.get("ContentModelFieldCompression")) return fields;
+        return this.compressionHandler.compress(fields);
+    }
+    async decompress(data) {
+        if (Array.isArray(data)) return data;
+        return this.compressionHandler.decompress(data);
+    }
+}
+const ModelFieldCompression_ModelFieldCompression = ModelFieldCompression.createImplementation({
+    implementation: ModelFieldCompressionImpl,
+    dependencies: [
+        CompressionHandler,
+        BuildParams
+    ]
+});
+export { ModelFieldCompression_ModelFieldCompression as ModelFieldCompression };
+
+//# sourceMappingURL=ModelFieldCompression.js.map

package/features/contentModel/ModelFieldCompression/ModelFieldCompression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/ModelFieldCompression/ModelFieldCompression.js","sources":["../../../../src/features/contentModel/ModelFieldCompression/ModelFieldCompression.ts"],"sourcesContent":["import { CompressionHandler } from \"@webiny/utils/exports/api.js\";\nimport { ModelFieldCompression as ModelFieldCompressionAbstraction } from \"./abstractions.js\";\nimport type { CmsModelField } from \"~/types/index.js\";\nimport { BuildParams } from \"@webiny/api-core/features/buildParams/index.js\";\n\nclass ModelFieldCompressionImpl implements ModelFieldCompressionAbstraction.Interface {\n    public constructor(\n        private readonly compressionHandler: CompressionHandler.Interface,\n        private readonly buildParams: BuildParams.Interface\n    ) {}\n\n    public async compress(\n        fields: CmsModelField[]\n    ): ModelFieldCompressionAbstraction.CompressResponse {\n        if (!this.buildParams.get<boolean>(\"ContentModelFieldCompression\")) {\n            return fields;\n        }\n        return this.compressionHandler.compress(fields);\n    }\n\n    public async decompress(\n        data: ModelFieldCompressionAbstraction.DecompressParams\n    ): ModelFieldCompressionAbstraction.DecompressResponse {\n        if (Array.isArray(data)) {\n            return data as CmsModelField[];\n        }\n        return this.compressionHandler.decompress<CmsModelField[]>(data);\n    }\n}\n\nexport const ModelFieldCompression = ModelFieldCompressionAbstraction.createImplementation({\n    implementation: ModelFieldCompressionImpl,\n    dependencies: [CompressionHandler, BuildParams]\n});\n"],"names":["ModelFieldCompressionImpl","compressionHandler","buildParams","fields","data","Array","ModelFieldCompression","ModelFieldCompressionAbstraction","CompressionHandler","BuildParams"],"mappings":";;;AAKA,MAAMA;IACF,YACqBC,kBAAgD,EAChDC,WAAkC,CACrD;aAFmBD,kBAAkB,GAAlBA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAa,SACTC,MAAuB,EAC0B;QACjD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAU,iCAC/B,OAAOA;QAEX,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAACA;IAC5C;IAEA,MAAa,WACTC,IAAuD,EACJ;QACnD,IAAIC,MAAM,OAAO,CAACD,OACd,OAAOA;QAEX,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAkBA;IAC/D;AACJ;AAEO,MAAME,8CAAwBC,sBAAAA,oBAAqD,CAAC;IACvF,gBAAgBP;IAChB,cAAc;QAACQ;QAAoBC;KAAY;AACnD"}

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

@@ -0,0 +1,17 @@
+import type { CmsModelField } from "../../../types/index.js";
+export interface IModelFieldCompressionCompressResult {
+    compression: string;
+    value: string;
+}
+export interface IModelFieldCompression {
+    compress(fields: CmsModelField[]): Promise<IModelFieldCompressionCompressResult | CmsModelField[]>;
+    decompress(data: IModelFieldCompressionCompressResult | CmsModelField[] | unknown): Promise<CmsModelField[]>;
+}
+export declare const ModelFieldCompression: import("@webiny/di").Abstraction<IModelFieldCompression>;
+export declare namespace ModelFieldCompression {
+    type Interface = IModelFieldCompression;
+    type CompressParams = CmsModelField[];
+    type CompressResponse = Promise<IModelFieldCompressionCompressResult | CmsModelField[]>;
+    type DecompressParams = IModelFieldCompressionCompressResult | CmsModelField[] | unknown;
+    type DecompressResponse = Promise<CmsModelField[]>;
+}

package/features/contentModel/ModelFieldCompression/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api/index.js";
+const ModelFieldCompression = createAbstraction("Cms/Model/FieldCompression");
+export { ModelFieldCompression };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/ModelFieldCompression/abstractions.js","sources":["../../../../src/features/contentModel/ModelFieldCompression/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api/index.js\";\nimport type { CmsModelField } from \"~/types/index.js\";\n\nexport interface IModelFieldCompressionCompressResult {\n    compression: string;\n    value: string;\n}\n\nexport interface IModelFieldCompression {\n    compress(\n        fields: CmsModelField[]\n    ): Promise<IModelFieldCompressionCompressResult | CmsModelField[]>;\n    decompress(\n        data: IModelFieldCompressionCompressResult | CmsModelField[] | unknown\n    ): Promise<CmsModelField[]>;\n}\n\nexport const ModelFieldCompression = createAbstraction<IModelFieldCompression>(\n    \"Cms/Model/FieldCompression\"\n);\n\nexport namespace ModelFieldCompression {\n    export type Interface = IModelFieldCompression;\n    export type CompressParams = CmsModelField[];\n    export type CompressResponse = Promise<IModelFieldCompressionCompressResult | CmsModelField[]>;\n    export type DecompressParams = IModelFieldCompressionCompressResult | CmsModelField[] | unknown;\n    export type DecompressResponse = Promise<CmsModelField[]>;\n}\n"],"names":["ModelFieldCompression","createAbstraction"],"mappings":";AAiBO,MAAMA,wBAAwBC,kBACjC"}

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

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

package/features/contentModel/ModelFieldCompression/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { ModelFieldCompression } from "./ModelFieldCompression.js";
+const ModelFieldCompressionFeature = createFeature({
+    name: "Cms/ModelFieldCompression",
+    register (container) {
+        container.register(ModelFieldCompression).inSingletonScope();
+    }
+});
+export { ModelFieldCompressionFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/ModelFieldCompression/feature.js","sources":["../../../../src/features/contentModel/ModelFieldCompression/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ModelFieldCompression } from \"./ModelFieldCompression.js\";\n\nexport const ModelFieldCompressionFeature = createFeature({\n    name: \"Cms/ModelFieldCompression\",\n    register(container) {\n        container.register(ModelFieldCompression).inSingletonScope();\n    }\n});\n"],"names":["ModelFieldCompressionFeature","createFeature","container","ModelFieldCompression"],"mappings":";;AAGO,MAAMA,+BAA+BC,cAAc;IACtD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,uBAAuB,gBAAgB;IAC9D;AACJ"}

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

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

package/features/contentModel/ModelFieldCompression/index.js

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

package/features/contentModel/ModelToAstConverter/ModelToAstConverter.d.ts

@@ -0,0 +1,18 @@
+import { ModelToAstConverter as ConverterAbstraction } from "./abstractions.js";
+import type { CmsModel, CmsModelAst } from "../../../types/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "../../../features/graphql/index.js";
+/**
+ * ModelToAstConverter implementation
+ *
+ * Wraps CmsModelToAstConverter and provides it with field type plugins
+ * for converting models to AST representation (used for GraphQL schema generation)
+ */
+declare class ModelToAstConverterImpl implements ConverterAbstraction.Interface {
+    private readonly registry;
+    constructor(registry: CmsModelFieldToGraphQLRegistry.Interface);
+    toAst(model: CmsModel): CmsModelAst;
+}
+export declare const ModelToAstConverter: typeof ModelToAstConverterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IModelToAstConverter>;
+};
+export {};

package/features/contentModel/ModelToAstConverter/ModelToAstConverter.js

@@ -0,0 +1,22 @@
+import { ModelToAstConverter } from "./abstractions.js";
+import { CmsModelFieldToAstConverterFromPlugins, CmsModelToAstConverter } from "../../../utils/contentModelAst/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "../../graphql/index.js";
+class ModelToAstConverterImpl {
+    constructor(registry){
+        this.registry = registry;
+    }
+    toAst(model) {
+        const fieldTypePlugins = this.registry.getAll();
+        const converter = new CmsModelToAstConverter(new CmsModelFieldToAstConverterFromPlugins(fieldTypePlugins));
+        return converter.toAst(model);
+    }
+}
+const ModelToAstConverter_ModelToAstConverter = ModelToAstConverter.createImplementation({
+    implementation: ModelToAstConverterImpl,
+    dependencies: [
+        CmsModelFieldToGraphQLRegistry
+    ]
+});
+export { ModelToAstConverter_ModelToAstConverter as ModelToAstConverter };
+
+//# sourceMappingURL=ModelToAstConverter.js.map

package/features/contentModel/ModelToAstConverter/ModelToAstConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/ModelToAstConverter/ModelToAstConverter.js","sources":["../../../../src/features/contentModel/ModelToAstConverter/ModelToAstConverter.ts"],"sourcesContent":["import { ModelToAstConverter as ConverterAbstraction } from \"./abstractions.js\";\nimport {\n    CmsModelFieldToAstConverterFromPlugins,\n    CmsModelToAstConverter\n} from \"~/utils/contentModelAst/index.js\";\nimport type { CmsModel, CmsModelAst } from \"~/types/index.js\";\nimport { CmsModelFieldToGraphQLRegistry } from \"~/features/graphql/index.js\";\n\n/**\n * ModelToAstConverter implementation\n *\n * Wraps CmsModelToAstConverter and provides it with field type plugins\n * for converting models to AST representation (used for GraphQL schema generation)\n */\nclass ModelToAstConverterImpl implements ConverterAbstraction.Interface {\n    public constructor(private readonly registry: CmsModelFieldToGraphQLRegistry.Interface) {}\n\n    toAst(model: CmsModel): CmsModelAst {\n        const fieldTypePlugins = this.registry.getAll();\n\n        const converter = new CmsModelToAstConverter(\n            new CmsModelFieldToAstConverterFromPlugins(fieldTypePlugins)\n        );\n\n        return converter.toAst(model);\n    }\n}\n\nexport const ModelToAstConverter = ConverterAbstraction.createImplementation({\n    implementation: ModelToAstConverterImpl,\n    dependencies: [CmsModelFieldToGraphQLRegistry]\n});\n"],"names":["ModelToAstConverterImpl","registry","model","fieldTypePlugins","converter","CmsModelToAstConverter","CmsModelFieldToAstConverterFromPlugins","ModelToAstConverter","ConverterAbstraction","CmsModelFieldToGraphQLRegistry"],"mappings":";;;AAcA,MAAMA;IACF,YAAoCC,QAAkD,CAAE;aAApDA,QAAQ,GAARA;IAAqD;IAEzF,MAAMC,KAAe,EAAe;QAChC,MAAMC,mBAAmB,IAAI,CAAC,QAAQ,CAAC,MAAM;QAE7C,MAAMC,YAAY,IAAIC,uBAClB,IAAIC,uCAAuCH;QAG/C,OAAOC,UAAU,KAAK,CAACF;IAC3B;AACJ;AAEO,MAAMK,0CAAsBC,oBAAAA,oBAAyC,CAAC;IACzE,gBAAgBR;IAChB,cAAc;QAACS;KAA+B;AAClD"}

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

@@ -0,0 +1,12 @@
+import type { CmsModel, CmsModelAst } from "../../../types/index.js";
+/**
+ * Convert model to AST
+ */
+export interface IModelToAstConverter {
+    toAst(model: CmsModel): CmsModelAst;
+}
+export declare const ModelToAstConverter: import("@webiny/di").Abstraction<IModelToAstConverter>;
+export declare namespace ModelToAstConverter {
+    type Interface = IModelToAstConverter;
+    type Return = CmsModelAst;
+}

package/features/contentModel/ModelToAstConverter/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/ModelToAstConverter/abstractions.js","sources":["../../../../src/features/contentModel/ModelToAstConverter/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel, CmsModelAst } from \"~/types/index.js\";\n\n/**\n * Convert model to AST\n */\nexport interface IModelToAstConverter {\n    toAst(model: CmsModel): CmsModelAst;\n}\n\nexport const ModelToAstConverter = createAbstraction<IModelToAstConverter>(\"ModelToAstConverter\");\n\nexport namespace ModelToAstConverter {\n    export type Interface = IModelToAstConverter;\n    export type Return = CmsModelAst;\n}\n"],"names":["ModelToAstConverter","createAbstraction"],"mappings":";AAUO,MAAMA,sBAAsBC,kBAAwC"}

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

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

package/features/contentModel/ModelToAstConverter/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { ModelToAstConverter } from "./ModelToAstConverter.js";
+const ModelToAstConverterFeature = createFeature({
+    name: "ModelToAstConverter",
+    register (container) {
+        container.register(ModelToAstConverter);
+    }
+});
+export { ModelToAstConverterFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/ModelToAstConverter/feature.js","sources":["../../../../src/features/contentModel/ModelToAstConverter/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ModelToAstConverter } from \"./ModelToAstConverter.js\";\n\nexport const ModelToAstConverterFeature = createFeature({\n    name: \"ModelToAstConverter\",\n    register(container) {\n        container.register(ModelToAstConverter);\n    }\n});\n"],"names":["ModelToAstConverterFeature","createFeature","container","ModelToAstConverter"],"mappings":";;AAGO,MAAMA,6BAA6BC,cAAc;IACpD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

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

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/contentModel/ModelToAstConverter/index.js

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/contentModel/RefModelsGenerator/RefModelsGenerator.d.ts

@@ -0,0 +1,19 @@
+import { type IRefModelsGenerator, type RefModelMetadata } from "./abstractions.js";
+import { ModelToAstConverter } from "../ModelToAstConverter/abstractions.js";
+import { ValuesSelectionGenerator } from "../ValuesSelectionGenerator/abstractions.js";
+import { ModelsFetcher } from "../shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+declare class RefModelsGeneratorImpl implements IRefModelsGenerator {
+    private readonly modelToAst;
+    private readonly modelsFetcher;
+    private readonly valuesSelectionGenerator;
+    constructor(modelToAst: ModelToAstConverter.Interface, modelsFetcher: ModelsFetcher.Interface, valuesSelectionGenerator: ValuesSelectionGenerator.Interface);
+    generate(model: CmsModel): Promise<Record<string, RefModelMetadata>>;
+    private collectRefModelIds;
+    private collectFromFieldNode;
+    private collectFromCollectionNode;
+}
+export declare const RefModelsGenerator: typeof RefModelsGeneratorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IRefModelsGenerator>;
+};
+export {};

package/features/contentModel/RefModelsGenerator/RefModelsGenerator.js

@@ -0,0 +1,56 @@
+import { RefModelsGenerator } from "./abstractions.js";
+import { ModelToAstConverter } from "../ModelToAstConverter/abstractions.js";
+import { ValuesSelectionGenerator } from "../ValuesSelectionGenerator/abstractions.js";
+import { ModelsFetcher } from "../shared/abstractions.js";
+class RefModelsGeneratorImpl {
+    constructor(modelToAst, modelsFetcher, valuesSelectionGenerator){
+        this.modelToAst = modelToAst;
+        this.modelsFetcher = modelsFetcher;
+        this.valuesSelectionGenerator = valuesSelectionGenerator;
+    }
+    async generate(model) {
+        const ast = this.modelToAst.toAst(model);
+        const refModelIds = new Set();
+        for (const node of ast.children)this.collectRefModelIds(node, refModelIds);
+        const result = {};
+        for (const modelId of refModelIds){
+            const fetchResult = await this.modelsFetcher.fetchById(modelId);
+            if (fetchResult.isFail()) continue;
+            const refModel = fetchResult.value;
+            const valuesSelection = this.valuesSelectionGenerator.generate(refModel);
+            result[modelId] = {
+                valuesSelection
+            };
+        }
+        return result;
+    }
+    collectRefModelIds(node, modelIds) {
+        if ("field" === node.type) this.collectFromFieldNode(node, modelIds);
+        else if ("collection" === node.type) this.collectFromCollectionNode(node, modelIds);
+    }
+    collectFromFieldNode(node, modelIds) {
+        const { field, children } = node;
+        if ("ref" === field.type) {
+            const models = field.settings?.models;
+            if (Array.isArray(models)) {
+                for (const refModel of models)if (refModel.modelId) modelIds.add(refModel.modelId);
+            }
+            return;
+        }
+        for (const child of children)this.collectRefModelIds(child, modelIds);
+    }
+    collectFromCollectionNode(node, modelIds) {
+        for (const child of node.children)this.collectRefModelIds(child, modelIds);
+    }
+}
+const RefModelsGenerator_RefModelsGenerator = RefModelsGenerator.createImplementation({
+    implementation: RefModelsGeneratorImpl,
+    dependencies: [
+        ModelToAstConverter,
+        ModelsFetcher,
+        ValuesSelectionGenerator
+    ]
+});
+export { RefModelsGenerator_RefModelsGenerator as RefModelsGenerator };
+
+//# sourceMappingURL=RefModelsGenerator.js.map

package/features/contentModel/RefModelsGenerator/RefModelsGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/RefModelsGenerator/RefModelsGenerator.js","sources":["../../../../src/features/contentModel/RefModelsGenerator/RefModelsGenerator.ts"],"sourcesContent":["import {\n    RefModelsGenerator as Abstraction,\n    type IRefModelsGenerator,\n    type RefModelMetadata\n} from \"./abstractions.js\";\nimport { ModelToAstConverter } from \"../ModelToAstConverter/abstractions.js\";\nimport { ValuesSelectionGenerator } from \"../ValuesSelectionGenerator/abstractions.js\";\nimport { ModelsFetcher } from \"../shared/abstractions.js\";\nimport type {\n    CmsModel,\n    CmsModelFieldAstNode,\n    CmsModelFieldAstNodeField,\n    CmsModelFieldAstNodeCollection\n} from \"~/types/index.js\";\n\nclass RefModelsGeneratorImpl implements IRefModelsGenerator {\n    constructor(\n        private readonly modelToAst: ModelToAstConverter.Interface,\n        private readonly modelsFetcher: ModelsFetcher.Interface,\n        private readonly valuesSelectionGenerator: ValuesSelectionGenerator.Interface\n    ) {}\n\n    async generate(model: CmsModel): Promise<Record<string, RefModelMetadata>> {\n        const ast = this.modelToAst.toAst(model);\n        const refModelIds = new Set<string>();\n\n        for (const node of ast.children) {\n            this.collectRefModelIds(node, refModelIds);\n        }\n\n        const result: Record<string, RefModelMetadata> = {};\n\n        for (const modelId of refModelIds) {\n            const fetchResult = await this.modelsFetcher.fetchById(modelId);\n            if (fetchResult.isFail()) {\n                continue;\n            }\n\n            const refModel = fetchResult.value;\n            const valuesSelection = this.valuesSelectionGenerator.generate(refModel);\n\n            result[modelId] = { valuesSelection };\n        }\n\n        return result;\n    }\n\n    private collectRefModelIds(node: CmsModelFieldAstNode, modelIds: Set<string>): void {\n        if (node.type === \"field\") {\n            this.collectFromFieldNode(node, modelIds);\n        } else if (node.type === \"collection\") {\n            this.collectFromCollectionNode(node, modelIds);\n        }\n    }\n\n    private collectFromFieldNode(node: CmsModelFieldAstNodeField, modelIds: Set<string>): void {\n        const { field, children } = node;\n\n        if (field.type === \"ref\") {\n            const models = field.settings?.models;\n            if (Array.isArray(models)) {\n                for (const refModel of models) {\n                    if (refModel.modelId) {\n                        modelIds.add(refModel.modelId);\n                    }\n                }\n            }\n            return;\n        }\n\n        for (const child of children) {\n            this.collectRefModelIds(child, modelIds);\n        }\n    }\n\n    private collectFromCollectionNode(\n        node: CmsModelFieldAstNodeCollection,\n        modelIds: Set<string>\n    ): void {\n        for (const child of node.children) {\n            this.collectRefModelIds(child, modelIds);\n        }\n    }\n}\n\nexport const RefModelsGenerator = Abstraction.createImplementation({\n    implementation: RefModelsGeneratorImpl,\n    dependencies: [ModelToAstConverter, ModelsFetcher, ValuesSelectionGenerator]\n});\n"],"names":["RefModelsGeneratorImpl","modelToAst","modelsFetcher","valuesSelectionGenerator","model","ast","refModelIds","Set","node","result","modelId","fetchResult","refModel","valuesSelection","modelIds","field","children","models","Array","child","RefModelsGenerator","Abstraction","ModelToAstConverter","ModelsFetcher","ValuesSelectionGenerator"],"mappings":";;;;AAeA,MAAMA;IACF,YACqBC,UAAyC,EACzCC,aAAsC,EACtCC,wBAA4D,CAC/E;aAHmBF,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,wBAAwB,GAAxBA;IAClB;IAEH,MAAM,SAASC,KAAe,EAA6C;QACvE,MAAMC,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAACD;QAClC,MAAME,cAAc,IAAIC;QAExB,KAAK,MAAMC,QAAQH,IAAI,QAAQ,CAC3B,IAAI,CAAC,kBAAkB,CAACG,MAAMF;QAGlC,MAAMG,SAA2C,CAAC;QAElD,KAAK,MAAMC,WAAWJ,YAAa;YAC/B,MAAMK,cAAc,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,CAACD;YACvD,IAAIC,YAAY,MAAM,IAClB;YAGJ,MAAMC,WAAWD,YAAY,KAAK;YAClC,MAAME,kBAAkB,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAACD;YAE/DH,MAAM,CAACC,QAAQ,GAAG;gBAAEG;YAAgB;QACxC;QAEA,OAAOJ;IACX;IAEQ,mBAAmBD,IAA0B,EAAEM,QAAqB,EAAQ;QAChF,IAAIN,AAAc,YAAdA,KAAK,IAAI,EACT,IAAI,CAAC,oBAAoB,CAACA,MAAMM;aAC7B,IAAIN,AAAc,iBAAdA,KAAK,IAAI,EAChB,IAAI,CAAC,yBAAyB,CAACA,MAAMM;IAE7C;IAEQ,qBAAqBN,IAA+B,EAAEM,QAAqB,EAAQ;QACvF,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGR;QAE5B,IAAIO,AAAe,UAAfA,MAAM,IAAI,EAAY;YACtB,MAAME,SAASF,MAAM,QAAQ,EAAE;YAC/B,IAAIG,MAAM,OAAO,CAACD,SACd;gBAAA,KAAK,MAAML,YAAYK,OACnB,IAAIL,SAAS,OAAO,EAChBE,SAAS,GAAG,CAACF,SAAS,OAAO;YAErC;YAEJ;QACJ;QAEA,KAAK,MAAMO,SAASH,SAChB,IAAI,CAAC,kBAAkB,CAACG,OAAOL;IAEvC;IAEQ,0BACJN,IAAoC,EACpCM,QAAqB,EACjB;QACJ,KAAK,MAAMK,SAASX,KAAK,QAAQ,CAC7B,IAAI,CAAC,kBAAkB,CAACW,OAAOL;IAEvC;AACJ;AAEO,MAAMM,wCAAqBC,mBAAAA,oBAAgC,CAAC;IAC/D,gBAAgBrB;IAChB,cAAc;QAACsB;QAAqBC;QAAeC;KAAyB;AAChF"}

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

@@ -0,0 +1,11 @@
+import type { CmsModel } from "../../../types/index.js";
+export interface RefModelMetadata {
+    valuesSelection: string;
+}
+export interface IRefModelsGenerator {
+    generate(model: CmsModel): Promise<Record<string, RefModelMetadata>>;
+}
+export declare const RefModelsGenerator: import("@webiny/di").Abstraction<IRefModelsGenerator>;
+export declare namespace RefModelsGenerator {
+    type Interface = IRefModelsGenerator;
+}

package/features/contentModel/RefModelsGenerator/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/RefModelsGenerator/abstractions.js","sources":["../../../../src/features/contentModel/RefModelsGenerator/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"~/types/index.js\";\n\nexport interface RefModelMetadata {\n    valuesSelection: string;\n}\n\nexport interface IRefModelsGenerator {\n    generate(model: CmsModel): Promise<Record<string, RefModelMetadata>>;\n}\n\nexport const RefModelsGenerator = createAbstraction<IRefModelsGenerator>(\"RefModelsGenerator\");\n\nexport namespace RefModelsGenerator {\n    export type Interface = IRefModelsGenerator;\n}\n"],"names":["RefModelsGenerator","createAbstraction"],"mappings":";AAWO,MAAMA,qBAAqBC,kBAAuC"}

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

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

package/features/contentModel/RefModelsGenerator/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { RefModelsGenerator } from "./RefModelsGenerator.js";
+const RefModelsGeneratorFeature = createFeature({
+    name: "RefModelsGenerator",
+    register (container) {
+        container.register(RefModelsGenerator);
+    }
+});
+export { RefModelsGeneratorFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/RefModelsGenerator/feature.js","sources":["../../../../src/features/contentModel/RefModelsGenerator/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { RefModelsGenerator } from \"./RefModelsGenerator.js\";\n\nexport const RefModelsGeneratorFeature = createFeature({\n    name: \"RefModelsGenerator\",\n    register(container) {\n        container.register(RefModelsGenerator);\n    }\n});\n"],"names":["RefModelsGeneratorFeature","createFeature","container","RefModelsGenerator"],"mappings":";;AAGO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

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

@@ -0,0 +1,2 @@
+export { RefModelsGenerator } from "./abstractions.js";
+export { RefModelsGeneratorFeature } from "./feature.js";

package/features/contentModel/RefModelsGenerator/index.js

@@ -0,0 +1,2 @@
+export { RefModelsGenerator } from "./abstractions.js";
+export { RefModelsGeneratorFeature } from "./feature.js";

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

@@ -0,0 +1,30 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelCache, ModelsFetcher } from "../../../features/contentModel/shared/abstractions.js";
+import { CmsContext, StorageOperations } from "../../../features/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+import { ModelFieldCompression } from "../../../features/contentModel/ModelFieldCompression/index.js";
+/**
+ * UpdateModelRepository - Validates domain rules and persists model updates.
+ *
+ * Responsibilities:
+ * - Validate API name endings
+ * - Validate singularApiName uniqueness (excluding current model)
+ * - Validate pluralApiName uniqueness (excluding current model)
+ * - Validate model fields
+ * - Persist to storage
+ * - Clear ModelCache after successful update
+ */
+declare class UpdateModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly modelCache;
+    private readonly modelsFetcher;
+    private readonly storageOperations;
+    private readonly cmsContext;
+    private readonly modelFieldCompression;
+    constructor(modelCache: ModelCache.Interface, modelsFetcher: ModelsFetcher.Interface, storageOperations: StorageOperations.Interface, cmsContext: CmsContext.Interface, modelFieldCompression: ModelFieldCompression.Interface);
+    execute(model: CmsModel, original: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const UpdateModelRepository: typeof UpdateModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateModelRepository>;
+};
+export {};

package/features/contentModel/UpdateModel/UpdateModelRepository.js

@@ -0,0 +1,87 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateModelRepository } from "./abstractions.js";
+import { ModelCache, ModelsFetcher } from "../shared/abstractions.js";
+import { ModelCannotUpdateCodeModelError, ModelPersistenceError, ModelValidationError } from "../../../domain/contentModel/errors.js";
+import { CmsContext, StorageOperations } from "../../shared/abstractions.js";
+import { validateEndingAllowed } from "../../../crud/contentModel/validate/endingAllowed.js";
+import { validateSingularApiName } from "../../../domain/contentModel/validation/singularApiName.js";
+import { validatePluralApiName } from "../../../domain/contentModel/validation/pluralApiName.js";
+import { validateModelFields } from "../../../domain/contentModel/validation/modelFields.js";
+import { ModelFieldCompression } from "../ModelFieldCompression/index.js";
+class UpdateModelRepositoryImpl {
+    constructor(modelCache, modelsFetcher, storageOperations, cmsContext, modelFieldCompression){
+        this.modelCache = modelCache;
+        this.modelsFetcher = modelsFetcher;
+        this.storageOperations = storageOperations;
+        this.cmsContext = cmsContext;
+        this.modelFieldCompression = modelFieldCompression;
+    }
+    async execute(model, original) {
+        try {
+            try {
+                validateEndingAllowed({
+                    model
+                });
+            } catch (error) {
+                return Result.fail(new ModelValidationError({
+                    message: error.message,
+                    data: error.data
+                }));
+            }
+            const modelsResult = await this.cmsContext.security.withoutAuthorization(async ()=>await this.modelsFetcher.fetchAll());
+            if (modelsResult.isFail()) return Result.fail(new ModelPersistenceError(modelsResult.error));
+            const allModels = modelsResult.value;
+            const models = allModels.filter((m)=>m.modelId !== model.modelId);
+            const existingModelResult = await this.modelsFetcher.fetchById(model.modelId);
+            if (existingModelResult.isFail()) return Result.fail(new ModelPersistenceError(existingModelResult.error));
+            if (existingModelResult.value.isPlugin) return Result.fail(new ModelCannotUpdateCodeModelError(model.modelId));
+            try {
+                for (const existingModel of models){
+                    validateSingularApiName({
+                        existingModel,
+                        model
+                    });
+                    validatePluralApiName({
+                        existingModel,
+                        model
+                    });
+                }
+                await validateModelFields({
+                    models,
+                    model,
+                    original,
+                    context: this.cmsContext
+                });
+            } catch (error) {
+                return Result.fail(new ModelValidationError({
+                    message: error.message,
+                    data: error.data
+                }));
+            }
+            const fields = await this.modelFieldCompression.compress(model.fields);
+            await this.storageOperations.models.update({
+                model: {
+                    ...model,
+                    fields
+                }
+            });
+            this.modelCache.clear();
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(new ModelPersistenceError(error));
+        }
+    }
+}
+const UpdateModelRepository_UpdateModelRepository = UpdateModelRepository.createImplementation({
+    implementation: UpdateModelRepositoryImpl,
+    dependencies: [
+        ModelCache,
+        ModelsFetcher,
+        StorageOperations,
+        CmsContext,
+        ModelFieldCompression
+    ]
+});
+export { UpdateModelRepository_UpdateModelRepository as UpdateModelRepository };
+
+//# sourceMappingURL=UpdateModelRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModel/UpdateModel/UpdateModelRepository.js","sources":["../../../../src/features/contentModel/UpdateModel/UpdateModelRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { UpdateModelRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelCache, ModelsFetcher } from \"~/features/contentModel/shared/abstractions.js\";\nimport {\n    ModelCannotUpdateCodeModelError,\n    ModelPersistenceError,\n    ModelValidationError\n} from \"~/domain/contentModel/errors.js\";\nimport { CmsContext, StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { validateEndingAllowed } from \"~/crud/contentModel/validate/endingAllowed.js\";\nimport { validateSingularApiName } from \"~/domain/contentModel/validation/singularApiName.js\";\nimport { validatePluralApiName } from \"~/domain/contentModel/validation/pluralApiName.js\";\nimport { validateModelFields } from \"~/domain/contentModel/validation/modelFields.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { ModelFieldCompression } from \"~/features/contentModel/ModelFieldCompression/index.js\";\n\n/**\n * UpdateModelRepository - Validates domain rules and persists model updates.\n *\n * Responsibilities:\n * - Validate API name endings\n * - Validate singularApiName uniqueness (excluding current model)\n * - Validate pluralApiName uniqueness (excluding current model)\n * - Validate model fields\n * - Persist to storage\n * - Clear ModelCache after successful update\n */\nclass UpdateModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private readonly modelCache: ModelCache.Interface,\n        private readonly modelsFetcher: ModelsFetcher.Interface,\n        private readonly storageOperations: StorageOperations.Interface,\n        private readonly cmsContext: CmsContext.Interface,\n        private readonly modelFieldCompression: ModelFieldCompression.Interface\n    ) {}\n\n    async execute(\n        model: CmsModel,\n        original: CmsModel\n    ): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            // Validate API name endings\n            try {\n                validateEndingAllowed({ model });\n            } catch (error) {\n                return Result.fail(\n                    new ModelValidationError({ message: error.message, data: error.data })\n                );\n            }\n\n            // Get all models for validation (excluding the current model)\n            const modelsResult = await this.cmsContext.security.withoutAuthorization(async () => {\n                return await this.modelsFetcher.fetchAll();\n            });\n\n            if (modelsResult.isFail()) {\n                return Result.fail(new ModelPersistenceError(modelsResult.error));\n            }\n\n            const allModels = modelsResult.value;\n            const models = allModels.filter(m => m.modelId !== model.modelId);\n\n            // Check if this is a plugin model\n            const existingModelResult = await this.modelsFetcher.fetchById(model.modelId);\n            if (existingModelResult.isFail()) {\n                return Result.fail(new ModelPersistenceError(existingModelResult.error));\n            }\n\n            if (existingModelResult.value.isPlugin) {\n                return Result.fail(new ModelCannotUpdateCodeModelError(model.modelId));\n            }\n\n            // Validate uniqueness\n            try {\n                for (const existingModel of models) {\n                    validateSingularApiName({\n                        existingModel,\n                        model\n                    });\n                    validatePluralApiName({\n                        existingModel,\n                        model\n                    });\n                }\n\n                // Validate model fields\n                await validateModelFields({\n                    models,\n                    model,\n                    original,\n                    context: this.cmsContext\n                });\n            } catch (error) {\n                return Result.fail(\n                    new ModelValidationError({ message: error.message, data: error.data })\n                );\n            }\n\n            const fields = await this.modelFieldCompression.compress(model.fields);\n\n            // Persist to storage\n            await this.storageOperations.models.update({\n                model: {\n                    ...model,\n                    fields\n                }\n            });\n\n            // Clear cache\n            this.modelCache.clear();\n\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new ModelPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const UpdateModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateModelRepositoryImpl,\n    dependencies: [ModelCache, ModelsFetcher, StorageOperations, CmsContext, ModelFieldCompression]\n});\n"],"names":["UpdateModelRepositoryImpl","modelCache","modelsFetcher","storageOperations","cmsContext","modelFieldCompression","model","original","validateEndingAllowed","error","Result","ModelValidationError","modelsResult","ModelPersistenceError","allModels","models","m","existingModelResult","ModelCannotUpdateCodeModelError","existingModel","validateSingularApiName","validatePluralApiName","validateModelFields","fields","UpdateModelRepository","RepositoryAbstraction","ModelCache","ModelsFetcher","StorageOperations","CmsContext","ModelFieldCompression"],"mappings":";;;;;;;;;;AA2BA,MAAMA;IACF,YACqBC,UAAgC,EAChCC,aAAsC,EACtCC,iBAA8C,EAC9CC,UAAgC,EAChCC,qBAAsD,CACzE;aALmBJ,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,iBAAiB,GAAjBA;aACAC,UAAU,GAAVA;aACAC,qBAAqB,GAArBA;IAClB;IAEH,MAAM,QACFC,KAAe,EACfC,QAAkB,EACgC;QAClD,IAAI;YAEA,IAAI;gBACAC,sBAAsB;oBAAEF;gBAAM;YAClC,EAAE,OAAOG,OAAO;gBACZ,OAAOC,OAAO,IAAI,CACd,IAAIC,qBAAqB;oBAAE,SAASF,MAAM,OAAO;oBAAE,MAAMA,MAAM,IAAI;gBAAC;YAE5E;YAGA,MAAMG,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,oBAAoB,CAAC,UAC9D,MAAM,IAAI,CAAC,aAAa,CAAC,QAAQ;YAG5C,IAAIA,aAAa,MAAM,IACnB,OAAOF,OAAO,IAAI,CAAC,IAAIG,sBAAsBD,aAAa,KAAK;YAGnE,MAAME,YAAYF,aAAa,KAAK;YACpC,MAAMG,SAASD,UAAU,MAAM,CAACE,CAAAA,IAAKA,EAAE,OAAO,KAAKV,MAAM,OAAO;YAGhE,MAAMW,sBAAsB,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,CAACX,MAAM,OAAO;YAC5E,IAAIW,oBAAoB,MAAM,IAC1B,OAAOP,OAAO,IAAI,CAAC,IAAIG,sBAAsBI,oBAAoB,KAAK;YAG1E,IAAIA,oBAAoB,KAAK,CAAC,QAAQ,EAClC,OAAOP,OAAO,IAAI,CAAC,IAAIQ,gCAAgCZ,MAAM,OAAO;YAIxE,IAAI;gBACA,KAAK,MAAMa,iBAAiBJ,OAAQ;oBAChCK,wBAAwB;wBACpBD;wBACAb;oBACJ;oBACAe,sBAAsB;wBAClBF;wBACAb;oBACJ;gBACJ;gBAGA,MAAMgB,oBAAoB;oBACtBP;oBACAT;oBACAC;oBACA,SAAS,IAAI,CAAC,UAAU;gBAC5B;YACJ,EAAE,OAAOE,OAAO;gBACZ,OAAOC,OAAO,IAAI,CACd,IAAIC,qBAAqB;oBAAE,SAASF,MAAM,OAAO;oBAAE,MAAMA,MAAM,IAAI;gBAAC;YAE5E;YAEA,MAAMc,SAAS,MAAM,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAACjB,MAAM,MAAM;YAGrE,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC;gBACvC,OAAO;oBACH,GAAGA,KAAK;oBACRiB;gBACJ;YACJ;YAGA,IAAI,CAAC,UAAU,CAAC,KAAK;YAErB,OAAOb,OAAO,EAAE;QACpB,EAAE,OAAOD,OAAO;YACZ,OAAOC,OAAO,IAAI,CAAC,IAAIG,sBAAsBJ;QACjD;IACJ;AACJ;AAEO,MAAMe,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBzB;IAChB,cAAc;QAAC0B;QAAYC;QAAeC;QAAmBC;QAAYC;KAAsB;AACnG"}

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

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateModelUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { UpdateModelRepository } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import type { CmsModel } from "../../../types/index.js";
+import type { CmsModelUpdateInput } from "../../../types/index.js";
+import { GetModelUseCase } from "../../../features/contentModel/GetModel/index.js";
+/**
+ * UpdateModelUseCase - Core model update orchestration.
+ *
+ * Responsibilities:
+ * - Validate input (Zod)
+ * - Fetch original model
+ * - Create updated domain model object
+ * - Handle group changes
+ * - Handle field ID changes (title, description, image)
+ * - Access control checks
+ * - Publish before event
+ * - Delegate to repository for validation and persistence
+ * - Publish after event or error event
+ *
+ * Note: Repository handles domain validations (API name uniqueness, field validation, etc.)
+ */
+declare class UpdateModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getModelUseCase;
+    private eventPublisher;
+    private repository;
+    private accessControl;
+    private tenantContext;
+    constructor(getModelUseCase: GetModelUseCase.Interface, eventPublisher: EventPublisher.Interface, repository: UpdateModelRepository.Interface, accessControl: AccessControl.Interface, tenantContext: TenantContext.Interface);
+    execute(modelId: string, input: CmsModelUpdateInput): Promise<Result<CmsModel, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateModelUseCase: typeof UpdateModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateModelUseCase>;
+};
+export {};