@schmock/faker 2.2.3 → 2.3.1

package/src/schema-enhancement.test.ts

@@ -1,216 +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("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/schema-enhancement.ts

@@ -1,128 +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;
-}
-
-export function enhanceSchemaWithSmartMapping(
-  schema: JSONSchema7,
-): JSONSchema7 {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-
-  const enhanced = { ...schema } as FakerSchema;
-
-  // 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 as Record<string, unknown>)[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 (
-    enhanced.additionalProperties &&
-    typeof enhanced.additionalProperties === "object" &&
-    !Array.isArray(enhanced.additionalProperties)
-  ) {
-    enhanced.additionalProperties = enhanceSchemaWithSmartMapping(
-      enhanced.additionalProperties as JSONSchema7,
-    );
-  }
-
-  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;
-    }
-  }
-
-  return enhanced;
-}

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

@@ -1,35 +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;
-
-  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);
-    });
-  });
-
-});

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

@@ -1,109 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { generateFromSchema } from "../index";
-
-const feature = await loadFeature("../../features/faker-plugin.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let generated: any;
-
-  Scenario(
-    "Generate object from simple schema",
-    ({ Given, When, Then, And }) => {
-      let schema: any;
-
-      Given("I create a schema plugin with:", (_, docString: string) => {
-        schema = JSON.parse(docString);
-      });
-
-      When("I generate data from the schema", async () => {
-        generated = await generateFromSchema({ schema });
-      });
-
-      Then(
-        "the generated data should have property {string} of type {string}",
-        (_, prop: string, type: string) => {
-          expect(generated).toHaveProperty(prop);
-          expect(typeof generated[prop]).toBe(type);
-        },
-      );
-
-      And(
-        "the generated data should have property {string} of type {string}",
-        (_, prop: string, type: string) => {
-          expect(generated).toHaveProperty(prop);
-          expect(typeof generated[prop]).toBe(type);
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Generate array of items with explicit count",
-    ({ Given, When, Then }) => {
-      let schema: any;
-      let count: number;
-
-      Given(
-        "I create a schema plugin for array with count {int}:",
-        (_, cnt: number, docString: string) => {
-          schema = JSON.parse(docString);
-          count = cnt;
-        },
-      );
-
-      When("I generate data from the schema", async () => {
-        generated = await generateFromSchema({ schema, count });
-      });
-
-      Then(
-        "the generated data should be an array of length {int}",
-        (_, length: number) => {
-          expect(Array.isArray(generated)).toBe(true);
-          expect(generated).toHaveLength(length);
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Template preserves string values for mixed templates",
-    ({ Given, When, Then }) => {
-      let template: string;
-      let result: any;
-
-      Given(
-        "I create a schema plugin with template override {string}",
-        (_, tmpl: string) => {
-          template = tmpl;
-        },
-      );
-
-      When(
-        "I generate data with param {string} set to {string}",
-        async (_, paramName: string, paramValue: string) => {
-          const schema = {
-            type: "object" as const,
-            properties: {
-              value: { type: "string" as const },
-            },
-          };
-          result = await generateFromSchema({
-            schema,
-            overrides: { value: template },
-            params: { [paramName]: paramValue },
-          });
-        },
-      );
-
-      Then(
-        "the template result should be the string {string}",
-        (_, expected: string) => {
-          expect(result.value).toBe(expected);
-          expect(typeof result.value).toBe("string");
-        },
-      );
-    },
-  );
-
-});