@schmock/faker 2.3.0 → 2.4.0

package/src/jsf-config.ts

@@ -1,156 +0,0 @@
-import { base, en, Faker } from "@faker-js/faker";
-import type { JSONSchema7, JSONSchema7Definition } from "json-schema";
-import {
-  type GenerateOptions,
-  generate,
-  type JsonSchema,
-} from "json-schema-faker";
-
-const MAX_GENERATION_SEED = 2_147_483_647;
-type JsfObjectSchema = Exclude<JsonSchema, boolean>;
-
-/**
- * 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] });
-  if (seed !== undefined) {
-    faker.seed(seed);
-  }
-  return faker;
-}
-
-export function resolveGenerationSeed(seed?: number): number {
-  return seed ?? Math.floor(Math.random() * MAX_GENERATION_SEED);
-}
-
-export function createSeededRandom(seed: number): () => number {
-  let state = seed;
-  return () => {
-    state += 0x6d2b79f5;
-    let value = state;
-    value = Math.imul(value ^ (value >>> 15), value | 1);
-    value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
-    return ((value ^ (value >>> 14)) >>> 0) / 4_294_967_296;
-  };
-}
-
-function normalizeDefinitionForJsf(
-  definition: JSONSchema7Definition,
-): JsonSchema {
-  return typeof definition === "boolean"
-    ? definition
-    : normalizeSchemaForJsf(definition);
-}
-
-function normalizeDefinitionMap(
-  definitions: Record<string, JSONSchema7Definition>,
-): Record<string, JsonSchema> {
-  return Object.fromEntries(
-    Object.entries(definitions).map(([key, definition]) => [
-      key,
-      normalizeDefinitionForJsf(definition),
-    ]),
-  );
-}
-
-/**
- * json-schema-faker consumes tuple schemas through the 2020-12 `prefixItems`
- * keyword. Convert Draft 7 tuple `items` recursively at the library boundary.
- */
-export function normalizeSchemaForJsf(schema: JSONSchema7): JsfObjectSchema {
-  const normalized: JsfObjectSchema = {};
-  for (const [key, value] of Object.entries(schema)) {
-    normalized[key] = value;
-  }
-
-  if (schema.properties) {
-    normalized.properties = normalizeDefinitionMap(schema.properties);
-  }
-
-  if (schema.definitions) {
-    normalized.definitions = normalizeDefinitionMap(schema.definitions);
-  }
-
-  if (schema.$defs) {
-    normalized.$defs = normalizeDefinitionMap(schema.$defs);
-  }
-
-  if (schema.patternProperties) {
-    normalized.patternProperties = normalizeDefinitionMap(
-      schema.patternProperties,
-    );
-  }
-
-  if (Array.isArray(schema.items)) {
-    normalized.prefixItems = schema.items.map(normalizeDefinitionForJsf);
-    normalized.items =
-      schema.additionalItems === undefined
-        ? true
-        : normalizeDefinitionForJsf(schema.additionalItems);
-    delete normalized.additionalItems;
-  } else if (schema.items !== undefined) {
-    normalized.items = normalizeDefinitionForJsf(schema.items);
-  }
-
-  for (const keyword of ["allOf", "anyOf", "oneOf"] as const) {
-    const definitions = schema[keyword];
-    if (definitions) {
-      normalized[keyword] = definitions.map(normalizeDefinitionForJsf);
-    }
-  }
-
-  if (schema.additionalProperties !== undefined) {
-    normalized.additionalProperties = normalizeDefinitionForJsf(
-      schema.additionalProperties,
-    );
-  }
-
-  for (const keyword of [
-    "contains",
-    "not",
-    "if",
-    "then",
-    "else",
-    "propertyNames",
-  ] as const) {
-    const definition = schema[keyword];
-    if (definition !== undefined) {
-      normalized[keyword] = normalizeDefinitionForJsf(definition);
-    }
-  }
-
-  if (schema.dependencies) {
-    normalized.dependencies = Object.fromEntries(
-      Object.entries(schema.dependencies).map(([key, dependency]) => [
-        key,
-        Array.isArray(dependency)
-          ? [...dependency]
-          : normalizeDefinitionForJsf(dependency),
-      ]),
-    );
-  }
-
-  return normalized;
-}
-
-/**
- * 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.
- */
-export async function generateWithJsf(
-  schema: JSONSchema7,
-  seed: number,
-): Promise<unknown> {
-  const options: GenerateOptions = {
-    seed,
-    optionalsProbability: 1.0,
-    alwaysFakeOptionals: true,
-    useDefaultValue: true,
-    failOnInvalidTypes: false,
-    extensions: { faker: createFakerInstance(seed) },
-  };
-
-  return generate(normalizeSchemaForJsf(schema), options);
-}

package/src/overrides.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"overrides.d.ts","sourceRoot":"","sources":["overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,WAAW,EACnB,aAAa,CAAC,EAAE,MAAM,EACtB,MAAM,GAAE,MAAM,MAAoB,GACjC,MAAM,CAyBR;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,GAAG,EACT,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,KAAK,CAAC,EAAE,GAAG,EACX,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,GAAG,CAuCL"}

package/src/overrides.property.test.ts

@@ -1,172 +0,0 @@
-import fc from "fast-check";
-import { describe, expect, it } from "vitest";
-import { applyOverrides, determineArrayCount } from "./overrides";
-
-describe("applyOverrides — property-based tests", () => {
-  it("never adds keys not in data or overrides (shape preservation)", () => {
-    // Use simple alphanumeric keys to avoid dot-path splitting edge cases,
-    // since keys containing "." are treated as nested paths by applyOverrides.
-    const safeKey = fc.stringMatching(/^[a-z][a-zA-Z0-9]{0,9}$/);
-
-    fc.assert(
-      fc.property(
-        fc.dictionary(safeKey, fc.jsonValue()),
-        fc.dictionary(safeKey, fc.jsonValue()),
-        (data, overrides) => {
-          const result = applyOverrides(data, overrides) as Record<
-            string,
-            unknown
-          >;
-
-          const allowedKeys = new Set([
-            ...Object.keys(data),
-            ...Object.keys(overrides),
-          ]);
-          for (const key of Object.keys(result)) {
-            expect(allowedKeys.has(key)).toBe(true);
-          }
-        },
-      ),
-      { numRuns: 100 },
-    );
-  });
-
-  it("with empty overrides returns structuredClone of data", () => {
-    fc.assert(
-      fc.property(fc.dictionary(fc.string(), fc.jsonValue()), (data) => {
-        const result = applyOverrides(data, {});
-
-        // Should be deep-equal but not the same reference
-        expect(result).toEqual(data);
-        if (Object.keys(data).length > 0) {
-          expect(result).not.toBe(data);
-        }
-      }),
-      { numRuns: 100 },
-    );
-  });
-
-  it("processTemplate idempotency: processing an already-resolved template is a no-op", () => {
-    // Resolved values contain no {{ }} markers, so re-applying overrides
-    // with the same non-template values should be idempotent
-    fc.assert(
-      fc.property(
-        fc.record({
-          name: fc.string().filter((s) => !s.includes("{{")),
-          age: fc.integer({ min: 0, max: 200 }),
-        }),
-        (data) => {
-          const overrides = { name: "Alice", age: 42 };
-
-          const first = applyOverrides(data, overrides);
-          const second = applyOverrides(
-            first as Record<string, unknown>,
-            overrides,
-          );
-
-          expect(second).toEqual(first);
-        },
-      ),
-      { numRuns: 100 },
-    );
-  });
-
-  it("DANGEROUS_KEYS (__proto__, constructor, prototype) are always rejected in setNestedProperty", () => {
-    const dangerousKeys = ["__proto__", "constructor", "prototype"];
-
-    for (const dangerous of dangerousKeys) {
-      // Flat key — dangerous key is skipped entirely, so no own property is set
-      const flatResult = applyOverrides(
-        { safe: "value" },
-        { [dangerous]: "injected" },
-      ) as Record<string, unknown>;
-      expect(Object.hasOwn(flatResult, dangerous)).toBe(false);
-
-      // Nested path with dangerous key at start — entire path is skipped
-      const nestedStartResult = applyOverrides(
-        { safe: "value" },
-        { [`${dangerous}.nested`]: "injected" },
-      ) as Record<string, unknown>;
-      expect(Object.hasOwn(nestedStartResult, dangerous)).toBe(false);
-
-      // Nested path with dangerous key in middle — traversal aborts
-      const nestedMiddleResult = applyOverrides(
-        { a: { b: "original" } },
-        { [`a.${dangerous}.c`]: "injected" },
-      ) as Record<string, unknown>;
-      const inner = nestedMiddleResult.a as Record<string, unknown>;
-      expect(Object.hasOwn(inner, dangerous)).toBe(false);
-
-      // Nested path with dangerous key at end — final key set is blocked
-      const nestedEndResult = applyOverrides(
-        { a: { b: "original" } },
-        { [`a.${dangerous}`]: "injected" },
-      ) as Record<string, unknown>;
-      const innerEnd = nestedEndResult.a as Record<string, unknown>;
-      expect(Object.hasOwn(innerEnd, dangerous)).toBe(false);
-    }
-  });
-});
-
-describe("applyOverrides — edge cases", () => {
-  it("deeply nested path 'a.b.c.d.e' creates intermediate objects", () => {
-    const data = { existing: "value" };
-    const result = applyOverrides(data, {
-      "a.b.c.d.e": "deep",
-    }) as Record<string, unknown>;
-
-    expect(result.existing).toBe("value");
-    const a = result.a as Record<string, unknown>;
-    const b = a.b as Record<string, unknown>;
-    const c = b.c as Record<string, unknown>;
-    const d = c.d as Record<string, unknown>;
-    expect(d.e).toBe("deep");
-  });
-
-  it("template '{{params.id}}' resolves correctly", () => {
-    const data = { userId: "placeholder" };
-    const result = applyOverrides(
-      data,
-      { userId: "{{params.id}}" },
-      { id: "abc-123" },
-    ) as Record<string, unknown>;
-
-    expect(result.userId).toBe("abc-123");
-  });
-
-  it("mixed template 'Hello {{params.name}}!' resolves to string", () => {
-    const data = { greeting: "placeholder" };
-    const result = applyOverrides(
-      data,
-      { greeting: "Hello {{params.name}}!" },
-      { name: "World" },
-    ) as Record<string, unknown>;
-
-    expect(result.greeting).toBe("Hello World!");
-    expect(typeof result.greeting).toBe("string");
-  });
-
-  it("on non-object data (null) returns data unchanged", () => {
-    expect(applyOverrides(null, { key: "value" })).toBe(null);
-  });
-
-  it("on non-object data (string) returns data unchanged", () => {
-    expect(applyOverrides("hello", { key: "value" })).toBe("hello");
-  });
-
-  it("on non-object data (number) returns data unchanged", () => {
-    expect(applyOverrides(42, { key: "value" })).toBe(42);
-  });
-});
-
-describe("determineArrayCount — edge cases", () => {
-  it("with explicitCount=0 returns 0", () => {
-    expect(determineArrayCount({}, 0)).toBe(0);
-  });
-
-  it("with negative explicitCount returns 0", () => {
-    expect(determineArrayCount({}, -1)).toBe(0);
-    expect(determineArrayCount({}, -100)).toBe(0);
-    expect(determineArrayCount({}, Number.NEGATIVE_INFINITY)).toBe(0);
-  });
-});

package/src/overrides.test.ts

@@ -1,38 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { describe, expect, it } from "vitest";
-import { determineArrayCount } from "./overrides";
-
-describe("determineArrayCount", () => {
-  it("returns explicit count when provided", () => {
-    expect(determineArrayCount({}, 5)).toBe(5);
-  });
-
-  it("returns 0 for negative explicit count", () => {
-    expect(determineArrayCount({}, -3)).toBe(0);
-  });
-
-  it("returns value within minItems/maxItems range", () => {
-    const schema: JSONSchema7 = { minItems: 2, maxItems: 5 };
-    for (let i = 0; i < 50; i++) {
-      const count = determineArrayCount(schema);
-      expect(count).toBeGreaterThanOrEqual(2);
-      expect(count).toBeLessThanOrEqual(5);
-    }
-  });
-
-  it("handles minItems greater than maxItems without producing garbage", () => {
-    const schema: JSONSchema7 = { minItems: 10, maxItems: 3 };
-    const count = determineArrayCount(schema);
-
-    // Should not produce negative numbers or unreasonably large values
-    expect(count).toBeGreaterThanOrEqual(0);
-    expect(Number.isFinite(count)).toBe(true);
-    expect(Number.isNaN(count)).toBe(false);
-  });
-
-  it("handles minItems equal to maxItems", () => {
-    const schema: JSONSchema7 = { minItems: 5, maxItems: 5 };
-    const count = determineArrayCount(schema);
-    expect(count).toBe(5);
-  });
-});

package/src/overrides.ts

@@ -1,179 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { DEFAULT_ARRAY_COUNT } from "./constants.js";
-
-const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/**
- * Determine number of items to generate for array schema
- * Prefers explicit count, then schema minItems/maxItems, with sane defaults
- * @param schema - Array schema with optional minItems/maxItems
- * @param explicitCount - Explicit count override from plugin options
- * @returns Number of array items to generate
- */
-export function determineArrayCount(
-  schema: JSONSchema7,
-  explicitCount?: number,
-  random: () => number = Math.random,
-): number {
-  if (explicitCount !== undefined) {
-    // Handle negative or invalid counts
-    if (explicitCount < 0) {
-      return 0;
-    }
-    return explicitCount;
-  }
-
-  if (schema.minItems !== undefined && schema.maxItems !== undefined) {
-    const min = schema.minItems;
-    const max = Math.max(min, schema.maxItems);
-    return Math.floor(random() * (max - min + 1)) + min;
-  }
-
-  if (schema.minItems !== undefined) {
-    return Math.max(schema.minItems, DEFAULT_ARRAY_COUNT);
-  }
-
-  if (schema.maxItems !== undefined) {
-    return Math.min(schema.maxItems, DEFAULT_ARRAY_COUNT);
-  }
-
-  if (Array.isArray(schema.items)) {
-    return schema.items.length;
-  }
-
-  return DEFAULT_ARRAY_COUNT;
-}
-
-/**
- * Apply overrides to generated data with support for templates
- * Supports nested paths (dot notation), templates with {{params.id}}, and state access
- * @param data - Generated data to apply overrides to
- * @param overrides - Override values (can use templates)
- * @param params - Route parameters for template expansion
- * @param state - Plugin state for template expansion
- * @param query - Query parameters for template expansion
- * @returns Data with overrides applied
- */
-export function applyOverrides(
-  data: unknown,
-  overrides?: Record<string, unknown>,
-  params?: Record<string, string>,
-  state?: Record<string, unknown>,
-  query?: Record<string, string>,
-): unknown {
-  if (!overrides) return data;
-  if (!isRecord(data)) return data;
-
-  const result = structuredClone(data);
-
-  for (const [key, value] of Object.entries(overrides)) {
-    if (DANGEROUS_KEYS.has(key)) continue;
-    // Handle nested paths like "data.id" or "pagination.page"
-    if (key.includes(".")) {
-      setNestedProperty(result, key, value, { params, state, query });
-    } else {
-      // Handle flat keys and nested objects
-      if (isRecord(value)) {
-        // Recursively apply nested overrides
-        if (isRecord(result[key])) {
-          result[key] = applyOverrides(
-            result[key],
-            value,
-            params,
-            state,
-            query,
-          );
-        } else {
-          result[key] = applyOverrides({}, value, params, state, query);
-        }
-      } else if (typeof value === "string" && value.includes("{{")) {
-        // Template processing
-        result[key] = processTemplate(value, { params, state, query });
-      } else {
-        result[key] = value;
-      }
-    }
-  }
-
-  return result;
-}
-
-function setNestedProperty(
-  obj: Record<string, unknown>,
-  path: string,
-  value: unknown,
-  context: TemplateContext,
-): void {
-  const parts = path.split(".");
-  let current: Record<string, unknown> = obj;
-
-  // Navigate to the parent of the target property
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (DANGEROUS_KEYS.has(part)) return;
-    const next = current[part];
-    if (isRecord(next)) {
-      current = next;
-    } else {
-      const nested: Record<string, unknown> = {};
-      current[part] = nested;
-      current = nested;
-    }
-  }
-
-  // Set the final property
-  const finalKey = parts[parts.length - 1];
-  if (DANGEROUS_KEYS.has(finalKey)) return;
-  if (typeof value === "string" && value.includes("{{")) {
-    current[finalKey] = processTemplate(value, context);
-  } else {
-    current[finalKey] = value;
-  }
-}
-
-interface TemplateContext {
-  params?: Record<string, string>;
-  state?: Record<string, unknown>;
-  query?: Record<string, string>;
-}
-
-function resolveTemplatePath(
-  context: TemplateContext,
-  expression: string,
-): unknown {
-  const parts = expression.trim().split(".");
-  let result: unknown = context;
-
-  for (const part of parts) {
-    if (isRecord(result)) {
-      result = result[part];
-    } else {
-      return undefined;
-    }
-  }
-
-  return result;
-}
-
-function processTemplate(template: string, context: TemplateContext): unknown {
-  // Check if the template is just a single template expression
-  const singleTemplateMatch = template.match(/^\{\{\s*([^}]+)\s*\}\}$/);
-  if (singleTemplateMatch) {
-    // For single templates, return the actual value without string conversion
-    const result = resolveTemplatePath(context, singleTemplateMatch[1]);
-    return result !== undefined ? result : template;
-  }
-
-  // For templates mixed with other text, do string replacement
-  return template.replace(
-    /\{\{\s*([^}]+)\s*\}\}/g,
-    (match, expression: string) => {
-      const result = resolveTemplatePath(context, expression);
-      return result !== undefined ? String(result) : match;
-    },
-  );
-}