@webergency-utils/typechecker 0.2.2 → 0.2.3

package/README.md

@@ -224,6 +224,10 @@ Generates a raw JSON Schema draft-07 object matching type `T` at compile time.
 
 Validates `input` against a **runtime JSON Schema** value (not a TypeScript generic).
 
+Only the documented schema subset is compiled. Recognized validation keywords that are not implemented
+(for example `enum`, `oneOf`, and `not`) throw during schema compilation instead of silently accepting data.
+Schema `pattern` values are rejected when they exceed the safety limit or contain common catastrophic-backtracking constructs.
+
 - **Parameters**:
   - `schema`: JSON Schema object.
   - `input`: The value to validate.
@@ -252,6 +256,8 @@ Like `assertGuard`, but against a JSON Schema value. Root replacement throws.
 #### `convertPropertyCasing<T, C extends CasingFormat>(obj: T, casing: C, options?: ConvertCasingOptions): ConvertPropertyCasing<T, C>`
 
 Recursively converts all property keys of an object to the specified casing format.
+If two source keys normalize to the same output key, conversion throws instead of silently discarding a value.
+Special keys such as `__proto__` are preserved as own data properties without changing the result prototype.
 
 - **Parameters**:
   - `obj`: The source object.
@@ -339,7 +345,7 @@ Extends `GuardOptions` for `validate` / `validateSchema` (adds `mutate`; no `err
 | :--- | :--- | :--- | :--- |
 | `mode` | `ValidationMode` | `'strict'` | Unknown-key policy (`strict` / `relaxed` / `strip`). Not coercion — see `ValidationMode` above. |
 | `from` | `'json' \| 'query' \| ((val, ctx) => any)` | `undefined` | Input conversion mode. `'json'` revives JSON-impossible types. `'query'` also coerces querystring shapes. A custom function is `(val, { key, path, parent, root, index?, kind }) => any` and runs only on type mismatch. `kind` is a `CoercionKind` dispatch tag (not `typeof` / a TS type). `key` is the nearest named path segment (for `[n]` leaves, the closest named key above). |
-| `mutate` | `boolean` | `false` | `true`: always write onto the input. `false`: always allocate new containers. |
+| `mutate` | `boolean` | `false` | `true`: write in place while validating (half-changed input on failure is allowed; union arms still use a side tree). `false`: always allocate new containers. |
 
 #### `interface AssertOptions`
 
@@ -360,7 +366,7 @@ Extends `ValidationOptions` for `assert` / `assertSchema`.
 Result object returned by `validate`.
 
 - `success`: `boolean`
-- `data?`: `T`
+- `data?`: `T` — present only when `success` is `true`
 - `errors?`: `IValidationError[]`
 
 #### `interface IValidationError`
@@ -443,7 +449,7 @@ Sanitizes and converts input values during validation.
 - `transform.LowerCase`: Converts string to lowercase.
 - `transform.UpperCase`: Converts string to uppercase.
 - `transform.Capitalize`: Capitalizes the first letter.
-- `transform.ToNumber`: Same coercion as `from: 'query'` for numbers (non-empty numeric strings → `parseFloat`).
+- `transform.ToNumber`: Same coercion as `from: 'query'` for numbers. The entire trimmed string must be a finite decimal/scientific number; partial strings, hexadecimal syntax, `NaN`, and infinities are rejected.
 - `transform.ToBoolean`: Same coercion as `from: 'query'` for booleans (`true`/`false`/`1`/`0`/`yes`/`no`/`on`/`off`); unknown values are left unchanged and fail the boolean check.
 - `transform.ToDate`: Same coercion as `from: 'query'` for dates (parseable strings and finite timestamps).
 - `transform.Custom<Fn>`: Custom mapping function: `(val) => any`.

package/dist/engine/generators.js

@@ -76,7 +76,7 @@ export function createConstrainedPrimitiveCheck(baseType, constraints, requiredU
             return `validators.multipleOf(v, path, ctx, ${valStr}${msgArg})`;
         }
         if (c.type === 'pattern') {
-            return `validators.pattern(v, path, ctx, new RegExp(${JSON.stringify(c.value)}), ${JSON.stringify('Pattern<' + c.value + '>')}${msgArg})`;
+            return `validators.pattern(v, path, ctx, validators.safeRegExp(${JSON.stringify(c.value)}), ${JSON.stringify('Pattern<' + c.value + '>')}${msgArg})`;
         }
         if (c.type === 'format') {
             return `v = validators.format(v, path, ctx, ${JSON.stringify(c.value)}${msgArg})`;
@@ -171,7 +171,7 @@ export function createArrayCheck(elementValidator, requiredUtils) {
 }
 export function createTemplateLiteralCheck(regexStr, expected, requiredUtils) {
     requiredUtils.add('validators');
-    const tpl = `(v, path, ctx) => validators.templateLiteral(v, path, ctx, new RegExp(${JSON.stringify(regexStr)}), ${JSON.stringify(expected)})`;
+    const tpl = `(v, path, ctx) => validators.templateLiteral(v, path, ctx, validators.safeRegExp(${JSON.stringify(regexStr)}), ${JSON.stringify(expected)})`;
     return stripPositions(templateToAst(tpl));
 }
 export function createUnionCheck(checks, requiredUtils, expected = 'Type<Union>') {
@@ -196,6 +196,7 @@ export function createObjectCheck(props, requiredUtils, expected = 'object', ind
         p.validator
     ]));
     const allowedKeys = props.map(p => ts.factory.createStringLiteral(p.name));
+    const allowedKeySet = ts.factory.createNewExpression(ts.factory.createIdentifier('Set'), undefined, [ts.factory.createArrayLiteralExpression(allowedKeys)]);
     if (indexValidator) {
         const tpl = `
         (v, path, ctx) => {
@@ -208,7 +209,7 @@ export function createObjectCheck(props, requiredUtils, expected = 'object', ind
         }
         `;
         return injectNodes(templateToAst(tpl), {
-            '__KEYS__': ts.factory.createArrayLiteralExpression(allowedKeys),
+            '__KEYS__': allowedKeySet,
             '__EXPECTED__': ts.factory.createStringLiteral(expected),
             '__PROPS__': ts.factory.createArrayLiteralExpression(propDefinitions, true),
             '__INDEX__': indexValidator
@@ -225,7 +226,7 @@ export function createObjectCheck(props, requiredUtils, expected = 'object', ind
     }
     `;
     return injectNodes(templateToAst(tpl), {
-        '__KEYS__': ts.factory.createArrayLiteralExpression(allowedKeys),
+        '__KEYS__': allowedKeySet,
         '__EXPECTED__': ts.factory.createStringLiteral(expected),
         '__PROPS__': ts.factory.createArrayLiteralExpression(propDefinitions, true)
     });
@@ -266,7 +267,7 @@ export function createIntersectionCheck(checks, requiredUtils) {
         let data = validators.objectShell(v, ctx);
         for (let i = 0; i < checks.length; i++) {
             const val = checks[i](v, path, ctx);
-            if (typeof val === "object" && val !== null && !Array.isArray(val) && typeof data === "object" && data !== null && !Array.isArray(data)) Object.assign(data, val);
+            if (typeof val === "object" && val !== null && !Array.isArray(val) && typeof data === "object" && data !== null && !Array.isArray(data)) validators.assign(data, val);
             else data = val;
         }
         return data;

package/dist/engine/hoister.js

@@ -1,39 +1,43 @@
 import ts from '../ts.js';
 export function hoistRegistrations(sourceFile, cache, requiredUtils, schemasMap) {
-    if (cache.size === 0 && requiredUtils.size === 0) {
+    const hasSchemas = !!(schemasMap && schemasMap.size > 0);
+    if (cache.size === 0 && requiredUtils.size === 0 && !hasSchemas) {
         return sourceFile;
     }
+    const declaredNames = collectDeclaredNames(sourceFile.statements);
     const utilityStatements = [
         // 1. import "@webergency-utils/typechecker/runtime";
         ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createStringLiteral('@webergency-utils/typechecker/runtime'), undefined)
     ];
-    if (!hasVariableDeclaration(sourceFile.statements, 'validators') &&
-        !hasVariableDeclaration(utilityStatements, 'validators')) {
+    const utilityNames = new Set();
+    if (!declaredNames.has('validators') && !utilityNames.has('validators')) {
+        utilityNames.add('validators');
         utilityStatements.push(ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
             ts.factory.createVariableDeclaration(ts.factory.createIdentifier('validators'), undefined, undefined, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('globalThis'), '__WEBERGENCY_TYPECHECKER_VALIDATORS__'))
         ], ts.NodeFlags.Const)));
     }
-    if (!hasVariableDeclaration(sourceFile.statements, 'MetadataStore') &&
-        !hasVariableDeclaration(utilityStatements, 'MetadataStore')) {
+    if (!declaredNames.has('MetadataStore') && !utilityNames.has('MetadataStore')) {
+        utilityNames.add('MetadataStore');
         utilityStatements.push(ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
             ts.factory.createVariableDeclaration(ts.factory.createIdentifier('MetadataStore'), undefined, undefined, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('globalThis'), '__WEBERGENCY_TYPECHECKER_METADATA_STORE__'))
         ], ts.NodeFlags.Const)));
     }
     const variablePrepends = [];
     const registrationAppends = [];
+    const prependedNames = new Set(utilityNames);
     for (const [hash, expr] of cache.entries()) {
+        const valName = `__val_${hash}`;
         // const __val_hash = expr;
-        if (!hasVariableDeclaration(sourceFile.statements, `__val_${hash}`) &&
-            !hasVariableDeclaration(utilityStatements, `__val_${hash}`) &&
-            !hasVariableDeclaration(variablePrepends, `__val_${hash}`)) {
+        if (!declaredNames.has(valName) && !prependedNames.has(valName)) {
+            prependedNames.add(valName);
             variablePrepends.push(ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(ts.factory.createIdentifier(`__val_${hash}`), undefined, undefined, expr)
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier(valName), undefined, undefined, expr)
             ], ts.NodeFlags.Const)));
         }
         // MetadataStore.registerValidator(hash, __val_hash);
         registrationAppends.push(ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), 'registerValidator'), undefined, [
             ts.factory.createStringLiteral(hash),
-            ts.factory.createIdentifier(`__val_${hash}`)
+            ts.factory.createIdentifier(valName)
         ])));
     }
     if (schemasMap) {
@@ -92,15 +96,17 @@ function findInsertionIndex(statements) {
     }
     return statements.length;
 }
-function hasVariableDeclaration(statements, name) {
+function collectDeclaredNames(statements) {
+    const names = new Set();
     for (const statement of statements) {
-        if (ts.isVariableStatement(statement)) {
-            for (const decl of statement.declarationList.declarations) {
-                if (ts.isIdentifier(decl.name) && decl.name.text === name) {
-                    return true;
-                }
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        for (const decl of statement.declarationList.declarations) {
+            if (ts.isIdentifier(decl.name)) {
+                names.add(decl.name.text);
             }
         }
     }
-    return false;
+    return names;
 }

package/dist/engine/resolver.d.ts

@@ -1,5 +1,5 @@
 import ts from '../ts.js';
-export declare function buildValidator(type: ts.Type, checker: ts.TypeChecker, validatorsMap: Map<string, ts.Expression>, requiredUtils: Set<string>): ts.Expression;
+export declare function buildValidator(type: ts.Type, checker: ts.TypeChecker, validatorsMap: Map<string, ts.Expression>, requiredUtils: Set<string>, hash?: string): ts.Expression;
 export declare function generateHash(type: ts.Type, checker: ts.TypeChecker): string;
 export declare function objectToAst(val: any): ts.Expression;
 export declare function getTypeComplexity(type: ts.Type, checker: ts.TypeChecker, visited: Set<number>): number;

package/dist/engine/resolver.js

@@ -129,13 +129,13 @@ function tryMergeObjectIntersection(types, checker, validatorsMap, requiredUtils
     }
     return createObjectCheck([...propMap.values()], requiredUtils, expected, indexValidator);
 }
-export function buildValidator(type, checker, validatorsMap, requiredUtils) {
-    const hash = generateHash(type, checker);
-    if (validatorsMap.has(hash)) {
-        return ts.factory.createIdentifier(`__val_${hash}`);
+export function buildValidator(type, checker, validatorsMap, requiredUtils, hash) {
+    const resolvedHash = hash ?? generateHash(type, checker);
+    if (validatorsMap.has(resolvedHash)) {
+        return ts.factory.createIdentifier(`__val_${resolvedHash}`);
     }
     // Set placeholder to handle circularity
-    validatorsMap.set(hash, ts.factory.createIdentifier(`PENDING_${hash}`));
+    validatorsMap.set(resolvedHash, ts.factory.createIdentifier(`PENDING_${resolvedHash}`));
     let result;
     const flags = type.getFlags();
     const isUnion = (((flags & ts.TypeFlags.Union) !== 0 || type.isUnion()) && type.types) ? true : false;
@@ -537,9 +537,9 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
             result = createPrimitiveCheck('any', requiredUtils);
         }
     }
-    validatorsMap.delete(hash);
-    validatorsMap.set(hash, result);
-    return ts.factory.createIdentifier(`__val_${hash}`);
+    validatorsMap.delete(resolvedHash);
+    validatorsMap.set(resolvedHash, result);
+    return ts.factory.createIdentifier(`__val_${resolvedHash}`);
 }
 function buildStructuralSignature(type, checker, visited = new Set()) {
     const flags = type.getFlags();
@@ -674,9 +674,16 @@ function buildStructuralSignature(type, checker, visited = new Set()) {
     }
     return 'any';
 }
+const hashByType = new WeakMap();
 export function generateHash(type, checker) {
+    const cached = hashByType.get(type);
+    if (cached) {
+        return cached;
+    }
     const structuralSig = buildStructuralSignature(type, checker);
-    return createHash('sha256').update(structuralSig).digest('hex').substring(0, 16);
+    const hash = createHash('sha256').update(structuralSig).digest('hex').substring(0, 16);
+    hashByType.set(type, hash);
+    return hash;
 }
 export function objectToAst(val) {
     if (val === null) {

package/dist/runtime/casing.js

@@ -70,9 +70,26 @@ export function convertPropertyCasing(obj, casing, options) {
         return obj.map((item) => convertPropertyCasing(item, casing, options));
     }
     const result = {};
+    const sourceKeys = new Map();
     for (const [key, value] of Object.entries(obj)) {
         const newKey = formatCasing(key, casing, options);
-        result[newKey] = convertPropertyCasing(value, casing, options);
+        const previousKey = sourceKeys.get(newKey);
+        if (previousKey !== undefined) {
+            throw new Error(`Casing conversion collision: ${previousKey} and ${key} both map to ${newKey}`);
+        }
+        sourceKeys.set(newKey, key);
+        const nested = convertPropertyCasing(value, casing, options);
+        if (newKey !== '__proto__' && newKey !== 'constructor' && newKey !== 'prototype') {
+            result[newKey] = nested;
+        }
+        else {
+            Object.defineProperty(result, newKey, {
+                value: nested,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
     }
     return result;
 }

package/dist/runtime/validators.d.ts

@@ -50,13 +50,14 @@ export interface AssertGuardOptions extends GuardOptions {
 }
 /** Options for `validate` / `validateSchema`. */
 export interface ValidationOptions extends GuardOptions {
-    /** `true`: always write onto the input. `false` (default): always allocate new containers. */
+    /** `true`: write in place while validating. `false` (default): allocate new containers. */
     mutate?: boolean;
 }
 /** Options for `assert` / `assertSchema`. */
 export interface AssertOptions extends ValidationOptions {
     errorFactory?: (errors: IValidationError[]) => Error;
 }
+declare function createSafeRegex(source: string, flags?: string): RegExp;
 /** Query-style number coercion — shared by `from: 'query'` and `transform.ToNumber`. */
 export declare function coerceQueryNumber(v: any): any;
 /** Query-style boolean coercion — shared by `from: 'query'` and `transform.ToBoolean`. */
@@ -70,6 +71,8 @@ export declare const validators: {
     coerceQueryBoolean: typeof coerceQueryBoolean;
     coerceQueryDate: typeof coerceQueryDate;
     coerceJsonDate: typeof coerceJsonDate;
+    safeRegExp: typeof createSafeRegex;
+    assign: (target: any, source: any) => any;
     string: (v: any, path: string, ctx: ValidationContext) => any;
     number: (v: any, path: string, ctx: ValidationContext) => any;
     bigint: (v: any, path: string, ctx: ValidationContext) => any;
@@ -83,9 +86,9 @@ export declare const validators: {
     array: (v: any, path: string, ctx: ValidationContext, childValidator: Function) => any;
     props: (v: any, data: any, path: string, ctx: ValidationContext, props: [string, boolean, Function][]) => void;
     objectShell: (v: any, ctx: ValidationContext) => any;
-    stripExtras: (data: any, ctx: ValidationContext, allowedKeys?: string[]) => any;
-    additionalProps: (v: any, data: any, path: string, ctx: ValidationContext, knownKeys: string[], childValidator: Function) => void;
-    object: (v: any, path: string, ctx: ValidationContext, allowedKeys?: string[], expected?: string) => any;
+    stripExtras: (data: any, ctx: ValidationContext, allowedKeys?: string[] | Set<string>) => any;
+    additionalProps: (v: any, data: any, path: string, ctx: ValidationContext, knownKeys: string[] | Set<string>, childValidator: Function) => void;
+    object: (v: any, path: string, ctx: ValidationContext, allowedKeys?: string[] | Set<string>, expected?: string) => any;
     templateLiteral: (v: any, path: string, ctx: ValidationContext, regex: RegExp, expected: string) => any;
     minLength: (v: string, path: string, ctx: ValidationContext, min: number, message?: string) => string;
     maxLength: (v: string, path: string, ctx: ValidationContext, max: number, message?: string) => string;
@@ -126,7 +129,7 @@ export declare class MetadataStoreClass {
     validate(validator: Function, value: any, options?: ValidationMode | ValidationOptions): {
         success: boolean;
         errors: IValidationError[];
-        data: any;
+        data?: any;
     };
 }
 export declare function groupErrorsByPath(errors: IValidationError[]): Record<string, {