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

package/features/modelBuilder/fields/UiTabsFieldType.js

@@ -0,0 +1,73 @@
+import { FieldType } from "./abstractions.js";
+import { LayoutFieldBuilder } from "./LayoutFieldBuilder.js";
+class TabsFieldBuilder extends LayoutFieldBuilder {
+    constructor(registry){
+        super("uiTabs"), this.registry = registry, this.tabs = [];
+    }
+    tab(id, config) {
+        const fieldBuilders = config.fields(this.registry);
+        const fields = [];
+        const layoutReplacements = new Map();
+        for (const [key, fieldBuilder] of Object.entries(fieldBuilders)){
+            fieldBuilder.fieldId(key);
+            const result = fieldBuilder.build();
+            if ("layout" === result.type) {
+                layoutReplacements.set(key, result.layoutCell);
+                if (result.fields) fields.push(...result.fields);
+            } else fields.push(result.field);
+        }
+        const rawLayout = config.layout || [];
+        const layout = rawLayout.map((row)=>row.map((cell)=>layoutReplacements.get(cell) ?? cell));
+        this.tabs.push({
+            id,
+            label: config.label,
+            icon: config.icon,
+            description: config.description || "",
+            fields,
+            layout,
+            rules: config.rules
+        });
+        return this;
+    }
+    build() {
+        const hoistedFields = [];
+        const layoutTabs = [];
+        for (const tab of this.tabs){
+            hoistedFields.push(...tab.fields);
+            layoutTabs.push({
+                id: tab.id,
+                label: tab.label,
+                icon: tab.icon || null,
+                layout: tab.layout,
+                rules: tab.rules
+            });
+        }
+        return {
+            type: "layout",
+            layoutCell: {
+                type: "tabs",
+                label: this.config.label,
+                description: this.config.description || null,
+                help: this.config.help || null,
+                tabs: layoutTabs,
+                rules: this.config.rules
+            },
+            fields: hoistedFields
+        };
+    }
+}
+class TabsFieldTypeFactory {
+    create(registry) {
+        return new TabsFieldBuilder(registry);
+    }
+    constructor(){
+        this.type = "uiTabs";
+    }
+}
+const UiTabsFieldType = FieldType.createImplementation({
+    implementation: TabsFieldTypeFactory,
+    dependencies: []
+});
+export { UiTabsFieldType };
+
+//# sourceMappingURL=UiTabsFieldType.js.map

package/features/modelBuilder/fields/UiTabsFieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/UiTabsFieldType.js","sources":["../../../../src/features/modelBuilder/fields/UiTabsFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport {\n    BaseFieldBuilder,\n    type FieldBuildResult,\n    type LayoutFieldBuildResult\n} from \"./BaseFieldBuilder.js\";\nimport { LayoutFieldBuilder } from \"./LayoutFieldBuilder.js\";\nimport { type IFieldBuilderRegistry } from \"../abstractions.js\";\nimport type {\n    CmsIcon,\n    CmsModelField,\n    CmsModelLayout,\n    CmsModelLayoutCell,\n    FieldRule\n} from \"~/types/index.js\";\n\ninterface ITab {\n    id: string;\n    label: string;\n    icon: CmsIcon | undefined;\n    description: string;\n    fields: CmsModelField[];\n    layout: CmsModelLayout;\n    rules?: FieldRule[];\n}\n\ninterface ITabConfig {\n    label: string;\n    icon?: CmsIcon;\n    description?: string;\n    fields: (registry: IFieldBuilderRegistry) => Record<string, BaseFieldBuilder<any>>;\n    layout?: string[][];\n    rules?: FieldRule[];\n}\n\nexport interface IUiTabsFieldBuilder extends LayoutFieldBuilder<\"uiTabs\"> {\n    tab(id: string, config: ITabConfig): this;\n}\n\nclass TabsFieldBuilder extends LayoutFieldBuilder<\"uiTabs\"> implements IUiTabsFieldBuilder {\n    private readonly tabs: ITab[] = [];\n\n    public constructor(private registry: IFieldBuilderRegistry) {\n        super(\"uiTabs\");\n    }\n\n    public tab(id: string, config: ITabConfig): this {\n        const fieldBuilders = config.fields(this.registry);\n        const fields: CmsModelField[] = [];\n        const layoutReplacements = new Map<string, CmsModelLayoutCell>();\n\n        for (const [key, fieldBuilder] of Object.entries(fieldBuilders)) {\n            fieldBuilder.fieldId(key);\n            const result: FieldBuildResult = (fieldBuilder as any).build();\n            if (result.type === \"layout\") {\n                layoutReplacements.set(key, result.layoutCell);\n                if (result.fields) {\n                    fields.push(...result.fields);\n                }\n            } else {\n                fields.push(result.field);\n            }\n        }\n\n        const rawLayout: string[][] = config.layout || [];\n        const layout: CmsModelLayout = rawLayout.map(row =>\n            row.map(cell => layoutReplacements.get(cell) ?? cell)\n        );\n\n        this.tabs.push({\n            id,\n            label: config.label,\n            icon: config.icon,\n            description: config.description || \"\",\n            fields,\n            layout,\n            rules: config.rules\n        });\n\n        return this;\n    }\n\n    public override build(): LayoutFieldBuildResult {\n        const hoistedFields: CmsModelField[] = [];\n        const layoutTabs = [];\n\n        for (const tab of this.tabs) {\n            hoistedFields.push(...tab.fields);\n            layoutTabs.push({\n                id: tab.id,\n                label: tab.label,\n                icon: tab.icon || null,\n                layout: tab.layout,\n                rules: tab.rules\n            });\n        }\n\n        return {\n            type: \"layout\",\n            layoutCell: {\n                type: \"tabs\",\n                label: this.config.label,\n                description: this.config.description || null,\n                help: this.config.help || null,\n                tabs: layoutTabs,\n                rules: this.config.rules\n            },\n            fields: hoistedFields\n        };\n    }\n}\n\nclass TabsFieldTypeFactory implements IFieldTypeFactory {\n    public readonly type = \"uiTabs\";\n\n    public create(registry: IFieldBuilderRegistry): IUiTabsFieldBuilder {\n        return new TabsFieldBuilder(registry);\n    }\n}\n\nexport const UiTabsFieldType = FieldType.createImplementation({\n    implementation: TabsFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        uiTabs(): IUiTabsFieldBuilder;\n    }\n}\n"],"names":["TabsFieldBuilder","LayoutFieldBuilder","registry","id","config","fieldBuilders","fields","layoutReplacements","Map","key","fieldBuilder","Object","result","rawLayout","layout","row","cell","hoistedFields","layoutTabs","tab","TabsFieldTypeFactory","UiTabsFieldType","FieldType"],"mappings":";;AAuCA,MAAMA,yBAAyBC;IAG3B,YAA2BC,QAA+B,CAAE;QACxD,KAAK,CAAC,gBADiBA,QAAQ,GAARA,UAAAA,IAAAA,CAFV,IAAI,GAAW,EAAE;IAIlC;IAEO,IAAIC,EAAU,EAAEC,MAAkB,EAAQ;QAC7C,MAAMC,gBAAgBD,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ;QACjD,MAAME,SAA0B,EAAE;QAClC,MAAMC,qBAAqB,IAAIC;QAE/B,KAAK,MAAM,CAACC,KAAKC,aAAa,IAAIC,OAAO,OAAO,CAACN,eAAgB;YAC7DK,aAAa,OAAO,CAACD;YACrB,MAAMG,SAA4BF,aAAqB,KAAK;YAC5D,IAAIE,AAAgB,aAAhBA,OAAO,IAAI,EAAe;gBAC1BL,mBAAmB,GAAG,CAACE,KAAKG,OAAO,UAAU;gBAC7C,IAAIA,OAAO,MAAM,EACbN,OAAO,IAAI,IAAIM,OAAO,MAAM;YAEpC,OACIN,OAAO,IAAI,CAACM,OAAO,KAAK;QAEhC;QAEA,MAAMC,YAAwBT,OAAO,MAAM,IAAI,EAAE;QACjD,MAAMU,SAAyBD,UAAU,GAAG,CAACE,CAAAA,MACzCA,IAAI,GAAG,CAACC,CAAAA,OAAQT,mBAAmB,GAAG,CAACS,SAASA;QAGpD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;YACXb;YACA,OAAOC,OAAO,KAAK;YACnB,MAAMA,OAAO,IAAI;YACjB,aAAaA,OAAO,WAAW,IAAI;YACnCE;YACAQ;YACA,OAAOV,OAAO,KAAK;QACvB;QAEA,OAAO,IAAI;IACf;IAEgB,QAAgC;QAC5C,MAAMa,gBAAiC,EAAE;QACzC,MAAMC,aAAa,EAAE;QAErB,KAAK,MAAMC,OAAO,IAAI,CAAC,IAAI,CAAE;YACzBF,cAAc,IAAI,IAAIE,IAAI,MAAM;YAChCD,WAAW,IAAI,CAAC;gBACZ,IAAIC,IAAI,EAAE;gBACV,OAAOA,IAAI,KAAK;gBAChB,MAAMA,IAAI,IAAI,IAAI;gBAClB,QAAQA,IAAI,MAAM;gBAClB,OAAOA,IAAI,KAAK;YACpB;QACJ;QAEA,OAAO;YACH,MAAM;YACN,YAAY;gBACR,MAAM;gBACN,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;gBACxB,aAAa,IAAI,CAAC,MAAM,CAAC,WAAW,IAAI;gBACxC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI;gBAC1B,MAAMD;gBACN,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;YAC5B;YACA,QAAQD;QACZ;IACJ;AACJ;AAEA,MAAMG;IAGK,OAAOlB,QAA+B,EAAuB;QAChE,OAAO,IAAIF,iBAAiBE;IAChC;;aAJgB,IAAI,GAAG;;AAK3B;AAEO,MAAMmB,kBAAkBC,UAAU,oBAAoB,CAAC;IAC1D,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/modelBuilder/fields/abstractions.d.ts

@@ -0,0 +1,18 @@
+import type { BaseFieldBuilder } from "./BaseFieldBuilder.js";
+import type { IFieldBuilderRegistry } from "../abstractions.js";
+/**
+ * Field Type Factory - creates a field builder instance
+ */
+export interface IFieldTypeFactory {
+    /** Unique identifier for this field type */
+    readonly type: string;
+    /** Create a new field builder instance */
+    create(registry: IFieldBuilderRegistry): BaseFieldBuilder<any>;
+}
+/**
+ * Use to implement new field types.
+ */
+export declare const FieldType: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+export declare namespace FieldType {
+    type Factory = IFieldTypeFactory;
+}

package/features/modelBuilder/fields/abstractions.js

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

package/features/modelBuilder/fields/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/abstractions.js","sources":["../../../../src/features/modelBuilder/fields/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { BaseFieldBuilder } from \"./BaseFieldBuilder.js\";\nimport type { IFieldBuilderRegistry } from \"../abstractions.js\";\n\n/**\n * Field Type Factory - creates a field builder instance\n */\nexport interface IFieldTypeFactory {\n    /** Unique identifier for this field type */\n    readonly type: string;\n\n    /** Create a new field builder instance */\n    create(registry: IFieldBuilderRegistry): BaseFieldBuilder<any>;\n}\n\n/**\n * Use to implement new field types.\n */\nexport const FieldType = createAbstraction<IFieldTypeFactory>(\"FieldType\");\n\nexport namespace FieldType {\n    export type Factory = IFieldTypeFactory;\n}\n"],"names":["FieldType","createAbstraction"],"mappings":";AAkBO,MAAMA,YAAYC,kBAAqC"}

package/features/modelBuilder/fields/fieldTypeValidator.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Validator interface mixins for type-safe field validators.
+ * These interfaces provide TypeScript autocomplete and type safety for field validation methods.
+ */
+export interface RequiredValidator {
+    required(message?: string): this;
+}
+export interface MinLengthValidator {
+    minLength(value: number, message?: string): this;
+}
+export interface MaxLengthValidator {
+    maxLength(value: number, message?: string): this;
+}
+/**
+ * Custom regex pattern validator.
+ * For common patterns, use the preset validators below (email, url, etc.).
+ */
+export interface PatternValidator {
+    pattern(regex: string, flags?: string, message?: string): this;
+}
+/**
+ * Pattern preset validators.
+ * These are convenience methods for common validation patterns.
+ */
+export interface EmailValidator {
+    email(message?: string): this;
+}
+export interface UrlValidator {
+    url(message?: string): this;
+}
+export interface LowerCaseValidator {
+    lowerCase(message?: string): this;
+}
+export interface UpperCaseValidator {
+    upperCase(message?: string): this;
+}
+export interface LowerCaseSpaceValidator {
+    lowerCaseSpace(message?: string): this;
+}
+export interface UpperCaseSpaceValidator {
+    upperCaseSpace(message?: string): this;
+}
+/**
+ * Number comparison validators
+ */
+export interface GteValidator {
+    gte(value: number, message?: string): this;
+}
+export interface LteValidator {
+    lte(value: number, message?: string): this;
+}
+/**
+ * Date/time comparison validators
+ */
+export interface DateGteValidator {
+    dateGte(value: string, message?: string): this;
+}
+export interface DateLteValidator {
+    dateLte(value: string, message?: string): this;
+}
+/**
+ * Unique value validator (ensures field value is unique across entries)
+ */
+export interface UniqueValidator {
+    unique(message?: string): this;
+}
+/**
+ * List validators (for list fields).
+ * These validate the array itself, not individual items.
+ */
+export interface ListMinLengthValidator {
+    listMinLength(value: number, message?: string): this;
+}
+export interface ListMaxLengthValidator {
+    listMaxLength(value: number, message?: string): this;
+}
+/**
+ * Validators to use when building a custom field type
+ */
+export declare namespace FieldTypeValidator {
+    type Required = RequiredValidator;
+    type MinLength = MinLengthValidator;
+    type MaxLength = MaxLengthValidator;
+    type Pattern = PatternValidator;
+    type Email = EmailValidator;
+    type Url = UrlValidator;
+    type LowerCase = LowerCaseValidator;
+    type UpperCase = UpperCaseValidator;
+    type LowerCaseSpace = LowerCaseSpaceValidator;
+    type UpperCaseSpace = UpperCaseSpaceValidator;
+    type Gte = GteValidator;
+    type Lte = LteValidator;
+    type DateGte = DateGteValidator;
+    type DateLte = DateLteValidator;
+    type Unique = UniqueValidator;
+    type ListMinLength = ListMinLengthValidator;
+    type ListMaxLength = ListMaxLengthValidator;
+}

package/features/modelBuilder/fields/resolveAssetUrl.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Build the turnkey delivery URL for a stored Asset field value.
+ *
+ * The Asset field stores `src` as the file's **base delivery URL** (the pristine
+ * original) with the per-usage crop kept beside it in `image.crop`. The delivery
+ * pipeline frames the image only when the URL carries a `?crop=` param, so a raw
+ * `src` never reflects the per-usage crop. This helper bakes that crop into the URL
+ * — it is what the generated `url` field on the Asset GraphQL type resolves to, so a
+ * headless consumer (any framework) gets a ready-to-use URL without having to know
+ * the delivery param contract.
+ *
+ * Note: only the per-usage crop is added here. Any **asset-level** crop (set in File
+ * Manager, stored on the file's metadata) is already baked in by the delivery on any
+ * GET of the base `src`, and a per-usage crop replaces — not composes with — it, so
+ * `src` + `?crop=<per-usage>` is the correct combined result.
+ */
+interface AssetImageCrop {
+    top?: number | null;
+    left?: number | null;
+    bottom?: number | null;
+    right?: number | null;
+}
+interface AssetValue {
+    src?: string | null;
+    image?: {
+        crop?: AssetImageCrop | null;
+    } | null;
+}
+/**
+ * The stored `src` with the per-usage crop baked in as a `?crop=` delivery param.
+ * Returns `src` unchanged when there is no per-usage crop, and `null` when the value
+ * has no source.
+ */
+export declare const resolveAssetUrl: (asset: AssetValue | null | undefined) => string | null;
+export {};

package/features/modelBuilder/fields/resolveAssetUrl.js

@@ -0,0 +1,26 @@
+const round = (n)=>Math.round(10000 * n) / 10000;
+const cropParam = (crop)=>{
+    if (!crop) return;
+    const top = crop.top ?? 0;
+    const left = crop.left ?? 0;
+    const bottom = crop.bottom ?? 0;
+    const right = crop.right ?? 0;
+    if (0 === top && 0 === left && 0 === bottom && 0 === right) return;
+    return [
+        top,
+        left,
+        bottom,
+        right
+    ].map(round).join(",");
+};
+const resolveAssetUrl = (asset)=>{
+    const src = asset?.src;
+    if (!src) return null;
+    const param = cropParam(asset?.image?.crop);
+    if (!param) return src;
+    const separator = src.includes("?") ? "&" : "?";
+    return `${src}${separator}crop=${param}`;
+};
+export { resolveAssetUrl };
+
+//# sourceMappingURL=resolveAssetUrl.js.map

package/features/modelBuilder/fields/resolveAssetUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/resolveAssetUrl.js","sources":["../../../../src/features/modelBuilder/fields/resolveAssetUrl.ts"],"sourcesContent":["/**\n * Build the turnkey delivery URL for a stored Asset field value.\n *\n * The Asset field stores `src` as the file's **base delivery URL** (the pristine\n * original) with the per-usage crop kept beside it in `image.crop`. The delivery\n * pipeline frames the image only when the URL carries a `?crop=` param, so a raw\n * `src` never reflects the per-usage crop. This helper bakes that crop into the URL\n * — it is what the generated `url` field on the Asset GraphQL type resolves to, so a\n * headless consumer (any framework) gets a ready-to-use URL without having to know\n * the delivery param contract.\n *\n * Note: only the per-usage crop is added here. Any **asset-level** crop (set in File\n * Manager, stored on the file's metadata) is already baked in by the delivery on any\n * GET of the base `src`, and a per-usage crop replaces — not composes with — it, so\n * `src` + `?crop=<per-usage>` is the correct combined result.\n */\n\ninterface AssetImageCrop {\n    top?: number | null;\n    left?: number | null;\n    bottom?: number | null;\n    right?: number | null;\n}\n\ninterface AssetValue {\n    src?: string | null;\n    image?: { crop?: AssetImageCrop | null } | null;\n}\n\nconst round = (n: number): number => Math.round(n * 10000) / 10000;\n\n/** `top,left,bottom,right` crop param, or `undefined` for a missing/full (no-op) crop. */\nconst cropParam = (crop: AssetImageCrop | null | undefined): string | undefined => {\n    if (!crop) {\n        return undefined;\n    }\n    const top = crop.top ?? 0;\n    const left = crop.left ?? 0;\n    const bottom = crop.bottom ?? 0;\n    const right = crop.right ?? 0;\n    if (top === 0 && left === 0 && bottom === 0 && right === 0) {\n        return undefined;\n    }\n    return [top, left, bottom, right].map(round).join(\",\");\n};\n\n/**\n * The stored `src` with the per-usage crop baked in as a `?crop=` delivery param.\n * Returns `src` unchanged when there is no per-usage crop, and `null` when the value\n * has no source.\n */\nexport const resolveAssetUrl = (asset: AssetValue | null | undefined): string | null => {\n    const src = asset?.src;\n    if (!src) {\n        return null;\n    }\n    const param = cropParam(asset?.image?.crop);\n    if (!param) {\n        return src;\n    }\n    const separator = src.includes(\"?\") ? \"&\" : \"?\";\n    return `${src}${separator}crop=${param}`;\n};\n"],"names":["round","n","Math","cropParam","crop","top","left","bottom","right","resolveAssetUrl","asset","src","param","separator"],"mappings":"AA6BA,MAAMA,QAAQ,CAACC,IAAsBC,KAAK,KAAK,CAACD,AAAI,QAAJA,KAAa;AAG7D,MAAME,YAAY,CAACC;IACf,IAAI,CAACA,MACD;IAEJ,MAAMC,MAAMD,KAAK,GAAG,IAAI;IACxB,MAAME,OAAOF,KAAK,IAAI,IAAI;IAC1B,MAAMG,SAASH,KAAK,MAAM,IAAI;IAC9B,MAAMI,QAAQJ,KAAK,KAAK,IAAI;IAC5B,IAAIC,AAAQ,MAARA,OAAaC,AAAS,MAATA,QAAcC,AAAW,MAAXA,UAAgBC,AAAU,MAAVA,OAC3C;IAEJ,OAAO;QAACH;QAAKC;QAAMC;QAAQC;KAAM,CAAC,GAAG,CAACR,OAAO,IAAI,CAAC;AACtD;AAOO,MAAMS,kBAAkB,CAACC;IAC5B,MAAMC,MAAMD,OAAO;IACnB,IAAI,CAACC,KACD,OAAO;IAEX,MAAMC,QAAQT,UAAUO,OAAO,OAAO;IACtC,IAAI,CAACE,OACD,OAAOD;IAEX,MAAME,YAAYF,IAAI,QAAQ,CAAC,OAAO,MAAM;IAC5C,OAAO,GAAGA,MAAME,UAAU,KAAK,EAAED,OAAO;AAC5C"}

package/features/modelBuilder/index.d.ts

@@ -0,0 +1,25 @@
+export { ModelFactory, type IModelSettings } from "./abstractions.js";
+export * from "./models/BaseModelBuilder.js";
+export * from "./models/ModelBuilder.js";
+export * from "./models/PrivateModelBuilder.js";
+export * from "./models/PublicModelBuilder.js";
+export * from "./feature.js";
+export * from "./fields/FieldBuilder.js";
+export * from "./fields/abstractions.js";
+export * from "./models/abstractions.js";
+export { TextFieldSubTypes, TextFieldTypes } from "./fields/TextFieldType.js";
+import "./fields/TextFieldType.js";
+import "./fields/LongTextFieldType.js";
+import "./fields/RichTextFieldType.js";
+import "./fields/NumberFieldType.js";
+import "./fields/BooleanFieldType.js";
+import "./fields/FileFieldType.js";
+import "./fields/DateTimeFieldType.js";
+import "./fields/ObjectFieldType.js";
+import "./fields/RefFieldType.js";
+import "./fields/DynamicZoneFieldType.js";
+import "./fields/JsonFieldType.js";
+import "./fields/SearchableJsonFieldType.js";
+import "./fields/UiSeparatorFieldType.js";
+import "./fields/UiTabsFieldType.js";
+import "./fields/UiAlertFieldType.js";

package/features/modelBuilder/index.js

@@ -0,0 +1,24 @@
+import "./fields/UiAlertFieldType.js";
+import "./fields/UiTabsFieldType.js";
+import "./fields/LongTextFieldType.js";
+import "./fields/RichTextFieldType.js";
+import "./fields/NumberFieldType.js";
+import "./fields/BooleanFieldType.js";
+import "./fields/FileFieldType.js";
+import "./fields/DateTimeFieldType.js";
+import "./fields/ObjectFieldType.js";
+import "./fields/RefFieldType.js";
+import "./fields/DynamicZoneFieldType.js";
+import "./fields/JsonFieldType.js";
+import "./fields/SearchableJsonFieldType.js";
+import "./fields/UiSeparatorFieldType.js";
+export * from "./models/BaseModelBuilder.js";
+export * from "./models/ModelBuilder.js";
+export * from "./models/PrivateModelBuilder.js";
+export * from "./models/PublicModelBuilder.js";
+export * from "./feature.js";
+export * from "./fields/FieldBuilder.js";
+export * from "./fields/abstractions.js";
+export * from "./models/abstractions.js";
+export { ModelFactory } from "./abstractions.js";
+export { TextFieldSubTypes, TextFieldTypes } from "./fields/TextFieldType.js";

package/features/modelBuilder/models/BaseModelBuilder.d.ts

@@ -0,0 +1,48 @@
+import { BaseFieldBuilder } from "../../../features/modelBuilder/index.js";
+import { CmsModelPlugin } from "../../../plugins/CmsModelPlugin.js";
+import { FieldBuilderRegistry, type IModelSettings } from "../abstractions.js";
+import type { CmsModelField, CmsModelLayoutCell } from "../../../types/index.js";
+/**
+ * Base class for all model builders, containing shared logic.
+ * Concrete builders (PrivateModelBuilder, PublicModelBuilder) extend this.
+ */
+export declare abstract class BaseModelBuilder<TBuild = CmsModelPlugin> {
+    protected registry: FieldBuilderRegistry.Interface;
+    protected config: {
+        modelId?: string;
+        name?: string;
+        tags?: string[];
+        settings?: IModelSettings;
+    };
+    protected isSingleEntry: boolean;
+    protected fieldBuildersMap: Map<string, BaseFieldBuilder<any>>;
+    constructor(registry: FieldBuilderRegistry.Interface);
+    modelId(id: string): this;
+    name(name: string): this;
+    singleEntry(): this;
+    tags(tags: string[]): this;
+    settings(settings: Partial<IModelSettings>): this;
+    fields(builder: (registry: FieldBuilderRegistry.Interface) => Record<string, BaseFieldBuilder<any>>): this;
+    /**
+     * Merge field operations from extension builder into existing builder.
+     * This handles the case where multiple fields of the same type exist,
+     * and we need to transfer operations from the temporary new builder
+     * to the existing builder.
+     * @internal
+     */
+    private mergeFieldOperations;
+    protected buildFields(): {
+        fields: CmsModelField[];
+        layoutReplacements: Map<string, CmsModelLayoutCell>;
+    };
+    /**
+     * Get tags with common defaults applied.
+     * Always includes "type:model" and optionally "singleEntry".
+     */
+    protected getTags(): string[];
+    /**
+     * Build the final model configuration.
+     * Must be implemented by concrete builders.
+     */
+    abstract build(): TBuild;
+}

package/features/modelBuilder/models/BaseModelBuilder.js

@@ -0,0 +1,87 @@
+class BaseModelBuilder {
+    constructor(registry){
+        this.registry = registry;
+        this.config = {};
+        this.isSingleEntry = false;
+        this.fieldBuildersMap = new Map();
+    }
+    modelId(id) {
+        this.config.modelId = id;
+        return this;
+    }
+    name(name) {
+        this.config.name = name;
+        return this;
+    }
+    singleEntry() {
+        this.isSingleEntry = true;
+        return this;
+    }
+    tags(tags) {
+        this.config.tags = tags;
+        return this;
+    }
+    settings(settings) {
+        this.config.settings = {
+            ...this.config.settings || {},
+            ...settings
+        };
+        return this;
+    }
+    fields(builder) {
+        this.registry.existingFields = this.fieldBuildersMap;
+        const fieldBuilders = builder(this.registry);
+        for (const [key, fieldBuilder] of Object.entries(fieldBuilders)){
+            fieldBuilder.fieldId(key);
+            const existingBuilder = this.fieldBuildersMap.get(key);
+            const isExtendMode = fieldBuilder._extendMode;
+            if (isExtendMode && existingBuilder) {
+                if (existingBuilder.type !== fieldBuilder.type) throw new Error(`Cannot extend field "${key}": type mismatch. Expected "${existingBuilder.type}", got "${fieldBuilder.type}".`);
+                this.mergeFieldOperations(key, existingBuilder, fieldBuilder);
+            } else if (existingBuilder && !isExtendMode) {
+                if (existingBuilder.type !== fieldBuilder.type) throw new Error(`Cannot redefine field "${key}": type mismatch. Expected "${existingBuilder.type}", got "${fieldBuilder.type}".`);
+                this.fieldBuildersMap.set(key, fieldBuilder);
+            } else if (existingBuilder || isExtendMode) throw new Error(`Cannot extend field "${key}": field does not exist. Use .extend() only for existing fields.`);
+            else this.fieldBuildersMap.set(key, fieldBuilder);
+        }
+        return this;
+    }
+    mergeFieldOperations(fieldId, existing, extension) {
+        if ("object" === existing.type && "object" === extension.type) {
+            const existingFieldMap = existing.fieldBuildersMap;
+            const extensionFieldMap = extension.fieldBuildersMap;
+            if (extensionFieldMap) for (const [nestedKey, nestedBuilder] of extensionFieldMap.entries())existingFieldMap.set(nestedKey, nestedBuilder);
+            const existingLayoutBuilder = existing.layoutBuilder;
+            const extensionLayoutBuilder = extension.layoutBuilder;
+            if (extensionLayoutBuilder) {
+                const snapshot = extensionLayoutBuilder.getSnapshot();
+                if (snapshot.layout.length > 0 && 0 === snapshot.modifiers.length) existingLayoutBuilder.setLayout(snapshot.layout);
+                for (const modifier of snapshot.modifiers)existingLayoutBuilder.addModifier(modifier);
+            }
+        }
+    }
+    buildFields() {
+        const fields = [];
+        const layoutReplacements = new Map();
+        for (const [fieldId, builder] of this.fieldBuildersMap){
+            const result = builder.build();
+            if ("layout" === result.type) {
+                layoutReplacements.set(fieldId, result.layoutCell);
+                if (result.fields) fields.push(...result.fields);
+            } else fields.push(result.field);
+        }
+        return {
+            fields,
+            layoutReplacements
+        };
+    }
+    getTags() {
+        const tagsSet = new Set(this.config.tags || []);
+        tagsSet.add("type:model");
+        if (this.isSingleEntry) tagsSet.add("singleEntry");
+        return Array.from(tagsSet);
+    }
+}
+export { BaseModelBuilder };
+
+//# sourceMappingURL=BaseModelBuilder.js.map

package/features/modelBuilder/models/BaseModelBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/models/BaseModelBuilder.js","sources":["../../../../src/features/modelBuilder/models/BaseModelBuilder.ts"],"sourcesContent":["import { BaseFieldBuilder } from \"~/features/modelBuilder/index.js\";\nimport { CmsModelPlugin } from \"~/plugins/CmsModelPlugin.js\";\nimport { FieldBuilderRegistry, type IModelSettings } from \"../abstractions.js\";\nimport type { CmsModelField, CmsModelLayoutCell } from \"~/types/index.js\";\n\n/**\n * Base class for all model builders, containing shared logic.\n * Concrete builders (PrivateModelBuilder, PublicModelBuilder) extend this.\n */\nexport abstract class BaseModelBuilder<TBuild = CmsModelPlugin> {\n    protected config: {\n        modelId?: string;\n        name?: string;\n        tags?: string[];\n        settings?: IModelSettings;\n    } = {};\n\n    protected isSingleEntry = false;\n    protected fieldBuildersMap = new Map<string, BaseFieldBuilder<any>>();\n\n    public constructor(protected registry: FieldBuilderRegistry.Interface) {}\n\n    modelId(id: string): this {\n        this.config.modelId = id;\n        return this;\n    }\n\n    name(name: string): this {\n        this.config.name = name;\n        return this;\n    }\n\n    singleEntry(): this {\n        this.isSingleEntry = true;\n        return this;\n    }\n\n    tags(tags: string[]): this {\n        this.config.tags = tags;\n        return this;\n    }\n\n    settings(settings: Partial<IModelSettings>): this {\n        this.config.settings = { ...(this.config.settings || {}), ...settings };\n        return this;\n    }\n\n    fields(\n        builder: (registry: FieldBuilderRegistry.Interface) => Record<string, BaseFieldBuilder<any>>\n    ): this {\n        // Pass existing fields to registry so it can return them when extending\n        (this.registry as any).existingFields = this.fieldBuildersMap;\n\n        const fieldBuilders = builder(this.registry);\n\n        for (const [key, fieldBuilder] of Object.entries(fieldBuilders)) {\n            // Set the fieldId from the object key\n            fieldBuilder.fieldId(key);\n\n            const existingBuilder = this.fieldBuildersMap.get(key);\n            const isExtendMode = (fieldBuilder as any)._extendMode;\n\n            if (isExtendMode && existingBuilder) {\n                // Extension mode - validate type and merge operations\n                if (existingBuilder.type !== fieldBuilder.type) {\n                    throw new Error(\n                        `Cannot extend field \"${key}\": type mismatch. Expected \"${existingBuilder.type}\", got \"${fieldBuilder.type}\".`\n                    );\n                }\n                // Merge operations from temporary new builder into existing builder\n                this.mergeFieldOperations(key, existingBuilder, fieldBuilder);\n            } else if (existingBuilder && !isExtendMode) {\n                // Replacement mode - validate type\n                if (existingBuilder.type !== fieldBuilder.type) {\n                    throw new Error(\n                        `Cannot redefine field \"${key}\": type mismatch. Expected \"${existingBuilder.type}\", got \"${fieldBuilder.type}\".`\n                    );\n                }\n                // Replace with new builder\n                this.fieldBuildersMap.set(key, fieldBuilder);\n            } else if (!existingBuilder && !isExtendMode) {\n                // New field - store builder\n                this.fieldBuildersMap.set(key, fieldBuilder);\n            } else {\n                // isExtendMode but no existingBuilder - this is an error\n                throw new Error(\n                    `Cannot extend field \"${key}\": field does not exist. Use .extend() only for existing fields.`\n                );\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Merge field operations from extension builder into existing builder.\n     * This handles the case where multiple fields of the same type exist,\n     * and we need to transfer operations from the temporary new builder\n     * to the existing builder.\n     * @internal\n     */\n    private mergeFieldOperations(\n        fieldId: string,\n        existing: BaseFieldBuilder<any>,\n        extension: BaseFieldBuilder<any>\n    ): void {\n        // For object fields, merge nested fields and layout operations\n        if (existing.type === \"object\" && extension.type === \"object\") {\n            const existingFieldMap = (existing as any).fieldBuildersMap;\n            const extensionFieldMap = (extension as any).fieldBuildersMap;\n\n            // Merge nested field builders\n            if (extensionFieldMap) {\n                for (const [nestedKey, nestedBuilder] of extensionFieldMap.entries()) {\n                    existingFieldMap.set(nestedKey, nestedBuilder);\n                }\n            }\n\n            // Merge layout operations\n            const existingLayoutBuilder = (existing as any).layoutBuilder;\n            const extensionLayoutBuilder = (extension as any).layoutBuilder;\n\n            if (extensionLayoutBuilder) {\n                const snapshot = extensionLayoutBuilder.getSnapshot();\n\n                // If extension called setLayout() with an array, apply it to existing\n                // We detect this by checking if there's a layout but no modifiers\n                if (snapshot.layout.length > 0 && snapshot.modifiers.length === 0) {\n                    existingLayoutBuilder.setLayout(snapshot.layout);\n                }\n\n                // Apply all modifiers from extension to existing\n                for (const modifier of snapshot.modifiers) {\n                    existingLayoutBuilder.addModifier(modifier);\n                }\n            }\n        }\n    }\n\n    protected buildFields(): {\n        fields: CmsModelField[];\n        layoutReplacements: Map<string, CmsModelLayoutCell>;\n    } {\n        const fields: CmsModelField[] = [];\n        const layoutReplacements = new Map<string, CmsModelLayoutCell>();\n\n        for (const [fieldId, builder] of this.fieldBuildersMap) {\n            const result = builder.build();\n            if (result.type === \"layout\") {\n                layoutReplacements.set(fieldId, result.layoutCell);\n                if (result.fields) {\n                    fields.push(...result.fields);\n                }\n            } else {\n                fields.push(result.field);\n            }\n        }\n\n        return { fields, layoutReplacements };\n    }\n\n    /**\n     * Get tags with common defaults applied.\n     * Always includes \"type:model\" and optionally \"singleEntry\".\n     */\n    protected getTags(): string[] {\n        const tagsSet = new Set(this.config.tags || []);\n        tagsSet.add(\"type:model\");\n        if (this.isSingleEntry) {\n            tagsSet.add(\"singleEntry\");\n        }\n        return Array.from(tagsSet);\n    }\n\n    /**\n     * Build the final model configuration.\n     * Must be implemented by concrete builders.\n     */\n    abstract build(): TBuild;\n}\n"],"names":["BaseModelBuilder","registry","Map","id","name","tags","settings","builder","fieldBuilders","key","fieldBuilder","Object","existingBuilder","isExtendMode","Error","fieldId","existing","extension","existingFieldMap","extensionFieldMap","nestedKey","nestedBuilder","existingLayoutBuilder","extensionLayoutBuilder","snapshot","modifier","fields","layoutReplacements","result","tagsSet","Set","Array"],"mappings":"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"}

package/features/modelBuilder/models/ModelBuilder.d.ts

@@ -0,0 +1,30 @@
+import { FieldBuilderRegistry } from "../abstractions.js";
+import { PrivateModelBuilder } from "./PrivateModelBuilder.js";
+import { PublicModelBuilder } from "./PublicModelBuilder.js";
+export interface IModelBuilderPrivateInput {
+    modelId: string;
+    name: string;
+}
+export interface IModelBuilderPublicInput {
+    name: string;
+    modelId: string;
+    group: string;
+    singularApiName?: string;
+    pluralApiName?: string;
+}
+/**
+ * Entry point builder that allows selecting model type.
+ * Call .private() or .public() to get the appropriate typed builder.
+ */
+export declare class ModelBuilder {
+    private registry;
+    constructor(registry: FieldBuilderRegistry.Interface);
+    /**
+     * Create a private model (internal models, no GraphQL API).
+     */
+    private(input: IModelBuilderPrivateInput): PrivateModelBuilder;
+    /**
+     * Create a public model (with GraphQL API).
+     */
+    public(input: IModelBuilderPublicInput): PublicModelBuilder;
+}

package/features/modelBuilder/models/ModelBuilder.js

@@ -0,0 +1,25 @@
+import { PrivateModelBuilder } from "./PrivateModelBuilder.js";
+import { PublicModelBuilder } from "./PublicModelBuilder.js";
+class ModelBuilder {
+    constructor(registry){
+        this.registry = registry;
+    }
+    private(input) {
+        const model = new PrivateModelBuilder(this.registry);
+        model.modelId(input.modelId);
+        model.name(input.name);
+        return model;
+    }
+    public(input) {
+        const model = new PublicModelBuilder(this.registry);
+        model.name(input.name);
+        model.modelId(input.modelId);
+        model.group(input.group);
+        if (input.singularApiName) model.singularApiName(input.singularApiName);
+        if (input.pluralApiName) model.pluralApiName(input.pluralApiName);
+        return model;
+    }
+}
+export { ModelBuilder };
+
+//# sourceMappingURL=ModelBuilder.js.map

package/features/modelBuilder/models/ModelBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/models/ModelBuilder.js","sources":["../../../../src/features/modelBuilder/models/ModelBuilder.ts"],"sourcesContent":["import { FieldBuilderRegistry } from \"../abstractions.js\";\nimport { PrivateModelBuilder } from \"./PrivateModelBuilder.js\";\nimport { PublicModelBuilder } from \"./PublicModelBuilder.js\";\n\nexport interface IModelBuilderPrivateInput {\n    modelId: string;\n    name: string;\n}\n\nexport interface IModelBuilderPublicInput {\n    name: string;\n    modelId: string;\n    group: string;\n    singularApiName?: string;\n    pluralApiName?: string;\n}\n\n/**\n * Entry point builder that allows selecting model type.\n * Call .private() or .public() to get the appropriate typed builder.\n */\nexport class ModelBuilder {\n    public constructor(private registry: FieldBuilderRegistry.Interface) {}\n\n    /**\n     * Create a private model (internal models, no GraphQL API).\n     */\n    public private(input: IModelBuilderPrivateInput): PrivateModelBuilder {\n        const model = new PrivateModelBuilder(this.registry);\n        model.modelId(input.modelId);\n        model.name(input.name);\n        return model;\n    }\n\n    /**\n     * Create a public model (with GraphQL API).\n     */\n    public public(input: IModelBuilderPublicInput): PublicModelBuilder {\n        const model = new PublicModelBuilder(this.registry);\n        model.name(input.name);\n        model.modelId(input.modelId);\n        model.group(input.group);\n        if (input.singularApiName) {\n            model.singularApiName(input.singularApiName);\n        }\n        if (input.pluralApiName) {\n            model.pluralApiName(input.pluralApiName);\n        }\n        return model;\n    }\n}\n"],"names":["ModelBuilder","registry","input","model","PrivateModelBuilder","PublicModelBuilder"],"mappings":";;AAqBO,MAAMA;IACT,YAA2BC,QAAwC,CAAE;aAA1CA,QAAQ,GAARA;IAA2C;IAK/D,QAAQC,KAAgC,EAAuB;QAClE,MAAMC,QAAQ,IAAIC,oBAAoB,IAAI,CAAC,QAAQ;QACnDD,MAAM,OAAO,CAACD,MAAM,OAAO;QAC3BC,MAAM,IAAI,CAACD,MAAM,IAAI;QACrB,OAAOC;IACX;IAKO,OAAOD,KAA+B,EAAsB;QAC/D,MAAMC,QAAQ,IAAIE,mBAAmB,IAAI,CAAC,QAAQ;QAClDF,MAAM,IAAI,CAACD,MAAM,IAAI;QACrBC,MAAM,OAAO,CAACD,MAAM,OAAO;QAC3BC,MAAM,KAAK,CAACD,MAAM,KAAK;QACvB,IAAIA,MAAM,eAAe,EACrBC,MAAM,eAAe,CAACD,MAAM,eAAe;QAE/C,IAAIA,MAAM,aAAa,EACnBC,MAAM,aAAa,CAACD,MAAM,aAAa;QAE3C,OAAOC;IACX;AACJ"}

package/features/modelBuilder/models/ModelsProvider.d.ts

@@ -0,0 +1,12 @@
+import { ModelsProvider as ProviderAbstraction } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { ModelFactory } from "../abstractions.js";
+import { FieldBuilderRegistry } from "../abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+export declare class ModelsProvider implements ProviderAbstraction.Interface {
+    private getModels;
+    private fieldsRegistry;
+    private accessControl;
+    constructor(getModels: () => ModelFactory.Interface[], fieldsRegistry: FieldBuilderRegistry.Interface, accessControl: AccessControl.Interface | undefined);
+    list(tenant: string): Promise<CmsModel[]>;
+}

package/features/modelBuilder/models/ModelsProvider.js

@@ -0,0 +1,31 @@
+import { filterAsync } from "../../../utils/filterAsync.js";
+import { ModelBuilder } from "./ModelBuilder.js";
+class ModelsProvider {
+    constructor(getModels, fieldsRegistry, accessControl){
+        this.getModels = getModels;
+        this.fieldsRegistry = fieldsRegistry;
+        this.accessControl = accessControl;
+    }
+    async list(tenant) {
+        const modelImpls = this.getModels();
+        const allModels = [];
+        for (const modelImpl of modelImpls){
+            const entryBuilder = new ModelBuilder(this.fieldsRegistry);
+            const typedBuilders = await modelImpl.execute(entryBuilder);
+            for (const typedBuilder of typedBuilders){
+                const modelPlugin = typedBuilder.build();
+                allModels.push({
+                    ...modelPlugin.contentModel,
+                    tenant
+                });
+            }
+        }
+        if (!this.accessControl) return allModels;
+        return filterAsync(allModels, (model)=>this.accessControl.canAccessModel({
+                model
+            }));
+    }
+}
+export { ModelsProvider };
+
+//# sourceMappingURL=ModelsProvider.js.map

package/features/modelBuilder/models/ModelsProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/models/ModelsProvider.js","sources":["../../../../src/features/modelBuilder/models/ModelsProvider.ts"],"sourcesContent":["import { ModelsProvider as ProviderAbstraction } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { ModelFactory } from \"../abstractions.js\";\nimport { FieldBuilderRegistry } from \"../abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { filterAsync } from \"~/utils/filterAsync.js\";\nimport { ModelBuilder } from \"./ModelBuilder.js\";\n\nexport class ModelsProvider implements ProviderAbstraction.Interface {\n    public constructor(\n        private getModels: () => ModelFactory.Interface[],\n        private fieldsRegistry: FieldBuilderRegistry.Interface,\n        private accessControl: AccessControl.Interface | undefined\n    ) {}\n\n    async list(tenant: string): Promise<CmsModel[]> {\n        const modelImpls = this.getModels();\n        const allModels: CmsModel[] = [];\n\n        for (const modelImpl of modelImpls) {\n            // Entry builder that determines model type\n            const entryBuilder = new ModelBuilder(this.fieldsRegistry);\n\n            // Get typed builders (array of private or public builders)\n            const typedBuilders = await modelImpl.execute(entryBuilder);\n\n            // Process each builder in the array\n            for (const typedBuilder of typedBuilders) {\n                const modelPlugin = typedBuilder.build();\n\n                allModels.push({\n                    ...modelPlugin.contentModel,\n                    tenant\n                });\n            }\n        }\n\n        if (!this.accessControl) {\n            return allModels;\n        }\n        // Apply access control filtering\n        return filterAsync(allModels, model => {\n            return this.accessControl!.canAccessModel({ model });\n        });\n    }\n}\n"],"names":["ModelsProvider","getModels","fieldsRegistry","accessControl","tenant","modelImpls","allModels","modelImpl","entryBuilder","ModelBuilder","typedBuilders","typedBuilder","modelPlugin","filterAsync","model"],"mappings":";;AAQO,MAAMA;IACT,YACYC,SAAyC,EACzCC,cAA8C,EAC9CC,aAAkD,CAC5D;aAHUF,SAAS,GAATA;aACAC,cAAc,GAAdA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,KAAKC,MAAc,EAAuB;QAC5C,MAAMC,aAAa,IAAI,CAAC,SAAS;QACjC,MAAMC,YAAwB,EAAE;QAEhC,KAAK,MAAMC,aAAaF,WAAY;YAEhC,MAAMG,eAAe,IAAIC,aAAa,IAAI,CAAC,cAAc;YAGzD,MAAMC,gBAAgB,MAAMH,UAAU,OAAO,CAACC;YAG9C,KAAK,MAAMG,gBAAgBD,cAAe;gBACtC,MAAME,cAAcD,aAAa,KAAK;gBAEtCL,UAAU,IAAI,CAAC;oBACX,GAAGM,YAAY,YAAY;oBAC3BR;gBACJ;YACJ;QACJ;QAEA,IAAI,CAAC,IAAI,CAAC,aAAa,EACnB,OAAOE;QAGX,OAAOO,YAAYP,WAAWQ,CAAAA,QACnB,IAAI,CAAC,aAAa,CAAE,cAAc,CAAC;gBAAEA;YAAM;IAE1D;AACJ"}

package/features/modelBuilder/models/PrivateModelBuilder.d.ts

@@ -0,0 +1,4 @@
+import { BaseModelBuilder } from "./BaseModelBuilder.js";
+export declare class PrivateModelBuilder extends BaseModelBuilder {
+    build(): import("~/plugins/CmsModelPlugin.js").CmsModelPlugin;
+}