@mionjs/run-types 0.8.7 → 0.8.10

package/src/mocking/constants.mock.ts

@@ -0,0 +1,87 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {MockOptions} from '../types.ts';
+
+export const mockRegExpsList = [
+    /abc/, // Matches the string 'abc'
+    /def/, // Matches the string 'def'
+    /123/, // Matches the string '123'
+    /xyz/, // Matches the string 'xyz'
+    /[\w]+/, // Matches one or more word characters
+    /\d{3}-\d{3}-\d{4}/, // Matches a phone number in the format XXX-XXX-XXXX
+    /[A-Z]/, // Matches a single uppercase letter
+    /[a-z]/, // Matches a single lowercase letter
+    /\d+/, // Matches one or more digits
+    /\s+/, // Matches one or more whitespace characters
+    /^https:\/\/[\w.-]+\.[a-zA-Z]{2,}$/i, // Matches a URL starting with http:// or https://
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i, // Matches an email address
+    /\b\d{2}\/\d{2}\/\d{4}\b/, // Matches a date in the format MM/DD/YYYY
+    /\b\d{1,2}:\d{2}\b/, // Matches a time in the format HH:MM
+    /\b\d{1,2}:\d{2}:\d{2}\b/, // Matches a time in the format HH:MM:SS
+    /\b\d{1,2}\/\d{1,2}\/\d{2}\b/, // Matches a date in the format M/D/YY
+    /\b\d{1,2}\/\d{1,2}\/\d{4}\b/, // Matches a date in the format M/D/YYYY
+    /\b\d{1,2}:\d{2}:\d{2} [AP]M\b/, // Matches a time in the format HH:MM:SS AM/PM
+    /\b\d{1,2}:\d{2} [AP]M\b/, // Matches a time in the format HH:MM AM/PM
+    /abc/gi, // Matches the string 'abc' with the global and case-insensitive flags
+    /['"]/, // regexp that contains single and double quotes
+    /\/(.*)\/(.*)?/, // regexp that contains a slash
+    /\/\//, // regexp that contains two slashes
+    /`/, // regexp that contains backticks
+    /\/\\\//, // regexp double scaped \\
+];
+
+export const stringCharSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 .>?<~!@#$%^&*()_+-=[]{}|;:,';
+export const emailLocalPartSymbols = '._%-';
+
+export const anyValuesList = [
+    {},
+    {hello: 'world'},
+    [],
+    [1, 3, 'hello'],
+    'hello',
+    1234,
+    BigInt(1),
+    true,
+    false,
+    null,
+    undefined,
+    Symbol('hello'),
+    -124,
+    0,
+    124,
+    0.1,
+    -0.1,
+    Infinity,
+    NaN,
+    new Date(),
+    /abc/,
+    new Map([
+        ['zero', 0],
+        ['one', 1],
+        ['two', 2],
+        ['three', 3],
+        ['four', 4],
+    ]),
+    new Set(['zero', 1, 2, 3, 'four']),
+];
+
+export const mockObjectList = [{}, {a: 1}, {b: 2}, {a: 1, b: 'hello'}, {a: 1, b: 2, c: 3}, {a: 'hello', b: 2, c: 'wold', d: 4}];
+
+export const defaultMockOptions = {
+    anyValuesList,
+    promiseTimeOut: 1,
+    regexpList: mockRegExpsList,
+    maxRandomStringLength: 100,
+    stringCharSet,
+    maxRandomItemsLength: 60,
+    /** probability to generate options types, number between 0 and 1 */
+    optionalProbability: 0.5,
+    objectList: mockObjectList,
+    maxStackDepth: 50,
+    maxMockRecursion: 10,
+} satisfies MockOptions;

package/src/mocking/mockRegistry.ts

@@ -0,0 +1,20 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {JitFnCompiler} from '../lib/jitFnCompiler.ts';
+
+// TODO, as mock could return results async with mock promises
+// we might need an unique JitCompiler, for each mock to avoid problems with the stack
+const mockCompCache = new Map<string, JitFnCompiler>();
+
+export function getMockCompiler(fnHash: string): JitFnCompiler {
+    return mockCompCache.get(fnHash)!;
+}
+
+export function setMockCompiler(fnHash: string, comp: JitFnCompiler): void {
+    mockCompCache.set(fnHash, comp);
+}

package/src/mocking/mockType.ts

@@ -0,0 +1,409 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {ReflectionKind} from '@deepkit/type';
+import type {MockOptions, Mutable, RunTypeOptions} from '../types.ts';
+import type {BaseRunType} from '../lib/baseRunTypes.ts';
+import {mockString, mockNumber, mockBoolean, mockBigInt, mockDate, random, mockRegExp, mockSymbol, mockAny} from './mockUtils.ts';
+import {stringCharSet} from './constants.mock.ts';
+import {ClassRunType} from '../nodes/collection/class.ts';
+import type {PropertyRunType} from '../nodes/member/property.ts';
+import type {MapRunType} from '../nodes/native/map.ts';
+import type {SetRunType} from '../nodes/native/set.ts';
+import type {InterfaceRunType} from '../nodes/collection/interface.ts';
+import type {TupleRunType} from '../nodes/collection/tuple.ts';
+import type {FunctionParamsRunType} from '../nodes/collection/functionParams.ts';
+import type {UnionRunType} from '../nodes/collection/union.ts';
+import type {EnumRunType} from '../nodes/atomic/enum.ts';
+import type {PromiseRunType} from '../nodes/native/promise.ts';
+import type {ParameterRunType} from '../nodes/member/param.ts';
+import type {RestParamsRunType} from '../nodes/member/restParams.ts';
+import {ReflectionSubKind} from '../constants.kind.ts';
+import {NonSerializableRunType} from '../nodes/native/nonSerializable.ts';
+import {IndexSignatureRunType} from '../nodes/member/indexProperty.ts';
+import {getRunTypeFormat, getRunTypeTransformer} from '../lib/formats.ts';
+import {JIT_STACK_TRACE_MESSAGE} from '../constants.ts';
+import {JitFunctions} from '../constants.functions.ts';
+import type {ArrayRunType} from '../nodes/member/array.ts';
+import {getJitUtils} from '@mionjs/core';
+import {MockJitCompiler, type JitFnCompiler} from '../lib/jitFnCompiler.ts';
+
+export function mockType(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[] = []): any {
+    // TODO: we could use JitCompiler functionality here to controls the stack etc
+    stack.push(runType);
+    const mockNestLevel = stack.filter((rt) => rt === runType).length;
+    const rtOpts = comp.opts;
+    const updatedOps = mockNestLevel ? getMockOptionsForNestedElements(rtOpts, mockNestLevel) : comp.opts;
+    (comp as Mutable<JitFnCompiler>).opts = updatedOps;
+    // Just one type validator allowed per type, and is responsible to mock the value,
+    // ie: email and uuid should contain the logic to generate a valid value
+    const typeValidator = getRunTypeFormat(runType);
+    let mocked = typeValidator ? typeValidator.mock(updatedOps, runType) : _mockType(runType, comp, stack);
+    (comp as Mutable<JitFnCompiler>).opts = rtOpts;
+    // once mocked multiple type transformers can be applied to the mocked value
+    const typeTransformer = getRunTypeTransformer(runType);
+    if (typeTransformer) {
+        const compiledFormatter = runType.createJitCompiledFunction(JitFunctions.format.id);
+        mocked = compiledFormatter.isNoop ? mocked : compiledFormatter.fn(mocked);
+    }
+    stack.pop();
+    return mocked;
+}
+
+// reduces all probabilities within the MockOptions to prevent infinite loops
+// each time mocking is a level deeper, the probabilities to generate an optional property should be reduced
+// this does not prevent infinite loops on types with circular references that are non optional,
+// we probably should throw an error in this case but these kind of types are technically not possible in real world so we can ignore them for now
+function getMockOptionsForNestedElements(opts: RunTypeOptions, nestLevel: number): RunTypeOptions {
+    const mOps = opts.mock as MockOptions;
+    const maxDepth = mOps.maxMockRecursion;
+    const divisor = nestLevel;
+    const {optionalProbability, maxRandomItemsLength: maxRandomArrayLength, optionalPropertyProbability, arrayLength} = mOps;
+    const newProv = nestLevel >= maxDepth ? 0 : optionalProbability / divisor;
+    const newMaxLength = nestLevel >= maxDepth ? 0 : Math.round(maxRandomArrayLength / divisor);
+    // console.log(`divisor: ${divisor} | newMaxLength: ${newMaxLength} | newProv: ${newProv}`);
+    const ret = {
+        mock: {
+            ...mOps,
+            optionalProbability: newProv,
+            maxRandomItemsLength: newMaxLength,
+        },
+    } satisfies RunTypeOptions;
+    if (optionalPropertyProbability) {
+        const entries = Object.entries(optionalPropertyProbability).map(([key, value]) => {
+            const newProv = nestLevel > maxDepth ? 0 : value / divisor;
+            return [key, value / newProv];
+        });
+        ret.mock.optionalPropertyProbability = Object.fromEntries(entries);
+    }
+    if (arrayLength) {
+        const newLength = nestLevel >= maxDepth ? 0 : Math.round(arrayLength / divisor);
+        ret.mock.arrayLength = newLength;
+    }
+    if (ret.mock.parentObj) ret.mock.parentObj = {}; // prevents mocking objects with circular references
+    return ret;
+}
+
+/**
+ * Centralized mock function with a giant switch statement that handles all node types.
+ * This function is similar to createRunType in runType.ts but for mocking.
+ */
+function _mockType(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[]): any {
+    // Handle circular references
+    const mOps = comp.opts.mock as MockOptions;
+    const recursionLevel = stack.filter((rt) => rt === runType).length;
+    const src = runType.src;
+    const kind = src.kind;
+    if (recursionLevel > mOps.maxMockRecursion) return undefined;
+
+    switch (kind) {
+        case ReflectionKind.never:
+            throw new Error('Cannot mock never type.' + printStackTrace(comp, stack));
+        case ReflectionKind.any:
+        case ReflectionKind.unknown:
+            return mockAny(mOps.anyValuesList);
+        // Atomic types
+        case ReflectionKind.string:
+            return mockString(mOps.stringLength || random(1, mOps.maxRandomStringLength), mOps.stringCharSet || stringCharSet);
+        case ReflectionKind.number:
+            return mockNumber(mOps.minNumber, mOps.maxNumber);
+        case ReflectionKind.boolean:
+            return mockBoolean();
+        case ReflectionKind.bigint:
+            return mockBigInt(mOps.minNumber, mOps.maxNumber);
+        case ReflectionKind.null:
+            return null;
+        case ReflectionKind.undefined:
+            return undefined;
+        case ReflectionKind.void:
+            return undefined;
+        case ReflectionKind.regexp:
+            return mockRegExp(mOps.regexpList);
+        case ReflectionKind.symbol:
+            return mockSymbol(mOps.symbolName, mOps.symbolLength, mOps.symbolCharSet);
+        case ReflectionKind.literal:
+            return src.literal;
+        case ReflectionKind.object:
+            return mOps.objectList[random(0, mOps.objectList.length - 1)];
+        case ReflectionKind.enum: {
+            const rt = runType as EnumRunType;
+            const i = mOps.enumIndex || random(0, rt.src.values.length - 1);
+            return rt.src.values[i];
+        }
+        case ReflectionKind.enumMember:
+            throw new Error('Mock enum member is not supported.' + printStackTrace(comp, stack));
+        // Collection types
+        case ReflectionKind.array: {
+            const rt = runType as ArrayRunType;
+            const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);
+            if (length === 0) return [];
+            return Array.from({length}, () => mockType(rt.getMemberType(), comp, stack));
+        }
+
+        case ReflectionKind.tuple: {
+            const rt = runType as TupleRunType;
+            const options = mOps.tupleOptions;
+            const params = rt.getChildRunTypes().map((p, i) => mockType(p, getChildOpts(comp, options?.[i]), stack));
+            if (rt.hasRestParameter(comp)) {
+                return [...params.slice(0, -1), ...params[params.length - 1]];
+            }
+            return params;
+        }
+        case ReflectionKind.intersection:
+        case ReflectionKind.objectLiteral: {
+            if (runType instanceof NonSerializableRunType) {
+                throw new Error(`Mock is disabled for Non Serializable types.` + printStackTrace(comp, stack));
+            } else {
+                const rt = runType as InterfaceRunType;
+                if (rt.isCallable()) return mockType(rt.getCallSignature()!, comp, stack);
+                let obj: Record<string | number, any> = mOps.parentObj || {};
+                rt.getChildRunTypes().forEach((prop) => {
+                    if (prop instanceof IndexSignatureRunType) {
+                        obj = {...obj, ...mockType(prop, comp, stack)};
+                        return;
+                    }
+                    const name = (prop as PropertyRunType).getChildVarName(comp);
+                    const isMethod = prop.src.kind === ReflectionKind.method || prop.src.kind === ReflectionKind.methodSignature;
+                    if (isMethod) return; // skip mocking methods
+                    obj[name] = mockType(prop, comp, stack);
+                });
+                return obj;
+            }
+        }
+        case ReflectionKind.class:
+            return _mockClass(runType, comp, stack);
+        case ReflectionKind.union: {
+            const rt = runType as UnionRunType;
+            if (mOps.unionIndex && (mOps.unionIndex < 0 || mOps.unionIndex >= rt.getChildRunTypes().length)) {
+                throw new Error(
+                    'unionIndex must be between 0 and the number of types in the union.' + printStackTrace(comp, stack)
+                );
+            }
+            const index = mOps?.unionIndex ?? random(0, rt.getChildRunTypes().length - 1);
+            return mockType(rt.getChildRunTypes()[index], comp, stack);
+        }
+
+        case ReflectionKind.function:
+        case ReflectionKind.callSignature:
+        case ReflectionKind.method:
+        case ReflectionKind.methodSignature:
+            if (runType.src.subKind === ReflectionSubKind.params) {
+                const rt = runType as FunctionParamsRunType;
+                const options = mOps.tupleOptions;
+                const params = rt.getParamRunTypes(comp).map((p, i) => mockType(p, getChildOpts(comp, options?.[i]), stack));
+                if (rt.hasRestParameter(comp)) {
+                    return [...params.slice(0, -1), ...params[params.length - 1]];
+                }
+                return params;
+            } else if (runType.src.kind === ReflectionKind.method || runType.src.kind === ReflectionKind.methodSignature) {
+                return undefined; // Skip methods silently
+            } else {
+                throw new Error('Mock is not allowed, call mockParams or mockReturn instead.' + printStackTrace(comp, stack));
+            }
+        case ReflectionKind.promise: {
+            const rt = runType as PromiseRunType;
+            const timeOut = mOps.promiseTimeOut || 1;
+            return new Promise((resolve, reject) => {
+                if (timeOut > 0) {
+                    setTimeout(() => {
+                        if (mOps.promiseReject) reject(mOps.promiseReject);
+                        else resolve(mockType(rt.getMemberType(), comp, stack));
+                    }, timeOut);
+                    return;
+                }
+                if (mOps.promiseReject) reject(mOps.promiseReject);
+                else resolve(mockType(rt.getMemberType(), comp, stack));
+            });
+        }
+        // Member types
+        case ReflectionKind.tupleMember:
+        case ReflectionKind.parameter: {
+            const rt = runType as ParameterRunType;
+            if (!rt.getJitChild(comp)) return undefined; // non serializable types are set to undefined
+            if (rt.isOptional() && !rt.isRest()) {
+                const probability = mOps.optionalProbability;
+                if (probability < 0 || probability > 1)
+                    throw new Error('optionalProbability must be between 0 and 1' + printStackTrace(comp, stack));
+                if (Math.random() > probability) {
+                    return undefined;
+                }
+            }
+            return mockType(rt.getMemberType(), comp, stack);
+        }
+        case ReflectionKind.propertySignature:
+        case ReflectionKind.property: {
+            const rt = runType as PropertyRunType;
+            const probability = mOps.optionalPropertyProbability?.[rt.getChildVarName(comp)] ?? mOps.optionalProbability;
+            if (probability < 0 || probability > 1)
+                throw new Error('optionalProbability must be between 0 and 1' + printStackTrace(comp, stack));
+            if (rt.src.optional && Math.random() > probability) return undefined;
+            return mockType(rt.getMemberType(), comp, stack);
+        }
+
+        case ReflectionKind.rest: {
+            const rt = runType as RestParamsRunType;
+            const length = random(0, mOps.maxRandomItemsLength);
+            const items: any[] = [];
+            for (let i = 0; i < length; i++) {
+                items.push(mockType(rt.getMemberType(), comp, stack));
+            }
+            return items;
+        }
+        case ReflectionKind.indexSignature: {
+            const rt = runType as IndexSignatureRunType;
+            const length = random(0, mOps.maxRandomItemsLength);
+            const parentObj = mOps.parentObj || {};
+            for (let i = 0; i < length; i++) {
+                let propName: number | string | symbol;
+                switch (true) {
+                    case !!(rt.src.index.kind === ReflectionKind.number):
+                        propName = i;
+                        break;
+                    case !!(rt.src.index.kind === ReflectionKind.string):
+                        propName = `key${i}`;
+                        break;
+                    case !!(rt.src.index.kind === ReflectionKind.symbol):
+                        propName = Symbol.for(`key${i}`);
+                        break;
+                    case !!(rt.src.index.kind === ReflectionKind.templateLiteral): {
+                        // walk the template literal spans to produce a key that matches the pattern.
+                        // retry a few times on collision since narrow patterns (eg `id-${number}`) can repeat.
+                        const tplTypes = ((rt.src.index as any).types as any[]) || [];
+                        const buildKey = () =>
+                            tplTypes
+                                .map((part: any) => {
+                                    switch (part.kind) {
+                                        case ReflectionKind.literal:
+                                            return String(part.literal);
+                                        case ReflectionKind.number:
+                                            return String(mockNumber(mOps.minNumber, mOps.maxNumber));
+                                        case ReflectionKind.string:
+                                        case ReflectionKind.any:
+                                        case ReflectionKind.infer:
+                                            return mockString(
+                                                mOps.stringLength || random(1, mOps.maxRandomStringLength),
+                                                mOps.stringCharSet || stringCharSet
+                                            );
+                                        default:
+                                            throw new Error(`Unsupported template literal span kind: ${part.kind}`);
+                                    }
+                                })
+                                .join('');
+                        let candidate = buildKey();
+                        for (let r = 0; r < 5 && candidate in parentObj; r++) candidate = buildKey();
+                        propName = candidate;
+                        break;
+                    }
+                    default:
+                        throw new Error('Invalid index signature type.');
+                }
+                parentObj[propName] = mockType(rt.getMemberType(), comp, stack);
+            }
+            return parentObj;
+        }
+
+        case ReflectionKind.templateLiteral: {
+            // walk the spans and emit a string for each: literal verbatim, string/any/infer => mockString,
+            // number => stringified mockNumber. The concatenated value is, by construction,
+            // accepted by the validation regex emitted by TemplateLiteralRunType.
+            const types = (src as any).types as any[];
+            return types
+                .map((part: any) => {
+                    switch (part.kind) {
+                        case ReflectionKind.literal:
+                            return String(part.literal);
+                        case ReflectionKind.number:
+                            return String(mockNumber(mOps.minNumber, mOps.maxNumber));
+                        case ReflectionKind.string:
+                        case ReflectionKind.any:
+                        case ReflectionKind.infer:
+                            return mockString(
+                                mOps.stringLength || random(1, mOps.maxRandomStringLength),
+                                mOps.stringCharSet || stringCharSet
+                            );
+                        default:
+                            throw new Error(
+                                `Unsupported template literal span kind: ${part.kind}` + printStackTrace(comp, stack)
+                            );
+                    }
+                })
+                .join('');
+        }
+        case ReflectionKind.infer:
+        case ReflectionKind.typeParameter:
+        default:
+            throw new Error(`Cant mock Unsupported RunType: ${runType.getTypeName()}` + printStackTrace(comp, stack));
+    }
+}
+
+function _mockClass(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType[]) {
+    const mOps = comp.opts.mock as MockOptions;
+    switch (runType.src.subKind) {
+        case ReflectionSubKind.date:
+            return mockDate(mOps.minDate, mOps.maxDate);
+        case ReflectionSubKind.map: {
+            const rt = runType as MapRunType;
+            const mockMap = new Map();
+            const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);
+            for (let i = 0; i < length; i++) {
+                const keyType = mockType(rt.keyRT, comp, stack);
+                const valueType = mockType(rt.valueRT, comp, stack);
+                mockMap.set(keyType, valueType);
+            }
+            return mockMap;
+        }
+        case ReflectionSubKind.set: {
+            const rt = runType as SetRunType;
+            const mockSet = new Set();
+            const length = mOps.arrayLength ?? random(0, mOps.maxRandomItemsLength);
+            for (let i = 0; i < length; i++) {
+                const value = mockType(rt.keyRT, comp, stack);
+                mockSet.add(value);
+            }
+            return mockSet;
+        }
+        case ReflectionSubKind.nonSerializable:
+            throw new Error(`Mock is disabled for Non Serializable types.` + printStackTrace(comp, stack));
+        default: {
+            if (!(runType instanceof ClassRunType)) {
+                throw new Error(`Cant mock Unsupported RunType: ${runType.getTypeName()}` + printStackTrace(comp, stack));
+            }
+            const rt = runType as ClassRunType;
+            const isSerializable = rt.isClassWithEmptyConstructor();
+            const deserializeFn = getJitUtils().getDeserializeFn(rt.getClassName());
+            if (!deserializeFn && !isSerializable) {
+                throw new Error(
+                    `Class ${rt.getClassName()} can not be mocked. Be sure to register a deserialize function first with jiUtils.${getJitUtils().setDeserializeFn.name}` +
+                        printStackTrace(comp, stack)
+                );
+            }
+            const instance = deserializeFn ? {} : new rt.src.classType();
+            // only properties that are used in jit operations are mocked, there properties should be initialized in the constructor
+            rt.getJitChildren(comp).forEach((prop) => {
+                const name = (prop as PropertyRunType).getChildVarName(comp);
+                if (prop instanceof IndexSignatureRunType) mockType(prop, comp, stack);
+                const mocked = mockType(prop, comp, stack);
+                if ((prop as PropertyRunType).src.optional && mocked === undefined) return;
+                instance[name] = mockType(prop, comp, stack);
+            });
+            if (deserializeFn) return deserializeFn(instance);
+            if (isSerializable) return instance;
+            throw new Error(`Class ${rt.getClassName()} can not be mocked.` + printStackTrace(comp, stack));
+        }
+    }
+}
+
+function getChildOpts(comp: JitFnCompiler, mockOpts?: MockOptions): JitFnCompiler {
+    if (!mockOpts) return comp;
+    const newOpts = {...comp.opts, mock: mockOpts};
+    return new MockJitCompiler(comp.rootType, newOpts, comp, comp.jitFnHash, comp.typeID);
+}
+
+function printStackTrace(comp: JitFnCompiler, stack: BaseRunType[]) {
+    const separator = '.';
+    return JIT_STACK_TRACE_MESSAGE + stack.map((rt) => comp.getTypeTraceInfo(rt)).join(separator);
+}

package/src/mocking/mockUtils.ts

@@ -0,0 +1,82 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {anyValuesList, stringCharSet} from './constants.mock.ts';
+import {mockRegExpsList} from './constants.mock.ts';
+
+export function mockBoolean(): boolean {
+    return Math.random() < 0.5;
+}
+
+export function mockBigInt(min = 0, max = 10000): bigint {
+    return BigInt(random(min, max));
+}
+
+export function mockString(length = random(0, 30), allowedChars = stringCharSet, disallowedChars: string = ''): string {
+    if (allowedChars.length === 0) throw new Error('Can not generate random string as allowedChars cannot be empty');
+    const allowedCharSet = allowedChars
+        .split('')
+        .filter((char) => !disallowedChars.includes(char))
+        .join('');
+    if (allowedCharSet.length === 0)
+        throw new Error('Can not generate random string as allowedChars and disallowedChars are mutually exclusive');
+    return Array.from({length}, () => allowedCharSet[random(0, allowedCharSet.length - 1)]).join('');
+}
+
+export function mockSymbol(name?: string, length?: number, charsSet?: string): symbol {
+    const symbolName = name ?? mockString(length, charsSet);
+    return Symbol(symbolName);
+}
+
+export function mockRegExp(list = mockRegExpsList): RegExp {
+    return list[random(0, list.length - 1)];
+}
+
+/**
+ * Generates a random number between min and max, both inclusive.
+ * @param min 0 by default
+ * @param max 10000 by default
+ * @returns random number
+ */
+export function mockNumber(min = 0, max = 10000): number {
+    if (min > max) {
+        throw new Error('min cannot be greater than max');
+    }
+    return random(min, max);
+}
+
+/**
+ * Generates a random date between minDate and maxDate, both inclusive.
+ * @param minDate 0 by default
+ * @param maxDate Date.now() by default
+ */
+export function mockDate(minDate: Date | number = new Date(0), maxDate: Date | number = new Date()): Date {
+    const min = typeof minDate === 'number' ? minDate : minDate.getTime();
+    const max = typeof maxDate === 'number' ? maxDate : maxDate.getTime();
+    if (min > max) {
+        throw new Error('minDate cannot be greater than maxDate');
+    }
+    return new Date(random(min, max));
+}
+
+export function mockAny(anyList = anyValuesList): any {
+    return anyList[random(0, anyList.length - 1)];
+}
+
+/** Generates a random number between min and max, both inclusive */
+export function random(min: number = 0, max = 10000): number {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+export function randomItem<T>(list: T[]): T {
+    return list[random(0, list.length - 1)];
+}
+
+export function mockRecursiveEmptyArray(depth: number, length: number) {
+    if (depth === 0) return [];
+    return Array.from({length}, () => mockRecursiveEmptyArray(depth - 1, length));
+}

package/src/nodes/atomic/any.ts

@@ -0,0 +1,22 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {type TypeAny, type TypeUnknown} from '@deepkit/type';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+import type {JitCode} from '../../types.ts';
+import {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+export class AnyRunType extends AtomicRunType<TypeAny | TypeUnknown> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        const isRoot = comp.getNestLevel(this) === 0;
+        if (isRoot) return {code: undefined, type: 'E'};
+        return {code: 'true', type: 'E'};
+    }
+    emitTypeErrors(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+}

package/src/nodes/atomic/bigInt.ts

@@ -0,0 +1,26 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeBigInt} from '@deepkit/type';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import type {JitCode} from '../../types.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+
+export class BigIntRunType extends AtomicRunType<TypeBigInt> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `typeof ${comp.vλl} === 'bigint'`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (typeof ${comp.vλl} !== 'bigint') ${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitPrepareForJson(comp: JitFnCompiler): JitCode {
+        return {code: `${comp.vλl}.toString()`, type: 'E'};
+    }
+    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
+        return {code: `BigInt(${comp.vλl})`, type: 'E'};
+    }
+}

package/src/nodes/atomic/boolean.ts

@@ -0,0 +1,26 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeBoolean} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {AtomicRunType} from '../../lib/baseRunTypes.ts';
+
+export class BooleanRunType extends AtomicRunType<TypeBoolean> {
+    emitIsType(comp: JitFnCompiler): JitCode {
+        return {code: `typeof ${comp.vλl} === 'boolean'`, type: 'E'};
+    }
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
+        return {code: `if (typeof ${comp.vλl} !== 'boolean') ${comp.callJitErr(this)}`, type: 'S'};
+    }
+    emitPrepareForJson(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+    emitRestoreFromJson(): JitCode {
+        return {code: undefined, type: 'S'};
+    }
+}