@burger-api/cli 0.7.0 → 0.9.1

package/src/utils/scanner.ts

@@ -0,0 +1,185 @@
+/**
+ * Build-time route scanner. Discovers route.ts and page files without loading modules.
+ * Path conversion rules match the framework (api-router, page-router).
+ */
+
+import { readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { detectExportedMethods } from './route-methods';
+import { ROUTE_CONSTANTS } from './route-conventions';
+import {
+    filePathToApiRoutePath,
+    filePathToPageRoutePath,
+} from './route-conventions';
+
+export interface ApiRouteScanEntry {
+    /** Absolute import path used by generated build entry */
+    importPath: string;
+    /** Route path with prefix (e.g. /api/users/:id) */
+    routePath: string;
+    isWildcard: boolean;
+    /** HTTP methods exported by the route module (set by method detection; omit = emit all) */
+    methods?: string[];
+}
+
+export interface PageRouteScanEntry {
+    /** Absolute import path used by generated build entry */
+    importPath: string;
+    routePath: string;
+}
+
+/**
+ * Scan apiDir for route.ts files and return entries for codegen.
+ * Uses same path/convention rules as framework ApiRouter.
+ */
+export async function scanApiRoutes(
+    cwd: string,
+    apiDir: string,
+    apiPrefix: string
+): Promise<ApiRouteScanEntry[]> {
+    const absoluteApiDir = path.resolve(cwd, apiDir);
+    if (!existsSync(absoluteApiDir)) {
+        return [];
+    }
+
+    const entries: ApiRouteScanEntry[] = [];
+    await scanApiDir(absoluteApiDir, '', apiPrefix, entries);
+    return entries;
+}
+
+async function scanApiDir(
+    dir: string,
+    basePath: string,
+    prefix: string,
+    out: ApiRouteScanEntry[]
+): Promise<void> {
+    let dynamicFolderFound = false;
+    let wildcardFolderFound = false;
+
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(dir, entry.name);
+        const relativePath = path.join(basePath, entry.name);
+
+        if (entry.isDirectory()) {
+            if (
+                entry.name.startsWith(ROUTE_CONSTANTS.WILDCARD_START) &&
+                entry.name !== ROUTE_CONSTANTS.WILDCARD_SIMPLE
+            ) {
+                continue;
+            }
+
+            const isDynamic =
+                entry.name.startsWith(ROUTE_CONSTANTS.DYNAMIC_FOLDER_START) &&
+                entry.name.endsWith(ROUTE_CONSTANTS.DYNAMIC_FOLDER_END) &&
+                !entry.name.startsWith(ROUTE_CONSTANTS.WILDCARD_START);
+            const isWildcard = entry.name === ROUTE_CONSTANTS.WILDCARD_SIMPLE;
+
+            if (isDynamic && wildcardFolderFound) {
+                throw new Error(
+                    `Cannot mix dynamic and wildcard route folders. Found dynamic '${entry.name}' but wildcard already exists in '${dir}'.`
+                );
+            }
+            if (isWildcard && dynamicFolderFound) {
+                throw new Error(
+                    `Cannot mix wildcard and dynamic route folders. Found wildcard '${entry.name}' but dynamic already exists in '${dir}'.`
+                );
+            }
+            if (isDynamic && dynamicFolderFound) {
+                throw new Error(
+                    `Multiple dynamic route folders in same directory: '${entry.name}' in '${dir}'.`
+                );
+            }
+            if (isWildcard && wildcardFolderFound) {
+                throw new Error(
+                    `Multiple wildcard route folders in same directory: '${entry.name}' in '${dir}'.`
+                );
+            }
+            if (isDynamic) dynamicFolderFound = true;
+            if (isWildcard) wildcardFolderFound = true;
+
+            await scanApiDir(entryPath, relativePath, prefix, out);
+            continue;
+        }
+
+        if (entry.isFile() && entry.name === 'route.ts') {
+            const routePath = filePathToApiRoutePath(relativePath, prefix);
+            const importPath = entryPath.split(path.sep).join('/');
+            const methods = await detectExportedMethods(entryPath);
+            const scanEntry: ApiRouteScanEntry = {
+                importPath,
+                routePath,
+                isWildcard: routePath.includes(
+                    ROUTE_CONSTANTS.WILDCARD_SEGMENT_PREFIX
+                ),
+            };
+            if (methods !== undefined) {
+                scanEntry.methods = methods;
+            }
+            out.push(scanEntry);
+        }
+    }
+}
+
+/**
+ * Scan pageDir for .tsx and .html pages and return entries for codegen.
+ */
+export async function scanPageRoutes(
+    cwd: string,
+    pageDir: string,
+    pagePrefix: string
+): Promise<PageRouteScanEntry[]> {
+    const absolutePageDir = path.resolve(cwd, pageDir);
+    if (!existsSync(absolutePageDir)) {
+        return [];
+    }
+
+    const entries: PageRouteScanEntry[] = [];
+    await scanPageDir(absolutePageDir, '', pagePrefix, entries);
+    return entries;
+}
+
+async function scanPageDir(
+    dir: string,
+    basePath: string,
+    prefix: string,
+    out: PageRouteScanEntry[]
+): Promise<void> {
+    let dynamicFolderFound = false;
+
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(dir, entry.name);
+        const relativePath = path.join(basePath, entry.name);
+
+        if (entry.isDirectory()) {
+            if (entry.name.startsWith(ROUTE_CONSTANTS.WILDCARD_START)) {
+                continue;
+            }
+
+            const isDynamic =
+                entry.name.startsWith(ROUTE_CONSTANTS.DYNAMIC_FOLDER_START) &&
+                entry.name.endsWith(ROUTE_CONSTANTS.DYNAMIC_FOLDER_END);
+            if (isDynamic && dynamicFolderFound) {
+                throw new Error(
+                    `Multiple dynamic page folders in same directory: '${entry.name}' in '${dir}'.`
+                );
+            }
+            if (isDynamic) dynamicFolderFound = true;
+            await scanPageDir(entryPath, relativePath, prefix, out);
+            continue;
+        }
+
+        if (
+            entry.isFile() &&
+            ROUTE_CONSTANTS.SUPPORTED_PAGE_EXTENSIONS.some((ext) =>
+                entry.name.endsWith(ext)
+            )
+        ) {
+            const routePath = filePathToPageRoutePath(relativePath, prefix);
+            const importPath = entryPath.split(path.sep).join('/');
+            out.push({ importPath, routePath });
+        }
+    }
+}

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.6.2',
+            'burger-api': '^0.9.0',
         },
         devDependencies: {
             '@types/bun': 'latest',
@@ -181,6 +181,37 @@ export function generateIndexFile(options: CreateOptions): string {
     return lines.join('\n');
 }
 
+/**
+ * Generate burger.config.ts from create command answers.
+ * This keeps build/runtime config explicit in scaffolded projects.
+ *
+ * @param options - Project configuration from user prompts
+ * @returns burger.config.ts content as a string
+ */
+export function generateBurgerConfig(options: CreateOptions): string {
+    const apiDir = `./src/${options.apiDir || 'api'}`;
+    const pageDir = `./src/${options.pageDir || 'pages'}`;
+    const apiPrefix = options.apiPrefix || '/api';
+    const pagePrefix = options.pagePrefix || '/';
+    const debug = Boolean(options.debug);
+
+    return [
+        '/**',
+        ' * BurgerAPI build and dev config.',
+        ' * Used by the CLI for build (burger-api build) and by your app if you load it.',
+        ' * Edit these paths and prefixes to match your project.',
+        ' */',
+        'export default {',
+        `    apiDir: ${JSON.stringify(apiDir)},   // folder with API route files`,
+        `    pageDir: ${JSON.stringify(pageDir)},   // folder with HTML pages`,
+        `    apiPrefix: ${JSON.stringify(apiPrefix)},   // URL prefix for API routes`,
+        `    pagePrefix: ${JSON.stringify(pagePrefix)},   // URL prefix for pages`,
+        `    debug: ${debug},   // extra logging when true`,
+        '};',
+        '',
+    ].join('\n');
+}
+
 /**
  * Generate a comprehensive API route file with full examples
  * Includes: OpenAPI metadata, Zod schemas, all HTTP methods, middleware
@@ -931,7 +962,7 @@ export function generateIndexPage(projectName: string): string {
 
     <!-- Footer -->
     <footer class="footer">
-        <div class="version">BurgerAPI v0.7.0 • Bun v1.3+</div>
+        <div class="version">BurgerAPI v0.9.0 • 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>
@@ -962,13 +993,15 @@ export function generateMiddlewareIndex(): string {
  * import { cors } from './cors/cors';
  * import { logger } from './logger/logger';
  * 
- * export const globalMiddleware = [
+ * export const globalMiddleware: Middleware[] = [
  *     logger(),
  *     cors(),
  * ];
  */
 
-export const globalMiddleware: any[] = [];
+import type { Middleware } from 'burger-api';
+
+export const globalMiddleware: Middleware[] = [];
 `;
 }
 
@@ -1026,6 +1059,10 @@ export async function createProject(
             join(targetDir, '.prettierrc'),
             generatePrettierConfig()
         );
+        await Bun.write(
+            join(targetDir, 'burger.config.ts'),
+            generateBurgerConfig(options)
+        );
 
         // Create src directory and index file
         await Bun.write(

package/src/utils/virtual-entry.ts

@@ -0,0 +1,121 @@
+/**
+ * Generate the in-memory virtual entrypoint source for Bun.build().
+ * Uses static imports so the bundler traces and embeds all route modules.
+ */
+
+import type { BuildConfig } from '../types/index';
+import type { ApiRouteScanEntry, PageRouteScanEntry } from './scanner';
+
+/** Default methods to emit when entry has no methods; excludes OPTIONS so we add 204 only when hasPreflight. */
+const DEFAULT_EMIT_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'];
+
+const PREFLIGHT_METHODS = ['POST', 'PUT', 'DELETE', 'PATCH'];
+
+function methodsToEmit(entry: ApiRouteScanEntry): string[] {
+    if (entry.methods && entry.methods.length > 0) {
+        return entry.methods;
+    }
+    return [...DEFAULT_EMIT_METHODS];
+}
+
+function pushImportLines(
+    lines: string[],
+    entries: { importPath: string }[],
+    variablePrefix: 'r' | 'p'
+): void {
+    entries.forEach((entry, index) => {
+        lines.push(
+            `import * as _${variablePrefix}${index} from '${entry.importPath}';`
+        );
+    });
+}
+
+/**
+ * Generate virtual entrypoint source that imports all routes and starts Burger with apiRoutes/pageRoutes.
+ */
+export function generateVirtualEntrySource(
+    config: BuildConfig,
+    apiEntries: ApiRouteScanEntry[],
+    pageEntries: PageRouteScanEntry[],
+    optionsImportPath?: string
+): string {
+    const lines: string[] = [];
+
+    lines.push('// Auto-generated by burger-api build. Do not edit.');
+    lines.push("import { Burger } from 'burger-api';");
+    if (optionsImportPath) {
+        lines.push(
+            `import { burgerOptions as __burgerOptions } from '${optionsImportPath}';`
+        );
+    }
+    lines.push('');
+    // Ensure CWD matches the bundle directory so HTML chunk paths resolve correctly
+    lines.push('process.chdir(import.meta.dir);');
+    lines.push('');
+
+    pushImportLines(lines, apiEntries, 'r');
+    if (pageEntries.length) {
+        lines.push('');
+        pushImportLines(lines, pageEntries, 'p');
+    }
+
+    lines.push('');
+    lines.push('const apiRoutes = [');
+
+    apiEntries.forEach((e, i) => {
+        const methods = methodsToEmit(e);
+        const hasPreflight = PREFLIGHT_METHODS.some((m) => methods.includes(m));
+
+        lines.push('  {');
+        lines.push(`    path: ${JSON.stringify(e.routePath)},`);
+        lines.push('    handlers: {');
+        for (const m of methods) {
+            lines.push(`      ${m}: _r${i}.${m},`);
+        }
+        if (!methods.includes('OPTIONS') && hasPreflight) {
+            lines.push(
+                `      OPTIONS: () => new Response(null, { status: 204 }),`
+            );
+        }
+        lines.push('    },');
+        lines.push(`    middleware: _r${i}.middleware,`);
+        lines.push(`    schema: _r${i}.schema,`);
+        lines.push(`    openapi: _r${i}.openapi,`);
+        lines.push(`    isWildcard: ${e.isWildcard},`);
+        lines.push('  },');
+    });
+
+    lines.push('];');
+    lines.push('');
+
+    lines.push('const pageRoutes = [');
+    pageEntries.forEach((p, i) => {
+        lines.push(
+            `  { path: ${JSON.stringify(p.routePath)}, handler: _p${i}.default },`
+        );
+        if (p.routePath !== '/' && !p.routePath.endsWith('/')) {
+            lines.push(
+                `  { path: ${JSON.stringify(p.routePath + '/')}, handler: _p${i}.default },`
+            );
+        }
+    });
+    lines.push('];');
+    lines.push('');
+
+    lines.push('const app = new Burger({');
+    if (optionsImportPath) {
+        lines.push('  ...__burgerOptions,');
+    } else {
+        lines.push(`  debug: ${config.debug === true},`);
+    }
+    lines.push('  apiRoutes,');
+    lines.push('  pageRoutes,');
+    lines.push('});');
+    lines.push('');
+    lines.push('const port = Number(process.env.PORT) || 4000;');
+    lines.push('app.serve(port, () => {');
+    lines.push('  console.log(`Server running on http://localhost:${port}`);');
+    lines.push('});');
+
+    return lines.join('\n');
+}