@mionjs/run-types 0.8.6 → 0.8.8

package/src/nodes/native/nonSerializable.ts

@@ -0,0 +1,42 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {TypeClass, TypeObjectLiteral} from '@deepkit/type';
+import {JitCode} from '../../types.ts';
+import {InterfaceRunType} from '../collection/interface.ts';
+
+// Non serializable types might not be Atomic but will be skipped so it doesn't matter
+export class NonSerializableRunType extends InterfaceRunType<TypeObjectLiteral | TypeClass> {
+    skipJit() {
+        // skip return false so we ensure the compile functions will throw when a NonSerializable type is used
+        return false;
+    }
+    emitIsType(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitTypeErrors(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitPrepareForJson(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitRestoreFromJson(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitHasUnknownKeys(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitUnknownKeyErrors(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitStripUnknownKeys(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitUnknownKeysToUndefined(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+}

package/src/nodes/native/promise.ts

@@ -0,0 +1,43 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import {type TypePromise} from '@deepkit/type';
+import type {JitCode} from '../../types.ts';
+import {MemberRunType} from '../../lib/baseRunTypes.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+
+export class PromiseRunType extends MemberRunType<TypePromise> {
+    skipJit(comp: JitFnCompiler): boolean {
+        return comp?.fnID !== JitFunctions.toJSCode.id;
+    }
+    emitIsType(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitTypeErrors(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitPrepareForJson(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    emitRestoreFromJson(): JitCode {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+    }
+    isOptional(): boolean {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getChildVarName(comp: JitFnCompiler): string | number {
+        return comp.getLocalVarName('p', this);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getChildLiteral(comp: JitFnCompiler): string | number {
+        return this.getChildVarName(comp);
+    }
+    useArrayAccessor(): boolean {
+        return false;
+    }
+}

package/src/nodes/native/set.ts

@@ -0,0 +1,56 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import type {SrcType} from '../../types.ts';
+import {ReflectionSubKind} from '../../constants.kind.ts';
+import {ReflectionKind, type TypeClass} from '@deepkit/type';
+import {GenericMemberRunType} from '../member/genericMember.ts';
+import {IterableRunType} from './Iterable.ts';
+import {JitFunctions} from '../../constants.functions.ts';
+import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
+import {cpf_safeIterableKey} from '../../run-types-pure-fns.ts';
+export class SetRunType extends IterableRunType {
+    keyRT = new SetKeyRunType();
+    children = [this.keyRT];
+    constructorName = 'Set';
+    onCreated(src: SrcType<TypeClass>): void {
+        const types = src.arguments;
+        if (!types || types.length !== 1) throw new Error(`Set expects 1 type argument: ie: Set<number>`);
+        super.onCreated(src);
+        this.keyRT.onCreated({
+            kind: ReflectionKind.parameter,
+            parent: src,
+            type: types[0],
+            subKind: ReflectionSubKind.setItem,
+        });
+    }
+    getCustomVλl(comp: JitFnCompiler) {
+        // restoreFromJson is decoding a regular array so no need to use an special case for vλl as other operations
+        if (comp.fnID === JitFunctions.restoreFromJson.id)
+            return {vλl: comp.getLocalVarName('it', this), isStandalone: false, useArrayAccessor: true};
+        // other operations use an special case for vλl where all parents are skipped
+        return {vλl: comp.getLocalVarName('it', this), isStandalone: true};
+    }
+}
+
+export class SetKeyRunType extends GenericMemberRunType<any> {
+    index = 0;
+    skipSettingAccessor() {
+        return true;
+    }
+    getStaticPathLiteral(comp: JitFnCompiler): string {
+        const parent = this.getParent()! as SetRunType;
+        const custom = parent.getCustomVλl(comp)!;
+        const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
+        return `{key:${safeKeyFn}(${custom.vλl}),index:${parent.getIndexVarName(comp)}}`;
+    }
+    getCustomVλl(comp: JitFnCompiler) {
+        if (comp.fnID === JitFunctions.fromBinary.id)
+            return {vλl: comp.getLocalVarName('sK', this), isStandalone: true, useArrayAccessor: false};
+        // other operations use an special case for vλl where all parents are skipped
+        return undefined;
+    }
+}

package/src/run-types-pure-fns.ts

@@ -0,0 +1,116 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+import type {TypeFormatError, StrNumber, RunTypeError} from '@mionjs/core';
+import {registerPureFnFactory} from '@mionjs/core';
+
+export const cpf_asJSONString = registerPureFnFactory('mion', 'asJSONString', function () {
+    // @ts-expect-error 2867
+    if (typeof Bun !== 'undefined') return JSON.stringify; // bun has a faster JSON.stringify
+    // eslint-disable-next-line no-control-regex
+    const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+    const MAX_SCAPE_TEST_LENGTH = 1000;
+    return function _asJSONStringRegexOnly(str) {
+        // Always use regex test for strings >= 42 chars (n o for loop)
+        if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
+            return '"' + str + '"';
+        } else {
+            return JSON.stringify(str);
+        }
+    };
+});
+
+export const cpf_getUnknownKeysFromArray = registerPureFnFactory('mion', 'getUnknownKeysFromArray', function () {
+    const MAX_UNKNOWN_KEYS = 10;
+    return function _getUnknownKeysFromArray(obj: Record<StrNumber, any>, keys: StrNumber[]): StrNumber[] {
+        const unknownKeys: StrNumber[] = [];
+        for (const prop in obj) {
+            let found = false;
+            for (let j = 0; j < keys.length; j++) {
+                if (keys[j] === prop) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                unknownKeys.push(prop as string);
+                if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error('Too many unknown keys');
+            }
+        }
+        return unknownKeys;
+    };
+});
+
+export const cpf_hasUnknownKeysFromArray = registerPureFnFactory('mion', 'hasUnknownKeysFromArray', function () {
+    return function _hasUnknownKeysFromArray(obj: Record<StrNumber, any>, keys: StrNumber[]): boolean {
+        for (const prop in obj) {
+            // iterates over the object keys and if not found prop adds to unknownKeys
+            let found = false;
+            for (let j = 0; j < keys.length; j++) {
+                if (keys[j] === prop) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) return true;
+        }
+        return false;
+    };
+});
+
+export const cpf_newRunTypeErr = registerPureFnFactory('mion', 'newRunTypeErr', function () {
+    return function _err(
+        pλth: readonly StrNumber[],
+        εrr: RunTypeError[],
+        expected: string,
+        accessPath?: readonly StrNumber[]
+    ): void {
+        const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
+        const runTypeErr: RunTypeError = {expected, path};
+        εrr.push(runTypeErr);
+    };
+});
+
+export const cpf_formatErr = registerPureFnFactory('mion', 'formatErr', function () {
+    return function _formatErr(
+        pλth: StrNumber[],
+        εrr: RunTypeError[],
+        expected: string,
+        fmtName: string,
+        paramName: string,
+        paramVal: string | number | boolean | bigint,
+        fmtPath: StrNumber[],
+        accessPath?: StrNumber[],
+        fmtAccessPath?: StrNumber[]
+    ): void {
+        const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
+        const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];
+        const format: TypeFormatError = {name: fmtName, formatPath: formatPath, val: paramVal};
+        const runTypeErr: Required<RunTypeError> = {expected, path, format};
+        εrr.push(runTypeErr);
+    };
+});
+
+export const cpf_safeIterableKey = registerPureFnFactory('mion', 'safeIterableKey', function () {
+    return function _safeKey(value: any): any {
+        if (value === undefined) return null;
+        if (value === null) return null;
+        const type = typeof value;
+        if (type === 'number' || type === 'string' || type === 'boolean') return value;
+        return null;
+    };
+});
+
+/** @reflection never */
+export const cpf_sanitizeCompiledFn = registerPureFnFactory('mion', 'sanitizeCompiledFn', function () {
+    const anonymousRegex = /^\s*function\s+anonymous\s*\(/;
+    return function sanitizeCompiled(fnCode: string): string {
+        if (anonymousRegex.test(fnCode)) {
+            return fnCode.replace(anonymousRegex, 'function (');
+        }
+        return fnCode;
+    };
+});

package/src/types.ts

@@ -0,0 +1,206 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+// ###### !IMPORTANT: all imports should be types only to prevent circular dependencies ######
+import type {Type, TypeCallSignature, TypeFunction, TypeMethod, TypeMethodSignature, TypeTuple} from '@deepkit/type';
+import type {TypeFormatParams} from '@mionjs/core';
+import type {JitFunctions} from './constants.functions.ts';
+import type {ReflectionSubKind} from './constants.kind.ts';
+import type {BaseRunTypeFormat} from './lib/baseRunTypeFormat.ts';
+import type {JitFnCompiler} from './lib/jitFnCompiler.ts';
+import type {CodeType} from './constants.functions.ts';
+
+export type StrNumber = string | number;
+
+/** Result of a jit compilation, contains the code and metadata about the code */
+export type JitCode = {
+    code: string | undefined;
+    type: CodeType;
+};
+
+// ############################################ RunTypes ############################################
+
+export type SrcType<T extends Type = Type> = T & {
+    readonly _rt: RunType;
+    readonly _typeId?: StrNumber; // Cached type ID to avoid recalculation (preserves number for atomic types)
+    readonly _formatId?: string; // Cached format ID (empty string means no format, undefined means not computed yet)
+    readonly subKind?: SubKind;
+};
+
+export type RunTypeFamily = 'A' | 'C' | 'M' | 'F'; // Atomic, Collection, Member, Function
+
+/**
+ * Runtime Metadata for a typescript types.
+ */
+export interface RunType {
+    readonly src: SrcType<any>;
+    getKindName(): string;
+    getFamily(): RunTypeFamily; // Atomic, Collection, Member, Function
+    mock: (options?: DeepPartial<RunTypeOptions>) => Promise<any>;
+
+    // ######## JIT functions ########
+    /** Returns a unique id for the type. it can be a long string similar to the typescript type itself but as shorter as possible */
+    getTypeID(): StrNumber;
+    getJitHash(opts: RunTypeOptions): string;
+    createJitFunction(jitFn: JitFn, opts?: RunTypeOptions): (...args: any[]) => any;
+}
+
+export type SubKind = (typeof ReflectionSubKind)[keyof typeof ReflectionSubKind];
+export type RunTypeVisitor = (deepkitType: Type, parents: RunType[], opts: RunTypeOptions) => RunType;
+export type SrcCollection = Type & {types: Type[]};
+export type SrcMember = Type & {type: Type};
+
+export interface JitCompilerOpts {
+    readonly fnID: string;
+    readonly typeID: StrNumber;
+    readonly jitFnHash: string;
+    readonly opts: RunTypeOptions;
+}
+
+export interface RunTypeChildAccessor extends RunType {
+    /**
+     * Returns the position of the child within the parent type.
+     */
+    getChildIndex(comp: JitFnCompiler): number;
+    /**
+     * Returns the variable name for the compiled child
+     * ie: for an object property, it should return the property name
+     * ie: for an array member, it should return the index variable name
+     */
+    getChildVarName(comp: JitFnCompiler): StrNumber;
+    /** Returns the static member name or literal as it should be inserted in source code.
+     * ie: for an object property, it should return the property name as a string encapsulated in quotes, ie: prop => 'prop'
+     * ie: for an array member, it should return the varName as is a dynamic value, ie: index => index
+     */
+    getChildLiteral(comp: JitFnCompiler): StrNumber;
+    /** Returns true if the property name is safe to use as a property accessor in source code
+     * ie: return false if a property can be accessed using the dot notation, ie: obj.prop, for properties that are numbers return false
+     * ie: for an array member return true as it should be accessed using the array accessor, ie: obj[index]
+     */
+    useArrayAccessor(): boolean;
+    /** Returns true if the property is optional */
+    isOptional(): boolean;
+    /** Some runType nodes might have some logic or being par of the AST, but we might not want to modify current stack variable vλl.
+     * Ie: (Rest params) is alway a child of a tupleMember, in this case we want vλl to point to the rest param and not the tuple member.
+     * so we want to skip setting the accessor in the parent.  */
+    skipSettingAccessor?(): boolean;
+    /** used to compile json stringify, items with the flag set will omit outputting comma after the item */
+    skipCommas?: boolean;
+}
+export interface CustomVλl {
+    vλl: string;
+    isStandalone?: boolean;
+    useArrayAccessor?: boolean;
+}
+
+export interface RunTypeOptions {
+    /** Slice parameters when parsing functions, so some parameter can be omitted from jit generation */
+    paramsSlice?: {start?: number; end?: number};
+    mock?: MockOptions;
+    /**
+     * When compiling literals will use the  Literal's type instead of the literal value.
+     * ie `type A = 'a'`  will be compiled as it was `type A = string` so will accept any string value not only 'a'
+     */
+    noLiterals?: boolean;
+    /**
+     * Skip checking array and just check for items type
+     * this speeds up isType and typeErrors functions but will not validate array length.
+     */
+    noIsArrayCheck?: boolean;
+    /** When true, isType and typeErrors will also reject objects with unknown/extra properties */
+    strictTypes?: boolean;
+}
+
+export type PartialRunTypeOptions = DeepPartial<RunTypeOptions>;
+
+// ############################################ JIT FUNCTIONS ############################################
+
+export type JitFn = (typeof JitFunctions)[keyof typeof JitFunctions];
+
+// one of the existing jit functions ids
+export type JitFnID = JitFn['id'];
+
+export type AnyFunction = TypeMethodSignature | TypeCallSignature | TypeFunction | TypeMethod;
+export type AnyParameterListRunType = AnyFunction | TypeTuple;
+
+// ############################################ MOCKING ############################################
+
+export interface MockOptions {
+    anyValuesList: any[];
+    minNumber?: number;
+    maxNumber?: number;
+    minDate?: number;
+    maxDate?: number;
+    enumIndex?: number;
+    objectList: object[];
+    promiseTimeOut: number;
+    promiseReject?: string | Error | any;
+    regexpList: RegExp[];
+    maxRandomStringLength: number;
+    stringLength?: number;
+    stringCharSet: string;
+    symbolLength?: number;
+    symbolCharSet?: string;
+    symbolName?: string;
+    maxRandomItemsLength: number;
+    arrayLength?: number;
+    /** probability to generate options types, number between 0 and 1,
+     * bigger values have bigger probability of generate the optional property */
+    optionalProbability: number;
+    /** probability to generate an specific property of an object, number between 0 and 1 */
+    optionalPropertyProbability?: Record<StrNumber, number>; // TODO change to a record of MockOptions
+    parentObj?: Record<StrNumber | symbol, any>;
+    /** the index of the object to mock withing the union */
+    unionIndex?: number;
+    tupleOptions?: MockOptions[];
+    paramsOptions?: MockOptions[];
+    maxStackDepth: number;
+    maxMockRecursion: number;
+}
+
+export interface MockOperation extends MockOptions {
+    /** Used for mocking object with circular references */
+    stack: RunType[];
+    fnID: JitFnID;
+}
+
+export type DKAnnotation = {
+    name: string;
+    options: SrcType;
+};
+
+export type FormatAnnotation = DKAnnotation & {
+    params?: TypeFormatParams;
+    formatter: BaseRunTypeFormat;
+};
+
+export type RunTypeAnnotation = {
+    name: string;
+    options: RunType;
+};
+
+// ############################################ OTHERS ############################################
+
+/** Any Class */
+export interface AnyClass<T = any> {
+    new (...args: any[]): T;
+}
+
+export type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+
+export type DeepRequired<T> = T extends object
+    ? {
+          [P in keyof T]?: DeepRequired<T[P]>;
+      }
+    : T;
+
+export type DeepPartial<T> = T extends object
+    ? {
+          [P in keyof T]?: DeepPartial<T[P]>;
+      }
+    : T;