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

package/models/base/BaseModel.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","WebinyError","BaseModel","__schema","Error","constructor","data","validateData","populate","Object","assign","validate","toData","ok","error","fail","validateOrThrow","clone","Constructor","_def","typeName","result","shape","key","structuredClone","updateWith","partial","updated","safeParse","success","message","code","errors"],"sources":["BaseModel.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { WebinyError } from \"@webiny/error\";\nimport z from \"zod\";\n\ntype DataProperties<T> = Omit<T, \"__schema\">;\n\nexport type IModelData<T> = {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    [K in keyof DataProperties<T> as T[K] extends Function ? never : K]: T[K];\n};\n\nexport type IModelInput<T> = IModelData<T>;\n\nexport abstract class BaseModel<TModel extends z.ZodObject<any> = any> {\n    get __schema(): TModel {\n        throw new Error(\"Schema getter is not implemented!\");\n    }\n\n    constructor(data: IModelData<TModel>) {\n        this.validateData(data);\n        this.populate(data);\n    }\n\n    populate(data: IModelData<TModel>): void {\n        Object.assign(this, data);\n    }\n\n    validate(): Result<true, WebinyError> {\n        try {\n            this.validateData(this.toData());\n            return Result.ok(true);\n        } catch (error) {\n            return Result.fail(error);\n        }\n    }\n\n    validateOrThrow(): void {\n        this.validateData(this.toData());\n    }\n\n    clone(): this {\n        const Constructor = this.constructor as new (data: IModelData<TModel>) => this;\n        return new Constructor(this.toData());\n    }\n\n    toData(): IModelData<TModel> {\n        if (this.__schema && this.__schema._def?.typeName === \"ZodObject\") {\n            const result = {} as IModelData<TModel>;\n            const shape = this.__schema.shape;\n            for (const key in shape) {\n                // always use structuredClone for safety.\n                // @ts-expect-error allow index.\n                result[key] = structuredClone(this[key]);\n            }\n            return result;\n        }\n\n        return { ...(this as any) } as IModelData<TModel>;\n    }\n\n    updateWith(partial: Partial<IModelData<this>>): void {\n        const updated = { ...this.toData(), ...partial };\n        this.validateData(updated);\n        this.populate(updated);\n    }\n\n    protected validateData(data: IModelData<TModel>): void {\n        const result = this.__schema.safeParse(data);\n        if (!result.success) {\n            throw new WebinyError({\n                message: \"Validation error\",\n                code: \"DOMAIN_MODEL_VALIDATION_ERROR\",\n                data: result.error.errors\n            });\n        }\n    }\n}\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,WAAW,QAAQ,eAAe;AAY3C,OAAO,MAAeC,SAAS,CAAwC;EACnE,IAAIC,QAAQA,CAAA,EAAW;IACnB,MAAM,IAAIC,KAAK,CAAC,mCAAmC,CAAC;EACxD;EAEAC,WAAWA,CAACC,IAAwB,EAAE;IAClC,IAAI,CAACC,YAAY,CAACD,IAAI,CAAC;IACvB,IAAI,CAACE,QAAQ,CAACF,IAAI,CAAC;EACvB;EAEAE,QAAQA,CAACF,IAAwB,EAAQ;IACrCG,MAAM,CAACC,MAAM,CAAC,IAAI,EAAEJ,IAAI,CAAC;EAC7B;EAEAK,QAAQA,CAAA,EAA8B;IAClC,IAAI;MACA,IAAI,CAACJ,YAAY,CAAC,IAAI,CAACK,MAAM,CAAC,CAAC,CAAC;MAChC,OAAOZ,MAAM,CAACa,EAAE,CAAC,IAAI,CAAC;IAC1B,CAAC,CAAC,OAAOC,KAAK,EAAE;MACZ,OAAOd,MAAM,CAACe,IAAI,CAACD,KAAK,CAAC;IAC7B;EACJ;EAEAE,eAAeA,CAAA,EAAS;IACpB,IAAI,CAACT,YAAY,CAAC,IAAI,CAACK,MAAM,CAAC,CAAC,CAAC;EACpC;EAEAK,KAAKA,CAAA,EAAS;IACV,MAAMC,WAAW,GAAG,IAAI,CAACb,WAAqD;IAC9E,OAAO,IAAIa,WAAW,CAAC,IAAI,CAACN,MAAM,CAAC,CAAC,CAAC;EACzC;EAEAA,MAAMA,CAAA,EAAuB;IACzB,IAAI,IAAI,CAACT,QAAQ,IAAI,IAAI,CAACA,QAAQ,CAACgB,IAAI,EAAEC,QAAQ,KAAK,WAAW,EAAE;MAC/D,MAAMC,MAAM,GAAG,CAAC,CAAuB;MACvC,MAAMC,KAAK,GAAG,IAAI,CAACnB,QAAQ,CAACmB,KAAK;MACjC,KAAK,MAAMC,GAAG,IAAID,KAAK,EAAE;QACrB;QACA;QACAD,MAAM,CAACE,GAAG,CAAC,GAAGC,eAAe,CAAC,IAAI,CAACD,GAAG,CAAC,CAAC;MAC5C;MACA,OAAOF,MAAM;IACjB;IAEA,OAAO;MAAE,GAAI;IAAa,CAAC;EAC/B;EAEAI,UAAUA,CAACC,OAAkC,EAAQ;IACjD,MAAMC,OAAO,GAAG;MAAE,GAAG,IAAI,CAACf,MAAM,CAAC,CAAC;MAAE,GAAGc;IAAQ,CAAC;IAChD,IAAI,CAACnB,YAAY,CAACoB,OAAO,CAAC;IAC1B,IAAI,CAACnB,QAAQ,CAACmB,OAAO,CAAC;EAC1B;EAEUpB,YAAYA,CAACD,IAAwB,EAAQ;IACnD,MAAMe,MAAM,GAAG,IAAI,CAAClB,QAAQ,CAACyB,SAAS,CAACtB,IAAI,CAAC;IAC5C,IAAI,CAACe,MAAM,CAACQ,OAAO,EAAE;MACjB,MAAM,IAAI5B,WAAW,CAAC;QAClB6B,OAAO,EAAE,kBAAkB;QAC3BC,IAAI,EAAE,+BAA+B;QACrCzB,IAAI,EAAEe,MAAM,CAACP,KAAK,CAACkB;MACvB,CAAC,CAAC;IACN;EACJ;AACJ","ignoreList":[]}

package/models/base/ModelBuilder.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { BaseModel, type IModelData as ExtractModelData } from "./BaseModel.js";
+export type ModelClass<TModel extends BaseModel<any>> = {
+    __schema: TModel["__schema"];
+    new (data: ExtractModelData<TModel>): TModel;
+    create(data: ExtractModelData<TModel>): TModel;
+};
+export declare const createModelSchema: <TReturn extends z.ZodRawShape>(factory: (zod: typeof z) => TReturn) => z.ZodObject<TReturn, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TReturn>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<TReturn> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+export declare class ModelBuilder<TModel extends BaseModel<any>> {
+    private name;
+    private schema;
+    private methods;
+    constructor(name: string, schema: TModel["__schema"]);
+    extendSchema<TExt extends z.ZodRawShape>(extensionFn: (zod: typeof z) => TExt): this;
+    withMethods<TExtMethods extends object>(methods: TExtMethods & ThisType<TModel & TExtMethods>): ModelBuilder<TModel & TExtMethods>;
+    getSchema(): TModel["__schema"];
+    build(): ModelClass<TModel>;
+}

package/models/base/ModelBuilder.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { BaseModel } from "./BaseModel.js";
+export const createModelSchema = factory => {
+  return z.object({
+    ...factory(z)
+  });
+};
+export class ModelBuilder {
+  methods = {};
+  constructor(name, schema) {
+    this.name = name;
+    this.schema = schema;
+    this.methods = {};
+  }
+  extendSchema(extensionFn) {
+    const shape = extensionFn(z);
+    const baseExtensions = this.schema.shape.extensions;
+    let baseExtensionsObject;
+    if (baseExtensions instanceof z.ZodObject) {
+      baseExtensionsObject = baseExtensions;
+    } else if (baseExtensions) {
+      let inner = baseExtensions;
+      while (inner && "_def" in inner && ["ZodOptional", "ZodNullable", "ZodDefault"].includes(inner._def.typeName)) {
+        inner = inner._def.innerType;
+      }
+      baseExtensionsObject = inner instanceof z.ZodObject ? inner : z.object({});
+    } else {
+      baseExtensionsObject = z.object({});
+    }
+    const newExtensions = baseExtensionsObject.extend(shape);
+    this.schema = this.schema.extend({
+      extensions: newExtensions
+    });
+    return this;
+  }
+  withMethods(methods) {
+    Object.assign(this.methods, methods);
+    return this;
+  }
+  getSchema() {
+    return this.schema;
+  }
+  build() {
+    const schema = this.schema;
+    const methods = this.methods;
+    const name = this.name;
+    class Model extends BaseModel {
+      get __schema() {
+        return schema;
+      }
+      static __schema = schema;
+      static create(data) {
+        return new this(data);
+      }
+      clone() {
+        const Constructor = this.constructor;
+        return new Constructor(this.toData());
+      }
+    }
+    Object.assign(Model.prototype, methods);
+    Object.defineProperty(Model.prototype, Symbol.toStringTag, {
+      value: name
+    });
+    return Model;
+  }
+}
+
+//# sourceMappingURL=ModelBuilder.js.map

package/models/base/ModelBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["z","BaseModel","createModelSchema","factory","object","ModelBuilder","methods","constructor","name","schema","extendSchema","extensionFn","shape","baseExtensions","extensions","baseExtensionsObject","ZodObject","inner","includes","_def","typeName","innerType","newExtensions","extend","withMethods","Object","assign","getSchema","build","Model","__schema","create","data","clone","Constructor","toData","prototype","defineProperty","Symbol","toStringTag","value"],"sources":["ModelBuilder.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { BaseModel, type IModelData as ExtractModelData } from \"./BaseModel.js\";\n\nexport type ModelClass<TModel extends BaseModel<any>> = {\n    __schema: TModel[\"__schema\"];\n    new (data: ExtractModelData<TModel>): TModel;\n    create(data: ExtractModelData<TModel>): TModel;\n};\n\nexport const createModelSchema = <TReturn extends z.ZodRawShape>(\n    factory: (zod: typeof z) => TReturn\n) => {\n    return z.object({ ...factory(z) });\n};\n\nexport class ModelBuilder<TModel extends BaseModel<any>> {\n    private methods: Partial<Record<keyof TModel, any>> = {};\n\n    constructor(\n        private name: string,\n        private schema: TModel[\"__schema\"]\n    ) {\n        this.methods = {};\n    }\n\n    extendSchema<TExt extends z.ZodRawShape>(extensionFn: (zod: typeof z) => TExt): this {\n        const shape = extensionFn(z);\n        const baseExtensions = (this.schema.shape as any).extensions;\n\n        let baseExtensionsObject: z.ZodObject<any>;\n        if (baseExtensions instanceof z.ZodObject) {\n            baseExtensionsObject = baseExtensions;\n        } else if (baseExtensions) {\n            let inner = baseExtensions as any;\n            while (\n                inner &&\n                \"_def\" in inner &&\n                [\"ZodOptional\", \"ZodNullable\", \"ZodDefault\"].includes(inner._def.typeName)\n            ) {\n                inner = inner._def.innerType;\n            }\n            baseExtensionsObject = inner instanceof z.ZodObject ? inner : z.object({});\n        } else {\n            baseExtensionsObject = z.object({});\n        }\n\n        const newExtensions = baseExtensionsObject.extend(shape);\n        this.schema = this.schema.extend({\n            extensions: newExtensions\n        }) as TModel[\"__schema\"];\n\n        return this;\n    }\n\n    withMethods<TExtMethods extends object>(\n        methods: TExtMethods & ThisType<TModel & TExtMethods>\n    ): ModelBuilder<TModel & TExtMethods> {\n        Object.assign(this.methods, methods);\n        return this as unknown as ModelBuilder<TModel & TExtMethods>;\n    }\n\n    getSchema() {\n        return this.schema;\n    }\n\n    build(): ModelClass<TModel> {\n        const schema = this.schema;\n        const methods = this.methods;\n        const name = this.name;\n\n        type ModelData = ExtractModelData<TModel>;\n\n        class Model extends BaseModel<TModel[\"__schema\"]> {\n            public override get __schema() {\n                return schema;\n            }\n\n            static __schema = schema;\n\n            static create(data: ModelData) {\n                return new this(data) as unknown as TModel;\n            }\n\n            override clone(): this {\n                const Constructor = this.constructor as new (data: ModelData) => this;\n                return new Constructor(this.toData());\n            }\n        }\n\n        Object.assign(Model.prototype, methods);\n\n        Object.defineProperty(Model.prototype, Symbol.toStringTag, {\n            value: name\n        });\n\n        return Model as unknown as ModelClass<TModel>;\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/models/base/ModelFactory.js

@@ -0,0 +1,3 @@
+
+
+//# sourceMappingURL=ModelFactory.js.map

package/models/base/ModelFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["ModelFactory.ts"],"sourcesContent":[""],"mappings":"","ignoreList":[]}

package/models/base/__tests__/ModelBuilder.test.d.ts

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

package/models/base/__tests__/ModelBuilder.test.js

@@ -0,0 +1,468 @@
+import { describe, it, expect } from "vitest";
+import { createModelSchema, ModelBuilder } from "../ModelBuilder.js";
+describe("ModelBuilder", () => {
+  describe("Basic functionality", () => {
+    it("should create a model class from schema", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        name: z.string()
+      }));
+      const builder = new ModelBuilder("Model", schema);
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        name: "Test"
+      });
+      expect(instance.id).toBe("1");
+      expect(instance.name).toBe("Test");
+    });
+    it("should expose schema as static property", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        name: z.string()
+      }));
+      const builder = new ModelBuilder("Model", schema);
+      const Model = builder.build();
+      expect(Model.__schema).toBeDefined();
+    });
+    it("should validate data on construction", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        age: z.number()
+      }));
+      const builder = new ModelBuilder("Model", schema);
+      const Model = builder.build();
+      expect(() => {
+        new Model({
+          id: "1",
+          age: "not a number"
+        });
+      }).toThrow("Validation error");
+    });
+    it("should throw on missing required fields", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        required: z.string()
+      }));
+      const builder = new ModelBuilder("Model", schema);
+      const Model = builder.build();
+      expect(() => {
+        new Model({
+          id: "1"
+        });
+      }).toThrow("Validation error");
+    });
+  });
+  describe("withMethods", () => {
+    it("should add methods to model", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        active: z.boolean()
+      }));
+      const builder = new ModelBuilder("Model", schema).withMethods({
+        isActive() {
+          return this.active;
+        },
+        activate() {
+          this.active = true;
+        }
+      });
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        active: false
+      });
+      expect(instance.isActive()).toBe(false);
+      instance.activate();
+      expect(instance.isActive()).toBe(true);
+    });
+    it("should chain multiple withMethods calls", () => {
+      const schema = createModelSchema(z => ({
+        count: z.number()
+      }));
+      const builder = new ModelBuilder("Model", schema).withMethods({
+        increment() {
+          this.count++;
+        }
+      }).withMethods({
+        decrement() {
+          this.count--;
+        }
+      });
+      const Model = builder.build();
+      const instance = new Model({
+        count: 5
+      });
+      instance.increment();
+      expect(instance.count).toBe(6);
+      instance.decrement();
+      expect(instance.count).toBe(5);
+    });
+    it("should have access to all properties in methods", () => {
+      const schema = createModelSchema(z => ({
+        firstName: z.string(),
+        lastName: z.string()
+      }));
+      const builder = new ModelBuilder("Model", schema).withMethods({
+        getFullName() {
+          return `${this.firstName} ${this.lastName}`;
+        }
+      });
+      const Model = builder.build();
+      const instance = new Model({
+        firstName: "John",
+        lastName: "Doe"
+      });
+      expect(instance.getFullName()).toBe("John Doe");
+    });
+  });
+  describe("extendSchema", () => {
+    it("should extend schema with new fields in extensions", () => {
+      const baseSchema = createModelSchema(z => ({
+        id: z.string()
+      }));
+      const builder = new ModelBuilder("Model", baseSchema).extendSchema(z => ({
+        name: z.string(),
+        age: z.number()
+      }));
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        // @ts-expect-error In a real environment, you'll never have everything in one file, so interface will be augmented.
+        extensions: {
+          name: "Test",
+          age: 25
+        }
+      });
+      expect(instance.id).toBe("1");
+      // @ts-expect-error
+      expect(instance.extensions.name).toBe("Test");
+      // @ts-expect-error
+      expect(instance.extensions.age).toBe(25);
+    });
+    it("should validate extended fields", () => {
+      const baseSchema = createModelSchema(z => ({
+        id: z.string()
+      }));
+      const builder = new ModelBuilder("Model", baseSchema).extendSchema(z => ({
+        email: z.string().email()
+      }));
+      const Model = builder.build();
+      expect(() => {
+        // @ts-expect-error
+        new Model({
+          id: "1",
+          extensions: {
+            email: "invalid-email"
+          }
+        });
+      }).toThrow("Validation error");
+      const valid = new Model({
+        id: "1",
+        // @ts-expect-error
+        extensions: {
+          email: "test@example.com"
+        }
+      });
+      // @ts-expect-error
+      expect(valid.extensions.email).toBe("test@example.com");
+    });
+    it("should chain extendSchema calls", () => {
+      const baseSchema = createModelSchema(z => ({
+        id: z.string()
+      }));
+      const builder = new ModelBuilder("Model", baseSchema).extendSchema(z => ({
+        name: z.string()
+      })).extendSchema(z => ({
+        age: z.number()
+      }));
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        // @ts-expect-error In a real environment, you'll never have everything in one file, so interface will be augmented.
+        extensions: {
+          name: "Test",
+          age: 30
+        }
+      });
+      expect(instance.id).toBe("1");
+      // @ts-expect-error
+      expect(instance.extensions.name).toBe("Test");
+      // @ts-expect-error
+      expect(instance.extensions.age).toBe(30);
+    });
+    it("should preserve methods when extending schema", () => {
+      const baseSchema = createModelSchema(z => ({
+        count: z.number()
+      }));
+      const builder = new ModelBuilder("Model", baseSchema).withMethods({
+        increment() {
+          this.count++;
+        }
+      }).extendSchema(z => ({
+        name: z.string()
+      }));
+      const Model = builder.build();
+      const instance = new Model({
+        count: 5,
+        // @ts-expect-error
+        extensions: {
+          name: "Counter"
+        }
+      });
+      instance.increment();
+      expect(instance.count).toBe(6);
+      // @ts-expect-error
+      expect(instance.extensions.name).toBe("Counter");
+    });
+  });
+  describe("clone", () => {
+    it("should create a copy of the instance", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        name: z.string()
+      }));
+      const builder = new ModelBuilder("Model", schema);
+      const Model = builder.build();
+      const original = new Model({
+        id: "1",
+        name: "Original"
+      });
+      const cloned = original.clone();
+      expect(cloned).not.toBe(original);
+      expect(cloned.id).toBe(original.id);
+      expect(cloned.name).toBe(original.name);
+    });
+    it("should clone with methods intact", () => {
+      const schema = createModelSchema(z => ({
+        count: z.number()
+      }));
+      const builder = new ModelBuilder("Model", schema).withMethods({
+        increment() {
+          this.count++;
+        }
+      });
+      const Model = builder.build();
+      const original = new Model({
+        count: 5
+      });
+      const cloned = original.clone();
+      cloned.increment();
+      expect(original.count).toBe(5);
+      expect(cloned.count).toBe(6);
+    });
+    it("should preserve extended properties in clone", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string()
+      }));
+      const builder = new ModelBuilder("Model", schema).extendSchema(z => ({
+        metadata: z.object({
+          key: z.string()
+        }).optional()
+      }));
+      const Model = builder.build();
+      const original = new Model({
+        id: "1",
+        // @ts-expect-error
+        extensions: {
+          metadata: {
+            key: "value"
+          }
+        }
+      });
+      const cloned = original.clone();
+
+      // @ts-expect-error
+      expect(cloned.extensions.metadata).toEqual({
+        key: "value"
+      });
+    });
+  });
+  describe("updateWith", () => {
+    it("should update properties", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        name: z.string(),
+        age: z.number()
+      }));
+      const builder = new ModelBuilder("Model", schema);
+      const Model = builder.build();
+      const instance = Model.create({
+        id: "1",
+        name: "John",
+        age: 25
+      });
+      instance.updateWith({
+        name: "Jane",
+        age: 30
+      });
+      expect(instance.id).toBe("1");
+      expect(instance.name).toBe("Jane");
+      expect(instance.age).toBe(30);
+    });
+    it("should validate updated data", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        email: z.string().email()
+      }));
+      const builder = new ModelBuilder("Model", schema);
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        email: "valid@example.com"
+      });
+      expect(() => {
+        instance.updateWith({
+          email: "invalid-email"
+        });
+      }).toThrow("Validation error");
+      expect(instance.email).toBe("valid@example.com");
+    });
+    it("should allow partial updates", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        name: z.string(),
+        age: z.number()
+      }));
+      const builder = new ModelBuilder("Model", schema);
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        name: "John",
+        age: 25
+      });
+      instance.updateWith({
+        age: 26
+      });
+      expect(instance.id).toBe("1");
+      expect(instance.name).toBe("John");
+      expect(instance.age).toBe(26);
+    });
+  });
+  describe("Complex composition", () => {
+    it("should handle full extension chain", () => {
+      const baseSchema = createModelSchema(z => ({
+        id: z.string(),
+        title: z.string()
+      }));
+      const builder = new ModelBuilder("Model", baseSchema).withMethods({
+        getTitle() {
+          return this.title;
+        }
+      }).extendSchema(z => ({
+        publishedAt: z.date().nullable()
+      })).withMethods({
+        publish() {
+          // @ts-expect-error
+          this.extensions.publishedAt = new Date();
+        },
+        isPublished() {
+          // @ts-expect-error
+          return this.extensions.publishedAt !== null;
+        }
+      }).extendSchema(z => ({
+        metadata: z.object({
+          seo: z.string().optional()
+        }).optional()
+      })).withMethods({
+        hasSeo() {
+          // @ts-expect-error
+          return !!this.extensions.metadata?.seo;
+        }
+      });
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        title: "Test Post",
+        // @ts-expect-error In a real environment, you'll never have everything in one file, so interface will be augmented.
+        extensions: {
+          publishedAt: null,
+          metadata: {
+            seo: "SEO Title"
+          }
+        }
+      });
+      instance.title = "Test Post";
+      expect(instance.getTitle()).toBe("Test Post");
+      expect(instance.isPublished()).toBe(false);
+      expect(instance.hasSeo()).toBe(true);
+      instance.publish();
+      expect(instance.isPublished()).toBe(true);
+    });
+    it("should support nested object schemas", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        author: z.object({
+          name: z.string(),
+          email: z.string()
+        })
+      }));
+      const builder = new ModelBuilder("Model", schema).withMethods({
+        getAuthorName() {
+          return this.author.name;
+        }
+      });
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        author: {
+          name: "John",
+          email: "john@example.com"
+        }
+      });
+      expect(instance.getAuthorName()).toBe("John");
+    });
+    it("should support array fields in schema", () => {
+      const schema = createModelSchema(z => ({
+        id: z.string(),
+        tags: z.array(z.string())
+      }));
+      const builder = new ModelBuilder("Model", schema).withMethods({
+        hasTag(tag) {
+          return this.tags.includes(tag);
+        },
+        addTag(tag) {
+          if (!this.tags.includes(tag)) {
+            this.tags.push(tag);
+          }
+        }
+      });
+      const Model = builder.build();
+      const instance = new Model({
+        id: "1",
+        tags: ["typescript", "testing"]
+      });
+      expect(instance.hasTag("typescript")).toBe(true);
+      expect(instance.hasTag("javascript")).toBe(false);
+      instance.addTag("javascript");
+      expect(instance.hasTag("javascript")).toBe(true);
+    });
+  });
+  describe("getSchema", () => {
+    it("should return the current schema", () => {
+      const baseSchema = createModelSchema(z => ({
+        id: z.string()
+      }));
+      const builder = new ModelBuilder("Model", baseSchema);
+      expect(builder.getSchema()).toBeDefined();
+    });
+    it("should return extended schema after extendSchema", () => {
+      const baseSchema = createModelSchema(z => ({
+        id: z.string()
+      }));
+      const extendedBuilder = new ModelBuilder("Model", baseSchema).extendSchema(z => ({
+        name: z.string()
+      }));
+      const schema = extendedBuilder.getSchema();
+      const result = schema.safeParse({
+        id: "1",
+        extensions: {
+          name: "Test"
+        }
+      });
+      expect(result.success).toBe(true);
+    });
+  });
+});
+
+//# sourceMappingURL=ModelBuilder.test.js.map