@schmock/faker 1.13.0 → 2.0.1

package/src/schema-enhancement.test.ts

@@ -0,0 +1,216 @@
+import type { JSONSchema7 } from "json-schema";
+import { describe, expect, it } from "vitest";
+import { enhanceSchemaWithSmartMapping } from "./schema-enhancement";
+
+describe("enhanceSchemaWithSmartMapping", () => {
+  it("does NOT mutate the original schema", () => {
+    const original: JSONSchema7 = {
+      type: "object",
+      properties: {
+        email: { type: "string" },
+        firstName: { type: "string" },
+        createdAt: { type: "string" },
+      },
+    };
+
+    // Deep snapshot before enhancement
+    const snapshot = JSON.parse(JSON.stringify(original));
+
+    enhanceSchemaWithSmartMapping(original);
+
+    // Original should be unchanged
+    expect(original).toEqual(snapshot);
+  });
+
+  it("enhancement of object with properties adds faker methods to appropriate fields", () => {
+    const schema: JSONSchema7 = {
+      type: "object",
+      properties: {
+        email: { type: "string" },
+        firstName: { type: "string" },
+        lastName: { type: "string" },
+        phone: { type: "string" },
+        uuid: { type: "string" },
+      },
+    };
+
+    const enhanced = enhanceSchemaWithSmartMapping(schema) as Record<
+      string,
+      unknown
+    >;
+    const props = enhanced.properties as Record<
+      string,
+      JSONSchema7 & { faker?: string }
+    >;
+
+    // Well-known fields should receive faker methods
+    expect(props.email.faker).toBeDefined();
+    expect(props.firstName.faker).toBeDefined();
+    expect(props.lastName.faker).toBeDefined();
+    expect(props.phone.faker).toBeDefined();
+    expect(props.uuid.faker).toBeDefined();
+
+    // Verify they are plausible faker method strings (namespace.method format)
+    for (const field of ["email", "firstName", "lastName", "phone", "uuid"]) {
+      const fakerMethod = props[field].faker as string;
+      expect(fakerMethod).toContain(".");
+      expect(fakerMethod.split(".").length).toBeGreaterThanOrEqual(2);
+    }
+  });
+
+  it("enhancement recurses into allOf branches", () => {
+    const schema: JSONSchema7 = {
+      allOf: [
+        {
+          type: "object",
+          properties: {
+            email: { type: "string" },
+          },
+        },
+        {
+          type: "object",
+          properties: {
+            phone: { type: "string" },
+          },
+        },
+      ],
+    };
+
+    const enhanced = enhanceSchemaWithSmartMapping(schema);
+    const allOf = enhanced.allOf as Array<
+      JSONSchema7 & { properties: Record<string, { faker?: string }> }
+    >;
+
+    expect(allOf).toHaveLength(2);
+    expect(allOf[0].properties.email.faker).toBeDefined();
+    expect(allOf[1].properties.phone.faker).toBeDefined();
+  });
+
+  it("enhancement recurses into anyOf branches", () => {
+    const schema: JSONSchema7 = {
+      anyOf: [
+        {
+          type: "object",
+          properties: {
+            email: { type: "string" },
+          },
+        },
+      ],
+    };
+
+    const enhanced = enhanceSchemaWithSmartMapping(schema);
+    const anyOf = enhanced.anyOf as Array<
+      JSONSchema7 & { properties: Record<string, { faker?: string }> }
+    >;
+
+    expect(anyOf).toHaveLength(1);
+    expect(anyOf[0].properties.email.faker).toBeDefined();
+  });
+
+  it("enhancement recurses into oneOf branches", () => {
+    const schema: JSONSchema7 = {
+      oneOf: [
+        {
+          type: "object",
+          properties: {
+            firstName: { type: "string" },
+          },
+        },
+      ],
+    };
+
+    const enhanced = enhanceSchemaWithSmartMapping(schema);
+    const oneOf = enhanced.oneOf as Array<
+      JSONSchema7 & { properties: Record<string, { faker?: string }> }
+    >;
+
+    expect(oneOf).toHaveLength(1);
+    expect(oneOf[0].properties.firstName.faker).toBeDefined();
+  });
+
+  it("enhancement recurses into array items", () => {
+    const schema: JSONSchema7 = {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          email: { type: "string" },
+          createdAt: { type: "string" },
+        },
+      },
+    };
+
+    const enhanced = enhanceSchemaWithSmartMapping(schema);
+    const items = enhanced.items as JSONSchema7 & {
+      properties: Record<string, { faker?: string }>;
+    };
+
+    expect(items.properties.email.faker).toBeDefined();
+    expect(items.properties.createdAt.faker).toBeDefined();
+  });
+
+  it("fields with existing faker property are not overridden", () => {
+    const schema: JSONSchema7 = {
+      type: "object",
+      properties: {
+        email: {
+          type: "string",
+          faker: "lorem.word",
+        } as JSONSchema7 & { faker: string },
+      },
+    };
+
+    const enhanced = enhanceSchemaWithSmartMapping(schema);
+    const props = enhanced.properties as Record<
+      string,
+      JSONSchema7 & { faker?: string }
+    >;
+
+    // Should keep the explicit faker method, not replace with email generator
+    expect(props.email.faker).toBe("lorem.word");
+  });
+
+  it("handles schema without properties gracefully", () => {
+    const schema: JSONSchema7 = { type: "string" };
+    const enhanced = enhanceSchemaWithSmartMapping(schema);
+    expect(enhanced).toEqual({ type: "string" });
+  });
+
+  it("handles null/undefined schema gracefully", () => {
+    expect(enhanceSchemaWithSmartMapping(null as unknown as JSONSchema7)).toBe(
+      null,
+    );
+    expect(
+      enhanceSchemaWithSmartMapping(undefined as unknown as JSONSchema7),
+    ).toBe(undefined);
+  });
+
+  it("enhancement recurses into array items when items is a tuple (array)", () => {
+    const schema: JSONSchema7 = {
+      type: "array",
+      items: [
+        {
+          type: "object",
+          properties: {
+            email: { type: "string" },
+          },
+        },
+        {
+          type: "object",
+          properties: {
+            phone: { type: "string" },
+          },
+        },
+      ],
+    };
+
+    const enhanced = enhanceSchemaWithSmartMapping(schema);
+    const items = enhanced.items as Array<
+      JSONSchema7 & { properties: Record<string, { faker?: string }> }
+    >;
+
+    expect(Array.isArray(items)).toBe(true);
+    expect(items[0].properties.email.faker).toBeDefined();
+    expect(items[1].properties.phone.faker).toBeDefined();
+  });
+});

package/src/steps/deterministic-seeds.steps.ts

@@ -32,25 +32,4 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario(
-    "Different seeds produce different output",
-    ({ Given, And, When, Then }) => {
-      Given("a schema plugin with seed 42", () => {
-        // setup done during generation
-      });
-
-      And("a schema plugin with seed 99", () => {
-        // setup done during generation
-      });
-
-      When("I generate data from each", async () => {
-        result1 = await generateFromSchema({ schema: testSchema, seed: 42 });
-        result2 = await generateFromSchema({ schema: testSchema, seed: 99 });
-      });
-
-      Then("the outputs are different", () => {
-        expect(result1).not.toEqual(result2);
-      });
-    },
-  );
 });

package/src/steps/faker-plugin.steps.ts

@@ -1,12 +1,11 @@
 import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
 import { expect } from "vitest";
-import { fakerPlugin, generateFromSchema } from "../index";
+import { generateFromSchema } from "../index";
 
 const feature = await loadFeature("../../features/faker-plugin.feature");
 
 describeFeature(feature, ({ Scenario }) => {
   let generated: any;
-  let error: Error | null = null;
 
   Scenario(
     "Generate object from simple schema",
@@ -107,102 +106,4 @@ describeFeature(feature, ({ Scenario }) => {
     },
   );
 
-  Scenario(
-    "Multiple schema plugin instances do not share state",
-    ({ Given, When, Then }) => {
-      let plugin1: any;
-      let plugin2: any;
-      let data1: any;
-      let data2: any;
-
-      Given("I create two separate schema plugin instances", () => {
-        const schema = {
-          type: "object" as const,
-          properties: {
-            name: { type: "string" as const },
-          },
-          required: ["name"],
-        };
-        plugin1 = fakerPlugin({ schema });
-        plugin2 = fakerPlugin({ schema });
-      });
-
-      When("I generate data from both instances", async () => {
-        const ctx = {
-          path: "/test",
-          route: {},
-          method: "GET" as const,
-          params: {},
-          query: {},
-          headers: {},
-          state: new Map(),
-        };
-        const result1 = await plugin1.process(ctx);
-        const result2 = await plugin2.process(ctx);
-        data1 = result1.response;
-        data2 = result2.response;
-      });
-
-      Then(
-        "the data from each instance should be independently generated",
-        () => {
-          expect(data1).toBeDefined();
-          expect(data2).toBeDefined();
-          expect(typeof data1.name).toBe("string");
-          expect(typeof data2.name).toBe("string");
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Invalid schema is rejected at plugin creation time",
-    ({ Given, Then }) => {
-      Given("I attempt to create a schema plugin with invalid schema", () => {
-        error = null;
-        try {
-          fakerPlugin({ schema: {} as any });
-        } catch (e) {
-          error = e as Error;
-        }
-      });
-
-      Then("it should throw a SchemaValidationError", () => {
-        expect(error).not.toBeNull();
-        expect(error?.name).toBe("SchemaValidationError");
-      });
-    },
-  );
-
-  Scenario(
-    "Faker method validation checks actual method existence",
-    ({ Given, Then }) => {
-      Given(
-        "I attempt to create a schema with faker method {string}",
-        (_, fakerMethod: string) => {
-          error = null;
-          try {
-            const schema = {
-              type: "object" as const,
-              properties: {
-                field: { type: "string" as const, faker: fakerMethod },
-              },
-            };
-            fakerPlugin({ schema: schema as any });
-          } catch (e) {
-            error = e as Error;
-          }
-        },
-      );
-
-      Then(
-        "it should throw a SchemaValidationError with message {string}",
-        (_, message: string) => {
-          expect(error).not.toBeNull();
-          expect(error?.name).toBe("SchemaValidationError");
-          expect(error?.message).toContain(message);
-        },
-      );
-    },
-  );
 });

package/src/test-utils.ts

@@ -119,13 +119,17 @@ export const validators = {
     // Generate multiple samples to check for patterns
     const mappedSamples: any[] = [];
     for (let i = 0; i < 10; i++) {
-      const result = await generateFromSchema({ schema: mappedSchema });
+      const result = (await generateFromSchema({
+        schema: mappedSchema,
+      })) as Record<string, unknown>;
       mappedSamples.push(result[fieldName]);
     }
 
     const unmappedSamples: any[] = [];
     for (let i = 0; i < 10; i++) {
-      const result = await generateFromSchema({ schema: unmappedSchema });
+      const result = (await generateFromSchema({
+        schema: unmappedSchema,
+      })) as Record<string, unknown>;
       unmappedSamples.push(result.unmappedRandomField12345);
     }
 
@@ -254,7 +258,7 @@ export const generate = {
   ): Promise<T[]> => {
     const results: T[] = [];
     for (let i = 0; i < count; i++) {
-      results.push(await generateFromSchema({ schema, ...options }));
+      results.push((await generateFromSchema({ schema, ...options })) as T);
     }
     return results;
   },

package/src/validation.ts

@@ -392,10 +392,10 @@ export function validateFakerMethod(fakerMethod: string): void {
     validationFaker = createFakerInstance();
   }
   const faker = validationFaker;
-  let current: any = faker;
+  let current: unknown = faker;
   for (const part of parts) {
     if (current && typeof current === "object" && part in current) {
-      current = current[part];
+      current = (current as Record<string, unknown>)[part];
     } else {
       throw new SchemaValidationError(
         "$.faker",