@webiny/api-core 0.0.0-unstable.0d717d18dd

package/models/cms/__tests__/PrivateCmsModelBuilder.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models/cms/__tests__/PrivateCmsModelBuilder.test.js","sources":["../../../../src/models/cms/__tests__/PrivateCmsModelBuilder.test.ts"],"sourcesContent":["import { describe, it, expect } from \"vitest\";\nimport { PrivateCmsModelBuilder } from \"../PrivateCmsModelBuilder.js\";\nimport { FieldBuilderRegistry } from \"../FieldBuilderRegistry.js\";\nimport { createFieldDefinitions, type InferFieldSchema } from \"../FieldDefinitionsBuilder.js\";\nimport type { IModel } from \"~/models/base/abstractions.js\";\n\ndescribe(\"PrivateCmsModelBuilder\", () => {\n    const registry = new FieldBuilderRegistry();\n    const builder = new PrivateCmsModelBuilder(registry);\n\n    describe(\"Basic Model Creation\", () => {\n        it(\"should create a basic model with text fields\", () => {\n            // ✅ Object syntax!\n            const fieldDefs = createFieldDefinitions(fields => ({\n                id: fields.text().required(),\n                title: fields.text().label(\"Title\").required()\n            }));\n\n            type Schema = InferFieldSchema<typeof fieldDefs>;\n            interface ITestModel extends IModel<Schema> {}\n\n            const model = builder.create<ITestModel>(\"test\", fieldDefs).build();\n\n            expect(model.modelId).toBe(\"test\");\n            expect(model.fields).toHaveLength(2);\n            expect(model.fields[0].fieldId).toBe(\"id\");\n            expect(model.fields[1].fieldId).toBe(\"title\");\n        });\n\n        it(\"should properly infer types\", () => {\n            const fieldDefs = createFieldDefinitions(fields => ({\n                id: fields.text().required(),\n                name: fields.text().label(\"Name\").required(),\n                email: fields.text().email().required()\n            }));\n\n            type Schema = InferFieldSchema<typeof fieldDefs>;\n            interface ITestModel extends IModel<Schema> {}\n\n            const model = builder.create<ITestModel>(\"test\", fieldDefs).build();\n\n            // ✅ Fully typed!\n            const instance = model.create({\n                id: \"1\",\n                name: \"John Doe\",\n                email: \"john@example.com\"\n            });\n\n            expect(instance.id).toBe(\"1\");\n            expect(instance.name).toBe(\"John Doe\");\n            expect(instance.email).toBe(\"john@example.com\");\n        });\n    });\n\n    describe(\"Object Fields\", () => {\n        it(\"should support nested object fields\", () => {\n            const fieldDefs = createFieldDefinitions(fields => ({\n                id: fields.text().required(),\n                author: fields\n                    .object(reg => ({\n                        name: reg.text().required(),\n                        email: reg.text().email().required()\n                    }))\n                    .label(\"Author\")\n            }));\n\n            type Schema = InferFieldSchema<typeof fieldDefs>;\n            interface ITestModel extends IModel<Schema> {}\n\n            const model = builder.create<ITestModel>(\"test\", fieldDefs).build();\n\n            const instance = model.create({\n                id: \"1\",\n                author: {\n                    name: \"John Doe\",\n                    email: \"john@example.com\"\n                }\n            });\n\n            expect(instance.author.name).toBe(\"John Doe\");\n            expect(instance.author.email).toBe(\"john@example.com\");\n        });\n    });\n\n    describe(\"Field Extensions\", () => {\n        it(\"should add extension fields under extensions property\", () => {\n            const fieldDefs = createFieldDefinitions(fields => ({\n                id: fields.text().required(),\n                title: fields.text().required()\n            }));\n\n            type Schema = InferFieldSchema<typeof fieldDefs>;\n            interface ITestModel extends IModel<Schema> {\n                extensions?: {\n                    seo?: {\n                        title: string;\n                        description: string;\n                    };\n                };\n            }\n\n            // ✅ Same object syntax as createFieldDefinitions!\n            const model = builder\n                .create<ITestModel>(\"test\", fieldDefs)\n                .extendFields(fields => ({\n                    seo: fields\n                        .object(reg => ({\n                            title: reg.text().label(\"SEO Title\"),\n                            description: reg.text().label(\"SEO Description\")\n                        }))\n                        .label(\"SEO Settings\")\n                }))\n                .build();\n\n            expect(model.fields).toHaveLength(3);\n        });\n\n        it(\"should support multiple extension fields\", () => {\n            const fieldDefs = createFieldDefinitions(fields => ({\n                id: fields.text().required(),\n                title: fields.text().required()\n            }));\n\n            type Schema = InferFieldSchema<typeof fieldDefs>;\n            interface ITestModel extends IModel<Schema> {\n                extensions?: {\n                    seo?: { title: string };\n                    published?: string;\n                };\n            }\n\n            // ✅ Clean object syntax!\n            const model = builder\n                .create<ITestModel>(\"test\", fieldDefs)\n                .extendFields(fields => ({\n                    seo: fields.object(reg => ({\n                        title: reg.text()\n                    })),\n                    published: fields.text()\n                }))\n                .build();\n\n            const instance = model.create({\n                id: \"1\",\n                title: \"Test\",\n                extensions: {\n                    seo: { title: \"SEO\" },\n                    published: \"2024-01-01\"\n                }\n            });\n\n            expect(instance.extensions?.seo?.title).toBe(\"SEO\");\n            expect(instance.extensions?.published).toBe(\"2024-01-01\");\n        });\n\n        it(\"should chain multiple extendFields calls\", () => {\n            const fieldDefs = createFieldDefinitions(fields => ({\n                id: fields.text().required(),\n                title: fields.text().required()\n            }));\n\n            type Schema = InferFieldSchema<typeof fieldDefs>;\n            interface ITestModel extends IModel<Schema> {\n                extensions?: {\n                    seo?: { title: string };\n                    analytics?: { tracking: string };\n                };\n            }\n\n            // ✅ Can chain multiple calls!\n            const model = builder\n                .create<ITestModel>(\"test\", fieldDefs)\n                .extendFields(fields => ({\n                    seo: fields.object(reg => ({\n                        title: reg.text()\n                    }))\n                }))\n                .extendFields(fields => ({\n                    analytics: fields.object(reg => ({\n                        tracking: reg.text()\n                    }))\n                }))\n                .build();\n\n            const instance = model.create({\n                id: \"1\",\n                title: \"Test\",\n                extensions: {\n                    seo: { title: \"SEO\" },\n                    analytics: { tracking: \"GA-123\" }\n                }\n            });\n\n            expect(instance.extensions?.seo?.title).toBe(\"SEO\");\n            expect(instance.extensions?.analytics?.tracking).toBe(\"GA-123\");\n        });\n    });\n\n    describe(\"Decorator Pattern\", () => {\n        it(\"should work with decorator pattern\", () => {\n            const PageFieldDefinitions = createFieldDefinitions(fields => ({\n                id: fields.text().required(),\n                title: fields.text().label(\"Title\").required(),\n                path: fields.text().label(\"Path\").slug().required()\n            }));\n\n            type PageFieldsSchema = InferFieldSchema<typeof PageFieldDefinitions>;\n\n            interface IPageExtensions {\n                seo?: { title: string; description: string };\n                publishedAt?: string;\n                publishedBy?: string;\n            }\n\n            interface IPage extends IModel<PageFieldsSchema> {\n                getFullPath(): string;\n                getSeoTitle(): string;\n                publish(userId: string): void;\n                isPublished(): boolean;\n                extensions?: IPageExtensions;\n            }\n\n            const baseBuilder = builder.create<IPage>(\"page\", PageFieldDefinitions).withMethods({\n                getFullPath() {\n                    return this.path.startsWith(\"/\") ? this.path : `/${this.path}`;\n                }\n            });\n\n            // ✅ Clean object syntax in decorators!\n            const withSeo = baseBuilder\n                .extendFields(fields => ({\n                    seo: fields.object(reg => ({\n                        title: reg.text(),\n                        description: reg.text()\n                    }))\n                }))\n                .withMethods({\n                    getSeoTitle() {\n                        return this.extensions?.seo?.title || this.title;\n                    }\n                });\n\n            // ✅ Clean object syntax for publishing!\n            const withPublishing = withSeo\n                .extendFields(fields => ({\n                    publishedAt: fields.text(),\n                    publishedBy: fields.text()\n                }))\n                .withMethods({\n                    publish(userId: string) {\n                        if (!this.extensions) {\n                            this.extensions = {};\n                        }\n                        this.extensions.publishedAt = new Date().toISOString();\n                        this.extensions.publishedBy = userId;\n                    },\n                    isPublished() {\n                        return !!this.extensions?.publishedAt;\n                    }\n                });\n\n            const model = withPublishing.build();\n\n            const page = model.create({\n                id: \"1\",\n                title: \"Home\",\n                path: \"home\",\n                extensions: {\n                    seo: { title: \"Home SEO\", description: \"Home Description\" }\n                }\n            });\n\n            expect(page.getFullPath()).toBe(\"/home\");\n            expect(page.getSeoTitle()).toBe(\"Home SEO\");\n            expect(page.isPublished()).toBe(false);\n\n            page.publish(\"user-123\");\n            expect(page.isPublished()).toBe(true);\n            expect(page.extensions?.publishedBy).toBe(\"user-123\");\n        });\n    });\n});\n"],"names":["describe","registry","FieldBuilderRegistry","builder","PrivateCmsModelBuilder","it","fieldDefs","createFieldDefinitions","fields","model","expect","instance","reg","PageFieldDefinitions","baseBuilder","withSeo","withPublishing","userId","Date","page"],"mappings":"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"}

package/models/cms/abstractions.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { Abstraction } from "@webiny/di";
+import type { IPrivateCmsModelConfiguration } from "./PrivateCmsModelBuilder.js";
+import type { FieldDefinitionsFactory } from "./FieldDefinitionsBuilder.js";
+import { type TextFieldBuilder, type ObjectFieldBuilder, FieldBuilder } from "./FieldBuilder.js";
+import type { BaseModel, IModelData } from "../../models/base/BaseModel.js";
+/**
+ * Field Builder Registry - provides field builders
+ */
+export interface IFieldBuilderRegistry {
+    text(): TextFieldBuilder<z.ZodString>;
+    object<TShape extends Record<string, z.ZodTypeAny>>(fields: (registry: IFieldBuilderRegistry) => {
+        [K in keyof TShape]: FieldBuilder<TShape[K]>;
+    }): ObjectFieldBuilder<TShape>;
+}
+export declare const FieldBuilderRegistry: Abstraction<IFieldBuilderRegistry>;
+/**
+ * Private CMS Model Builder - builds CMS model configurations
+ */
+export interface IPrivateCmsModelBuilder {
+    create<TModel extends BaseModel<any>>(modelId: string, fieldDefinitions: FieldDefinitionsFactory<any>): IPrivateCmsModelConfiguration<TModel>;
+}
+export declare const PrivateCmsModelBuilder: Abstraction<IPrivateCmsModelBuilder>;
+export declare namespace PrivateCmsModelBuilder {
+    type Interface = IPrivateCmsModelBuilder;
+}
+/**
+ * CMS Model Builder - builds the model configuration for a specific model
+ */
+export interface ICmsModelBuilder<TModel extends BaseModel<any>> {
+    buildCmsModel(): Promise<IPrivateCmsModelConfiguration<TModel>>;
+}
+/**
+ * CMS Model Factory - creates model instances
+ */
+export interface ICmsModelFactory<TModel extends BaseModel<any>> {
+    create(data: IModelData<TModel>): Promise<TModel>;
+}

package/models/cms/abstractions.js

@@ -0,0 +1,6 @@
+import { Abstraction } from "@webiny/di";
+const FieldBuilderRegistry = new Abstraction("FieldBuilderRegistry");
+const PrivateCmsModelBuilder = new Abstraction("PrivateCmsModelBuilder");
+export { FieldBuilderRegistry, PrivateCmsModelBuilder };
+
+//# sourceMappingURL=abstractions.js.map

package/models/cms/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models/cms/abstractions.js","sources":["../../../src/models/cms/abstractions.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { Abstraction } from \"@webiny/di\";\nimport type { IPrivateCmsModelConfiguration } from \"./PrivateCmsModelBuilder.js\";\nimport type { FieldDefinitionsFactory } from \"./FieldDefinitionsBuilder.js\";\nimport { type TextFieldBuilder, type ObjectFieldBuilder, FieldBuilder } from \"./FieldBuilder.js\";\nimport type { BaseModel, IModelData } from \"~/models/base/BaseModel.js\";\n\n/**\n * Field Builder Registry - provides field builders\n */\nexport interface IFieldBuilderRegistry {\n    text(): TextFieldBuilder<z.ZodString>;\n    object<TShape extends Record<string, z.ZodTypeAny>>(\n        fields: (registry: IFieldBuilderRegistry) => {\n            [K in keyof TShape]: FieldBuilder<TShape[K]>;\n        }\n    ): ObjectFieldBuilder<TShape>;\n}\n\nexport const FieldBuilderRegistry = new Abstraction<IFieldBuilderRegistry>(\"FieldBuilderRegistry\");\n\n/**\n * Private CMS Model Builder - builds CMS model configurations\n */\nexport interface IPrivateCmsModelBuilder {\n    create<TModel extends BaseModel<any>>(\n        modelId: string,\n        fieldDefinitions: FieldDefinitionsFactory<any>\n    ): IPrivateCmsModelConfiguration<TModel>;\n}\n\nexport const PrivateCmsModelBuilder = new Abstraction<IPrivateCmsModelBuilder>(\n    \"PrivateCmsModelBuilder\"\n);\n\nexport namespace PrivateCmsModelBuilder {\n    export type Interface = IPrivateCmsModelBuilder;\n}\n\n/**\n * CMS Model Builder - builds the model configuration for a specific model\n */\nexport interface ICmsModelBuilder<TModel extends BaseModel<any>> {\n    buildCmsModel(): Promise<IPrivateCmsModelConfiguration<TModel>>;\n}\n\n/**\n * CMS Model Factory - creates model instances\n */\nexport interface ICmsModelFactory<TModel extends BaseModel<any>> {\n    create(data: IModelData<TModel>): Promise<TModel>;\n}\n"],"names":["FieldBuilderRegistry","Abstraction","PrivateCmsModelBuilder"],"mappings":";AAmBO,MAAMA,uBAAuB,IAAIC,YAAmC;AAYpE,MAAMC,yBAAyB,IAAID,YACtC"}

package/models/cms/fieldsBuilder.md

@@ -0,0 +1,388 @@
+Let's implement a multi-instance DI pattern where all field types implement the same abstraction.
+
+Core Architecture
+cms/fields/abstractions.ts
+
+```ts
+import { Abstraction } from "@webiny/di-container";
+import type { FieldBuilder } from "../FieldBuilder.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(): FieldBuilder<any>;
+}
+
+/**
+ * Field Type abstraction - use with { multiple: true } in DI
+ */
+export const FieldType = new Abstraction<IFieldTypeFactory>("FieldType");
+```
+
+cms/fields/TextFieldType.ts
+
+```ts
+import { createImplementation } from "@webiny/di-container";
+import { z } from "zod";
+import { FieldBuilder } from "../FieldBuilder.js";
+import { FieldType, type IFieldTypeFactory } from "./abstractions.js";
+
+export interface ITextFieldBuilder extends FieldBuilder<z.ZodString> {
+  label(text: string): this;
+  required(message?: string): this;
+  minLength(length: number, message?: string): this;
+  maxLength(length: number, message?: string): this;
+  slug(): this;
+  email(): this;
+  url(): this;
+  unique(): this;
+  help(text: string): this;
+  placeholder(text: string): this;
+}
+
+class TextFieldBuilder extends FieldBuilder<z.ZodString> implements ITextFieldBuilder {
+  constructor() {
+    super("text", z.string());
+  }
+
+  required(message?: string): this {
+    this.zodSchema = this.zodSchema.min(1, message || "Field is required");
+    this.config.validation?.push({
+      name: "required",
+      message: message || "Field is required",
+      settings: {}
+    });
+    return this;
+  }
+
+  minLength(length: number, message?: string): this {
+    this.zodSchema = this.zodSchema.min(length, message);
+    return this;
+  }
+
+  maxLength(length: number, message?: string): this {
+    this.zodSchema = this.zodSchema.max(length, message);
+    return this;
+  }
+
+  slug(): this {
+    this.zodSchema = this.zodSchema.regex(/^[a-z0-9-]+$/, "Must be a valid slug");
+    this.config.validation?.push({
+      name: "slug",
+      message: "Must be a valid slug",
+      settings: {}
+    });
+    return this;
+  }
+
+  email(): this {
+    this.zodSchema = this.zodSchema.email("Must be a valid email");
+    this.config.validation?.push({
+      name: "email",
+      message: "Must be a valid email",
+      settings: {}
+    });
+    return this;
+  }
+
+  url(): this {
+    this.zodSchema = this.zodSchema.url("Must be a valid URL");
+    this.config.validation?.push({
+      name: "url",
+      message: "Must be a valid URL",
+      settings: {}
+    });
+    return this;
+  }
+
+  unique(): this {
+    this.config.validation?.push({
+      name: "unique",
+      message: "Value must be unique",
+      settings: {}
+    });
+    return this;
+  }
+}
+
+class TextFieldTypeFactory implements IFieldTypeFactory {
+  readonly type = "text";
+
+  create(): ITextFieldBuilder {
+    return new TextFieldBuilder();
+  }
+}
+
+export const TextFieldType = createImplementation({
+  abstraction: FieldType,
+  implementation: TextFieldTypeFactory,
+  dependencies: []
+});
+```
+
+cms/FieldBuilderRegistry.ts - Multi-instance injection
+
+```ts
+import { createImplementation, Container } from "@webiny/di-container";
+import { z } from "zod";
+import {
+  FieldBuilderRegistry as RegistryAbstraction,
+  type IFieldBuilderRegistry
+} from "./abstractions.js";
+import { FieldType, type IFieldTypeFactory } from "./fields/abstractions.js";
+import type { FieldBuilder } from "./FieldBuilder.js";
+
+class FieldBuilderRegistryImpl implements IFieldBuilderRegistry {
+  private fieldTypes = new Map<string, IFieldTypeFactory>();
+
+  constructor(
+    fieldTypeFactories: IFieldTypeFactory[] // ✅ Inject ALL field types!
+  ) {
+    // Register all field types by their type name
+    for (const factory of fieldTypeFactories) {
+      this.fieldTypes.set(factory.type, factory);
+    }
+
+    // Return Proxy for dynamic method access
+    return new Proxy(this, {
+      get(target, prop: string) {
+        // Check if it's a registered field type
+        const factory = target.fieldTypes.get(prop);
+        if (factory) {
+          return () => factory.create();
+        }
+
+        // Otherwise return the actual property
+        return (target as any)[prop];
+      }
+    }) as any;
+  }
+
+  // TypeScript interface needs these (but Proxy provides them at runtime)
+  text = undefined as any;
+  object = undefined as any;
+}
+
+export const FieldBuilderRegistryImplementation = createImplementation({
+  abstraction: RegistryAbstraction,
+  implementation: FieldBuilderRegistryImpl,
+  dependencies: [[FieldType, { multiple: true }]] // ✅ Multi-instance!
+});
+```
+
+cms/abstractions.ts - Base interface
+
+```ts
+import { Abstraction } from "@webiny/di-container";
+import type { BaseModel } from "~/models/BaseModel.js";
+import type { IModelData } from "~/models/abstractions.js";
+import type { IPrivateCmsModelConfiguration } from "./PrivateCmsModelBuilder.js";
+import type { FieldDefinitionsFactory } from "./FieldDefinitionsBuilder.js";
+import type { ITextFieldBuilder } from "./fields/TextFieldType.js";
+import { z } from "zod";
+import type { FieldBuilder } from "./FieldBuilder.js";
+
+/**
+ * Field Builder Registry
+ * Plugins can extend this via module augmentation
+ */
+export interface IFieldBuilderRegistry {
+  text(): ITextFieldBuilder;
+  // object is special - needs registry reference
+  object<TShape extends Record<string, z.ZodTypeAny>>(
+    fields: (registry: IFieldBuilderRegistry) => {
+      [K in keyof TShape]: FieldBuilder<TShape[K]>;
+    }
+  ): FieldBuilder<z.ZodObject<TShape>>;
+}
+
+export const FieldBuilderRegistry = new Abstraction<IFieldBuilderRegistry>("FieldBuilderRegistry");
+
+// ... rest of abstractions
+```
+
+Plugin: Color Field
+plugins/color-field/ColorFieldType.ts
+
+```ts
+import { createImplementation } from "@webiny/di-container";
+import { z } from "zod";
+import { FieldBuilder } from "~/cms/FieldBuilder.js";
+import { FieldType, type IFieldTypeFactory } from "~/cms/fields/abstractions.js";
+
+export interface IColorFieldBuilder extends FieldBuilder<z.ZodString> {
+  label(text: string): this;
+  required(message?: string): this;
+  default(hex: string): this;
+  allowAlpha(): this;
+  palette(colors: string[]): this;
+  help(text: string): this;
+}
+
+class ColorFieldBuilder extends FieldBuilder<z.ZodString> implements IColorFieldBuilder {
+  constructor() {
+    super("color", z.string().regex(/^#[0-9A-Fa-f]{6}$/));
+  }
+
+  required(message?: string): this {
+    this.zodSchema = this.zodSchema.min(1, message || "Color is required");
+    this.config.validation?.push({
+      name: "required",
+      message: message || "Color is required",
+      settings: {}
+    });
+    return this;
+  }
+
+  default(hex: string): this {
+    this.zodSchema = this.zodSchema.default(hex);
+    this.config.settings = { ...this.config.settings, default: hex };
+    return this;
+  }
+
+  allowAlpha(): this {
+    this.zodSchema = z.string().regex(/^#[0-9A-Fa-f]{6,8}$/);
+    this.config.settings = { ...this.config.settings, allowAlpha: true };
+    return this;
+  }
+
+  palette(colors: string[]): this {
+    this.config.settings = { ...this.config.settings, palette: colors };
+    return this;
+  }
+}
+
+class ColorFieldTypeFactory implements IFieldTypeFactory {
+  readonly type = "color";
+
+  create(): IColorFieldBuilder {
+    return new ColorFieldBuilder();
+  }
+}
+
+// ✅ Register as FieldType implementation!
+export const ColorFieldType = createImplementation({
+  abstraction: FieldType,
+  implementation: ColorFieldTypeFactory,
+  dependencies: []
+});
+```
+
+plugins/color-field/module-augmentation.ts
+
+```ts
+// Module augmentation for TypeScript autocomplete
+declare module "~/cms/abstractions.js" {
+  interface IFieldBuilderRegistry {
+    color(): IColorFieldBuilder;
+  }
+}
+
+import type { IColorFieldBuilder } from "./ColorFieldType.js";
+```
+
+plugins/color-field/index.ts
+
+```ts
+import type { Container } from "@webiny/di-container";
+import { ColorFieldType } from "./ColorFieldType.js";
+import "./module-augmentation.js"; // ✅ Import for side effects
+
+export function registerColorField(container: Container) {
+// ✅ Just register the implementation - that's it!
+container.register(ColorFieldType);
+}
+
+export { ColorFieldType, type IColorFieldBuilder } from "./ColorFieldType.js";
+Registration
+typescriptimport { Container } from "@webiny/di-container";
+import { FieldBuilderRegistryImplementation } from "~/cms/FieldBuilderRegistry.js";
+import { TextFieldType } from "~/cms/fields/TextFieldType.js";
+import { registerColorField } from "~/plugins/color-field/index.js";
+
+const container = new Container();
+
+// ✅ Register core field types
+container.register(TextFieldType);
+// container.register(NumberFieldType);
+// container.register(DateFieldType);
+// ... etc
+
+// ✅ Register registry (will automatically get all FieldType implementations)
+container.register(FieldBuilderRegistryImplementation);
+
+// ✅ Register plugin field types
+registerColorField(container);
+```
+
+// That's it! No decorators needed!
+Usage
+
+```ts
+const PageFieldDefinitions = createFieldDefinitions(fields => ({
+  id: fields.text().required(),
+  title: fields.text().label("Title").required(),
+  backgroundColor: fields
+    .color() // ✅ Autocomplete works!
+    .label("Background Color")
+    .default("#ffffff")
+    .palette(["#ff0000", "#00ff00", "#0000ff"])
+}));
+```
+
+Tests
+
+```ts
+describe("Color Field Plugin", () => {
+  it("should register and use color field via multi-instance DI", async () => {
+    const container = new Container();
+
+    // Register core fields
+    container.register(TextFieldType);
+
+    // Register color field plugin
+    registerColorField(container);
+
+    // Register infrastructure
+    container.register(FieldBuilderRegistryImplementation);
+    container.register(PrivateCmsModelBuilderImplementation);
+
+    const fieldDefs = createFieldDefinitions(fields => ({
+      id: fields.text().required(),
+      bgColor: fields.color().label("Background").default("#ffffff")
+    }));
+
+    type Schema = InferFieldSchema<typeof fieldDefs>;
+    interface ITestModel extends IModel<Schema> {}
+
+    const builder = container.resolve(PrivateCmsModelBuilder);
+    const model = builder.create<ITestModel>("test", fieldDefs).__build();
+
+    const instance = model.create({
+      id: "1",
+      bgColor: "#ff5733"
+    });
+
+    expect(instance.bgColor).toBe("#ff5733");
+  });
+});
+```
+
+Benefits
+✅ One abstraction - FieldType for all field types
+✅ Zero boilerplate - No decorators, just register implementations
+✅ Multi-instance DI - Container automatically collects all implementations
+✅ Module augmentation - TypeScript autocomplete works
+✅ Simple plugin registration - Just container.register(ColorFieldType)
+✅ Uniform pattern - All field types follow same structure
+✅ Easy to add fields - Create factory, register, done!
+To add a new field type:
+
+Create XFieldTypeFactory implements IFieldTypeFactory
+Register as FieldType implementation
+Add module augmentation for TypeScript

package/models/cms/types.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import type { ModelClass } from "../../models/base/ModelBuilder.js";
+import type { BaseModel } from "../../models/base/BaseModel.js";
+import type { IModelData } from "../../models/base/abstractions.js";
+export interface FieldConfig {
+    fieldId: string;
+    type: string;
+    label?: string;
+    help?: string;
+    placeholder?: string;
+    validation?: ValidationRule[];
+    settings?: Record<string, any>;
+    zodSchema: z.ZodTypeAny;
+    fields?: FieldConfig[];
+}
+export interface ValidationRule {
+    name: string;
+    message: string;
+    settings: Record<string, any>;
+}
+export interface CmsModelMetadata {
+    icon?: string;
+    description?: string;
+    titleFieldId?: string;
+    descriptionFieldId?: string;
+    imageFieldId?: string;
+    tags?: string[];
+}
+export interface PrivateCmsModel<TModel extends BaseModel<any>> {
+    type: "private";
+    modelType: "private";
+    Model: ModelClass<TModel>;
+    modelId: string;
+    name: string;
+    icon?: string;
+    description?: string;
+    fields: FieldConfig[];
+    schema: TModel["__schema"];
+    create: (data: IModelData<TModel>) => TModel;
+}
+export interface FieldBuilderConfig {
+    fieldId: string;
+    config: FieldConfig;
+    zodSchema: z.ZodTypeAny;
+}

package/models/simple/Page/PageModelBuilder.d.ts

@@ -0,0 +1,10 @@
+import { ModelBuilder as Builder } from "../../../models/base/ModelBuilder.js";
+import { PageModelBuilder as BuilderAbstraction, type IPage } from "./abstractions.js";
+declare class PageModelBuilderImpl implements BuilderAbstraction.Interface {
+    buildModel(): Promise<Builder<IPage & {
+        hasTitle(): boolean;
+        cancel(): void;
+    }>>;
+}
+export declare const PageModelBuilder: import("@webiny/di").Implementation<typeof PageModelBuilderImpl>;
+export {};

package/models/simple/Page/PageModelBuilder.js

@@ -0,0 +1,21 @@
+import { createImplementation } from "@webiny/di";
+import { ModelBuilder } from "../../base/ModelBuilder.js";
+import { PageModelBuilder, PageSchema } from "./abstractions.js";
+class PageModelBuilderImpl {
+    async buildModel() {
+        return new ModelBuilder("Page", PageSchema).withMethods({
+            hasTitle () {
+                return "" !== this.title;
+            },
+            cancel () {}
+        });
+    }
+}
+const PageModelBuilder_PageModelBuilder = createImplementation({
+    abstraction: PageModelBuilder,
+    implementation: PageModelBuilderImpl,
+    dependencies: []
+});
+export { PageModelBuilder_PageModelBuilder as PageModelBuilder };
+
+//# sourceMappingURL=PageModelBuilder.js.map

package/models/simple/Page/PageModelBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models/simple/Page/PageModelBuilder.js","sources":["../../../../src/models/simple/Page/PageModelBuilder.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { ModelBuilder as Builder } from \"~/models/base/ModelBuilder.js\";\nimport { PageSchema, PageModelBuilder as BuilderAbstraction, type IPage } from \"./abstractions.js\";\n\nclass PageModelBuilderImpl implements BuilderAbstraction.Interface {\n    async buildModel() {\n        return new Builder<IPage>(\"Page\", PageSchema).withMethods({\n            hasTitle() {\n                return this.title !== \"\";\n            },\n            cancel() {}\n        });\n    }\n}\n\nexport const PageModelBuilder = createImplementation({\n    abstraction: BuilderAbstraction,\n    implementation: PageModelBuilderImpl,\n    dependencies: []\n});\n"],"names":["PageModelBuilderImpl","Builder","PageSchema","PageModelBuilder","createImplementation","BuilderAbstraction"],"mappings":";;;AAIA,MAAMA;IACF,MAAM,aAAa;QACf,OAAO,IAAIC,aAAe,QAAQC,YAAY,WAAW,CAAC;YACtD;gBACI,OAAO,AAAe,OAAf,IAAI,CAAC,KAAK;YACrB;YACA,WAAU;QACd;IACJ;AACJ;AAEO,MAAMC,oCAAmBC,qBAAqB;IACjD,aAAaC;IACb,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/models/simple/Page/PageModelFactory.d.ts

@@ -0,0 +1,9 @@
+import { PageModelFactory as FactoryAbstraction, PageModelBuilder, type IPage } from "./abstractions.js";
+declare class PageModelFactoryImpl implements FactoryAbstraction.Interface {
+    private modelBuilder;
+    private modelClass;
+    constructor(modelBuilder: PageModelBuilder.Interface);
+    create(data: FactoryAbstraction.CreateInput): Promise<IPage>;
+}
+export declare const PageModelFactory: import("@webiny/di").Implementation<typeof PageModelFactoryImpl>;
+export {};

package/models/simple/Page/PageModelFactory.js

@@ -0,0 +1,23 @@
+import { createImplementation } from "@webiny/di";
+import { PageModelBuilder, PageModelFactory } from "./abstractions.js";
+class PageModelFactoryImpl {
+    constructor(modelBuilder){
+        this.modelBuilder = modelBuilder;
+    }
+    async create(data) {
+        if (this.modelClass) return this.modelClass.create(data);
+        const builder = await this.modelBuilder.buildModel();
+        this.modelClass = builder.build();
+        return this.modelClass.create(data);
+    }
+}
+const PageModelFactory_PageModelFactory = createImplementation({
+    abstraction: PageModelFactory,
+    implementation: PageModelFactoryImpl,
+    dependencies: [
+        PageModelBuilder
+    ]
+});
+export { PageModelFactory_PageModelFactory as PageModelFactory };
+
+//# sourceMappingURL=PageModelFactory.js.map

package/models/simple/Page/PageModelFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models/simple/Page/PageModelFactory.js","sources":["../../../../src/models/simple/Page/PageModelFactory.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport {\n    PageModelFactory as FactoryAbstraction,\n    PageModelBuilder,\n    type IPage\n} from \"./abstractions.js\";\nimport type { ModelClass } from \"~/models/base/ModelBuilder.js\";\n\nclass PageModelFactoryImpl implements FactoryAbstraction.Interface {\n    private modelClass: ModelClass<IPage> | undefined;\n\n    constructor(private modelBuilder: PageModelBuilder.Interface) {}\n\n    async create(data: FactoryAbstraction.CreateInput): Promise<IPage> {\n        if (this.modelClass) {\n            return this.modelClass.create(data);\n        }\n\n        const builder = await this.modelBuilder.buildModel();\n        this.modelClass = builder.build();\n\n        return this.modelClass.create(data);\n    }\n}\n\nexport const PageModelFactory = createImplementation({\n    abstraction: FactoryAbstraction,\n    implementation: PageModelFactoryImpl,\n    dependencies: [PageModelBuilder]\n});\n"],"names":["PageModelFactoryImpl","modelBuilder","data","builder","PageModelFactory","createImplementation","FactoryAbstraction","PageModelBuilder"],"mappings":";;AAQA,MAAMA;IAGF,YAAoBC,YAAwC,CAAE;aAA1CA,YAAY,GAAZA;IAA2C;IAE/D,MAAM,OAAOC,IAAoC,EAAkB;QAC/D,IAAI,IAAI,CAAC,UAAU,EACf,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA;QAGlC,MAAMC,UAAU,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU;QAClD,IAAI,CAAC,UAAU,GAAGA,QAAQ,KAAK;QAE/B,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAACD;IAClC;AACJ;AAEO,MAAME,oCAAmBC,qBAAqB;IACjD,aAAaC;IACb,gBAAgBN;IAChB,cAAc;QAACO;KAAiB;AACpC"}

package/models/simple/Page/__tests__/PageModelBuilderDecorator.d.ts

@@ -0,0 +1,20 @@
+import { PageModelBuilder as BuilderAbstraction } from "../abstractions.js";
+declare class PageModelBuilderDecoratorImpl implements BuilderAbstraction.Interface {
+    private decoratee;
+    constructor(decoratee: BuilderAbstraction.Interface);
+    buildModel(): Promise<import("../../../base/ModelBuilder.js").ModelBuilder<import("~/models/simple/Page/abstractions.js").IPage & {
+        hasSeoTitle(): boolean;
+    }>>;
+}
+export declare const PageModelBuilderDecorator: typeof PageModelBuilderDecoratorImpl;
+declare module "~/models/simple/Page/abstractions.js" {
+    interface IPage {
+        hasSeoTitle(): boolean;
+    }
+    interface IPageExtensions {
+        seo?: {
+            title: string;
+        };
+    }
+}
+export {};

package/models/simple/Page/__tests__/PageModelBuilderDecorator.js

@@ -0,0 +1,27 @@
+import { createDecorator } from "@webiny/di";
+import { PageModelBuilder } from "../abstractions.js";
+class PageModelBuilderDecoratorImpl {
+    constructor(decoratee){
+        this.decoratee = decoratee;
+    }
+    async buildModel() {
+        const builder = await this.decoratee.buildModel();
+        return builder.extendSchema((z)=>({
+                seo: z.object({
+                    title: z.string()
+                })
+            })).withMethods({
+            hasSeoTitle () {
+                return this.extensions?.seo?.title !== "";
+            }
+        });
+    }
+}
+const PageModelBuilderDecorator = createDecorator({
+    abstraction: PageModelBuilder,
+    decorator: PageModelBuilderDecoratorImpl,
+    dependencies: []
+});
+export { PageModelBuilderDecorator };
+
+//# sourceMappingURL=PageModelBuilderDecorator.js.map

package/models/simple/Page/__tests__/PageModelBuilderDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models/simple/Page/__tests__/PageModelBuilderDecorator.js","sources":["../../../../../src/models/simple/Page/__tests__/PageModelBuilderDecorator.ts"],"sourcesContent":["import { createDecorator } from \"@webiny/di\";\nimport { PageModelBuilder as BuilderAbstraction } from \"../abstractions.js\";\n\nclass PageModelBuilderDecoratorImpl implements BuilderAbstraction.Interface {\n    constructor(private decoratee: BuilderAbstraction.Interface) {}\n\n    async buildModel() {\n        const builder = await this.decoratee.buildModel();\n\n        return builder\n            .extendSchema(z => ({\n                seo: z.object({\n                    title: z.string()\n                })\n            }))\n            .withMethods({\n                hasSeoTitle() {\n                    return this.extensions?.seo?.title !== \"\";\n                }\n            });\n    }\n}\n\nexport const PageModelBuilderDecorator = createDecorator({\n    abstraction: BuilderAbstraction,\n    decorator: PageModelBuilderDecoratorImpl,\n    dependencies: []\n});\n\ndeclare module \"~/models/simple/Page/abstractions.js\" {\n    interface IPage {\n        hasSeoTitle(): boolean;\n    }\n\n    interface IPageExtensions {\n        seo?: { title: string };\n    }\n}\n"],"names":["PageModelBuilderDecoratorImpl","decoratee","builder","z","PageModelBuilderDecorator","createDecorator","BuilderAbstraction"],"mappings":";;AAGA,MAAMA;IACF,YAAoBC,SAAuC,CAAE;aAAzCA,SAAS,GAATA;IAA0C;IAE9D,MAAM,aAAa;QACf,MAAMC,UAAU,MAAM,IAAI,CAAC,SAAS,CAAC,UAAU;QAE/C,OAAOA,QACF,YAAY,CAACC,CAAAA,IAAM;gBAChB,KAAKA,EAAE,MAAM,CAAC;oBACV,OAAOA,EAAE,MAAM;gBACnB;YACJ,IACC,WAAW,CAAC;YACT;gBACI,OAAO,IAAI,CAAC,UAAU,EAAE,KAAK,UAAU;YAC3C;QACJ;IACR;AACJ;AAEO,MAAMC,4BAA4BC,gBAAgB;IACrD,aAAaC;IACb,WAAWN;IACX,cAAc,EAAE;AACpB"}