@schmock/faker 2.3.0 → 2.3.1

package/src/schema-enhancement.test.ts

@@ -1,222 +0,0 @@
-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("adds useful text generation to an unconstrained root string", () => {
-    const schema: JSONSchema7 = { type: "string" };
-    const enhanced = enhanceSchemaWithSmartMapping(schema);
-    expect(enhanced).toEqual({ type: "string", faker: "lorem.word" });
-  });
-
-  it("preserves an explicit zero minimum length", () => {
-    const schema: JSONSchema7 = { type: "string", minLength: 0 };
-    const enhanced = enhanceSchemaWithSmartMapping(schema);
-    expect(enhanced).toEqual(schema);
-  });
-
-  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/schema-enhancement.ts

@@ -1,144 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { findBestMapping } from "./field-name-matcher.js";
-import { isJSONSchema7, validateFakerMethod } from "./validation.js";
-
-/** JSONSchema7 extended with json-schema-faker's `faker` property and schmock markers */
-interface FakerSchema extends JSONSchema7 {
-  faker?: string | Record<string, unknown>;
-  schmockNullable?: boolean;
-  schmockTrueProbability?: number;
-}
-
-function needsStringFallback(schema: FakerSchema): boolean {
-  return (
-    schema.type === "string" &&
-    schema.faker === undefined &&
-    schema.format === undefined &&
-    schema.pattern === undefined &&
-    schema.enum === undefined &&
-    schema.const === undefined &&
-    schema.$ref === undefined &&
-    schema.minLength === undefined &&
-    schema.maxLength === undefined
-  );
-}
-
-export function enhanceSchemaWithSmartMapping(
-  schema: JSONSchema7,
-): JSONSchema7 {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-
-  const enhanced: FakerSchema = { ...schema };
-
-  // Handle object properties
-  if (enhanced.properties) {
-    enhanced.properties = { ...enhanced.properties };
-
-    for (const [fieldName, fieldSchema] of Object.entries(
-      enhanced.properties,
-    )) {
-      if (isJSONSchema7(fieldSchema)) {
-        enhanced.properties[fieldName] = enhanceFieldSchema(
-          fieldName,
-          fieldSchema,
-        );
-      }
-    }
-  }
-
-  // Recurse into composition keywords
-  for (const keyword of ["allOf", "anyOf", "oneOf"] as const) {
-    const branches = enhanced[keyword];
-    if (Array.isArray(branches)) {
-      enhanced[keyword] = branches.map((branch) =>
-        isJSONSchema7(branch) ? enhanceSchemaWithSmartMapping(branch) : branch,
-      );
-    }
-  }
-
-  // Recurse into array items
-  if (enhanced.items) {
-    if (Array.isArray(enhanced.items)) {
-      enhanced.items = enhanced.items.map((item) =>
-        isJSONSchema7(item) ? enhanceSchemaWithSmartMapping(item) : item,
-      );
-    } else if (isJSONSchema7(enhanced.items)) {
-      enhanced.items = enhanceSchemaWithSmartMapping(enhanced.items);
-    }
-  }
-
-  // Recurse into additionalProperties
-  if (isJSONSchema7(enhanced.additionalProperties)) {
-    enhanced.additionalProperties = enhanceSchemaWithSmartMapping(
-      enhanced.additionalProperties,
-    );
-  }
-
-  if (needsStringFallback(enhanced)) {
-    enhanced.faker = "lorem.word";
-  }
-
-  return enhanced;
-}
-
-function enhanceFieldSchema(
-  fieldName: string,
-  fieldSchema: JSONSchema7,
-): FakerSchema {
-  const enhanced: FakerSchema = { ...fieldSchema };
-
-  // If already has faker extension, validate it and don't override.
-  // User-supplied faker values are always strings; the object form is only
-  // produced internally by this function when fakerArgs are present.
-  if (enhanced.faker) {
-    if (typeof enhanced.faker === "string") {
-      validateFakerMethod(enhanced.faker);
-    }
-    return enhanced;
-  }
-
-  // Recursively enhance nested schemas first
-  const hasComposition = enhanced.allOf || enhanced.anyOf || enhanced.oneOf;
-  if (enhanced.properties || hasComposition || enhanced.items) {
-    const recursed = enhanceSchemaWithSmartMapping(enhanced);
-    Object.assign(enhanced, recursed);
-  }
-
-  // Don't apply field-level faker mapping to composition schemas — the branches define their own types
-  if (hasComposition) {
-    return enhanced;
-  }
-
-  // Don't apply smart mapping when const or enum is defined — these have fixed values
-  if (enhanced.const !== undefined || enhanced.enum) {
-    return enhanced;
-  }
-
-  // Apply smart field name mapping via the scoring matcher
-  const match = findBestMapping(fieldName, enhanced);
-  if (match) {
-    const { fakerMethod, format, trueProbability, fakerArgs } = match.mapping;
-    // Use the JSF object form when fakerArgs are present so the options object
-    // is forwarded to the faker method (e.g. number.int({ min, max })).
-    // JSF calls Q(...J) where J is the value, so we must wrap fakerArgs in an
-    // array: { "number.int": [{ min, max }] } → faker.number.int({ min, max }).
-    // Fall back to the plain string form when there are no args.
-    if (fakerArgs) {
-      enhanced.faker = { [fakerMethod]: [fakerArgs] };
-    } else {
-      enhanced.faker = fakerMethod;
-    }
-    if (format) {
-      enhanced.format = format;
-    }
-    if (trueProbability !== undefined) {
-      enhanced.schmockTrueProbability = trueProbability;
-    }
-  } else if (needsStringFallback(enhanced)) {
-    enhanced.faker = "lorem.word";
-  }
-
-  return enhanced;
-}

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

@@ -1,112 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { generateFromSchema } from "../index";
-
-const feature = await loadFeature("../../features/deterministic-seeds.feature");
-
-const testSchema = {
-  type: "object" as const,
-  properties: {
-    name: { type: "string" as const },
-    age: { type: "integer" as const, minimum: 1, maximum: 100 },
-  },
-  required: ["name", "age"],
-};
-
-describeFeature(feature, ({ Scenario }) => {
-  let result1: unknown;
-  let result2: unknown;
-  let seededArray1: unknown;
-  let seededArray2: unknown;
-  let differentSeedResult1: unknown;
-  let differentSeedResult2: unknown;
-
-  Scenario("Same seed produces same output", ({ Given, When, Then }) => {
-    Given("a schema plugin with seed 42", () => {
-      // seed will be passed during generation
-    });
-
-    When("I generate data twice with the same seed", async () => {
-      result1 = await generateFromSchema({ schema: testSchema, seed: 42 });
-      result2 = await generateFromSchema({ schema: testSchema, seed: 42 });
-    });
-
-    Then("both outputs are identical", () => {
-      expect(result1).toEqual(result2);
-    });
-  });
-
-  Scenario(
-    "Different seeds produce different output",
-    ({ Given, When, Then }) => {
-      let firstSeed = 0;
-      let secondSeed = 0;
-
-      Given(
-        "a schema plugin using seeds {int} and {int}",
-        (_, seedA: number, seedB: number) => {
-          firstSeed = seedA;
-          secondSeed = seedB;
-        },
-      );
-
-      When("I generate data once with each seed", async () => {
-        differentSeedResult1 = await generateFromSchema({
-          schema: testSchema,
-          seed: firstSeed,
-        });
-        differentSeedResult2 = await generateFromSchema({
-          schema: testSchema,
-          seed: secondSeed,
-        });
-      });
-
-      Then("the differently seeded outputs are distinct", () => {
-        expect(differentSeedResult1).not.toEqual(differentSeedResult2);
-      });
-    },
-  );
-
-  Scenario(
-    "Seeded arrays are reproducible without repeating every item",
-    ({ Given, When, Then, And }) => {
-      let count = 0;
-
-      Given(
-        "an array schema plugin with seed 42 and count {int}",
-        (_, requestedCount: number) => {
-          count = requestedCount;
-        },
-      );
-
-      When("I generate the seeded array twice", async () => {
-        const schema = {
-          type: "array" as const,
-          items: {
-            type: "object" as const,
-            properties: {
-              id: { type: "integer" as const },
-              name: { type: "string" as const },
-            },
-            required: ["id", "name"],
-          },
-        };
-        seededArray1 = await generateFromSchema({ schema, count, seed: 42 });
-        seededArray2 = await generateFromSchema({ schema, count, seed: 42 });
-      });
-
-      Then("both seeded arrays are identical", () => {
-        expect(seededArray1).toEqual(seededArray2);
-      });
-
-      And("the seeded array contains varied items", () => {
-        expect(Array.isArray(seededArray1)).toBe(true);
-        if (!Array.isArray(seededArray1)) {
-          throw new Error("Expected seeded output to be an array");
-        }
-        const serialized = seededArray1.map((item) => JSON.stringify(item));
-        expect(new Set(serialized).size).toBeGreaterThan(1);
-      });
-    },
-  );
-});