@schmock/faker 2.2.3 → 2.3.1

package/src/field-name-matcher.test.ts

@@ -1,292 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  findBestMapping,
-  scoreMatch,
-  tokenizeFieldName,
-} from "./field-name-matcher";
-
-describe("tokenizeFieldName", () => {
-  it("splits camelCase", () => {
-    expect(tokenizeFieldName("userFirstName")).toEqual([
-      "user",
-      "first",
-      "name",
-    ]);
-  });
-
-  it("splits snake_case", () => {
-    expect(tokenizeFieldName("created_at")).toEqual(["created", "at"]);
-  });
-
-  it("splits kebab-case", () => {
-    expect(tokenizeFieldName("user-name")).toEqual(["user", "name"]);
-  });
-
-  it("handles consecutive uppercase (HTMLParser)", () => {
-    expect(tokenizeFieldName("HTMLParser")).toEqual(["html", "parser"]);
-  });
-
-  it("handles is_active", () => {
-    expect(tokenizeFieldName("is_active")).toEqual(["is", "active"]);
-  });
-
-  it("handles single word", () => {
-    expect(tokenizeFieldName("email")).toEqual(["email"]);
-  });
-
-  it("handles uppercase single word", () => {
-    expect(tokenizeFieldName("UUID")).toEqual(["uuid"]);
-  });
-
-  it("handles mixed formats", () => {
-    expect(tokenizeFieldName("userEmail_address")).toEqual([
-      "user",
-      "email",
-      "address",
-    ]);
-  });
-});
-
-describe("scoreMatch", () => {
-  it("returns 1.0 for exact match", () => {
-    expect(scoreMatch(["email"], ["email"])).toBe(1.0);
-  });
-
-  it("returns 1.0 for exact multi-token match", () => {
-    expect(scoreMatch(["first", "name"], ["first_name"])).toBe(1.0);
-  });
-
-  it("returns 0.7 for substring match with low keyword coverage", () => {
-    // "email" is 1/3 tokens → low coverage (0.65) but substring match (0.7) wins
-    expect(scoreMatch(["user", "email", "address"], ["email"])).toBe(0.7);
-  });
-
-  it("returns 0.9 when all keyword tokens found with high coverage", () => {
-    // ["created", "at"] are both found in ["user", "created", "at"] → 2/3 coverage > 50%
-    expect(scoreMatch(["user", "created", "at"], ["created_at"])).toBe(0.9);
-  });
-
-  it("returns 0.8 when field ends with keyword", () => {
-    // ["name"] is at the end of ["display", "name"] — ends-with score = 0.8
-    // coverage is 1/2 = 0.5, not > 0.5, so "all found" gives 0.65
-    // ends-with wins at 0.8
-    expect(scoreMatch(["display", "name"], ["name"])).toBe(0.8);
-  });
-
-  it("returns 0.7 for substring match", () => {
-    expect(scoreMatch(["myemailfield"], ["email"])).toBe(0.7);
-  });
-
-  it("returns 0 for no match", () => {
-    expect(scoreMatch(["foo", "bar"], ["email"])).toBe(0);
-  });
-});
-
-describe("findBestMapping", () => {
-  it("maps email field", () => {
-    const result = findBestMapping("email", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("internet.email");
-  });
-
-  it("maps userEmail field", () => {
-    const result = findBestMapping("userEmail", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("internet.email");
-  });
-
-  it("maps firstName field", () => {
-    const result = findBestMapping("firstName", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("person.firstName");
-  });
-
-  it("maps first_name field", () => {
-    const result = findBestMapping("first_name", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("person.firstName");
-  });
-
-  it("maps createdAt to date.recent", () => {
-    const result = findBestMapping("createdAt", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("date.recent");
-    expect(result?.mapping.format).toBe("date-time");
-  });
-
-  it("maps city field", () => {
-    const result = findBestMapping("city", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("location.city");
-  });
-
-  it("maps url field", () => {
-    const result = findBestMapping("url", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("internet.url");
-  });
-
-  it("maps avatar field", () => {
-    const result = findBestMapping("avatar", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("image.avatar");
-  });
-
-  it("maps latitude field to number", () => {
-    const result = findBestMapping("latitude", { type: "number" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("location.latitude");
-  });
-
-  it("maps description field", () => {
-    const result = findBestMapping("description", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("lorem.paragraph");
-  });
-
-  it("maps title field", () => {
-    const result = findBestMapping("title", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("lorem.sentence");
-  });
-
-  it("maps country field", () => {
-    const result = findBestMapping("country", { type: "string" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("location.country");
-  });
-
-  it("maps isActive boolean with probability", () => {
-    const result = findBestMapping("isActive", { type: "boolean" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.trueProbability).toBe(0.9);
-  });
-
-  it("maps is_deleted boolean with low probability", () => {
-    const result = findBestMapping("is_deleted", { type: "boolean" });
-    expect(result).toBeDefined();
-    expect(result?.mapping.trueProbability).toBe(0.05);
-  });
-
-  describe("ID suffix detection", () => {
-    it("maps userId to UUID", () => {
-      const result = findBestMapping("userId", { type: "string" });
-      expect(result).toBeDefined();
-      expect(result?.mapping.fakerMethod).toBe("string.uuid");
-    });
-
-    it("maps order_id to UUID", () => {
-      const result = findBestMapping("order_id", { type: "string" });
-      expect(result).toBeDefined();
-      expect(result?.mapping.fakerMethod).toBe("string.uuid");
-    });
-
-    it("maps parent_id to UUID", () => {
-      const result = findBestMapping("parent_id", { type: "string" });
-      expect(result).toBeDefined();
-      expect(result?.mapping.fakerMethod).toBe("string.uuid");
-    });
-
-    it("does not map single id without format:uuid", () => {
-      const result = findBestMapping("id", { type: "string" });
-      // 'id' alone shouldn't trigger UUID — it's a single token so suffix rule doesn't apply
-      // But it could still match something else. Let's just check it doesn't falsely match
-      if (result) {
-        // Could match 'id' in some mapping, that's OK
-        expect(result.score).toBeGreaterThan(0);
-      }
-    });
-
-    it("does not map Id suffix on number fields", () => {
-      const result = findBestMapping("userId", { type: "number" });
-      // Number type should not get UUID mapping
-      if (result) {
-        expect(result.mapping.fakerMethod).not.toBe("string.uuid");
-      }
-    });
-  });
-
-  describe("skip conditions", () => {
-    it("skips when schema has pattern", () => {
-      const result = findBestMapping("email", {
-        type: "string",
-        pattern: "^[a-z]+$",
-      });
-      expect(result).toBeUndefined();
-    });
-
-    it("skips when schema has enum", () => {
-      const result = findBestMapping("email", {
-        type: "string",
-        enum: ["a@b.com", "c@d.com"],
-      });
-      expect(result).toBeUndefined();
-    });
-
-    it("skips when schema already has faker", () => {
-      const schema = { type: "string" as const, faker: "lorem.word" } as any;
-      const result = findBestMapping("email", schema);
-      expect(result).toBeUndefined();
-    });
-
-    // Regression: name-based mappings (e.g. lorem.word for 'label') don't
-    // honor JSON Schema length constraints, so they'd produce out-of-range
-    // strings ~20% of the time when the schema asked for a specific length.
-    // Skip the mapping and let json-schema-faker generate a length-respecting
-    // string instead. Mirrors the numeric constraint skip in the loop below.
-    it("skips string mapping when schema has minLength", () => {
-      const result = findBestMapping("label", {
-        type: "string",
-        minLength: 3,
-      });
-      expect(result).toBeUndefined();
-    });
-
-    it("skips string mapping when schema has maxLength", () => {
-      const result = findBestMapping("label", {
-        type: "string",
-        maxLength: 20,
-      });
-      expect(result).toBeUndefined();
-    });
-
-    it("skips string mapping when both length constraints are set", () => {
-      const result = findBestMapping("label", {
-        type: "string",
-        minLength: 3,
-        maxLength: 20,
-      });
-      expect(result).toBeUndefined();
-    });
-
-    it("does not skip non-string types when minLength happens to be set", () => {
-      // minLength is a string-only keyword; on a non-string schema it's
-      // meaningless. The number mapping for 'age' should still apply.
-      const result = findBestMapping("age", {
-        type: "number",
-        minLength: 3, // nonsensical on a number, but shouldn't block the mapping
-      } as any);
-      expect(result).toBeDefined();
-    });
-  });
-
-  it("does not map unrecognized fields", () => {
-    const result = findBestMapping("randomFieldXYZ123", { type: "string" });
-    expect(result).toBeUndefined();
-  });
-
-  it("respects type constraints", () => {
-    // latitude mapping requires number type
-    const result = findBestMapping("latitude", { type: "string" });
-    expect(result).toBeUndefined();
-  });
-
-  it("maps format:uuid even without name match", () => {
-    const result = findBestMapping("someField", {
-      type: "string",
-      format: "uuid",
-    });
-    expect(result).toBeDefined();
-    expect(result?.mapping.fakerMethod).toBe("string.uuid");
-  });
-});

package/src/field-name-matcher.ts

@@ -1,188 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import type { FieldMapping } from "./field-mappings.js";
-import { ALL_FIELD_MAPPINGS } from "./field-mappings.js";
-
-/**
- * Split a field name (camelCase, snake_case, kebab-case) into lowercase tokens.
- * "userFirstName" → ["user", "first", "name"]
- * "created_at"    → ["created", "at"]
- * "HTMLParser"    → ["html", "parser"]
- * "is_active"     → ["is", "active"]
- */
-export function tokenizeFieldName(name: string): string[] {
-  // Split on _ and -
-  const parts = name.split(/[_-]/);
-  const tokens: string[] = [];
-
-  for (const part of parts) {
-    if (!part) continue;
-    // Split camelCase and consecutive uppercase (e.g., HTMLParser → HTML, Parser)
-    const camelTokens = part
-      .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
-      .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-      .split("_");
-
-    for (const t of camelTokens) {
-      if (t) tokens.push(t.toLowerCase());
-    }
-  }
-
-  return tokens;
-}
-
-/**
- * Score how well a set of keyword tokens matches field name tokens.
- * Returns 0-1:
- *   1.0 — exact full match (joined tokens equal joined keywords)
- *   0.9 — all keyword tokens found in field tokens with high coverage (>50%)
- *   0.8 — field ends with keyword tokens
- *   0.7 — substring match (keyword appears in joined field name)
- *   0.65 — all keyword tokens found but low coverage (<=50%)
- */
-export function scoreMatch(fieldTokens: string[], keywords: string[]): number {
-  const fieldJoined = fieldTokens.join("");
-
-  let bestScore = 0;
-
-  // Try each keyword variant, keep the highest score
-  for (const keyword of keywords) {
-    const kwTokens = tokenizeFieldName(keyword);
-    const kwJoined = kwTokens.join("");
-
-    // Exact match: joined tokens are identical
-    if (fieldJoined === kwJoined) return 1.0;
-
-    // All keyword tokens present in field tokens with high coverage
-    if (
-      kwTokens.length > 0 &&
-      kwTokens.every((kt) => fieldTokens.includes(kt))
-    ) {
-      const coverage = kwTokens.length / fieldTokens.length;
-      const score = coverage > 0.5 ? 0.9 : 0.65;
-      bestScore = Math.max(bestScore, score);
-    }
-
-    // Field ends with keyword tokens
-    if (kwTokens.length > 0 && kwTokens.length <= fieldTokens.length) {
-      const tail = fieldTokens.slice(-kwTokens.length);
-      if (tail.every((t, i) => t === kwTokens[i])) {
-        bestScore = Math.max(bestScore, 0.8);
-      }
-    }
-
-    // Substring match: keyword joined appears in field joined
-    if (kwJoined.length >= 3 && fieldJoined.includes(kwJoined)) {
-      bestScore = Math.max(bestScore, 0.7);
-    }
-  }
-
-  return bestScore;
-}
-
-interface MatchResult {
-  mapping: FieldMapping;
-  score: number;
-}
-
-/**
- * Find the best field mapping for a given field name and schema.
- * Returns the highest-scoring match above its threshold, or undefined.
- */
-export function findBestMapping(
-  fieldName: string,
-  schema: JSONSchema7,
-  mappings: FieldMapping[] = ALL_FIELD_MAPPINGS,
-): MatchResult | undefined {
-  const schemaAny = schema as Record<string, unknown>;
-  const schemaType = typeof schema.type === "string" ? schema.type : undefined;
-
-  // Priority: format:uuid always maps to string.uuid
-  if (schemaType === "string" && schema.format === "uuid") {
-    return {
-      mapping: {
-        keywords: ["uuid"],
-        fakerMethod: "string.uuid",
-        schemaType: "string",
-        minScore: 0.5,
-      },
-      score: 1.0,
-    };
-  }
-
-  // Skip if schema already has pattern, enum, faker, or $ref constraint
-  // Also skip string mappings when minLength/maxLength is set — name-based
-  // mappings (e.g. lorem.word for "label") don't honor JSON Schema length
-  // constraints, so they'd produce out-of-range strings ~20% of the time.
-  // Mirrors the numeric constraint skip just below.
-  if (
-    schemaAny.pattern ||
-    schemaAny.enum ||
-    schemaAny.faker ||
-    schemaAny.$ref ||
-    (schemaType === "string" &&
-      (schema.minLength !== undefined || schema.maxLength !== undefined))
-  ) {
-    return undefined;
-  }
-
-  // Skip numeric faker mapping when schema already constrains the range
-  const hasNumericConstraints =
-    schema.minimum !== undefined ||
-    schema.maximum !== undefined ||
-    schema.exclusiveMinimum !== undefined ||
-    schema.exclusiveMaximum !== undefined;
-
-  const tokens = tokenizeFieldName(fieldName);
-
-  let best: MatchResult | undefined;
-
-  for (const mapping of mappings) {
-    // Skip numeric faker mappings when schema has explicit constraints
-    if (
-      hasNumericConstraints &&
-      (mapping.schemaType === "number" || mapping.schemaType === "integer")
-    ) {
-      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 =
-        (mapping.schemaType === "number" && schemaType === "integer") ||
-        (mapping.schemaType === "integer" && schemaType === "number");
-      if (!isNumeric) continue;
-    }
-
-    const score = scoreMatch(tokens, mapping.keywords);
-    if (score >= mapping.minScore && (!best || score > best.score)) {
-      best = { mapping, score };
-    }
-  }
-
-  // ID suffix detection: fields ending in Id/_id with string type → UUID
-  // Only if no better match was found or the existing match is weak
-  if (schemaType === "string") {
-    const lastToken = tokens[tokens.length - 1];
-    if (lastToken === "id" && tokens.length > 1) {
-      const idScore = 0.8;
-      if (!best || best.score < idScore) {
-        best = {
-          mapping: {
-            keywords: ["id"],
-            fakerMethod: "string.uuid",
-            schemaType: "string",
-            minScore: 0.5,
-          },
-          score: idScore,
-        };
-      }
-    }
-  }
-
-  return best;
-}

package/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAO/C,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CA+CvE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,uBAAuB,GAAG,GAAG,CA6CxE"}