@actuallyjamez/elysian 0.11.0 → 0.12.0

package/dist/cli/commands/build.js

@@ -2,17 +2,18 @@
  * Build command - Production build of all lambdas
  */
 import { defineCommand } from "citty";
-import { readdirSync, mkdirSync, existsSync, rmSync } from "fs";
+import { mkdirSync, rmSync } from "fs";
 import { join } from "path";
 import { loadConfig } from "../../core/config";
-import { bundleLambda } from "../../core/bundler";
+import { bundleApiRoute, bundleGenericLambda, } from "../../core/bundler";
 import { packageLambda } from "../../core/packager";
 import { generateManifest, writeManifest } from "../../core/manifest";
 import { writeTerraformVars } from "../../core/terraform";
 import { shouldGenerateOpenApi, writeOpenApiLambda, } from "../../core/openapi";
-import { createWrapperEntry } from "../../core/handler-wrapper";
+import { createWrapperEntry, createGenericLambdaWrapper } from "../../core/handler-wrapper";
 import { getLambdaBundleName } from "../../core/naming";
-import { ui, pc, formatDuration, formatSize } from "../ui";
+import { discoverLambdas, validateExport, } from "../../core/discovery";
+import { logger, printHeader, printSection, printDivider, printBlank, printLambda, printRoute, formatDuration, formatSize, } from "../logger";
 export const buildCommand = defineCommand({
     meta: {
         name: "build",
@@ -32,127 +33,211 @@ export const buildCommand = defineCommand({
             process.env.NODE_ENV = "production";
         }
         // Header
-        ui.header(args.prod ? pc.yellow("production") : "development");
+        printHeader(args.prod ? "\x1b[33mproduction\x1b[0m" : "development");
         // Load config
         let config;
         try {
             config = await loadConfig();
         }
         catch (error) {
-            ui.error(error instanceof Error ? error.message : String(error));
+            logger.error(error instanceof Error ? error.message : String(error));
             process.exit(1);
         }
+        const cwd = process.cwd();
         const name = config.name;
-        const lambdasDir = join(process.cwd(), config.lambdasDir);
-        const outputDir = join(process.cwd(), config.outputDir);
-        const terraformDir = join(process.cwd(), config.terraform.outputDir);
-        // Ensure directories exist
-        if (!existsSync(lambdasDir)) {
-            ui.error(`Lambdas directory not found: ${lambdasDir}`);
-            process.exit(1);
-        }
+        const outputDir = join(cwd, config.outputDir);
+        const terraformDir = join(cwd, config.terraform.outputDir);
+        // Ensure output directories exist
         mkdirSync(outputDir, { recursive: true });
         mkdirSync(terraformDir, { recursive: true });
+        // Discover lambdas in both directories
+        const discovered = await discoverLambdas(cwd, config, (filename, reason) => {
+            logger.warn(`Skipping ${filename}: ${reason}`);
+        });
+        // Check if we have anything to build
+        if (discovered.apiRoutes.length === 0 && discovered.functions.length === 0) {
+            logger.warn(`No lambda files found in ${config.api.dir} or ${config.functions.dir}`);
+            return;
+        }
         // Create temp directory for generated files
         const tempDir = join(outputDir, "__temp__");
         mkdirSync(tempDir, { recursive: true });
-        // Get lambda files
-        let lambdaFiles = readdirSync(lambdasDir).filter((f) => f.endsWith(".ts") && !f.startsWith("__"));
-        if (lambdaFiles.length === 0) {
-            ui.warn(`No lambda files found in ${config.lambdasDir}`);
-            return;
-        }
-        // Generate OpenAPI aggregator if enabled
-        if (shouldGenerateOpenApi(config)) {
-            await writeOpenApiLambda(lambdaFiles, lambdasDir, config, tempDir);
-            lambdaFiles.push("openapi.ts");
+        // Track all build results
+        const allBuildResults = [];
+        const packageSizes = new Map();
+        // =====================
+        // Build API Routes
+        // =====================
+        if (discovered.apiRoutes.length > 0) {
+            printSection("API Routes");
+            logger.success(`Compiling ${discovered.apiRoutes.length} API routes from ${config.api.dir}...`);
+            // Generate OpenAPI aggregator if enabled
+            let apiRoutesWithOpenApi = [...discovered.apiRoutes];
+            if (shouldGenerateOpenApi(config)) {
+                const openApiPath = await writeOpenApiLambda(discovered.apiRoutes, config, tempDir);
+                const openApiRoute = {
+                    name: "openapi",
+                    sourcePath: openApiPath,
+                    bundleName: getLambdaBundleName(name, "openapi"),
+                };
+                apiRoutesWithOpenApi.push(openApiRoute);
+            }
+            for (const route of apiRoutesWithOpenApi) {
+                // Create wrapper entry that imports the original and exports handler
+                const wrapperPath = join(tempDir, `${route.name}-wrapper.ts`);
+                const wrapperContent = createWrapperEntry(route.sourcePath);
+                await Bun.write(wrapperPath, wrapperContent);
+                // Bundle the wrapper
+                const result = await bundleApiRoute({ ...route, sourcePath: wrapperPath }, outputDir, config);
+                allBuildResults.push(result);
+                if (!result.success) {
+                    logger.error(`Failed to build ${route.name}: ${result.error}`);
+                    process.exit(1);
+                }
+            }
+            // Validate exports (skip openapi which is auto-generated)
+            for (const route of discovered.apiRoutes) {
+                const bundlePath = join(outputDir, `${route.bundleName}.js`);
+                const validationError = await validateExport(bundlePath, "routes", route.sourcePath);
+                if (validationError) {
+                    logger.error(validationError.message);
+                    process.exit(1);
+                }
+            }
         }
-        // Build phase
-        ui.success(`Compiling ${lambdaFiles.length} lambdas...`);
-        const buildResults = [];
-        for (const file of lambdaFiles) {
-            const lambdaName = file.replace(/\.ts$/, "");
-            const bundleName = getLambdaBundleName(name, lambdaName);
-            // For OpenAPI, the source is in tempDir; for regular lambdas, it's in lambdasDir
-            const inputPath = file === "openapi.ts"
-                ? join(tempDir, file)
-                : join(lambdasDir, file);
-            // Create wrapper entry that imports the original and exports handler
-            const wrapperPath = join(tempDir, `${lambdaName}-wrapper.ts`);
-            const wrapperContent = createWrapperEntry(inputPath);
-            await Bun.write(wrapperPath, wrapperContent);
-            // Bundle the wrapper with prefixed name
-            const result = await bundleLambda(bundleName, wrapperPath, outputDir, config);
-            buildResults.push({ ...result, name: lambdaName, bundleName });
-            if (!result.success) {
-                ui.error(`Failed to build ${lambdaName}: ${result.error}`);
-                process.exit(1);
+        // =====================
+        // Build Generic Functions
+        // =====================
+        if (discovered.functions.length > 0) {
+            printSection("Generic Functions");
+            logger.success(`Compiling ${discovered.functions.length} generic functions from ${config.functions.dir}...`);
+            for (const fn of discovered.functions) {
+                // Create wrapper that extracts handler from defineLambda export
+                const wrapperPath = join(tempDir, `${fn.name}-lambda-wrapper.ts`);
+                const wrapperContent = createGenericLambdaWrapper(fn.sourcePath);
+                await Bun.write(wrapperPath, wrapperContent);
+                // Bundle the wrapper
+                const result = await bundleGenericLambda({ ...fn, sourcePath: wrapperPath }, outputDir, config);
+                allBuildResults.push(result);
+                if (!result.success) {
+                    logger.error(`Failed to build ${fn.name}: ${result.error}`);
+                    process.exit(1);
+                }
+            }
+            // Validate exports
+            for (const fn of discovered.functions) {
+                const bundlePath = join(outputDir, `${fn.bundleName}.js`);
+                const validationError = await validateExport(bundlePath, "lambda", fn.sourcePath);
+                if (validationError) {
+                    logger.error(validationError.message);
+                    process.exit(1);
+                }
             }
         }
         // Clean up temp directory
         rmSync(tempDir, { recursive: true, force: true });
-        // No need to clean up OpenAPI file separately - it's in tempDir
-        // Package phase
-        ui.success("Packaging lambdas...");
-        const packageSizes = new Map();
-        for (const file of lambdaFiles) {
-            const lambdaName = file.replace(/\.ts$/, "");
-            const bundleName = getLambdaBundleName(name, lambdaName);
-            const jsPath = join(outputDir, `${bundleName}.js`);
-            const result = await packageLambda(bundleName, jsPath, outputDir);
-            if (!result.success) {
-                ui.error(`Failed to package ${lambdaName}: ${result.error}`);
+        // =====================
+        // Package Phase
+        // =====================
+        printSection("Packaging");
+        logger.success("Packaging lambdas...");
+        for (const result of allBuildResults) {
+            if (!result.success)
+                continue;
+            const jsPath = join(outputDir, `${result.bundleName}.js`);
+            const packageResult = await packageLambda(result.bundleName, jsPath, outputDir);
+            if (!packageResult.success) {
+                logger.error(`Failed to package ${result.name}: ${packageResult.error}`);
                 process.exit(1);
             }
-            // Get zip size (store by original name for display)
-            const zipPath = join(outputDir, `${bundleName}.zip`);
+            // Get zip size
+            const zipPath = join(outputDir, `${result.bundleName}.zip`);
             const stat = await Bun.file(zipPath).stat();
             if (stat) {
-                packageSizes.set(lambdaName, stat.size);
+                packageSizes.set(result.name, stat.size);
             }
         }
-        // Generate manifest
-        ui.success("Generating manifest...");
+        // =====================
+        // Generate Manifest
+        // =====================
+        printSection("Manifest");
+        logger.success("Generating manifest...");
         try {
-            const manifest = await generateManifest(lambdaFiles, outputDir, config.openapi.enabled, name);
+            const manifest = await generateManifest(discovered.apiRoutes, discovered.functions, outputDir, config.api.openapi.enabled, name);
             // Write JSON manifest
             const manifestPath = join(outputDir, "manifest.json");
             await writeManifest(manifest, manifestPath);
-            // Write Terraform variables
+            // Write Terraform variables (both files)
             await writeTerraformVars(manifest, config);
             // Duration
             const duration = Date.now() - startTime;
-            // Route table
-            ui.section("Routes");
-            // Group routes by lambda (use original name for display)
-            const routesByLambda = new Map();
-            for (const route of manifest.routes) {
-                // Extract display name (original name) from bundle name
-                const displayName = route.lambda.startsWith(`${name}-`)
-                    ? route.lambda.slice(name.length + 1)
-                    : route.lambda;
-                const existing = routesByLambda.get(displayName) || [];
-                existing.push(route);
-                routesByLambda.set(displayName, existing);
+            // =====================
+            // Output Summary
+            // =====================
+            // API Routes table
+            if (manifest.routes.length > 0) {
+                printSection("API Routes");
+                // Group routes by lambda
+                const routesByLambda = new Map();
+                for (const route of manifest.routes) {
+                    const displayName = route.lambda.startsWith(`${name}-`)
+                        ? route.lambda.slice(name.length + 1)
+                        : route.lambda;
+                    const existing = routesByLambda.get(displayName) || [];
+                    existing.push(route);
+                    routesByLambda.set(displayName, existing);
+                }
+                const maxPathLen = Math.max(...manifest.routes.map((r) => r.path.length));
+                for (const [displayName, routes] of routesByLambda) {
+                    const size = packageSizes.get(displayName);
+                    const sizeStr = size ? formatSize(size) : undefined;
+                    printLambda(displayName, sizeStr);
+                    for (const route of routes) {
+                        printRoute(route.method, route.path, route.pathParameters, maxPathLen);
+                    }
+                    printBlank();
+                }
             }
-            // Find longest path for alignment
-            const maxPathLen = Math.max(...manifest.routes.map((r) => r.path.length));
-            for (const [displayName, routes] of routesByLambda) {
-                const size = packageSizes.get(displayName);
-                const sizeStr = size ? formatSize(size) : undefined;
-                ui.labeled(displayName, sizeStr);
-                for (const route of routes) {
-                    ui.route(route.method, route.path, route.pathParameters, maxPathLen);
+            // Generic Lambdas table
+            if (manifest.genericLambdas.length > 0) {
+                printSection("Functions");
+                for (const lambda of manifest.genericLambdas) {
+                    const size = packageSizes.get(lambda.name);
+                    const sizeStr = size ? formatSize(size) : undefined;
+                    let triggerStr;
+                    if (lambda.trigger?.type) {
+                        const triggerType = lambda.trigger.type;
+                        // Show schedule duration if available
+                        if (triggerType === "schedule" && lambda.trigger.config && "every" in lambda.trigger.config) {
+                            triggerStr = `\x1b[90m[${triggerType}: ${lambda.trigger.config.every}]\x1b[0m`;
+                        }
+                        else {
+                            triggerStr = `\x1b[90m[${triggerType}]\x1b[0m`;
+                        }
+                    }
+                    else {
+                        triggerStr = "\x1b[90m[manual]\x1b[0m";
+                    }
+                    printLambda(`${lambda.name} ${triggerStr}`, sizeStr);
                 }
-                ui.blank();
+                printBlank();
             }
             // Summary footer
-            ui.divider();
-            ui.success(`Compiled ${pc.bold(String(manifest.lambdas.length))} lambdas (${manifest.routes.length} routes) in ${pc.bold(formatDuration(duration))}`);
-            ui.blank();
+            printDivider();
+            const totalLambdas = manifest.lambdas.length + manifest.genericLambdas.length;
+            const routeCount = manifest.routes.length;
+            const parts = [];
+            if (manifest.lambdas.length > 0) {
+                parts.push(`${manifest.lambdas.length} API routes`);
+            }
+            if (manifest.genericLambdas.length > 0) {
+                parts.push(`${manifest.genericLambdas.length} functions`);
+            }
+            logger.success(`Compiled \x1b[1m${totalLambdas}\x1b[0m lambdas (${parts.join(", ")}) in \x1b[1m${formatDuration(duration)}\x1b[0m`);
+            printBlank();
         }
         catch (error) {
-            ui.error(error instanceof Error ? error.message : String(error));
+            logger.error(error instanceof Error ? error.message : String(error));
             process.exit(1);
         }
     },

package/dist/cli/commands/dev.d.ts

@@ -1,5 +1,7 @@
 /**
  * Dev command - Live mode using AppSync Events bridge
+ *
+ * Supports both API routes (src/api/) and generic functions (src/functions/).
  */
 export declare const devCommand: import("citty").CommandDef<{
     "no-localstack": {