@casekit/orm2-testing 0.0.0-20250331202540 → 1.0.0

package/package.json

@@ -1,41 +1,40 @@
 {
   "name": "@casekit/orm2-testing",
   "description": "",
-  "version": "0.0.0-20250331202540",
+  "version": "1.0.0",
   "author": "",
   "dependencies": {
-    "@anatine/zod-mock": "^3.13.5",
-    "es-toolkit": "^1.33.0",
-    "@casekit/orm2-config": "0.0.0-20250331202540",
-    "@casekit/sql": "0.0.0-20250331202540",
-    "@casekit/orm2-schema": "0.0.0-20250331202540",
-    "@casekit/toolbox": "0.0.0-20250331202540"
+    "@faker-js/faker": "^9.8.0",
+    "es-toolkit": "^1.39.3",
+    "@casekit/orm2-config": "1.0.0",
+    "@casekit/sql": "1.0.0",
+    "@casekit/toolbox": "1.0.0",
+    "@casekit/orm2-schema": "1.0.0"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
-    "@types/node": "^22.13.13",
-    "@vitest/coverage-v8": "^3.0.9",
+    "@types/node": "^24.0.3",
+    "@vitest/coverage-v8": "^3.2.4",
     "prettier": "^3.5.3",
-    "prettier-plugin-svelte": "^3.3.3",
+    "prettier-plugin-svelte": "^3.4.0",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.9",
-    "@casekit/tsconfig": "0.0.0-20250331202540",
-    "@casekit/prettier-config": "0.0.0-20250331202540"
+    "vitest": "^3.2.4",
+    "@casekit/prettier-config": "1.0.0",
+    "@casekit/tsconfig": "1.0.0"
   },
   "exports": {
-    ".": "./build/index.js"
+    ".": "./src/index.ts"
   },
   "files": [
-    "/build"
+    "/src"
   ],
   "imports": {
-    "#*": "./build/*"
+    "#*": "./src/*"
   },
   "keywords": [],
   "license": "ISC",
-  "main": "index.js",
   "peerDependencies": {
-    "zod": "^3.24.2"
+    "zod": "^4.0.17"
   },
   "prettier": "@casekit/prettier-config",
   "type": "module",

package/src/factory.ts

@@ -0,0 +1,47 @@
+import { mapValues, uniq } from "es-toolkit";
+import { z } from "zod";
+
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinitions, ModelName, ModelType } from "@casekit/orm2-schema";
+
+import { generate } from "./generate.js";
+
+export type Factory<Models extends ModelDefinitions> = {
+    [M in ModelName<Models>]: (
+        overrides?: Partial<ModelType<Models[M]>>,
+    ) => ModelType<Models[M]>;
+};
+
+export const makeFactory = <Models extends ModelDefinitions>(
+    config: NormalizedConfig,
+): Factory<Models> => {
+    return mapValues(config.models, (model) => {
+        // We never want to generate foreign key values
+        // as there's no way for us to know how to generate
+        // valid ones. This is up to the user to provide.
+        const fkOverrides = Object.fromEntries(
+            uniq(model.foreignKeys.flatMap((fk) => fk.fields)).map((fk) => [
+                fk,
+                null,
+            ]),
+        );
+
+        const fields = Object.entries(model.fields)
+            .filter(([_, f]) => !f.provided)
+            .map(([name, f]) => [
+                name,
+                f.default
+                    ? f.zodSchema.optional()
+                    : f.nullable
+                      ? f.zodSchema.nullable()
+                      : f.zodSchema,
+            ]);
+
+        const schema = z.object(Object.fromEntries(fields));
+        return (overrides: Record<string, unknown>) => ({
+            ...generate(schema),
+            ...fkOverrides,
+            ...overrides,
+        });
+    }) as Factory<Models>;
+};

package/src/generate.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+
+import { generate } from "./generate.js";
+
+describe("generate", () => {
+    it("generates a simple object with string fields", () => {
+        const schema = z.object({
+            name: z.string(),
+            description: z.string(),
+        });
+
+        const result = generate(schema);
+
+        expect(result).toEqual({
+            name: expect.any(String),
+            description: expect.any(String),
+        });
+    });
+
+    it("generates an object with various field types", () => {
+        const schema = z.object({
+            id: z.uuid(),
+            name: z.string(),
+            age: z.number(),
+            isActive: z.boolean(),
+            createdAt: z.date(),
+            balance: z.bigint(),
+        });
+
+        const result = generate(schema);
+
+        expect(result).toEqual({
+            id: expect.stringMatching(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/),
+            name: expect.any(String),
+            age: expect.any(Number),
+            isActive: expect.any(Boolean),
+            createdAt: expect.any(Date),
+            balance: expect.any(Number),
+        });
+    });
+
+    it("generates nested objects", () => {
+        const schema = z.object({
+            user: z.object({
+                name: z.string(),
+                email: z.email(),
+            }),
+            settings: z.object({
+                notifications: z.boolean(),
+                theme: z.string(),
+            }),
+        });
+
+        const result = generate(schema);
+
+        expect(result).toEqual({
+            user: {
+                name: expect.any(String),
+                email: expect.stringMatching(/^[^\s@]+@[^\s@]+\.[^\s@]+$/),
+            },
+            settings: {
+                notifications: expect.any(Boolean),
+                theme: expect.any(String),
+            },
+        });
+    });
+
+    it("generates arrays", () => {
+        const schema = z.object({
+            tags: z.array(z.string()),
+            scores: z.array(z.number()),
+        });
+
+        const result = generate(schema);
+
+        expect(result.tags).toEqual(expect.arrayContaining([expect.any(String)]));
+        expect(result.scores).toEqual(expect.arrayContaining([expect.any(Number)]));
+    });
+
+    it("generates records", () => {
+        const schema = z.object({
+            metadata: z.record(z.string(), z.string()),
+            counts: z.record(z.number(), z.string()),
+        });
+
+        const result = generate(schema);
+
+        expect(result).toEqual({
+            metadata: {
+                a: expect.any(String),
+                b: expect.any(String),
+                c: expect.any(String),
+            },
+            counts: {
+                a: expect.any(String),
+                b: expect.any(String),
+                c: expect.any(String),
+            },
+        });
+    });
+
+    it("generates arrays of objects", () => {
+        const schema = z.object({
+            users: z.array(
+                z.object({
+                    id: z.string().uuid(),
+                    name: z.string(),
+                }),
+            ),
+        });
+
+        const result = generate(schema);
+
+        expect(result).toEqual({
+            users: expect.arrayContaining([
+                expect.objectContaining({
+                    id: expect.stringMatching(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/),
+                    name: expect.any(String),
+                }),
+            ]),
+        });
+    });
+
+    it("applies overrides to generated data", () => {
+        const schema = z.object({
+            name: z.string(),
+            age: z.number(),
+            isActive: z.boolean(),
+        });
+
+        const result = generate(schema, {
+            name: "John Doe",
+            age: 30,
+        });
+
+        expect(result).toEqual({
+            name: "John Doe",
+            age: 30,
+            isActive: expect.any(Boolean),
+        });
+    });
+
+    it("handles partial overrides", () => {
+        const schema = z.object({
+            id: z.string().uuid(),
+            name: z.string(),
+            email: z.string(),
+        });
+
+        const result = generate(schema, {
+            name: "Jane Smith",
+        });
+
+        expect(result).toEqual({
+            id: expect.stringMatching(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/),
+            name: "Jane Smith",
+            email: expect.any(String),
+        });
+    });
+
+    it("generates deeply nested structures", () => {
+        const schema = z.object({
+            level1: z.object({
+                level2: z.object({
+                    level3: z.object({
+                        value: z.string(),
+                    }),
+                }),
+            }),
+        });
+
+        const result = generate(schema);
+
+        expect(result).toEqual({
+            level1: {
+                level2: {
+                    level3: {
+                        value: expect.any(String),
+                    },
+                },
+            },
+        });
+    });
+
+    it("handles unknown schema types by returning undefined", () => {
+        const customSchema = z.custom<string>((val) => typeof val === "string");
+        const schema = z.object({
+            custom: customSchema,
+        });
+
+        const result = generate(schema);
+
+        expect(result).toEqual({
+            custom: undefined,
+        });
+    });
+
+    it("generates complex mixed structures", () => {
+        const schema = z.object({
+            company: z.object({
+                name: z.string(),
+                founded: z.date(),
+                employees: z.array(
+                    z.object({
+                        id: z.uuid(),
+                        name: z.string(),
+                        email: z.string(),
+                        active: z.boolean(),
+                    }),
+                ),
+                metadata: z.record(z.string(), z.string()),
+            }),
+        });
+
+        const result = generate(schema);
+
+        expect(result).toEqual({
+            company: {
+                name: expect.any(String),
+                founded: expect.any(Date),
+                employees: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: expect.stringMatching(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/),
+                        name: expect.any(String),
+                        email: expect.any(String),
+                        active: expect.any(Boolean),
+                    }),
+                ]),
+                metadata: {
+                    a: expect.any(String),
+                    b: expect.any(String),
+                    c: expect.any(String),
+                },
+            },
+        });
+    });
+});

package/src/generate.ts

@@ -0,0 +1,49 @@
+import { faker } from "@faker-js/faker";
+import z, { ZodObject, ZodType } from "zod";
+import { $ZodType } from "zod/v4/core";
+
+const generateInner = <T>(schema: $ZodType<T>): unknown => {
+    if (schema instanceof ZodObject) {
+        const shape = schema.shape;
+        const result: Record<string, unknown> = {};
+        for (const key in shape) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            result[key] = generateInner(shape[key]);
+        }
+        return result as T;
+    } else if (schema instanceof z.ZodOptional) {
+        return generateInner(schema.def.innerType);
+    } else if (schema instanceof z.ZodRecord) {
+        return {
+            a: generateInner(schema.valueType),
+            b: generateInner(schema.valueType),
+            c: generateInner(schema.valueType),
+        };
+    } else if (schema instanceof z.ZodEnum) {
+        return faker.helpers.arrayElement(Object.values(schema.def.entries));
+    } else if (schema instanceof z.ZodArray) {
+        return faker.helpers.multiple(() => generateInner(schema.element), {
+            count: { min: 1, max: 3 },
+        });
+    } else if (schema instanceof z.ZodDate) {
+        return faker.date.past();
+    } else if (schema instanceof z.ZodBoolean) {
+        return faker.datatype.boolean();
+    } else if (schema instanceof z.ZodUUID) {
+        return faker.string.uuid();
+    } else if (schema instanceof z.ZodString) {
+        return faker.lorem.word();
+    } else if (schema instanceof z.ZodEmail) {
+        return faker.internet.exampleEmail();
+    } else if (schema instanceof z.ZodBigInt) {
+        return faker.number.int({ min: 1, max: 100 });
+    } else if (schema instanceof z.ZodNumber) {
+        return faker.number.int({ min: 1, max: 100 });
+    } else {
+        return undefined;
+    }
+};
+
+export const generate = <T>(schema: ZodType<T>, overrides?: Partial<T>): T => {
+    return { ...(generateInner(schema) as T), ...overrides };
+};

package/build/factory.d.ts

@@ -1,7 +0,0 @@
-import { GenerateMockOptions } from "@anatine/zod-mock";
-import { NormalizedConfig } from "@casekit/orm2-config";
-import { ModelDefinitions, ModelName, ModelType } from "@casekit/orm2-schema";
-export type Factory<Models extends ModelDefinitions> = {
-    [M in ModelName<Models>]: (overrides?: Partial<ModelType<Models[M]>>) => ModelType<Models[M]>;
-};
-export declare const makeFactory: <Models extends ModelDefinitions>(config: NormalizedConfig, options?: GenerateMockOptions) => Factory<Models>;

package/build/factory.js

@@ -1,30 +0,0 @@
-import { generateMock } from "@anatine/zod-mock";
-import { mapValues, uniq } from "es-toolkit";
-import { z } from "zod";
-export const makeFactory = (config, options) => {
-    return mapValues(config.models, (model) => {
-        // We never want to generate foreign key values
-        // as there's no way for us to know how to generate
-        // valid ones. This is up to the user to provide.
-        const fkOverrides = Object.fromEntries(uniq(model.foreignKeys.flatMap((fk) => fk.fields)).map((fk) => [
-            fk,
-            null,
-        ]));
-        const fields = Object.entries(model.fields)
-            .filter(([_, f]) => !f.provided)
-            .map(([name, f]) => [
-            name,
-            f.default
-                ? f.zodSchema.optional()
-                : f.nullable
-                    ? f.zodSchema.nullable()
-                    : f.zodSchema,
-        ]);
-        const schema = z.object(Object.fromEntries(fields));
-        return (overrides) => ({
-            ...generateMock(schema, options),
-            ...fkOverrides,
-            ...overrides,
-        });
-    });
-};

package/build/index.js

@@ -1 +0,0 @@
-export { makeFactory } from "./factory.js";