@zap-js/client 0.0.2 → 0.0.4

package/dist/cli/commands/codegen.js

@@ -0,0 +1,95 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { cliLogger } from '../utils/logger.js';
+/**
+ * Find the zap-codegen binary in known locations
+ */
+function findCodegenBinary() {
+    const projectDir = process.cwd();
+    // Check multiple possible locations
+    const possiblePaths = [
+        // Project bin directory
+        join(projectDir, 'bin', 'zap-codegen'),
+        join(projectDir, 'bin', 'zap-codegen.exe'),
+        // Workspace target (for monorepo development)
+        join(projectDir, '../../target/release/zap-codegen'),
+        join(projectDir, '../../target/aarch64-apple-darwin/release/zap-codegen'),
+        join(projectDir, '../../target/x86_64-unknown-linux-gnu/release/zap-codegen'),
+        join(projectDir, '../../target/debug/zap-codegen'),
+        // Local target directory
+        join(projectDir, 'target/release/zap-codegen'),
+        join(projectDir, 'target/debug/zap-codegen'),
+    ];
+    for (const path of possiblePaths) {
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    // Try global zap-codegen as fallback
+    try {
+        execSync('which zap-codegen', { stdio: 'pipe' });
+        return 'zap-codegen';
+    }
+    catch {
+        // Not in PATH
+    }
+    return null;
+}
+/**
+ * Generate TypeScript bindings from Rust exports
+ */
+export async function codegenCommand(options) {
+    const outputDir = options.output || './src/api';
+    try {
+        cliLogger.header('Generating TypeScript Bindings');
+        // Find the codegen binary
+        const codegenBinary = findCodegenBinary();
+        if (!codegenBinary) {
+            cliLogger.error('zap-codegen binary not found');
+            cliLogger.newline();
+            cliLogger.info('Please build the codegen binary first:');
+            cliLogger.command('cargo build --release --bin zap-codegen');
+            cliLogger.newline();
+            cliLogger.info('Or install globally:');
+            cliLogger.command('npm install -g @zapjs/codegen');
+            cliLogger.newline();
+            process.exit(1);
+        }
+        cliLogger.spinner('codegen', `Generating bindings to ${outputDir}...`);
+        try {
+            let cmd = `"${codegenBinary}"`;
+            if (options.output) {
+                cmd += ` --output-dir ${options.output}`;
+            }
+            else {
+                cmd += ` --output-dir ${outputDir}`;
+            }
+            if (options.input) {
+                cmd += ` --input ${options.input}`;
+            }
+            execSync(cmd, {
+                stdio: 'pipe',
+            });
+            cliLogger.succeedSpinner('codegen', 'TypeScript bindings generated');
+        }
+        catch (error) {
+            cliLogger.failSpinner('codegen', 'Codegen failed');
+            if (error instanceof Error) {
+                cliLogger.error('Error details', error.message);
+            }
+            process.exit(1);
+        }
+        cliLogger.newline();
+        cliLogger.success('Codegen complete!');
+        cliLogger.keyValue('Generated files in', outputDir);
+        cliLogger.newline();
+    }
+    catch (error) {
+        cliLogger.error('Codegen failed');
+        if (error instanceof Error) {
+            cliLogger.error('Error details', error.message);
+        }
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,20 @@
+export interface DevOptions {
+    port?: string;
+    vitePort?: string;
+    open?: boolean;
+    logLevel?: string;
+    release?: boolean;
+    skipBuild?: boolean;
+    binaryPath?: string;
+    codegenBinaryPath?: string;
+}
+/**
+ * Start development server with hot reload
+ *
+ * Orchestrates:
+ * - Rust backend compilation with file watching
+ * - Vite frontend dev server
+ * - Automatic TypeScript binding generation
+ * - Hot reload signaling
+ */
+export declare function devCommand(options: DevOptions): Promise<void>;

package/dist/cli/commands/dev.js

@@ -0,0 +1,78 @@
+import path from 'path';
+import { existsSync } from 'fs';
+import { DevServer } from '../../dev-server/index.js';
+import { cliLogger } from '../utils/logger.js';
+/**
+ * Auto-detect pre-built binaries in bin/ directory
+ */
+function detectBinaries(projectDir) {
+    const binDir = path.join(projectDir, 'bin');
+    const result = {};
+    // Check for zap binary
+    const zapBinary = path.join(binDir, 'zap');
+    const zapBinaryExe = path.join(binDir, 'zap.exe');
+    if (existsSync(zapBinary)) {
+        result.binaryPath = zapBinary;
+    }
+    else if (existsSync(zapBinaryExe)) {
+        result.binaryPath = zapBinaryExe;
+    }
+    // Check for zap-codegen binary
+    const codegenBinary = path.join(binDir, 'zap-codegen');
+    const codegenBinaryExe = path.join(binDir, 'zap-codegen.exe');
+    if (existsSync(codegenBinary)) {
+        result.codegenBinaryPath = codegenBinary;
+    }
+    else if (existsSync(codegenBinaryExe)) {
+        result.codegenBinaryPath = codegenBinaryExe;
+    }
+    return result;
+}
+/**
+ * Start development server with hot reload
+ *
+ * Orchestrates:
+ * - Rust backend compilation with file watching
+ * - Vite frontend dev server
+ * - Automatic TypeScript binding generation
+ * - Hot reload signaling
+ */
+export async function devCommand(options) {
+    const projectDir = process.cwd();
+    // Auto-detect pre-built binaries if not explicitly provided
+    const detectedBinaries = detectBinaries(projectDir);
+    const config = {
+        projectDir,
+        rustPort: options.port ? parseInt(options.port, 10) : 3000,
+        vitePort: options.vitePort ? parseInt(options.vitePort, 10) : 5173,
+        logLevel: options.logLevel || 'info',
+        release: options.release || false,
+        skipInitialBuild: options.skipBuild || false,
+        openBrowser: options.open !== false,
+        binaryPath: options.binaryPath || detectedBinaries.binaryPath,
+        codegenBinaryPath: options.codegenBinaryPath || detectedBinaries.codegenBinaryPath,
+    };
+    // Log if using pre-built binaries
+    if (config.binaryPath) {
+        cliLogger.info('Using pre-built binary', config.binaryPath);
+    }
+    const server = new DevServer(config);
+    // Handle graceful shutdown
+    const shutdown = async () => {
+        await server.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    try {
+        await server.start();
+        // Keep the process running
+        await new Promise(() => { });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            cliLogger.error('Development server failed', error);
+        }
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,9 @@
+export interface NewOptions {
+    template: string;
+    install?: boolean;
+    git?: boolean;
+}
+/**
+ * Create a new ZapJS project
+ */
+export declare function newCommand(name: string, options: NewOptions): Promise<void>;

package/dist/cli/commands/new.js

@@ -0,0 +1,307 @@
+import { execSync } from 'child_process';
+import inquirer from 'inquirer';
+import fsExtra from 'fs-extra';
+import { join, resolve } from 'path';
+import { cliLogger } from '../utils/logger.js';
+const { ensureDirSync, writeFileSync } = fsExtra;
+/**
+ * Create a new ZapJS project
+ */
+export async function newCommand(name, options) {
+    if (!name || name.trim() === '') {
+        cliLogger.error('Project name is required');
+        process.exit(1);
+    }
+    const projectDir = resolve(process.cwd(), name);
+    try {
+        // Check if directory already exists
+        try {
+            const fs = await import('fs');
+            if (fs.existsSync(projectDir)) {
+                cliLogger.error(`Directory "${name}" already exists`);
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            // Directory doesn't exist, which is good
+        }
+        cliLogger.header(`Create New ZapJS Project: ${name}`);
+        // Prompt for template if not specified
+        let template = options.template;
+        const templates = ['basic', 'fullstack'];
+        if (!templates.includes(template)) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'template',
+                    message: 'Choose a template:',
+                    choices: templates.map((t) => ({
+                        name: t.charAt(0).toUpperCase() + t.slice(1),
+                        value: t,
+                    })),
+                    default: 'basic',
+                },
+            ]);
+            template = answers.template;
+        }
+        // Create project directory
+        cliLogger.spinner('dir', 'Creating project directory...');
+        ensureDirSync(projectDir);
+        cliLogger.succeedSpinner('dir', 'Project directory created');
+        // Create project files
+        cliLogger.spinner('files', `Creating ${template} project...`);
+        createMinimalProject(projectDir, name, template);
+        cliLogger.succeedSpinner('files', 'Project files created');
+        // Install dependencies
+        if (options.install !== false) {
+            cliLogger.spinner('deps', 'Installing dependencies...');
+            try {
+                execSync('npm install', { cwd: projectDir, stdio: 'pipe' });
+                cliLogger.succeedSpinner('deps', 'Dependencies installed');
+            }
+            catch (error) {
+                cliLogger.warn('npm install skipped. Run "npm install" manually.');
+            }
+        }
+        // Initialize git
+        if (options.git !== false) {
+            cliLogger.spinner('git', 'Initializing git repository...');
+            try {
+                execSync('git init', { cwd: projectDir, stdio: 'pipe' });
+                execSync('git add .', { cwd: projectDir, stdio: 'pipe' });
+                execSync('git commit -m "Initial commit"', {
+                    cwd: projectDir,
+                    stdio: 'pipe',
+                });
+                cliLogger.succeedSpinner('git', 'Git repository initialized');
+            }
+            catch (error) {
+                cliLogger.warn('Git initialization skipped');
+            }
+        }
+        // Success message
+        cliLogger.newline();
+        cliLogger.success(`Project ${name} created successfully!`);
+        cliLogger.newline();
+        // Next steps
+        cliLogger.info('Next steps:');
+        cliLogger.command(`cd ${name}`);
+        cliLogger.command('cargo build --release');
+        cliLogger.command('zap dev');
+        cliLogger.newline();
+        cliLogger.info('Happy coding! 🚀');
+        cliLogger.newline();
+    }
+    catch (error) {
+        cliLogger.error('Project creation failed');
+        if (error instanceof Error) {
+            cliLogger.error('Error details', error.message);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Create a minimal project structure
+ */
+function createMinimalProject(projectDir, projectName, template) {
+    // Create directory structure
+    const dirs = [
+        'server/src',
+        'routes',
+        'routes/api',
+        'src',
+        'src/generated',
+    ];
+    for (const dir of dirs) {
+        ensureDirSync(join(projectDir, dir));
+    }
+    // Create server/src/main.rs
+    const mainRs = `use zap::Zap;
+
+#[tokio::main]
+async fn main() {
+    let mut app = Zap::new()
+        .port(3000)
+        .hostname("127.0.0.1")
+        .cors()
+        .logging();
+
+    // Register your routes here
+    app.get("/api/health", || {
+        serde_json::json!({ "status": "ok" })
+    });
+
+    if let Err(e) = app.listen().await {
+        eprintln!("Server error: {}", e);
+        std::process::exit(1);
+    }
+}
+`;
+    // Create routes/__root.tsx
+    const rootTsx = `import React from 'react';
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>ZapJS App</title>
+      </head>
+      <body>
+        {children}
+      </body>
+    </html>
+  );
+}
+`;
+    // Create routes/index.tsx
+    const indexRoute = `export default function HomePage() {
+  return (
+    <div style={{ fontFamily: 'system-ui, sans-serif', padding: '2rem' }}>
+      <h1>Welcome to ZapJS</h1>
+      <p>Fullstack Rust + React Framework</p>
+      <p>
+        Edit <code>routes/index.tsx</code> to get started.
+      </p>
+    </div>
+  );
+}
+`;
+    // Create routes/api/hello.ts
+    const helloApi = `import { server } from '../../src/generated/server';
+
+export const GET = async () => {
+  return {
+    message: 'Hello from ZapJS!',
+    timestamp: new Date().toISOString(),
+  };
+};
+
+export const POST = async ({ request }: { request: Request }) => {
+  const body = await request.json();
+  return {
+    received: body,
+    message: 'Data received successfully',
+  };
+};
+`;
+    // Create routes/api/users.$id.ts
+    const usersApi = `export const GET = async ({ params }: { params: { id: string } }) => {
+  return {
+    id: params.id,
+    name: \`User \${params.id}\`,
+    email: \`user\${params.id}@example.com\`,
+  };
+};
+`;
+    // Create package.json
+    const packageJson = {
+        name: projectName,
+        version: '0.1.0',
+        type: 'module',
+        scripts: {
+            'dev': 'zap dev',
+            'build': 'zap build',
+            'serve': 'zap serve',
+            'routes': 'zap routes',
+        },
+        dependencies: {
+            'react': '^18.0.0',
+            'react-dom': '^18.0.0',
+            '@zapjs/runtime': '^0.1.0',
+            '@zapjs/router': '^0.1.0',
+        },
+        devDependencies: {
+            '@types/react': '^18.0.0',
+            '@types/react-dom': '^18.0.0',
+            '@zapjs/cli': '^0.1.0',
+            'typescript': '^5.0.0',
+            'vite': '^5.0.0',
+        },
+    };
+    // Create Cargo.toml
+    const cargoToml = `[package]
+name = "${projectName}"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+zap = { path = "../../packages/server" }
+tokio = { version = "1.0", features = ["full"] }
+serde_json = "1.0"
+`;
+    // Create zap.config.ts
+    const zapConfig = `import { defineConfig } from 'zap';
+
+export default defineConfig({
+  server: {
+    port: 3000,
+    hostname: '127.0.0.1',
+  },
+  dev: {
+    apiPort: 3000,
+    clientPort: 5173,
+    watchRust: true,
+    watchTypeScript: true,
+    open: true,
+  },
+});
+`;
+    // Create tsconfig.json
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2020',
+            useDefineForClassFields: true,
+            lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+            module: 'ESNext',
+            skipLibCheck: true,
+            esModuleInterop: true,
+            allowSyntheticDefaultImports: true,
+            strict: true,
+            noEmit: true,
+            jsx: 'react-jsx',
+            moduleResolution: 'bundler',
+            allowImportingTsExtensions: true,
+        },
+        include: ['client/src'],
+        references: [{ path: './tsconfig.node.json' }],
+    };
+    // Write files
+    writeFileSync(join(projectDir, 'server/src/main.rs'), mainRs);
+    writeFileSync(join(projectDir, 'routes/__root.tsx'), rootTsx);
+    writeFileSync(join(projectDir, 'routes/index.tsx'), indexRoute);
+    writeFileSync(join(projectDir, 'routes/api/hello.ts'), helloApi);
+    writeFileSync(join(projectDir, 'routes/api/users.$id.ts'), usersApi);
+    writeFileSync(join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+    writeFileSync(join(projectDir, 'Cargo.toml'), cargoToml);
+    writeFileSync(join(projectDir, 'zap.config.ts'), zapConfig);
+    writeFileSync(join(projectDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+    // Create .gitignore
+    const gitignore = `# Dependencies
+node_modules/
+package-lock.json
+
+# Build output
+/dist
+/target
+/server/target
+
+# Rust
+Cargo.lock
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Environment
+.env
+.env.local
+
+# Logs
+*.log
+`;
+    writeFileSync(join(projectDir, '.gitignore'), gitignore);
+}

package/dist/cli/commands/routes-old.d.ts

@@ -0,0 +1,9 @@
+export interface RoutesOptions {
+    routesDir?: string;
+    output?: string;
+    json?: boolean;
+}
+/**
+ * Scan routes and generate route tree
+ */
+export declare function routesCommand(options: RoutesOptions): Promise<void>;

package/dist/cli/commands/routes-old.js

@@ -0,0 +1,106 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { existsSync, mkdirSync } from 'fs';
+import { join, resolve } from 'path';
+/**
+ * Scan routes and generate route tree
+ */
+export async function routesCommand(options) {
+    const spinner = ora();
+    try {
+        const projectDir = process.cwd();
+        const routesDir = resolve(options.routesDir || join(projectDir, 'routes'));
+        const outputDir = resolve(options.output || join(projectDir, 'src', 'generated'));
+        console.log(chalk.cyan('\n⚡ ZapJS Route Scanner\n'));
+        // Check if routes directory exists
+        if (!existsSync(routesDir)) {
+            console.log(chalk.yellow('No routes directory found.'));
+            console.log(chalk.gray(`Expected: ${routesDir}`));
+            console.log(chalk.gray('\nCreate a routes/ directory with your route files to get started.'));
+            console.log(chalk.gray('\nTanStack-style conventions:'));
+            console.log(chalk.gray('  routes/index.tsx          → /'));
+            console.log(chalk.gray('  routes/about.tsx          → /about'));
+            console.log(chalk.gray('  routes/$postId.tsx        → /:postId'));
+            console.log(chalk.gray('  routes/posts.$id.tsx      → /posts/:id'));
+            console.log(chalk.gray('  routes/api/users.ts       → /api/users'));
+            console.log(chalk.gray('  routes/_layout.tsx        → Layout wrapper'));
+            console.log(chalk.gray('  routes/__root.tsx         → Root layout\n'));
+            return;
+        }
+        // Try to load the router package
+        spinner.start('Loading route scanner...');
+        let router;
+        try {
+            // Dynamic import using variable to prevent TypeScript from resolving
+            const moduleName = '@zapjs/router';
+            router = await (Function('moduleName', 'return import(moduleName)')(moduleName));
+        }
+        catch {
+            spinner.fail('@zapjs/router not found');
+            console.log(chalk.yellow('\nInstall the router package:'));
+            console.log(chalk.cyan('  npm install @zapjs/router\n'));
+            return;
+        }
+        spinner.succeed('Route scanner loaded');
+        // Scan routes
+        spinner.start(`Scanning ${routesDir}...`);
+        const tree = router.scanRoutes(routesDir);
+        spinner.succeed('Routes scanned');
+        // Output JSON if requested
+        if (options.json) {
+            console.log(JSON.stringify(tree, null, 2));
+            return;
+        }
+        // Print route summary
+        console.log(chalk.white('\n  Page Routes:'));
+        if (tree.routes.length === 0) {
+            console.log(chalk.gray('    (none)'));
+        }
+        else {
+            for (const route of tree.routes) {
+                const params = route.params.length > 0
+                    ? chalk.gray(` [${route.params.map(p => p.name).join(', ')}]`)
+                    : '';
+                const index = route.isIndex ? chalk.gray(' (index)') : '';
+                console.log(chalk.cyan(`    ${route.urlPath}`) + params + index);
+                console.log(chalk.gray(`      → ${route.relativePath}`));
+            }
+        }
+        console.log(chalk.white('\n  API Routes:'));
+        if (tree.apiRoutes.length === 0) {
+            console.log(chalk.gray('    (none)'));
+        }
+        else {
+            for (const route of tree.apiRoutes) {
+                const params = route.params.length > 0
+                    ? chalk.gray(` [${route.params.map(p => p.name).join(', ')}]`)
+                    : '';
+                const methods = route.methods
+                    ? chalk.gray(` (${route.methods.join(', ')})`)
+                    : '';
+                console.log(chalk.green(`    ${route.urlPath}`) + params + methods);
+                console.log(chalk.gray(`      → ${route.relativePath}`));
+            }
+        }
+        // Generate route tree files
+        spinner.start('Generating route tree...');
+        if (!existsSync(outputDir)) {
+            mkdirSync(outputDir, { recursive: true });
+        }
+        router.generateRouteTree({
+            outputDir,
+            routeTree: tree,
+        });
+        spinner.succeed('Route tree generated');
+        // Summary
+        console.log(chalk.green(`\n✓ Found ${tree.routes.length} page routes, ${tree.apiRoutes.length} API routes`));
+        console.log(chalk.gray(`  Output: ${outputDir}\n`));
+    }
+    catch (error) {
+        spinner.fail('Route scanning failed');
+        if (error instanceof Error) {
+            console.error(chalk.red(`\nError: ${error.message}\n`));
+        }
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,11 @@
+export interface RoutesOptions {
+    routesDir?: string;
+    output?: string;
+    json?: boolean;
+    showCode?: boolean;
+    verbose?: boolean;
+}
+/**
+ * Enhanced route scanner that shows handler logic
+ */
+export declare function routesCommand(options: RoutesOptions): Promise<void>;