@webiny/api-headless-cms 0.0.0-unstable.df6d94b531 → 0.0.0-unstable.df7a8bb475

package/features/contentEntry/UpdateSingletonEntry/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","UpdateSingletonEntryUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsModel,\n    UpdateCmsEntryInput,\n    UpdateCmsEntryOptionsInput\n} from \"~/types/index.js\";\nimport type {\n    EntryLockedError,\n    EntryNotAuthorizedError,\n    EntryNotFoundError,\n    EntryPersistenceError,\n    EntryValidationError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * UpdateSingletonEntry Use Case\n *\n * Updates the singleton entry for a model.\n */\nexport interface IUpdateSingletonEntryUseCase {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        data: UpdateCmsEntryInput<T>,\n        options?: UpdateCmsEntryOptionsInput\n    ): Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\nexport interface IUpdateSingletonEntryUseCaseErrors {\n    notFound: EntryNotFoundError;\n    notAuthorized: EntryNotAuthorizedError;\n    validation: EntryValidationError;\n    persistence: EntryPersistenceError;\n    locked: EntryLockedError;\n}\n\ntype UseCaseError = IUpdateSingletonEntryUseCaseErrors[keyof IUpdateSingletonEntryUseCaseErrors];\n\nexport const UpdateSingletonEntryUseCase = createAbstraction<IUpdateSingletonEntryUseCase>(\n    \"UpdateSingletonEntryUseCase\"\n);\n\nexport namespace UpdateSingletonEntryUseCase {\n    export type Interface = IUpdateSingletonEntryUseCase;\n    export type Input<T extends CmsEntryValues = CmsEntryValues> = UpdateCmsEntryInput<T>;\n    export type Options = UpdateCmsEntryOptionsInput;\n\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<\n        Result<CmsEntry<T>, UseCaseError>\n    >;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAgB/D;AACA;AACA;AACA;AACA;;AAmBA,OAAO,MAAMC,2BAA2B,GAAGD,iBAAiB,CACxD,6BACJ,CAAC","ignoreList":[]}

package/features/contentEntry/UpdateSingletonEntry/feature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * UpdateSingletonEntry Feature
+ *
+ * Provides functionality for updating singleton entries.
+ * Gets the entry (creating if needed) then updates it.
+ */
+export declare const UpdateSingletonEntryFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentEntry/UpdateSingletonEntry/feature.js

@@ -0,0 +1,18 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateSingletonEntryUseCase } from "./UpdateSingletonEntryUseCase.js";
+
+/**
+ * UpdateSingletonEntry Feature
+ *
+ * Provides functionality for updating singleton entries.
+ * Gets the entry (creating if needed) then updates it.
+ */
+export const UpdateSingletonEntryFeature = createFeature({
+  name: "UpdateSingletonEntry",
+  register(container) {
+    // Register use case
+    container.register(UpdateSingletonEntryUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/contentEntry/UpdateSingletonEntry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","UpdateSingletonEntryUseCase","UpdateSingletonEntryFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateSingletonEntryUseCase } from \"./UpdateSingletonEntryUseCase.js\";\n\n/**\n * UpdateSingletonEntry Feature\n *\n * Provides functionality for updating singleton entries.\n * Gets the entry (creating if needed) then updates it.\n */\nexport const UpdateSingletonEntryFeature = createFeature({\n    name: \"UpdateSingletonEntry\",\n    register(container) {\n        // Register use case\n        container.register(UpdateSingletonEntryUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,2BAA2B;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,2BAA2B,GAAGF,aAAa,CAAC;EACrDG,IAAI,EAAE,sBAAsB;EAC5BC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,2BAA2B,CAAC;EACnD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/UpdateSingletonEntry/index.d.ts

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

package/features/contentEntry/UpdateSingletonEntry/index.js

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

package/features/contentEntry/UpdateSingletonEntry/index.js.map

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

package/features/contentEntry/ValidateEntry/ValidateEntryUseCase.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { type IValidateEntryUserCaseExecuteResult, ValidateEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { AccessControl, CmsContext } from "../../../features/shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../../../features/contentEntry/GetRevisionById/index.js";
+import type { CmsEntryValues, CmsModel, UpdateCmsEntryInput } from "../../../types/index.js";
+/**
+ * ValidateEntryUseCase - Orchestrates entry data validation.
+ *
+ * Responsibilities:
+ * - Apply access control
+ * - Optionally get the entry being validated (if id provided)
+ * - Map and clean input data
+ * - Validate data against model field validators
+ * - Return validation results
+ */
+declare class ValidateEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private accessControl;
+    private getRevisionById;
+    private cmsContext;
+    constructor(accessControl: AccessControl.Interface, getRevisionById: GetRevisionByIdUseCase.Interface, cmsContext: CmsContext.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string | null, inputData: UpdateCmsEntryInput<T>): Promise<Result<IValidateEntryUserCaseExecuteResult[], UseCaseAbstraction.Error>>;
+}
+export declare const ValidateEntryUseCase: import("@webiny/di").Implementation<typeof ValidateEntryUseCaseImpl>;
+export {};

package/features/contentEntry/ValidateEntry/ValidateEntryUseCase.js

@@ -0,0 +1,74 @@
+import { createImplementation, Result } from "@webiny/feature/api";
+import { ValidateEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { AccessControl, CmsContext } from "../../shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../GetRevisionById/index.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+import { mapAndCleanUpdatedInputData } from "../../../crud/contentEntry/entryDataFactories/index.js";
+import { validateModelEntryData } from "../../../crud/contentEntry/entryDataValidation.js";
+
+/**
+ * ValidateEntryUseCase - Orchestrates entry data validation.
+ *
+ * Responsibilities:
+ * - Apply access control
+ * - Optionally get the entry being validated (if id provided)
+ * - Map and clean input data
+ * - Validate data against model field validators
+ * - Return validation results
+ */
+class ValidateEntryUseCaseImpl {
+  constructor(accessControl, getRevisionById, cmsContext) {
+    this.accessControl = accessControl;
+    this.getRevisionById = getRevisionById;
+    this.cmsContext = cmsContext;
+  }
+  async execute(model, id, inputData) {
+    // Check access control
+    const canAccess = await this.accessControl.canAccessEntry({
+      model,
+      rwd: "w"
+    });
+    if (!canAccess) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Map and clean input data
+    const input = mapAndCleanUpdatedInputData(model, inputData.values || {});
+
+    // Optionally get the entry being validated
+    let originalEntry = undefined;
+    if (id) {
+      const entryResult = await this.getRevisionById.execute(model, id);
+      if (entryResult.isFail()) {
+        return Result.fail(entryResult.error);
+      }
+      originalEntry = entryResult.value;
+
+      // Check access control on the specific entry
+      const canAccessEntry = await this.accessControl.canAccessEntry({
+        model,
+        entry: originalEntry,
+        rwd: "w"
+      });
+      if (!canAccessEntry) {
+        return Result.fail(EntryNotAuthorizedError.fromModel(model));
+      }
+    }
+
+    // Validate the data
+    const validationResult = await validateModelEntryData({
+      context: this.cmsContext,
+      model,
+      values: input,
+      entry: originalEntry
+    });
+    return Result.ok(validationResult.length > 0 ? validationResult : []);
+  }
+}
+export const ValidateEntryUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: ValidateEntryUseCaseImpl,
+  dependencies: [AccessControl, GetRevisionByIdUseCase, CmsContext]
+});
+
+//# sourceMappingURL=ValidateEntryUseCase.js.map

package/features/contentEntry/ValidateEntry/ValidateEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","Result","ValidateEntryUseCase","UseCaseAbstraction","AccessControl","CmsContext","GetRevisionByIdUseCase","EntryNotAuthorizedError","mapAndCleanUpdatedInputData","validateModelEntryData","ValidateEntryUseCaseImpl","constructor","accessControl","getRevisionById","cmsContext","execute","model","id","inputData","canAccess","canAccessEntry","rwd","fail","fromModel","input","values","originalEntry","undefined","entryResult","isFail","error","value","entry","validationResult","context","ok","length","abstraction","implementation","dependencies"],"sources":["ValidateEntryUseCase.ts"],"sourcesContent":["import { createImplementation, Result } from \"@webiny/feature/api\";\nimport {\n    type IValidateEntryUserCaseExecuteResult,\n    ValidateEntryUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\nimport { AccessControl, CmsContext } from \"~/features/shared/abstractions.js\";\nimport { GetRevisionByIdUseCase } from \"~/features/contentEntry/GetRevisionById/index.js\";\nimport type { CmsEntryValues, CmsModel, UpdateCmsEntryInput } from \"~/types/index.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { mapAndCleanUpdatedInputData } from \"~/crud/contentEntry/entryDataFactories/index.js\";\nimport { validateModelEntryData } from \"~/crud/contentEntry/entryDataValidation.js\";\n\n/**\n * ValidateEntryUseCase - Orchestrates entry data validation.\n *\n * Responsibilities:\n * - Apply access control\n * - Optionally get the entry being validated (if id provided)\n * - Map and clean input data\n * - Validate data against model field validators\n * - Return validation results\n */\nclass ValidateEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private accessControl: AccessControl.Interface,\n        private getRevisionById: GetRevisionByIdUseCase.Interface,\n        private cmsContext: CmsContext.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string | null,\n        inputData: UpdateCmsEntryInput<T>\n    ): Promise<Result<IValidateEntryUserCaseExecuteResult[], UseCaseAbstraction.Error>> {\n        // Check access control\n        const canAccess = await this.accessControl.canAccessEntry({ model, rwd: \"w\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Map and clean input data\n        const input = mapAndCleanUpdatedInputData<T>(model, inputData.values || ({} as T));\n\n        // Optionally get the entry being validated\n        let originalEntry = undefined;\n        if (id) {\n            const entryResult = await this.getRevisionById.execute(model, id);\n\n            if (entryResult.isFail()) {\n                return Result.fail(entryResult.error);\n            }\n\n            originalEntry = entryResult.value;\n\n            // Check access control on the specific entry\n            const canAccessEntry = await this.accessControl.canAccessEntry({\n                model,\n                entry: originalEntry,\n                rwd: \"w\"\n            });\n\n            if (!canAccessEntry) {\n                return Result.fail(EntryNotAuthorizedError.fromModel(model));\n            }\n        }\n\n        // Validate the data\n        const validationResult = await validateModelEntryData({\n            context: this.cmsContext,\n            model,\n            values: input,\n            entry: originalEntry\n        });\n\n        return Result.ok(validationResult.length > 0 ? validationResult : []);\n    }\n}\n\nexport const ValidateEntryUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: ValidateEntryUseCaseImpl,\n    dependencies: [AccessControl, GetRevisionByIdUseCase, CmsContext]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,EAAEC,MAAM,QAAQ,qBAAqB;AAClE,SAEIC,oBAAoB,IAAIC,kBAAkB;AAE9C,SAASC,aAAa,EAAEC,UAAU;AAClC,SAASC,sBAAsB;AAE/B,SAASC,uBAAuB;AAChC,SAASC,2BAA2B;AACpC,SAASC,sBAAsB;;AAE/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wBAAwB,CAAyC;EAC5DC,WAAWA,CACNC,aAAsC,EACtCC,eAAiD,EACjDC,UAAgC,EAC1C;IAAA,KAHUF,aAAsC,GAAtCA,aAAsC;IAAA,KACtCC,eAAiD,GAAjDA,eAAiD;IAAA,KACjDC,UAAgC,GAAhCA,UAAgC;EACzC;EAEH,MAAaC,OAAOA,CAChBC,KAAe,EACfC,EAAiB,EACjBC,SAAiC,EAC+C;IAChF;IACA,MAAMC,SAAS,GAAG,MAAM,IAAI,CAACP,aAAa,CAACQ,cAAc,CAAC;MAAEJ,KAAK;MAAEK,GAAG,EAAE;IAAI,CAAC,CAAC;IAC9E,IAAI,CAACF,SAAS,EAAE;MACZ,OAAOlB,MAAM,CAACqB,IAAI,CAACf,uBAAuB,CAACgB,SAAS,CAACP,KAAK,CAAC,CAAC;IAChE;;IAEA;IACA,MAAMQ,KAAK,GAAGhB,2BAA2B,CAAIQ,KAAK,EAAEE,SAAS,CAACO,MAAM,IAAK,CAAC,CAAO,CAAC;;IAElF;IACA,IAAIC,aAAa,GAAGC,SAAS;IAC7B,IAAIV,EAAE,EAAE;MACJ,MAAMW,WAAW,GAAG,MAAM,IAAI,CAACf,eAAe,CAACE,OAAO,CAACC,KAAK,EAAEC,EAAE,CAAC;MAEjE,IAAIW,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;QACtB,OAAO5B,MAAM,CAACqB,IAAI,CAACM,WAAW,CAACE,KAAK,CAAC;MACzC;MAEAJ,aAAa,GAAGE,WAAW,CAACG,KAAK;;MAEjC;MACA,MAAMX,cAAc,GAAG,MAAM,IAAI,CAACR,aAAa,CAACQ,cAAc,CAAC;QAC3DJ,KAAK;QACLgB,KAAK,EAAEN,aAAa;QACpBL,GAAG,EAAE;MACT,CAAC,CAAC;MAEF,IAAI,CAACD,cAAc,EAAE;QACjB,OAAOnB,MAAM,CAACqB,IAAI,CAACf,uBAAuB,CAACgB,SAAS,CAACP,KAAK,CAAC,CAAC;MAChE;IACJ;;IAEA;IACA,MAAMiB,gBAAgB,GAAG,MAAMxB,sBAAsB,CAAC;MAClDyB,OAAO,EAAE,IAAI,CAACpB,UAAU;MACxBE,KAAK;MACLS,MAAM,EAAED,KAAK;MACbQ,KAAK,EAAEN;IACX,CAAC,CAAC;IAEF,OAAOzB,MAAM,CAACkC,EAAE,CAACF,gBAAgB,CAACG,MAAM,GAAG,CAAC,GAAGH,gBAAgB,GAAG,EAAE,CAAC;EACzE;AACJ;AAEA,OAAO,MAAM/B,oBAAoB,GAAGF,oBAAoB,CAAC;EACrDqC,WAAW,EAAElC,kBAAkB;EAC/BmC,cAAc,EAAE5B,wBAAwB;EACxC6B,YAAY,EAAE,CAACnC,aAAa,EAAEE,sBAAsB,EAAED,UAAU;AACpE,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/ValidateEntry/abstractions.d.ts

@@ -0,0 +1,32 @@
+import type { Result } from "@webiny/feature/api";
+import type { CmsEntryValues, CmsModel, UpdateCmsEntryInput } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryNotFoundError } from "../../../domain/contentEntry/errors.js";
+import { GetRevisionByIdUseCase } from "../../../features/contentEntry/GetRevisionById/index.js";
+export interface IValidateEntryUserCaseExecuteResult {
+    error: string;
+    id: string;
+    fieldId: string;
+    parents: string[];
+}
+/**
+ * ValidateEntry Use Case - Validates entry data against model field validators.
+ * This can be used to validate data before creating or updating an entry.
+ */
+export type IValidateEntryUseCaseExecuteResult = Promise<Result<IValidateEntryUserCaseExecuteResult[], UseCaseError>>;
+export interface IValidateEntryUseCase {
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string | null | undefined, input: UpdateCmsEntryInput<T>): IValidateEntryUseCaseExecuteResult;
+}
+export interface IValidateEntryUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    notFound: EntryNotFoundError;
+    getRevisionById: GetRevisionByIdUseCase.Error;
+}
+type UseCaseError = IValidateEntryUseCaseErrors[keyof IValidateEntryUseCaseErrors];
+export declare const ValidateEntryUseCase: import("@webiny/di").Abstraction<IValidateEntryUseCase>;
+export declare namespace ValidateEntryUseCase {
+    type Interface = IValidateEntryUseCase;
+    type Input<T extends CmsEntryValues = CmsEntryValues> = UpdateCmsEntryInput<T>;
+    type Error = UseCaseError;
+    type Return = IValidateEntryUseCaseExecuteResult;
+}
+export {};

package/features/contentEntry/ValidateEntry/abstractions.js

@@ -0,0 +1,10 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * ValidateEntry Use Case - Validates entry data against model field validators.
+ * This can be used to validate data before creating or updating an entry.
+ */
+
+export const ValidateEntryUseCase = createAbstraction("ValidateEntryUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/contentEntry/ValidateEntry/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ValidateEntryUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import type { Result } from \"@webiny/feature/api\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsEntryValues, CmsModel, UpdateCmsEntryInput } from \"~/types/index.js\";\nimport type { EntryNotAuthorizedError, EntryNotFoundError } from \"~/domain/contentEntry/errors.js\";\nimport { GetRevisionByIdUseCase } from \"~/features/contentEntry/GetRevisionById/index.js\";\n\nexport interface IValidateEntryUserCaseExecuteResult {\n    error: string;\n    id: string;\n    fieldId: string;\n    parents: string[];\n}\n/**\n * ValidateEntry Use Case - Validates entry data against model field validators.\n * This can be used to validate data before creating or updating an entry.\n */\n\nexport type IValidateEntryUseCaseExecuteResult = Promise<\n    Result<IValidateEntryUserCaseExecuteResult[], UseCaseError>\n>;\nexport interface IValidateEntryUseCase {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string | null | undefined,\n        input: UpdateCmsEntryInput<T>\n    ): IValidateEntryUseCaseExecuteResult;\n}\n\nexport interface IValidateEntryUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    notFound: EntryNotFoundError;\n    getRevisionById: GetRevisionByIdUseCase.Error;\n}\n\ntype UseCaseError = IValidateEntryUseCaseErrors[keyof IValidateEntryUseCaseErrors];\n\nexport const ValidateEntryUseCase =\n    createAbstraction<IValidateEntryUseCase>(\"ValidateEntryUseCase\");\n\nexport namespace ValidateEntryUseCase {\n    export type Interface = IValidateEntryUseCase;\n    export type Input<T extends CmsEntryValues = CmsEntryValues> = UpdateCmsEntryInput<T>;\n\n    export type Error = UseCaseError;\n    export type Return = IValidateEntryUseCaseExecuteResult;\n}\n"],"mappings":"AACA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAWvD;AACA;AACA;AACA;;AAqBA,OAAO,MAAMC,oBAAoB,GAC7BD,iBAAiB,CAAwB,sBAAsB,CAAC","ignoreList":[]}

package/features/contentEntry/ValidateEntry/feature.d.ts

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

package/features/contentEntry/ValidateEntry/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { ValidateEntryUseCase } from "./ValidateEntryUseCase.js";
+export const ValidateEntryFeature = createFeature({
+  name: "ValidateEntry",
+  register(container) {
+    // Register use case (transient scope)
+    container.register(ValidateEntryUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/contentEntry/ValidateEntry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ValidateEntryUseCase","ValidateEntryFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ValidateEntryUseCase } from \"./ValidateEntryUseCase.js\";\n\nexport const ValidateEntryFeature = createFeature({\n    name: \"ValidateEntry\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(ValidateEntryUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,oBAAoB;AAE7B,OAAO,MAAMC,oBAAoB,GAAGF,aAAa,CAAC;EAC9CG,IAAI,EAAE,eAAe;EACrBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,oBAAoB,CAAC;EAC5C;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/ValidateEntry/index.d.ts

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

package/features/contentEntry/ValidateEntry/index.js

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

package/features/contentEntry/ValidateEntry/index.js.map

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

package/features/contentModel/ContentModelFeature.d.ts

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

package/features/contentModel/ContentModelFeature.js

@@ -0,0 +1,33 @@
+import { createFeature } from "@webiny/feature/api";
+import { createMemoryCache } from "../../utils/index.js";
+import { PluginModelsProvider } from "./shared/PluginModelsProvider.js";
+import { ModelCache } from "./shared/abstractions.js";
+import { ModelsFetcher } from "./shared/ModelsFetcher.js";
+import { CreateModelFeature } from "./CreateModel/feature.js";
+import { CreateModelFromFeature } from "./CreateModelFrom/feature.js";
+import { UpdateModelFeature } from "./UpdateModel/feature.js";
+import { DeleteModelFeature } from "./DeleteModel/feature.js";
+import { GetModelFeature } from "./GetModel/feature.js";
+import { ListModelsFeature } from "./ListModels/feature.js";
+import { ModelToAstConverterFeature } from "./ModelToAstConverter/feature.js";
+export const ContentModelFeature = createFeature({
+  name: "ContentModel",
+  register(container) {
+    container.registerInstance(ModelCache, createMemoryCache());
+    container.register(PluginModelsProvider).inSingletonScope();
+    container.register(ModelsFetcher).inSingletonScope();
+    ModelToAstConverterFeature.register(container);
+
+    // Query features
+    GetModelFeature.register(container);
+    ListModelsFeature.register(container);
+
+    // Command features
+    CreateModelFeature.register(container);
+    CreateModelFromFeature.register(container);
+    UpdateModelFeature.register(container);
+    DeleteModelFeature.register(container);
+  }
+});
+
+//# sourceMappingURL=ContentModelFeature.js.map

package/features/contentModel/ContentModelFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","createMemoryCache","PluginModelsProvider","ModelCache","ModelsFetcher","CreateModelFeature","CreateModelFromFeature","UpdateModelFeature","DeleteModelFeature","GetModelFeature","ListModelsFeature","ModelToAstConverterFeature","ContentModelFeature","name","register","container","registerInstance","inSingletonScope"],"sources":["ContentModelFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { createMemoryCache } from \"~/utils/index.js\";\nimport { PluginModelsProvider } from \"~/features/contentModel/shared/PluginModelsProvider.js\";\nimport { ModelCache } from \"~/features/contentModel/shared/abstractions.js\";\nimport { ModelsFetcher } from \"~/features/contentModel/shared/ModelsFetcher.js\";\nimport { CreateModelFeature } from \"~/features/contentModel/CreateModel/feature.js\";\nimport { CreateModelFromFeature } from \"~/features/contentModel/CreateModelFrom/feature.js\";\nimport { UpdateModelFeature } from \"~/features/contentModel/UpdateModel/feature.js\";\nimport { DeleteModelFeature } from \"~/features/contentModel/DeleteModel/feature.js\";\nimport { GetModelFeature } from \"~/features/contentModel/GetModel/feature.js\";\nimport { ListModelsFeature } from \"~/features/contentModel/ListModels/feature.js\";\nimport { ModelToAstConverterFeature } from \"~/features/contentModel/ModelToAstConverter/feature.js\";\n\nexport const ContentModelFeature = createFeature({\n    name: \"ContentModel\",\n    register(container) {\n        container.registerInstance(ModelCache, createMemoryCache());\n        container.register(PluginModelsProvider).inSingletonScope();\n        container.register(ModelsFetcher).inSingletonScope();\n\n        ModelToAstConverterFeature.register(container);\n\n        // Query features\n        GetModelFeature.register(container);\n        ListModelsFeature.register(container);\n\n        // Command features\n        CreateModelFeature.register(container);\n        CreateModelFromFeature.register(container);\n        UpdateModelFeature.register(container);\n        DeleteModelFeature.register(container);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,iBAAiB;AAC1B,SAASC,oBAAoB;AAC7B,SAASC,UAAU;AACnB,SAASC,aAAa;AACtB,SAASC,kBAAkB;AAC3B,SAASC,sBAAsB;AAC/B,SAASC,kBAAkB;AAC3B,SAASC,kBAAkB;AAC3B,SAASC,eAAe;AACxB,SAASC,iBAAiB;AAC1B,SAASC,0BAA0B;AAEnC,OAAO,MAAMC,mBAAmB,GAAGZ,aAAa,CAAC;EAC7Ca,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACC,gBAAgB,CAACb,UAAU,EAAEF,iBAAiB,CAAC,CAAC,CAAC;IAC3Dc,SAAS,CAACD,QAAQ,CAACZ,oBAAoB,CAAC,CAACe,gBAAgB,CAAC,CAAC;IAC3DF,SAAS,CAACD,QAAQ,CAACV,aAAa,CAAC,CAACa,gBAAgB,CAAC,CAAC;IAEpDN,0BAA0B,CAACG,QAAQ,CAACC,SAAS,CAAC;;IAE9C;IACAN,eAAe,CAACK,QAAQ,CAACC,SAAS,CAAC;IACnCL,iBAAiB,CAACI,QAAQ,CAACC,SAAS,CAAC;;IAErC;IACAV,kBAAkB,CAACS,QAAQ,CAACC,SAAS,CAAC;IACtCT,sBAAsB,CAACQ,QAAQ,CAACC,SAAS,CAAC;IAC1CR,kBAAkB,CAACO,QAAQ,CAACC,SAAS,CAAC;IACtCP,kBAAkB,CAACM,QAAQ,CAACC,SAAS,CAAC;EAC1C;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import { CreateModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelCache } from "../../../features/contentModel/shared/abstractions.js";
+import { PluginModelsProvider } from "../../../features/contentModel/shared/abstractions.js";
+import { ListModelsUseCase } from "../../../features/contentModel/ListModels/index.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+import { CmsContext } from "../../../features/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * CreateModelRepository - Validates domain rules and persists a new model.
+ *
+ * Responsibilities:
+ * - Generate modelId from input
+ * - Validate modelId is allowed (not in disallowed list)
+ * - Validate API name endings
+ * - Validate modelId uniqueness (database + plugins)
+ * - Validate API name uniqueness (database + plugins)
+ * - Validate plugin conflicts
+ * - Validate model fields
+ * - Persist to storage
+ * - Clear ModelCache after successful create
+ */
+declare class CreateModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private modelCache;
+    private pluginModelsProvider;
+    private listModelsUseCase;
+    private storageOperations;
+    private tenantContext;
+    private cmsContext;
+    constructor(modelCache: ModelCache.Interface, pluginModelsProvider: PluginModelsProvider.Interface, listModelsUseCase: ListModelsUseCase.Interface, storageOperations: StorageOperations.Interface, tenantContext: TenantContext.Interface, cmsContext: CmsContext.Interface);
+    execute(model: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const CreateModelRepository: typeof CreateModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateModelRepository>;
+};
+export {};

package/features/contentModel/CreateModel/CreateModelRepository.js

@@ -0,0 +1,166 @@
+import camelCase from "lodash/camelCase.js";
+import { Result } from "@webiny/feature/api";
+import { CreateModelRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ModelCache } from "../shared/abstractions.js";
+import { PluginModelsProvider } from "../shared/abstractions.js";
+import { ListModelsUseCase } from "../ListModels/index.js";
+import { ModelAlreadyExistsError } from "../../../domain/contentModel/errors.js";
+import { ModelPersistenceError } from "../../../domain/contentModel/errors.js";
+import { ModelValidationError } from "../../../domain/contentModel/errors.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+import { CmsContext } from "../../shared/abstractions.js";
+import { validateExistingModelId, validateModelIdAllowed } from "../../../crud/contentModel/validate/modelId.js";
+import { validateEndingAllowed } from "../../../crud/contentModel/validate/endingAllowed.js";
+import { ensureTypeTag } from "../../../domain/contentModel/ensureTypeTag.js";
+import { validateSingularApiName } from "../../../domain/contentModel/validation/singularApiName.js";
+import { validatePluralApiName } from "../../../domain/contentModel/validation/pluralApiName.js";
+import { validateModelFields } from "../../../domain/contentModel/validation/modelFields.js";
+
+/**
+ * Generate modelId from model following the exact logic from beforeCreate.ts
+ */
+const getModelId = model => {
+  const {
+    modelId,
+    name
+  } = model;
+  const value = modelId ? modelId.trim() : null;
+  if (value) {
+    const isModelIdValid = camelCase(value).toLowerCase() === value.toLowerCase();
+    if (isModelIdValid) {
+      return value;
+    }
+    return camelCase(value);
+  } else if (name) {
+    return camelCase(name.trim());
+  }
+  throw new ModelValidationError(`There is no "modelId" or "name" passed into the create model method.`);
+};
+
+/**
+ * CreateModelRepository - Validates domain rules and persists a new model.
+ *
+ * Responsibilities:
+ * - Generate modelId from input
+ * - Validate modelId is allowed (not in disallowed list)
+ * - Validate API name endings
+ * - Validate modelId uniqueness (database + plugins)
+ * - Validate API name uniqueness (database + plugins)
+ * - Validate plugin conflicts
+ * - Validate model fields
+ * - Persist to storage
+ * - Clear ModelCache after successful create
+ */
+class CreateModelRepositoryImpl {
+  constructor(modelCache, pluginModelsProvider, listModelsUseCase, storageOperations, tenantContext, cmsContext) {
+    this.modelCache = modelCache;
+    this.pluginModelsProvider = pluginModelsProvider;
+    this.listModelsUseCase = listModelsUseCase;
+    this.storageOperations = storageOperations;
+    this.tenantContext = tenantContext;
+    this.cmsContext = cmsContext;
+  }
+  async execute(model) {
+    try {
+      const tenant = this.tenantContext.getTenant();
+
+      // TODO: this will eventually become part of the Model domain object.
+      const modelId = getModelId(model);
+      model.modelId = modelId;
+
+      // Validate modelId is allowed (not in disallowed list)
+      try {
+        validateModelIdAllowed({
+          model
+        });
+      } catch (error) {
+        return Result.fail(new ModelValidationError({
+          message: error.message,
+          data: error.data
+        }));
+      }
+
+      // Validate API name endings
+      try {
+        validateEndingAllowed({
+          model
+        });
+      } catch (error) {
+        return Result.fail(new ModelValidationError({
+          message: error.message,
+          data: error.data
+        }));
+      }
+
+      // Check for plugin model conflicts
+      const pluginModels = await this.pluginModelsProvider.list(tenant.id);
+      const pluginModelConflict = pluginModels.find(pm => {
+        return pm.modelId === model.modelId;
+      });
+      if (pluginModelConflict) {
+        return Result.fail(new ModelAlreadyExistsError({
+          modelId,
+          message: `Model "${modelId}" is already registered via a plugin.`
+        }));
+      }
+
+      // Get all models for further validation
+      const modelsResult = await this.listModelsUseCase.execute();
+      if (modelsResult.isFail()) {
+        return Result.fail(new ModelPersistenceError(modelsResult.error));
+      }
+      const models = modelsResult.value;
+      try {
+        /**
+         * We need to check for the existence of:
+         * - modelId
+         * - singularApiName
+         * - pluralApiName
+         */
+        for (const existingModel of models) {
+          validateExistingModelId({
+            existingModel,
+            model
+          });
+          validateSingularApiName({
+            existingModel,
+            model
+          });
+          validatePluralApiName({
+            existingModel,
+            model
+          });
+        }
+        await validateModelFields({
+          models,
+          model,
+          context: this.cmsContext
+        });
+      } catch (error) {
+        return Result.fail(new ModelValidationError(error.message));
+      }
+
+      // TODO: ideally, this will eventually be handled by the Model domain object
+      model.tags = ensureTypeTag(model);
+
+      // Persist to storage
+      await this.storageOperations.models.create({
+        model
+      });
+
+      // Clear cache
+      this.modelCache.clear();
+      return Result.ok();
+    } catch (error) {
+      console.error(error, error.stack);
+      return Result.fail(new ModelPersistenceError(error));
+    }
+  }
+}
+export const CreateModelRepository = RepositoryAbstraction.createImplementation({
+  implementation: CreateModelRepositoryImpl,
+  dependencies: [ModelCache, PluginModelsProvider, ListModelsUseCase, StorageOperations, TenantContext, CmsContext]
+});
+
+//# sourceMappingURL=CreateModelRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["camelCase","Result","CreateModelRepository","RepositoryAbstraction","ModelCache","PluginModelsProvider","ListModelsUseCase","ModelAlreadyExistsError","ModelPersistenceError","ModelValidationError","StorageOperations","TenantContext","CmsContext","validateExistingModelId","validateModelIdAllowed","validateEndingAllowed","ensureTypeTag","validateSingularApiName","validatePluralApiName","validateModelFields","getModelId","model","modelId","name","value","trim","isModelIdValid","toLowerCase","CreateModelRepositoryImpl","constructor","modelCache","pluginModelsProvider","listModelsUseCase","storageOperations","tenantContext","cmsContext","execute","tenant","getTenant","error","fail","message","data","pluginModels","list","id","pluginModelConflict","find","pm","modelsResult","isFail","models","existingModel","context","tags","create","clear","ok","console","stack","createImplementation","implementation","dependencies"],"sources":["CreateModelRepository.ts"],"sourcesContent":["import camelCase from \"lodash/camelCase.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { CreateModelRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ModelCache } from \"~/features/contentModel/shared/abstractions.js\";\nimport { PluginModelsProvider } from \"~/features/contentModel/shared/abstractions.js\";\nimport { ListModelsUseCase } from \"~/features/contentModel/ListModels/index.js\";\nimport { ModelAlreadyExistsError } from \"~/domain/contentModel/errors.js\";\nimport { ModelPersistenceError } from \"~/domain/contentModel/errors.js\";\nimport { ModelValidationError } from \"~/domain/contentModel/errors.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/TenantContext\";\nimport { CmsContext } from \"~/features/shared/abstractions.js\";\nimport {\n    validateExistingModelId,\n    validateModelIdAllowed\n} from \"~/crud/contentModel/validate/modelId.js\";\nimport { validateEndingAllowed } from \"~/crud/contentModel/validate/endingAllowed.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { ensureTypeTag } from \"~/domain/contentModel/ensureTypeTag.js\";\nimport { validateSingularApiName } from \"~/domain/contentModel/validation/singularApiName.js\";\nimport { validatePluralApiName } from \"~/domain/contentModel/validation/pluralApiName.js\";\nimport { validateModelFields } from \"~/domain/contentModel/validation/modelFields.js\";\n\n/**\n * Generate modelId from model following the exact logic from beforeCreate.ts\n */\nconst getModelId = (model: { modelId?: string; name?: string }): string => {\n    const { modelId, name } = model;\n    const value = modelId ? modelId.trim() : null;\n    if (value) {\n        const isModelIdValid = camelCase(value).toLowerCase() === value.toLowerCase();\n        if (isModelIdValid) {\n            return value;\n        }\n        return camelCase(value);\n    } else if (name) {\n        return camelCase(name.trim());\n    }\n    throw new ModelValidationError(\n        `There is no \"modelId\" or \"name\" passed into the create model method.`\n    );\n};\n\n/**\n * CreateModelRepository - Validates domain rules and persists a new model.\n *\n * Responsibilities:\n * - Generate modelId from input\n * - Validate modelId is allowed (not in disallowed list)\n * - Validate API name endings\n * - Validate modelId uniqueness (database + plugins)\n * - Validate API name uniqueness (database + plugins)\n * - Validate plugin conflicts\n * - Validate model fields\n * - Persist to storage\n * - Clear ModelCache after successful create\n */\nclass CreateModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private modelCache: ModelCache.Interface,\n        private pluginModelsProvider: PluginModelsProvider.Interface,\n        private listModelsUseCase: ListModelsUseCase.Interface,\n        private storageOperations: StorageOperations.Interface,\n        private tenantContext: TenantContext.Interface,\n        private cmsContext: CmsContext.Interface\n    ) {}\n\n    async execute(model: CmsModel): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            const tenant = this.tenantContext.getTenant();\n\n            // TODO: this will eventually become part of the Model domain object.\n            const modelId = getModelId(model);\n            model.modelId = modelId;\n\n            // Validate modelId is allowed (not in disallowed list)\n            try {\n                validateModelIdAllowed({ model });\n            } catch (error) {\n                return Result.fail(\n                    new ModelValidationError({\n                        message: error.message,\n                        data: error.data\n                    })\n                );\n            }\n\n            // Validate API name endings\n            try {\n                validateEndingAllowed({ model });\n            } catch (error) {\n                return Result.fail(\n                    new ModelValidationError({\n                        message: error.message,\n                        data: error.data\n                    })\n                );\n            }\n\n            // Check for plugin model conflicts\n            const pluginModels = await this.pluginModelsProvider.list(tenant.id);\n            const pluginModelConflict = pluginModels.find(pm => {\n                return pm.modelId === model.modelId;\n            });\n\n            if (pluginModelConflict) {\n                return Result.fail(\n                    new ModelAlreadyExistsError({\n                        modelId,\n                        message: `Model \"${modelId}\" is already registered via a plugin.`\n                    })\n                );\n            }\n\n            // Get all models for further validation\n            const modelsResult = await this.listModelsUseCase.execute();\n\n            if (modelsResult.isFail()) {\n                return Result.fail(new ModelPersistenceError(modelsResult.error));\n            }\n\n            const models = modelsResult.value;\n\n            try {\n                /**\n                 * We need to check for the existence of:\n                 * - modelId\n                 * - singularApiName\n                 * - pluralApiName\n                 */\n                for (const existingModel of models) {\n                    validateExistingModelId({\n                        existingModel,\n                        model\n                    });\n                    validateSingularApiName({\n                        existingModel,\n                        model\n                    });\n                    validatePluralApiName({\n                        existingModel,\n                        model\n                    });\n                }\n\n                await validateModelFields({\n                    models,\n                    model,\n                    context: this.cmsContext\n                });\n            } catch (error) {\n                return Result.fail(new ModelValidationError((error as Error).message));\n            }\n\n            // TODO: ideally, this will eventually be handled by the Model domain object\n            model.tags = ensureTypeTag(model);\n\n            // Persist to storage\n            await this.storageOperations.models.create({ model });\n\n            // Clear cache\n            this.modelCache.clear();\n\n            return Result.ok();\n        } catch (error) {\n            console.error(error, error.stack);\n            return Result.fail(new ModelPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const CreateModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateModelRepositoryImpl,\n    dependencies: [\n        ModelCache,\n        PluginModelsProvider,\n        ListModelsUseCase,\n        StorageOperations,\n        TenantContext,\n        CmsContext\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

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

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