@oxog/vld 2.0.3 → 2.1.0

package/dist/cli/bin.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+import { vldCli } from './index.js';
+import * as fs from 'fs';
+import { readFileSync } from 'fs';
+import * as path from 'path';
+import pigment from '../pigment.js';
+import { prettifyError, prettifyErrorColored } from '../errors.js';
+import v from '../index.js';
+
+/**
+ * VLD CLI - Validate Command
+ *
+ * Validate JSON data against a VLD schema file.
+ */
+function assertWithinCwd(absolutePath, label, original) {
+    const allowedDir = process.cwd();
+    if (!absolutePath.startsWith(allowedDir + path.sep) && absolutePath !== allowedDir) {
+        throw new Error(`${label} path escapes allowed directory: ${original}`);
+    }
+}
+/**
+ * Validate command
+ */
+const validateCommand = {
+    name: 'validate',
+    description: 'Validate JSON data against a VLD schema',
+    aliases: ['v'],
+    arguments: [
+        {
+            name: 'schema',
+            description: 'Path to schema file (.ts or .js)',
+            required: true
+        },
+        {
+            name: 'data',
+            description: 'Path to JSON data file or JSON string',
+            required: true
+        }
+    ],
+    options: [
+        {
+            name: 'strict',
+            short: 's',
+            description: 'Enable strict mode (no extra keys)',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'quiet',
+            short: 'q',
+            description: 'Only output errors',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'json',
+            short: 'j',
+            description: 'Output as JSON',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'no-color',
+            description: 'Disable colored output',
+            type: 'boolean',
+            default: false
+        }
+    ],
+    action: async (args, options) => {
+        const schemaPath = args['schema'];
+        const dataArg = args['data'];
+        const quiet = options['quiet'];
+        const json = options['json'];
+        const noColor = options['no-color'];
+        // Load schema
+        let schema;
+        try {
+            const absoluteSchemaPath = path.resolve(process.cwd(), schemaPath);
+            // Security: Ensure resolved path is within allowed directories
+            assertWithinCwd(absoluteSchemaPath, 'Schema', schemaPath);
+            if (!fs.existsSync(absoluteSchemaPath)) {
+                throw new Error(`Schema file not found: ${schemaPath}`);
+            }
+            // Dynamic import for ESM/CJS compatibility
+            const schemaModule = await import(absoluteSchemaPath);
+            schema = schemaModule.default || schemaModule.schema || schemaModule;
+            if (!schema || typeof schema.parse !== 'function') {
+                throw new Error('Schema must export a VLD validator with parse() method');
+            }
+        }
+        catch (error) {
+            if (json) {
+                console.log(JSON.stringify({ success: false, error: error.message }));
+            }
+            else {
+                console.error(pigment.red('Schema Error:'), error.message);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        // Load data
+        let data;
+        try {
+            // Check if it's a file path or JSON string
+            if (dataArg.startsWith('{') || dataArg.startsWith('[')) {
+                data = JSON.parse(dataArg);
+            }
+            else {
+                const absoluteDataPath = path.resolve(process.cwd(), dataArg);
+                // Security: Ensure resolved path is within allowed directories
+                assertWithinCwd(absoluteDataPath, 'Data', dataArg);
+                if (!fs.existsSync(absoluteDataPath)) {
+                    throw new Error(`Data file not found: ${dataArg}`);
+                }
+                const content = fs.readFileSync(absoluteDataPath, 'utf-8');
+                data = JSON.parse(content);
+            }
+        }
+        catch (error) {
+            if (json) {
+                console.log(JSON.stringify({ success: false, error: error.message }));
+            }
+            else {
+                console.error(pigment.red('Data Error:'), error.message);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        // Validate
+        const result = schema.safeParse(data);
+        if (json) {
+            if (result.success) {
+                console.log(JSON.stringify({ success: true, data: result.data }));
+            }
+            else {
+                const err = result.error;
+                const errorJson = {
+                    success: false,
+                    error: err?.message,
+                    issues: err?.issues
+                };
+                console.log(JSON.stringify(errorJson));
+            }
+        }
+        else {
+            if (result.success) {
+                if (!quiet) {
+                    console.log(pigment.green('Validation passed'));
+                    console.log('');
+                    console.log(pigment.dim('Data:'));
+                    console.log(JSON.stringify(result.data, null, 2));
+                }
+            }
+            else {
+                console.error(pigment.red('Validation failed'));
+                console.error('');
+                // Check if it's a VldError with issues
+                if (result.error && 'issues' in result.error) {
+                    const formatted = noColor
+                        ? prettifyError(result.error, { colored: false })
+                        : prettifyErrorColored(result.error);
+                    console.error(formatted);
+                }
+                else {
+                    console.error(result.error?.message || 'Unknown error');
+                }
+                process.exitCode = 1;
+            }
+        }
+    }
+};
+
+/**
+ * VLD CLI - Benchmark Command
+ *
+ * Run performance benchmarks for VLD validation.
+ */
+/**
+ * Run a single benchmark
+ */
+function runBenchmark(name, fn, iterations) {
+    // Warm up
+    for (let i = 0; i < Math.min(100, iterations / 10); i++) {
+        fn();
+    }
+    // Run benchmark
+    const start = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        fn();
+    }
+    const end = performance.now();
+    const totalMs = end - start;
+    const avgMs = totalMs / iterations;
+    const opsPerSec = 1000 / avgMs;
+    return { name, iterations, totalMs, avgMs, opsPerSec };
+}
+/**
+ * Format number with comma separators
+ */
+function formatNumber(n) {
+    return n.toLocaleString('en-US', { maximumFractionDigits: 2 });
+}
+/**
+ * Format benchmark result
+ */
+function formatResult(result, colored) {
+    const name = colored ? pigment.cyan(result.name.padEnd(30)) : result.name.padEnd(30);
+    const ops = colored
+        ? pigment.green(formatNumber(result.opsPerSec).padStart(12))
+        : formatNumber(result.opsPerSec).padStart(12);
+    const avg = colored
+        ? pigment.yellow(result.avgMs.toFixed(6).padStart(12))
+        : result.avgMs.toFixed(6).padStart(12);
+    return `${name} ${ops} ops/sec  ${avg} ms/op`;
+}
+/**
+ * Benchmark command
+ */
+const benchmarkCommand = {
+    name: 'benchmark',
+    description: 'Run performance benchmarks',
+    aliases: ['bench', 'b'],
+    options: [
+        {
+            name: 'iterations',
+            short: 'n',
+            description: 'Number of iterations',
+            type: 'number',
+            default: 10000
+        },
+        {
+            name: 'suite',
+            short: 's',
+            description: 'Benchmark suite to run (all, primitives, objects, arrays)',
+            type: 'string',
+            default: 'all'
+        },
+        {
+            name: 'json',
+            short: 'j',
+            description: 'Output as JSON',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'no-color',
+            description: 'Disable colored output',
+            type: 'boolean',
+            default: false
+        }
+    ],
+    action: async (_args, options) => {
+        const iterations = options['iterations'];
+        const suite = options['suite'];
+        const json = options['json'];
+        const noColor = options['no-color'];
+        const colored = !noColor;
+        const results = [];
+        // Primitive validators
+        const stringSchema = v.string();
+        const numberSchema = v.number();
+        const booleanSchema = v.boolean();
+        const dateSchema = v.date();
+        // Object validator
+        const userSchema = v.object({
+            name: v.string(),
+            email: v.string(),
+            age: v.number(),
+            active: v.boolean()
+        });
+        // Array validator
+        const numbersSchema = v.array(v.number());
+        // Nested object validator
+        const nestedSchema = v.object({
+            user: v.object({
+                name: v.string(),
+                email: v.string()
+            }),
+            items: v.array(v.object({
+                id: v.number(),
+                name: v.string(),
+                price: v.number()
+            }))
+        });
+        // Test data
+        const testString = 'hello world';
+        const testNumber = 42;
+        const testBoolean = true;
+        const testDate = new Date();
+        const testUser = { name: 'John', email: 'john@example.com', age: 30, active: true };
+        const testNumbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        const testNested = {
+            user: { name: 'John', email: 'john@example.com' },
+            items: [
+                { id: 1, name: 'Item 1', price: 10.99 },
+                { id: 2, name: 'Item 2', price: 20.99 },
+                { id: 3, name: 'Item 3', price: 30.99 }
+            ]
+        };
+        if (!json) {
+            console.log(pigment.bold('VLD Performance Benchmark'));
+            console.log(pigment.dim(`Running ${formatNumber(iterations)} iterations per test`));
+            console.log('');
+        }
+        // Primitive benchmarks
+        if (suite === 'all' || suite === 'primitives') {
+            if (!json) {
+                console.log(pigment.bold('Primitives:'));
+            }
+            results.push(runBenchmark('string.parse()', () => stringSchema.parse(testString), iterations));
+            results.push(runBenchmark('number.parse()', () => numberSchema.parse(testNumber), iterations));
+            results.push(runBenchmark('boolean.parse()', () => booleanSchema.parse(testBoolean), iterations));
+            results.push(runBenchmark('date.parse()', () => dateSchema.parse(testDate), iterations));
+            results.push(runBenchmark('string.safeParse()', () => stringSchema.safeParse(testString), iterations));
+            if (!json) {
+                for (const result of results.slice(-5)) {
+                    console.log('  ' + formatResult(result, colored));
+                }
+                console.log('');
+            }
+        }
+        // Object benchmarks
+        if (suite === 'all' || suite === 'objects') {
+            if (!json) {
+                console.log(pigment.bold('Objects:'));
+            }
+            results.push(runBenchmark('object.parse()', () => userSchema.parse(testUser), iterations));
+            results.push(runBenchmark('object.safeParse()', () => userSchema.safeParse(testUser), iterations));
+            results.push(runBenchmark('nested.parse()', () => nestedSchema.parse(testNested), iterations));
+            if (!json) {
+                for (const result of results.slice(-3)) {
+                    console.log('  ' + formatResult(result, colored));
+                }
+                console.log('');
+            }
+        }
+        // Array benchmarks
+        if (suite === 'all' || suite === 'arrays') {
+            if (!json) {
+                console.log(pigment.bold('Arrays:'));
+            }
+            results.push(runBenchmark('array.parse()', () => numbersSchema.parse(testNumbers), iterations));
+            results.push(runBenchmark('array.safeParse()', () => numbersSchema.safeParse(testNumbers), iterations));
+            if (!json) {
+                for (const result of results.slice(-2)) {
+                    console.log('  ' + formatResult(result, colored));
+                }
+                console.log('');
+            }
+        }
+        // Summary
+        if (!json) {
+            const totalOps = results.reduce((sum, r) => sum + r.opsPerSec, 0);
+            const avgOps = totalOps / results.length;
+            console.log(pigment.bold('Summary:'));
+            console.log(`  Total benchmarks: ${results.length}`);
+            console.log(`  Average ops/sec:  ${formatNumber(avgOps)}`);
+        }
+        else {
+            console.log(JSON.stringify({
+                iterations,
+                suite,
+                results: results.map((r) => ({
+                    name: r.name,
+                    iterations: r.iterations,
+                    totalMs: r.totalMs,
+                    avgMs: r.avgMs,
+                    opsPerSec: r.opsPerSec
+                }))
+            }));
+        }
+    }
+};
+
+/**
+ * VLD CLI Entry Point
+ *
+ * This is the main entry point for the `vld` command-line tool.
+ */
+const packageJson = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf-8'));
+const version = packageJson.version || '0.0.0';
+vldCli.version = version;
+// Register commands
+vldCli.command(validateCommand);
+vldCli.command(benchmarkCommand);
+// Help command
+vldCli.command({
+    name: 'help',
+    description: 'Show help information',
+    aliases: ['h'],
+    action: () => {
+        console.log(vldCli.help());
+    }
+});
+// Version command
+vldCli.command({
+    name: 'version',
+    description: 'Show version information',
+    action: () => {
+        console.log(`vld v${version}`);
+    }
+});
+// Run CLI
+vldCli.run(process.argv.slice(2)).catch((error) => {
+    console.error('Fatal error:', error);
+    process.exitCode = 1;
+});

package/dist/cli/commands/benchmark.d.ts

@@ -3,9 +3,8 @@
  *
  * Run performance benchmarks for VLD validation.
  */
-import type { CliCommand } from '../index';
+import type { CliCommand } from '../index.js';
 /**
  * Benchmark command
  */
 export declare const benchmarkCommand: CliCommand;
-//# sourceMappingURL=benchmark.d.ts.map

package/dist/cli/commands/validate.d.ts

@@ -3,9 +3,8 @@
  *
  * Validate JSON data against a VLD schema file.
  */
-import type { CliCommand } from '../index';
+import type { CliCommand } from '../index.js';
 /**
  * Validate command
  */
 export declare const validateCommand: CliCommand;
-//# sourceMappingURL=validate.d.ts.map

package/dist/cli/index.d.ts

@@ -56,4 +56,3 @@ export declare function createCli(name: string, version: string, description: st
  */
 export declare const vldCli: Cli;
 export { createCli as cli };
-//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,205 @@
+import pigment from '../pigment.js';
+
+/**
+ * VLD CLI Tool
+ *
+ * Command-line interface for VLD validation library.
+ * Provides commands for validation, schema generation, and benchmarking.
+ */
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args, options = []) {
+    const result = {
+        positional: [],
+        options: {}
+    };
+    // Set defaults
+    for (const opt of options) {
+        if (opt.default !== undefined) {
+            result.options[opt.name] = opt.default;
+        }
+    }
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === undefined) {
+            i++;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            // Long option
+            const [name, value] = arg.slice(2).split('=');
+            if (name === undefined || name === '') {
+                i++;
+                continue;
+            }
+            const option = options.find((o) => o.name === name);
+            if (option) {
+                if (option.type === 'boolean') {
+                    result.options[name] = value !== 'false';
+                }
+                else if (value !== undefined) {
+                    result.options[name] = option.type === 'number' ? Number(value) : value;
+                }
+                else if (i + 1 < args.length && args[i + 1] !== undefined && !args[i + 1].startsWith('-')) {
+                    i++;
+                    const nextArg = args[i];
+                    if (nextArg !== undefined) {
+                        result.options[name] = option.type === 'number' ? Number(nextArg) : nextArg;
+                    }
+                }
+                else {
+                    result.options[name] = true;
+                }
+            }
+        }
+        else if (arg.startsWith('-')) {
+            // Short option
+            const short = arg.slice(1);
+            const option = options.find((o) => o.short === short);
+            if (option) {
+                if (option.type === 'boolean') {
+                    result.options[option.name] = true;
+                }
+                else if (i + 1 < args.length && args[i + 1] !== undefined && !args[i + 1].startsWith('-')) {
+                    i++;
+                    const nextArg = args[i];
+                    if (nextArg === undefined) {
+                        i++;
+                        continue;
+                    }
+                    result.options[option.name] =
+                        option.type === 'number' ? Number(nextArg) : nextArg;
+                }
+            }
+        }
+        else {
+            // Positional argument
+            result.positional.push(arg);
+        }
+        i++;
+    }
+    return result;
+}
+/**
+ * Create a CLI instance
+ */
+function createCli(name, version, description) {
+    const commands = new Map();
+    const cli = {
+        name,
+        version,
+        description,
+        commands,
+        command(cmd) {
+            commands.set(cmd.name, cmd);
+            if (cmd.aliases) {
+                for (const alias of cmd.aliases) {
+                    commands.set(alias, cmd);
+                }
+            }
+            return this;
+        },
+        help() {
+            const lines = [];
+            lines.push(pigment.bold(`${this.name} v${this.version}`));
+            lines.push(pigment.dim(description));
+            lines.push('');
+            lines.push(pigment.bold('Usage:'));
+            lines.push(`  ${name} <command> [options]`);
+            lines.push('');
+            lines.push(pigment.bold('Commands:'));
+            const uniqueCommands = new Map();
+            for (const [, cmd] of commands) {
+                if (!uniqueCommands.has(cmd.name)) {
+                    uniqueCommands.set(cmd.name, cmd);
+                }
+            }
+            for (const [cmdName, cmd] of uniqueCommands) {
+                const aliases = cmd.aliases?.length ? pigment.dim(` (${cmd.aliases.join(', ')})`) : '';
+                lines.push(`  ${pigment.cyan(cmdName)}${aliases}`);
+                lines.push(`    ${cmd.description}`);
+            }
+            lines.push('');
+            lines.push(pigment.bold('Options:'));
+            lines.push(`  ${pigment.cyan('-h, --help')}     Show help`);
+            lines.push(`  ${pigment.cyan('-v, --version')}  Show version`);
+            return lines.join('\n');
+        },
+        async run(args) {
+            // Handle help
+            if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+                console.log(this.help());
+                return;
+            }
+            // Handle version
+            if (args.includes('--version') || args.includes('-v')) {
+                console.log(`${this.name} v${this.version}`);
+                return;
+            }
+            // Get command
+            const cmdName = args[0];
+            if (cmdName === undefined) {
+                console.log(this.help());
+                return;
+            }
+            const cmd = commands.get(cmdName);
+            if (!cmd) {
+                console.error(pigment.red(`Unknown command: ${cmdName}`));
+                console.log('');
+                console.log(this.help());
+                process.exitCode = 1;
+                return;
+            }
+            // Parse arguments
+            const parsed = parseArgs(args.slice(1), cmd.options);
+            // Map positional arguments
+            const positionalArgs = {};
+            if (cmd.arguments) {
+                for (let i = 0; i < cmd.arguments.length; i++) {
+                    const arg = cmd.arguments[i];
+                    if (arg === undefined) {
+                        continue;
+                    }
+                    if (i < parsed.positional.length) {
+                        positionalArgs[arg.name] = parsed.positional[i];
+                    }
+                    else if (arg.default !== undefined) {
+                        positionalArgs[arg.name] = arg.default;
+                    }
+                    else if (arg.required) {
+                        console.error(pigment.red(`Missing required argument: ${arg.name}`));
+                        process.exitCode = 1;
+                        return;
+                    }
+                }
+            }
+            // Check required options
+            if (cmd.options) {
+                for (const opt of cmd.options) {
+                    if (opt.required && parsed.options[opt.name] === undefined) {
+                        console.error(pigment.red(`Missing required option: --${opt.name}`));
+                        process.exitCode = 1;
+                        return;
+                    }
+                }
+            }
+            // Execute command
+            try {
+                await cmd.action(positionalArgs, parsed.options);
+            }
+            catch (error) {
+                console.error(pigment.red('Error:'), error.message);
+                process.exitCode = 1;
+            }
+        }
+    };
+    return cli;
+}
+/**
+ * VLD CLI instance
+ */
+const vldCli = createCli('vld', '1.5.0', 'Fast TypeScript Validation Library');
+
+export { createCli as cli, createCli, vldCli };

package/dist/codecs/index.d.ts

@@ -1,7 +1,25 @@
-import { VldCodec } from '../validators/codec';
+import { VldCodec } from '../validators/codec.js';
 /**
  * Predefined codecs for common transformations (Zod-compatible)
  */
+export interface VldUrl {
+    hash: string;
+    host: string;
+    hostname: string;
+    readonly href: string;
+    password: string;
+    pathname: string;
+    port: string;
+    readonly protocol: string;
+    search: string;
+    username: string;
+    toString(): string;
+    toJSON(): string;
+}
+/**
+ * Invert a codec, swapping encode and decode directions.
+ */
+export declare function invertCodec<TInput, TOutput>(codec: VldCodec<TInput, TOutput>): VldCodec<TOutput, TInput>;
 /**
  * String to number codec
  */
@@ -37,11 +55,11 @@ export declare const jsonCodec: <T = any>(schema?: any) => VldCodec<string, T>;
 /**
  * String to URL codec
  */
-export declare const stringToURL: VldCodec<string, import("url").URL>;
+export declare const stringToURL: VldCodec<string, VldUrl>;
 /**
  * String to HTTP/HTTPS URL codec
  */
-export declare const stringToHttpURL: VldCodec<string, import("url").URL>;
+export declare const stringToHttpURL: VldCodec<string, VldUrl>;
 /**
  * URI component encode/decode codec
  */
@@ -86,4 +104,3 @@ export declare const base64Json: <T = any>(schema?: any) => VldCodec<string, T>;
  * JWT payload decoder (base64url encoded JSON) - updated
  */
 export declare const jwtPayload: (schema?: any) => VldCodec<string, any>;
-//# sourceMappingURL=index.d.ts.map