@burger-api/cli 0.7.1 → 0.9.1

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,
+    };
+}

package/src/utils/entry-options.ts

@@ -0,0 +1,326 @@
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { dirname, resolve } from 'path';
+
+interface PreparedEntryOptions {
+    importPath?: string;
+    tempFilePath?: string;
+}
+
+const ENTRY_OPTIONS_FILENAME = '__burger_build_options__.ts';
+
+/**
+ * Find the index of the closing ')' that matches the '(' at openIndex.
+ * Skips strings, template literals, and comments so parens inside them are ignored.
+ * Returns -1 if no matching ')' is found.
+ */
+function findMatchingClosingParen(source: string, openIndex: number): number {
+    let depth = 1;
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplate = false;
+    let interpolationBraceDepth = 0;
+    let nestedTemplateDepth = 0;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+
+    for (let i = openIndex + 1; i < source.length; i++) {
+        const ch = source[i];
+        const next = i + 1 < source.length ? source[i + 1] : '';
+
+        if (inLineComment) {
+            if (ch === '\n') inLineComment = false;
+            continue;
+        }
+        if (inBlockComment) {
+            if (ch === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+
+        if (inSingle) {
+            if (!escaped && ch === "'") inSingle = false;
+            escaped = !escaped && ch === '\\';
+            continue;
+        }
+        if (inDouble) {
+            if (!escaped && ch === '"') inDouble = false;
+            escaped = !escaped && ch === '\\';
+            continue;
+        }
+        if (inTemplate) {
+            if (!escaped && ch === '`') {
+                if (nestedTemplateDepth > 0) {
+                    nestedTemplateDepth--;
+                } else if (interpolationBraceDepth > 0) {
+                    nestedTemplateDepth++;
+                } else {
+                    inTemplate = false;
+                    interpolationBraceDepth = 0;
+                    nestedTemplateDepth = 0;
+                }
+                escaped = false;
+                continue;
+            }
+            if (!escaped && ch === '$' && next === '{') {
+                interpolationBraceDepth = 1;
+                i++;
+                escaped = false;
+                continue;
+            }
+            if (!escaped && nestedTemplateDepth === 0) {
+                if (ch === '{') {
+                    interpolationBraceDepth++;
+                    escaped = false;
+                    continue;
+                }
+                if (ch === '}') {
+                    interpolationBraceDepth--;
+                    escaped = false;
+                    continue;
+                }
+            }
+            if (!escaped && ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            escaped = false;
+            continue;
+        }
+
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            escaped = false;
+            continue;
+        }
+        if (ch === '"') {
+            inDouble = true;
+            escaped = false;
+            continue;
+        }
+        if (ch === '`') {
+            inTemplate = true;
+            interpolationBraceDepth = 0;
+            nestedTemplateDepth = 0;
+            escaped = false;
+            continue;
+        }
+
+        if (ch === '(') {
+            depth++;
+            continue;
+        }
+        if (ch === ')') {
+            depth--;
+            if (depth === 0) return i;
+        }
+    }
+
+    return -1;
+}
+
+function extractBurgerOptionsObjectLiteral(source: string): string | null {
+    const burgerCtor = source.match(/\bnew\s+Burger\s*\(/);
+    if (!burgerCtor || burgerCtor.index === undefined) {
+        return null;
+    }
+
+    const callStart = source.indexOf('(', burgerCtor.index);
+    if (callStart < 0) {
+        return null;
+    }
+
+    const callEnd = findMatchingClosingParen(source, callStart);
+    if (callEnd < 0) {
+        return null;
+    }
+
+    const objectStart = source.indexOf('{', callStart + 1);
+    if (objectStart < 0 || objectStart >= callEnd) {
+        return null;
+    }
+
+    let i = objectStart;
+    let depth = 0;
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplate = false;
+    let interpolationBraceDepth = 0;
+    let nestedTemplateDepth = 0;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+
+    for (; i < source.length; i++) {
+        const ch = source[i];
+        const next = i + 1 < source.length ? source[i + 1] : '';
+
+        if (inLineComment) {
+            if (ch === '\n') inLineComment = false;
+            continue;
+        }
+        if (inBlockComment) {
+            if (ch === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+
+        if (inSingle) {
+            if (!escaped && ch === "'") inSingle = false;
+            escaped = !escaped && ch === '\\';
+            continue;
+        }
+        if (inDouble) {
+            if (!escaped && ch === '"') inDouble = false;
+            escaped = !escaped && ch === '\\';
+            continue;
+        }
+        if (inTemplate) {
+            if (!escaped && ch === '`') {
+                if (nestedTemplateDepth > 0) {
+                    nestedTemplateDepth--;
+                } else if (interpolationBraceDepth > 0) {
+                    nestedTemplateDepth++;
+                } else {
+                    inTemplate = false;
+                    interpolationBraceDepth = 0;
+                    nestedTemplateDepth = 0;
+                }
+                escaped = false;
+                continue;
+            }
+            if (!escaped && ch === '$' && next === '{') {
+                interpolationBraceDepth = 1;
+                i++;
+                escaped = false;
+                continue;
+            }
+            if (!escaped && nestedTemplateDepth === 0) {
+                if (ch === '{') {
+                    interpolationBraceDepth++;
+                    escaped = false;
+                    continue;
+                }
+                if (ch === '}') {
+                    interpolationBraceDepth--;
+                    escaped = false;
+                    continue;
+                }
+            }
+            if (!escaped && ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            escaped = false;
+            continue;
+        }
+
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            escaped = false;
+            continue;
+        }
+        if (ch === '"') {
+            inDouble = true;
+            escaped = false;
+            continue;
+        }
+        if (ch === '`') {
+            inTemplate = true;
+            interpolationBraceDepth = 0;
+            nestedTemplateDepth = 0;
+            escaped = false;
+            continue;
+        }
+
+        if (ch === '{') {
+            depth++;
+            continue;
+        }
+        if (ch === '}') {
+            depth--;
+            if (depth === 0) {
+                return source.slice(objectStart, i + 1);
+            }
+        }
+    }
+
+    return null;
+}
+
+export function prepareEntryOptionsModule(options: {
+    cwd: string;
+    entryFile: string;
+}): PreparedEntryOptions {
+    const entryPath = resolve(options.cwd, options.entryFile);
+    if (!existsSync(entryPath)) {
+        throw new Error(`Entry file not found: ${options.entryFile}`);
+    }
+
+    const source = readFileSync(entryPath, 'utf-8');
+    const objectLiteral = extractBurgerOptionsObjectLiteral(source);
+
+    if (!objectLiteral) {
+        return {};
+    }
+
+    const burgerCtor = source.match(/\bnew\s+Burger\s*\(/);
+    const rawPrelude = source.slice(0, burgerCtor?.index ?? 0).trimEnd();
+    // Remove trailing partial assignment fragments like "const app ="
+    // when the constructor is assigned (e.g. const app = new Burger(...)).
+    const prelude = rawPrelude
+        .replace(
+            /(?:const|let|var)\s+[A-Za-z_$][A-Za-z0-9_$]*\s*(?::\s*.*?)?\s*=\s*$/,
+            ''
+        )
+        .replace(/\s*export\s+default\s*$/, '')
+        .trimEnd();
+    const tempFilePath = resolve(dirname(entryPath), ENTRY_OPTIONS_FILENAME);
+    const tempFileSource = [
+        '// Auto-generated by burger-api build. Do not edit.',
+        prelude,
+        '',
+        `export const burgerOptions = ${objectLiteral};`,
+        '',
+    ].join('\n');
+
+    writeFileSync(tempFilePath, tempFileSource, 'utf-8');
+
+    return {
+        importPath: tempFilePath.split('\\').join('/'),
+        tempFilePath,
+    };
+}
+
+export function cleanupEntryOptionsModule(tempFilePath?: string): void {
+    if (!tempFilePath) {
+        return;
+    }
+    if (existsSync(tempFilePath)) {
+        unlinkSync(tempFilePath);
+    }
+}

package/src/utils/logger.ts

@@ -403,23 +403,24 @@ const LOGO_TEXT = `
  ██╔╝  ██╔══██╗██║   ██║██╔══██╗██║  ╚██╗██╔══╝  ██╔══██╗██╔══██║██╔═══╝ ██║
 ██╔╝   ██████╦╝╚██████╔╝██║  ██║╚██████╔╝███████╗██║  ██║██║  ██║██║     ██║
 ╚═╝    ╚═════╝  ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝╚═╝   ╚═╝╚═╝     ╚═╝
-                                    CLI tool for BurgerAPI projects - v0.7.1                                            
 `.trim();
 
 /**
  * Show ASCII art banner for BurgerAPI CLI
  * Displays when CLI starts
  * Uses ASCII-safe characters for Windows CMD compatibility
+ * @param version - CLI version (e.g. from package.json); defaults to '0.0.0'
  */
-export function showBanner(): void {
+export function showBanner(version: string = '0.0.0'): void {
     const bannerColor = '\x1b[38;2;255;204;153m'; // Warm orange color
 
     const reset = '\x1b[0m';
+    const tagline = `CLI tool for BurgerAPI projects - v${version}`;
 
     // Unicode banner for modern terminals
     console.log(`${bannerColor}
-${LOGO_TEXT}    
-                                                                                                 
+${LOGO_TEXT}
+${tagline}
 ${reset}`);
 }
 

package/src/utils/route-conventions.ts

@@ -0,0 +1,142 @@
+import * as path from 'path';
+
+/**
+ * Shared route conventions for CLI scanning and code generation.
+ * Must match framework routing rules (packages/burger-api pathConversion). Sync check: bun run test:route-sync (from repo root).
+ */
+export const ROUTE_CONSTANTS = {
+    SUPPORTED_PAGE_EXTENSIONS: ['.tsx', '.html'],
+    PAGE_INDEX_FILES: ['index.tsx', 'index.html'],
+    DYNAMIC_SEGMENT_PREFIX: ':',
+    DYNAMIC_FOLDER_START: '[',
+    DYNAMIC_FOLDER_END: ']',
+    GROUPING_FOLDER_START: '(',
+    GROUPING_FOLDER_END: ')',
+    WILDCARD_SEGMENT_PREFIX: '*',
+    WILDCARD_SIMPLE: '[...]',
+    WILDCARD_START: '[...',
+};
+
+/**
+ * Cleans a prefix by removing leading and trailing slashes.
+ * @param prefix The prefix to clean.
+ * @returns The cleaned prefix.
+ */
+function cleanPrefix(prefix: string): string {
+    let p = prefix;
+    while (p.startsWith('/')) p = p.slice(1);
+    while (p.endsWith('/')) p = p.slice(0, -1);
+    return p;
+}
+
+/**
+ * Converts a file path to an API route path.
+ * @param filePath The file path to convert.
+ * @param prefix The prefix to prepend to the route path.
+ * @returns The API route path.
+ */
+export function filePathToApiRoutePath(
+    filePath: string,
+    prefix: string
+): string {
+    if (filePath.endsWith('route.ts')) {
+        filePath = filePath.slice(0, -'route.ts'.length);
+    }
+
+    const segments = filePath.split(path.sep);
+    const resultSegments: string[] = [];
+
+    for (const segment of segments) {
+        if (!segment) continue;
+        if (
+            segment.startsWith(ROUTE_CONSTANTS.GROUPING_FOLDER_START) &&
+            segment.endsWith(ROUTE_CONSTANTS.GROUPING_FOLDER_END)
+        ) {
+            continue;
+        }
+        if (
+            segment.startsWith(ROUTE_CONSTANTS.DYNAMIC_FOLDER_START) &&
+            segment.endsWith(ROUTE_CONSTANTS.DYNAMIC_FOLDER_END) &&
+            !segment.startsWith(ROUTE_CONSTANTS.WILDCARD_START)
+        ) {
+            resultSegments.push(
+                ROUTE_CONSTANTS.DYNAMIC_SEGMENT_PREFIX + segment.slice(1, -1)
+            );
+        } else if (segment === ROUTE_CONSTANTS.WILDCARD_SIMPLE) {
+            resultSegments.push(ROUTE_CONSTANTS.WILDCARD_SEGMENT_PREFIX);
+        } else {
+            resultSegments.push(segment);
+        }
+    }
+
+    let route = '/' + resultSegments.join('/');
+    const clean = cleanPrefix(prefix);
+    if (clean) {
+        route = '/' + clean + route;
+    }
+    if (route !== '/' && route.endsWith('/')) {
+        route = route.slice(0, -1);
+    }
+    return route;
+}
+
+/**
+ * Converts a file path to a page route path.
+ * @param filePath The file path to convert.
+ * @param prefix The prefix to prepend to the route path.
+ * @returns The page route path.
+ */
+export function filePathToPageRoutePath(
+    filePath: string,
+    prefix: string
+): string {
+    const segments = filePath.split(path.sep);
+    const resultSegments: string[] = [];
+
+    for (const segment of segments) {
+        if (!segment) continue;
+        if (
+            segment.startsWith(ROUTE_CONSTANTS.GROUPING_FOLDER_START) &&
+            segment.endsWith(ROUTE_CONSTANTS.GROUPING_FOLDER_END)
+        ) {
+            continue;
+        }
+        if (
+            segment.startsWith(ROUTE_CONSTANTS.DYNAMIC_FOLDER_START) &&
+            segment.endsWith(ROUTE_CONSTANTS.DYNAMIC_FOLDER_END)
+        ) {
+            resultSegments.push(
+                ROUTE_CONSTANTS.DYNAMIC_SEGMENT_PREFIX + segment.slice(1, -1)
+            );
+        } else {
+            resultSegments.push(segment);
+        }
+    }
+
+    let route = '/' + resultSegments.join('/');
+    const clean = cleanPrefix(prefix);
+    if (clean) {
+        route = '/' + clean + route;
+    }
+    if (route !== '/' && route.endsWith('/')) {
+        route = route.slice(0, -1);
+    }
+
+    const pathSegments = route.split('/');
+    const lastSegment = pathSegments.at(-1);
+    if (typeof lastSegment === 'string') {
+        if (ROUTE_CONSTANTS.PAGE_INDEX_FILES.includes(lastSegment)) {
+            pathSegments.pop();
+        } else {
+            const extensionIndex = lastSegment.lastIndexOf('.');
+            if (extensionIndex > 0) {
+                pathSegments[pathSegments.length - 1] = lastSegment.slice(
+                    0,
+                    extensionIndex
+                );
+            }
+        }
+    }
+
+    return pathSegments.join('/') === '' ? '/' : pathSegments.join('/');
+}

package/src/utils/route-methods.ts

@@ -0,0 +1,91 @@
+/**
+ * Build-time detection of which HTTP methods a route module exports.
+ * Used so the virtual entry only emits handler keys for methods that exist.
+ */
+
+import { readFile } from 'fs/promises';
+
+const HTTP_METHOD_NAMES = [
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'HEAD',
+    'OPTIONS',
+] as const;
+
+/** Matches export async function GET( or export function POST( */
+const EXPORT_FUNCTION_RE =
+    /export\s+(?:async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*\(/g;
+
+/** Matches export { ... } and captures the content between braces */
+const EXPORT_NAMED_BLOCK_RE = /export\s*\{([^}]*)\}/g;
+
+/** Matches export const GET = ... or export const POST = async (req) => ... */
+const EXPORT_CONST_RE =
+    /export\s+const\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*=/g;
+
+/** Matches a single HTTP method name (used to find all methods inside a block) */
+const METHOD_NAME_RE = /\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\b/g;
+
+/**
+ * Strip comments so export regexes do not match inside comments.
+ * Removes multi-line comments (/* ... *\/) and lines that are only a single-line comment (// ...).
+ */
+function stripComments(content: string): string {
+    let out = content.replace(/\/\*[\s\S]*?\*\//g, ' ');
+    out = out.replace(/^\s*\/\/[^\n]*$/gm, '\n');
+    return out;
+}
+
+/**
+ * Detect which HTTP methods are exported from a route file.
+ * Reads the file and looks for export function METHOD(, export const METHOD = ..., and export { ... METHOD ... }.
+ *
+ * @param filePath - Absolute path to the route file (e.g. route.ts).
+ * @returns Array of method names found, or undefined if file could not be read or parsed.
+ */
+export async function detectExportedMethods(
+    filePath: string
+): Promise<string[] | undefined> {
+    let content: string;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    } catch {
+        return undefined;
+    }
+
+    const contentWithoutComments = stripComments(content);
+    const found = new Set<string>();
+
+    let match: RegExpExecArray | null;
+    EXPORT_FUNCTION_RE.lastIndex = 0;
+    while ((match = EXPORT_FUNCTION_RE.exec(contentWithoutComments)) !== null) {
+        const name = match[1];
+        if (name) found.add(name);
+    }
+
+    EXPORT_CONST_RE.lastIndex = 0;
+    while ((match = EXPORT_CONST_RE.exec(contentWithoutComments)) !== null) {
+        const name = match[1];
+        if (name) found.add(name);
+    }
+
+    // Scan each export { ... } block and collect all HTTP method names inside it
+    EXPORT_NAMED_BLOCK_RE.lastIndex = 0;
+    while ((match = EXPORT_NAMED_BLOCK_RE.exec(contentWithoutComments)) !== null) {
+        const blockContent = match[1] ?? '';
+        let methodMatch: RegExpExecArray | null;
+        METHOD_NAME_RE.lastIndex = 0;
+        while ((methodMatch = METHOD_NAME_RE.exec(blockContent)) !== null) {
+            const name = methodMatch[1];
+            if (name) found.add(name);
+        }
+    }
+
+    const methods = [...found].filter((m) =>
+        (HTTP_METHOD_NAMES as readonly string[]).includes(m)
+    );
+    return methods.length > 0 ? methods : undefined;
+}