@webiny/api-core 0.0.0-unstable.61c048f412

package/models/cms/fieldsBuilder.md

@@ -0,0 +1,386 @@
+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;
+  helpText(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 z.ZodRawShape>(
+    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;
+  helpText(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;
+    helpText?: string;
+    placeholderText?: 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/cms/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=types.js.map

package/models/cms/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import { z } from \"zod\";\nimport type { ModelClass } from \"~/models/base/ModelBuilder.js\";\nimport type { BaseModel } from \"~/models/base/BaseModel.js\";\nimport type { IModelData } from \"~/models/base/abstractions.js\";\n\nexport interface FieldConfig {\n    fieldId: string;\n    type: string;\n    label?: string;\n    helpText?: string;\n    placeholderText?: string;\n    validation?: ValidationRule[];\n    settings?: Record<string, any>;\n    zodSchema: z.ZodTypeAny;\n    fields?: FieldConfig[]; // For nested object fields\n}\n\nexport interface ValidationRule {\n    name: string;\n    message: string;\n    settings: Record<string, any>;\n}\n\nexport interface CmsModelMetadata {\n    icon?: string;\n    description?: string;\n    titleFieldId?: string;\n    descriptionFieldId?: string;\n    imageFieldId?: string;\n    tags?: string[];\n}\n\n// Make PrivateCmsModel generic!\nexport interface PrivateCmsModel<TModel extends BaseModel<any>> {\n    type: \"private\";\n    modelType: \"private\";\n    Model: ModelClass<TModel>;\n    modelId: string;\n    name: string;\n    icon?: string;\n    description?: string;\n    fields: FieldConfig[];\n    schema: TModel[\"__schema\"];\n    create: (data: IModelData<TModel>) => TModel;\n}\n\nexport interface FieldBuilderConfig {\n    fieldId: string;\n    config: FieldConfig;\n    zodSchema: z.ZodTypeAny;\n}\n"],"mappings":"","ignoreList":[]}

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,20 @@
+import { createImplementation } from "@webiny/di";
+import { ModelBuilder as Builder } from "../../base/ModelBuilder.js";
+import { PageSchema, PageModelBuilder as BuilderAbstraction } from "./abstractions.js";
+class PageModelBuilderImpl {
+  async buildModel() {
+    return new Builder("Page", PageSchema).withMethods({
+      hasTitle() {
+        return this.title !== "";
+      },
+      cancel() {}
+    });
+  }
+}
+export const PageModelBuilder = createImplementation({
+  abstraction: BuilderAbstraction,
+  implementation: PageModelBuilderImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=PageModelBuilder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","ModelBuilder","Builder","PageSchema","PageModelBuilder","BuilderAbstraction","PageModelBuilderImpl","buildModel","withMethods","hasTitle","title","cancel","abstraction","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,YAAY;AACjD,SAASC,YAAY,IAAIC,OAAO;AAChC,SAASC,UAAU,EAAEC,gBAAgB,IAAIC,kBAAkB;AAE3D,MAAMC,oBAAoB,CAAyC;EAC/D,MAAMC,UAAUA,CAAA,EAAG;IACf,OAAO,IAAIL,OAAO,CAAQ,MAAM,EAAEC,UAAU,CAAC,CAACK,WAAW,CAAC;MACtDC,QAAQA,CAAA,EAAG;QACP,OAAO,IAAI,CAACC,KAAK,KAAK,EAAE;MAC5B,CAAC;MACDC,MAAMA,CAAA,EAAG,CAAC;IACd,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMP,gBAAgB,GAAGJ,oBAAoB,CAAC;EACjDY,WAAW,EAAEP,kBAAkB;EAC/BQ,cAAc,EAAEP,oBAAoB;EACpCQ,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

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,22 @@
+import { createImplementation } from "@webiny/di";
+import { PageModelFactory as FactoryAbstraction, PageModelBuilder } 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);
+  }
+}
+export const PageModelFactory = createImplementation({
+  abstraction: FactoryAbstraction,
+  implementation: PageModelFactoryImpl,
+  dependencies: [PageModelBuilder]
+});
+
+//# sourceMappingURL=PageModelFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","PageModelFactory","FactoryAbstraction","PageModelBuilder","PageModelFactoryImpl","constructor","modelBuilder","create","data","modelClass","builder","buildModel","build","abstraction","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,YAAY;AACjD,SACIC,gBAAgB,IAAIC,kBAAkB,EACtCC,gBAAgB;AAKpB,MAAMC,oBAAoB,CAAyC;EAG/DC,WAAWA,CAASC,YAAwC,EAAE;IAAA,KAA1CA,YAAwC,GAAxCA,YAAwC;EAAG;EAE/D,MAAMC,MAAMA,CAACC,IAAoC,EAAkB;IAC/D,IAAI,IAAI,CAACC,UAAU,EAAE;MACjB,OAAO,IAAI,CAACA,UAAU,CAACF,MAAM,CAACC,IAAI,CAAC;IACvC;IAEA,MAAME,OAAO,GAAG,MAAM,IAAI,CAACJ,YAAY,CAACK,UAAU,CAAC,CAAC;IACpD,IAAI,CAACF,UAAU,GAAGC,OAAO,CAACE,KAAK,CAAC,CAAC;IAEjC,OAAO,IAAI,CAACH,UAAU,CAACF,MAAM,CAACC,IAAI,CAAC;EACvC;AACJ;AAEA,OAAO,MAAMP,gBAAgB,GAAGD,oBAAoB,CAAC;EACjDa,WAAW,EAAEX,kBAAkB;EAC/BY,cAAc,EAAEV,oBAAoB;EACpCW,YAAY,EAAE,CAACZ,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

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,26 @@
+import { createDecorator } from "@webiny/di";
+import { PageModelBuilder as BuilderAbstraction } 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 !== "";
+      }
+    });
+  }
+}
+export const PageModelBuilderDecorator = createDecorator({
+  abstraction: BuilderAbstraction,
+  decorator: PageModelBuilderDecoratorImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=PageModelBuilderDecorator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createDecorator","PageModelBuilder","BuilderAbstraction","PageModelBuilderDecoratorImpl","constructor","decoratee","buildModel","builder","extendSchema","z","seo","object","title","string","withMethods","hasSeoTitle","extensions","PageModelBuilderDecorator","abstraction","decorator","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,eAAe,QAAQ,YAAY;AAC5C,SAASC,gBAAgB,IAAIC,kBAAkB;AAE/C,MAAMC,6BAA6B,CAAyC;EACxEC,WAAWA,CAASC,SAAuC,EAAE;IAAA,KAAzCA,SAAuC,GAAvCA,SAAuC;EAAG;EAE9D,MAAMC,UAAUA,CAAA,EAAG;IACf,MAAMC,OAAO,GAAG,MAAM,IAAI,CAACF,SAAS,CAACC,UAAU,CAAC,CAAC;IAEjD,OAAOC,OAAO,CACTC,YAAY,CAACC,CAAC,KAAK;MAChBC,GAAG,EAAED,CAAC,CAACE,MAAM,CAAC;QACVC,KAAK,EAAEH,CAAC,CAACI,MAAM,CAAC;MACpB,CAAC;IACL,CAAC,CAAC,CAAC,CACFC,WAAW,CAAC;MACTC,WAAWA,CAAA,EAAG;QACV,OAAO,IAAI,CAACC,UAAU,EAAEN,GAAG,EAAEE,KAAK,KAAK,EAAE;MAC7C;IACJ,CAAC,CAAC;EACV;AACJ;AAEA,OAAO,MAAMK,yBAAyB,GAAGjB,eAAe,CAAC;EACrDkB,WAAW,EAAEhB,kBAAkB;EAC/BiB,SAAS,EAAEhB,6BAA6B;EACxCiB,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,15 @@
+import { PageModelBuilder as BuilderAbstraction } from "../abstractions.js";
+declare class PageModelBuilderDecorator2Impl implements BuilderAbstraction.Interface {
+    private decoratee;
+    constructor(decoratee: BuilderAbstraction.Interface);
+    buildModel(): Promise<import("../../../base/ModelBuilder.js").ModelBuilder<import("~/models/simple/Page/abstractions.js").IPage>>;
+}
+export declare const PageModelBuilderDecorator2: typeof PageModelBuilderDecorator2Impl;
+declare module "~/models/simple/Page/abstractions.js" {
+    interface IPageExtensions {
+        social?: {
+            description: string;
+        };
+    }
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { createDecorator } from "@webiny/di";
+import { PageModelBuilder as BuilderAbstraction } from "../abstractions.js";
+class PageModelBuilderDecorator2Impl {
+  constructor(decoratee) {
+    this.decoratee = decoratee;
+  }
+  async buildModel() {
+    const builder = await this.decoratee.buildModel();
+    return builder.extendSchema(z => ({
+      social: z.object({
+        description: z.string()
+      })
+    }));
+  }
+}
+export const PageModelBuilderDecorator2 = createDecorator({
+  abstraction: BuilderAbstraction,
+  decorator: PageModelBuilderDecorator2Impl,
+  dependencies: []
+});
+
+//# sourceMappingURL=PageModelBuilderDecorator2.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createDecorator","PageModelBuilder","BuilderAbstraction","PageModelBuilderDecorator2Impl","constructor","decoratee","buildModel","builder","extendSchema","z","social","object","description","string","PageModelBuilderDecorator2","abstraction","decorator","dependencies"],"sources":["PageModelBuilderDecorator2.ts"],"sourcesContent":["import { createDecorator } from \"@webiny/di\";\nimport { PageModelBuilder as BuilderAbstraction } from \"../abstractions.js\";\n\nclass PageModelBuilderDecorator2Impl implements BuilderAbstraction.Interface {\n    constructor(private decoratee: BuilderAbstraction.Interface) {}\n\n    async buildModel() {\n        const builder = await this.decoratee.buildModel();\n\n        return builder.extendSchema(z => ({\n            social: z.object({\n                description: z.string()\n            })\n        }));\n    }\n}\n\nexport const PageModelBuilderDecorator2 = createDecorator({\n    abstraction: BuilderAbstraction,\n    decorator: PageModelBuilderDecorator2Impl,\n    dependencies: []\n});\n\ndeclare module \"~/models/simple/Page/abstractions.js\" {\n    interface IPageExtensions {\n        social?: { description: string };\n    }\n}\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,YAAY;AAC5C,SAASC,gBAAgB,IAAIC,kBAAkB;AAE/C,MAAMC,8BAA8B,CAAyC;EACzEC,WAAWA,CAASC,SAAuC,EAAE;IAAA,KAAzCA,SAAuC,GAAvCA,SAAuC;EAAG;EAE9D,MAAMC,UAAUA,CAAA,EAAG;IACf,MAAMC,OAAO,GAAG,MAAM,IAAI,CAACF,SAAS,CAACC,UAAU,CAAC,CAAC;IAEjD,OAAOC,OAAO,CAACC,YAAY,CAACC,CAAC,KAAK;MAC9BC,MAAM,EAAED,CAAC,CAACE,MAAM,CAAC;QACbC,WAAW,EAAEH,CAAC,CAACI,MAAM,CAAC;MAC1B,CAAC;IACL,CAAC,CAAC,CAAC;EACP;AACJ;AAEA,OAAO,MAAMC,0BAA0B,GAAGd,eAAe,CAAC;EACtDe,WAAW,EAAEb,kBAAkB;EAC/Bc,SAAS,EAAEb,8BAA8B;EACzCc,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export {};

package/models/simple/Page/__tests__/PageModelFactory.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { Container } from "@webiny/di";
+import { PageModelBuilder } from "../PageModelBuilder.js";
+import { PageModelFactory } from "../PageModelFactory.js";
+import { PageModelFactory as FactoryAbstraction } from "../abstractions.js";
+import { PageModelBuilderDecorator } from "./PageModelBuilderDecorator.js";
+import { PageModelBuilderDecorator2 } from "./PageModelBuilderDecorator2.js";
+describe("PageModelFactory", () => {
+  it("should be able to create page instance", async () => {
+    const container = new Container();
+    container.register(PageModelBuilder);
+    container.register(PageModelFactory);
+    container.registerDecorator(PageModelBuilderDecorator);
+    container.registerDecorator(PageModelBuilderDecorator2);
+    const pageModelFactory = container.resolve(FactoryAbstraction);
+    const page1 = await pageModelFactory.create({
+      id: "1",
+      title: "Test",
+      content: "test",
+      publishedAt: new Date(),
+      extensions: {
+        seo: {
+          title: "SEO"
+        },
+        social: {
+          description: "Networking"
+        }
+      }
+    });
+    expect(page1.title).toEqual("Test");
+    expect(page1.extensions?.seo?.title).toEqual("SEO");
+    expect(page1.extensions?.social?.description).toEqual("Networking");
+    expect(page1.hasTitle()).toEqual(true);
+    expect(page1.hasSeoTitle()).toEqual(true);
+  });
+});
+
+//# sourceMappingURL=PageModelFactory.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["describe","expect","it","Container","PageModelBuilder","PageModelFactory","FactoryAbstraction","PageModelBuilderDecorator","PageModelBuilderDecorator2","container","register","registerDecorator","pageModelFactory","resolve","page1","create","id","title","content","publishedAt","Date","extensions","seo","social","description","toEqual","hasTitle","hasSeoTitle"],"sources":["PageModelFactory.test.ts"],"sourcesContent":["import { describe, expect, it } from \"vitest\";\nimport { Container } from \"@webiny/di\";\nimport { PageModelBuilder } from \"~/models/simple/Page/PageModelBuilder.js\";\nimport { PageModelFactory } from \"~/models/simple/Page/PageModelFactory.js\";\nimport { PageModelFactory as FactoryAbstraction } from \"~/models/simple/Page/abstractions.js\";\nimport { PageModelBuilderDecorator } from \"./PageModelBuilderDecorator.js\";\nimport { PageModelBuilderDecorator2 } from \"./PageModelBuilderDecorator2.js\";\n\ndescribe(\"PageModelFactory\", () => {\n    it(\"should be able to create page instance\", async () => {\n        const container = new Container();\n        container.register(PageModelBuilder);\n        container.register(PageModelFactory);\n        container.registerDecorator(PageModelBuilderDecorator);\n        container.registerDecorator(PageModelBuilderDecorator2);\n\n        const pageModelFactory = container.resolve(FactoryAbstraction);\n\n        const page1 = await pageModelFactory.create({\n            id: \"1\",\n            title: \"Test\",\n            content: \"test\",\n            publishedAt: new Date(),\n            extensions: {\n                seo: {\n                    title: \"SEO\"\n                },\n                social: {\n                    description: \"Networking\"\n                }\n            }\n        });\n\n        expect(page1.title).toEqual(\"Test\");\n        expect(page1.extensions?.seo?.title).toEqual(\"SEO\");\n        expect(page1.extensions?.social?.description).toEqual(\"Networking\");\n        expect(page1.hasTitle()).toEqual(true);\n        expect(page1.hasSeoTitle()).toEqual(true);\n    });\n});\n"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,QAAQ;AAC7C,SAASC,SAAS,QAAQ,YAAY;AACtC,SAASC,gBAAgB;AACzB,SAASC,gBAAgB;AACzB,SAASA,gBAAgB,IAAIC,kBAAkB;AAC/C,SAASC,yBAAyB;AAClC,SAASC,0BAA0B;AAEnCR,QAAQ,CAAC,kBAAkB,EAAE,MAAM;EAC/BE,EAAE,CAAC,wCAAwC,EAAE,YAAY;IACrD,MAAMO,SAAS,GAAG,IAAIN,SAAS,CAAC,CAAC;IACjCM,SAAS,CAACC,QAAQ,CAACN,gBAAgB,CAAC;IACpCK,SAAS,CAACC,QAAQ,CAACL,gBAAgB,CAAC;IACpCI,SAAS,CAACE,iBAAiB,CAACJ,yBAAyB,CAAC;IACtDE,SAAS,CAACE,iBAAiB,CAACH,0BAA0B,CAAC;IAEvD,MAAMI,gBAAgB,GAAGH,SAAS,CAACI,OAAO,CAACP,kBAAkB,CAAC;IAE9D,MAAMQ,KAAK,GAAG,MAAMF,gBAAgB,CAACG,MAAM,CAAC;MACxCC,EAAE,EAAE,GAAG;MACPC,KAAK,EAAE,MAAM;MACbC,OAAO,EAAE,MAAM;MACfC,WAAW,EAAE,IAAIC,IAAI,CAAC,CAAC;MACvBC,UAAU,EAAE;QACRC,GAAG,EAAE;UACDL,KAAK,EAAE;QACX,CAAC;QACDM,MAAM,EAAE;UACJC,WAAW,EAAE;QACjB;MACJ;IACJ,CAAC,CAAC;IAEFvB,MAAM,CAACa,KAAK,CAACG,KAAK,CAAC,CAACQ,OAAO,CAAC,MAAM,CAAC;IACnCxB,MAAM,CAACa,KAAK,CAACO,UAAU,EAAEC,GAAG,EAAEL,KAAK,CAAC,CAACQ,OAAO,CAAC,KAAK,CAAC;IACnDxB,MAAM,CAACa,KAAK,CAACO,UAAU,EAAEE,MAAM,EAAEC,WAAW,CAAC,CAACC,OAAO,CAAC,YAAY,CAAC;IACnExB,MAAM,CAACa,KAAK,CAACY,QAAQ,CAAC,CAAC,CAAC,CAACD,OAAO,CAAC,IAAI,CAAC;IACtCxB,MAAM,CAACa,KAAK,CAACa,WAAW,CAAC,CAAC,CAAC,CAACF,OAAO,CAAC,IAAI,CAAC;EAC7C,CAAC,CAAC;AACN,CAAC,CAAC","ignoreList":[]}