@mionjs/devtools 0.8.10 → 0.13.2

package/src/vite-plugin/resolveModule.ts

@@ -1,50 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-/**
- * Inlined from @mionjs/core/src/utils.ts to avoid the vite plugin depending on core.
- * Keep in sync with the original implementation.
- */
-
-import {resolve} from 'path/posix';
-import {fileURLToPath} from 'url';
-
-/** Resolves a module path in both CJS and ESM environments. */
-export async function resolveModule(moduleName: string, callerDir?: string): Promise<string> {
-    const resolvedPath = moduleName.startsWith('.') && callerDir ? resolve(callerDir, moduleName) : moduleName;
-    const metaResolve = getImportMetaResolve();
-    if (metaResolve) {
-        const resolved = await metaResolve(resolvedPath);
-        if (resolved) return resolved.startsWith('file:') ? fileURLToPath(resolved) : resolved;
-    }
-
-    try {
-        if (typeof require !== 'undefined' && typeof require.resolve === 'function') return require.resolve(resolvedPath);
-    } catch {
-        // Ignore and fall back to createRequire
-    }
-
-    try {
-        const {createRequire} = await import('module');
-        const basePath = callerDir ? resolve(callerDir, 'noop.js') : resolve(process.cwd(), 'noop.js');
-        const requireFn = createRequire(basePath);
-        return requireFn.resolve(resolvedPath);
-    } catch (err) {
-        throw new Error(`Failed to resolve module "${moduleName}": ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-
-function getImportMetaResolve(): ((specifier: string) => string | Promise<string> | undefined) | undefined {
-    try {
-        // eslint-disable-next-line no-new-func
-        return new Function('specifier', 'return import.meta.resolve?.(specifier);') as (
-            specifier: string
-        ) => string | Promise<string> | undefined;
-    } catch {
-        return undefined;
-    }
-}

package/src/vite-plugin/transformers.ts

@@ -1,209 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-// based on https://github.com/marcj/deepkit/blob/e7da3b48c50115d6e59e233eb9f018513d4d68ce/packages/vite/src/plugin.ts
-
-import {createFilter} from '@rollup/pluginutils';
-import * as ts from 'typescript';
-import {transformer, declarationTransformer} from '@deepkit/type-compiler';
-import {DeepkitTypeOptions, ExtractedPureFn} from './types.ts';
-import {extractPureFnsFromSource} from './extractPureFn.ts';
-
-// ── Deepkit ─────────────────────────────────────────────────────────
-
-/** Deepkit configuration components for integration into the unified transform pipeline */
-export interface DeepkitConfig {
-    filter: (fileName: string) => boolean;
-    compilerOptions: ts.CompilerOptions;
-    beforeTransformers: ts.CustomTransformerFactory[];
-    afterTransformers: ts.CustomTransformerFactory[];
-}
-
-/**
- * Post-deepkit transformer that converts require() calls back to import declarations.
- * Deepkit's getModuleType() reads tsconfig's module:NodeNext and falls back to 'cjs'
- * because ts.transpileModule doesn't set sourceFile.impliedNodeFormat. This causes
- * deepkit to emit `var {__ΩFoo} = require("./bar.ts")` instead of ESM imports.
- * This transformer converts those back to `import {__ΩFoo} from "./bar.ts"` so Rollup
- * can properly resolve and rewrite the module specifiers.
- */
-const requireToImport: ts.CustomTransformerFactory = (context: ts.TransformationContext): ts.CustomTransformer => ({
-    transformSourceFile(sf: ts.SourceFile): ts.SourceFile {
-        const newStatements: ts.Statement[] = [];
-        let changed = false;
-        for (const stmt of sf.statements) {
-            const converted = tryConvertRequireToImport(context.factory, stmt);
-            if (converted) {
-                newStatements.push(converted);
-                changed = true;
-            } else {
-                newStatements.push(stmt);
-            }
-        }
-        return changed ? context.factory.updateSourceFile(sf, newStatements) : sf;
-    },
-    transformBundle(b: ts.Bundle): ts.Bundle {
-        return b;
-    },
-});
-
-/**
- * Converts CJS require patterns to ESM import declarations:
- * - `var {a, b} = require("./path")` → `import {a, b} from "./path"`
- * - `var mod = require("./path")` → `import mod from "./path"`
- */
-function tryConvertRequireToImport(f: ts.NodeFactory, stmt: ts.Statement): ts.ImportDeclaration | undefined {
-    if (!ts.isVariableStatement(stmt)) return undefined;
-    const decls = stmt.declarationList.declarations;
-    if (decls.length !== 1) return undefined;
-    const decl = decls[0];
-    if (!decl.initializer || !ts.isCallExpression(decl.initializer)) return undefined;
-    const callee = decl.initializer.expression;
-    if (!ts.isIdentifier(callee) || callee.text !== 'require') return undefined;
-    if (decl.initializer.arguments.length !== 1) return undefined;
-    const specArg = decl.initializer.arguments[0];
-    if (!ts.isStringLiteral(specArg)) return undefined;
-
-    // var {a, b} = require("./path") → import {a, b} from "./path"
-    if (ts.isObjectBindingPattern(decl.name)) {
-        const specifiers = decl.name.elements.map((el) =>
-            f.createImportSpecifier(false, undefined, f.createIdentifier((el.name as ts.Identifier).text))
-        );
-        return f.createImportDeclaration(
-            undefined,
-            f.createImportClause(false, undefined, f.createNamedImports(specifiers)),
-            f.createStringLiteral(specArg.text)
-        );
-    }
-
-    // var mod = require("./path") → import mod from "./path"
-    if (ts.isIdentifier(decl.name)) {
-        return f.createImportDeclaration(
-            undefined,
-            f.createImportClause(false, f.createIdentifier(decl.name.text), undefined),
-            f.createStringLiteral(specArg.text)
-        );
-    }
-
-    return undefined;
-}
-
-/** Creates deepkit config components that can be integrated into a unified ts.transpileModule call */
-export function createDeepkitConfig(options: DeepkitTypeOptions = {}): DeepkitConfig {
-    const filter = createFilter(options.include ?? ['**/*.tsx', '**/*.ts'], options.exclude ?? 'node_modules/**');
-    return {
-        filter: (fileName: string) => filter(fileName),
-        compilerOptions: {
-            target: ts.ScriptTarget.ESNext,
-            module: ts.ModuleKind.ESNext,
-            sourceMap: true,
-            configFilePath: options.tsConfig || process.cwd() + '/tsconfig.json',
-            ...(options.compilerOptions || {}),
-        },
-        beforeTransformers: [transformer],
-        afterTransformers: [declarationTransformer, requireToImport],
-    };
-}
-
-// ── Pure function transformer ───────────────────────────────────────
-
-/**
- * Creates a TypeScript CustomTransformerFactory that injects build-time data into pure function calls.
- * For pureServerFn(def): injects bodyHash as 2nd argument.
- * For registerPureFnFactory(ns, id, fn): injects ParsedFactoryFn as 4th argument.
- *
- * Pre-extracts data using existing extractPureFnsFromSource to ensure hash consistency
- * with the virtual module cache (same whole-file esbuild strip + JS AST path).
- */
-export function createPureFnTransformerFactory(
-    originalSource: string,
-    filePath: string,
-    collector?: ExtractedPureFn[],
-    noViteClient = false
-): ts.CustomTransformerFactory {
-    const hasPureServerFn = originalSource.includes('pureServerFn');
-    const hasFactory = originalSource.includes('registerPureFnFactory');
-    const hasMapFrom = originalSource.includes('mapFrom');
-
-    const pureServerFns = hasPureServerFn ? extractPureFnsFromSource(originalSource, filePath, 'pureServerFn', noViteClient) : [];
-    const factoryFns = hasFactory ? extractPureFnsFromSource(originalSource, filePath, 'registerPureFnFactory') : [];
-    const mapFromFns = hasMapFrom ? extractPureFnsFromSource(originalSource, filePath, 'mapFrom', noViteClient) : [];
-
-    return (context: ts.TransformationContext): ts.CustomTransformer => {
-        let pureIdx = 0;
-        let factoryIdx = 0;
-        let mapFromIdx = 0;
-
-        function visitor(node: ts.Node): ts.Node {
-            if (ts.isCallExpression(node)) {
-                const callee = node.expression;
-                if (ts.isIdentifier(callee)) {
-                    if (callee.text === 'pureServerFn' && pureIdx < pureServerFns.length) {
-                        if (node.arguments.length >= 2) {
-                            pureIdx++;
-                            return ts.visitEachChild(node, visitor, context);
-                        }
-                        const data = pureServerFns[pureIdx++];
-                        collector?.push(data);
-                        return context.factory.updateCallExpression(node, node.expression, node.typeArguments, [
-                            ...node.arguments,
-                            context.factory.createStringLiteral(data.bodyHash),
-                        ]);
-                    }
-                    if (callee.text === 'registerPureFnFactory' && factoryIdx < factoryFns.length) {
-                        if (node.arguments.length >= 4) {
-                            factoryIdx++;
-                            return ts.visitEachChild(node, visitor, context);
-                        }
-                        const data = factoryFns[factoryIdx++];
-                        collector?.push(data);
-                        return context.factory.updateCallExpression(node, node.expression, node.typeArguments, [
-                            ...node.arguments,
-                            createParsedFactoryFnNode(context.factory, data),
-                        ]);
-                    }
-                    if (callee.text === 'mapFrom' && mapFromIdx < mapFromFns.length) {
-                        // mapFrom(source, mapper) -> mapFrom(source, mapper, 'bodyHash')
-                        if (node.arguments.length >= 3) {
-                            mapFromIdx++;
-                            return ts.visitEachChild(node, visitor, context);
-                        }
-                        const data = mapFromFns[mapFromIdx++];
-                        collector?.push(data);
-                        return context.factory.updateCallExpression(node, node.expression, node.typeArguments, [
-                            ...node.arguments,
-                            context.factory.createStringLiteral(data.bodyHash),
-                        ]);
-                    }
-                }
-            }
-            return ts.visitEachChild(node, visitor, context);
-        }
-
-        return {
-            transformSourceFile(sourceFile: ts.SourceFile): ts.SourceFile {
-                if (pureServerFns.length === 0 && factoryFns.length === 0 && mapFromFns.length === 0) return sourceFile;
-                return ts.visitNode(sourceFile, visitor) as ts.SourceFile;
-            },
-            transformBundle(bundle: ts.Bundle): ts.Bundle {
-                return bundle;
-            },
-        };
-    };
-}
-
-/** Creates an AST node for {bodyHash: '...', paramNames: [...], code: '...'} */
-function createParsedFactoryFnNode(factory: ts.NodeFactory, data: ExtractedPureFn): ts.ObjectLiteralExpression {
-    return factory.createObjectLiteralExpression([
-        factory.createPropertyAssignment('bodyHash', factory.createStringLiteral(data.bodyHash)),
-        factory.createPropertyAssignment(
-            'paramNames',
-            factory.createArrayLiteralExpression(data.paramNames.map((n) => factory.createStringLiteral(n)))
-        ),
-        factory.createPropertyAssignment('code', factory.createStringLiteral(data.fnBody)),
-    ]);
-}

package/src/vite-plugin/types.ts

@@ -1,182 +0,0 @@
-import {CompilerOptions} from 'typescript';
-
-/** AOT cache generation options for the Vite plugin */
-export interface AOTCacheOptions {
-    /** Excluded JIT function IDs */
-    excludedFns?: string[];
-
-    /** Excluded pure function names */
-    excludedPureFns?: string[];
-
-    /**
-     * Disk caching for AOT compilation results.
-     * Caches the compiled output so subsequent builds skip the expensive vite-node compile step
-     * when server source hasn't changed.
-     * - true (default): Cache in Vite's cacheDir (node_modules/.vite/)
-     * - string: Custom cache directory path
-     * - false: Disable disk caching
-     *
-     * Set env MION_AOT_FORCE=true to force regeneration regardless of this setting.
-     */
-    cache?: boolean | string;
-
-    /**
-     * Stub out @mionjs/run-types and @deepkit/* modules during the bundle build.
-     * When AOT caches are pre-compiled, these modules are not needed at runtime
-     * and can be replaced with empty stubs to reduce bundle size.
-     * Useful for edge runtime builds where bundle size matters.
-     *
-     * Only applies to the parent build process — the AOT child process (MION_COMPILE=buildOnly)
-     * always uses the real modules to generate caches.
-     */
-    excludeReflection?: boolean;
-
-    /**
-     * Register additional virtual modules with a custom prefix, resolving to the same AOT cache data.
-     * Useful for creating virtual modules (e.g. `virtual:client-mion-aot/*`) that imports from
-     * these prefixed virtual modules in source, while Vite/Rollup resolves and bundles them
-     * into the build output automatically.
-     *
-     * The plugin resolves `virtual:{id}/jit-fns`, `virtual:{id}/pure-fns`,
-     * `virtual:{id}/router-cache`, and `virtual:{id}/caches`.
-     *
-     * Example: `'client-mion-aot'` → `virtual:client-mion-aot/jit-fns`
-     */
-    customVirtualModuleId?: string;
-
-    /**
-     * When true, strips unused metadata properties (code, args, defaultParamValues, fnID, paramNames)
-     * from AOT caches to reduce client bundle size. The closure functions (createJitFn/createPureFn)
-     * are still serialized and sufficient for runtime restoration.
-     */
-    isClient?: boolean;
-}
-
-/** Server configuration for the mion Vite plugin */
-export interface MionServerConfig {
-    /**
-     * Path to the server start script that initializes the router.
-     *
-     * The plugin will run this script to generate AOT caches for ALL routes
-     * (internal mion routes + your custom routes).
-     *
-     * If server is not configured, the plugin will automatically use the built-in defaultRoutes.ts
-     * from @mionjs/router to generate caches for internal mion routes only.
-     * Your custom routes will be fetched at runtime via fetchRemoteMethodsMetadata().
-     */
-    startScript: string;
-
-    /**
-     * Path to the server's vite.config.ts file.
-     * Used by vite-node to run the start script with proper transformations.
-     * If not provided, vite-node will auto-discover the config from the
-     * startScript's directory.
-     */
-    viteConfig?: string;
-
-    /**
-     * Server run mode:
-     * - 'buildOnly': spawn child process, get AOT caches, kill process (default)
-     * - 'childProcess': spawn child process, get AOT caches via IPC, keep server running
-     * - 'middleware': load in same Vite process as middleware (for Nuxt-like frameworks)
-     */
-    runMode: 'buildOnly' | 'childProcess' | 'middleware';
-
-    /** Max wait time in ms for the server's platform adapter to call setPlatformConfig() (default 30000).
-     *  Only applies in childProcess mode. When set, the plugin waits for a
-     *  mion-platform-ready IPC message before resolving serverReady. */
-    waitTimeout?: number;
-
-    /** Extra environment variables passed to the child process (buildOnly/childProcess modes). */
-    env?: Record<string, string>;
-
-    /** Extra arguments appended after the start script in the child process (buildOnly/childProcess modes). */
-    args?: string[];
-}
-
-/** Serializable registry entry for a single pure function */
-export interface PureServerFnRegistryEntry {
-    readonly namespace: string;
-    /** The function name (required for lookup) */
-    readonly fnName: string;
-    readonly paramNames: string[];
-    readonly code: string;
-    /** Hash of the function body - used for version validation */
-    readonly bodyHash: string;
-    readonly dependencies: Set<string>;
-    /** Indicates if this is a factory function that receives jitUtils */
-    readonly isFactory: boolean;
-}
-
-/** The serializable registry shape written to disk (keyed by namespace::fnName) */
-export interface PureServerFnRegistry {
-    readonly version: string;
-    /** Entries keyed by namespace::fnName */
-    readonly entries: Record<string, PureServerFnRegistryEntry>;
-}
-
-/** Plugin options for the server-side Vite plugin */
-export interface ServerPureFunctionsOptions {
-    /** Path to the client package source directory containing pureServerFn() calls */
-    clientSrcPath: string;
-    /** Glob patterns for files to scan within clientSrcPath. Defaults to ['**\/*.ts', '**\/*.tsx', '**\/*.vue'] */
-    include?: string[];
-    /** Glob patterns for files to exclude from scanning */
-    exclude?: string[];
-    /**
-     * When true, requires all pureServerFn() and mapFrom() calls to have an explicit name/identifier
-     * as a string literal argument. This enables non-Vite clients (e.g. Next.js with Turbopack)
-     * to use these functions without build-time transforms.
-     */
-    noViteClient?: boolean;
-}
-
-/** Extracted function data from AST analysis */
-export interface ExtractedPureFn {
-    /** The namespace this pure function belongs to */
-    namespace: string;
-    /** The function name (required for lookup via namespace::fnName) */
-    fnName: string;
-    paramNames: string[];
-    /** The normalized function body code */
-    fnBody: string;
-    /** Hash of the function body - used for version validation */
-    bodyHash: string;
-    /** Dependencies in format "namespace::fnName" */
-    dependencies: Set<string>;
-    sourceFile: string;
-    /** Indicates if this is a factory function that receives jitUtils */
-    isFactory: boolean;
-}
-
-/** Pre-parsed factory function data injected at build time by the mion vite plugin (duplicated from core, can't share types) */
-export interface ParsedFactoryFn {
-    /** Hash of the function body */
-    readonly bodyHash: string;
-    /** The names of the factory function parameters */
-    readonly paramNames: string[];
-    /** The normalized function body code */
-    readonly code: string;
-}
-
-/** Reflection mode for deepkit type compiler */
-export type ReflectionMode = 'default' | 'explicit' | 'never';
-
-/** Options for deepkit type transformation */
-export interface DeepkitTypeOptions {
-    /** Glob patterns to include. Defaults to ['**\/*.tsx', '**\/*.ts'] */
-    include?: string | string[];
-
-    /**  Glob patterns to exclude. Defaults to 'node_modules/**' */
-    exclude?: string | string[];
-    /**  Path to tsconfig.json. If not provided, will search from project root. */
-    tsConfig?: string;
-    /**
-     * Override reflection mode. If not set, uses tsconfig's reflection option.
-     * Set to 'default' to enable reflection for all files regardless of tsconfig.
-     * Useful for simple projects without explicit tsconfig reflection configuration.
-     */
-    reflection?: ReflectionMode;
-    /** Additional compiler options to merge with tsconfig.json */
-    compilerOptions?: CompilerOptions;
-}

package/src/vite-plugin/virtual-modules.d.ts

@@ -1,48 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-/** Exports JIT functions cache data. */
-declare module 'virtual:mion-aot/jit-fns' {
-    export const jitFnsCache: Record<string, any>;
-}
-
-/** Exports pure functions cache data. */
-declare module 'virtual:mion-aot/pure-fns' {
-    export const pureFnsCache: Record<string, Record<string, any>>;
-}
-
-/** Exports router methods cache data. */
-declare module 'virtual:mion-aot/router-cache' {
-    export const routerCache: Record<string, any>;
-}
-
-/**
- * Combined AOT caches module.
- * Imports all 3 cache modules, registers them via addAOTCaches() and addRoutesToCache(),
- * and re-exports the cache data for manual re-registration (e.g. after resetClientCaches in tests).
- */
-declare module 'virtual:mion-aot/caches' {
-    export const jitFnsCache: Record<string, any>;
-    export const pureFnsCache: Record<string, Record<string, any>>;
-    export const routerCache: Record<string, any>;
-}
-
-/** Virtual module for server pure functions extracted from client source at build time. */
-declare module 'virtual:mion-server-pure-fns' {
-    interface ServerPureFnEntry {
-        namespace: string;
-        fnName: string;
-        paramNames: string[];
-        code: string;
-        bodyHash: string;
-        pureFnDependencies?: string[];
-        isFactory: boolean;
-        fn: ((...args: any[]) => any) | undefined;
-        createFn?: (jitUtils: any) => (...args: any[]) => any;
-    }
-    export const serverPureFnsCache: Record<string, Record<string, ServerPureFnEntry>>;
-}

package/src/vite-plugin/virtualModule.ts

@@ -1,94 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {ExtractedPureFn} from './types.ts';
-
-/** Generates the virtual module source code from extracted server pure functions */
-export function generateServerPureFnsVirtualModule(extractedFns: ExtractedPureFn[]): string {
-    // Group functions by namespace
-    const byNamespace = new Map<string, ExtractedPureFn[]>();
-    for (const fn of extractedFns) {
-        const list = byNamespace.get(fn.namespace) || [];
-        list.push(fn);
-        byNamespace.set(fn.namespace, list);
-    }
-
-    // Generate nested namespace entries
-    const namespaceEntries: string[] = [];
-    for (const [namespace, fns] of byNamespace) {
-        const fnEntries = fns.map((fn) => generateEntryCode(fn));
-        namespaceEntries.push(`    ${JSON.stringify(namespace)}: {\n${fnEntries.join(',\n')}\n    }`);
-    }
-
-    return `// Auto-generated by @mionjs/server-pure-functions
-// Do not edit manually
-
-export const serverPureFnsCache = {
-${namespaceEntries.join(',\n')}
-};
-`;
-}
-
-/** Generates the code for a single server pure function entry */
-function generateEntryCode(fn: ExtractedPureFn): string {
-    const paramsArray = fn.paramNames.map((p) => JSON.stringify(p)).join(', ');
-
-    // Convert dependencies from "namespace::fnName" to just "fnName" (same-namespace resolution)
-    const depsArray = [...fn.dependencies].map((d) => {
-        const parts = d.split('::');
-        return JSON.stringify(parts.length === 2 ? parts[1] : d);
-    });
-
-    // Generate the function code
-    const fnCode = fn.isFactory ? generateFactoryFn(fn) : generateDirectFn(fn);
-
-    const depsLine = depsArray.length > 0 ? `\n            pureFnDependencies: [${depsArray.join(', ')}],` : '';
-
-    return `        ${JSON.stringify(fn.fnName)}: {
-            namespace: ${JSON.stringify(fn.namespace)},
-            fnName: ${JSON.stringify(fn.fnName)},
-            paramNames: [${paramsArray}],
-            code: ${JSON.stringify(fn.fnBody)},
-            bodyHash: ${JSON.stringify(fn.bodyHash)},${depsLine}
-            isFactory: ${fn.isFactory},
-${fnCode}
-        }`;
-}
-
-/** Generates a direct fn property for a regular pure function */
-function generateDirectFn(fn: ExtractedPureFn): string {
-    const params = fn.paramNames.join(', ');
-    const safeName = makeSafeFunctionName(fn.fnName);
-
-    return `            fn: function ${safeName}(${params}) {
-                ${fn.fnBody}
-            },`;
-}
-
-/** Generates createFn + fn: undefined for a factory function */
-function generateFactoryFn(fn: ExtractedPureFn): string {
-    const params = fn.paramNames.join(', ');
-    const safeName = makeSafeFunctionName(fn.fnName);
-
-    return `            fn: undefined,
-            createFn: function ${safeName}(jitUtils) {
-                return (function factory(${params}) {
-                    ${fn.fnBody}
-                })(jitUtils);
-            },`;
-}
-
-/** Makes a function name safe for use as a JavaScript identifier */
-function makeSafeFunctionName(name: string): string {
-    // Replace any non-alphanumeric characters with underscores
-    const safe = name.replace(/[^a-zA-Z0-9_$]/g, '_');
-    // Ensure it starts with a letter or underscore
-    if (/^[0-9]/.test(safe)) {
-        return '_' + safe;
-    }
-    return safe || 'anonymous';
-}