exisjs 0.1.2

package/dist/utils/validator.js

@@ -0,0 +1,719 @@
+"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.BooleanValidator = 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;
+    }
+    optional() {
+        this.isOptional = true;
+        return this;
+    }
+    default(val) {
+        this.isOptional = true;
+        this._hasDefault = true;
+        this.defaultValue = val;
+        return this;
+    }
+    refine(check, message = 'Invalid value') {
+        return new RefineValidator(this, check, message);
+    }
+    transform(fn) {
+        return new TransformValidator(this, fn);
+    }
+    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;
+    }
+    _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' }] };
+        if (this.minLen !== undefined && value.length < this.minLen)
+            return {
+                success: false,
+                errors: [
+                    {
+                        path,
+                        message: this.minMsg ??
+                            `String must be at least ${this.minLen} characters`,
+                    },
+                ],
+            };
+        if (this.maxLen !== undefined && value.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(value))
+            return {
+                success: false,
+                errors: [{ path, message: this.emailMsg ?? 'Invalid email' }],
+            };
+        if (this.regexPattern !== undefined && !this.regexPattern.test(value))
+            return {
+                success: false,
+                errors: [{ path, message: this.regexMsg ?? 'Invalid format' }],
+            };
+        return { success: true, data: value };
+    }
+}
+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;
+    }
+    _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 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 BooleanValidator extends ValidatorType {
+    toOpenApi() {
+        return { type: 'boolean' };
+    }
+    _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')
+            return { success: true, data: value };
+        if (value === 'true' || value === '1')
+            return { success: true, data: true };
+        if (value === 'false' || value === '0')
+            return { success: true, data: false };
+        return { success: false, errors: [{ path, message: 'Expected boolean' }] };
+    }
+}
+exports.BooleanValidator = BooleanValidator;
+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;
+    }
+    _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 };
+        return { success: true, data: data };
+    }
+    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 };
+        return { success: true, data: data };
+    }
+}
+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;
+    }
+    _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 };
+    }
+    _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' }] };
+        if (!this.values.includes(value))
+            return {
+                success: false,
+                errors: [
+                    { path, message: `Expected one of: ${this.values.join(', ')}` },
+                ],
+            };
+        return { success: true, data: value };
+    }
+}
+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' };
+    }
+    _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;
+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) => {
+        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;
+    },
+};
+//# sourceMappingURL=validator.js.map