@schmock/schema 1.0.0

package/dist/test-utils.d.ts

@@ -0,0 +1,59 @@
+import type { JSONSchema7 } from "json-schema";
+export declare const schemas: {
+    simple: {
+        string: () => JSONSchema7;
+        number: () => JSONSchema7;
+        object: (properties?: Record<string, JSONSchema7>) => JSONSchema7;
+        array: (items: JSONSchema7, constraints?: {
+            minItems?: number;
+            maxItems?: number;
+        }) => JSONSchema7;
+    };
+    withFaker: (type: JSONSchema7["type"], fakerMethod: string) => JSONSchema7;
+    nested: {
+        deep: (depth: number, leafSchema?: JSONSchema7) => JSONSchema7;
+        wide: (width: number, propertySchema?: JSONSchema7) => JSONSchema7;
+    };
+    complex: {
+        user: () => JSONSchema7;
+        apiResponse: () => JSONSchema7;
+    };
+};
+export declare const validators: {
+    isFieldMapped: (fieldName: string, fieldType?: JSONSchema7["type"]) => Promise<boolean>;
+    uniquenessRatio: (samples: any[]) => number;
+    allMatch: (samples: any[], validator: (sample: any) => boolean) => boolean;
+    appearsToBeFromCategory: (samples: string[], category: "email" | "name" | "phone" | "address" | "uuid" | "date") => boolean;
+};
+export declare const performance: {
+    measure: <T>(fn: () => T | Promise<T>) => Promise<{
+        result: T;
+        duration: number;
+    }>;
+    measureMemory: (fn: () => void) => number;
+    benchmark: (_name: string, fn: () => any, iterations?: number) => Promise<{
+        mean: number;
+        min: number;
+        max: number;
+    }>;
+};
+export declare const generate: {
+    samples: <T>(schema: JSONSchema7, count?: number, options?: any) => T[];
+    withSeed: (schema: JSONSchema7, _seed?: number) => any;
+};
+export declare const stats: {
+    distribution: (samples: any[]) => Map<any, number>;
+    entropy: (samples: any[]) => number;
+};
+export declare const schemaTests: {
+    expectValid: (schema: JSONSchema7) => void;
+    expectInvalid: (schema: any, errorMessage?: string | RegExp) => void;
+    expectSchemaError: (schema: any, path: string, issue?: string) => void;
+};
+export declare const mocks: {
+    trackFakerCalls: () => {
+        calls: string[];
+        reset: () => void;
+    };
+};
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C,eAAO,MAAM,OAAO;;sBAEJ,WAAW;sBAIX,WAAW;8BAIF,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,KAAQ,WAAW;uBAM1D,WAAW,gBACJ;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,KACrD,WAAW;;sBAOE,WAAW,CAAC,MAAM,CAAC,eAAe,MAAM,KAAG,WAAW;;sBAQ7D,MAAM,eACD,WAAW,KACtB,WAAW;sBAWL,MAAM,mBACG,WAAW,KAC1B,WAAW;;;oBASJ,WAAW;2BAYJ,WAAW;;CAkB/B,CAAC;AAGF,eAAO,MAAM,UAAU;+BAGR,MAAM,cACN,WAAW,CAAC,MAAM,CAAC,KAC7B,OAAO,CAAC,OAAO,CAAC;+BAoCQ,GAAG,EAAE,KAAG,MAAM;wBAMrB,GAAG,EAAE,aAAa,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,KAAG,OAAO;uCAM7D,MAAM,EAAE,YACP,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,KACjE,OAAO;CAgDX,CAAC;AAGF,eAAO,MAAM,WAAW;cACN,CAAC,MACX,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KACvB,OAAO,CAAC;QAAE,MAAM,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;wBAOvB,MAAM,IAAI,KAAG,MAAM;uBAW9B,MAAM,MACT,MAAM,GAAG,0BAEZ,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CAgBvD,CAAC;AAGF,eAAO,MAAM,QAAQ;cACT,CAAC,UAAU,WAAW,4BAAwB,GAAG,KAAG,CAAC,EAAE;uBAM9C,WAAW,UAAU,MAAM,KAAG,GAAG;CAKrD,CAAC;AAGF,eAAO,MAAM,KAAK;4BACQ,GAAG,EAAE,KAAG,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC;uBAS7B,GAAG,EAAE,KAAG,MAAM;CAclC,CAAC;AAGF,eAAO,MAAM,WAAW;0BACA,WAAW,KAAG,IAAI;4BAIhB,GAAG,iBAAiB,MAAM,GAAG,MAAM,KAAG,IAAI;gCAQtC,GAAG,QAAQ,MAAM,UAAU,MAAM,KAAG,IAAI;CAerE,CAAC;AA8BF,eAAO,MAAM,KAAK;;;;;CAYjB,CAAC"}

package/dist/test-utils.js

@@ -0,0 +1,269 @@
+import { expect } from "vitest";
+import { generateFromSchema } from "./index";
+// Schema Factory Functions
+export const schemas = {
+    simple: {
+        string: () => ({
+            type: "string",
+        }),
+        number: () => ({
+            type: "number",
+        }),
+        object: (properties = {}) => ({
+            type: "object",
+            properties,
+        }),
+        array: (items, constraints) => ({
+            type: "array",
+            items,
+            ...constraints,
+        }),
+    },
+    withFaker: (type, fakerMethod) => ({
+        type: type,
+        faker: fakerMethod,
+    }),
+    nested: {
+        deep: (depth, leafSchema = schemas.simple.string()) => {
+            if (depth <= 0)
+                return leafSchema;
+            return {
+                type: "object",
+                properties: {
+                    nested: schemas.nested.deep(depth - 1, leafSchema),
+                },
+            };
+        },
+        wide: (width, propertySchema = schemas.simple.string()) => ({
+            type: "object",
+            properties: Object.fromEntries(Array.from({ length: width }, (_, i) => [`prop${i}`, propertySchema])),
+        }),
+    },
+    complex: {
+        user: () => ({
+            type: "object",
+            properties: {
+                id: { type: "string", format: "uuid" },
+                email: { type: "string" },
+                firstName: { type: "string" },
+                lastName: { type: "string" },
+                createdAt: { type: "string" },
+            },
+            required: ["id", "email"],
+        }),
+        apiResponse: () => ({
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                data: {
+                    type: "array",
+                    items: schemas.complex.user(),
+                },
+                meta: {
+                    type: "object",
+                    properties: {
+                        page: { type: "number" },
+                        total: { type: "number" },
+                    },
+                },
+            },
+        }),
+    },
+};
+// Validation Helpers
+export const validators = {
+    // Check if a field was mapped to a faker method by comparing with unmapped behavior
+    isFieldMapped: async (fieldName, fieldType = "string") => {
+        const mappedSchema = {
+            type: "object",
+            properties: {
+                [fieldName]: { type: fieldType },
+            },
+        };
+        const unmappedSchema = {
+            type: "object",
+            properties: {
+                unmappedRandomField12345: { type: fieldType },
+            },
+        };
+        // Generate multiple samples to check for patterns
+        const mappedSamples = Array.from({ length: 10 }, () => generateFromSchema({ schema: mappedSchema })[fieldName]);
+        const unmappedSamples = Array.from({ length: 10 }, () => generateFromSchema({ schema: unmappedSchema }).unmappedRandomField12345);
+        // If field is mapped to a specific faker method, it should have different characteristics
+        // than the generic unmapped field
+        return (analyzeDataCharacteristics(mappedSamples) !==
+            analyzeDataCharacteristics(unmappedSamples));
+    },
+    // Analyze uniqueness of generated data
+    uniquenessRatio: (samples) => {
+        const unique = new Set(samples);
+        return unique.size / samples.length;
+    },
+    // Check if all samples match a basic pattern without being too specific
+    allMatch: (samples, validator) => {
+        return samples.every(validator);
+    },
+    // Check if data appears to be from a specific faker category
+    appearsToBeFromCategory: (samples, category) => {
+        switch (category) {
+            case "email":
+                return validators.allMatch(samples, (s) => typeof s === "string" && s.includes("@") && s.includes("."));
+            case "name":
+                return validators.allMatch(samples, (s) => typeof s === "string" &&
+                    s.length > 1 &&
+                    s.length < 50 &&
+                    /^[A-Z]/.test(s));
+            case "phone":
+                return validators.allMatch(samples, (s) => typeof s === "string" && /\d/.test(s) && s.length > 10);
+            case "address":
+                return validators.allMatch(samples, (s) => typeof s === "string" &&
+                    s.length > 10 &&
+                    /\d/.test(s) &&
+                    /[A-Z]/.test(s));
+            case "uuid":
+                return validators.allMatch(samples, (s) => typeof s === "string" &&
+                    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s));
+            case "date":
+                return validators.allMatch(samples, (s) => typeof s === "string" && !Number.isNaN(Date.parse(s)));
+            default:
+                return false;
+        }
+    },
+};
+// Performance Testing Utilities
+export const performance = {
+    measure: async (fn) => {
+        const start = Date.now();
+        const result = await fn();
+        const duration = Date.now() - start;
+        return { result, duration };
+    },
+    measureMemory: (fn) => {
+        if (globalThis.gc) {
+            globalThis.gc();
+        }
+        const before = process.memoryUsage().heapUsed;
+        fn();
+        const after = process.memoryUsage().heapUsed;
+        return after - before;
+    },
+    benchmark: async (_name, fn, iterations = 100) => {
+        const times = [];
+        for (let i = 0; i < iterations; i++) {
+            const start = Date.now();
+            await fn();
+            const duration = Date.now() - start;
+            times.push(duration);
+        }
+        return {
+            mean: times.reduce((a, b) => a + b, 0) / times.length,
+            min: Math.min(...times),
+            max: Math.max(...times),
+        };
+    },
+};
+// Test Data Generators
+export const generate = {
+    samples: (schema, count = 10, options) => {
+        return Array.from({ length: count }, () => generateFromSchema({ schema, ...options }));
+    },
+    withSeed: (schema, _seed) => {
+        // Note: faker.js doesn't support seeding in the same way,
+        // but we can at least ensure consistent test behavior
+        return generateFromSchema({ schema });
+    },
+};
+// Statistical Analysis
+export const stats = {
+    distribution: (samples) => {
+        const dist = new Map();
+        for (const sample of samples) {
+            const key = JSON.stringify(sample);
+            dist.set(key, (dist.get(key) || 0) + 1);
+        }
+        return dist;
+    },
+    entropy: (samples) => {
+        const dist = stats.distribution(samples);
+        const total = samples.length;
+        let entropy = 0;
+        for (const count of dist.values()) {
+            const p = count / total;
+            if (p > 0) {
+                entropy -= p * Math.log2(p);
+            }
+        }
+        return entropy;
+    },
+};
+// Schema Validation Test Helpers
+export const schemaTests = {
+    expectValid: (schema) => {
+        expect(() => generateFromSchema({ schema })).not.toThrow();
+    },
+    expectInvalid: (schema, errorMessage) => {
+        if (errorMessage) {
+            expect(() => generateFromSchema({ schema })).toThrow(errorMessage);
+        }
+        else {
+            expect(() => generateFromSchema({ schema })).toThrow();
+        }
+    },
+    expectSchemaError: (schema, path, issue) => {
+        try {
+            generateFromSchema({ schema });
+            throw new Error("Expected schema validation to fail");
+        }
+        catch (error) {
+            expect(error.name).toBe("SchemaValidationError");
+            // The schemaPath is in the context
+            if (error.context?.schemaPath) {
+                expect(error.context.schemaPath).toBe(path);
+            }
+            if (issue) {
+                expect(error.message).toContain(issue);
+            }
+        }
+    },
+};
+// Helper to analyze data characteristics without hardcoding patterns
+function analyzeDataCharacteristics(samples) {
+    if (samples.length === 0)
+        return "empty";
+    const first = samples[0];
+    const type = typeof first;
+    if (type !== "string")
+        return type;
+    // Analyze string characteristics
+    const characteristics = [type];
+    // Check common patterns without being too specific
+    if (samples.every((s) => s.includes("@")))
+        characteristics.push("has-at");
+    if (samples.every((s) => /^\d+$/.test(s)))
+        characteristics.push("numeric");
+    if (samples.every((s) => /^[0-9a-f-]+$/i.test(s)))
+        characteristics.push("hex-like");
+    if (samples.every((s) => s.length > 50))
+        characteristics.push("long");
+    if (samples.every((s) => s.length < 10))
+        characteristics.push("short");
+    if (validators.uniquenessRatio(samples) > 0.8)
+        characteristics.push("high-entropy");
+    if (validators.uniquenessRatio(samples) < 0.2)
+        characteristics.push("low-entropy");
+    return characteristics.join("-");
+}
+// Mock/Spy utilities for testing faker integration
+export const mocks = {
+    trackFakerCalls: () => {
+        const calls = [];
+        // This would need actual implementation with faker.js internals
+        // For now, it's a placeholder for the concept
+        return {
+            calls,
+            reset: () => {
+                calls.length = 0;
+            },
+        };
+    },
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@schmock/schema",
+  "description": "JSON Schema-based automatic data generation for Schmock",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "bun build:lib && bun build:types",
+    "build:lib": "bun build --minify --outdir=dist src/index.ts",
+    "build:types": "tsc -p tsconfig.json",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "lint": "biome check src/*.ts",
+    "lint:fix": "biome check --write --unsafe src/*.ts"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "json-schema-faker": "^0.5.6",
+    "@faker-js/faker": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^24.9.1",
+    "vitest": "^4.0.15"
+  }
+}