@schmock/faker 2.2.3 → 2.3.1

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,176 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { DEFAULT_ARRAY_COUNT } from "./constants.js";
-
-const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-
-/**
- * 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);
-  }
-
-  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 (typeof data !== "object" || data === null) return data;
-
-  const result = structuredClone(data) as Record<string, unknown>;
-
-  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 (
-        typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value)
-      ) {
-        const nested = value as Record<string, unknown>;
-        // Recursively apply nested overrides
-        if (result[key] && typeof result[key] === "object") {
-          result[key] = applyOverrides(
-            result[key],
-            nested,
-            params,
-            state,
-            query,
-          );
-        } else {
-          result[key] = applyOverrides({}, nested, 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;
-    if (
-      !(part in current) ||
-      typeof current[part] !== "object" ||
-      current[part] === null
-    ) {
-      current[part] = {};
-    }
-    current = current[part] as Record<string, unknown>;
-  }
-
-  // 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 (result && typeof result === "object") {
-      result = (result as Record<string, unknown>)[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;
-    },
-  );
-}