@mionjs/router 0.8.10 → 0.13.0

package/src/lib/remoteMethods.ts

@@ -1,180 +0,0 @@
-/* ########
- * 2023 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {type RouterEntry, type Routes} from '../types/general.ts';
-import {type RemoteMethod} from '../types/remoteMethods.ts';
-import type {PublicApi} from '../types/publicMethods.ts';
-import type {
-    AnyObject,
-    JitCompiledFn,
-    JitCompiledFnData,
-    PureFunctionData,
-    MethodWithOptions,
-    PureFnsDataCache,
-} from '@mionjs/core';
-import {isRoute, isHeadersMiddleFnDef, isMiddleFnDef} from '../types/guards.ts';
-import {getMiddleFnExecutable, getRouteExecutable, isPrivateDefinition} from '../router.ts';
-import {getRouterItemId, MAX_STACK_DEPTH, getJitFnHashes, getJitUtils, EMPTY_HASH} from '@mionjs/core';
-
-// ############# PRIVATE STATE #############
-const publicMethods: Map<string, MethodWithOptions> = new Map();
-
-// ############# PUBLIC METHODS #############
-export function resetRemoteMethodsMetadata() {
-    publicMethods.clear();
-}
-
-/**
- * Returns a data structure containing all public information and types of the routes.
- * This data and types can be used to generate router clients, etc...
- */
-export function getPublicApi<R extends Routes>(routes: R): PublicApi<R> {
-    return recursiveGetSerializableRoutes(routes) as PublicApi<R>;
-}
-
-// ############# PRIVATE METHODS #############
-
-function recursiveGetSerializableRoutes<R extends Routes>(
-    routes: R,
-    currentPointer: string[] = [],
-    publicData: AnyObject = {}
-): AnyObject {
-    const entries = Object.entries(routes);
-    entries.forEach(([key, item]: [string, RouterEntry]) => {
-        const itemPointer = [...currentPointer, key];
-        const id = getRouterItemId(itemPointer);
-
-        if (isPrivateDefinition(item, id)) {
-            publicData[key] = null; // middleFns that don't receive or return data are not public
-        } else if (isMiddleFnDef(item) || isHeadersMiddleFnDef(item) || isRoute(item)) {
-            const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);
-            if (!executable)
-                throw new Error(`Route or MiddleFn ${id} not found. Please check you have called router.registerRoutes first.`);
-            publicData[key] = getSerializableMethod(executable as RemoteMethod);
-        } else {
-            const subRoutes: Routes = routes[key] as Routes;
-            publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);
-        }
-    });
-
-    return publicData;
-}
-
-export function getSerializableMethod(executable: RemoteMethod): MethodWithOptions {
-    const existing = publicMethods.get(executable.id);
-    if (existing) return existing as MethodWithOptions;
-
-    const newRemoteMethod: MethodWithOptions = {
-        type: executable.type,
-        id: executable.id,
-        nestLevel: executable.nestLevel,
-        isAsync: executable.isAsync,
-        hasReturnData: executable.hasReturnData,
-        paramsJitHash: executable.paramsJitHash,
-        returnJitHash: executable.returnJitHash,
-        pointer: executable.pointer,
-        ...(executable.paramNames ? {paramNames: executable.paramNames} : {}),
-        options: executable.options,
-    };
-    if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;
-    if (executable.middleFnIds) newRemoteMethod.middleFnIds = executable.middleFnIds;
-    publicMethods.set(executable.id, newRemoteMethod);
-    return newRemoteMethod as MethodWithOptions;
-}
-
-/** Serializes pure function dependencies into a namespaced cache structure.
- * @param namespacedDepHash - Pure function dependency in format "namespace::fnHash"
- * @param purFnDeps - Namespaced cache to store serialized pure functions
- * @param depth - Current recursion depth for stack overflow protection
- */
-export function serializePureDeps(namespacedDepHash: string, purFnDeps: PureFnsDataCache, depth = 0) {
-    if (depth >= MAX_STACK_DEPTH)
-        throw new Error(`Max depth reached serializing pure function dependencies, for: ${namespacedDepHash}`);
-    // Parse "namespace::fnHash" format
-    const parts = namespacedDepHash.split('::');
-    if (parts.length !== 2)
-        throw new Error(`Invalid pure function dependency format: ${namespacedDepHash}, expected "namespace::fnHash"`);
-    const [namespace, fnHash] = parts;
-    // Ensure namespace exists in the cache
-    if (!purFnDeps[namespace]) purFnDeps[namespace] = {};
-    // Check if already serialized (prevent infinite recursion on circular dependencies)
-    if (purFnDeps[namespace][fnHash]) return;
-    const pureDep = getJitUtils().getCompiledPureFn(namespace, fnHash);
-    if (!pureDep) throw new Error(`Pure function ${fnHash} not found in namespace ${namespace}`);
-    const serializedPureDep: PureFunctionData = {
-        ...pureDep,
-        pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : undefined,
-    };
-    purFnDeps[namespace][fnHash] = serializedPureDep;
-    // Dependencies within the same namespace are stored as just fnHash, not namespaced
-    pureDep.pureFnDependencies?.forEach((depFnHash) => serializePureDeps(`${namespace}::${depFnHash}`, purFnDeps, depth + 1));
-}
-
-export function serializeJitFn(
-    jitFnHash: string,
-    deps: Record<string, JitCompiledFnData>,
-    purFnDeps: PureFnsDataCache,
-    depth = 0
-) {
-    if (depth >= MAX_STACK_DEPTH)
-        throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${jitFnHash}`);
-    const jitFn = getJitUtils().getJIT(jitFnHash);
-    if (!jitFn) throw new Error(`Jit function ${jitFnHash} not found`);
-    if (deps[jitFnHash]) return; // already serialized and prevent infinite recursion on circular dependencies
-    const serializedJitFn = getSerializableJitCompiler(jitFn);
-    deps[jitFnHash] = serializedJitFn;
-    jitFn.jitDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));
-    jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));
-}
-
-export function serializeMethodDeps(
-    method: MethodWithOptions,
-    deps: Record<string, JitCompiledFnData>,
-    purFnDeps: PureFnsDataCache
-) {
-    const {paramsJitHash, returnJitHash} = method;
-    // Skip serialization for empty hashes (no params or void return)
-    // Always request binary hashes so they are included when available (e.g. middleware in binary routes).
-    // serializeJitFn is only called when the JIT function exists in the store, so non-binary methods are unaffected.
-    if (paramsJitHash !== EMPTY_HASH) {
-        const paramsJitHashes = getJitFnHashes(paramsJitHash, true);
-        for (const k in paramsJitHashes) {
-            if (getJitUtils().getJIT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);
-        }
-    }
-    if (returnJitHash !== EMPTY_HASH) {
-        const returnJitHashes = getJitFnHashes(returnJitHash, true);
-        let foundAny = false;
-        for (const k in returnJitHashes) {
-            if (getJitUtils().getJIT(returnJitHashes[k])) {
-                serializeJitFn(returnJitHashes[k], deps, purFnDeps);
-                foundAny = true;
-            }
-        }
-        if (!foundAny) {
-            throw new Error(
-                `Method "${method.id}" declares returnJitHash="${returnJitHash}" but no JIT functions are registered under that hash. ` +
-                    `This usually means a Promise/Function return type was not unwrapped before computing the hash.`
-            );
-        }
-    }
-}
-
-function getSerializableJitCompiler(comp: JitCompiledFn): JitCompiledFnData {
-    return {
-        typeName: comp.typeName,
-        fnID: comp.fnID,
-        jitFnHash: comp.jitFnHash,
-        args: structuredClone(comp.args),
-        isNoop: comp.isNoop,
-        defaultParamValues: structuredClone(comp.defaultParamValues),
-        code: comp.code,
-        jitDependencies: comp.jitDependencies ? [...comp.jitDependencies] : undefined,
-        pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : undefined,
-        ...(comp.paramNames ? {paramNames: [...comp.paramNames]} : {}),
-    };
-}

package/src/lib/test/aotEmitter-test-router.ts

@@ -1,40 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-/**
- * Test router script for AOT emitter tests.
- * This script is spawned as a child process with MION_COMPILE=buildOnly
- * to test that emitAOTCaches() correctly sends IPC messages.
- *
- * Uses initMionRouter which automatically calls emitAOTCaches() when MION_COMPILE=buildOnly.
- */
-
-import {initMionRouter, route, middleFn, Routes, PublicApi} from '@mionjs/router';
-
-interface User {
-    id: string;
-    name: string;
-}
-
-const routes = {
-    users: {
-        getUser: route((ctx, id: string): User => ({id, name: 'Test User'})),
-        createUser: route((ctx, user: User): string => `Created user ${user.name}`),
-    },
-    utils: {
-        sum: route((ctx, a: number, b: number): number => a + b),
-    },
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    log: middleFn((ctx): void => {
-        // Log middleFn
-    }),
-} satisfies Routes;
-
-// Initialize the router - this will call emitAOTCaches() automatically when MION_COMPILE=buildOnly
-export const testApiPromise: Promise<PublicApi<typeof routes>> = initMionRouter(routes, {basePath: 'api/v1'});
-
-export {routes};