@actuallyjamez/elysian 0.7.0 → 0.7.1

package/dist/cli/commands/build.js

@@ -9,7 +9,7 @@ import { bundleLambda } from "../../core/bundler";
 import { packageLambda } from "../../core/packager";
 import { generateManifest, writeManifest } from "../../core/manifest";
 import { writeTerraformVars } from "../../core/terraform";
-import { shouldGenerateOpenApi, writeOpenApiLambda, cleanupOpenApiLambda, } from "../../core/openapi";
+import { shouldGenerateOpenApi, writeOpenApiLambda, } from "../../core/openapi";
 import { createWrapperEntry } from "../../core/handler-wrapper";
 import { getLambdaBundleName } from "../../core/naming";
 import { ui, pc, formatDuration, formatSize } from "../ui";
@@ -53,6 +53,9 @@ export const buildCommand = defineCommand({
         }
         mkdirSync(outputDir, { recursive: true });
         mkdirSync(terraformDir, { recursive: true });
+        // 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) {
@@ -61,18 +64,19 @@ export const buildCommand = defineCommand({
         }
         // Generate OpenAPI aggregator if enabled
         if (shouldGenerateOpenApi(config)) {
-            await writeOpenApiLambda(lambdaFiles, lambdasDir, config);
+            await writeOpenApiLambda(lambdaFiles, lambdasDir, config, tempDir);
             lambdaFiles.push("__openapi__.ts");
         }
         // Build phase
         ui.success(`Compiling ${lambdaFiles.length} lambdas...`);
-        const tempDir = join(outputDir, "__temp__");
-        mkdirSync(tempDir, { recursive: true });
         const buildResults = [];
         for (const file of lambdaFiles) {
             const lambdaName = file.replace(/\.ts$/, "");
             const bundleName = getLambdaBundleName(name, lambdaName);
-            const inputPath = join(lambdasDir, file);
+            // 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);
@@ -87,10 +91,7 @@ export const buildCommand = defineCommand({
         }
         // Clean up temp directory
         rmSync(tempDir, { recursive: true, force: true });
-        // Clean up generated OpenAPI file
-        if (shouldGenerateOpenApi(config)) {
-            await cleanupOpenApiLambda(lambdasDir);
-        }
+        // No need to clean up OpenAPI file separately - it's in tempDir
         // Package phase
         ui.success("Packaging lambdas...");
         const packageSizes = new Map();

package/dist/cli/commands/dev.js

@@ -11,7 +11,7 @@ import { createWrapperEntry } from "../../core/handler-wrapper";
 import { getLambdaBundleName } from "../../core/naming";
 import { generateManifest, writeManifest } from "../../core/manifest";
 import { writeTerraformVars } from "../../core/terraform";
-import { shouldGenerateOpenApi, writeOpenApiLambda, cleanupOpenApiLambda, } from "../../core/openapi";
+import { shouldGenerateOpenApi, writeOpenApiLambda, } from "../../core/openapi";
 import { detectLocalStack, isTerraformInitialized, runTfLocalInit, runTfLocalApply, getTerraformOutputs, } from "../../core/localstack";
 import { ui, pc, createSpinner, formatDuration } from "../ui";
 export const devCommand = defineCommand({
@@ -100,7 +100,10 @@ export const devCommand = defineCommand({
         async function buildSingleLambda(filename) {
             const lambdaName = filename.replace(/\.ts$/, "");
             const bundleName = getLambdaBundleName(name, lambdaName);
-            const inputPath = join(lambdasDir, filename);
+            // For OpenAPI, the source is in tempDir; for regular lambdas, it's in lambdasDir
+            const inputPath = filename === "__openapi__.ts"
+                ? join(tempDir, filename)
+                : join(lambdasDir, filename);
             // Create wrapper entry
             const wrapperPath = join(tempDir, `${lambdaName}-wrapper.ts`);
             const wrapperContent = createWrapperEntry(inputPath);
@@ -108,17 +111,17 @@ export const devCommand = defineCommand({
             // Bundle with prefixed name
             const buildResult = await bundleLambda(bundleName, wrapperPath, outputDir, config);
             if (!buildResult.success) {
-                return false;
+                return { success: false, error: buildResult.error };
             }
             // Package if not disabled
             if (!args["no-package"]) {
                 const jsPath = join(outputDir, `${bundleName}.js`);
                 const packageResult = await packageLambda(bundleName, jsPath, outputDir);
                 if (!packageResult.success) {
-                    return false;
+                    return { success: false, error: packageResult.error };
                 }
             }
-            return true;
+            return { success: true };
         }
         // Build all lambdas (including OpenAPI if enabled)
         async function buildAll() {
@@ -127,20 +130,17 @@ export const devCommand = defineCommand({
             const filesToBuild = [...lambdaFiles];
             // Generate OpenAPI aggregator if enabled
             if (shouldGenerateOpenApi(config)) {
-                await writeOpenApiLambda(lambdaFiles, lambdasDir, config);
+                await writeOpenApiLambda(lambdaFiles, lambdasDir, config, tempDir);
                 filesToBuild.push("__openapi__.ts");
             }
             // Build all lambdas
             for (const file of filesToBuild) {
-                const success = await buildSingleLambda(file);
-                if (!success) {
-                    return { success: false, count: 0, error: `Failed to build ${file}` };
+                const result = await buildSingleLambda(file);
+                if (!result.success) {
+                    return { success: false, count: 0, error: `${file}: ${result.error || "Unknown error"}` };
                 }
             }
-            // Cleanup OpenAPI source file
-            if (shouldGenerateOpenApi(config)) {
-                await cleanupOpenApiLambda(lambdasDir);
-            }
+            // No need to cleanup OpenAPI - it's in tempDir which persists during dev
             return { success: true, count: filesToBuild.length };
         }
         // Generate manifest and terraform vars

package/dist/cli/commands/init/scaffold.js

@@ -147,7 +147,7 @@ async function scaffoldTerraform(cwd, info, name, result) {
  */
 export async function installDependencies(cwd, packageManager) {
     const deps = ["elysia", "@actuallyjamez/elysian"];
-    const devDeps = ["@types/bun", "typescript"];
+    const devDeps = ["@types/node", "typescript"];
     const addCmd = packageManager === "npm" ? "install" : "add";
     const devFlag = packageManager === "npm" ? "--save-dev" : "-D";
     ui.info("Installing dependencies...");

package/dist/cli/commands/init/templates.js

@@ -91,7 +91,7 @@ export function tsconfigTemplate() {
             esModuleInterop: true,
             skipLibCheck: true,
             noEmit: true,
-            types: ["bun-types"],
+            types: ["@types/node"],
         },
         include: ["src/**/*", "elysian.config.ts"],
         exclude: ["node_modules", "dist"],

package/dist/core/bundler.js

@@ -21,15 +21,37 @@ export async function bundleLambda(name, inputPath, outputDir, config) {
             plugins: [createHandlerWrapperPlugin()],
         });
         if (!result.success) {
-            const errors = result.logs
+            // Extract detailed error messages from build logs
+            const errorMessages = result.logs
                 .filter((log) => log.level === "error")
-                .map((log) => log.message)
-                .join("\n");
+                .map((log) => {
+                // Include file position if available
+                const position = log.position;
+                if (position) {
+                    return `${position.file}:${position.line}:${position.column}: ${log.message}`;
+                }
+                return log.message;
+            });
+            // Also include warnings that might be relevant
+            const warningMessages = result.logs
+                .filter((log) => log.level === "warning")
+                .map((log) => log.message);
+            const allMessages = [...errorMessages, ...warningMessages];
+            // If no messages captured, try to get string representation of all logs
+            if (allMessages.length === 0 && result.logs.length > 0) {
+                const allLogs = result.logs.map((log) => `[${log.level}] ${log.message}`);
+                return {
+                    name,
+                    outputPath: join(outputDir, `${name}.js`),
+                    success: false,
+                    error: allLogs.join("\n") || "Build failed with no error message",
+                };
+            }
             return {
                 name,
                 outputPath: join(outputDir, `${name}.js`),
                 success: false,
-                error: errors || "Unknown build error",
+                error: allMessages.length > 0 ? allMessages.join("\n") : "Build failed with no error message",
             };
         }
         return {
@@ -39,11 +61,36 @@ export async function bundleLambda(name, inputPath, outputDir, config) {
         };
     }
     catch (error) {
+        // Handle AggregateError from Bun bundler (contains detailed parse errors)
+        if (error instanceof AggregateError && error.errors?.length > 0) {
+            const errorMessages = error.errors.map((e) => {
+                // Use Bun.inspect for nicely formatted error output
+                if (typeof Bun !== "undefined" && Bun.inspect) {
+                    return Bun.inspect(e);
+                }
+                // Fallback: try to extract message and position
+                const err = e;
+                if (err.position) {
+                    return `${err.position.file}:${err.position.line}:${err.position.column}: ${err.message}`;
+                }
+                return String(e);
+            });
+            return {
+                name,
+                outputPath: join(outputDir, `${name}.js`),
+                success: false,
+                error: errorMessages.join("\n\n"),
+            };
+        }
+        // Capture full error details including stack trace
+        const errorMessage = error instanceof Error
+            ? `${error.message}${error.stack ? `\n${error.stack}` : ""}`
+            : String(error);
         return {
             name,
             outputPath: join(outputDir, `${name}.js`),
             success: false,
-            error: error instanceof Error ? error.message : String(error),
+            error: errorMessage,
         };
     }
 }

package/dist/core/handler-wrapper.js

@@ -124,14 +124,32 @@ export const handler = __createElysiaHandler(__route);
 `;
     return modifiedCode + handlerWrapper;
 }
+/**
+ * Get the path to a module from elysian's node_modules
+ */
+function resolveFromElysian(modulePath) {
+    // Use import.meta.resolve to get the absolute path
+    // This resolves relative to where this code is located (elysian package)
+    try {
+        const resolved = import.meta.resolve(modulePath);
+        // Convert file:// URL to path
+        return resolved.replace("file://", "");
+    }
+    catch {
+        // Fallback to relative import if resolution fails
+        return modulePath;
+    }
+}
 /**
  * Create a wrapper entry file that imports and re-exports with handler
  */
 export function createWrapperEntry(originalPath) {
+    const honoTinyPath = resolveFromElysian("hono/tiny");
+    const honoLambdaPath = resolveFromElysian("hono/aws-lambda");
     return `
 import route from "${originalPath}";
-import { Hono } from "hono/tiny";
-import { handle } from "hono/aws-lambda";
+import { Hono } from "${honoTinyPath}";
+import { handle } from "${honoLambdaPath}";
 
 // Re-export the route as default for introspection
 export default route;

package/dist/core/openapi.d.ts

@@ -8,11 +8,11 @@ import type { ResolvedConfig } from "./config";
 /**
  * Generate the OpenAPI aggregator lambda source code
  */
-export declare function generateOpenApiLambdaSource(lambdaFiles: string[], config: ResolvedConfig): string;
+export declare function generateOpenApiLambdaSource(lambdaFiles: string[], lambdasDir: string, config: ResolvedConfig): string;
 /**
  * Write the OpenAPI aggregator lambda to a temp location for bundling
  */
-export declare function writeOpenApiLambda(lambdaFiles: string[], lambdasDir: string, config: ResolvedConfig): Promise<string>;
+export declare function writeOpenApiLambda(lambdaFiles: string[], lambdasDir: string, config: ResolvedConfig, tempDir: string): Promise<string>;
 /**
  * Check if OpenAPI aggregator needs to be generated
  */
@@ -20,4 +20,4 @@ export declare function shouldGenerateOpenApi(config: ResolvedConfig): boolean;
 /**
  * Clean up the generated OpenAPI lambda file
  */
-export declare function cleanupOpenApiLambda(lambdasDir: string): Promise<void>;
+export declare function cleanupOpenApiLambda(tempDir: string): Promise<void>;

package/dist/core/openapi.js

@@ -5,28 +5,46 @@
  * from all other lambdas to provide a complete API specification.
  */
 import { join } from "path";
+/**
+ * Resolve a module path from elysian's node_modules
+ */
+function resolveFromElysian(modulePath) {
+    try {
+        const resolved = import.meta.resolve(modulePath);
+        return resolved.replace("file://", "");
+    }
+    catch {
+        return modulePath;
+    }
+}
 /**
  * Generate the OpenAPI aggregator lambda source code
  */
-export function generateOpenApiLambdaSource(lambdaFiles, config) {
+export function generateOpenApiLambdaSource(lambdaFiles, lambdasDir, config) {
     // Filter out any existing openapi file to avoid circular imports
     const routeFiles = lambdaFiles.filter((f) => !f.includes("openapi") && !f.startsWith("__"));
     const imports = routeFiles
         .map((file, index) => {
         const name = file.replace(/\.ts$/, "");
-        return `import route${index} from "./${name}";`;
+        // Use absolute path to the lambda file
+        const absolutePath = join(lambdasDir, name);
+        return `import route${index} from "${absolutePath}";`;
     })
         .join("\n");
     const uses = routeFiles.map((_, index) => `.use(route${index})`).join("\n\t\t");
+    // Resolve paths from elysian's dependencies
+    const honoTinyPath = resolveFromElysian("hono/tiny");
+    const honoLambdaPath = resolveFromElysian("hono/aws-lambda");
+    const openapiPath = resolveFromElysian("@elysiajs/openapi");
     return `/**
  * Auto-generated OpenAPI aggregator lambda
  * Generated by elysia-apigw - DO NOT EDIT
  */
 
 import Elysia from "elysia";
-import { openapi } from "@elysiajs/openapi";
-import { Hono } from "hono/tiny";
-import { handle } from "hono/aws-lambda";
+import { openapi } from "${openapiPath}";
+import { Hono } from "${honoTinyPath}";
+import { handle } from "${honoLambdaPath}";
 
 ${imports}
 
@@ -54,9 +72,9 @@ export const handler = handle(api);
 /**
  * Write the OpenAPI aggregator lambda to a temp location for bundling
  */
-export async function writeOpenApiLambda(lambdaFiles, lambdasDir, config) {
-    const source = generateOpenApiLambdaSource(lambdaFiles, config);
-    const outputPath = join(lambdasDir, "__openapi__.ts");
+export async function writeOpenApiLambda(lambdaFiles, lambdasDir, config, tempDir) {
+    const source = generateOpenApiLambdaSource(lambdaFiles, lambdasDir, config);
+    const outputPath = join(tempDir, "__openapi__.ts");
     await Bun.write(outputPath, source);
     return outputPath;
 }
@@ -69,8 +87,8 @@ export function shouldGenerateOpenApi(config) {
 /**
  * Clean up the generated OpenAPI lambda file
  */
-export async function cleanupOpenApiLambda(lambdasDir) {
-    const openApiPath = join(lambdasDir, "__openapi__.ts");
+export async function cleanupOpenApiLambda(tempDir) {
+    const openApiPath = join(tempDir, "__openapi__.ts");
     try {
         const file = Bun.file(openApiPath);
         if (await file.exists()) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@actuallyjamez/elysian",
-	"version": "0.7.0",
+	"version": "0.7.1",
 	"description": "Automatic Lambda bundler for Elysia with API Gateway and Terraform integration",
 	"type": "module",
 	"main": "./dist/index.js",