@schmock/faker 2.3.0 → 2.3.1

package/dist/test-utils.js

@@ -1,284 +0,0 @@
-import { expect } from "vitest";
-import { generateFromSchema } from "./index";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-// Schema Factory Functions
-export const schemas = {
-    simple: {
-        string: () => ({
-            type: "string",
-        }),
-        number: () => ({
-            type: "number",
-        }),
-        object: (properties = {}) => ({
-            type: "object",
-            properties,
-        }),
-        array: (items, constraints) => ({
-            type: "array",
-            items,
-            ...constraints,
-        }),
-    },
-    withFaker: (type, fakerMethod) => ({
-        type,
-        faker: fakerMethod,
-    }),
-    nested: {
-        deep: (depth, leafSchema = schemas.simple.string()) => {
-            if (depth <= 0)
-                return leafSchema;
-            return {
-                type: "object",
-                properties: {
-                    nested: schemas.nested.deep(depth - 1, leafSchema),
-                },
-            };
-        },
-        wide: (width, propertySchema = schemas.simple.string()) => ({
-            type: "object",
-            properties: Object.fromEntries(Array.from({ length: width }, (_, i) => [`prop${i}`, propertySchema])),
-        }),
-    },
-    complex: {
-        user: () => ({
-            type: "object",
-            properties: {
-                id: { type: "string", format: "uuid" },
-                email: { type: "string" },
-                firstName: { type: "string" },
-                lastName: { type: "string" },
-                createdAt: { type: "string" },
-            },
-            required: ["id", "email"],
-        }),
-        apiResponse: () => ({
-            type: "object",
-            properties: {
-                success: { type: "boolean" },
-                data: {
-                    type: "array",
-                    items: schemas.complex.user(),
-                },
-                meta: {
-                    type: "object",
-                    properties: {
-                        page: { type: "number" },
-                        total: { type: "number" },
-                    },
-                },
-            },
-        }),
-    },
-};
-// Validation Helpers
-export const validators = {
-    // Check if a field was mapped to a faker method by comparing with unmapped behavior
-    isFieldMapped: async (fieldName, fieldType = "string") => {
-        const mappedSchema = {
-            type: "object",
-            properties: {
-                [fieldName]: { type: fieldType },
-            },
-        };
-        const unmappedSchema = {
-            type: "object",
-            properties: {
-                unmappedRandomField12345: { type: fieldType },
-            },
-        };
-        // Generate multiple samples to check for patterns
-        const mappedSamples = [];
-        for (let i = 0; i < 10; i++) {
-            const result = await generateFromSchema({
-                schema: mappedSchema,
-            });
-            if (!isRecord(result)) {
-                throw new Error("Expected mapped schema generation to return an object");
-            }
-            mappedSamples.push(result[fieldName]);
-        }
-        const unmappedSamples = [];
-        for (let i = 0; i < 10; i++) {
-            const result = await generateFromSchema({
-                schema: unmappedSchema,
-            });
-            if (!isRecord(result)) {
-                throw new Error("Expected unmapped schema generation to return an object");
-            }
-            unmappedSamples.push(result.unmappedRandomField12345);
-        }
-        // If field is mapped to a specific faker method, it should have different characteristics
-        // than the generic unmapped field
-        return (analyzeDataCharacteristics(mappedSamples) !==
-            analyzeDataCharacteristics(unmappedSamples));
-    },
-    // Analyze uniqueness of generated data
-    uniquenessRatio: (samples) => {
-        const unique = new Set(samples);
-        return unique.size / samples.length;
-    },
-    // Check if all samples match a basic pattern without being too specific
-    allMatch: (samples, validator) => {
-        return samples.every(validator);
-    },
-    // Check if data appears to be from a specific faker category
-    appearsToBeFromCategory: (samples, category) => {
-        switch (category) {
-            case "email":
-                return validators.allMatch(samples, (s) => typeof s === "string" && s.includes("@") && s.includes("."));
-            case "name":
-                return validators.allMatch(samples, (s) => typeof s === "string" &&
-                    s.length > 1 &&
-                    s.length < 50 &&
-                    /^[A-Z]/.test(s));
-            case "phone":
-                return validators.allMatch(samples, (s) => typeof s === "string" && /\d/.test(s) && s.length > 10);
-            case "address":
-                return validators.allMatch(samples, (s) => typeof s === "string" &&
-                    s.length > 10 &&
-                    /\d/.test(s) &&
-                    /[A-Z]/.test(s));
-            case "uuid":
-                return validators.allMatch(samples, (s) => typeof s === "string" &&
-                    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s));
-            case "date":
-                return validators.allMatch(samples, (s) => typeof s === "string" && !Number.isNaN(Date.parse(s)));
-            default:
-                return false;
-        }
-    },
-};
-// Performance Testing Utilities
-export const performance = {
-    measure: async (fn) => {
-        const start = Date.now();
-        const result = await fn();
-        const duration = Date.now() - start;
-        return { result, duration };
-    },
-    measureMemory: (fn) => {
-        if (globalThis.gc) {
-            globalThis.gc();
-        }
-        const before = process.memoryUsage().heapUsed;
-        fn();
-        const after = process.memoryUsage().heapUsed;
-        return after - before;
-    },
-    benchmark: async (_name, fn, iterations = 100) => {
-        const times = [];
-        for (let i = 0; i < iterations; i++) {
-            const start = Date.now();
-            await fn();
-            const duration = Date.now() - start;
-            times.push(duration);
-        }
-        return {
-            mean: times.reduce((a, b) => a + b, 0) / times.length,
-            min: Math.min(...times),
-            max: Math.max(...times),
-        };
-    },
-};
-// Test Data Generators
-export const generate = {
-    samples: async (schema, count = 10, options) => {
-        const results = [];
-        for (let i = 0; i < count; i++) {
-            results.push(await generateFromSchema({ schema, ...options }));
-        }
-        return results;
-    },
-    withSeed: async (schema, seed) => {
-        return await generateFromSchema({ schema, seed });
-    },
-};
-// Statistical Analysis
-export const stats = {
-    distribution: (samples) => {
-        const dist = new Map();
-        for (const sample of samples) {
-            const key = JSON.stringify(sample) ?? "undefined";
-            dist.set(key, (dist.get(key) || 0) + 1);
-        }
-        return dist;
-    },
-    entropy: (samples) => {
-        const dist = stats.distribution(samples);
-        const total = samples.length;
-        let entropy = 0;
-        for (const count of dist.values()) {
-            const p = count / total;
-            if (p > 0) {
-                entropy -= p * Math.log2(p);
-            }
-        }
-        return entropy;
-    },
-};
-// Schema Validation Test Helpers
-export const schemaTests = {
-    expectValid: async (schema) => {
-        await expect(generateFromSchema({ schema })).resolves.not.toThrow();
-    },
-    expectInvalid: async (schema, errorMessage) => {
-        if (errorMessage) {
-            await expect(generateFromSchema({ schema })).rejects.toThrow(errorMessage);
-        }
-        else {
-            await expect(generateFromSchema({ schema })).rejects.toThrow();
-        }
-    },
-    expectSchemaError: async (schema, path, issue) => {
-        try {
-            await generateFromSchema({ schema });
-            throw new Error("Expected schema validation to fail");
-        }
-        catch (error) {
-            expect(error).toBeInstanceOf(Error);
-            if (!(error instanceof Error)) {
-                throw new Error("Expected schema validation to throw an Error");
-            }
-            expect(error.name).toBe("SchemaValidationError");
-            // The schemaPath is in the context
-            if ("context" in error &&
-                isRecord(error.context) &&
-                error.context.schemaPath) {
-                expect(error.context.schemaPath).toBe(path);
-            }
-            if (issue) {
-                expect(error.message).toContain(issue);
-            }
-        }
-    },
-};
-// Helper to analyze data characteristics without hardcoding patterns
-function analyzeDataCharacteristics(samples) {
-    if (samples.length === 0)
-        return "empty";
-    const first = samples[0];
-    const type = typeof first;
-    if (!samples.every((sample) => typeof sample === "string"))
-        return type;
-    // Analyze string characteristics
-    const characteristics = [type];
-    // Check common patterns without being too specific
-    if (samples.every((s) => s.includes("@")))
-        characteristics.push("has-at");
-    if (samples.every((s) => /^\d+$/.test(s)))
-        characteristics.push("numeric");
-    if (samples.every((s) => /^[0-9a-f-]+$/i.test(s)))
-        characteristics.push("hex-like");
-    if (samples.every((s) => s.length > 50))
-        characteristics.push("long");
-    if (samples.every((s) => s.length < 10))
-        characteristics.push("short");
-    if (validators.uniquenessRatio(samples) > 0.8)
-        characteristics.push("high-entropy");
-    if (validators.uniquenessRatio(samples) < 0.2)
-        characteristics.push("low-entropy");
-    return characteristics.join("-");
-}

package/dist/validation.js

@@ -1,300 +0,0 @@
-import { ResourceLimitError, SchemaValidationError } from "@schmock/core";
-import { DEEP_NESTING_THRESHOLD, DEFAULT_ARRAY_COUNT, LARGE_ARRAY_THRESHOLD, MAX_ARRAY_SIZE, MAX_NESTING_DEPTH, } from "./constants.js";
-import { createFakerInstance } from "./jsf-config.js";
-let validationFaker;
-export function isJSONSchema7(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Validate JSON Schema structure and enforce resource limits
- * Checks for malformed schemas, circular references, excessive nesting,
- * and dangerous patterns that could cause memory issues
- * @param schema - JSON Schema to validate
- * @param path - Current path in schema tree (for error messages)
- * @throws {SchemaValidationError} When schema structure is invalid
- * @throws {ResourceLimitError} When schema exceeds safety limits
- */
-export function validateSchema(schema, path = "$") {
-    if (!schema || typeof schema !== "object") {
-        throw new SchemaValidationError(path, "Schema must be a valid JSON Schema object");
-    }
-    if (Object.keys(schema).length === 0) {
-        throw new SchemaValidationError(path, "Schema cannot be empty");
-    }
-    // Check for invalid schema types
-    const validTypes = [
-        "object",
-        "array",
-        "string",
-        "number",
-        "integer",
-        "boolean",
-        "null",
-    ];
-    if (schema.type &&
-        typeof schema.type === "string" &&
-        !validTypes.includes(schema.type)) {
-        throw new SchemaValidationError(path, `Invalid schema type: "${schema.type}"`, "Supported types are: object, array, string, number, integer, boolean, null");
-    }
-    // Check for malformed properties (must be object, not string)
-    if (schema.type === "object" && schema.properties) {
-        if (typeof schema.properties !== "object" ||
-            Array.isArray(schema.properties)) {
-            throw new SchemaValidationError(`${path}.properties`, "Properties must be an object mapping property names to schemas", 'Use { "propertyName": { "type": "string" } } format');
-        }
-        // Validate each property recursively
-        for (const [propName, propSchema] of Object.entries(schema.properties)) {
-            if (typeof propSchema === "object" && propSchema !== null) {
-                // Check for invalid faker methods in property schemas
-                const fakerProp = "faker" in propSchema ? String(propSchema.faker) : undefined;
-                if (fakerProp) {
-                    try {
-                        validateFakerMethod(fakerProp);
-                    }
-                    catch (error) {
-                        // Re-throw with proper path context
-                        if (error instanceof SchemaValidationError) {
-                            const ctx = error.context;
-                            let issue = "Invalid faker method";
-                            let suggestion;
-                            if (ctx && typeof ctx === "object") {
-                                if ("issue" in ctx && typeof ctx.issue === "string")
-                                    issue = ctx.issue;
-                                if ("suggestion" in ctx && typeof ctx.suggestion === "string")
-                                    suggestion = ctx.suggestion;
-                            }
-                            throw new SchemaValidationError(`${path}.properties.${propName}.faker`, issue, suggestion);
-                        }
-                        if (error instanceof Error)
-                            throw error;
-                        throw new Error(String(error));
-                    }
-                }
-                validateSchema(propSchema, `${path}.properties.${propName}`);
-            }
-        }
-    }
-    // Check for invalid array items
-    if (schema.type === "array") {
-        // Array must have items defined and non-null
-        if (schema.items === null || schema.items === undefined) {
-            throw new SchemaValidationError(`${path}.items`, "Array schema must have valid items definition", "Define items as a schema object or array of schemas");
-        }
-        if (Array.isArray(schema.items)) {
-            if (schema.items.length === 0) {
-                throw new SchemaValidationError(`${path}.items`, "Array items cannot be empty array", "Provide at least one item schema");
-            }
-            schema.items.forEach((item, index) => {
-                if (typeof item === "object" && item !== null) {
-                    validateSchema(item, `${path}.items[${index}]`);
-                }
-            });
-        }
-        else if (typeof schema.items === "object" && schema.items !== null) {
-            validateSchema(schema.items, `${path}.items`);
-        }
-    }
-    // Full-tree integrity checks are O(n) each, so only run them once at the
-    // top of the recursion. Running them at every node turns validation into
-    // O(n²) on deep schemas without finding anything the top-level pass misses.
-    // The self-ref/$ref="#" check is part of this group so that an inner $ref
-    // is reported as "circular references" (caught by hasCircularReference at
-    // the root), matching the legacy error message.
-    if (path === "$") {
-        if (hasCircularReference(schema)) {
-            throw new SchemaValidationError(path, "Schema contains circular references which are not supported");
-        }
-        if (schema.$ref === "#") {
-            throw new SchemaValidationError(path, "Self-referencing schemas are not supported");
-        }
-        const depth = calculateNestingDepth(schema);
-        if (depth > MAX_NESTING_DEPTH) {
-            throw new ResourceLimitError("schema_nesting_depth", MAX_NESTING_DEPTH, depth);
-        }
-        if (depth >= DEEP_NESTING_THRESHOLD) {
-            checkForDeepNestingWithArrays(schema, path);
-        }
-        checkArraySizeLimits(schema, path);
-    }
-}
-/**
- * Detect circular references in JSON Schema using path-based traversal
- * Uses backtracking to distinguish between cycles and legitimate schema reuse
- * @param schema - Schema to check for cycles
- * @param currentPath - Set of schemas currently in traversal path
- * @returns true if circular reference detected, false otherwise
- * @example
- * // Detects: schema A -> B -> A (cycle)
- * // Allows: schema A -> B, A -> C (reuse of A)
- */
-function hasCircularReference(schema, currentPath = new Set()) {
-    // Check if this schema is currently being traversed (cycle detected)
-    if (currentPath.has(schema)) {
-        return true;
-    }
-    if (schema.$ref === "#") {
-        return true;
-    }
-    // Add to current path for this traversal branch
-    currentPath.add(schema);
-    if (schema.type === "object" && schema.properties) {
-        for (const prop of Object.values(schema.properties)) {
-            if (isJSONSchema7(prop)) {
-                if (hasCircularReference(prop, currentPath)) {
-                    return true;
-                }
-            }
-        }
-    }
-    if (schema.type === "array" && schema.items) {
-        const items = Array.isArray(schema.items) ? schema.items : [schema.items];
-        for (const item of items) {
-            if (isJSONSchema7(item)) {
-                if (hasCircularReference(item, currentPath)) {
-                    return true;
-                }
-            }
-        }
-    }
-    // Remove from current path after checking all children (backtrack)
-    currentPath.delete(schema);
-    return false;
-}
-/**
- * Calculate maximum nesting depth of a JSON Schema
- * Recursively traverses object properties and array items
- * @param schema - Schema to measure
- * @param depth - Current depth (internal recursion parameter)
- * @returns Maximum nesting depth found
- */
-function calculateNestingDepth(schema, depth = 0) {
-    if (depth > MAX_NESTING_DEPTH) {
-        return depth;
-    }
-    let maxDepth = depth;
-    if (schema.type === "object" && schema.properties) {
-        for (const prop of Object.values(schema.properties)) {
-            if (isJSONSchema7(prop)) {
-                maxDepth = Math.max(maxDepth, calculateNestingDepth(prop, depth + 1));
-            }
-        }
-    }
-    if (schema.type === "array" && schema.items) {
-        const items = Array.isArray(schema.items) ? schema.items : [schema.items];
-        for (const item of items) {
-            if (isJSONSchema7(item)) {
-                maxDepth = Math.max(maxDepth, calculateNestingDepth(item, depth + 1));
-            }
-        }
-    }
-    return maxDepth;
-}
-/**
- * Check for dangerous patterns of deep nesting combined with large arrays
- * Prevents memory issues from schemas like: depth 3+ with 100+ item arrays
- * @param schema - Schema to check
- * @param _path - Path in schema (unused but kept for signature consistency)
- * @throws {ResourceLimitError} When dangerous nesting pattern detected
- */
-function checkForDeepNestingWithArrays(schema, _path) {
-    // Look for arrays in deeply nested structures that could cause memory issues
-    function findArraysInDeepNesting(node, currentDepth) {
-        const schemaType = node.type;
-        const isArray = Array.isArray(schemaType)
-            ? schemaType.includes("array")
-            : schemaType === "array";
-        if (isArray) {
-            const maxItems = node.maxItems || DEFAULT_ARRAY_COUNT;
-            // Be more aggressive about deep nesting detection
-            if (currentDepth >= DEEP_NESTING_THRESHOLD &&
-                maxItems >= LARGE_ARRAY_THRESHOLD) {
-                throw new ResourceLimitError("deep_nesting_memory_risk", DEEP_NESTING_THRESHOLD * LARGE_ARRAY_THRESHOLD, currentDepth * maxItems);
-            }
-            // Check items if they exist
-            if (node.items) {
-                const items = Array.isArray(node.items) ? node.items : [node.items];
-                for (const item of items) {
-                    if (isJSONSchema7(item)) {
-                        findArraysInDeepNesting(item, currentDepth + 1);
-                    }
-                }
-            }
-            return;
-        }
-        if (schemaType === "object" && node.properties) {
-            for (const prop of Object.values(node.properties)) {
-                if (isJSONSchema7(prop)) {
-                    findArraysInDeepNesting(prop, currentDepth + 1);
-                }
-            }
-        }
-    }
-    findArraysInDeepNesting(schema, 0);
-}
-function checkArraySizeLimits(schema, path) {
-    // Recursively check all array constraints in the schema
-    if (schema.type === "array") {
-        // Check for dangerously large maxItems
-        if (schema.maxItems && schema.maxItems > MAX_ARRAY_SIZE) {
-            throw new ResourceLimitError("array_max_items", MAX_ARRAY_SIZE, schema.maxItems);
-        }
-        // Check for combination of deep nesting and large arrays
-        const depth = calculateNestingDepth(schema);
-        const estimatedSize = schema.maxItems || schema.minItems || DEFAULT_ARRAY_COUNT;
-        // If we have deep nesting and large arrays, it could cause memory issues
-        if (depth > DEEP_NESTING_THRESHOLD &&
-            estimatedSize > LARGE_ARRAY_THRESHOLD) {
-            throw new ResourceLimitError("memory_estimation", DEEP_NESTING_THRESHOLD * LARGE_ARRAY_THRESHOLD, depth * estimatedSize);
-        }
-    }
-    // Recursively check nested schemas
-    if (schema.type === "object" && schema.properties) {
-        for (const [propName, propSchema] of Object.entries(schema.properties)) {
-            if (isJSONSchema7(propSchema)) {
-                checkArraySizeLimits(propSchema, `${path}.properties.${propName}`);
-            }
-        }
-    }
-    if (schema.type === "array" && schema.items) {
-        if (Array.isArray(schema.items)) {
-            schema.items.forEach((item, index) => {
-                if (isJSONSchema7(item)) {
-                    checkArraySizeLimits(item, `${path}.items[${index}]`);
-                }
-            });
-        }
-        else if (isJSONSchema7(schema.items)) {
-            checkArraySizeLimits(schema.items, `${path}.items`);
-        }
-    }
-}
-/**
- * Validate that faker method string references a valid Faker.js API
- * Checks format (namespace.method) and validates against known namespaces
- * @param fakerMethod - Faker method string (e.g., "person.fullName")
- * @throws {SchemaValidationError} When faker method format or namespace is invalid
- */
-export function validateFakerMethod(fakerMethod) {
-    // Check if faker method follows valid format (namespace.method)
-    const parts = fakerMethod.split(".");
-    if (parts.length < 2) {
-        throw new SchemaValidationError("$.faker", `Invalid faker method format: "${fakerMethod}"`, "Use format like 'person.firstName' or 'internet.email'");
-    }
-    // Validate by resolving the method path on a cached faker instance
-    if (!validationFaker) {
-        validationFaker = createFakerInstance();
-    }
-    const faker = validationFaker;
-    let current = faker;
-    for (const part of parts) {
-        if (current && typeof current === "object" && part in current) {
-            current = Reflect.get(current, part);
-        }
-        else {
-            throw new SchemaValidationError("$.faker", `Invalid faker method: "${fakerMethod}"`, "Check faker.js documentation for valid methods");
-        }
-    }
-    if (typeof current !== "function") {
-        throw new SchemaValidationError("$.faker", `Invalid faker method: "${fakerMethod}" is not a function`, "Check faker.js documentation for valid methods");
-    }
-}