@schmock/faker 1.9.4 → 1.10.0

package/dist/jsf-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsf-config.d.ts","sourceRoot":"","sources":["../src/jsf-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAM,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,GAAG,MAAM,mBAAmB,CAAC;AAEpC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,CAAC,EAAE,MAAM,SAMhD;AAoBD,wBAAgB,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,CAuBhD"}
+{"version":3,"file":"jsf-config.d.ts","sourceRoot":"","sources":["../src/jsf-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,GAAG,MAAM,mBAAmB,CAAC;AAEpC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,CAAC,EAAE,MAAM,SAMhD;AAoBD,wBAAgB,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,CAuBhD"}

package/dist/jsf-config.js

@@ -1,4 +1,4 @@
-import { en, Faker } from "@faker-js/faker";
+import { base, en, Faker } from "@faker-js/faker";
 import jsf from "json-schema-faker";
 /**
  * Create isolated faker instance to avoid race conditions
@@ -6,7 +6,7 @@ import jsf from "json-schema-faker";
  * @returns Fresh Faker instance with English locale
  */
 export function createFakerInstance(seed) {
-    const faker = new Faker({ locale: [en] });
+    const faker = new Faker({ locale: [en, base] });
     if (seed !== undefined) {
         faker.seed(seed);
     }

package/dist/schema-enhancement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-enhancement.d.ts","sourceRoot":"","sources":["../src/schema-enhancement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAQ/C,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,WAAW,GAClB,WAAW,CAwBb"}
+{"version":3,"file":"schema-enhancement.d.ts","sourceRoot":"","sources":["../src/schema-enhancement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAW/C,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,WAAW,GAClB,WAAW,CAwDb"}

package/dist/schema-enhancement.js

@@ -1,3 +1,4 @@
+import { findBestMapping } from "./field-name-matcher.js";
 import { isJSONSchema7, validateFakerMethod } from "./validation.js";
 export function enhanceSchemaWithSmartMapping(schema) {
     if (!schema || typeof schema !== "object") {
@@ -5,7 +6,7 @@ export function enhanceSchemaWithSmartMapping(schema) {
     }
     const enhanced = { ...schema };
     // Handle object properties
-    if (enhanced.type === "object" && enhanced.properties) {
+    if (enhanced.properties) {
         enhanced.properties = { ...enhanced.properties };
         for (const [fieldName, fieldSchema] of Object.entries(enhanced.properties)) {
             if (isJSONSchema7(fieldSchema)) {
@@ -13,6 +14,28 @@ export function enhanceSchemaWithSmartMapping(schema) {
             }
         }
     }
+    // Recurse into composition keywords
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        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 (enhanced.additionalProperties &&
+        typeof enhanced.additionalProperties === "object" &&
+        !Array.isArray(enhanced.additionalProperties)) {
+        enhanced.additionalProperties = enhanceSchemaWithSmartMapping(enhanced.additionalProperties);
+    }
     return enhanced;
 }
 function enhanceFieldSchema(fieldName, fieldSchema) {
@@ -22,60 +45,26 @@ function enhanceFieldSchema(fieldName, fieldSchema) {
         validateFakerMethod(enhanced.faker);
         return enhanced;
     }
-    // Apply smart field name mapping
-    const lowerFieldName = fieldName.toLowerCase();
-    // Email fields
-    if (lowerFieldName.includes("email")) {
-        enhanced.format = "email";
-        enhanced.faker = "internet.email";
-    }
-    // Name fields
-    else if (lowerFieldName === "firstname" || lowerFieldName === "first_name") {
-        enhanced.faker = "person.firstName";
-    }
-    else if (lowerFieldName === "lastname" || lowerFieldName === "last_name") {
-        enhanced.faker = "person.lastName";
-    }
-    else if (lowerFieldName === "name" || lowerFieldName === "fullname") {
-        enhanced.faker = "person.fullName";
-    }
-    // Phone fields
-    else if (lowerFieldName.includes("phone") || lowerFieldName === "mobile") {
-        enhanced.faker = "phone.number";
+    // 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);
     }
-    // Address fields
-    else if (lowerFieldName === "street" || lowerFieldName === "address") {
-        enhanced.faker = "location.streetAddress";
-    }
-    else if (lowerFieldName === "city") {
-        enhanced.faker = "location.city";
-    }
-    else if (lowerFieldName === "zipcode" || lowerFieldName === "zip") {
-        enhanced.faker = "location.zipCode";
-    }
-    // UUID fields
-    else if (lowerFieldName === "uuid" ||
-        (lowerFieldName === "id" && enhanced.format === "uuid")) {
-        enhanced.faker = "string.uuid";
-    }
-    // Date fields
-    else if (lowerFieldName.includes("createdat") ||
-        lowerFieldName.includes("created_at") ||
-        lowerFieldName.includes("updatedat") ||
-        lowerFieldName.includes("updated_at")) {
-        enhanced.format = "date-time";
-        enhanced.faker = "date.recent";
-    }
-    // Company fields
-    else if (lowerFieldName.includes("company")) {
-        enhanced.faker = "company.name";
-    }
-    else if (lowerFieldName === "position" || lowerFieldName === "jobtitle") {
-        enhanced.faker = "person.jobTitle";
+    // Don't apply field-level faker mapping to composition schemas — the branches define their own types
+    if (hasComposition) {
+        return enhanced;
     }
-    // Price/money fields
-    else if (lowerFieldName === "price" || lowerFieldName === "amount") {
-        enhanced.faker = "commerce.price";
+    // Apply smart field name mapping via the scoring matcher
+    const match = findBestMapping(fieldName, enhanced);
+    if (match) {
+        enhanced.faker = match.mapping.fakerMethod;
+        if (match.mapping.format) {
+            enhanced.format = match.mapping.format;
+        }
+        if (match.mapping.trueProbability !== undefined) {
+            enhanced.schmockTrueProbability = match.mapping.trueProbability;
+        }
     }
     return enhanced;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/faker",
   "description": "Faker-powered automatic data generation for Schmock",
-  "version": "1.9.4",
+  "version": "1.10.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,7 +19,7 @@
   },
   "scripts": {
     "build": "bun build:lib && bun build:types",
-    "build:lib": "bun build --minify --target node --outdir=dist src/index.ts",
+    "build:lib": "bun build --minify --target browser --outdir=dist src/index.ts --external @faker-js/faker --external json-schema-faker --external @schmock/core",
     "build:types": "tsc -p tsconfig.json",
     "test": "vitest",
     "test:watch": "vitest --watch",
@@ -34,7 +34,7 @@
     "json-schema-faker": "^0.5.6"
   },
   "peerDependencies": {
-    "@schmock/core": "^1.9.4"
+    "@schmock/core": "^1.10.0"
   },
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^6.2.0",

package/src/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const MAX_ARRAY_SIZE = 10000;
+export declare const MAX_NESTING_DEPTH = 10;
+export declare const DEFAULT_ARRAY_COUNT = 3;
+export declare const DEEP_NESTING_THRESHOLD = 3;
+export declare const LARGE_ARRAY_THRESHOLD = 100;
+//# sourceMappingURL=constants.d.ts.map

package/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"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

@@ -4,3 +4,6 @@ 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/field-mappings.test.ts

@@ -0,0 +1,340 @@
+import { describe, expect, it } from "vitest";
+import { ALL_FIELD_MAPPINGS, type FieldMapping } from "./field-mappings";
+import { findBestMapping } from "./field-name-matcher";
+import { generateFromSchema } from "./index";
+
+/**
+ * Generate a value for a field by placing it inside an object schema
+ * and calling generateFromSchema. Returns the generated value.
+ */
+function generateField(fieldName: string, schemaType: string): unknown {
+  const schema = {
+    type: "object" as const,
+    properties: {
+      [fieldName]: { type: schemaType as "string" | "number" | "boolean" },
+    },
+  };
+  const result = generateFromSchema({ schema });
+  return result[fieldName];
+}
+
+// ─── Matcher coverage: every mapping's first keyword resolves ───────
+
+describe("Field mapping matcher coverage", () => {
+  for (const mapping of ALL_FIELD_MAPPINGS) {
+    const keyword = mapping.keywords[0];
+    const type = mapping.schemaType ?? "string";
+
+    it(`"${keyword}" → ${mapping.fakerMethod}`, () => {
+      const match = findBestMapping(keyword, {
+        type: type as "string" | "number" | "boolean",
+      });
+      expect(match).toBeDefined();
+      expect(match?.mapping.fakerMethod).toBe(mapping.fakerMethod);
+    });
+  }
+});
+
+// ─── Generation: every mapping produces a value of the right type ──
+
+describe("Field mapping generation", () => {
+  // Group mappings by category for readable output
+  const stringMappings = ALL_FIELD_MAPPINGS.filter(
+    (m) => !m.schemaType || m.schemaType === "string",
+  );
+  const numberMappings = ALL_FIELD_MAPPINGS.filter(
+    (m) => m.schemaType === "number",
+  );
+  const booleanMappings = ALL_FIELD_MAPPINGS.filter(
+    (m) => m.schemaType === "boolean",
+  );
+
+  describe("string fields", () => {
+    for (const mapping of stringMappings) {
+      const keyword = mapping.keywords[0];
+
+      it(`"${keyword}" generates a non-empty string`, () => {
+        const value = generateField(keyword, "string");
+        expect(typeof value).toBe("string");
+        expect((value as string).length).toBeGreaterThan(0);
+      });
+    }
+  });
+
+  describe("number fields", () => {
+    for (const mapping of numberMappings) {
+      const keyword = mapping.keywords[0];
+
+      it(`"${keyword}" generates a number`, () => {
+        const value = generateField(keyword, "number");
+        expect(typeof value).toBe("number");
+        expect(Number.isFinite(value as number)).toBe(true);
+      });
+    }
+  });
+
+  describe("boolean fields", () => {
+    for (const mapping of booleanMappings) {
+      const keyword = mapping.keywords[0];
+
+      it(`"${keyword}" generates a boolean`, () => {
+        const value = generateField(keyword, "boolean");
+        expect(typeof value).toBe("boolean");
+      });
+    }
+  });
+});
+
+// ─── All keyword variants resolve to the same faker method ─────────
+
+describe("All keyword variants match", () => {
+  for (const mapping of ALL_FIELD_MAPPINGS) {
+    if (mapping.keywords.length <= 1) continue;
+
+    describe(`${mapping.fakerMethod}`, () => {
+      for (const keyword of mapping.keywords) {
+        it(`"${keyword}" matches`, () => {
+          const match = findBestMapping(keyword, {
+            type: (mapping.schemaType ?? "string") as
+              | "string"
+              | "number"
+              | "boolean",
+          });
+          expect(match).toBeDefined();
+          expect(match?.mapping.fakerMethod).toBe(mapping.fakerMethod);
+        });
+      }
+    });
+  }
+});
+
+// ─── Category-specific quality checks ──────────────────────────────
+
+describe("Category quality checks", () => {
+  function samples(fieldName: string, type: string, count = 10): unknown[] {
+    return Array.from({ length: count }, () => generateField(fieldName, type));
+  }
+
+  describe("Identity & Auth", () => {
+    it("email contains @ and .", () => {
+      for (const v of samples("email", "string")) {
+        expect(v).toMatch(/@.*\./);
+      }
+    });
+
+    it("username is a non-empty string", () => {
+      for (const v of samples("username", "string")) {
+        expect(typeof v).toBe("string");
+        expect((v as string).length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe("Person", () => {
+    it("firstName starts with uppercase", () => {
+      for (const v of samples("firstName", "string")) {
+        expect(v).toMatch(/^[A-Z]/);
+      }
+    });
+
+    it("lastName starts with uppercase", () => {
+      for (const v of samples("lastName", "string")) {
+        expect(v).toMatch(/^[A-Z]/);
+      }
+    });
+
+    it("name (fullName) contains a space", () => {
+      for (const v of samples("name", "string")) {
+        expect(v).toContain(" ");
+      }
+    });
+  });
+
+  describe("Contact", () => {
+    it("phone contains digits", () => {
+      for (const v of samples("phone", "string")) {
+        expect(v).toMatch(/\d/);
+      }
+    });
+  });
+
+  describe("Address", () => {
+    it("city is a capitalized string", () => {
+      for (const v of samples("city", "string")) {
+        expect(v).toMatch(/^[A-Z]/);
+      }
+    });
+
+    it("zipcode matches US format", () => {
+      for (const v of samples("zipcode", "string")) {
+        expect(v).toMatch(/^\d{5}/);
+      }
+    });
+
+    it("latitude is a valid number", () => {
+      for (const v of samples("latitude", "number")) {
+        expect(typeof v).toBe("number");
+      }
+    });
+
+    it("longitude is a valid number", () => {
+      for (const v of samples("longitude", "number")) {
+        expect(typeof v).toBe("number");
+      }
+    });
+  });
+
+  describe("Internet", () => {
+    it("url starts with http", () => {
+      for (const v of samples("url", "string")) {
+        expect(v).toMatch(/^https?:\/\//);
+      }
+    });
+
+    it("ip_address looks like an IP", () => {
+      for (const v of samples("ip_address", "string")) {
+        expect(v).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+      }
+    });
+  });
+
+  describe("IDs", () => {
+    it("uuid matches UUID pattern", () => {
+      for (const v of samples("uuid", "string")) {
+        expect(v).toMatch(
+          /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+        );
+      }
+    });
+
+    it("userId (suffix rule) generates UUID", () => {
+      for (const v of samples("userId", "string")) {
+        expect(v).toMatch(
+          /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+        );
+      }
+    });
+
+    it("order_id (suffix rule) generates UUID", () => {
+      for (const v of samples("order_id", "string")) {
+        expect(v).toMatch(
+          /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+        );
+      }
+    });
+  });
+
+  describe("Text/Content", () => {
+    it("description is a paragraph (> 20 chars)", () => {
+      for (const v of samples("description", "string")) {
+        expect((v as string).length).toBeGreaterThan(20);
+      }
+    });
+
+    it("title is sentence-length", () => {
+      for (const v of samples("title", "string")) {
+        expect((v as string).length).toBeGreaterThan(5);
+      }
+    });
+  });
+
+  describe("Business", () => {
+    it("company generates a non-empty string", () => {
+      for (const v of samples("company", "string")) {
+        expect((v as string).length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe("Date/Time", () => {
+    it("createdAt generates parseable dates", () => {
+      for (const v of samples("createdAt", "string")) {
+        expect(Date.parse(v as string)).not.toBeNaN();
+      }
+    });
+
+    it("updatedAt generates parseable dates", () => {
+      for (const v of samples("updatedAt", "string")) {
+        expect(Date.parse(v as string)).not.toBeNaN();
+      }
+    });
+
+    it("expires_at generates parseable dates", () => {
+      for (const v of samples("expires_at", "string")) {
+        expect(Date.parse(v as string)).not.toBeNaN();
+      }
+    });
+  });
+
+  describe("Boolean weighting", () => {
+    it("isActive is mostly true (~90%)", () => {
+      const values = samples("isActive", "boolean", 200) as boolean[];
+      const trueCount = values.filter(Boolean).length;
+      // With p=0.9 and n=200, expect 160-200 trues
+      expect(trueCount).toBeGreaterThan(140);
+    });
+
+    it("isDeleted is mostly false (~5% true)", () => {
+      const values = samples("isDeleted", "boolean", 200) as boolean[];
+      const trueCount = values.filter(Boolean).length;
+      // With p=0.05 and n=200, expect 0-30 trues
+      expect(trueCount).toBeLessThan(40);
+    });
+
+    it("isVerified is mostly true (~80%)", () => {
+      const values = samples("isVerified", "boolean", 200) as boolean[];
+      const trueCount = values.filter(Boolean).length;
+      expect(trueCount).toBeGreaterThan(120);
+    });
+  });
+
+  describe("Nullable post-processing", () => {
+    it("schmockNullable fields are null ~5% of the time", () => {
+      const schema = {
+        type: "object" as const,
+        properties: {
+          value: {
+            type: "string" as const,
+            schmockNullable: true,
+          } as any,
+        },
+      };
+
+      let nullCount = 0;
+      const total = 500;
+      for (let i = 0; i < total; i++) {
+        const result = generateFromSchema({ schema });
+        if (result.value === null) nullCount++;
+      }
+
+      // With p=0.05 and n=500, expect 10-45 nulls (generous bounds)
+      expect(nullCount).toBeGreaterThan(5);
+      expect(nullCount).toBeLessThan(60);
+    });
+  });
+
+  describe("Composition recursion", () => {
+    it("enhances fields inside allOf branches", () => {
+      const schema = {
+        type: "object" as const,
+        properties: {
+          data: {
+            allOf: [
+              {
+                type: "object" as const,
+                properties: {
+                  email: { type: "string" as const },
+                  city: { type: "string" as const },
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const result = generateFromSchema({ schema });
+      expect(result.data.email).toMatch(/@/);
+      expect(result.data.city).toMatch(/^[A-Z]/);
+    });
+  });
+});