@ramiyohay/schema-faker 0.3.0

package/README.md

@@ -0,0 +1,81 @@
+# schema-faker
+
+Generate fake data from **Zod schemas** in a deterministic, type-safe, and extensible way.
+
+`schema-faker` creates realistic-looking mock data **directly from your existing schemas**, without writing manual mocks.
+
+---
+
+## Why schema-faker?
+
+Most fake data libraries generate random values field-by-field.  
+`schema-faker` works **schema-first**.
+
+### Benefits
+- ✅ Uses schemas you already have (Zod)
+- ✅ Deterministic output (seed support)
+- ✅ Fully type-safe
+- ✅ No dependency on Faker
+- ✅ Perfect for tests, seeds, and mock APIs
+
+### Type Support
+- ✅ string
+- ✅ number
+- ✅ boolean
+- ✅ object
+- ✅ array
+- ✅ optional
+- ✅ enum
+- ✅ nullable
+- ✅ tuple
+- ✅ union
+- ✅ literal
+- ✅ date
+
+
+## Install
+npm install schema-faker zod
+
+## Basic Usage
+```ts
+import { z } from "zod";
+import { generate } from "schema-faker";
+
+const User = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  age: z.number().min(18)
+});
+
+const user = generate(User);
+
+// you can also create multi objects
+
+const users = generate(User, {
+  count: 5,
+  seed: 42,
+});
+```
+
+# Override Data Usage
+```ts
+import { z } from "zod";
+import { generate } from "schema-faker";
+
+const UserSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  age: z.number().min(18).max(65),
+  isActive: z.boolean(),
+});
+
+// email and age will stay the same
+const user = generate(UserSchema, {
+  overrides: {
+    email: "test@example.com",
+    age: 30,
+  },
+});
+
+console.log(user);
+```

package/dist/core/context.d.ts

@@ -0,0 +1,4 @@
+import { Random } from "./random";
+export type Context = {
+    random: Random;
+};

package/dist/core/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/deepMerge.d.ts

@@ -0,0 +1 @@
+export declare function deepMerge(target: any, source: any): any;

package/dist/core/deepMerge.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = deepMerge;
+// Deeply merges two objects
+function deepMerge(target, source) {
+    if (source === null || typeof source !== "object" || Array.isArray(source)) {
+        return source;
+    }
+    if (target === null || typeof target !== "object" || Array.isArray(target)) {
+        return source;
+    }
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        result[key] = deepMerge(target[key], source[key]);
+    }
+    return result;
+}

package/dist/core/random.d.ts

@@ -0,0 +1,8 @@
+export declare class Random {
+    private seed;
+    constructor(seed?: number);
+    private next;
+    int(min: number, max: number): number;
+    bool(): boolean;
+    string(length: number): string;
+}

package/dist/core/random.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Random = void 0;
+class Random {
+    constructor(seed = Date.now()) {
+        this.seed = seed;
+    }
+    next() {
+        this.seed = (this.seed * 9301 + 49297) % 233280;
+        return this.seed / 233280;
+    }
+    int(min, max) {
+        return Math.floor(this.next() * (max - min + 1)) + min;
+    }
+    bool() {
+        return this.next() > 0.5;
+    }
+    string(length) {
+        const chars = "abcdefghijklmnopqrstuvwxyz";
+        return Array.from({ length }, () => chars[this.int(0, chars.length - 1)]).join("");
+    }
+}
+exports.Random = Random;

package/dist/generate.d.ts

@@ -0,0 +1,2 @@
+import { GenerateOptions } from "./types";
+export declare function generate(schema: any, options?: GenerateOptions): any;

package/dist/generate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+const random_1 = require("./core/random");
+const parseZod_1 = require("./zod/parseZod");
+const deepMerge_1 = require("./core/deepMerge");
+function generate(schema, options = {}) {
+    const ctx = {
+        random: new random_1.Random(options.seed),
+    };
+    // create data based on schema
+    const generated = (0, parseZod_1.parseZodSchema)(schema, ctx);
+    // apply overrides if provided
+    if (options.overrides) {
+        return (0, deepMerge_1.deepMerge)(generated, options.overrides);
+    }
+    return generated;
+}

package/dist/generators/array.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../core/context";
+export declare function generateArray(schema: any, ctx: Context): any[];

package/dist/generators/array.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateArray = generateArray;
+const parseZod_1 = require("../zod/parseZod");
+function generateArray(schema, ctx) {
+    const min = schema._def.minLength?.value ?? 1;
+    const max = schema._def.maxLength?.value ?? min + 4;
+    const length = ctx.random.int(min, max);
+    const itemSchema = schema._def.type;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+        result.push((0, parseZod_1.parseZodSchema)(itemSchema, ctx));
+    }
+    return result;
+}

package/dist/generators/boolean.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../core/context";
+export declare function generateBoolean(ctx: Context): boolean;

package/dist/generators/boolean.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBoolean = generateBoolean;
+function generateBoolean(ctx) {
+    return ctx.random.bool();
+}

package/dist/generators/date.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../core/context";
+export declare function generateDate(schema: any, ctx: Context): Date;

package/dist/generators/date.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDate = generateDate;
+const DEFAULT_MIN_DATE = new Date("1970-01-01").getTime();
+// Helper to convert Date or number to timestamp
+function toTimestamp(value) {
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    throw new Error("Invalid date constraint value");
+}
+function generateDate(schema, ctx) {
+    const checks = schema._def.checks ?? [];
+    let min = DEFAULT_MIN_DATE;
+    let max = Date.now();
+    for (const check of checks) {
+        if (check.kind === "min") {
+            min = toTimestamp(check.value);
+        }
+        if (check.kind === "max") {
+            max = toTimestamp(check.value);
+        }
+    }
+    // date range validation
+    if (min > max) {
+        throw new Error("Invalid date range: min > max");
+    }
+    const timestamp = ctx.random.int(min, max);
+    return new Date(timestamp);
+}

package/dist/generators/enum.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../core/context";
+export declare function generateEnum(schema: any, ctx: Context): any;

package/dist/generators/enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnum = generateEnum;
+function generateEnum(schema, ctx) {
+    const values = schema._def.values;
+    const index = ctx.random.int(0, values.length - 1);
+    return values[index];
+}

package/dist/generators/number.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../core/context";
+export declare function generateNumber(schema: any, ctx: Context): number;

package/dist/generators/number.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNumber = generateNumber;
+function generateNumber(schema, ctx) {
+    const checks = schema._def.checks ?? [];
+    let min = 0;
+    let max = 100;
+    for (const check of checks) {
+        if (check.kind === "min")
+            min = check.value;
+        if (check.kind === "max")
+            max = check.value;
+    }
+    return ctx.random.int(min, max);
+}

package/dist/generators/string.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../core/context";
+export declare function generateString(schema: any, ctx: Context): string;

package/dist/generators/string.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateString = generateString;
+function generateUUID(ctx) {
+    const hex = () => ctx.random.int(0, 15).toString(16);
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = ctx.random.int(0, 15);
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+function generateString(schema, ctx) {
+    const checks = schema._def.checks ?? [];
+    if (checks.some((c) => c.kind === "uuid")) {
+        return generateUUID(ctx);
+    }
+    if (checks.some((c) => c.kind === "email")) {
+        return `user${ctx.random.int(1, 9999)}@example.com`;
+    }
+    return ctx.random.string(10);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { generate } from "./generate";

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = void 0;
+var generate_1 = require("./generate");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_1.generate; } });

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+export type GenerateOptions = {
+    seed?: number;
+    count?: number;
+    overrides?: Record<string, any>;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/zod/parseZod.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../core/context";
+export declare function parseZodSchema(schema: any, ctx: Context): any;

package/dist/zod/parseZod.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseZodSchema = parseZodSchema;
+const string_1 = require("../generators/string");
+const number_1 = require("../generators/number");
+const boolean_1 = require("../generators/boolean");
+const array_1 = require("../generators/array");
+const enum_1 = require("../generators/enum");
+const date_1 = require("../generators/date");
+function parseZodSchema(schema, ctx) {
+    switch (schema._def.typeName) {
+        case "ZodString": // String type
+            return (0, string_1.generateString)(schema, ctx);
+        case "ZodNumber": // Number type
+            return (0, number_1.generateNumber)(schema, ctx);
+        case "ZodBoolean": // Boolean type
+            return (0, boolean_1.generateBoolean)(ctx);
+        case "ZodArray": // Array type
+            return (0, array_1.generateArray)(schema, ctx);
+        case "ZodOptional": {
+            // 50% undefined, 50% value
+            return ctx.random.bool()
+                ? undefined
+                : parseZodSchema(schema._def.innerType, ctx);
+        }
+        case "ZodNullable": {
+            // 50% null, 50% value
+            return ctx.random.bool()
+                ? null // important: return null here
+                : parseZodSchema(schema._def.innerType, ctx);
+        }
+        case "ZodEnum": // Enum type, return one of the enum values
+            return (0, enum_1.generateEnum)(schema, ctx);
+        case "ZodObject": // Object type
+            const shape = schema.shape;
+            const obj = {};
+            for (const key in shape) {
+                obj[key] = parseZodSchema(shape[key], ctx);
+            }
+            return obj;
+        case "ZodLiteral": // Literal type, always return the literal value
+            return schema._def.value;
+        case "ZodUnion": {
+            // Union type, randomly pick one of the options
+            const options = schema._def.options;
+            const index = ctx.random.int(0, options.length - 1);
+            return parseZodSchema(options[index], ctx);
+        }
+        case "ZodTuple": { // Tuple type , create array with fixed length and types
+            const items = schema._def.items;
+            return items.map((itemSchema) => parseZodSchema(itemSchema, ctx));
+        }
+        case "ZodDate": // Date type
+            return (0, date_1.generateDate)(schema, ctx);
+        default:
+            return null;
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@ramiyohay/schema-faker",
+  "version": "0.3.0",
+  "description": "Generate fake data from Zod schemas in a deterministic way",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ramiyohay/schema-faker"
+  },
+  "keywords": [
+    "faker",
+    "schema",
+    "zod",
+    "mock",
+    "testing",
+    "seed",
+    "fake-data"
+  ],
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  }
+}