exisjs 0.7.13 → 0.8.0

package/dist/validator/engine.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TexDiscriminatedUnionEngine = exports.TexTransformedEngine = exports.TexEngine = void 0;
-const rs_1 = require("@exisjs/rs");
+const compile_1 = require("./compile");
 const tex_types_1 = require("./tex-types");
 const error_1 = require("./error");
 class TexEngine {
@@ -11,7 +11,7 @@ class TexEngine {
         this.rawSchema = rawSchema;
         this.strict = strict;
         this._isOptional = isOptional;
-        this.validator = new rs_1.TexValidator(schema, strict);
+        this.validator = (0, compile_1.compileSchema)(schema, strict);
     }
     getCompiledSchema() {
         return this.schema;
@@ -89,250 +89,19 @@ class TexEngine {
         return new TexEngine(newSchema, newRaw, this.strict, this._isOptional);
     }
     parse(data) {
-        // 1. Apply defaults and run pre-validation sanitizers on the raw payload (if it's an object)
+        const plan = this._plan || (this._plan = splitPlan(buildPlan(this.rawSchema)));
+        const coerceScalars = Boolean(this._isQueryOrParam);
+        // 1. Defaults, empty-string handling, coercion and sanitizers. Only
+        // fields that need any of it are visited.
         if (data && typeof data === 'object') {
-            for (const [key, val] of Object.entries(this.rawSchema)) {
-                // Apply default value / lazy factory function if field is omitted or undefined
-                if (data[key] === undefined) {
-                    if (val instanceof tex_types_1.TexType && val.defaultValue !== undefined) {
-                        data[key] =
-                            typeof val.defaultValue === 'function'
-                                ? val.defaultValue()
-                                : val.defaultValue;
-                    }
-                }
-                if (typeof data[key] === 'string' && data[key].trim() === '') {
-                    const raw = val instanceof tex_types_1.TexType ? val._raw : String(val);
-                    if (raw.includes('optional') ||
-                        raw.includes('nullable') ||
-                        raw.includes('nullish') ||
-                        raw.includes('?') ||
-                        val?._isOptional) {
-                        if (raw.includes('nullable') &&
-                            !raw.includes('optional') &&
-                            !raw.includes('nullish')) {
-                            data[key] = null;
-                        }
-                        else {
-                            delete data[key];
-                            // If deleted but default is defined, apply default
-                            if (val instanceof tex_types_1.TexType && val.defaultValue !== undefined) {
-                                data[key] =
-                                    typeof val.defaultValue === 'function'
-                                        ? val.defaultValue()
-                                        : val.defaultValue;
-                            }
-                        }
-                    }
-                }
-                if (data[key] !== undefined && data[key] !== null) {
-                    if (val instanceof tex_types_1.TexType && val._raw.startsWith('date')) {
-                        if (val._raw.includes('coerce')) {
-                            if (typeof data[key] === 'string' ||
-                                typeof data[key] === 'number') {
-                                const d = new Date(data[key]);
-                                if (isNaN(d.getTime())) {
-                                    throw new error_1.ValidatorError([
-                                        {
-                                            path: key,
-                                            message: 'Must be a valid date',
-                                            expected: 'valid date string or timestamp',
-                                            received: (0, error_1.formatReceivedValue)(data[key]),
-                                            code: 'INVALID_DATE',
-                                        },
-                                    ]);
-                                }
-                                data[key] = d;
-                            }
-                        }
-                        if (!(data[key] instanceof Date) &&
-                            typeof data[key] !== 'string' &&
-                            typeof data[key] !== 'number') {
-                            throw new error_1.ValidatorError([
-                                {
-                                    path: key,
-                                    message: 'Must be a valid date',
-                                    expected: 'valid date or date string',
-                                    received: (0, error_1.formatReceivedValue)(data[key]),
-                                    code: 'INVALID_TYPE',
-                                },
-                            ]);
-                        }
-                        if (data[key] instanceof Date && isNaN(data[key].getTime())) {
-                            throw new error_1.ValidatorError([
-                                {
-                                    path: key,
-                                    message: 'Must be a valid date',
-                                    expected: 'valid date string or timestamp',
-                                    received: (0, error_1.formatReceivedValue)(data[key]),
-                                    code: 'INVALID_DATE',
-                                },
-                            ]);
-                        }
-                        if (val._raw.includes('minDate:')) {
-                            const minStr = val._raw.match(/minDate:([^\s|]+)/)?.[1];
-                            if (minStr &&
-                                new Date(data[key]).getTime() < new Date(minStr).getTime()) {
-                                throw new error_1.ValidatorError([
-                                    {
-                                        path: key,
-                                        message: `Date must be after ${minStr}`,
-                                        expected: `>= ${minStr}`,
-                                        received: (0, error_1.formatReceivedValue)(data[key]),
-                                        code: 'DATE_TOO_EARLY',
-                                    },
-                                ]);
-                            }
-                        }
-                        if (val._raw.includes('maxDate:')) {
-                            const maxStr = val._raw.match(/maxDate:([^\s|]+)/)?.[1];
-                            if (maxStr &&
-                                new Date(data[key]).getTime() > new Date(maxStr).getTime()) {
-                                throw new error_1.ValidatorError([
-                                    {
-                                        path: key,
-                                        message: `Date must be before ${maxStr}`,
-                                        expected: `<= ${maxStr}`,
-                                        received: (0, error_1.formatReceivedValue)(data[key]),
-                                        code: 'DATE_TOO_LATE',
-                                    },
-                                ]);
-                            }
-                        }
-                    }
-                    if (val instanceof tex_types_1.TexType && val._raw.startsWith('string')) {
-                        if (val._raw.includes('coerce') && typeof data[key] !== 'string') {
-                            data[key] = String(data[key]);
-                        }
-                    }
-                    if (val instanceof tex_types_1.TexType && val._raw.startsWith('number')) {
-                        if (val._raw.includes('coerce') || this._isQueryOrParam) {
-                            if (typeof data[key] === 'string' && data[key].trim() !== '') {
-                                const n = Number(data[key]);
-                                if (!isNaN(n)) {
-                                    data[key] = n;
-                                }
-                                else {
-                                    throw new error_1.ValidatorError([
-                                        {
-                                            path: key,
-                                            message: 'Must be a number',
-                                            expected: 'number',
-                                            received: (0, error_1.formatReceivedValue)(data[key]),
-                                            code: 'INVALID_TYPE',
-                                        },
-                                    ]);
-                                }
-                            }
-                        }
-                    }
-                    if (val instanceof tex_types_1.TexType && val._raw.startsWith('boolean')) {
-                        if (val._raw.includes('coerce') || this._isQueryOrParam) {
-                            if (typeof data[key] === 'string' && data[key].trim() !== '') {
-                                const lower = data[key].toLowerCase().trim();
-                                if (lower === 'true' || lower === '1') {
-                                    data[key] = true;
-                                }
-                                else if (lower === 'false' || lower === '0') {
-                                    data[key] = false;
-                                }
-                                else {
-                                    throw new error_1.ValidatorError([
-                                        {
-                                            path: key,
-                                            message: 'Must be a boolean',
-                                            expected: 'boolean (true or false)',
-                                            received: (0, error_1.formatReceivedValue)(data[key]),
-                                            code: 'INVALID_TYPE',
-                                        },
-                                    ]);
-                                }
-                            }
-                        }
-                    }
-                    if (val instanceof tex_types_1.TexType &&
-                        val._raw.startsWith('array<') &&
-                        val._raw.includes('coerce')) {
-                        if (!Array.isArray(data[key])) {
-                            if (typeof data[key] === 'string') {
-                                const parts = data[key].includes(',')
-                                    ? data[key].split(',').map((s) => s.trim())
-                                    : [data[key]];
-                                if (val._raw.startsWith('array<number')) {
-                                    data[key] = parts.map((p) => {
-                                        const n = Number(p);
-                                        return isNaN(n) ? p : n;
-                                    });
-                                }
-                                else if (val._raw.startsWith('array<boolean')) {
-                                    data[key] = parts.map((p) => {
-                                        if (p.toLowerCase() === 'true')
-                                            return true;
-                                        if (p.toLowerCase() === 'false')
-                                            return false;
-                                        return p;
-                                    });
-                                }
-                                else {
-                                    data[key] = parts;
-                                }
-                            }
-                            else {
-                                data[key] = [data[key]];
-                            }
-                        }
-                        else {
-                            if (val._raw.startsWith('array<number')) {
-                                data[key] = data[key].map((item) => {
-                                    if (typeof item === 'string') {
-                                        const n = Number(item);
-                                        return isNaN(n) ? item : n;
-                                    }
-                                    return item;
-                                });
-                            }
-                            else if (val._raw.startsWith('array<boolean')) {
-                                data[key] = data[key].map((item) => {
-                                    if (typeof item === 'string') {
-                                        if (item.toLowerCase() === 'true')
-                                            return true;
-                                        if (item.toLowerCase() === 'false')
-                                            return false;
-                                    }
-                                    return item;
-                                });
-                            }
-                        }
-                    }
-                    if (val instanceof tex_types_1.TexType && val.sanitizers.length > 0) {
-                        for (const s of val.sanitizers) {
-                            if (data[key] === undefined || data[key] === null)
-                                break;
-                            data[key] = s(data[key]);
-                        }
-                    }
-                    const itemSchema = val?._item;
-                    if (itemSchema && Array.isArray(data[key])) {
-                        if (itemSchema instanceof tex_types_1.TexType &&
-                            itemSchema.sanitizers.length > 0) {
-                            for (let i = 0; i < data[key].length; i++) {
-                                if (data[key][i] !== undefined && data[key][i] !== null) {
-                                    for (const s of itemSchema.sanitizers) {
-                                        if (data[key][i] === undefined || data[key][i] === null)
-                                            break;
-                                        data[key][i] = s(data[key][i]);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+            const prep = coerceScalars ? plan.prepQuery : plan.prep;
+            for (const f of prep)
+                prepareField(data, f, coerceScalars);
         }
-        // 2. Rust Validation
+        // 2. Type validation (compiled once per schema)
         let parsedData;
         try {
-            parsedData = this.validator.parse(data);
+            parsedData = this.validator(data);
         }
         catch (err) {
             if (data === process.env &&
@@ -451,88 +220,33 @@ class TexEngine {
             const received = (0, error_1.formatReceivedValue)(receivedRaw);
             throw new error_1.ValidatorError([{ path, message, expected, received, code }]);
         }
-        // Preserve Date objects and ensure defaults are applied
-        if (parsedData && typeof parsedData === 'object') {
-            for (const [key, val] of Object.entries(this.rawSchema)) {
+        if (parsedData && typeof parsedData === 'object' && plan.post.length > 0) {
+            const errors = [];
+            for (const f of plan.post) {
+                const key = f.key;
+                // Preserve Date objects and ensure defaults are applied
                 if (parsedData[key] === undefined &&
-                    val instanceof tex_types_1.TexType &&
-                    val.defaultValue !== undefined) {
-                    parsedData[key] =
-                        typeof val.defaultValue === 'function'
-                            ? val.defaultValue()
-                            : val.defaultValue;
+                    f.tex?.defaultValue !== undefined) {
+                    parsedData[key] = resolveDefault(f.tex.defaultValue);
                 }
-                if (val instanceof tex_types_1.TexType &&
-                    val._raw.startsWith('date') &&
-                    data &&
-                    data[key] instanceof Date) {
+                if (f.isDate && data && data[key] instanceof Date) {
                     parsedData[key] = data[key];
                 }
-            }
-        }
-        // 3. Post-validation synchronous refinements
-        const errors = [];
-        if (parsedData && typeof parsedData === 'object') {
-            for (const [key, val] of Object.entries(this.rawSchema)) {
-                if (parsedData[key] !== undefined) {
-                    const isNullableField = val instanceof tex_types_1.TexType &&
-                        (val._raw.includes('nullable') || val._raw.includes('nullish'));
-                    if (parsedData[key] === null && isNullableField) {
-                        continue;
-                    }
-                    if (val instanceof tex_types_1.TexType && val.refinements.length > 0) {
-                        for (const r of val.refinements) {
-                            if (!r.async && !r.fn(parsedData[key])) {
-                                const msg = typeof r.message === 'function'
-                                    ? r.message(parsedData[key])
-                                    : r.message || 'Invalid value';
-                                errors.push({
-                                    path: key,
-                                    message: msg,
-                                    expected: 'custom refinement rule',
-                                    received: (0, error_1.formatReceivedValue)(parsedData[key]),
-                                    code: 'CUSTOM_VALIDATION',
-                                });
-                            }
-                        }
-                    }
-                    const itemSchema = val?._item;
-                    if (itemSchema && Array.isArray(parsedData[key])) {
-                        if (itemSchema instanceof tex_types_1.TexType &&
-                            itemSchema.refinements.length > 0) {
-                            const isItemNullable = itemSchema._raw.includes('nullable') ||
-                                itemSchema._raw.includes('nullish');
-                            for (let i = 0; i < parsedData[key].length; i++) {
-                                if (parsedData[key][i] === null && isItemNullable)
-                                    continue;
-                                for (const r of itemSchema.refinements) {
-                                    if (!r.async && !r.fn(parsedData[key][i])) {
-                                        const msg = typeof r.message === 'function'
-                                            ? r.message(parsedData[key][i])
-                                            : r.message || 'Invalid value';
-                                        errors.push({
-                                            path: `${key}[${i}]`,
-                                            message: msg,
-                                            expected: 'custom refinement rule',
-                                            received: (0, error_1.formatReceivedValue)(parsedData[key][i]),
-                                            code: 'CUSTOM_VALIDATION',
-                                        });
-                                    }
-                                }
-                            }
-                        }
+                // 3. Post-validation synchronous refinements
+                if (f.hasRefinements && parsedData[key] !== undefined) {
+                    if (!(parsedData[key] === null && f.isNullable)) {
+                        runSyncRefinements(f, parsedData[key], errors);
                     }
                 }
             }
-        }
-        if (errors.length > 0)
-            throw new error_1.ValidatorError(errors);
-        // 4. Post-validation field transformations
-        if (parsedData && typeof parsedData === 'object') {
-            for (const [key, val] of Object.entries(this.rawSchema)) {
-                if (parsedData[key] !== undefined) {
-                    if (val instanceof tex_types_1.TexType && val.transformations.length > 0) {
-                        for (const t of val.transformations) {
+            if (errors.length > 0)
+                throw new error_1.ValidatorError(errors);
+            // 4. Post-validation field transformations
+            for (const f of plan.post) {
+                if (f.tex && f.tex.transformations.length > 0) {
+                    const key = f.key;
+                    if (parsedData[key] !== undefined) {
+                        for (const t of f.tex.transformations) {
                             parsedData[key] = t(parsedData[key]);
                         }
                     }
@@ -807,4 +521,258 @@ class TexDiscriminatedUnionEngine {
     }
 }
 exports.TexDiscriminatedUnionEngine = TexDiscriminatedUnionEngine;
+function needsPrep(f, coerceScalars) {
+    return (f.tex?.defaultValue !== undefined ||
+        f.emptyString !== 'keep' ||
+        f.isDate ||
+        f.stringCoerce ||
+        f.number === 'coerce' ||
+        f.boolean === 'coerce' ||
+        (coerceScalars && (f.number === 'query' || f.boolean === 'query')) ||
+        f.array !== 'no' ||
+        (f.tex !== null && f.tex.sanitizers.length > 0) ||
+        (f.item !== null && f.item.sanitizers.length > 0));
+}
+function splitPlan(plan) {
+    return {
+        prep: plan.filter((f) => needsPrep(f, false)),
+        prepQuery: plan.filter((f) => needsPrep(f, true)),
+        post: plan.filter((f) => f.tex?.defaultValue !== undefined ||
+            f.isDate ||
+            f.hasRefinements ||
+            (f.tex !== null && f.tex.transformations.length > 0)),
+    };
+}
+function scalarMode(plain, raw, type, coerce) {
+    if (!plain || !raw.startsWith(type))
+        return 'no';
+    return coerce ? 'coerce' : 'query';
+}
+function arrayMode(plain, raw, coerce) {
+    if (!plain || !coerce || !raw.startsWith('array<'))
+        return 'no';
+    if (raw.startsWith('array<number'))
+        return 'number';
+    if (raw.startsWith('array<boolean'))
+        return 'boolean';
+    return 'other';
+}
+function buildPlan(rawSchema) {
+    const plan = [];
+    for (const key of Object.keys(rawSchema)) {
+        const val = rawSchema[key];
+        const tex = val instanceof tex_types_1.TexType ? val : null;
+        const raw = tex ? tex._raw : String(val);
+        // Unions coerce per alternative inside the compiled rule
+        const plain = tex !== null && !raw.includes('||');
+        const coerce = raw.includes('coerce');
+        const nullable = raw.includes('nullable');
+        const nullish = raw.includes('nullish');
+        const optional = raw.includes('optional');
+        let emptyString = 'keep';
+        if (optional ||
+            nullable ||
+            nullish ||
+            raw.includes('?') ||
+            val?._isOptional) {
+            emptyString = nullable && !optional && !nullish ? 'null' : 'delete';
+        }
+        const item = val?._item instanceof tex_types_1.TexType ? val._item : null;
+        const isDate = plain && raw.startsWith('date');
+        plan.push({
+            key,
+            tex,
+            emptyString,
+            isDate,
+            dateCoerce: isDate && coerce,
+            minDate: isDate ? raw.match(/minDate:([^\s|]+)/)?.[1] : undefined,
+            maxDate: isDate ? raw.match(/maxDate:([^\s|]+)/)?.[1] : undefined,
+            stringCoerce: plain && coerce && raw.startsWith('string'),
+            number: scalarMode(plain, raw, 'number', coerce),
+            boolean: scalarMode(plain, raw, 'boolean', coerce),
+            array: arrayMode(plain, raw, coerce),
+            item,
+            isNullable: tex !== null && (nullable || nullish),
+            hasRefinements: (tex !== null && tex.refinements.length > 0) ||
+                (item !== null && item.refinements.length > 0),
+        });
+    }
+    return plan;
+}
+function resolveDefault(defaultValue) {
+    return typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+}
+function fieldError(key, value, message, expected, code) {
+    throw new error_1.ValidatorError([
+        {
+            path: key,
+            message,
+            expected,
+            received: (0, error_1.formatReceivedValue)(value),
+            code,
+        },
+    ]);
+}
+function prepareDate(key, value, f) {
+    if (f.dateCoerce &&
+        (typeof value === 'string' || typeof value === 'number')) {
+        const d = new Date(value);
+        if (isNaN(d.getTime())) {
+            fieldError(key, value, 'Must be a valid date', 'valid date string or timestamp', 'INVALID_DATE');
+        }
+        value = d;
+    }
+    if (!(value instanceof Date) &&
+        typeof value !== 'string' &&
+        typeof value !== 'number') {
+        fieldError(key, value, 'Must be a valid date', 'valid date or date string', 'INVALID_TYPE');
+    }
+    if (value instanceof Date && isNaN(value.getTime())) {
+        fieldError(key, value, 'Must be a valid date', 'valid date string or timestamp', 'INVALID_DATE');
+    }
+    const time = new Date(value).getTime();
+    if (f.minDate && time < new Date(f.minDate).getTime()) {
+        fieldError(key, value, `Date must be after ${f.minDate}`, `>= ${f.minDate}`, 'DATE_TOO_EARLY');
+    }
+    if (f.maxDate && time > new Date(f.maxDate).getTime()) {
+        fieldError(key, value, `Date must be before ${f.maxDate}`, `<= ${f.maxDate}`, 'DATE_TOO_LATE');
+    }
+    return value;
+}
+function prepareField(data, f, coerceScalars) {
+    const key = f.key;
+    const tex = f.tex;
+    // Apply default value / lazy factory function if field is omitted
+    if (data[key] === undefined && tex?.defaultValue !== undefined) {
+        data[key] = resolveDefault(tex.defaultValue);
+    }
+    if (f.emptyString !== 'keep' &&
+        typeof data[key] === 'string' &&
+        data[key].trim() === '') {
+        if (f.emptyString === 'null') {
+            data[key] = null;
+        }
+        else {
+            delete data[key];
+            if (tex?.defaultValue !== undefined) {
+                data[key] = resolveDefault(tex.defaultValue);
+            }
+        }
+    }
+    let value = data[key];
+    if (value === undefined || value === null)
+        return;
+    if (f.isDate)
+        data[key] = value = prepareDate(key, value, f);
+    if (f.stringCoerce && typeof value !== 'string') {
+        data[key] = value = String(value);
+    }
+    if ((f.number === 'coerce' || (f.number === 'query' && coerceScalars)) &&
+        typeof value === 'string' &&
+        value.trim() !== '') {
+        const n = Number(value);
+        if (isNaN(n))
+            fieldError(key, value, 'Must be a number', 'number', 'INVALID_TYPE');
+        data[key] = value = n;
+    }
+    if ((f.boolean === 'coerce' || (f.boolean === 'query' && coerceScalars)) &&
+        typeof value === 'string' &&
+        value.trim() !== '') {
+        const lower = value.toLowerCase().trim();
+        if (lower === 'true' || lower === '1')
+            data[key] = value = true;
+        else if (lower === 'false' || lower === '0')
+            data[key] = value = false;
+        else {
+            fieldError(key, value, 'Must be a boolean', 'boolean (true or false)', 'INVALID_TYPE');
+        }
+    }
+    if (f.array !== 'no')
+        data[key] = coerceArray(value, f.array);
+    if (tex !== null && tex.sanitizers.length > 0) {
+        for (const s of tex.sanitizers) {
+            if (data[key] === undefined || data[key] === null)
+                break;
+            data[key] = s(data[key]);
+        }
+    }
+    const item = f.item;
+    if (item !== null && item.sanitizers.length > 0 && Array.isArray(data[key])) {
+        const arr = data[key];
+        for (let i = 0; i < arr.length; i++) {
+            for (const s of item.sanitizers) {
+                if (arr[i] === undefined || arr[i] === null)
+                    break;
+                arr[i] = s(arr[i]);
+            }
+        }
+    }
+}
+function coerceItem(item, kind) {
+    if (typeof item !== 'string')
+        return item;
+    if (kind === 'number') {
+        const n = Number(item);
+        return isNaN(n) ? item : n;
+    }
+    if (kind === 'boolean') {
+        const lower = item.toLowerCase();
+        if (lower === 'true')
+            return true;
+        if (lower === 'false')
+            return false;
+    }
+    return item;
+}
+function coerceArray(value, kind) {
+    if (!Array.isArray(value)) {
+        if (typeof value !== 'string')
+            return [value];
+        const parts = value.includes(',')
+            ? value.split(',').map((s) => s.trim())
+            : [value];
+        return kind === 'other' ? parts : parts.map((p) => coerceItem(p, kind));
+    }
+    return kind === 'other' ? value : value.map((v) => coerceItem(v, kind));
+}
+function refinementMessage(r, value) {
+    return typeof r.message === 'function'
+        ? r.message(value)
+        : r.message || 'Invalid value';
+}
+function runSyncRefinements(f, value, errors) {
+    if (f.tex !== null) {
+        for (const r of f.tex.refinements) {
+            if (!r.async && !r.fn(value)) {
+                errors.push({
+                    path: f.key,
+                    message: refinementMessage(r, value),
+                    expected: 'custom refinement rule',
+                    received: (0, error_1.formatReceivedValue)(value),
+                    code: 'CUSTOM_VALIDATION',
+                });
+            }
+        }
+    }
+    const item = f.item;
+    if (item === null || item.refinements.length === 0 || !Array.isArray(value)) {
+        return;
+    }
+    const itemNullable = item._raw.includes('nullable') || item._raw.includes('nullish');
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === null && itemNullable)
+            continue;
+        for (const r of item.refinements) {
+            if (!r.async && !r.fn(value[i])) {
+                errors.push({
+                    path: `${f.key}[${i}]`,
+                    message: refinementMessage(r, value[i]),
+                    expected: 'custom refinement rule',
+                    received: (0, error_1.formatReceivedValue)(value[i]),
+                    code: 'CUSTOM_VALIDATION',
+                });
+            }
+        }
+    }
+}
 //# sourceMappingURL=engine.js.map