@burger-api/cli 0.6.6

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@burger-api/cli",
+  "version": "0.6.6",
+  "description": "Simple command-line tool for Burger API projects",
+  "module": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "burger-api": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build:win": "bun build ./src/index.ts --compile --target bun-windows-x64 --outfile dist/burger-api.exe --minify",
+    "build:linux": "bun build ./src/index.ts --compile --target bun-linux-x64 --outfile dist/burger-api-linux --minify",
+    "build:mac": "bun build ./src/index.ts --compile --target bun-darwin-arm64 --outfile dist/burger-api-mac --minify",
+    "build:mac-intel": "bun build ./src/index.ts --compile --target bun-darwin-x64 --outfile dist/burger-api-mac-intel --minify",
+    "build:all": "bun run build:win && bun run build:linux && bun run build:mac && bun run build:mac-intel"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "@clack/prompts": "^0.7.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/commander": "^2.12.5"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "keywords": [
+    "burger-api",
+    "cli",
+    "framework",
+    "bun"
+  ],
+  "author": "Isfhan Ahmed",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/isfhan/burger-api.git",
+    "directory": "packages/cli"
+  }
+}

package/src/commands/add.ts

@@ -0,0 +1,201 @@
+/**
+ * Add Command
+ *
+ * Downloads middleware from the ecosystem and adds it to the user's project.
+ * Users can add multiple middleware at once!
+ *
+ * Example: burger-api add cors logger rate-limiter
+ */
+
+import { Command } from 'commander';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import * as clack from '@clack/prompts';
+import { generateMiddlewareIndex } from '../utils/templates';
+import { middlewareExists, downloadMiddleware } from '../utils/github';
+import {
+    spinner,
+    success,
+    error as logError,
+    info,
+    newline,
+    header,
+    code,
+    warning,
+    bullet,
+} from '../utils/logger';
+
+/**
+ * Create the "add" command
+ * Downloads middleware from GitHub and copies to project
+ */
+export const addCommand = new Command('add')
+    .description('Add middleware from the ecosystem')
+    .argument('<middleware...>', 'Names of middleware to add')
+    .action(async (middlewareNames: string[]) => {
+        clack.intro('Add middleware to your project');
+
+        // Make sure we're in a BurgerAPI project
+        if (!existsSync('package.json')) {
+            clack.outro('Not in a BurgerAPI project');
+            logError(
+                'Please run this command from a BurgerAPI project directory.'
+            );
+            info('Create a new project with: burger-api create <name>');
+            process.exit(1);
+        }
+
+        // Create ecosystem/middleware directory if it doesn't exist
+        // Ecosystem middleware goes here, user's custom middleware can go in middleware/
+        const ecosystemDir = join(process.cwd(), 'ecosystem');
+        const middlewareDir = join(ecosystemDir, 'middleware');
+        if (!existsSync(middlewareDir)) {
+            // Create it with a proper starter file
+            await Bun.write(
+                join(middlewareDir, 'index.ts'),
+                generateMiddlewareIndex()
+            );
+            info('Created ecosystem/middleware/ directory');
+            newline();
+        }
+
+        // Process each middleware
+        const results = {
+            success: [] as string[],
+            failed: [] as string[],
+            skipped: [] as string[],
+        };
+
+        for (const name of middlewareNames) {
+            try {
+                // Check if it exists on GitHub
+                const spin = spinner(`Checking ${name}...`);
+
+                let exists;
+                try {
+                    exists = await middlewareExists(name);
+                } catch (err) {
+                    spin.stop('Could not connect to GitHub', true);
+                    logError(
+                        'Please check your internet connection and try again.'
+                    );
+                    results.failed.push(name);
+                    continue;
+                }
+
+                if (!exists) {
+                    spin.stop(`Middleware "${name}" not found`, true);
+                    results.failed.push(name);
+                    continue;
+                }
+
+                spin.update(`Downloading ${name}...`);
+
+                // Check if it already exists locally
+                const targetDir = join(middlewareDir, name);
+                if (existsSync(targetDir)) {
+                    spin.stop();
+                    // Ask if they want to overwrite
+                    const shouldOverwrite = await clack.confirm({
+                        message: `${name} already exists. Overwrite?`,
+                        initialValue: false,
+                    });
+
+                    if (clack.isCancel(shouldOverwrite) || !shouldOverwrite) {
+                        info(`Skipped ${name}`);
+                        results.skipped.push(name);
+                        continue;
+                    }
+                }
+
+                // Download the middleware
+                try {
+                    const filesDownloaded = await downloadMiddleware(
+                        name,
+                        targetDir
+                    );
+                    spin.stop(`Added ${name} (${filesDownloaded} files)`);
+                    results.success.push(name);
+                } catch (err) {
+                    spin.stop('Download failed', true);
+                    if (
+                        err instanceof Error &&
+                        err.message.includes('Could not download')
+                    ) {
+                        logError(
+                            'Please check your internet connection and try again.'
+                        );
+                    } else {
+                        logError(
+                            err instanceof Error ? err.message : 'Unknown error'
+                        );
+                    }
+                    results.failed.push(name);
+                }
+            } catch (err) {
+                logError(
+                    `Failed to add ${name}: ${
+                        err instanceof Error ? err.message : 'Unknown error'
+                    }`
+                );
+                results.failed.push(name);
+            }
+        }
+
+        // Show summary
+        newline();
+        if (results.success.length > 0) {
+            success(`Successfully added ${results.success.length} middleware:`);
+            results.success.forEach((name) => bullet(name));
+            newline();
+
+            // Show usage instructions
+            header('How to Use');
+            info('Import and use the middleware in your index.ts:');
+            newline();
+            code('import { Burger } from "burger-api";');
+            results.success.forEach((name) => {
+                code(
+                    `import { ${name} } from "./ecosystem/middleware/${name}/${name}";`
+                );
+            });
+            newline();
+            code('const app = new Burger({');
+            code('    apiDir: "./api",');
+            code('    globalMiddleware: [');
+            results.success.forEach((name) => {
+                code(`        ${name}(),`);
+            });
+            code('    ],');
+            code('});');
+            newline();
+            newline();
+
+            info('Check each middleware README for configuration options:');
+            results.success.forEach((name) => {
+                bullet(`ecosystem/middleware/${name}/README.md`);
+            });
+            newline();
+        }
+
+        if (results.failed.length > 0) {
+            warning(`Failed to add ${results.failed.length} middleware:`);
+            results.failed.forEach((name) => bullet(name));
+            newline();
+            info('Run "burger-api list" to see available middleware.');
+            newline();
+        }
+
+        if (results.skipped.length > 0) {
+            info(`Skipped ${results.skipped.length} middleware:`);
+            results.skipped.forEach((name) => bullet(name));
+            newline();
+        }
+
+        if (results.success.length > 0) {
+            clack.outro('Middleware added successfully!');
+        } else {
+            clack.outro('No middleware were added');
+            process.exit(1);
+        }
+    });

package/src/commands/build.ts

@@ -0,0 +1,250 @@
+/**
+ * Build Commands
+ *
+ * Two commands for packaging your Burger API project:
+ * 1. `burger-api build <file>` - Bundle to single JS file
+ * 2. `burger-api build:executable <file>` - Compile to standalone executable
+ *
+ * These are wrappers around Bun's build commands with sensible defaults.
+ */
+
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import {
+    spinner,
+    success,
+    error as logError,
+    info,
+    newline,
+    formatSize,
+    dim,
+} from '../utils/logger';
+
+/**
+ * Build command options
+ */
+interface BuildCommandOptions {
+    outfile: string;
+    minify?: boolean;
+    sourcemap?: string;
+    target?: string;
+}
+
+/**
+ * Build executable command options
+ */
+interface BuildExecutableOptions {
+    outfile?: string;
+    target?: string;
+    minify: boolean;
+    bytecode: boolean;
+}
+
+/**
+ * Create the "build" command
+ * Bundles your code into a single JavaScript file
+ */
+export const buildCommand = new Command('build')
+    .description('Bundle your project to a single JavaScript file')
+    .argument('<file>', 'Entry file to build (e.g., index.ts)')
+    .option('--outfile <path>', 'Output file path', '.build/bundle.js')
+    .option('--minify', 'Minify the output')
+    .option(
+        '--sourcemap <type>',
+        'Generate sourcemaps (inline, linked, or none)'
+    )
+    .option('--target <target>', 'Target environment (e.g., bun, node)')
+    .action(async (file: string, options: BuildCommandOptions) => {
+        // Check if the input file exists
+        if (!existsSync(file)) {
+            logError(`File not found: ${file}`);
+            process.exit(1);
+        }
+
+        const spin = spinner('Building project...');
+
+        try {
+            // Build the command arguments for Bun
+            const args = ['build', file];
+
+            // Add output file
+            args.push('--outfile', options.outfile);
+
+            // Add optional flags
+            if (options.minify) {
+                args.push('--minify');
+            }
+
+            if (options.sourcemap) {
+                args.push('--sourcemap', options.sourcemap);
+            }
+
+            // Always target bun by default since BurgerAPI uses Bun builtins
+            args.push('--target', options.target || 'bun');
+
+            // Run the build using Bun.spawn
+            const proc = Bun.spawn(['bun', ...args], {
+                stdout: 'pipe',
+                stderr: 'pipe',
+            });
+
+            // Wait for it to complete
+            const exitCode = await proc.exited;
+
+            if (exitCode !== 0) {
+                // Read error output
+                const errorText = await new Response(proc.stderr).text();
+                spin.stop('Build failed', true);
+                logError(errorText || 'Build process failed');
+                process.exit(1);
+            }
+
+            // Get file size
+            const outputFile = Bun.file(options.outfile);
+            const size = outputFile.size;
+
+            spin.stop('Build completed successfully!');
+            newline();
+            success(`Output: ${options.outfile}`);
+            info(`Size: ${formatSize(size)}`);
+            newline();
+            dim('Run your bundle with: bun ' + options.outfile);
+            newline();
+        } catch (err) {
+            spin.stop('Build failed', true);
+            logError(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+
+/**
+ * Create the "build:executable" command
+ * Compiles your code to a standalone executable
+ */
+export const buildExecutableCommand = new Command('build:executable')
+    .description('Compile your project to a standalone executable')
+    .argument('<file>', 'Entry file to compile (e.g., index.ts)')
+    .option('--outfile <path>', 'Output file path')
+    .option(
+        '--target <target>',
+        'Target platform (bun-windows-x64, bun-linux-x64, bun-darwin-arm64)'
+    )
+    .option('--minify', 'Minify the output (enabled by default)', true)
+    .option('--no-bytecode', 'Disable bytecode compilation')
+    .action(async (file: string, options: BuildExecutableOptions) => {
+        // Check if the input file exists
+        if (!existsSync(file)) {
+            logError(`File not found: ${file}`);
+            process.exit(1);
+        }
+
+        // Determine output filename
+        let outfile = options.outfile;
+        if (!outfile) {
+            // Get project name from package.json or use basename
+            const projectName = getProjectName();
+
+            // Add platform-specific extension
+            // Check if targeting Windows or if we're on Windows without a specific target
+            const isWindows =
+                options.target?.includes('windows') ||
+                (!options.target && process.platform === 'win32');
+
+            if (isWindows) {
+                outfile = `.build/${projectName}.exe`;
+            } else {
+                outfile = `.build/${projectName}`;
+            }
+        }
+
+        const spin = spinner('Compiling to executable...');
+
+        try {
+            // Build the command arguments for Bun
+            const args = ['build', file, '--compile'];
+
+            // Add output file
+            args.push('--outfile', outfile);
+
+            // Add target platform
+            if (options.target) {
+                args.push('--target', options.target);
+            }
+
+            // Add minify (on by default)
+            if (options.minify) {
+                args.push('--minify');
+            }
+
+            // Add bytecode (on by default, unless --no-bytecode is passed)
+            if (options.bytecode !== false) {
+                args.push('--bytecode');
+            }
+
+            spin.update('Compiling... (this may take a minute)');
+
+            // Run the build using Bun.spawn
+            const proc = Bun.spawn(['bun', ...args], {
+                stdout: 'pipe',
+                stderr: 'pipe',
+            });
+
+            // Wait for it to complete
+            const exitCode = await proc.exited;
+
+            if (exitCode !== 0) {
+                // Read error output
+                const errorText = await new Response(proc.stderr).text();
+                spin.stop('Compilation failed', true);
+                logError(errorText || 'Compilation process failed');
+                process.exit(1);
+            }
+
+            // Get file size - check if file exists first
+            let size = 0;
+            if (existsSync(outfile)) {
+                const executableFile = Bun.file(outfile);
+                size = executableFile.size;
+            }
+
+            spin.stop('Compilation completed successfully!');
+            newline();
+            success(`Executable: ${outfile}`);
+            if (size > 0) {
+                info(`Size: ${formatSize(size)}`);
+            }
+            newline();
+            info('Your standalone executable is ready to run!');
+
+            if (process.platform !== 'win32') {
+                dim(`Make it executable: chmod +x ${outfile}`);
+                dim(`Run it: ./${outfile}`);
+            } else {
+                dim(`Run it: ${outfile}`);
+            }
+            newline();
+        } catch (err) {
+            spin.stop('Compilation failed', true);
+            logError(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+
+/**
+ * Get the project name from package.json
+ * Falls back to 'app' if not found
+ */
+function getProjectName(): string {
+    try {
+        const packageJsonPath = join(process.cwd(), 'package.json');
+        if (existsSync(packageJsonPath)) {
+            const content = readFileSync(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(content);
+            return packageJson?.name || 'app';
+        }
+    } catch (err) {
+        // Ignore errors
+    }
+    return 'app';
+}