@schmock/faker 1.12.0 → 2.0.0

package/src/field-mappings.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { ALL_FIELD_MAPPINGS, type FieldMapping } from "./field-mappings";
+import { ALL_FIELD_MAPPINGS } from "./field-mappings";
 import { findBestMapping } from "./field-name-matcher";
 import { generateFromSchema } from "./index";
 
@@ -7,14 +7,17 @@ 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 {
+async function generateField(
+  fieldName: string,
+  schemaType: string,
+): Promise<unknown> {
   const schema = {
     type: "object" as const,
     properties: {
       [fieldName]: { type: schemaType as "string" | "number" | "boolean" },
     },
   };
-  const result = generateFromSchema({ schema });
+  const result = await generateFromSchema({ schema });
   return result[fieldName];
 }
 
@@ -53,8 +56,8 @@ describe("Field mapping generation", () => {
     for (const mapping of stringMappings) {
       const keyword = mapping.keywords[0];
 
-      it(`"${keyword}" generates a non-empty string`, () => {
-        const value = generateField(keyword, "string");
+      it(`"${keyword}" generates a non-empty string`, async () => {
+        const value = await generateField(keyword, "string");
         expect(typeof value).toBe("string");
         expect((value as string).length).toBeGreaterThan(0);
       });
@@ -65,8 +68,8 @@ describe("Field mapping generation", () => {
     for (const mapping of numberMappings) {
       const keyword = mapping.keywords[0];
 
-      it(`"${keyword}" generates a number`, () => {
-        const value = generateField(keyword, "number");
+      it(`"${keyword}" generates a number`, async () => {
+        const value = await generateField(keyword, "number");
         expect(typeof value).toBe("number");
         expect(Number.isFinite(value as number)).toBe(true);
       });
@@ -77,8 +80,8 @@ describe("Field mapping generation", () => {
     for (const mapping of booleanMappings) {
       const keyword = mapping.keywords[0];
 
-      it(`"${keyword}" generates a boolean`, () => {
-        const value = generateField(keyword, "boolean");
+      it(`"${keyword}" generates a boolean`, async () => {
+        const value = await generateField(keyword, "boolean");
         expect(typeof value).toBe("boolean");
       });
     }
@@ -111,19 +114,27 @@ describe("All keyword variants match", () => {
 // ─── 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));
+  async function samples(
+    fieldName: string,
+    type: string,
+    count = 10,
+  ): Promise<unknown[]> {
+    const results: unknown[] = [];
+    for (let i = 0; i < count; i++) {
+      results.push(await generateField(fieldName, type));
+    }
+    return results;
   }
 
   describe("Identity & Auth", () => {
-    it("email contains @ and .", () => {
-      for (const v of samples("email", "string")) {
+    it("email contains @ and .", async () => {
+      for (const v of await samples("email", "string")) {
         expect(v).toMatch(/@.*\./);
       }
     });
 
-    it("username is a non-empty string", () => {
-      for (const v of samples("username", "string")) {
+    it("username is a non-empty string", async () => {
+      for (const v of await samples("username", "string")) {
         expect(typeof v).toBe("string");
         expect((v as string).length).toBeGreaterThan(0);
       }
@@ -131,92 +142,92 @@ describe("Category quality checks", () => {
   });
 
   describe("Person", () => {
-    it("firstName starts with uppercase", () => {
-      for (const v of samples("firstName", "string")) {
+    it("firstName starts with uppercase", async () => {
+      for (const v of await samples("firstName", "string")) {
         expect(v).toMatch(/^[A-Z]/);
       }
     });
 
-    it("lastName starts with uppercase", () => {
-      for (const v of samples("lastName", "string")) {
+    it("lastName starts with uppercase", async () => {
+      for (const v of await samples("lastName", "string")) {
         expect(v).toMatch(/^[A-Z]/);
       }
     });
 
-    it("name (fullName) contains a space", () => {
-      for (const v of samples("name", "string")) {
+    it("name (fullName) contains a space", async () => {
+      for (const v of await samples("name", "string")) {
         expect(v).toContain(" ");
       }
     });
   });
 
   describe("Contact", () => {
-    it("phone contains digits", () => {
-      for (const v of samples("phone", "string")) {
+    it("phone contains digits", async () => {
+      for (const v of await samples("phone", "string")) {
         expect(v).toMatch(/\d/);
       }
     });
   });
 
   describe("Address", () => {
-    it("city is a capitalized string", () => {
-      for (const v of samples("city", "string")) {
+    it("city is a capitalized string", async () => {
+      for (const v of await samples("city", "string")) {
         expect(v).toMatch(/^[A-Z]/);
       }
     });
 
-    it("zipcode matches US format", () => {
-      for (const v of samples("zipcode", "string")) {
+    it("zipcode matches US format", async () => {
+      for (const v of await samples("zipcode", "string")) {
         expect(v).toMatch(/^\d{5}/);
       }
     });
 
-    it("latitude is a valid number", () => {
-      for (const v of samples("latitude", "number")) {
+    it("latitude is a valid number", async () => {
+      for (const v of await samples("latitude", "number")) {
         expect(typeof v).toBe("number");
       }
     });
 
-    it("longitude is a valid number", () => {
-      for (const v of samples("longitude", "number")) {
+    it("longitude is a valid number", async () => {
+      for (const v of await samples("longitude", "number")) {
         expect(typeof v).toBe("number");
       }
     });
   });
 
   describe("Internet", () => {
-    it("url starts with http", () => {
-      for (const v of samples("url", "string")) {
+    it("url starts with http", async () => {
+      for (const v of await samples("url", "string")) {
         expect(v).toMatch(/^https?:\/\//);
       }
     });
 
-    it("ip_address looks like an IP", () => {
-      for (const v of samples("ip_address", "string")) {
+    it("ip_address looks like an IP", async () => {
+      for (const v of await 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")) {
+    it("uuid matches UUID pattern", async () => {
+      for (const v of await 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")) {
+    it("userId (suffix rule) generates UUID", async () => {
+      for (const v of await 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")) {
+    it("order_id (suffix rule) generates UUID", async () => {
+      for (const v of await 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,
         );
@@ -225,71 +236,71 @@ describe("Category quality checks", () => {
   });
 
   describe("Text/Content", () => {
-    it("description is a paragraph (> 20 chars)", () => {
-      for (const v of samples("description", "string")) {
+    it("description is a paragraph (> 20 chars)", async () => {
+      for (const v of await samples("description", "string")) {
         expect((v as string).length).toBeGreaterThan(20);
       }
     });
 
-    it("title is sentence-length", () => {
-      for (const v of samples("title", "string")) {
+    it("title is sentence-length", async () => {
+      for (const v of await 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")) {
+    it("company generates a non-empty string", async () => {
+      for (const v of await 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")) {
+    it("createdAt generates parseable dates", async () => {
+      for (const v of await samples("createdAt", "string")) {
         expect(Date.parse(v as string)).not.toBeNaN();
       }
     });
 
-    it("updatedAt generates parseable dates", () => {
-      for (const v of samples("updatedAt", "string")) {
+    it("updatedAt generates parseable dates", async () => {
+      for (const v of await 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")) {
+    it("expires_at generates parseable dates", async () => {
+      for (const v of await 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[];
+    it("isActive is mostly true (~90%)", async () => {
+      const values = (await 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[];
+    it("isDeleted is mostly false (~5% true)", async () => {
+      const values = (await 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[];
+    it("isVerified is mostly true (~80%)", async () => {
+      const values = (await 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", () => {
+    it("schmockNullable fields are null ~5% of the time", async () => {
       const schema = {
         type: "object" as const,
         properties: {
@@ -303,7 +314,7 @@ describe("Category quality checks", () => {
       let nullCount = 0;
       const total = 500;
       for (let i = 0; i < total; i++) {
-        const result = generateFromSchema({ schema });
+        const result = await generateFromSchema({ schema });
         if (result.value === null) nullCount++;
       }
 
@@ -314,7 +325,7 @@ describe("Category quality checks", () => {
   });
 
   describe("Composition recursion", () => {
-    it("enhances fields inside allOf branches", () => {
+    it("enhances fields inside allOf branches", async () => {
       const schema = {
         type: "object" as const,
         properties: {
@@ -332,7 +343,7 @@ describe("Category quality checks", () => {
         },
       };
 
-      const result = generateFromSchema({ schema });
+      const result = await generateFromSchema({ schema });
       expect(result.data.email).toMatch(/@/);
       expect(result.data.city).toMatch(/^[A-Z]/);
     });

package/src/field-name-matcher.ts

@@ -109,8 +109,13 @@ export function findBestMapping(
     };
   }
 
-  // Skip if schema already has pattern, enum, or faker constraint
-  if (schemaAny.pattern || schemaAny.enum || schemaAny.faker) {
+  // Skip if schema already has pattern, enum, faker, or $ref constraint
+  if (
+    schemaAny.pattern ||
+    schemaAny.enum ||
+    schemaAny.faker ||
+    schemaAny.$ref
+  ) {
     return undefined;
   }
 
@@ -134,6 +139,11 @@ export function findBestMapping(
       continue;
     }
 
+    // Skip faker mappings for object/array schemas — they generate primitive values
+    if (schemaType === "object" || schemaType === "array") {
+      continue;
+    }
+
     // Check schema type constraint
     if (mapping.schemaType && schemaType && mapping.schemaType !== schemaType) {
       const isNumeric =