@schmock/faker 1.12.0 → 2.0.0

package/src/index.ts

@@ -7,7 +7,7 @@ import {
 } from "@schmock/core";
 import type { JSONSchema7 } from "json-schema";
 import { MAX_ARRAY_SIZE, NULLABLE_NULL_PROBABILITY } from "./constants.js";
-import { getJsf } from "./jsf-config.js";
+import { generateWithJsf } from "./jsf-config.js";
 import { applyOverrides, determineArrayCount } from "./overrides.js";
 import { enhanceSchemaWithSmartMapping } from "./schema-enhancement.js";
 import { isJSONSchema7, validateSchema } from "./validation.js";
@@ -37,14 +37,14 @@ export function fakerPlugin(options: FakerPluginOptions): Schmock.Plugin {
     name: "faker",
     version: "1.0.1",
 
-    process(context: Schmock.PluginContext, response?: any) {
+    async process(context: Schmock.PluginContext, response?: any) {
       // If response already exists, pass it through
       if (response !== undefined && response !== null) {
         return { context, response };
       }
 
       try {
-        const generatedResponse = generateFromSchema({
+        const generatedResponse = await generateFromSchema({
           schema: options.schema,
           count: options.count,
           overrides: options.overrides,
@@ -78,7 +78,9 @@ export function fakerPlugin(options: FakerPluginOptions): Schmock.Plugin {
   };
 }
 
-export function generateFromSchema(options: SchemaGenerationContext): any {
+export async function generateFromSchema(
+  options: SchemaGenerationContext,
+): Promise<any> {
   const { schema, count, overrides, params, state, query, seed } = options;
 
   validateSchema(schema);
@@ -110,7 +112,7 @@ export function generateFromSchema(options: SchemaGenerationContext): any {
 
     generated = [];
     for (let i = 0; i < itemCount; i++) {
-      let item = getJsf(seed).generate(enhancedItemSchema);
+      let item = await generateWithJsf(enhancedItemSchema, seed);
       item = postProcessGenerated(item, enhancedItemSchema);
       item = applyOverrides(item, overrides, params, state, query);
       generated.push(item);
@@ -118,7 +120,7 @@ export function generateFromSchema(options: SchemaGenerationContext): any {
   } else {
     // Handle object schemas
     const enhancedSchema = enhanceSchemaWithSmartMapping(schema);
-    generated = getJsf(seed).generate(enhancedSchema);
+    generated = await generateWithJsf(enhancedSchema, seed);
     generated = postProcessGenerated(generated, enhancedSchema);
     generated = applyOverrides(generated, overrides, params, state, query);
   }

package/src/integration.test.ts

@@ -6,7 +6,7 @@ import { generate, schemas, validators } from "./test-utils";
 
 describe("Schema Generator Integration Tests", () => {
   describe("End-to-End Scenarios", () => {
-    it("generates complete mock API response with relationships", () => {
+    it("generates complete mock API response with relationships", async () => {
       const schema: JSONSchema7 = {
         type: "object",
         properties: {
@@ -59,7 +59,7 @@ describe("Schema Generator Integration Tests", () => {
         },
       };
 
-      const result = generateFromSchema({ schema });
+      const result = await generateFromSchema({ schema });
 
       // Verify complete structure
       expect(result.user).toBeDefined();
@@ -87,7 +87,7 @@ describe("Schema Generator Integration Tests", () => {
       }
     });
 
-    it("generates consistent data across related fields", () => {
+    it("generates consistent data across related fields", async () => {
       const plugin = fakerPlugin({
         schema: {
           type: "object",
@@ -137,7 +137,7 @@ describe("Schema Generator Integration Tests", () => {
         route: {},
       };
 
-      const result = plugin.process(context);
+      const result = await plugin.process(context);
 
       expect(result.response.order.customerId).toBe("customer-456");
       expect(result.response.order.createdAt).toBe("2024-01-01T10:00:00Z");
@@ -164,7 +164,7 @@ describe("Schema Generator Integration Tests", () => {
   });
 
   describe("Cross-Package Integration", () => {
-    it("works with complex nested schemas from multiple sources", () => {
+    it("works with complex nested schemas from multiple sources", async () => {
       const addressSchema: JSONSchema7 = {
         type: "object",
         properties: {
@@ -190,7 +190,7 @@ describe("Schema Generator Integration Tests", () => {
         },
       };
 
-      const result = generateFromSchema({ schema: customerSchema });
+      const result = await generateFromSchema({ schema: customerSchema });
 
       // Both addresses should be valid structures
       expect(result.billingAddress.street).toBeDefined();
@@ -203,7 +203,7 @@ describe("Schema Generator Integration Tests", () => {
       expect(["US", "CA", "MX"]).toContain(result.shippingAddress.country);
     });
 
-    it("handles schema composition with allOf, anyOf, oneOf", () => {
+    it("handles schema composition with allOf, anyOf, oneOf", async () => {
       const baseSchema: JSONSchema7 = {
         type: "object",
         properties: {
@@ -245,7 +245,7 @@ describe("Schema Generator Integration Tests", () => {
         ],
       };
 
-      const results = generate.samples<any>(documentSchema, 10);
+      const results = await generate.samples<any>(documentSchema, 10);
 
       results.forEach((result) => {
         // Should have base properties
@@ -265,7 +265,7 @@ describe("Schema Generator Integration Tests", () => {
   });
 
   describe("State Management Integration", () => {
-    it("maintains state across multiple generations", () => {
+    it("maintains state across multiple generations", async () => {
       const _callCount = 0;
       const plugin = fakerPlugin({
         schema: {
@@ -293,7 +293,8 @@ describe("Schema Generator Integration Tests", () => {
       };
 
       // Simulate multiple requests with evolving state
-      const results = Array.from({ length: 5 }, (_, i) => {
+      const results: any[] = [];
+      for (let i = 0; i < 5; i++) {
         const context = {
           ...baseContext,
           state: new Map(),
@@ -302,8 +303,9 @@ describe("Schema Generator Integration Tests", () => {
             sessionId: "session-123",
           },
         };
-        return plugin.process(context).response;
-      });
+        const r = await plugin.process(context);
+        results.push(r.response);
+      }
 
       // Request numbers should increment
       results.forEach((result, i) => {
@@ -312,7 +314,7 @@ describe("Schema Generator Integration Tests", () => {
       });
     });
 
-    it("generates stateful mock data", () => {
+    it("generates stateful mock data", async () => {
       const cartSchema: JSONSchema7 = {
         type: "object",
         properties: {
@@ -334,10 +336,10 @@ describe("Schema Generator Integration Tests", () => {
       };
 
       // Generate initial cart
-      const cart1 = generateFromSchema({ schema: cartSchema });
+      const cart1 = await generateFromSchema({ schema: cartSchema });
 
       // Simulate adding items (would be done through state in real usage)
-      const cart2 = generateFromSchema({
+      const cart2 = await generateFromSchema({
         schema: cartSchema,
         overrides: {
           id: cart1.id, // Keep same cart ID
@@ -352,7 +354,7 @@ describe("Schema Generator Integration Tests", () => {
   });
 
   describe("Performance at Scale", () => {
-    it("generates large datasets efficiently", () => {
+    it("generates large datasets efficiently", async () => {
       const schema: JSONSchema7 = {
         type: "array",
         items: {
@@ -374,7 +376,7 @@ describe("Schema Generator Integration Tests", () => {
       };
 
       const startTime = Date.now();
-      const result = generateFromSchema({ schema, count: 100 });
+      const result = await generateFromSchema({ schema, count: 100 });
       const duration = Date.now() - startTime;
 
       expect(result).toHaveLength(100);
@@ -404,7 +406,7 @@ describe("Schema Generator Integration Tests", () => {
 
       // Simulate concurrent requests
       const promises = Array.from({ length: 20 }, () =>
-        Promise.resolve(plugin.process(context)),
+        plugin.process(context),
       );
 
       const results = await Promise.all(promises);
@@ -420,10 +422,10 @@ describe("Schema Generator Integration Tests", () => {
   });
 
   describe("Error Recovery and Resilience", () => {
-    it("recovers from validation errors gracefully", () => {
+    it("recovers from validation errors gracefully", async () => {
       // First, try invalid schema
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: {
@@ -436,14 +438,14 @@ describe("Schema Generator Integration Tests", () => {
       }
 
       // Should still work with valid schema
-      const result = generateFromSchema({
+      const result = await generateFromSchema({
         schema: schemas.simple.object({ id: schemas.simple.number() }),
       });
 
       expect(result).toHaveProperty("id");
     });
 
-    it("handles partial template failures", () => {
+    it("handles partial template failures", async () => {
       const plugin = fakerPlugin({
         schema: {
           type: "object",
@@ -462,7 +464,7 @@ describe("Schema Generator Integration Tests", () => {
         },
       });
 
-      const result = plugin.process({
+      const result = await plugin.process({
         method: "GET",
         path: "/test",
         params: { value1: "success" },
@@ -485,7 +487,7 @@ describe("Schema Generator Integration Tests", () => {
   });
 
   describe("Advanced Integration Patterns", () => {
-    it("supports pagination patterns", () => {
+    it("supports pagination patterns", async () => {
       const paginatedSchema: JSONSchema7 = {
         type: "object",
         properties: {
@@ -523,7 +525,7 @@ describe("Schema Generator Integration Tests", () => {
         },
       });
 
-      const result = plugin.process({
+      const result = await plugin.process({
         method: "GET",
         path: "/api/items",
         params: {},
@@ -541,7 +543,7 @@ describe("Schema Generator Integration Tests", () => {
       expect(result.response.pagination.hasNext).toBe(true);
     });
 
-    it("supports versioned API responses", () => {
+    it("supports versioned API responses", async () => {
       const v1Schema: JSONSchema7 = {
         type: "object",
         properties: {
@@ -571,8 +573,8 @@ describe("Schema Generator Integration Tests", () => {
         },
       };
 
-      const v1Result = generateFromSchema({ schema: v1Schema });
-      const v2Result = generateFromSchema({ schema: v2Schema });
+      const v1Result = await generateFromSchema({ schema: v1Schema });
+      const v2Result = await generateFromSchema({ schema: v2Schema });
 
       expect(v1Result.version).toBe("1.0");
       expect(typeof v1Result.data.id).toBe("number");

package/src/jsf-config.ts

@@ -1,10 +1,10 @@
 import { base, en, Faker } from "@faker-js/faker";
-import jsf from "json-schema-faker";
+import type { JSONSchema7 } from "json-schema";
+import { generate } from "json-schema-faker";
 
 /**
- * Create isolated faker instance to avoid race conditions
- * Each generation gets its own faker instance to ensure thread-safety
- * @returns Fresh Faker instance with English locale
+ * Create isolated faker instance to avoid race conditions.
+ * Each generation gets its own faker instance to ensure thread-safety.
  */
 export function createFakerInstance(seed?: number) {
   const faker = new Faker({ locale: [en, base] });
@@ -14,45 +14,29 @@ export function createFakerInstance(seed?: number) {
   return faker;
 }
 
-let jsfConfigured = false;
-let currentSeed: number | undefined;
-
 /**
- * Create a seeded PRNG using the mulberry32 algorithm.
- * Returns a function that produces deterministic values in [0, 1).
+ * Generate data from a JSON schema using json-schema-faker 0.6.0 async API.
+ * Stateless — each call is self-contained with its own faker instance and options.
  */
-function createSeededRandom(seed: number): () => number {
-  let state = seed | 0;
-  return () => {
-    state = (state + 0x6d2b79f5) | 0;
-    let t = state;
-    t = Math.imul(t ^ (t >>> 15), t | 1);
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
+export async function generateWithJsf(
+  schema: JSONSchema7,
+  seed?: number,
+): Promise<unknown> {
+  // When no seed is specified, generate a random seed to ensure different
+  // results on each call. JSF 0.6.0 treats seed=undefined as deterministic.
+  const effectiveSeed = seed ?? Math.floor(Math.random() * 2147483647);
 
-export function getJsf(seed?: number): typeof jsf {
-  const seedChanged = seed !== currentSeed;
-  if (!jsfConfigured || seedChanged) {
-    currentSeed = seed;
-    jsf.extend("faker", () => createFakerInstance(seed));
-    jsf.option({
-      requiredOnly: false,
+  return generate(
+    schema as any,
+    {
+      seed: effectiveSeed,
+      optionalsProbability: 1.0,
       alwaysFakeOptionals: true,
       useDefaultValue: true,
       ignoreMissingRefs: true,
       failOnInvalidTypes: false,
       failOnInvalidFormat: false,
-    });
-    jsfConfigured = true;
-  }
-  // Always reset PRNG for deterministic output per call
-  if (seed !== undefined) {
-    jsf.option({ random: createSeededRandom(seed) });
-    jsf.extend("faker", () => createFakerInstance(seed));
-  } else {
-    jsf.option({ random: Math.random });
-  }
-  return jsf;
+      extensions: { faker: createFakerInstance(seed) },
+    } as any,
+  );
 }

package/src/performance.test.ts

@@ -14,8 +14,8 @@ describe("Performance and Memory", () => {
 
       const times: number[] = [];
       for (let i = 0; i < 10; i++) {
-        const { duration } = await perf.measure(() =>
-          generateFromSchema({ schema }),
+        const { duration } = await perf.measure(
+          async () => await generateFromSchema({ schema }),
         );
         times.push(duration);
       }
@@ -33,8 +33,8 @@ describe("Performance and Memory", () => {
         }),
       );
 
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({ schema }),
+      const { duration } = await perf.measure(
+        async () => await generateFromSchema({ schema }),
       );
 
       expect(duration).toBeLessThan(100); // Reasonable for nested structure
@@ -49,8 +49,8 @@ describe("Performance and Memory", () => {
         { minItems: 50, maxItems: 50 },
       );
 
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({ schema }),
+      const { duration } = await perf.measure(
+        async () => await generateFromSchema({ schema }),
       );
 
       expect(duration).toBeLessThan(200); // Should handle 50 items quickly
@@ -82,8 +82,8 @@ describe("Performance and Memory", () => {
         },
       };
 
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({ schema }),
+      const { duration } = await perf.measure(
+        async () => await generateFromSchema({ schema }),
       );
 
       expect(duration).toBeLessThan(300); // Complex but still reasonable
@@ -104,8 +104,8 @@ describe("Performance and Memory", () => {
 
       // Warmup runs to stabilize JIT
       for (let i = 0; i < 3; i++) {
-        generateFromSchema({ schema: smallSchema });
-        generateFromSchema({ schema: largeSchema });
+        await generateFromSchema({ schema: smallSchema });
+        await generateFromSchema({ schema: largeSchema });
       }
 
       // Multiple measurement runs for statistical stability
@@ -114,12 +114,12 @@ describe("Performance and Memory", () => {
 
       for (let i = 0; i < 10; i++) {
         const start1 = performance.now();
-        generateFromSchema({ schema: smallSchema });
+        await generateFromSchema({ schema: smallSchema });
         const small = performance.now() - start1;
         smallTimes.push(small);
 
         const start2 = performance.now();
-        generateFromSchema({ schema: largeSchema });
+        await generateFromSchema({ schema: largeSchema });
         const large = performance.now() - start2;
         largeTimes.push(large);
       }
@@ -148,8 +148,8 @@ describe("Performance and Memory", () => {
 
       // Warmup
       for (let i = 0; i < 3; i++) {
-        generateFromSchema({ schema: narrowSchema });
-        generateFromSchema({ schema: wideSchema });
+        await generateFromSchema({ schema: narrowSchema });
+        await generateFromSchema({ schema: wideSchema });
       }
 
       // Measure with multiple runs, dropping outliers
@@ -158,11 +158,11 @@ describe("Performance and Memory", () => {
 
       for (let i = 0; i < 10; i++) {
         const start1 = performance.now();
-        generateFromSchema({ schema: narrowSchema });
+        await generateFromSchema({ schema: narrowSchema });
         narrowTimes.push(performance.now() - start1);
 
         const start2 = performance.now();
-        generateFromSchema({ schema: wideSchema });
+        await generateFromSchema({ schema: wideSchema });
         wideTimes.push(performance.now() - start2);
       }
 
@@ -231,16 +231,17 @@ describe("Performance and Memory", () => {
         message: "User {{params.id}} at {{state.timestamp}}",
       };
 
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({
-          schema,
-          overrides,
-          params: { id: "123" },
-          state: {
-            user: { id: "user-456" },
-            timestamp: new Date().toISOString(),
-          },
-        }),
+      const { duration } = await perf.measure(
+        async () =>
+          await generateFromSchema({
+            schema,
+            overrides,
+            params: { id: "123" },
+            state: {
+              user: { id: "user-456" },
+              timestamp: new Date().toISOString(),
+            },
+          }),
       );
 
       expect(duration).toBeLessThan(50); // Template processing should be fast
@@ -252,8 +253,9 @@ describe("Performance and Memory", () => {
       const schema = schemas.complex.user();
 
       const { duration } = await perf.measure(async () => {
-        const promises = Array.from({ length: 20 }, () =>
-          generateFromSchema({ schema }),
+        const promises = Array.from(
+          { length: 20 },
+          async () => await generateFromSchema({ schema }),
         );
         await Promise.all(promises);
       });
@@ -268,13 +270,13 @@ describe("Performance and Memory", () => {
       });
 
       // Warm up
-      generateFromSchema({ schema });
+      await generateFromSchema({ schema });
 
       // Test under load
       const iterations = 100;
       const { duration } = await perf.measure(async () => {
         for (let i = 0; i < iterations; i++) {
-          generateFromSchema({ schema });
+          await generateFromSchema({ schema });
         }
       });
 
@@ -284,7 +286,7 @@ describe("Performance and Memory", () => {
   });
 
   describe("Memory Efficiency", () => {
-    it("doesn't leak memory on repeated generation", () => {
+    it("doesn't leak memory on repeated generation", async () => {
       const schema = schemas.simple.object({
         id: schemas.simple.number(),
         name: schemas.simple.string(),
@@ -292,7 +294,7 @@ describe("Performance and Memory", () => {
 
       // Generate many times
       for (let i = 0; i < 1000; i++) {
-        const result = generateFromSchema({ schema });
+        const result = await generateFromSchema({ schema });
         // Result should be garbage collectable
         expect(result).toBeDefined();
       }
@@ -301,7 +303,7 @@ describe("Performance and Memory", () => {
       expect(true).toBe(true);
     });
 
-    it("handles large data structures without excessive memory", () => {
+    it("handles large data structures without excessive memory", async () => {
       const schema = schemas.simple.array(
         schemas.simple.object({
           id: schemas.simple.string(),
@@ -311,15 +313,15 @@ describe("Performance and Memory", () => {
       );
 
       // Should be able to generate without memory issues
-      const result = generateFromSchema({ schema });
+      const result = await generateFromSchema({ schema });
       expect(result).toHaveLength(1000);
     });
 
-    it("cleans up after schema validation errors", () => {
+    it("cleans up after schema validation errors", async () => {
       // Generate errors repeatedly
       for (let i = 0; i < 100; i++) {
         try {
-          generateFromSchema({ schema: { type: "invalid" as any } });
+          await generateFromSchema({ schema: { type: "invalid" as any } });
         } catch (_e) {
           // Expected
         }
@@ -341,7 +343,7 @@ describe("Performance and Memory", () => {
       // Generate multiple times to ensure consistent behavior
       const results: any[] = [];
       for (let i = 0; i < 10; i++) {
-        const result = generateFromSchema({ schema });
+        const result = await generateFromSchema({ schema });
         results.push(result);
       }
 
@@ -414,8 +416,8 @@ describe("Performance and Memory", () => {
     it("handles empty schemas efficiently", async () => {
       const schema = schemas.simple.object({});
 
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({ schema }),
+      const { duration } = await perf.measure(
+        async () => await generateFromSchema({ schema }),
       );
 
       expect(duration).toBeLessThan(10); // Empty should be instant
@@ -429,8 +431,8 @@ describe("Performance and Memory", () => {
         },
       });
 
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({ schema }),
+      const { duration } = await perf.measure(
+        async () => await generateFromSchema({ schema }),
       );
 
       expect(duration).toBeLessThan(50); // Large enum shouldn't be slow
@@ -473,8 +475,8 @@ describe("Performance and Memory", () => {
         ],
       };
 
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({ schema }),
+      const { duration } = await perf.measure(
+        async () => await generateFromSchema({ schema }),
       );
 
       expect(duration).toBeLessThan(200); // Complex but manageable