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

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

@@ -0,0 +1,451 @@
+import { describe, expect, it } from "vitest";
+import { ModelBuilder, createModelSchema } 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",
+                extensions: {
+                    name: "Test",
+                    age: 25
+                }
+            });
+            expect(instance.id).toBe("1");
+            expect(instance.extensions.name).toBe("Test");
+            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(()=>{
+                new Model({
+                    id: "1",
+                    extensions: {
+                        email: "invalid-email"
+                    }
+                });
+            }).toThrow("Validation error");
+            const valid = new Model({
+                id: "1",
+                extensions: {
+                    email: "test@example.com"
+                }
+            });
+            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",
+                extensions: {
+                    name: "Test",
+                    age: 30
+                }
+            });
+            expect(instance.id).toBe("1");
+            expect(instance.extensions.name).toBe("Test");
+            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,
+                extensions: {
+                    name: "Counter"
+                }
+            });
+            instance.increment();
+            expect(instance.count).toBe(6);
+            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",
+                extensions: {
+                    metadata: {
+                        key: "value"
+                    }
+                }
+            });
+            const cloned = original.clone();
+            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 () {
+                    this.extensions.publishedAt = new Date();
+                },
+                isPublished () {
+                    return null !== this.extensions.publishedAt;
+                }
+            }).extendSchema((z)=>({
+                    metadata: z.object({
+                        seo: z.string().optional()
+                    }).optional()
+                })).withMethods({
+                hasSeo () {
+                    return !!this.extensions.metadata?.seo;
+                }
+            });
+            const Model = builder.build();
+            const instance = new Model({
+                id: "1",
+                title: "Test Post",
+                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

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

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

package/models/base/abstractions.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import type { ModelBuilder } from "./ModelBuilder.js";
+import { BaseModel, type IModelData } from "./BaseModel.js";
+export type { IModelInput, IModelData } from "./BaseModel.js";
+export type IModel<TSchema extends z.ZodObject<any>> = BaseModel<TSchema> & z.infer<TSchema>;
+/**
+ * Builder builds the model class (not an instance).
+ * It knows both the schema and the public model interface.
+ */
+export interface IModelBuilder<TModel extends BaseModel<any>> {
+    buildModel(): Promise<ModelBuilder<TModel>>;
+}
+/**
+ * Factory creates model instances.
+ * It directly produces the model with the correct schema and public interface.
+ */
+export interface IModelFactory<TModel extends BaseModel<any>> {
+    create(data: IModelData<TModel>): Promise<TModel>;
+}

package/models/cms/FieldBuilder.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { FieldConfig } from "./types.js";
+import type { IFieldBuilderRegistry } from "./abstractions.js";
+export declare abstract class FieldBuilder<TZod extends z.ZodTypeAny> {
+    protected config: Partial<FieldConfig>;
+    protected zodSchema: TZod;
+    constructor(type: string, initialSchema: TZod);
+    label(text: string): this;
+    help(text: string): this;
+    placeholder(text: string): this;
+    toConfig(): FieldConfig;
+    getZodSchema(): TZod;
+}
+export declare class TextFieldBuilder<TZod extends z.ZodString = z.ZodString> extends FieldBuilder<TZod> {
+    constructor(schema?: TZod);
+    required(message?: string): TextFieldBuilder<z.ZodString>;
+    minLength(length: number, message?: string): this;
+    maxLength(length: number, message?: string): this;
+    slug(): this;
+    email(): this;
+    url(): this;
+    private addStringValidator;
+    unique(): this;
+}
+export declare class ObjectFieldBuilder<TShape extends z.ZodRawShape> extends FieldBuilder<z.ZodObject<TShape>> {
+    private readonly nestedFields;
+    constructor(fields: (registry: IFieldBuilderRegistry) => {
+        [K in keyof TShape]: FieldBuilder<TShape[K] & z.ZodTypeAny>;
+    }, registry: IFieldBuilderRegistry);
+    optional(): ObjectFieldBuilder<TShape> & {
+        getZodSchema(): z.ZodOptional<z.ZodObject<TShape>>;
+    };
+    nullable(): ObjectFieldBuilder<TShape> & {
+        getZodSchema(): z.ZodNullable<z.ZodObject<TShape>>;
+    };
+    toConfig(): FieldConfig;
+}