@zipbul/baker 2.1.0 → 3.0.0

package/dist/src/rules/typechecker.d.ts

@@ -1,14 +1,14 @@
 import type { EmittableRule } from '../types';
-export declare const isString: EmittableRule;
+export declare const isString: import("../types").InternalRule;
 export interface IsNumberOptions {
     allowNaN?: boolean;
     allowInfinity?: boolean;
     maxDecimalPlaces?: number;
 }
 export declare function isNumber(options?: IsNumberOptions): EmittableRule;
-export declare const isBoolean: EmittableRule;
-export declare const isDate: EmittableRule;
+export declare const isBoolean: import("../types").InternalRule;
+export declare const isDate: import("../types").InternalRule;
 export declare function isEnum(entity: object): EmittableRule;
-export declare const isInt: EmittableRule;
-export declare const isArray: EmittableRule;
-export declare const isObject: EmittableRule;
+export declare const isInt: import("../types").InternalRule;
+export declare const isArray: import("../types").InternalRule;
+export declare const isObject: import("../types").InternalRule;

package/dist/src/rules/typechecker.js

@@ -0,0 +1,143 @@
+import { makeRule } from '../rule-plan.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// isString — typeof check (§4.8 A: operator inline)
+// ─────────────────────────────────────────────────────────────────────────────
+export const isString = makeRule({
+    name: 'isString',
+    constraints: {},
+    validate: value => typeof value === 'string',
+    emit: (varName, ctx) => `if (typeof ${varName} !== 'string') ${ctx.fail('isString')};`,
+});
+export function isNumber(options) {
+    const allowNaN = options?.allowNaN ?? false;
+    const allowInfinity = options?.allowInfinity ?? false;
+    const maxDecimalPlaces = options?.maxDecimalPlaces;
+    const validate = (value) => {
+        if (typeof value !== 'number') {
+            return false;
+        }
+        // Check NaN first — since isFinite(NaN) is also false, order matters
+        if (isNaN(value)) {
+            return allowNaN;
+        }
+        // Non-NaN non-finite values (Infinity / -Infinity)
+        if (!isFinite(value)) {
+            return allowInfinity;
+        }
+        if (maxDecimalPlaces !== undefined) {
+            const parts = value.toExponential().split('e');
+            const mantissaDecimals = (parts[0].split('.')[1] || '').length;
+            const exponent = parseInt(parts[1], 10);
+            if (Math.max(0, mantissaDecimals - exponent) > maxDecimalPlaces) {
+                return false;
+            }
+        }
+        return true;
+    };
+    return makeRule({
+        name: 'isNumber',
+        constraints: {
+            allowNaN: options?.allowNaN,
+            allowInfinity: options?.allowInfinity,
+            maxDecimalPlaces: options?.maxDecimalPlaces,
+        },
+        validate,
+        emit: (varName, ctx) => {
+            if (ctx.insideTypeGate) {
+                // typeof + isNaN already verified by gate — emit only Infinity/maxDecimalPlaces checks
+                let code = '';
+                if (!allowInfinity) {
+                    code += `if (${varName} === Infinity || ${varName} === -Infinity) ${ctx.fail('isNumber')};`;
+                }
+                if (maxDecimalPlaces !== undefined) {
+                    code += `${code ? '\nelse ' : ''}{ var exp=${varName}.toExponential().split('e'); var mant=(exp[0].split('.')[1]||'').length; var exp2=parseInt(exp[1],10); if(Math.max(0,mant-exp2)>${maxDecimalPlaces}) ${ctx.fail('isNumber')}; }`;
+                }
+                return code;
+            }
+            let code = `if (typeof ${varName} !== 'number') ${ctx.fail('isNumber')};`;
+            if (!allowNaN) {
+                code += `\nelse if (isNaN(${varName})) ${ctx.fail('isNumber')};`;
+            }
+            if (!allowInfinity) {
+                code += `\nelse if (${varName} === Infinity || ${varName} === -Infinity) ${ctx.fail('isNumber')};`;
+            }
+            if (maxDecimalPlaces !== undefined) {
+                code += `\nelse { var exp=${varName}.toExponential().split('e'); var mant=(exp[0].split('.')[1]||'').length; var exp2=parseInt(exp[1],10); if(Math.max(0,mant-exp2)>${maxDecimalPlaces}) ${ctx.fail('isNumber')}; }`;
+            }
+            return code;
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// isBoolean — typeof check (§4.8 A)
+// ─────────────────────────────────────────────────────────────────────────────
+export const isBoolean = makeRule({
+    name: 'isBoolean',
+    constraints: {},
+    validate: value => typeof value === 'boolean',
+    emit: (varName, ctx) => `if (typeof ${varName} !== 'boolean') ${ctx.fail('isBoolean')};`,
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// isDate — instanceof Date + getTime() NaN check (§4.8 A)
+// ─────────────────────────────────────────────────────────────────────────────
+export const isDate = makeRule({
+    name: 'isDate',
+    constraints: {},
+    validate: value => value instanceof Date && !isNaN(value.getTime()),
+    emit: (varName, ctx) => `if (!(${varName} instanceof Date) || isNaN(${varName}.getTime())) ${ctx.fail('isDate')};`,
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// isEnum — factory: indexOf check using Object.values array (§4.8 C)
+// ─────────────────────────────────────────────────────────────────────────────
+export function isEnum(entity) {
+    const values = Object.values(entity);
+    // Set lookup is O(1); array indexOf is O(n). Measured (Bun/JSC):
+    // - 4 items: indexOf 1.2 ns vs Set.has 2.2 ns (indexOf marginally faster)
+    // - 50 items: indexOf 64 ns vs Set.has 8.4 ns (Set 7.5x faster)
+    // Use Set when there are enough values to overcome its constant-factor overhead.
+    const useSet = values.length >= 8;
+    const valuesSet = useSet ? new Set(values) : null;
+    return makeRule({
+        name: 'isEnum',
+        constraints: { values },
+        validate: useSet ? value => valuesSet.has(value) : value => values.includes(value),
+        emit: (varName, ctx) => {
+            if (useSet) {
+                const i = ctx.addRef(valuesSet);
+                return `if (!refs[${i}].has(${varName})) ${ctx.fail('isEnum')};`;
+            }
+            const i = ctx.addRef(values);
+            return `if (!refs[${i}].includes(${varName})) ${ctx.fail('isEnum')};`;
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// isInt — typeof + Number.isInteger check (§4.8 A)
+// ─────────────────────────────────────────────────────────────────────────────
+export const isInt = makeRule({
+    name: 'isInt',
+    requiresType: 'number',
+    constraints: {},
+    validate: value => typeof value === 'number' && Number.isInteger(value),
+    emit: (varName, ctx) => ctx.insideTypeGate
+        ? `if (!Number.isInteger(${varName})) ${ctx.fail('isInt')};`
+        : `if (typeof ${varName} !== 'number' || !Number.isInteger(${varName})) ${ctx.fail('isInt')};`,
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// isArray — Array.isArray check (§4.8 A: operator inline)
+// ─────────────────────────────────────────────────────────────────────────────
+export const isArray = makeRule({
+    name: 'isArray',
+    constraints: {},
+    validate: value => Array.isArray(value),
+    emit: (varName, ctx) => `if (!Array.isArray(${varName})) ${ctx.fail('isArray')};`,
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// isObject — typeof object + non-null + non-array (§4.8 A)
+// ─────────────────────────────────────────────────────────────────────────────
+export const isObject = makeRule({
+    name: 'isObject',
+    constraints: {},
+    validate: value => typeof value === 'object' && value !== null && !Array.isArray(value),
+    emit: (varName, ctx) => `if (typeof ${varName} !== 'object' || ${varName} === null || Array.isArray(${varName})) ${ctx.fail('isObject')};`,
+});

package/dist/src/seal/circular-analyzer.js

@@ -0,0 +1,63 @@
+import { BakerError } from '../errors.js';
+import { getRaw } from '../meta-access.js';
+/**
+ * Static analysis for circular references (§4.6)
+ *
+ * Traverses the @Type reference graph via DFS to detect cycles.
+ *
+ * Flat DTO without cycles → false (zero WeakSet overhead)
+ * DTO with cycles → true (WeakSet automatically inserted)
+ */
+export function analyzeCircular(Class) {
+    // @Type reference graph DFS — detect back-edges via visited set
+    const visited = new Set();
+    function walk(cls) {
+        if (visited.has(cls)) {
+            return true;
+        } // back-edge → cycle detected
+        visited.add(cls);
+        const raw = getRaw(cls);
+        if (raw) {
+            for (const meta of Object.values(raw)) {
+                // Simple @Type
+                if (meta.type?.fn) {
+                    let typeResult;
+                    try {
+                        typeResult = meta.type.fn();
+                    }
+                    catch (e) {
+                        throw new BakerError(`${cls.name}: type function threw: ${e.message}`, { cause: e });
+                    }
+                    const nested = Array.isArray(typeResult) ? typeResult[0] : typeResult;
+                    if (walk(nested)) {
+                        return true;
+                    }
+                }
+                // discriminator subTypes
+                if (meta.type?.discriminator) {
+                    for (const sub of meta.type.discriminator.subTypes) {
+                        if (walk(sub.value)) {
+                            return true;
+                        }
+                    }
+                }
+                // W1 (F-1): collectionValue thunk (Set/Map nested DTO) — invoke and walk
+                if (meta.type?.collectionValue) {
+                    let resolved;
+                    try {
+                        resolved = meta.type.collectionValue();
+                    }
+                    catch (e) {
+                        throw new BakerError(`${cls.name}: collectionValue function threw: ${e.message}`, { cause: e });
+                    }
+                    if (typeof resolved === 'function' && walk(resolved)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        visited.delete(cls); // Release tree edge — prevent false positives for diamond patterns
+        return false;
+    }
+    return walk(Class);
+}

package/dist/src/seal/codegen-utils.d.ts

@@ -0,0 +1,7 @@
+/** Convert key to a valid JS identifier suffix (encode non-alphanumeric chars via charCode to prevent collisions) */
+export declare function sanitizeKey(key: string): string;
+/**
+ * Generate a groups-has expression for the fast-path single-group / Set pattern.
+ * Checks if any of the given groups match the runtime groups.
+ */
+export declare function buildGroupsHasExpr(singleGroupVar: string, groupsVar: string, groups: string[]): string;

package/dist/src/seal/codegen-utils.js

@@ -0,0 +1,18 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// Shared code-generation utilities for deserialize/serialize builders
+// ─────────────────────────────────────────────────────────────────────────────
+/** Convert key to a valid JS identifier suffix (encode non-alphanumeric chars via charCode to prevent collisions) */
+export function sanitizeKey(key) {
+    return key.replace(/[^a-zA-Z0-9_]/g, ch => `$${ch.charCodeAt(0)}$`);
+}
+/**
+ * Generate a groups-has expression for the fast-path single-group / Set pattern.
+ * Checks if any of the given groups match the runtime groups.
+ */
+export function buildGroupsHasExpr(singleGroupVar, groupsVar, groups) {
+    const checks = groups.map(group => {
+        const q = JSON.stringify(group);
+        return `(${singleGroupVar}===${q} || (${groupsVar} && ${groupsVar}.has(${q})))`;
+    });
+    return checks.join(' || ');
+}

package/dist/src/seal/deserialize-builder.d.ts

@@ -1,5 +1,10 @@
 import type { Result, ResultAsync } from '@zipbul/result';
-import type { RawClassMeta } from '../types';
 import type { SealOptions, RuntimeOptions } from '../interfaces';
-import { type BakerError } from '../errors';
-export declare function buildDeserializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean): (input: unknown, opts?: RuntimeOptions) => Result<T, BakerError[]> | ResultAsync<T, BakerError[]>;
+import type { RawClassMeta } from '../types';
+import { type BakerIssue } from '../errors';
+type DeserializeExecutor<T> = (input: unknown, opts?: RuntimeOptions) => Result<T, BakerIssue[]> | ResultAsync<T, BakerIssue[]>;
+type ValidateExecutor = (input: unknown, opts?: RuntimeOptions) => BakerIssue[] | null | Promise<BakerIssue[] | null>;
+declare function buildDeserializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean): DeserializeExecutor<T>;
+declare function buildDeserializeCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, validateOnly: true): ValidateExecutor;
+declare function buildValidateCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean): ValidateExecutor;
+export { buildDeserializeCode, buildValidateCode };