@schmock/faker 1.9.0 → 1.9.1

package/src/jsf-config.ts

@@ -0,0 +1,56 @@
+import { en, Faker } from "@faker-js/faker";
+import jsf from "json-schema-faker";
+
+/**
+ * Create isolated faker instance to avoid race conditions
+ * Each generation gets its own faker instance to ensure thread-safety
+ * @returns Fresh Faker instance with English locale
+ */
+export function createFakerInstance(seed?: number) {
+  const faker = new Faker({ locale: [en] });
+  if (seed !== undefined) {
+    faker.seed(seed);
+  }
+  return faker;
+}
+
+let jsfConfigured = false;
+let currentSeed: number | undefined;
+
+/**
+ * Create a seeded PRNG using the mulberry32 algorithm.
+ * Returns a function that produces deterministic values in [0, 1).
+ */
+function createSeededRandom(seed: number): () => number {
+  let state = seed | 0;
+  return () => {
+    state = (state + 0x6d2b79f5) | 0;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export function getJsf(seed?: number): typeof jsf {
+  const seedChanged = seed !== currentSeed;
+  if (!jsfConfigured || seedChanged) {
+    currentSeed = seed;
+    jsf.extend("faker", () => createFakerInstance(seed));
+    jsf.option({
+      requiredOnly: false,
+      alwaysFakeOptionals: true,
+      useDefaultValue: true,
+      ignoreMissingRefs: true,
+      failOnInvalidTypes: false,
+      failOnInvalidFormat: false,
+    });
+    jsfConfigured = true;
+  }
+  // Always reset PRNG for deterministic output per call
+  if (seed !== undefined) {
+    jsf.option({ random: createSeededRandom(seed) });
+    jsf.extend("faker", () => createFakerInstance(seed));
+  }
+  return jsf;
+}

package/src/overrides.ts

@@ -0,0 +1,179 @@
+import type { JSONSchema7 } from "json-schema";
+import { DEFAULT_ARRAY_COUNT } from "./constants.js";
+
+/**
+ * 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,
+): number {
+  if (explicitCount !== undefined) {
+    // Handle negative or invalid counts
+    if (explicitCount < 0) {
+      return 0;
+    }
+    return explicitCount;
+  }
+
+  if (schema.minItems !== undefined && schema.maxItems !== undefined) {
+    return (
+      Math.floor(Math.random() * (schema.maxItems - schema.minItems + 1)) +
+      schema.minItems
+    );
+  }
+
+  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: any,
+  overrides?: Record<string, any>,
+  params?: Record<string, string>,
+  state?: any,
+  query?: Record<string, string>,
+): any {
+  if (!overrides) return data;
+
+  const result = structuredClone(data);
+
+  for (const [key, value] of Object.entries(overrides)) {
+    // 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)
+      ) {
+        // Recursively apply nested overrides
+        if (result[key] && typeof result[key] === "object") {
+          result[key] = applyOverrides(
+            result[key],
+            value,
+            params,
+            state,
+            query,
+          );
+        } else {
+          result[key] = applyOverrides({}, value, 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: any,
+  path: string,
+  value: any,
+  context: {
+    params?: Record<string, string>;
+    state?: any;
+    query?: Record<string, string>;
+  },
+): void {
+  const parts = path.split(".");
+  let current = obj;
+
+  // Navigate to the parent of the target property
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (
+      !(part in current) ||
+      typeof current[part] !== "object" ||
+      current[part] === null
+    ) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+
+  // Set the final property
+  const finalKey = parts[parts.length - 1];
+  if (typeof value === "string" && value.includes("{{")) {
+    current[finalKey] = processTemplate(value, context);
+  } else {
+    current[finalKey] = value;
+  }
+}
+
+function processTemplate(
+  template: string,
+  context: {
+    params?: Record<string, string>;
+    state?: any;
+    query?: Record<string, string>;
+  },
+): any {
+  // 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 expression = singleTemplateMatch[1];
+    const parts = expression.trim().split(".");
+    let result: any = context;
+
+    for (const part of parts) {
+      if (result && typeof result === "object") {
+        result = result[part];
+      } else {
+        return template; // Return original if can't resolve
+      }
+    }
+
+    return result !== undefined ? result : template;
+  }
+
+  // For templates mixed with other text, do string replacement
+  const processed = template.replace(
+    /\{\{\s*([^}]+)\s*\}\}/g,
+    (match, expression) => {
+      const parts = expression.trim().split(".");
+      let result: any = context;
+
+      for (const part of parts) {
+        if (result && typeof result === "object") {
+          result = result[part];
+        } else {
+          return match; // Return original if can't resolve
+        }
+      }
+
+      return result !== undefined ? String(result) : match;
+    },
+  );
+
+  return processed;
+}

package/src/schema-enhancement.ts

@@ -0,0 +1,106 @@
+import type { JSONSchema7 } from "json-schema";
+import { isJSONSchema7, validateFakerMethod } from "./validation.js";
+
+/** JSONSchema7 extended with json-schema-faker's `faker` property */
+interface FakerSchema extends JSONSchema7 {
+  faker?: string;
+}
+
+export function enhanceSchemaWithSmartMapping(
+  schema: JSONSchema7,
+): JSONSchema7 {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+
+  const enhanced = { ...schema };
+
+  // Handle object properties
+  if (enhanced.type === "object" && enhanced.properties) {
+    enhanced.properties = { ...enhanced.properties };
+
+    for (const [fieldName, fieldSchema] of Object.entries(
+      enhanced.properties,
+    )) {
+      if (isJSONSchema7(fieldSchema)) {
+        enhanced.properties[fieldName] = enhanceFieldSchema(
+          fieldName,
+          fieldSchema,
+        );
+      }
+    }
+  }
+
+  return enhanced;
+}
+
+function enhanceFieldSchema(
+  fieldName: string,
+  fieldSchema: JSONSchema7,
+): FakerSchema {
+  const enhanced: FakerSchema = { ...fieldSchema };
+
+  // If already has faker extension, validate it and don't override
+  if (enhanced.faker) {
+    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";
+  }
+  // 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";
+  }
+  // Price/money fields
+  else if (lowerFieldName === "price" || lowerFieldName === "amount") {
+    enhanced.faker = "commerce.price";
+  }
+
+  return enhanced;
+}