exisjs 0.6.1 → 0.7.1

package/dist/validator/validator.js

@@ -1,931 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.v = exports.FileValidator = exports.AnyValidator = exports.RecordValidator = exports.DateValidator = exports.UnionValidator = exports.LiteralValidator = exports.EnumValidator = exports.ArrayValidator = exports.ObjectValidator = exports.CoerceBooleanValidator = exports.BooleanValidator = exports.CoerceNumberValidator = exports.NumberValidator = exports.StringValidator = exports.AsyncRefineValidator = exports.TransformValidator = exports.RefineValidator = exports.ValidatorType = exports.ValidatorError = void 0;
-class ValidatorError extends Error {
-    constructor(errors) {
-        super('Validation Error: ' +
-            errors.map((e) => `${e.path}: ${e.message}`).join(', '));
-        this.errors = errors;
-        this.name = 'ValidatorError';
-    }
-}
-exports.ValidatorError = ValidatorError;
-class ValidatorType {
-    constructor() {
-        this.isOptional = false;
-        this._hasDefault = false;
-        this._isUnique = false;
-        this._index = false;
-        this._sanitizers = [];
-    }
-    optional() {
-        this.isOptional = true;
-        return this;
-    }
-    default(val) {
-        this.isOptional = true;
-        this._hasDefault = true;
-        this.defaultValue = val;
-        return this;
-    }
-    unique() {
-        this._isUnique = true;
-        return this;
-    }
-    index() {
-        this._index = true;
-        return this;
-    }
-    refine(check, message = 'Invalid value') {
-        return new RefineValidator(this, check, message);
-    }
-    sanitize(...sanitizers) {
-        this._sanitizers.push(...sanitizers);
-        return this;
-    }
-    transform(fn) {
-        return new TransformValidator(this, fn);
-    }
-    or(other) {
-        return new UnionValidator([this, other]);
-    }
-    /**
-     * Converts this validator into a Mongoose-compatible schema field definition.
-     * Override in subclasses for specific type mappings.
-     */
-    toMongoField() {
-        const field = { type: 'Mixed' };
-        if (!this.isOptional)
-            field.required = true;
-        if (this._hasDefault) {
-            field.default =
-                typeof this.defaultValue === 'function'
-                    ? this.defaultValue
-                    : this.defaultValue;
-        }
-        if (this._isUnique)
-            field.unique = true;
-        if (this._index)
-            field.index = true;
-        return field;
-    }
-    async _validateAsync(value, path) {
-        return this._validate(value, path);
-    }
-    validate(value, path = '') {
-        if (this._hasDefault && value === undefined) {
-            const def = typeof this.defaultValue === 'function'
-                ? this.defaultValue()
-                : this.defaultValue;
-            return { success: true, data: def };
-        }
-        return this._validate(value, path);
-    }
-    async validateAsync(value, path = '') {
-        if (this._hasDefault && value === undefined) {
-            const def = typeof this.defaultValue === 'function'
-                ? this.defaultValue()
-                : this.defaultValue;
-            return { success: true, data: def };
-        }
-        return this._validateAsync(value, path);
-    }
-    refineAsync(check, message = 'Invalid value') {
-        return new AsyncRefineValidator(this, check, message);
-    }
-    parse(value) {
-        const result = this.validate(value, '');
-        if (!result.success)
-            throw new ValidatorError(result.errors);
-        return result.data;
-    }
-    async parseAsync(value) {
-        const result = await this.validateAsync(value, '');
-        if (!result.success)
-            throw new ValidatorError(result.errors);
-        return result.data;
-    }
-}
-exports.ValidatorType = ValidatorType;
-class RefineValidator extends ValidatorType {
-    constructor(base, check, message) {
-        super();
-        this.base = base;
-        this.check = check;
-        this.message = message;
-    }
-    toOpenApi() {
-        return this.base.toOpenApi();
-    }
-    _validate(value, path) {
-        const res = this.base._validate(value, path);
-        if (!res.success)
-            return res;
-        if (res.data !== undefined) {
-            if (!this.check(res.data)) {
-                const msg = typeof this.message === 'function'
-                    ? this.message(res.data)
-                    : this.message;
-                return { success: false, errors: [{ path, message: msg }] };
-            }
-        }
-        return res;
-    }
-}
-exports.RefineValidator = RefineValidator;
-class TransformValidator extends ValidatorType {
-    constructor(base, fn) {
-        super();
-        this.base = base;
-        this.fn = fn;
-    }
-    toOpenApi() {
-        return this.base.toOpenApi();
-    }
-    _validate(value, path) {
-        const res = this.base._validate(value, path);
-        if (!res.success)
-            return res;
-        if (res.data !== undefined) {
-            try {
-                const transformed = this.fn(res.data);
-                return { success: true, data: transformed };
-            }
-            catch (err) {
-                return {
-                    success: false,
-                    errors: [
-                        {
-                            path,
-                            message: err instanceof Error ? err.message : 'Transform failed',
-                        },
-                    ],
-                };
-            }
-        }
-        return { success: true, data: res.data };
-    }
-}
-exports.TransformValidator = TransformValidator;
-class AsyncRefineValidator extends ValidatorType {
-    constructor(base, check, message) {
-        super();
-        this.base = base;
-        this.check = check;
-        this.message = message;
-    }
-    toOpenApi() {
-        return this.base.toOpenApi();
-    }
-    _validate(_value, _path) {
-        throw new Error('Async validation requires parseAsync() to be used');
-    }
-    async _validateAsync(value, path) {
-        const res = await this.base.validateAsync(value, path);
-        if (!res.success)
-            return res;
-        if (res.data !== undefined) {
-            if (!(await this.check(res.data))) {
-                const msg = typeof this.message === 'function'
-                    ? this.message(res.data)
-                    : this.message;
-                return { success: false, errors: [{ path, message: msg }] };
-            }
-        }
-        return res;
-    }
-}
-exports.AsyncRefineValidator = AsyncRefineValidator;
-class StringValidator extends ValidatorType {
-    min(len, message) {
-        this.minLen = len;
-        this.minMsg = message;
-        return this;
-    }
-    max(len, message) {
-        this.maxLen = len;
-        this.maxMsg = message;
-        return this;
-    }
-    email(message) {
-        this.isEmail = true;
-        this.emailMsg = message;
-        return this;
-    }
-    regex(pattern, message) {
-        this.regexPattern = pattern;
-        this.regexMsg = message;
-        return this;
-    }
-    toOpenApi() {
-        const schema = { type: 'string' };
-        if (this.minLen !== undefined)
-            schema.minLength = this.minLen;
-        if (this.maxLen !== undefined)
-            schema.maxLength = this.maxLen;
-        if (this.isEmail)
-            schema.format = 'email';
-        return schema;
-    }
-    toMongoField() {
-        const field = { type: String };
-        if (!this.isOptional)
-            field.required = true;
-        if (this._hasDefault)
-            field.default = this.defaultValue;
-        if (this._isUnique)
-            field.unique = true;
-        if (this._index)
-            field.index = true;
-        if (this.minLen !== undefined)
-            field.minlength = this.minLen;
-        if (this.maxLen !== undefined)
-            field.maxlength = this.maxLen;
-        if (this.regexPattern)
-            field.match = this.regexPattern;
-        return field;
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value !== 'string')
-            return { success: false, errors: [{ path, message: 'Expected string' }] };
-        let typedVal = value;
-        for (const s of this._sanitizers)
-            typedVal = s(typedVal);
-        if (this.minLen !== undefined && typedVal.length < this.minLen)
-            return {
-                success: false,
-                errors: [
-                    {
-                        path,
-                        message: this.minMsg ??
-                            `String must be at least ${this.minLen} characters`,
-                    },
-                ],
-            };
-        if (this.maxLen !== undefined && typedVal.length > this.maxLen)
-            return {
-                success: false,
-                errors: [
-                    {
-                        path,
-                        message: this.maxMsg ?? `String must be at most ${this.maxLen} characters`,
-                    },
-                ],
-            };
-        if (this.isEmail && !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(typedVal))
-            return {
-                success: false,
-                errors: [{ path, message: this.emailMsg ?? 'Invalid email' }],
-            };
-        if (this.regexPattern !== undefined && !this.regexPattern.test(typedVal))
-            return {
-                success: false,
-                errors: [{ path, message: this.regexMsg ?? 'Invalid format' }],
-            };
-        return { success: true, data: typedVal };
-    }
-}
-exports.StringValidator = StringValidator;
-class NumberValidator extends ValidatorType {
-    min(val, message) {
-        this.minVal = val;
-        this.minMsg = message;
-        return this;
-    }
-    max(val, message) {
-        this.maxVal = val;
-        this.maxMsg = message;
-        return this;
-    }
-    toOpenApi() {
-        const schema = { type: 'number' };
-        if (this.minVal !== undefined)
-            schema.minimum = this.minVal;
-        if (this.maxVal !== undefined)
-            schema.maximum = this.maxVal;
-        return schema;
-    }
-    toMongoField() {
-        const field = { type: Number };
-        if (!this.isOptional)
-            field.required = true;
-        if (this._hasDefault)
-            field.default = this.defaultValue;
-        if (this._isUnique)
-            field.unique = true;
-        if (this._index)
-            field.index = true;
-        if (this.minVal !== undefined)
-            field.min = this.minVal;
-        if (this.maxVal !== undefined)
-            field.max = this.maxVal;
-        return field;
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value === 'boolean' ||
-            (typeof value === 'string' && value.trim() === '')) {
-            return { success: false, errors: [{ path, message: 'Expected number' }] };
-        }
-        const num = Number(value);
-        if (isNaN(num))
-            return {
-                success: false,
-                errors: [{ path, message: 'Expected valid number' }],
-            };
-        if (this.minVal !== undefined && num < this.minVal)
-            return {
-                success: false,
-                errors: [
-                    {
-                        path,
-                        message: this.minMsg ?? `Number must be at least ${this.minVal}`,
-                    },
-                ],
-            };
-        if (this.maxVal !== undefined && num > this.maxVal)
-            return {
-                success: false,
-                errors: [
-                    {
-                        path,
-                        message: this.maxMsg ?? `Number must be at most ${this.maxVal}`,
-                    },
-                ],
-            };
-        return { success: true, data: num };
-    }
-}
-exports.NumberValidator = NumberValidator;
-class CoerceNumberValidator extends NumberValidator {
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value === 'boolean' ||
-            (typeof value === 'string' && value.trim() === '')) {
-            return { success: false, errors: [{ path, message: 'Expected number' }] };
-        }
-        const num = Number(value);
-        return super._validate(num, path);
-    }
-}
-exports.CoerceNumberValidator = CoerceNumberValidator;
-class BooleanValidator extends ValidatorType {
-    toOpenApi() {
-        return { type: 'boolean' };
-    }
-    toMongoField() {
-        const field = { type: Boolean };
-        if (!this.isOptional)
-            field.required = true;
-        if (this._hasDefault)
-            field.default = this.defaultValue;
-        return field;
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value === 'boolean') {
-            let typedVal = value;
-            for (const s of this._sanitizers)
-                typedVal = s(typedVal);
-            return { success: true, data: typedVal };
-        }
-        if (value === 'true' || value === '1') {
-            let typedVal = true;
-            for (const s of this._sanitizers)
-                typedVal = s(typedVal);
-            return { success: true, data: typedVal };
-        }
-        if (value === 'false' || value === '0')
-            return { success: true, data: false };
-        return { success: false, errors: [{ path, message: 'Expected boolean' }] };
-    }
-}
-exports.BooleanValidator = BooleanValidator;
-class CoerceBooleanValidator extends BooleanValidator {
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value === 'boolean') {
-            let typedVal = value;
-            for (const s of this._sanitizers)
-                typedVal = s(typedVal);
-            return { success: true, data: typedVal };
-        }
-        if (value === 'true' || value === '1') {
-            let typedVal = true;
-            for (const s of this._sanitizers)
-                typedVal = s(typedVal);
-            return { success: true, data: typedVal };
-        }
-        if (value === 'false' || value === '0')
-            return { success: true, data: false };
-        return { success: false, errors: [{ path, message: 'Expected boolean' }] };
-    }
-}
-exports.CoerceBooleanValidator = CoerceBooleanValidator;
-class ObjectValidator extends ValidatorType {
-    constructor(shape) {
-        super();
-        this.shape = shape;
-        this._keys = Object.keys(shape);
-    }
-    partial() {
-        const newShape = {};
-        for (const key of this._keys) {
-            newShape[key] = this.shape[key].optional();
-        }
-        return new ObjectValidator(newShape);
-    }
-    pick(keys) {
-        const newShape = {};
-        for (const key of keys) {
-            if (key in this.shape) {
-                newShape[key] = this.shape[key];
-            }
-        }
-        return new ObjectValidator(newShape);
-    }
-    omit(keys) {
-        const newShape = {};
-        for (const key of this._keys) {
-            if (!keys.includes(key)) {
-                newShape[key] = this.shape[key];
-            }
-        }
-        return new ObjectValidator(newShape);
-    }
-    toOpenApi() {
-        const properties = {};
-        const required = [];
-        for (const key of this._keys) {
-            const validator = this.shape[key];
-            properties[key] = validator.toOpenApi();
-            if (!validator.isOptional) {
-                required.push(key);
-            }
-        }
-        const schema = {
-            type: 'object',
-            properties,
-        };
-        if (required.length > 0)
-            schema.required = required;
-        return schema;
-    }
-    /**
-     * Converts this tex.object() schema into a Mongoose-compatible schema definition.
-     * Pass the result directly to `new mongoose.Schema()`.
-     *
-     * @example
-     * const UserSchema = tex.object({ name: tex.string(), email: tex.email() })
-     * const User = mongoose.model('User', new mongoose.Schema(UserSchema.toMongoSchema()))
-     */
-    toMongoSchema() {
-        const schemaDef = {};
-        for (const key of this._keys) {
-            const validator = this.shape[key];
-            schemaDef[key] = validator.toMongoField();
-        }
-        return schemaDef;
-    }
-    toMongoField() {
-        // Nested object — return the shape as a sub-document definition
-        const nested = {};
-        for (const key of this._keys) {
-            nested[key] = this.shape[key].toMongoField();
-        }
-        return nested;
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value !== 'object' || Array.isArray(value))
-            return { success: false, errors: [{ path, message: 'Expected object' }] };
-        const errors = [];
-        const data = {};
-        for (const key of this._keys) {
-            const validator = this.shape[key];
-            const fieldPath = path ? `${path}.${key}` : key;
-            const result = validator.validate(value[key], fieldPath);
-            if (result.success) {
-                if (result.data !== undefined)
-                    data[key] = result.data;
-            }
-            else {
-                for (const error of result.errors) {
-                    errors.push(error);
-                }
-            }
-        }
-        if (errors.length > 0)
-            return { success: false, errors };
-        let typedVal = data;
-        for (const s of this._sanitizers)
-            typedVal = s(typedVal);
-        return { success: true, data: typedVal };
-    }
-    async _validateAsync(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value !== 'object' || Array.isArray(value))
-            return { success: false, errors: [{ path, message: 'Expected object' }] };
-        const errors = [];
-        const data = {};
-        await Promise.all(this._keys.map(async (key) => {
-            const validator = this.shape[key];
-            const fieldPath = path ? `${path}.${key}` : key;
-            const result = await validator.validateAsync(value[key], fieldPath);
-            if (result.success) {
-                if (result.data !== undefined)
-                    data[key] = result.data;
-            }
-            else {
-                for (const error of result.errors) {
-                    errors.push(error);
-                }
-            }
-        }));
-        if (errors.length > 0)
-            return { success: false, errors };
-        let typedVal = data;
-        for (const s of this._sanitizers)
-            typedVal = s(typedVal);
-        return { success: true, data: typedVal };
-    }
-}
-exports.ObjectValidator = ObjectValidator;
-class ArrayValidator extends ValidatorType {
-    constructor(schema) {
-        super();
-        this.schema = schema;
-    }
-    min(len, message) {
-        this.minLen = len;
-        this.minMsg = message;
-        return this;
-    }
-    max(len, message) {
-        this.maxLen = len;
-        this.maxMsg = message;
-        return this;
-    }
-    toOpenApi() {
-        const schema = {
-            type: 'array',
-            items: this.schema.toOpenApi(),
-        };
-        if (this.minLen !== undefined)
-            schema.minItems = this.minLen;
-        if (this.maxLen !== undefined)
-            schema.maxItems = this.maxLen;
-        return schema;
-    }
-    toMongoField() {
-        // Return as Mongoose array syntax: [{ type: String }]
-        const innerField = this.schema.toMongoField();
-        return [innerField];
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (!Array.isArray(value))
-            return { success: false, errors: [{ path, message: 'Expected array' }] };
-        if (this.minLen !== undefined && value.length < this.minLen)
-            return {
-                success: false,
-                errors: [
-                    {
-                        path,
-                        message: this.minMsg ?? `Array must have at least ${this.minLen} items`,
-                    },
-                ],
-            };
-        if (this.maxLen !== undefined && value.length > this.maxLen)
-            return {
-                success: false,
-                errors: [
-                    {
-                        path,
-                        message: this.maxMsg ?? `Array must have at most ${this.maxLen} items`,
-                    },
-                ],
-            };
-        const errors = [];
-        const data = [];
-        for (let i = 0; i < value.length; i++) {
-            const res = this.schema.validate(value[i], path ? `${path}[${i}]` : `[${i}]`);
-            if (res.success) {
-                data.push(res.data);
-            }
-            else {
-                for (const error of res.errors) {
-                    errors.push(error);
-                }
-            }
-        }
-        if (errors.length > 0)
-            return { success: false, errors };
-        return { success: true, data: data };
-    }
-}
-exports.ArrayValidator = ArrayValidator;
-class EnumValidator extends ValidatorType {
-    constructor(values) {
-        super();
-        this.values = values;
-    }
-    toOpenApi() {
-        return { type: 'string', enum: this.values };
-    }
-    toMongoField() {
-        const field = {
-            type: String,
-            enum: [...this.values],
-        };
-        if (!this.isOptional)
-            field.required = true;
-        if (this._hasDefault)
-            field.default = this.defaultValue;
-        if (this._isUnique)
-            field.unique = true;
-        if (this._index)
-            field.index = true;
-        return field;
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value !== 'string')
-            return { success: false, errors: [{ path, message: 'Expected string' }] };
-        let typedVal = value;
-        for (const s of this._sanitizers)
-            typedVal = s(typedVal);
-        if (!this.values.includes(typedVal))
-            return {
-                success: false,
-                errors: [
-                    { path, message: `Expected one of: ${this.values.join(', ')}` },
-                ],
-            };
-        return { success: true, data: typedVal };
-    }
-}
-exports.EnumValidator = EnumValidator;
-class LiteralValidator extends ValidatorType {
-    constructor(exact) {
-        super();
-        this.exact = exact;
-    }
-    toOpenApi() {
-        return { type: typeof this.exact, enum: [this.exact] };
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (value !== this.exact)
-            return {
-                success: false,
-                errors: [{ path, message: `Expected literal ${this.exact}` }],
-            };
-        return { success: true, data: value };
-    }
-}
-exports.LiteralValidator = LiteralValidator;
-class UnionValidator extends ValidatorType {
-    constructor(schemas) {
-        super();
-        this.schemas = schemas;
-    }
-    toOpenApi() {
-        return { anyOf: this.schemas.map((s) => s.toOpenApi()) };
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        const errors = [];
-        for (const schema of this.schemas) {
-            const res = schema.validate(value, path);
-            if (res.success)
-                return res;
-            errors.push(...res.errors);
-        }
-        return {
-            success: false,
-            errors: [{ path, message: 'Invalid union value' }],
-        };
-    }
-}
-exports.UnionValidator = UnionValidator;
-class DateValidator extends ValidatorType {
-    toOpenApi() {
-        return { type: 'string', format: 'date-time' };
-    }
-    toMongoField() {
-        const field = { type: Date };
-        if (!this.isOptional)
-            field.required = true;
-        if (this._hasDefault)
-            field.default = this.defaultValue;
-        if (this._index)
-            field.index = true;
-        return field;
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        let date;
-        if (value instanceof Date) {
-            date = value;
-        }
-        else if (typeof value === 'string' || typeof value === 'number') {
-            date = new Date(value);
-        }
-        else {
-            return {
-                success: false,
-                errors: [{ path, message: 'Expected date string or object' }],
-            };
-        }
-        if (isNaN(date.getTime())) {
-            return { success: false, errors: [{ path, message: 'Invalid date' }] };
-        }
-        return { success: true, data: date };
-    }
-}
-exports.DateValidator = DateValidator;
-class RecordValidator extends ValidatorType {
-    constructor(schema) {
-        super();
-        this.schema = schema;
-    }
-    toOpenApi() {
-        return { type: 'object', additionalProperties: this.schema.toOpenApi() };
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        if (typeof value !== 'object' || Array.isArray(value))
-            return { success: false, errors: [{ path, message: 'Expected object' }] };
-        const errors = [];
-        const data = {};
-        for (const key in value) {
-            const fieldPath = path ? `${path}.${key}` : key;
-            const res = this.schema.validate(value[key], fieldPath);
-            if (res.success) {
-                data[key] = res.data;
-            }
-            else {
-                for (const error of res.errors) {
-                    errors.push(error);
-                }
-            }
-        }
-        if (errors.length > 0)
-            return { success: false, errors };
-        return { success: true, data: data };
-    }
-}
-exports.RecordValidator = RecordValidator;
-// ─── Any Validator ─────────────────────────────────────────────────────────────
-class AnyValidator extends ValidatorType {
-    toOpenApi() {
-        return {};
-    }
-    _validate(value) {
-        return { success: true, data: value };
-    }
-}
-exports.AnyValidator = AnyValidator;
-class FileValidator extends ValidatorType {
-    maxSize(bytes) {
-        this._maxSize = bytes;
-        return this;
-    }
-    mimeTypes(types) {
-        this._mimeTypes = types;
-        return this;
-    }
-    toOpenApi() {
-        return { type: 'string', format: 'binary' };
-    }
-    _validate(value, path) {
-        if (value === undefined || value === null) {
-            if (this.isOptional)
-                return { success: true, data: undefined };
-            return { success: false, errors: [{ path, message: 'Required' }] };
-        }
-        // We expect the busboy parsed object: { filename, mimeType, buffer }
-        if (typeof value === 'object' &&
-            value !== null &&
-            'buffer' in value &&
-            Buffer.isBuffer(value.buffer)) {
-            const file = value;
-            if (this._maxSize && file.buffer.length > this._maxSize) {
-                return {
-                    success: false,
-                    errors: [
-                        { path, message: `File size exceeds ${this._maxSize} bytes` },
-                    ],
-                };
-            }
-            if (this._mimeTypes && !this._mimeTypes.includes(file.mimeType)) {
-                return {
-                    success: false,
-                    errors: [
-                        {
-                            path,
-                            message: `Invalid mime type. Expected one of: ${this._mimeTypes.join(', ')}`,
-                        },
-                    ],
-                };
-            }
-            return { success: true, data: file };
-        }
-        return { success: false, errors: [{ path, message: 'Expected file' }] };
-    }
-}
-exports.FileValidator = FileValidator;
-/**
- * @deprecated The `v` validation engine is deprecated in favor of the new string-based `@exisjs/tex` validation engine.
- * Please migrate to `tex.type({ ... })` for native Rust-powered validation.
- */
-exports.v = {
-    string: () => new StringValidator(),
-    number: () => new NumberValidator(),
-    boolean: () => new BooleanValidator(),
-    object: (shape) => new ObjectValidator(shape),
-    array: (schema) => new ArrayValidator(schema),
-    enum: (values) => new EnumValidator(values),
-    literal: (exact) => new LiteralValidator(exact),
-    union: (schemas) => new UnionValidator(schemas),
-    date: () => new DateValidator(),
-    record: (schema) => new RecordValidator(schema),
-    any: () => new AnyValidator(),
-    file: () => new FileValidator(),
-    env: (schema) => {
-        // Skip validation during build phase — env vars aren't available at build time
-        if (process.env.__EXIS_BUILD === 'true') {
-            return new Proxy({}, {
-                get: (_target, prop) => process.env[prop],
-            });
-        }
-        const result = schema.validate(process.env, 'process.env');
-        if (!result.success) {
-            const messages = result.errors
-                .map((e) => `  - ${e.path.replace('process.env.', '')}: ${e.message}`)
-                .join('\n');
-            console.error(`\x1b[31m Environment Validation Failed:\x1b[0m\n${messages}`);
-            process.exit(1);
-        }
-        return result.data;
-    },
-    coerce: {
-        number: () => new CoerceNumberValidator(),
-        boolean: () => new CoerceBooleanValidator(),
-    },
-};
-//# sourceMappingURL=validator.js.map