@schmock/faker 2.3.0 → 2.4.0

package/src/audit-faker-args.test.ts

@@ -1,97 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { describe, expect, it } from "vitest";
-import { generateFromSchema } from "./index";
-
-/**
- * Regression tests for fakerArgs threading in field-mappings.
- *
- * Bug (4.5): enhanceFieldSchema read only fakerMethod/format/trueProbability
- * from a matched mapping — it never forwarded fakerArgs — so numeric bounds
- * defined in field-mappings.ts (e.g. age → {min:18, max:80}) were silently
- * ignored and faker fell back to its own defaults (potentially a very wide
- * range).
- *
- * Fix: when a matched mapping has fakerArgs, set
- *   enhanced.faker = { [fakerMethod]: fakerArgs }
- * (the json-schema-faker object-form extension), so JSF passes the options
- * object to faker's method.  If the object form does not honour the bounds
- * in the current JSF/faker setup, fall back to also stamping minimum/maximum
- * onto the schema so numeric constraints are applied at the schema level.
- */
-
-describe("fakerArgs on field mappings are honoured (fix 4.5)", () => {
-  it("generates age values always within [18, 80] across 50 samples", async () => {
-    const schema: JSONSchema7 = {
-      type: "object",
-      properties: {
-        age: { type: "integer" },
-      },
-      required: ["age"],
-    };
-
-    const outOfRange: number[] = [];
-
-    for (let i = 0; i < 50; i++) {
-      const result = (await generateFromSchema({ schema })) as Record<
-        string,
-        unknown
-      >;
-      const age = result.age as number;
-      if (age < 18 || age > 80) {
-        outOfRange.push(age);
-      }
-    }
-
-    expect(outOfRange).toEqual([]);
-  });
-
-  it("generates rating values always within [1, 5] across 50 samples", async () => {
-    const schema: JSONSchema7 = {
-      type: "object",
-      properties: {
-        rating: { type: "integer" },
-      },
-      required: ["rating"],
-    };
-
-    const outOfRange: number[] = [];
-
-    for (let i = 0; i < 50; i++) {
-      const result = (await generateFromSchema({ schema })) as Record<
-        string,
-        unknown
-      >;
-      const rating = result.rating as number;
-      if (rating < 1 || rating > 5) {
-        outOfRange.push(rating);
-      }
-    }
-
-    expect(outOfRange).toEqual([]);
-  });
-
-  it("generates count values always within [1, 100] across 50 samples", async () => {
-    const schema: JSONSchema7 = {
-      type: "object",
-      properties: {
-        count: { type: "integer" },
-      },
-      required: ["count"],
-    };
-
-    const outOfRange: number[] = [];
-
-    for (let i = 0; i < 50; i++) {
-      const result = (await generateFromSchema({ schema })) as Record<
-        string,
-        unknown
-      >;
-      const count = result.count as number;
-      if (count < 1 || count > 100) {
-        outOfRange.push(count);
-      }
-    }
-
-    expect(outOfRange).toEqual([]);
-  });
-});

package/src/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["constants.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,cAAc,QAAQ,CAAC;AACpC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,qBAAqB,MAAM,CAAC"}

package/src/constants.ts

@@ -1,9 +0,0 @@
-// Resource limits for safety
-export const MAX_ARRAY_SIZE = 10000;
-export const MAX_NESTING_DEPTH = 10; // Reasonable limit for schema nesting
-export const DEFAULT_ARRAY_COUNT = 3; // Default items to generate when not specified
-export const DEEP_NESTING_THRESHOLD = 3; // Depth at which to check for memory risks
-export const LARGE_ARRAY_THRESHOLD = 100; // Array size considered "large"
-
-// Data quality tuning
-export const NULLABLE_NULL_PROBABILITY = 0.05; // 5% chance nullable fields are null

package/src/data-quality.test.ts

@@ -1,415 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { generate, schemas, stats, validators } from "./test-utils";
-
-describe("Data Quality and Statistical Properties", () => {
-  describe("Randomness and Distribution", () => {
-    it("generates diverse values for string fields", async () => {
-      const schema = schemas.simple.object({
-        text: schemas.simple.string(),
-      });
-
-      const samples = await generate.samples<any>(schema, 100);
-      const values = samples.map((s) => s.text);
-
-      // Should have high uniqueness
-      const uniqueness = validators.uniquenessRatio(values);
-      expect(uniqueness).toBeGreaterThan(0.9); // Most values should be unique
-
-      // Should have good entropy
-      const entropy = stats.entropy(values);
-      expect(entropy).toBeGreaterThan(4); // High randomness
-    });
-
-    it("generates well-distributed numeric values", async () => {
-      const schema = schemas.simple.object({
-        value: {
-          type: "number",
-          minimum: 0,
-          maximum: 100,
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 200);
-      const values = samples.map((s) => s.value);
-
-      // Check distribution
-      const min = Math.min(...values);
-      const max = Math.max(...values);
-      const mean = values.reduce((a, b) => a + b, 0) / values.length;
-
-      expect(min).toBeGreaterThanOrEqual(0);
-      expect(max).toBeLessThanOrEqual(100);
-      expect(mean).toBeGreaterThan(30); // Should be somewhat centered
-      expect(mean).toBeLessThan(70);
-
-      // Check for good spread
-      const variance =
-        values.reduce((sum, val) => sum + (val - mean) ** 2, 0) / values.length;
-      expect(variance).toBeGreaterThan(100); // Good spread of values
-    });
-
-    it("generates diverse enum selections", async () => {
-      const schema = schemas.simple.object({
-        status: {
-          type: "string",
-          enum: ["active", "pending", "inactive", "archived"],
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 100);
-      const distribution = stats.distribution(samples.map((s) => s.status));
-
-      // All enum values should be used
-      expect(distribution.size).toBe(4);
-
-      // Should be relatively balanced (not always picking the same value)
-      const counts = Array.from(distribution.values());
-      const minCount = Math.min(...counts);
-      const maxCount = Math.max(...counts);
-
-      // No value should dominate too much
-      expect(maxCount / minCount).toBeLessThan(5);
-    });
-
-    it("generates diverse boolean values", async () => {
-      const schema = schemas.simple.object({
-        flag: { type: "boolean" },
-      });
-
-      const samples = await generate.samples<any>(schema, 100);
-      const trueCount = samples.filter((s) => s.flag === true).length;
-      const falseCount = samples.filter((s) => s.flag === false).length;
-
-      // Should be roughly balanced
-      expect(trueCount).toBeGreaterThan(20);
-      expect(falseCount).toBeGreaterThan(20);
-      expect(Math.abs(trueCount - falseCount)).toBeLessThan(60);
-    });
-  });
-
-  describe("Format Compliance", () => {
-    it("generates valid email formats consistently", async () => {
-      const schema = schemas.simple.object({
-        email: { type: "string", format: "email" },
-      });
-
-      const samples = await generate.samples<any>(schema, 50);
-
-      samples.forEach((sample) => {
-        // RFC 5322 simplified regex
-        const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-        expect(sample.email).toMatch(emailRegex);
-
-        // Should have reasonable length
-        expect(sample.email.length).toBeGreaterThan(5);
-        expect(sample.email.length).toBeLessThan(100);
-
-        // Should have exactly one @
-        expect(sample.email.split("@").length).toBe(2);
-      });
-
-      // Should generate diverse emails
-      const uniqueness = validators.uniquenessRatio(
-        samples.map((s) => s.email),
-      );
-      expect(uniqueness).toBeGreaterThan(0.8);
-    });
-
-    it("generates valid UUIDs consistently", async () => {
-      const schema = schemas.simple.object({
-        id: { type: "string", format: "uuid" },
-      });
-
-      const samples = await generate.samples<any>(schema, 50);
-      const uuidRegex =
-        /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-
-      samples.forEach((sample) => {
-        expect(sample.id).toMatch(uuidRegex);
-        expect(sample.id.length).toBe(36);
-      });
-
-      // All UUIDs should be unique
-      const uniqueness = validators.uniquenessRatio(samples.map((s) => s.id));
-      expect(uniqueness).toBe(1);
-    });
-
-    it("generates valid dates with reasonable ranges", async () => {
-      const schema = schemas.simple.object({
-        created: { type: "string", format: "date-time" },
-      });
-
-      const samples = await generate.samples<any>(schema, 50);
-
-      samples.forEach((sample) => {
-        const date = new Date(sample.created);
-
-        // Should be valid date
-        expect(date.getTime()).not.toBeNaN();
-
-        // Should be properly formatted
-        expect(sample.created).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
-
-        // Should be a reasonable date (within reasonable historical range)
-        expect(date.getFullYear()).toBeGreaterThan(1800);
-        expect(date.getFullYear()).toBeLessThan(2200);
-      });
-    });
-
-    it("generates valid URLs when specified", async () => {
-      const schema = schemas.simple.object({
-        website: { type: "string", format: "uri" },
-      });
-
-      const samples = await generate.samples<any>(schema, 20);
-
-      samples.forEach((sample) => {
-        if (sample.website) {
-          // Should look like a URL
-          expect(sample.website).toMatch(/^https?:\/\//);
-          // Should have domain
-          expect(sample.website).toContain(".");
-        }
-      });
-    });
-  });
-
-  describe("Constraint Satisfaction", () => {
-    it("respects string length constraints consistently", async () => {
-      const schema = schemas.simple.object({
-        xyzField: {
-          type: "string",
-          minLength: 5,
-          maxLength: 15,
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 100);
-
-      samples.forEach((sample) => {
-        expect(sample.xyzField.length).toBeGreaterThanOrEqual(5);
-        expect(sample.xyzField.length).toBeLessThanOrEqual(15);
-      });
-
-      // Should use various lengths, not always min or max
-      const lengths = samples.map((s) => s.xyzField.length);
-      const uniqueLengths = new Set(lengths);
-      expect(uniqueLengths.size).toBeGreaterThan(3);
-    });
-
-    it("respects numeric ranges with good distribution", async () => {
-      const schema = schemas.simple.object({
-        age: {
-          type: "integer",
-          minimum: 18,
-          maximum: 65,
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 100);
-      const ages = samples.map((s) => s.age);
-
-      // All should be in range
-      ages.forEach((age) => {
-        expect(age).toBeGreaterThanOrEqual(18);
-        expect(age).toBeLessThanOrEqual(65);
-        expect(Number.isInteger(age)).toBe(true);
-      });
-
-      // Should have good spread
-      const uniqueAges = new Set(ages);
-      expect(uniqueAges.size).toBeGreaterThan(20);
-
-      // Should hit near boundaries sometimes
-      expect(ages.some((age) => age <= 25)).toBe(true);
-      expect(ages.some((age) => age >= 58)).toBe(true);
-    });
-
-    it("maintains array uniqueness when specified", async () => {
-      const schema = schemas.simple.object({
-        tags: {
-          type: "array",
-          items: { type: "string", pattern: "^tag-\\d{3}$" },
-          minItems: 5,
-          maxItems: 5,
-          uniqueItems: true,
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 20);
-
-      samples.forEach((sample) => {
-        expect(sample.tags).toHaveLength(5);
-
-        // All items should be unique
-        const uniqueTags = new Set(sample.tags);
-        expect(uniqueTags.size).toBe(5);
-
-        // All should match pattern
-        sample.tags.forEach((tag) => {
-          expect(tag).toMatch(/^tag-\d{3}$/);
-        });
-      });
-    });
-  });
-
-  describe("Realistic Data Generation", () => {
-    it("generates realistic person names", async () => {
-      const schema = schemas.simple.object({
-        firstName: { type: "string" },
-        lastName: { type: "string" },
-        fullName: { type: "string" },
-      });
-
-      const samples = await generate.samples<any>(schema, 50);
-
-      samples.forEach((sample) => {
-        // First names should be properly capitalized and reasonable length
-        expect(sample.firstName).toMatch(/^[A-Z]/); // Starts with capital
-        expect(sample.firstName.length).toBeGreaterThanOrEqual(2);
-        expect(sample.firstName.length).toBeLessThan(15);
-        expect(sample.firstName).not.toContain(" "); // No spaces in first names
-
-        // Last names should be single words, may have special chars
-        expect(sample.lastName).toMatch(/^[A-Z]/);
-        expect(sample.lastName.length).toBeGreaterThanOrEqual(2);
-        expect(sample.lastName.length).toBeLessThanOrEqual(30); // Generous for longer generated names
-
-        // Full names should have multiple parts
-        const nameParts = sample.fullName.split(" ");
-        expect(nameParts.length).toBeGreaterThanOrEqual(2);
-        expect(nameParts.length).toBeLessThanOrEqual(4);
-      });
-
-      // Should generate diverse names
-      const firstNames = samples.map((s) => s.firstName);
-      expect(validators.uniquenessRatio(firstNames)).toBeGreaterThan(0.5); // Slightly more forgiving
-    });
-
-    it("generates realistic addresses", async () => {
-      const schema = schemas.simple.object({
-        street: { type: "string" },
-        city: { type: "string" },
-        zipcode: { type: "string" },
-      });
-
-      const samples = await generate.samples<any>(schema, 30);
-
-      samples.forEach((sample) => {
-        // Street addresses should have numbers and street names
-        expect(sample.street).toMatch(/\d/);
-        expect(sample.street).toMatch(/[A-Z]/);
-        expect(sample.street.length).toBeGreaterThanOrEqual(5); // Allow short addresses like "9 Ave."
-
-        // Cities should be properly formatted
-        expect(sample.city).toMatch(/^[A-Z]/);
-        expect(sample.city).not.toMatch(/\d/); // No numbers in city names
-
-        // Zip codes should be valid US format
-        expect(sample.zipcode).toMatch(/^\d{5}(-\d{4})?$/);
-      });
-    });
-
-    it("generates consistent related data", async () => {
-      const schema = schemas.simple.object({
-        user: {
-          type: "object",
-          properties: {
-            email: schemas.simple.string(),
-            username: schemas.simple.string(),
-            createdAt: schemas.simple.string(),
-            updatedAt: schemas.simple.string(),
-          },
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 20);
-
-      samples.forEach((sample) => {
-        // All fields should be present and be strings
-        expect(typeof sample.user.email).toBe("string");
-        expect(typeof sample.user.username).toBe("string");
-        expect(typeof sample.user.createdAt).toBe("string");
-        expect(typeof sample.user.updatedAt).toBe("string");
-
-        // Should generate reasonable content
-        expect(sample.user.email.length).toBeGreaterThan(0);
-        expect(sample.user.username.length).toBeGreaterThan(0);
-      });
-    });
-  });
-
-  describe("Edge Cases and Boundaries", () => {
-    it("handles empty strings when allowed", async () => {
-      const schema = schemas.simple.object({
-        optional: {
-          type: "string",
-          minLength: 0,
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 50);
-
-      // All should be valid strings respecting minLength constraint
-      samples.forEach((sample) => {
-        expect(typeof sample.optional).toBe("string");
-        expect(sample.optional.length).toBeGreaterThanOrEqual(0);
-      });
-
-      // Should generate various lengths
-      const lengths = samples.map((s) => s.optional.length);
-      const uniqueLengths = new Set(lengths);
-      expect(uniqueLengths.size).toBeGreaterThan(1);
-    });
-
-    it("handles zero and negative numbers appropriately", async () => {
-      const schema = schemas.simple.object({
-        balance: {
-          type: "number",
-          minimum: -1000,
-          maximum: 1000,
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 100);
-      const balances = samples.map((s) => s.balance);
-
-      // Should include negative and positive values
-      const hasNegative = balances.some((b) => b < 0);
-      const hasPositive = balances.some((b) => b > 0);
-
-      expect(hasNegative || hasPositive).toBe(true); // At least one type
-
-      // All should be within range
-      balances.forEach((b) => {
-        expect(b).toBeGreaterThanOrEqual(-1000);
-        expect(b).toBeLessThanOrEqual(1000);
-      });
-    });
-
-    it("generates boundary values occasionally", async () => {
-      const schema = schemas.simple.object({
-        score: {
-          type: "integer",
-          minimum: 0,
-          maximum: 100,
-        },
-      });
-
-      const samples = await generate.samples<any>(schema, 200);
-      const scores = samples.map((s) => s.score);
-
-      // Should respect the boundaries and generate diverse values
-      expect(scores.every((s) => s >= 0 && s <= 100)).toBe(true);
-
-      // Should generate values near boundaries sometimes (within 5 of min/max)
-      const nearMin = scores.filter((s) => s <= 5).length;
-      const nearMax = scores.filter((s) => s >= 95).length;
-      expect(nearMin + nearMax).toBeGreaterThan(0); // At least some near boundaries
-
-      // Should have good distribution across the range
-      const uniqueValues = new Set(scores);
-      expect(uniqueValues.size).toBeGreaterThan(20); // Good variety
-    });
-  });
-});