@burger-api/cli 0.9.1 → 0.9.3

package/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 All notable changes to the Burger API CLI will be documented in this file.
 
-## Version 0.9.0 - (March 15, 2026)
+## Version 0.9.3 - (March 17, 2026)
 
 -   ✨ **Create** – New projects get a config file (`burger.config.ts`) from
     your answers; the build uses this config when present.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burger-api/cli",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Simple command-line tool for Burger API projects",
   "module": "src/index.ts",
   "type": "module",

package/src/utils/build/bun.ts

@@ -0,0 +1,134 @@
+import { resolve } from 'path';
+
+function formatBunBuildLogs(logs: unknown): string {
+    if (!Array.isArray(logs) || logs.length === 0) {
+        return '';
+    }
+
+    const messages: string[] = [];
+    for (const item of logs) {
+        if (!item || typeof item !== 'object') continue;
+
+        const log = item as {
+            level?: string;
+            message?: string;
+            text?: string;
+            name?: string;
+            position?: { file?: string; line?: number; column?: number };
+        };
+        const text =
+            (typeof log.message === 'string' && log.message) ||
+            (typeof log.text === 'string' && log.text) ||
+            (typeof log.name === 'string' && log.name) ||
+            '';
+        if (!text) continue;
+
+        const level =
+            typeof log.level === 'string' ? log.level.toUpperCase() : 'ERROR';
+        const file = log.position?.file ? `${log.position.file}` : '';
+        const line =
+            typeof log.position?.line === 'number'
+                ? `:${log.position.line}`
+                : '';
+        const column =
+            typeof log.position?.column === 'number'
+                ? `:${log.position.column}`
+                : '';
+        const location = file ? ` (${file}${line}${column})` : '';
+        messages.push(`- [${level}] ${text}${location}`);
+    }
+    return messages.join('\n');
+}
+
+function extractBunBuildDetails(err: unknown): string {
+    if (!err || typeof err !== 'object') {
+        return '';
+    }
+
+    const anyErr = err as {
+        logs?: unknown;
+        errors?: unknown;
+        cause?: { logs?: unknown; errors?: unknown };
+    };
+    const candidates = [
+        anyErr.logs,
+        anyErr.errors,
+        anyErr.cause?.logs,
+        anyErr.cause?.errors,
+    ];
+
+    for (const candidate of candidates) {
+        const detail = formatBunBuildLogs(candidate);
+        if (detail) return detail;
+    }
+    return '';
+}
+
+export function createBunBuildOptions(options: {
+    entryPath: string;
+    outDir: string;
+    cwd: string;
+    outfile: string;
+    target?: string;
+    minify?: boolean;
+    sourcemap?: string;
+    compile?: boolean;
+    bytecode?: boolean;
+}): Parameters<typeof Bun.build>[0] {
+    const buildOptions: Parameters<typeof Bun.build>[0] = {
+        entrypoints: [options.entryPath],
+        outdir: options.outDir,
+        target: (options.target as 'bun') || 'bun',
+        minify: options.minify ?? false,
+        splitting: false,
+        sourcemap:
+            options.sourcemap === undefined
+                ? undefined
+                : (options.sourcemap as 'none' | 'linked' | 'inline' | 'external'),
+    };
+
+    const ext = buildOptions as unknown as Record<string, unknown>;
+    ext.naming = {
+        chunk: '[name]-[hash].[ext]',
+        asset: '[name]-[hash].[ext]',
+    };
+
+    if (options.compile) {
+        ext.compile = {
+            outfile: resolve(options.cwd, options.outfile),
+            ...(options.target && { target: options.target }),
+        };
+        if (options.bytecode !== false) {
+            ext.bytecode = true;
+        }
+        delete ext.outdir;
+    }
+
+    return buildOptions;
+}
+
+export async function runBunBuildOrThrow(
+    buildOptions: Parameters<typeof Bun.build>[0]
+): Promise<Awaited<ReturnType<typeof Bun.build>>> {
+    let result: Awaited<ReturnType<typeof Bun.build>>;
+    try {
+        result = await Bun.build(buildOptions);
+    } catch (err) {
+        const detail = extractBunBuildDetails(err);
+        const message = err instanceof Error ? err.message : 'Bun.build failed.';
+        if (detail) {
+            throw new Error(`${message}\n${detail}`);
+        }
+        throw new Error(message);
+    }
+
+    if (!result.success) {
+        const detail = formatBunBuildLogs((result as { logs?: unknown }).logs);
+        if (detail) {
+            throw new Error(`Bun.build failed.\n${detail}`);
+        }
+        throw new Error('Bun.build failed.');
+    }
+
+    return result;
+}

package/src/utils/build/entry.ts

@@ -0,0 +1,74 @@
+import { dirname, resolve } from 'path';
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'fs';
+
+export function prepareVirtualEntry(options: {
+    cwd: string;
+    outfile: string;
+    pageDir: string;
+    source: string;
+    hasPages: boolean;
+}): { outDir: string; virtualSourcePath: string; virtualPath: string } {
+    const outDir = resolve(options.cwd, dirname(options.outfile));
+    mkdirSync(outDir, { recursive: true });
+
+    const virtualEntryDir = options.hasPages
+        ? resolve(options.cwd, options.pageDir)
+        : outDir;
+    mkdirSync(virtualEntryDir, { recursive: true });
+
+    const virtualSourcePath = resolve(virtualEntryDir, '__burger_build_entry__.ts');
+    const virtualPath = virtualSourcePath.split('\\').join('/');
+    writeFileSync(virtualSourcePath, options.source, 'utf-8');
+
+    return { outDir, virtualSourcePath, virtualPath };
+}
+
+export function cleanupVirtualEntry(virtualSourcePath: string): void {
+    if (existsSync(virtualSourcePath)) {
+        unlinkSync(virtualSourcePath);
+    }
+}
+
+export async function finalizeBuildOutputs(options: {
+    result: Awaited<ReturnType<typeof Bun.build>>;
+    cwd: string;
+    outfile: string;
+    outDir: string;
+    compile?: boolean;
+}): Promise<{ path: string; size: number }[]> {
+    const desiredOut = resolve(options.cwd, options.outfile);
+    const outputs: { path: string; size: number }[] = [];
+
+    if (!options.result.outputs?.length) {
+        return outputs;
+    }
+
+    const first = options.result.outputs[0] as Blob & { path?: string };
+    const outPath = first.path ? resolve(first.path) : undefined;
+
+    const entryArtifacts = new Set<string>([
+        resolve(options.outDir, '__burger_build_entry__.js'),
+    ]);
+    if (outPath?.endsWith('__burger_build_entry__.js')) {
+        entryArtifacts.add(outPath);
+    }
+
+    if (!options.compile && outPath && outPath !== desiredOut) {
+        const blob = first as Blob;
+        await Bun.write(desiredOut, blob);
+        outputs.push({ path: desiredOut, size: blob.size });
+    } else {
+        outputs.push({
+            path: outPath ?? desiredOut,
+            size: (first as Blob).size ?? 0,
+        });
+    }
+
+    for (const entryArtifact of entryArtifacts) {
+        if (entryArtifact !== desiredOut && existsSync(entryArtifact)) {
+            unlinkSync(entryArtifact);
+        }
+    }
+
+    return outputs;
+}

package/src/utils/build/pipeline.ts

@@ -0,0 +1,90 @@
+import { resolveBuildConfig } from '../config';
+import { scanApiRoutes, scanPageRoutes } from '../scanner';
+import { generateVirtualEntrySource } from '../virtual-entry';
+import { createBunBuildOptions, runBunBuildOrThrow } from './bun';
+import {
+    cleanupVirtualEntry,
+    finalizeBuildOutputs,
+    prepareVirtualEntry,
+} from './entry';
+import {
+    cleanupEntryOptionsModule,
+    prepareEntryOptionsModule,
+} from '../entry-options';
+
+export interface VirtualBuildResult {
+    success: boolean;
+    hasPages: boolean;
+    outputs: { path: string; size: number }[];
+}
+
+export async function runVirtualEntryBuild(options: {
+    cwd: string;
+    entryFile: string;
+    outfile: string;
+    target?: string;
+    minify?: boolean;
+    sourcemap?: string;
+    compile?: boolean;
+    bytecode?: boolean;
+}): Promise<VirtualBuildResult> {
+    const config = await resolveBuildConfig(options.cwd);
+    const entryOptions = prepareEntryOptionsModule({
+        cwd: options.cwd,
+        entryFile: options.entryFile,
+    });
+
+    const [apiEntries, pageEntries] = await Promise.all([
+        scanApiRoutes(options.cwd, config.apiDir, config.apiPrefix),
+        scanPageRoutes(options.cwd, config.pageDir, config.pagePrefix),
+    ]);
+
+    if (apiEntries.length === 0 && pageEntries.length === 0) {
+        throw new Error(
+            `No routes found. Ensure ${config.apiDir} or ${config.pageDir} ` +
+                `exist and contain route.ts files or page files.`
+        );
+    }
+
+    const source = generateVirtualEntrySource(
+        config,
+        apiEntries,
+        pageEntries,
+        entryOptions.importPath
+    );
+    const hasPages = pageEntries.length > 0;
+    const { outDir, virtualPath, virtualSourcePath } = prepareVirtualEntry({
+        cwd: options.cwd,
+        outfile: options.outfile,
+        pageDir: config.pageDir,
+        source,
+        hasPages,
+    });
+
+    const buildOptions = createBunBuildOptions({
+        entryPath: virtualPath,
+        outDir,
+        cwd: options.cwd,
+        outfile: options.outfile,
+        target: options.target,
+        minify: options.minify,
+        sourcemap: options.sourcemap,
+        compile: options.compile,
+        bytecode: options.bytecode,
+    });
+
+    try {
+        const result = await runBunBuildOrThrow(buildOptions);
+        const outputs = await finalizeBuildOutputs({
+            result,
+            cwd: options.cwd,
+            outfile: options.outfile,
+            outDir,
+            compile: options.compile,
+        });
+        return { success: result.success ?? false, hasPages, outputs };
+    } finally {
+        cleanupVirtualEntry(virtualSourcePath);
+        cleanupEntryOptionsModule(entryOptions.tempFilePath);
+    }
+}

package/src/utils/build/project.ts

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Read the project name from package.json.
+ * Falls back to 'app' if not found or on any error.
+ */
+export function getProjectName(cwd: string = process.cwd()): string {
+    try {
+        const packageJsonPath = join(cwd, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as {
+                name?: string;
+            };
+            return pkg?.name || 'app';
+        }
+    } catch {
+        // Ignore — use fallback
+    }
+    return 'app';
+}

package/src/utils/templates.ts

@@ -30,7 +30,7 @@ export function generatePackageJson(projectName: string): string {
             build: 'bun build src/index.ts --outdir ./dist',
         },
         dependencies: {
-            'burger-api': '^0.9.0',
+            'burger-api': '^0.9.3',
         },
         devDependencies: {
             '@types/bun': 'latest',
@@ -962,7 +962,7 @@ export function generateIndexPage(projectName: string): string {
 
     <!-- Footer -->
     <footer class="footer">
-        <div class="version">BurgerAPI v0.9.0 • Bun v1.3+</div>
+        <div class="version">BurgerAPI v0.9.3 • Bun v1.3+</div>
         <div class="social-links">
             <a href="https://github.com/isfhan/burger-api" target="_blank">GitHub</a>
             <a href="https://www.npmjs.com/package/burger-api" target="_blank">NPM</a>