@zap-js/client 0.0.2 → 0.0.4

package/dist/cli/index.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { newCommand } from './commands/new.js';
+import { devCommand } from './commands/dev.js';
+import { buildCommand } from './commands/build.js';
+import { serveCommand } from './commands/serve.js';
+import { codegenCommand } from './commands/codegen.js';
+import { routesCommand } from './commands/routes.js';
+import { cliLogger } from './utils/logger.js';
+const program = new Command();
+program
+    .name('zap')
+    .description('ZapJS - Fullstack Rust + React Framework')
+    .version('0.1.0', '-v, --version')
+    .helpOption('-h, --help');
+// Register commands
+program
+    .command('new <name>')
+    .description('Create a new ZapJS project')
+    .option('-t, --template <template>', 'Template to use (basic|fullstack)', 'basic')
+    .option('--no-install', 'Skip npm install')
+    .option('--no-git', 'Skip git initialization')
+    .action((name, options) => newCommand(name, options));
+program
+    .command('dev')
+    .description('Start development server with hot reload')
+    .option('-p, --port <port>', 'API server port', '3000')
+    .option('--vite-port <port>', 'Vite dev server port', '5173')
+    .option('--no-open', 'Do not open browser')
+    .option('-l, --log-level <level>', 'Log level (debug|info|warn|error)', 'info')
+    .option('--release', 'Build in release mode')
+    .option('--skip-build', 'Skip initial Rust build')
+    .action((options) => devCommand(options));
+program
+    .command('build')
+    .description('Build for production')
+    .option('--release', 'Build optimized release build', true)
+    .option('-o, --output <dir>', 'Output directory', './dist')
+    .option('--target <target>', 'Cross-compile target (e.g., x86_64-unknown-linux-gnu)')
+    .option('--skip-frontend', 'Skip frontend build')
+    .option('--skip-codegen', 'Skip TypeScript codegen')
+    .action((options) => buildCommand(options));
+program
+    .command('serve')
+    .description('Run production server')
+    .option('-p, --port <port>', 'Port to run on')
+    .option('--host <host>', 'Host to bind to')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('-w, --workers <count>', 'Number of worker threads')
+    .action((options) => serveCommand(options));
+program
+    .command('codegen')
+    .description('Generate TypeScript bindings from Rust exports')
+    .option('-i, --input <file>', 'Input metadata JSON file')
+    .option('-o, --output <dir>', 'Output directory', './src/api')
+    .action((options) => codegenCommand(options));
+program
+    .command('routes')
+    .description('Scan routes directory and generate route tree')
+    .option('-d, --routes-dir <dir>', 'Routes directory path')
+    .option('-o, --output <dir>', 'Output directory for generated files')
+    .option('--json', 'Output routes as JSON')
+    .option('--verbose', 'Show full handler code')
+    .action((options) => routesCommand(options));
+// Handle unknown commands
+program.on('command:*', () => {
+    cliLogger.error(`Unknown command "${program.args[0]}"`);
+    cliLogger.newline();
+    program.outputHelp();
+    process.exit(1);
+});
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}
+program.parse();

package/dist/cli/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logger.js';
+export * from './port-finder.js';

package/dist/cli/utils/index.js

@@ -0,0 +1,2 @@
+export * from './logger.js';
+export * from './port-finder.js';

package/dist/cli/utils/logger.d.ts

@@ -0,0 +1,84 @@
+/**
+ * ZapJS CLI Logger - Orange-themed visual logging utility
+ *
+ * Brand Colors (from zap.svg logo):
+ * - Primary Orange: #ec751a
+ * - Light Orange: #f5ba77
+ * - Dark Background: #0a0a0a
+ */
+import { Ora } from 'ora';
+export declare class CliLogger {
+    private spinners;
+    /**
+     * Print ZapJS branded header
+     */
+    header(text: string): void;
+    /**
+     * Success message with checkmark
+     */
+    success(message: string, details?: string): void;
+    /**
+     * Error message with X symbol
+     */
+    error(message: string, err?: Error | string): void;
+    /**
+     * Warning message with warning symbol
+     */
+    warn(message: string, details?: string): void;
+    /**
+     * Info message with info symbol
+     */
+    info(message: string, details?: string): void;
+    /**
+     * Step indicator (numbered steps)
+     */
+    step(num: number, message: string): void;
+    /**
+     * Command suggestion (dimmed with code styling)
+     */
+    command(cmd: string, description?: string): void;
+    /**
+     * Start a spinner with orange color
+     */
+    spinner(id: string, text: string): Ora;
+    /**
+     * Update spinner text
+     */
+    updateSpinner(id: string, text: string): void;
+    /**
+     * Stop spinner with success
+     */
+    succeedSpinner(id: string, text?: string): void;
+    /**
+     * Stop spinner with error
+     */
+    failSpinner(id: string, text?: string): void;
+    /**
+     * Print a blank line
+     */
+    newline(): void;
+    /**
+     * Print dimmed separator line
+     */
+    separator(): void;
+    /**
+     * Print key-value pair
+     */
+    keyValue(key: string, value: string | number): void;
+    /**
+     * Print list item with bullet
+     */
+    listItem(text: string, bullet?: string): void;
+    /**
+     * Print a box around text
+     */
+    box(title: string, content: string[]): void;
+}
+/**
+ * Global CLI logger instance
+ */
+export declare const cliLogger: CliLogger;
+/**
+ * Convenience exports
+ */
+export declare const header: (text: string) => void, success: (message: string, details?: string) => void, error: (message: string, err?: Error | string) => void, warn: (message: string, details?: string) => void, info: (message: string, details?: string) => void, step: (num: number, message: string) => void, command: (cmd: string, description?: string) => void, spinner: (id: string, text: string) => Ora, updateSpinner: (id: string, text: string) => void, succeedSpinner: (id: string, text?: string) => void, failSpinner: (id: string, text?: string) => void, newline: () => void, separator: () => void, keyValue: (key: string, value: string | number) => void, listItem: (text: string, bullet?: string) => void, box: (title: string, content: string[]) => void;

package/dist/cli/utils/logger.js

@@ -0,0 +1,181 @@
+/**
+ * ZapJS CLI Logger - Orange-themed visual logging utility
+ *
+ * Brand Colors (from zap.svg logo):
+ * - Primary Orange: #ec751a
+ * - Light Orange: #f5ba77
+ * - Dark Background: #0a0a0a
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+// Define brand colors
+const COLORS = {
+    primary: '#ec751a', // Main orange from logo
+    light: '#f5ba77', // Light orange for accents
+    success: '#10b981', // Green for success
+    error: '#ef4444', // Red for errors
+    warning: '#f59e0b', // Amber for warnings
+    info: '#3b82f6', // Blue for info
+    dim: '#6b7280', // Gray for secondary text
+};
+// Custom chalk instances with brand colors
+const orange = chalk.hex(COLORS.primary);
+const orangeLight = chalk.hex(COLORS.light);
+const successColor = chalk.hex(COLORS.success);
+const errorColor = chalk.hex(COLORS.error);
+const warningColor = chalk.hex(COLORS.warning);
+const infoColor = chalk.hex(COLORS.info);
+const dim = chalk.hex(COLORS.dim);
+export class CliLogger {
+    constructor() {
+        this.spinners = new Map();
+    }
+    /**
+     * Print ZapJS branded header
+     */
+    header(text) {
+        console.log();
+        console.log(orange.bold(`⚡ ${text}`));
+        console.log(dim('─'.repeat(60)));
+    }
+    /**
+     * Success message with checkmark
+     */
+    success(message, details) {
+        console.log(successColor('✓'), chalk.white(message));
+        if (details) {
+            console.log(dim(`  ${details}`));
+        }
+    }
+    /**
+     * Error message with X symbol
+     */
+    error(message, err) {
+        console.log(errorColor('✗'), chalk.white(message));
+        if (err) {
+            const errorMsg = typeof err === 'string' ? err : err.message;
+            console.log(dim(`  ${errorMsg}`));
+        }
+    }
+    /**
+     * Warning message with warning symbol
+     */
+    warn(message, details) {
+        console.log(warningColor('⚠'), chalk.white(message));
+        if (details) {
+            console.log(dim(`  ${details}`));
+        }
+    }
+    /**
+     * Info message with info symbol
+     */
+    info(message, details) {
+        console.log(infoColor('ℹ'), chalk.white(message));
+        if (details) {
+            console.log(dim(`  ${details}`));
+        }
+    }
+    /**
+     * Step indicator (numbered steps)
+     */
+    step(num, message) {
+        const stepNum = orange(`[${num}]`);
+        console.log(`${stepNum} ${chalk.white(message)}`);
+    }
+    /**
+     * Command suggestion (dimmed with code styling)
+     */
+    command(cmd, description) {
+        console.log(`  ${orangeLight('$')} ${chalk.cyan(cmd)}`);
+        if (description) {
+            console.log(dim(`    ${description}`));
+        }
+    }
+    /**
+     * Start a spinner with orange color
+     */
+    spinner(id, text) {
+        const spinner = ora({
+            text: chalk.white(text),
+            color: 'yellow', // ora doesn't support hex, yellow is closest to orange
+            spinner: 'dots',
+        }).start();
+        this.spinners.set(id, spinner);
+        return spinner;
+    }
+    /**
+     * Update spinner text
+     */
+    updateSpinner(id, text) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.text = chalk.white(text);
+        }
+    }
+    /**
+     * Stop spinner with success
+     */
+    succeedSpinner(id, text) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.succeed(text ? chalk.white(text) : undefined);
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Stop spinner with error
+     */
+    failSpinner(id, text) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.fail(text ? chalk.white(text) : undefined);
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Print a blank line
+     */
+    newline() {
+        console.log();
+    }
+    /**
+     * Print dimmed separator line
+     */
+    separator() {
+        console.log(dim('─'.repeat(60)));
+    }
+    /**
+     * Print key-value pair
+     */
+    keyValue(key, value) {
+        console.log(`  ${dim(key + ':')} ${chalk.white(value)}`);
+    }
+    /**
+     * Print list item with bullet
+     */
+    listItem(text, bullet = '•') {
+        console.log(`  ${orange(bullet)} ${chalk.white(text)}`);
+    }
+    /**
+     * Print a box around text
+     */
+    box(title, content) {
+        const maxLen = Math.max(title.length, ...content.map(c => c.length));
+        const width = maxLen + 4;
+        console.log(orange('┌' + '─'.repeat(width) + '┐'));
+        console.log(orange('│') + chalk.white.bold(` ${title.padEnd(maxLen)} `) + orange('│'));
+        console.log(orange('├' + '─'.repeat(width) + '┤'));
+        content.forEach(line => {
+            console.log(orange('│') + chalk.white(` ${line.padEnd(maxLen)} `) + orange('│'));
+        });
+        console.log(orange('└' + '─'.repeat(width) + '┘'));
+    }
+}
+/**
+ * Global CLI logger instance
+ */
+export const cliLogger = new CliLogger();
+/**
+ * Convenience exports
+ */
+export const { header, success, error, warn, info, step, command, spinner, updateSpinner, succeedSpinner, failSpinner, newline, separator, keyValue, listItem, box, } = cliLogger;

package/dist/cli/utils/port-finder.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Find an available port starting from the given port
+ */
+export declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;
+/**
+ * Find multiple available ports
+ */
+export declare function findAvailablePorts(ports: number[]): Promise<Record<string, number>>;

package/dist/cli/utils/port-finder.js

@@ -0,0 +1,48 @@
+import { createServer } from 'net';
+/**
+ * Find an available port starting from the given port
+ */
+export async function findAvailablePort(startPort, maxAttempts = 10) {
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = startPort + i;
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    // If no port found, just return the original
+    return startPort;
+}
+/**
+ * Check if a port is available
+ */
+function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+/**
+ * Find multiple available ports
+ */
+export async function findAvailablePorts(ports) {
+    const result = {};
+    let currentPort = Math.min(...ports);
+    for (const originalPort of ports) {
+        const available = await findAvailablePort(currentPort);
+        result[`port_${originalPort}`] = available;
+        currentPort = available + 1;
+    }
+    return result;
+}

package/dist/dev-server/codegen-runner.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'events';
+export interface CodegenConfig {
+    projectDir: string;
+    outputDir?: string;
+    codegenBinary?: string;
+}
+export type CodegenStatus = 'idle' | 'running' | 'success' | 'failed';
+/**
+ * CodegenRunner - Automatically regenerates TypeScript bindings from Rust
+ *
+ * Triggered when:
+ * - Rust files with #[zap::export] are modified
+ * - Cargo.toml changes
+ * - After successful Rust build
+ */
+export declare class CodegenRunner extends EventEmitter {
+    private config;
+    private status;
+    private lastGenerated;
+    constructor(config: CodegenConfig);
+    /**
+     * Get current status
+     */
+    getStatus(): CodegenStatus;
+    /**
+     * Run codegen to regenerate TypeScript bindings
+     */
+    run(): Promise<boolean>;
+    /**
+     * Find the codegen binary
+     */
+    private findCodegenBinary;
+    /**
+     * Check if codegen is needed based on file modification times
+     */
+    isStale(): Promise<boolean>;
+    /**
+     * Get the output directory
+     */
+    getOutputDir(): string;
+}

package/dist/dev-server/codegen-runner.js

@@ -0,0 +1,172 @@
+import { spawn, execSync } from 'child_process';
+import { EventEmitter } from 'events';
+import path from 'path';
+import { existsSync } from 'fs';
+/**
+ * CodegenRunner - Automatically regenerates TypeScript bindings from Rust
+ *
+ * Triggered when:
+ * - Rust files with #[zap::export] are modified
+ * - Cargo.toml changes
+ * - After successful Rust build
+ */
+export class CodegenRunner extends EventEmitter {
+    constructor(config) {
+        super();
+        this.status = 'idle';
+        this.lastGenerated = null;
+        this.config = {
+            outputDir: './src/generated',
+            ...config,
+        };
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Run codegen to regenerate TypeScript bindings
+     */
+    async run() {
+        if (this.status === 'running') {
+            return false;
+        }
+        this.status = 'running';
+        this.emit('start');
+        try {
+            const binary = await this.findCodegenBinary();
+            if (!binary) {
+                this.status = 'failed';
+                this.emit('error', new Error('zap-codegen binary not found'));
+                return false;
+            }
+            return new Promise((resolve) => {
+                const args = ['--output-dir', this.config.outputDir];
+                console.log(`[codegen] Running: ${binary} ${args.join(' ')}`);
+                console.log(`[codegen] CWD: ${this.config.projectDir}`);
+                const proc = spawn(binary, args, {
+                    cwd: this.config.projectDir,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                let stderr = '';
+                let stdout = '';
+                proc.stdout?.on('data', (data) => {
+                    stdout += data.toString();
+                    console.log(`[codegen stdout] ${data.toString().trim()}`);
+                    this.emit('output', data.toString());
+                });
+                proc.stderr?.on('data', (data) => {
+                    stderr += data.toString();
+                    console.log(`[codegen stderr] ${data.toString().trim()}`);
+                    this.emit('stderr', data.toString());
+                });
+                proc.on('close', (code) => {
+                    console.log(`[codegen] Process exited with code: ${code}`);
+                    if (stdout)
+                        console.log(`[codegen] Full stdout: ${stdout}`);
+                    if (stderr)
+                        console.log(`[codegen] Full stderr: ${stderr}`);
+                    if (code === 0) {
+                        this.status = 'success';
+                        this.lastGenerated = new Date();
+                        this.emit('complete', { success: true });
+                        resolve(true);
+                    }
+                    else {
+                        this.status = 'failed';
+                        this.emit('complete', { success: false, error: stderr });
+                        resolve(false);
+                    }
+                });
+                proc.on('error', (err) => {
+                    console.log(`[codegen] Process error: ${err.message}`);
+                    this.status = 'failed';
+                    this.emit('error', err);
+                    resolve(false);
+                });
+            });
+        }
+        catch (err) {
+            this.status = 'failed';
+            this.emit('error', err);
+            return false;
+        }
+    }
+    /**
+     * Find the codegen binary
+     */
+    async findCodegenBinary() {
+        console.log(`[codegen] Looking for binary, config.codegenBinary: ${this.config.codegenBinary}`);
+        console.log(`[codegen] projectDir: ${this.config.projectDir}`);
+        // Check explicit config
+        if (this.config.codegenBinary) {
+            console.log(`[codegen] Checking explicit path: ${this.config.codegenBinary}`);
+            if (existsSync(this.config.codegenBinary)) {
+                console.log(`[codegen] Found at explicit path`);
+                return this.config.codegenBinary;
+            }
+            console.log(`[codegen] Not found at explicit path`);
+        }
+        // Check project's bin directory first (for pre-built binaries)
+        const binCandidates = [
+            path.join(this.config.projectDir, 'bin/zap-codegen'),
+            path.join(this.config.projectDir, 'bin/zap-codegen.exe'),
+            // Installed package location (when @zap-js/client is a dependency)
+            path.join(__dirname, '../../bin/zap-codegen'),
+            // node_modules location
+            path.join(this.config.projectDir, 'node_modules/@zap-js/client/bin/zap-codegen'),
+        ];
+        for (const candidate of binCandidates) {
+            console.log(`[codegen] Checking bin candidate: ${candidate}`);
+            if (existsSync(candidate)) {
+                console.log(`[codegen] Found at: ${candidate}`);
+                return candidate;
+            }
+        }
+        // Check project's target directory
+        const candidates = [
+            path.join(this.config.projectDir, 'target/release/zap-codegen'),
+            path.join(this.config.projectDir, 'target/debug/zap-codegen'),
+            // Check for architecture-specific builds
+            path.join(this.config.projectDir, 'target/aarch64-apple-darwin/release/zap-codegen'),
+            path.join(this.config.projectDir, 'target/x86_64-unknown-linux-gnu/release/zap-codegen'),
+        ];
+        for (const candidate of candidates) {
+            console.log(`[codegen] Checking target candidate: ${candidate}`);
+            if (existsSync(candidate)) {
+                console.log(`[codegen] Found at: ${candidate}`);
+                return candidate;
+            }
+        }
+        // Try to find in PATH
+        try {
+            execSync('which zap-codegen', { stdio: 'ignore' });
+            console.log(`[codegen] Found in PATH`);
+            return 'zap-codegen';
+        }
+        catch {
+            // Not in PATH
+        }
+        console.log(`[codegen] Binary not found anywhere`);
+        return null;
+    }
+    /**
+     * Check if codegen is needed based on file modification times
+     */
+    async isStale() {
+        if (!this.lastGenerated) {
+            return true;
+        }
+        // Could implement more sophisticated staleness detection
+        // by comparing Rust file mtimes with generated file mtimes
+        return false;
+    }
+    /**
+     * Get the output directory
+     */
+    getOutputDir() {
+        return path.join(this.config.projectDir, this.config.outputDir);
+    }
+}

package/dist/dev-server/hot-reload.d.ts

@@ -0,0 +1,72 @@
+import { EventEmitter } from 'events';
+export interface HotReloadConfig {
+    port?: number;
+    host?: string;
+}
+export type ReloadType = 'full' | 'partial' | 'rust' | 'typescript' | 'config' | 'routes';
+export interface ReloadMessage {
+    type: 'reload' | 'update' | 'error' | 'connected';
+    target?: ReloadType;
+    files?: string[];
+    message?: string;
+    timestamp: number;
+}
+/**
+ * HotReloadServer - WebSocket server for hot reload signaling
+ *
+ * Broadcasts reload signals to connected clients:
+ * - Full page reload for Rust changes
+ * - Partial reload for TypeScript changes (Vite HMR handles this)
+ * - Config reload notifications
+ */
+export declare class HotReloadServer extends EventEmitter {
+    private config;
+    private wss;
+    private httpServer;
+    private clients;
+    constructor(config?: HotReloadConfig);
+    /**
+     * Start the hot reload WebSocket server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Broadcast a reload signal to all clients
+     */
+    reload(target: ReloadType, files?: string[]): void;
+    /**
+     * Broadcast an update signal (partial reload)
+     */
+    update(files: string[]): void;
+    /**
+     * Broadcast an error message
+     */
+    notifyError(errorMessage: string): void;
+    /**
+     * Broadcast a message to all connected clients
+     */
+    private broadcast;
+    /**
+     * Send a message to a specific client
+     */
+    private send;
+    /**
+     * Get the number of connected clients
+     */
+    getClientCount(): number;
+    /**
+     * Get the hot reload server URL
+     */
+    getUrl(): string;
+    /**
+     * Get the client script for browser injection
+     */
+    getClientScript(): string;
+    /**
+     * Get an HTML script tag for the client
+     */
+    getScriptTag(): string;
+}