@burger-api/cli 0.7.1 → 0.9.3

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/config.ts

@@ -0,0 +1,78 @@
+/**
+ * Build config resolution: conventions-first with optional burger.config.ts
+ *
+ * Used by the CLI build pipeline to discover apiDir, pageDir, and prefixes
+ * without parsing the user's entry file.
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import type { BuildConfig } from '../types/index';
+
+const CONVENTION_DEFAULTS: BuildConfig = {
+    apiDir: './src/api',
+    pageDir: './src/pages',
+    apiPrefix: '/api',
+    pagePrefix: '/',
+    debug: false,
+};
+
+const CONFIG_NAMES = ['burger.config.ts', 'burger.config.js'];
+
+/**
+ * Resolve build configuration from the project directory.
+ * Uses convention defaults; overrides with burger.config.ts / burger.config.js if present.
+ *
+ * @param cwd - Project root (e.g. process.cwd())
+ * @returns BuildConfig with resolved paths and prefixes
+ */
+export async function resolveBuildConfig(cwd: string): Promise<BuildConfig> {
+    let configPath: string | null = null;
+    for (const name of CONFIG_NAMES) {
+        const candidate = join(cwd, name);
+        if (existsSync(candidate)) {
+            configPath = candidate;
+            break;
+        }
+    }
+
+    if (!configPath) {
+        return { ...CONVENTION_DEFAULTS };
+    }
+
+    try {
+        const mod = await import(configPath);
+        const user = mod.default ?? mod;
+        if (!user || typeof user !== 'object') {
+            return { ...CONVENTION_DEFAULTS };
+        }
+        return mergeBuildConfig(CONVENTION_DEFAULTS, user);
+    } catch (err) {
+        console.warn(
+            `[burger-api] Could not load ${configPath}: ${err instanceof Error ? err.message : String(err)}. Using convention defaults.`
+        );
+        return { ...CONVENTION_DEFAULTS };
+    }
+}
+
+function mergeBuildConfig(
+    defaults: BuildConfig,
+    user: Record<string, unknown>
+): BuildConfig {
+    return {
+        apiDir:
+            typeof user.apiDir === 'string' ? user.apiDir : defaults.apiDir,
+        pageDir:
+            typeof user.pageDir === 'string' ? user.pageDir : defaults.pageDir,
+        apiPrefix:
+            typeof user.apiPrefix === 'string'
+                ? user.apiPrefix
+                : defaults.apiPrefix,
+        pagePrefix:
+            typeof user.pagePrefix === 'string'
+                ? user.pagePrefix
+                : defaults.pagePrefix,
+        debug:
+            typeof user.debug === 'boolean' ? user.debug : defaults.debug,
+    };
+}