@zap-js/client 0.0.2 → 0.0.4

package/dist/cli/commands/routes.js

@@ -0,0 +1,280 @@
+import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { cliLogger } from '../utils/logger.js';
+// ESM equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Extract handler code from a route file
+ */
+function extractHandlerCode(filePath, method) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        if (method) {
+            // Look for specific HTTP method handler
+            const patterns = [
+                // export const GET = ...
+                new RegExp(`export\\s+(?:const|let|var)\\s+${method}\\s*=\\s*([^;]+)`, 's'),
+                // export function GET() { ... }
+                new RegExp(`export\\s+(?:async\\s+)?function\\s+${method}\\s*\\([^)]*\\)\\s*{([^}]+)}`, 's'),
+                // export async function GET() { ... }
+                new RegExp(`export\\s+async\\s+function\\s+${method}\\s*\\([^)]*\\)\\s*{([^}]+)}`, 's'),
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match) {
+                    return match[0].trim();
+                }
+            }
+        }
+        else {
+            // Look for default export (page component)
+            const patterns = [
+                // export default function Component() { ... }
+                /export\s+default\s+(?:async\s+)?function\s+\w*\s*\([^)]*\)\s*{[^}]+}/s,
+                // const Component = () => { ... }; export default Component;
+                /(?:const|let|var)\s+(\w+)\s*=\s*(?:\([^)]*\)|[^=]+)\s*=>\s*{[^}]+}.*export\s+default\s+\1/s,
+                // export default () => { ... }
+                /export\s+default\s+(?:\([^)]*\)|[^=]+)\s*=>\s*{[^}]+}/s,
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match) {
+                    // Limit to first 10 lines for preview
+                    const lines = match[0].split('\n').slice(0, 10);
+                    if (lines.length >= 10) {
+                        lines.push('  // ...');
+                    }
+                    return lines.join('\n');
+                }
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Enhanced route scanner that shows handler logic
+ */
+export async function routesCommand(options) {
+    try {
+        const projectDir = process.cwd();
+        const routesDir = resolve(options.routesDir || join(projectDir, 'routes'));
+        const outputDir = resolve(options.output || join(projectDir, 'src', 'generated'));
+        const showCode = options.showCode !== false; // Default to true
+        cliLogger.header('ZapJS Route Scanner');
+        // Check if routes directory exists
+        if (!existsSync(routesDir)) {
+            cliLogger.warn('No routes directory found');
+            cliLogger.keyValue('Expected', routesDir);
+            cliLogger.newline();
+            cliLogger.info('Create a routes/ directory with your route files to get started');
+            cliLogger.newline();
+            cliLogger.info('Next.js-style conventions:');
+            cliLogger.listItem('routes/index.tsx          → /');
+            cliLogger.listItem('routes/about.tsx          → /about');
+            cliLogger.listItem('routes/[postId].tsx       → /:postId');
+            cliLogger.listItem('routes/posts/[id].tsx     → /posts/:id');
+            cliLogger.listItem('routes/api/users.ts       → /api/users');
+            cliLogger.listItem('routes/_layout.tsx        → Layout wrapper');
+            cliLogger.listItem('routes/__root.tsx         → Root layout');
+            cliLogger.newline();
+            return;
+        }
+        // Try to load the router package
+        cliLogger.spinner('loader', 'Loading route scanner...');
+        let router;
+        try {
+            // Path from dist/cli/commands/routes.js to dist/router/index.js
+            const routerPath = join(__dirname, '../../router/index.js');
+            if (existsSync(routerPath)) {
+                router = await import(routerPath);
+            }
+            else {
+                throw new Error(`Router module not found at ${routerPath}`);
+            }
+        }
+        catch (error) {
+            cliLogger.failSpinner('loader', 'Route scanner not found');
+            cliLogger.error('Error', error instanceof Error ? error.message : String(error));
+            return;
+        }
+        cliLogger.succeedSpinner('loader', 'Route scanner loaded');
+        // Scan routes
+        cliLogger.spinner('scan', `Scanning ${routesDir}...`);
+        const tree = router.scanRoutes(routesDir);
+        cliLogger.succeedSpinner('scan', 'Routes scanned');
+        // Output JSON if requested
+        if (options.json) {
+            console.log(JSON.stringify(tree, null, 2));
+            return;
+        }
+        // Print route summary with code
+        cliLogger.newline();
+        cliLogger.info('📁 Page Routes:');
+        cliLogger.newline();
+        if (tree.routes.length === 0) {
+            console.log('    (none)');
+        }
+        else {
+            for (const route of tree.routes) {
+                const params = route.params.length > 0
+                    ? ` [${route.params.map((p) => p.name).join(', ')}]`
+                    : '';
+                const index = route.isIndex ? ' (index)' : '';
+                console.log(`  ${route.urlPath}${params}${index}`);
+                console.log(`    File: ${route.relativePath}`);
+                if (showCode) {
+                    const code = extractHandlerCode(route.filePath);
+                    if (code && options.verbose) {
+                        console.log('    Handler:');
+                        const codeLines = code.split('\n').map(line => '      ' + line);
+                        console.log(codeLines.join('\n'));
+                    }
+                }
+                // Show special exports
+                const features = [];
+                if (route.hasErrorComponent)
+                    features.push('error boundary');
+                if (route.hasPendingComponent)
+                    features.push('loading state');
+                if (route.hasMeta)
+                    features.push('meta tags');
+                if (route.hasMiddleware)
+                    features.push('middleware');
+                if (route.hasGenerateStaticParams)
+                    features.push('SSG');
+                if (features.length > 0) {
+                    console.log(`    Features: ${features.join(', ')}`);
+                }
+                console.log();
+            }
+        }
+        cliLogger.newline();
+        cliLogger.info('🌐 API Routes:');
+        cliLogger.newline();
+        if (tree.apiRoutes.length === 0) {
+            console.log('    (none)');
+        }
+        else {
+            for (const route of tree.apiRoutes) {
+                const params = route.params.length > 0
+                    ? ` [${route.params.map((p) => p.name).join(', ')}]`
+                    : '';
+                const methods = route.methods
+                    ? ` ${route.methods.join(' | ')}`
+                    : '';
+                console.log(`  ${route.urlPath}${params}`);
+                console.log(`    File: ${route.relativePath}`);
+                console.log(`    Methods:${methods}`);
+                if (showCode && route.methods) {
+                    for (const method of route.methods) {
+                        const code = extractHandlerCode(route.filePath, method);
+                        if (code) {
+                            if (options.verbose) {
+                                console.log(`    ${method} Handler:`);
+                                const codeLines = code.split('\n').map(line => '      ' + line);
+                                console.log(codeLines.join('\n'));
+                            }
+                            else {
+                                // Just show first line
+                                const firstLine = code.split('\n')[0];
+                                console.log(`    ${method}: ${firstLine.trim()}...`);
+                            }
+                        }
+                    }
+                }
+                // Show features
+                const features = [];
+                if (route.hasMiddleware)
+                    features.push('middleware');
+                if (features.length > 0) {
+                    console.log(`    Features: ${features.join(', ')}`);
+                }
+                console.log();
+            }
+        }
+        // Show layouts
+        if (tree.layouts && tree.layouts.length > 0) {
+            cliLogger.newline();
+            cliLogger.info('📐 Layouts:');
+            cliLogger.newline();
+            for (const layout of tree.layouts) {
+                console.log(`  ${layout.scopePath || '/'} (scope)`);
+                console.log(`    File: ${layout.relativePath}`);
+                if (layout.parentLayout) {
+                    console.log(`    Parent: ${layout.parentLayout}`);
+                }
+                console.log();
+            }
+        }
+        // Show WebSocket routes
+        if (tree.wsRoutes && tree.wsRoutes.length > 0) {
+            cliLogger.newline();
+            cliLogger.info('🔌 WebSocket Routes:');
+            cliLogger.newline();
+            for (const route of tree.wsRoutes) {
+                const params = route.params.length > 0
+                    ? ` [${route.params.map((p) => p.name).join(', ')}]`
+                    : '';
+                console.log(`  ${route.urlPath}${params}`);
+                console.log(`    File: ${route.relativePath}`);
+                console.log();
+            }
+        }
+        // Generate route tree files if output is specified
+        if (!options.json) {
+            cliLogger.spinner('generate', 'Generating route tree...');
+            if (!existsSync(outputDir)) {
+                mkdirSync(outputDir, { recursive: true });
+            }
+            // Use enhanced route tree generation if available
+            if (router.generateEnhancedRouteTree) {
+                router.generateEnhancedRouteTree({
+                    outputDir,
+                    routeTree: tree,
+                });
+            }
+            else {
+                router.generateRouteTree({
+                    outputDir,
+                    routeTree: tree,
+                });
+            }
+            cliLogger.succeedSpinner('generate', 'Route tree generated');
+            // Summary
+            const totalRoutes = tree.routes.length + tree.apiRoutes.length + (tree.wsRoutes?.length || 0);
+            cliLogger.newline();
+            cliLogger.success(`Found ${totalRoutes} total routes:`);
+            console.log(`  - ${tree.routes.length} page routes`);
+            console.log(`  - ${tree.apiRoutes.length} API routes`);
+            if (tree.wsRoutes?.length) {
+                console.log(`  - ${tree.wsRoutes.length} WebSocket routes`);
+            }
+            if (tree.layouts?.length) {
+                console.log(`  - ${tree.layouts.length} layouts`);
+            }
+            cliLogger.newline();
+            cliLogger.keyValue('Output', outputDir);
+            cliLogger.newline();
+        }
+        // Tips
+        if (!options.verbose && showCode) {
+            cliLogger.info('💡 Tip: Use --verbose flag to see full handler code');
+            cliLogger.newline();
+        }
+    }
+    catch (error) {
+        cliLogger.error('Route scanning failed');
+        if (error instanceof Error) {
+            cliLogger.error('Error details', error.message);
+            if (options.verbose) {
+                console.error(error.stack);
+            }
+        }
+        process.exit(1);
+    }
+}

package/dist/cli/commands/serve.d.ts

@@ -0,0 +1,17 @@
+export interface ServeOptions {
+    port?: string;
+    host?: string;
+    config?: string;
+    workers?: string;
+    logLevel?: string;
+}
+/**
+ * Run production server
+ *
+ * This command now properly:
+ * 1. Starts an IPC server for TypeScript route handlers
+ * 2. Loads and registers route handlers from the route manifest
+ * 3. Passes proper --config and --socket args to the Rust binary
+ * 4. Coordinates both processes for graceful shutdown
+ */
+export declare function serveCommand(options: ServeOptions): Promise<void>;

package/dist/cli/commands/serve.js

@@ -0,0 +1,386 @@
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join, resolve } from 'path';
+import { tmpdir } from 'os';
+import { pathToFileURL } from 'url';
+import { findAvailablePort } from '../utils/port-finder.js';
+import { IpcServer } from '../../runtime/index.js';
+import { cliLogger } from '../utils/logger.js';
+// Register tsx loader for TypeScript imports
+let tsxRegistered = false;
+async function ensureTsxRegistered() {
+    if (tsxRegistered)
+        return;
+    try {
+        const tsx = await import('tsx/esm/api');
+        tsx.register();
+        tsxRegistered = true;
+    }
+    catch {
+        // tsx not available, try without it
+    }
+}
+/**
+ * Run production server
+ *
+ * This command now properly:
+ * 1. Starts an IPC server for TypeScript route handlers
+ * 2. Loads and registers route handlers from the route manifest
+ * 3. Passes proper --config and --socket args to the Rust binary
+ * 4. Coordinates both processes for graceful shutdown
+ */
+export async function serveCommand(options) {
+    try {
+        cliLogger.header('ZapJS Production Server');
+        // Determine working directory (dist or current)
+        const distDir = resolve('./dist');
+        const workDir = existsSync(join(distDir, 'bin', 'zap')) ? distDir : process.cwd();
+        let binPath = join(workDir, 'bin', 'zap');
+        // Check for binary in multiple locations
+        if (!existsSync(binPath)) {
+            const altPaths = [
+                join(process.cwd(), 'bin', 'zap'),
+                join(process.cwd(), 'target', 'release', 'zap'),
+            ];
+            for (const altPath of altPaths) {
+                if (existsSync(altPath)) {
+                    binPath = altPath;
+                    break;
+                }
+            }
+        }
+        if (!existsSync(binPath)) {
+            cliLogger.error('No production binary found');
+            cliLogger.info('Run `zap build` first to create a production build');
+            process.exit(1);
+        }
+        // Load production config if available
+        let prodConfig = null;
+        const configPath = options.config || join(workDir, 'config.json');
+        if (existsSync(configPath)) {
+            try {
+                prodConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+                cliLogger.success(`Loaded config from ${configPath}`);
+            }
+            catch {
+                cliLogger.warn('Failed to parse config.json, using defaults');
+            }
+        }
+        await runProductionServer(binPath, options, workDir, prodConfig);
+    }
+    catch (error) {
+        cliLogger.error('Failed to start server');
+        if (error instanceof Error) {
+            cliLogger.error('Error details', error.message);
+        }
+        process.exit(1);
+    }
+}
+async function runProductionServer(binPath, options, workDir, prodConfig) {
+    const port = parseInt(options.port || prodConfig?.server?.port?.toString() || '3000');
+    const host = options.host || prodConfig?.server?.host || '0.0.0.0';
+    const logLevel = options.logLevel || prodConfig?.logging?.level || 'info';
+    // Find available port
+    cliLogger.spinner('port', `Checking port ${port}...`);
+    const availablePort = await findAvailablePort(port);
+    if (availablePort !== port) {
+        cliLogger.warn(`Port ${port} in use, using ${availablePort}`);
+    }
+    else {
+        cliLogger.succeedSpinner('port', `Port ${availablePort} available`);
+    }
+    // Generate unique socket path
+    const socketPath = join(tmpdir(), `zap-prod-${Date.now()}-${Math.random().toString(36).substring(7)}.sock`);
+    // Start IPC server for TypeScript handlers
+    cliLogger.spinner('ipc', 'Starting IPC server...');
+    const ipcServer = new IpcServer(socketPath);
+    await ipcServer.start();
+    cliLogger.succeedSpinner('ipc', 'IPC server started');
+    // Load and register route handlers
+    const routes = await loadRouteHandlers(ipcServer, workDir);
+    // Build Rust server configuration
+    const zapConfig = {
+        port: availablePort,
+        hostname: host,
+        ipc_socket_path: socketPath,
+        routes,
+        static_files: prodConfig?.static ? [{
+                prefix: prodConfig.static.prefix,
+                directory: prodConfig.static.directory,
+            }] : [],
+        middleware: {
+            enable_cors: true,
+            enable_logging: true,
+            enable_compression: true,
+        },
+        health_check_path: '/health',
+    };
+    // Also check for static directory in workDir
+    const staticDir = join(workDir, 'static');
+    if (existsSync(staticDir) && zapConfig.static_files.length === 0) {
+        zapConfig.static_files.push({
+            prefix: '/',
+            directory: staticDir,
+        });
+    }
+    // Write config to temp file
+    const tempConfigPath = join(tmpdir(), `zap-config-${Date.now()}.json`);
+    writeFileSync(tempConfigPath, JSON.stringify(zapConfig, null, 2));
+    // Start Rust server
+    cliLogger.spinner('rust', 'Starting Rust HTTP server...');
+    const rustProcess = spawn(binPath, [
+        '--config', tempConfigPath,
+        '--socket', socketPath,
+        '--log-level', logLevel,
+    ], {
+        cwd: workDir,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            PORT: availablePort.toString(),
+            HOST: host,
+            RUST_LOG: logLevel,
+            ZAP_ENV: 'production',
+        },
+    });
+    let started = false;
+    rustProcess.stdout?.on('data', (data) => {
+        const output = data.toString();
+        if (!started && (output.includes('listening') || output.includes('Server'))) {
+            started = true;
+            cliLogger.succeedSpinner('rust', 'Server started');
+            printServerInfo(host, availablePort, workDir, prodConfig, routes.length);
+        }
+        if (started) {
+            process.stdout.write(output);
+        }
+    });
+    rustProcess.stderr?.on('data', (data) => {
+        const output = data.toString();
+        if (!started) {
+            // Don't fail immediately on stderr - Rust logs info to stderr sometimes
+            if (output.includes('error') || output.includes('Error')) {
+                cliLogger.failSpinner('rust', 'Server failed to start');
+                cliLogger.error(output);
+                cleanup(ipcServer, tempConfigPath);
+                process.exit(1);
+            }
+        }
+        process.stderr.write(output);
+    });
+    rustProcess.on('error', (err) => {
+        cliLogger.failSpinner('rust', `Failed to start: ${err.message}`);
+        cleanup(ipcServer, tempConfigPath);
+        process.exit(1);
+    });
+    rustProcess.on('exit', (code) => {
+        if (code !== 0 && code !== null) {
+            cliLogger.error(`Server exited with code ${code}`);
+            cleanup(ipcServer, tempConfigPath);
+            process.exit(code);
+        }
+    });
+    // If server doesn't output "listening", assume it started after a delay
+    setTimeout(() => {
+        if (!started) {
+            started = true;
+            cliLogger.succeedSpinner('rust', 'Server started');
+            printServerInfo(host, availablePort, workDir, prodConfig, routes.length);
+        }
+    }, 3000);
+    // Graceful shutdown
+    const shutdown = async () => {
+        cliLogger.warn('Shutting down...');
+        // Kill Rust process
+        if (!rustProcess.killed) {
+            rustProcess.kill('SIGTERM');
+        }
+        // Stop IPC server
+        await ipcServer.stop();
+        // Cleanup temp config
+        cleanup(null, tempConfigPath);
+        // Force kill after timeout
+        setTimeout(() => {
+            if (!rustProcess.killed) {
+                rustProcess.kill('SIGKILL');
+            }
+            process.exit(0);
+        }, 5000);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+/**
+ * Load TypeScript route handlers from route manifest
+ */
+async function loadRouteHandlers(ipcServer, workDir) {
+    const routes = [];
+    // Try multiple manifest locations
+    const manifestPaths = [
+        join(workDir, 'src', 'generated', 'routeManifest.json'),
+        join(process.cwd(), 'src', 'generated', 'routeManifest.json'),
+    ];
+    let manifestPath = null;
+    for (const path of manifestPaths) {
+        if (existsSync(path)) {
+            manifestPath = path;
+            break;
+        }
+    }
+    if (!manifestPath) {
+        cliLogger.info('No route manifest found - API routes will not be available');
+        return routes;
+    }
+    try {
+        const manifestContent = readFileSync(manifestPath, 'utf-8');
+        const manifest = JSON.parse(manifestContent);
+        if (!manifest.apiRoutes || manifest.apiRoutes.length === 0) {
+            cliLogger.info('No API routes in manifest');
+            return routes;
+        }
+        // Register tsx for TypeScript imports
+        await ensureTsxRegistered();
+        cliLogger.spinner('routes', `Loading ${manifest.apiRoutes.length} API route handlers...`);
+        for (const apiRoute of manifest.apiRoutes) {
+            try {
+                // Find route file
+                const routePaths = [
+                    join(workDir, 'routes', apiRoute.relativePath),
+                    join(process.cwd(), 'routes', apiRoute.relativePath),
+                ];
+                let routeFilePath = null;
+                for (const rp of routePaths) {
+                    if (existsSync(rp)) {
+                        routeFilePath = rp;
+                        break;
+                    }
+                }
+                if (!routeFilePath) {
+                    cliLogger.warn(`[routes] Route file not found: ${apiRoute.relativePath}`);
+                    continue;
+                }
+                // Dynamic import the route module
+                const fileUrl = pathToFileURL(routeFilePath).href;
+                const routeModule = await import(fileUrl);
+                // Register each HTTP method handler
+                const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+                for (const method of methods) {
+                    if (routeModule[method]) {
+                        const handlerId = `handler_${method}_${apiRoute.urlPath.replace(/\//g, '_').replace(/:/g, '')}`;
+                        // Register handler with IPC server
+                        ipcServer.registerHandler(handlerId, async (req) => {
+                            try {
+                                const result = await routeModule[method](req);
+                                return formatHandlerResponse(result);
+                            }
+                            catch (err) {
+                                const message = err instanceof Error ? err.message : String(err);
+                                cliLogger.error(`[handler] ERROR in ${method} ${apiRoute.urlPath}:`, message);
+                                return {
+                                    status: 500,
+                                    headers: { 'content-type': 'application/json' },
+                                    body: JSON.stringify({ error: 'Internal Server Error', message }),
+                                };
+                            }
+                        });
+                        routes.push({
+                            method,
+                            path: apiRoute.urlPath,
+                            handler_id: handlerId,
+                            is_typescript: true,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                cliLogger.warn(`[routes] Failed to load ${apiRoute.relativePath}: ${message}`);
+            }
+        }
+        cliLogger.succeedSpinner('routes', `Loaded ${routes.length} API route handlers`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        cliLogger.warn(`Failed to load route manifest: ${message}`);
+    }
+    return routes;
+}
+/**
+ * Format handler result into IPC response
+ */
+function formatHandlerResponse(result) {
+    // Handle Response object
+    if (result instanceof Response) {
+        return {
+            status: result.status,
+            headers: Object.fromEntries(result.headers.entries()),
+            body: '',
+        };
+    }
+    // Handle string
+    if (typeof result === 'string') {
+        return {
+            status: 200,
+            headers: { 'content-type': 'text/plain' },
+            body: result,
+        };
+    }
+    // Handle object (JSON)
+    if (typeof result === 'object' && result !== null) {
+        return {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(result),
+        };
+    }
+    // Default
+    return {
+        status: 200,
+        headers: { 'content-type': 'text/plain' },
+        body: String(result),
+    };
+}
+/**
+ * Cleanup temp files
+ */
+function cleanup(ipcServer, configPath) {
+    if (ipcServer) {
+        try {
+            ipcServer.stop();
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    if (configPath && existsSync(configPath)) {
+        try {
+            unlinkSync(configPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+function printServerInfo(host, port, workDir, config, routeCount) {
+    const displayHost = host === '0.0.0.0' ? 'localhost' : host;
+    cliLogger.newline();
+    cliLogger.success('Production server running');
+    cliLogger.newline();
+    cliLogger.info('Endpoints:');
+    cliLogger.listItem(`http://${displayHost}:${port}`, '➜');
+    if (host === '0.0.0.0') {
+        cliLogger.listItem(`http://0.0.0.0:${port} (all interfaces)`, '➜');
+    }
+    if (routeCount !== undefined && routeCount > 0) {
+        cliLogger.newline();
+        cliLogger.keyValue('API routes', `${routeCount} handlers registered`);
+    }
+    if (config?.static) {
+        cliLogger.keyValue('Static files', config.static.directory);
+    }
+    cliLogger.newline();
+    cliLogger.keyValue('Working dir', workDir);
+    cliLogger.newline();
+    cliLogger.info('Press Ctrl+C to stop');
+    cliLogger.newline();
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};