@casekit/orm2-testing 0.0.1 → 1.0.1

package/build/factory.d.ts

@@ -0,0 +1,6 @@
+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) => Factory<Models>;

package/build/factory.js

@@ -0,0 +1,30 @@
+import { mapValues, uniq } from "es-toolkit";
+import { z } from "zod";
+import { generate } from "./generate.js";
+export const makeFactory = (config) => {
+    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) => ({
+            ...generate(schema),
+            ...fkOverrides,
+            ...overrides,
+        });
+    });
+};

package/build/generate.d.ts

@@ -0,0 +1,2 @@
+import { ZodType } from "zod";
+export declare const generate: <T>(schema: ZodType<T>, overrides?: Partial<T>) => T;

package/{src/generate.ts → build/generate.js}

@@ -1,49 +1,58 @@
 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 => {
+import z, { ZodObject } from "zod";
+const generateInner = (schema) => {
     if (schema instanceof ZodObject) {
         const shape = schema.shape;
-        const result: Record<string, unknown> = {};
+        const result = {};
         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 result;
+    }
+    else if (schema instanceof z.ZodOptional) {
         return generateInner(schema.def.innerType);
-    } else if (schema instanceof z.ZodRecord) {
+    }
+    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) {
+    }
+    else if (schema instanceof z.ZodEnum) {
         return faker.helpers.arrayElement(Object.values(schema.def.entries));
-    } else if (schema instanceof z.ZodArray) {
+    }
+    else if (schema instanceof z.ZodArray) {
         return faker.helpers.multiple(() => generateInner(schema.element), {
             count: { min: 1, max: 3 },
         });
-    } else if (schema instanceof z.ZodDate) {
+    }
+    else if (schema instanceof z.ZodDate) {
         return faker.date.past();
-    } else if (schema instanceof z.ZodBoolean) {
+    }
+    else if (schema instanceof z.ZodBoolean) {
         return faker.datatype.boolean();
-    } else if (schema instanceof z.ZodUUID) {
+    }
+    else if (schema instanceof z.ZodUUID) {
         return faker.string.uuid();
-    } else if (schema instanceof z.ZodString) {
+    }
+    else if (schema instanceof z.ZodString) {
         return faker.lorem.word();
-    } else if (schema instanceof z.ZodEmail) {
+    }
+    else if (schema instanceof z.ZodEmail) {
         return faker.internet.exampleEmail();
-    } else if (schema instanceof z.ZodBigInt) {
+    }
+    else if (schema instanceof z.ZodBigInt) {
         return faker.number.int({ min: 1, max: 100 });
-    } else if (schema instanceof z.ZodNumber) {
+    }
+    else if (schema instanceof z.ZodNumber) {
         return faker.number.int({ min: 1, max: 100 });
-    } else {
+    }
+    else {
         return undefined;
     }
 };
-
-export const generate = <T>(schema: ZodType<T>, overrides?: Partial<T>): T => {
-    return { ...(generateInner(schema) as T), ...overrides };
+export const generate = (schema, overrides) => {
+    return { ...generateInner(schema), ...overrides };
 };

package/build/generate.test.d.ts

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

package/{src/generate.test.ts → build/generate.test.js}

@@ -1,23 +1,18 @@
 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(),
@@ -27,9 +22,7 @@ describe("generate", () => {
             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),
@@ -39,7 +32,6 @@ describe("generate", () => {
             balance: expect.any(Number),
         });
     });
-
     it("generates nested objects", () => {
         const schema = z.object({
             user: z.object({
@@ -51,9 +43,7 @@ describe("generate", () => {
                 theme: z.string(),
             }),
         });
-
         const result = generate(schema);
-
         expect(result).toEqual({
             user: {
                 name: expect.any(String),
@@ -65,27 +55,21 @@ describe("generate", () => {
             },
         });
     });
-
     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),
@@ -99,19 +83,14 @@ describe("generate", () => {
             },
         });
     });
-
     it("generates arrays of objects", () => {
         const schema = z.object({
-            users: z.array(
-                z.object({
-                    id: z.string().uuid(),
-                    name: z.string(),
-                }),
-            ),
+            users: z.array(z.object({
+                id: z.string().uuid(),
+                name: z.string(),
+            })),
         });
-
         const result = generate(schema);
-
         expect(result).toEqual({
             users: expect.arrayContaining([
                 expect.objectContaining({
@@ -121,44 +100,37 @@ describe("generate", () => {
             ]),
         });
     });
-
     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({
@@ -169,9 +141,7 @@ describe("generate", () => {
                 }),
             }),
         });
-
         const result = generate(schema);
-
         expect(result).toEqual({
             level1: {
                 level2: {
@@ -182,39 +152,31 @@ describe("generate", () => {
             },
         });
     });
-
     it("handles unknown schema types by returning undefined", () => {
-        const customSchema = z.custom<string>((val) => typeof val === "string");
+        const customSchema = z.custom((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(),
-                    }),
-                ),
+                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),

package/build/index.js

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

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@casekit/orm2-testing",
   "description": "",
-  "version": "0.0.1",
+  "version": "1.0.1",
   "author": "",
   "dependencies": {
     "@faker-js/faker": "^9.8.0",
     "es-toolkit": "^1.39.3",
-    "@casekit/orm2-config": "0.0.1",
-    "@casekit/orm2-schema": "0.0.1",
-    "@casekit/sql": "0.0.1",
-    "@casekit/toolbox": "0.0.1"
+    "@casekit/orm2-config": "1.0.1",
+    "@casekit/toolbox": "1.0.1",
+    "@casekit/orm2-schema": "1.0.1",
+    "@casekit/sql": "1.0.1"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
@@ -19,17 +19,17 @@
     "prettier-plugin-svelte": "^3.4.0",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@casekit/prettier-config": "0.0.1",
-    "@casekit/tsconfig": "0.0.1"
+    "@casekit/tsconfig": "1.0.1",
+    "@casekit/prettier-config": "1.0.1"
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./build/index.js"
   },
   "files": [
-    "/src"
+    "/build"
   ],
   "imports": {
-    "#*": "./src/*"
+    "#*": "./build/*"
   },
   "keywords": [],
   "license": "ISC",

package/src/factory.ts

@@ -1,47 +0,0 @@
-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>;
-};