jtcsv 3.0.0 → 3.1.0

package/dist/src/utils/schema-validator.js

@@ -0,0 +1,609 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSchema = loadSchema;
+exports.createValidationHook = createValidationHook;
+exports.applySchemaValidation = applySchemaValidation;
+exports.createValidationHooks = createValidationHooks;
+exports.createSchemaValidators = createSchemaValidators;
+exports.loadSchemaAsync = loadSchemaAsync;
+exports.applySchemaValidationAsync = applySchemaValidationAsync;
+exports.createAsyncValidationHook = createAsyncValidationHook;
+const fs = __importStar(require("fs"));
+const fsPromises = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const errors_1 = require("../errors");
+function loadSchema(schemaPathOrJson) {
+    if (!schemaPathOrJson || typeof schemaPathOrJson !== 'string') {
+        throw new errors_1.ValidationError('Schema must be a string (JSON or file path)');
+    }
+    let schemaString = schemaPathOrJson;
+    const isFilePath = schemaPathOrJson.endsWith('.json') ||
+        schemaPathOrJson.includes('/') ||
+        schemaPathOrJson.includes('\\');
+    if (isFilePath) {
+        const safePath = path.resolve(schemaPathOrJson);
+        const normalizedPath = path.normalize(schemaPathOrJson);
+        if (normalizedPath.includes('..') ||
+            /\\\.\.\\|\/\.\.\//.test(schemaPathOrJson) ||
+            schemaPathOrJson.startsWith('..') ||
+            schemaPathOrJson.includes('/..')) {
+            throw new errors_1.SecurityError('Directory traversal detected in schema file path');
+        }
+        if (!fs.existsSync(safePath)) {
+            throw new errors_1.ValidationError(`Schema file not found: ${schemaPathOrJson}`);
+        }
+        if (!safePath.toLowerCase().endsWith('.json')) {
+            throw new errors_1.ValidationError('Schema file must have .json extension');
+        }
+        try {
+            schemaString = fs.readFileSync(safePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'EACCES') {
+                throw new errors_1.SecurityError(`Permission denied reading schema file: ${schemaPathOrJson}`);
+            }
+            throw new errors_1.ValidationError(`Failed to read schema file: ${error.message}`);
+        }
+    }
+    try {
+        const schema = JSON.parse(schemaString);
+        if (typeof schema !== 'object' || schema === null) {
+            throw new errors_1.ValidationError('Schema must be a JSON object');
+        }
+        return schema;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new errors_1.ValidationError(`Invalid JSON in schema: ${error.message}`);
+        }
+        throw new errors_1.ValidationError(`Failed to parse schema: ${error.message}`);
+    }
+}
+function createSimpleValidator(schema) {
+    return {
+        validate(data, options = {}) {
+            const errors = [];
+            const warnings = [];
+            if (!Array.isArray(data)) {
+                return {
+                    valid: false,
+                    errors: [{
+                            row: 0,
+                            type: 'INVALID_DATA',
+                            field: '',
+                            message: 'Data must be an array'
+                        }],
+                    warnings: [],
+                    summary: {
+                        totalRows: 0,
+                        validRows: 0,
+                        errorCount: 1,
+                        warningCount: 0
+                    }
+                };
+            }
+            for (let i = 0; i < data.length; i++) {
+                const row = data[i];
+                for (const [field, rule] of Object.entries(schema)) {
+                    const value = row[field];
+                    if (rule.required && (value === undefined || value === null || value === '')) {
+                        errors.push({
+                            row: i + 1,
+                            type: 'REQUIRED',
+                            field,
+                            message: `Field "${field}" is required`,
+                            value
+                        });
+                        continue;
+                    }
+                    if (value === undefined || value === null || value === '') {
+                        continue;
+                    }
+                    if (rule.type) {
+                        const types = Array.isArray(rule.type) ? rule.type : [rule.type];
+                        let typeValid = false;
+                        for (const type of types) {
+                            if (checkType(value, type)) {
+                                typeValid = true;
+                                break;
+                            }
+                        }
+                        if (!typeValid) {
+                            errors.push({
+                                row: i + 1,
+                                type: 'TYPE',
+                                field,
+                                message: `Field "${field}" must be of type ${types.join(' or ')}`,
+                                value,
+                                expected: types
+                            });
+                        }
+                    }
+                    if (rule.min !== undefined && typeof value === 'string' && value.length < rule.min) {
+                        errors.push({
+                            row: i + 1,
+                            type: 'MIN_LENGTH',
+                            field,
+                            message: `Field "${field}" must be at least ${rule.min} characters`,
+                            value,
+                            min: rule.min
+                        });
+                    }
+                    if (rule.max !== undefined && typeof value === 'string' && value.length > rule.max) {
+                        errors.push({
+                            row: i + 1,
+                            type: 'MAX_LENGTH',
+                            field,
+                            message: `Field "${field}" must be at most ${rule.max} characters`,
+                            value,
+                            max: rule.max
+                        });
+                    }
+                    if (rule.min !== undefined && typeof value === 'number' && value < rule.min) {
+                        errors.push({
+                            row: i + 1,
+                            type: 'MIN_VALUE',
+                            field,
+                            message: `Field "${field}" must be at least ${rule.min}`,
+                            value,
+                            min: rule.min
+                        });
+                    }
+                    if (rule.max !== undefined && typeof value === 'number' && value > rule.max) {
+                        errors.push({
+                            row: i + 1,
+                            type: 'MAX_VALUE',
+                            field,
+                            message: `Field "${field}" must be at most ${rule.max}`,
+                            value,
+                            max: rule.max
+                        });
+                    }
+                    if (rule.pattern && typeof value === 'string') {
+                        const pattern = rule.pattern instanceof RegExp ? rule.pattern : new RegExp(rule.pattern);
+                        if (!pattern.test(value)) {
+                            errors.push({
+                                row: i + 1,
+                                type: 'PATTERN',
+                                field,
+                                message: `Field "${field}" must match pattern`,
+                                value,
+                                pattern: pattern.toString()
+                            });
+                        }
+                    }
+                    if (rule.enum && Array.isArray(rule.enum) && !rule.enum.includes(value)) {
+                        errors.push({
+                            row: i + 1,
+                            type: 'ENUM',
+                            field,
+                            message: `Field "${field}" must be one of: ${rule.enum.join(', ')}`,
+                            value,
+                            allowed: rule.enum
+                        });
+                    }
+                }
+            }
+            return {
+                valid: errors.length === 0,
+                errors,
+                warnings,
+                summary: {
+                    totalRows: data.length,
+                    validRows: data.length - errors.length,
+                    errorCount: errors.length,
+                    warningCount: warnings.length
+                }
+            };
+        }
+    };
+}
+function checkType(value, type) {
+    switch (type) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number' && !isNaN(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'integer':
+            return Number.isInteger(value);
+        case 'float':
+            return typeof value === 'number' && !Number.isInteger(value);
+        case 'date':
+            return value instanceof Date && !isNaN(value.getTime());
+        case 'array':
+            return Array.isArray(value);
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        default:
+            return false;
+    }
+}
+function createValidationHook(schema) {
+    let schemaObj;
+    if (typeof schema === 'string') {
+        schemaObj = loadSchema(schema);
+    }
+    else if (typeof schema === 'object' && schema !== null) {
+        schemaObj = schema;
+    }
+    else {
+        throw new errors_1.ValidationError('Schema must be an object or a path to a JSON file');
+    }
+    let validator;
+    try {
+        const JtcsvValidator = require('../../packages/jtcsv-validator/src/index');
+        validator = new JtcsvValidator();
+        if (schemaObj.fields) {
+            validator.schema(schemaObj.fields);
+        }
+        else {
+            Object.entries(schemaObj).forEach(([field, rule]) => {
+                if (typeof rule === 'object') {
+                    validator.field(field, rule);
+                }
+            });
+        }
+    }
+    catch (error) {
+        console.warn('@jtcsv/validator not available, using simple validation');
+        validator = createSimpleValidator(schemaObj);
+    }
+    return function (row, index, context) {
+        try {
+            const result = validator.validate([row], {
+                stopOnFirstError: true,
+                transform: false
+            });
+            if (!result.valid && result.errors.length > 0) {
+                const error = result.errors[0];
+                throw new errors_1.ValidationError(`Row ${index + 1}: ${error.message} (field: ${error.field})`);
+            }
+            return row;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            console.error(`Validation error at row ${index}: ${error.message}`);
+            if (process.env['NODE_ENV'] === 'development') {
+                console.error(error.stack);
+            }
+            return row;
+        }
+    };
+}
+function applySchemaValidation(data, schema) {
+    if (!Array.isArray(data)) {
+        throw new errors_1.ValidationError('Data must be an array');
+    }
+    const validationHook = createValidationHook(schema);
+    const errors = [];
+    const validatedData = [];
+    for (let i = 0; i < data.length; i++) {
+        try {
+            const validatedRow = validationHook(data[i], i, { operation: 'validate' });
+            validatedData.push(validatedRow);
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                errors.push({
+                    row: i + 1,
+                    message: error.message,
+                    data: data[i]
+                });
+            }
+            else {
+                validatedData.push(data[i]);
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        data: validatedData,
+        summary: {
+            totalRows: data.length,
+            validRows: validatedData.length,
+            errorCount: errors.length,
+            errorRate: data.length > 0 ? (errors.length / data.length) * 100 : 0
+        }
+    };
+}
+function createValidationHooks(schema) {
+    const { TransformHooks } = require('../core/transform-hooks');
+    const hooks = new TransformHooks();
+    const validationHook = createValidationHook(schema);
+    hooks.perRow(validationHook);
+    return hooks;
+}
+function createSchemaValidators(schema) {
+    const validators = {};
+    const properties = schema.properties || schema;
+    const requiredFields = schema.required || [];
+    if (!properties || typeof properties !== 'object') {
+        return validators;
+    }
+    for (const [key, definition] of Object.entries(properties)) {
+        const validator = {
+            type: definition.type,
+            required: requiredFields.includes(key)
+        };
+        if (definition.type === 'string' && definition.format) {
+            validator.format = (value) => {
+                if (definition.format === 'date-time') {
+                    if (value instanceof Date) {
+                        return value.toISOString();
+                    }
+                    if (typeof value === 'string') {
+                        const date = new Date(value);
+                        if (!isNaN(date.getTime())) {
+                            return date.toISOString();
+                        }
+                    }
+                }
+                if (definition.format === 'email') {
+                    if (typeof value === 'string') {
+                        return value.toLowerCase().trim();
+                    }
+                }
+                if (definition.format === 'uri') {
+                    if (typeof value === 'string') {
+                        return value.trim();
+                    }
+                }
+                return value;
+            };
+        }
+        validator.validate = (value) => {
+            if (value === null || value === undefined) {
+                return !validator.required;
+            }
+            if (definition.type === 'string' && typeof value !== 'string') {
+                if (definition.format === 'date-time' && value instanceof Date) {
+                    return true;
+                }
+                return false;
+            }
+            if (definition.type === 'number' && typeof value !== 'number') {
+                return false;
+            }
+            if (definition.type === 'integer' && (!Number.isInteger(value) || typeof value !== 'number')) {
+                return false;
+            }
+            if (definition.type === 'boolean' && typeof value !== 'boolean') {
+                return false;
+            }
+            if (definition.type === 'array' && !Array.isArray(value)) {
+                return false;
+            }
+            if (definition.type === 'object' && (typeof value !== 'object' || value === null || Array.isArray(value))) {
+                return false;
+            }
+            if (definition.type === 'string') {
+                if (definition.minLength !== undefined && value.length < definition.minLength) {
+                    return false;
+                }
+                if (definition.maxLength !== undefined && value.length > definition.maxLength) {
+                    return false;
+                }
+                if (definition.pattern && !new RegExp(definition.pattern).test(value)) {
+                    return false;
+                }
+                if (definition.format === 'email' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+                    return false;
+                }
+                if (definition.format === 'uri') {
+                    try {
+                        new URL(value);
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+            }
+            if (definition.type === 'number' || definition.type === 'integer') {
+                if (definition.minimum !== undefined && value < definition.minimum) {
+                    return false;
+                }
+                if (definition.maximum !== undefined && value > definition.maximum) {
+                    return false;
+                }
+                if (definition.exclusiveMinimum !== undefined && value <= definition.exclusiveMinimum) {
+                    return false;
+                }
+                if (definition.exclusiveMaximum !== undefined && value >= definition.exclusiveMaximum) {
+                    return false;
+                }
+                if (definition.multipleOf !== undefined && value % definition.multipleOf !== 0) {
+                    return false;
+                }
+            }
+            if (definition.type === 'array') {
+                if (definition.minItems !== undefined && value.length < definition.minItems) {
+                    return false;
+                }
+                if (definition.maxItems !== undefined && value.length > definition.maxItems) {
+                    return false;
+                }
+                if (definition.uniqueItems && new Set(value).size !== value.length) {
+                    return false;
+                }
+                if (definition.items) {
+                    for (const item of value) {
+                        const itemValidator = createSchemaValidators({ properties: { item: definition.items } });
+                        if (itemValidator.item && !itemValidator.item.validate(item)) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (definition.type === 'object' && definition.properties) {
+                const nestedValidators = createSchemaValidators(definition);
+                for (const [nestedKey, nestedValidator] of Object.entries(nestedValidators)) {
+                    if (value[nestedKey] !== undefined && !nestedValidator.validate(value[nestedKey])) {
+                        return false;
+                    }
+                    if (nestedValidator.required && value[nestedKey] === undefined) {
+                        return false;
+                    }
+                }
+            }
+            if (definition.enum && !definition.enum.includes(value)) {
+                return false;
+            }
+            return true;
+        };
+        validators[key] = validator;
+    }
+    return validators;
+}
+async function loadSchemaAsync(schemaPathOrJson) {
+    if (!schemaPathOrJson || typeof schemaPathOrJson !== 'string') {
+        throw new errors_1.ValidationError('Schema must be a string (JSON or file path)');
+    }
+    let schemaString = schemaPathOrJson;
+    const isFilePath = schemaPathOrJson.endsWith('.json') ||
+        schemaPathOrJson.includes('/') ||
+        schemaPathOrJson.includes('\\');
+    if (isFilePath) {
+        const safePath = path.resolve(schemaPathOrJson);
+        const normalizedPath = path.normalize(schemaPathOrJson);
+        if (normalizedPath.includes('..') ||
+            /\\\.\.\\|\/\.\.\//.test(schemaPathOrJson) ||
+            schemaPathOrJson.startsWith('..') ||
+            schemaPathOrJson.includes('/..')) {
+            throw new errors_1.SecurityError('Directory traversal detected in schema file path');
+        }
+        try {
+            await fsPromises.access(safePath);
+        }
+        catch {
+            throw new errors_1.ValidationError(`Schema file not found: ${schemaPathOrJson}`);
+        }
+        if (!safePath.toLowerCase().endsWith('.json')) {
+            throw new errors_1.ValidationError('Schema file must have .json extension');
+        }
+        try {
+            schemaString = await fsPromises.readFile(safePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'EACCES') {
+                throw new errors_1.SecurityError(`Permission denied reading schema file: ${schemaPathOrJson}`);
+            }
+            throw new errors_1.ValidationError(`Failed to read schema file: ${error.message}`);
+        }
+    }
+    try {
+        const schema = JSON.parse(schemaString);
+        if (typeof schema !== 'object' || schema === null) {
+            throw new errors_1.ValidationError('Schema must be a JSON object');
+        }
+        return schema;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new errors_1.ValidationError(`Invalid JSON in schema: ${error.message}`);
+        }
+        throw new errors_1.ValidationError(`Failed to parse schema: ${error.message}`);
+    }
+}
+async function applySchemaValidationAsync(data, schema) {
+    if (!Array.isArray(data)) {
+        throw new errors_1.ValidationError('Data must be an array');
+    }
+    const schemaObj = typeof schema === 'string' ? await loadSchemaAsync(schema) : schema;
+    const validationHook = createValidationHook(schemaObj);
+    if (data.length > 1000) {
+        const { createWorkerPool } = require('../workers/worker-pool');
+        const pool = createWorkerPool({
+            workerCount: Math.min(4, require('os').cpus().length),
+            workerScript: require.resolve('./validation-worker.js')
+        });
+        try {
+            const validationPromises = data.map((row, index) => pool.execute({ row, index, schema: schemaObj, operation: 'validate' }));
+            const results = await Promise.all(validationPromises);
+            const errors = [];
+            const validatedData = [];
+            results.forEach((result, index) => {
+                if (result.error) {
+                    errors.push({
+                        row: index + 1,
+                        message: result.error.message,
+                        data: data[index]
+                    });
+                }
+                else {
+                    validatedData.push(result.validatedRow);
+                }
+            });
+            return {
+                valid: errors.length === 0,
+                errors,
+                data: validatedData,
+                summary: {
+                    totalRows: data.length,
+                    validRows: validatedData.length,
+                    errorCount: errors.length,
+                    errorRate: data.length > 0 ? (errors.length / data.length) * 100 : 0
+                }
+            };
+        }
+        finally {
+            await pool.terminate();
+        }
+    }
+    return applySchemaValidation(data, schemaObj);
+}
+function createAsyncValidationHook(schema) {
+    const syncHook = createValidationHook(schema);
+    return async function (row, index, context) {
+        return Promise.resolve(syncHook(row, index, context));
+    };
+}
+exports.default = {
+    loadSchema,
+    loadSchemaAsync,
+    createValidationHook,
+    createAsyncValidationHook,
+    applySchemaValidation,
+    applySchemaValidationAsync,
+    createValidationHooks,
+    checkType,
+    createSchemaValidators
+};
+//# sourceMappingURL=schema-validator.js.map