@actuallyjamez/elysian 0.2.1

package/dist/core/handler-wrapper.js

@@ -0,0 +1,143 @@
+/**
+ * Bun plugin to inject Lambda handler wrapper for default exports
+ *
+ * This transforms:
+ *   export default createLambda().get("/hello", ...)
+ *
+ * Into:
+ *   const __elysia_route__ = createLambda().get("/hello", ...)
+ *   export default __elysia_route__;
+ *   export const handler = __createHandler(__elysia_route__);
+ */
+/**
+ * Create a Bun plugin that wraps default Elysia exports with a Lambda handler
+ */
+export function createHandlerWrapperPlugin() {
+    return {
+        name: "elysia-apigw-handler-wrapper",
+        setup(build) {
+            // We'll handle this at the output level instead
+            // by appending handler export after bundling
+        },
+    };
+}
+/**
+ * Transform source code to add handler export
+ * This is called after the initial bundle to add the handler wrapper
+ */
+export function wrapWithHandler(code) {
+    // Check if there's already a handler export
+    if (/export\s+(const|let|var|function)\s+handler\b/.test(code)) {
+        return code;
+    }
+    // Check for default export
+    const hasDefaultExport = /export\s+default\s+/.test(code);
+    if (!hasDefaultExport) {
+        return code;
+    }
+    // Add the handler wrapper import and export at the end
+    const handlerCode = `
+// Auto-injected by elysia-apigw
+import { Hono } from "hono/tiny";
+import { handle } from "hono/aws-lambda";
+
+const __defaultExport = await (async () => {
+  const mod = await import.meta.require?.("./index.mjs") ?? { default: null };
+  return mod.default;
+})();
+
+function __createHandler(route) {
+  const api = new Hono().mount("/", route.fetch);
+  return handle(api);
+}
+
+export const handler = __createHandler(__defaultExport);
+`;
+    return code + handlerCode;
+}
+/**
+ * Alternative approach: Transform the bundle output directly
+ * This rewrites the code to capture the default export and wrap it
+ */
+export function transformBundleForLambda(code, lambdaName) {
+    // If handler already exists, return as-is
+    if (/export\s+(const|let|var|function)\s+handler\b/.test(code)) {
+        return code;
+    }
+    // Find and capture default export, wrap with handler
+    // We use a simple regex-based approach for common patterns
+    // Pattern 1: export default <identifier>;
+    // Pattern 2: export default createLambda()...;
+    // Pattern 3: export { something as default };
+    // The safest approach is to append a wrapper that re-imports the module
+    // But for a single-file bundle, we need a different strategy
+    // For bundled output, we'll use a post-processing approach:
+    // 1. Replace "export default X" with "const __defaultRoute__ = X; export default __defaultRoute__"
+    // 2. Append handler creation
+    // Match various default export patterns
+    const patterns = [
+        // export default identifier;
+        /export\s+default\s+(\w+)\s*;/,
+        // export default expression (function call, object, etc)
+        /export\s+default\s+/,
+    ];
+    let hasDefault = false;
+    let modifiedCode = code;
+    // Check if code has default export
+    if (/export\s+default\s+/.test(code)) {
+        hasDefault = true;
+    }
+    if (!hasDefault) {
+        // No default export, check for named route exports and use the first one
+        const namedExportMatch = code.match(/export\s+(?:const|let|var)\s+(\w+(?:Route|Lambda|App))\s*=/);
+        if (namedExportMatch) {
+            // Add default export for the route
+            modifiedCode += `\nexport default ${namedExportMatch[1]};\n`;
+            hasDefault = true;
+        }
+    }
+    if (!hasDefault) {
+        console.warn(`Warning: No default export or route found in ${lambdaName}. Handler not injected.`);
+        return code;
+    }
+    // Append the handler wrapper
+    const handlerWrapper = `
+// ============================================
+// Auto-injected Lambda handler by elysia-apigw
+// ============================================
+import { Hono as __Hono } from "hono/tiny";
+import { handle as __handle } from "hono/aws-lambda";
+
+// Re-export with handler wrapper
+// The default export should be an Elysia instance
+const __route = (await import("./index.mjs")).default;
+
+function __createElysiaHandler(route) {
+  if (!route || typeof route.fetch !== "function") {
+    throw new Error("Default export must be an Elysia instance with .fetch method");
+  }
+  const api = new __Hono().mount("/", route.fetch);
+  return __handle(api);
+}
+
+export const handler = __createElysiaHandler(__route);
+`;
+    return modifiedCode + handlerWrapper;
+}
+/**
+ * Create a wrapper entry file that imports and re-exports with handler
+ */
+export function createWrapperEntry(originalPath) {
+    return `
+import route from "${originalPath}";
+import { Hono } from "hono/tiny";
+import { handle } from "hono/aws-lambda";
+
+// Re-export the route as default for introspection
+export default route;
+
+// Create and export the Lambda handler
+const api = new Hono().mount("/", route.fetch);
+export const handler = handle(api);
+`;
+}

package/dist/core/manifest.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Route manifest generation through introspection of built lambdas
+ */
+export interface RouteInfo {
+    method: string;
+    path: string;
+    pathParameters: string[];
+}
+export interface LambdaManifest {
+    name: string;
+    routes: RouteInfo[];
+}
+export interface ApiRoute {
+    method: string;
+    path: string;
+    lambda: string;
+    pathParameters: string[];
+    apiGatewayPath: string;
+}
+export interface ApiManifest {
+    lambdas: LambdaManifest[];
+    routes: ApiRoute[];
+}
+/**
+ * Convert Elysia path params (:id) to API Gateway format ({id})
+ */
+export declare function convertToApiGatewayPath(path: string): string;
+/**
+ * Extract path parameters from a route path
+ */
+export declare function extractPathParameters(path: string): string[];
+/**
+ * Generate a valid Terraform resource name from route info
+ */
+export declare function generateRouteName(lambda: string, method: string, path: string): string;
+/**
+ * Generate manifest by introspecting built lambda modules
+ */
+export declare function generateManifest(lambdaFiles: string[], outputDir: string, openapiEnabled?: boolean, apiName?: string): Promise<ApiManifest>;
+/**
+ * Write manifest to JSON file
+ */
+export declare function writeManifest(manifest: ApiManifest, outputPath: string): Promise<void>;

package/dist/core/manifest.js

@@ -0,0 +1,127 @@
+/**
+ * Route manifest generation through introspection of built lambdas
+ */
+import { join, isAbsolute } from "path";
+import { getLambdaBundleName } from "./naming";
+/**
+ * Convert Elysia path params (:id) to API Gateway format ({id})
+ */
+export function convertToApiGatewayPath(path) {
+    return path.replace(/:([^/]+)/g, "{$1}");
+}
+/**
+ * Extract path parameters from a route path
+ */
+export function extractPathParameters(path) {
+    const matches = path.match(/:([^/]+)/g);
+    return matches ? matches.map((m) => m.slice(1)) : [];
+}
+/**
+ * Generate a valid Terraform resource name from route info
+ */
+export function generateRouteName(lambda, method, path) {
+    const sanitizedPath = path
+        .replace(/^\//, "")
+        .replace(/\//g, "_")
+        .replace(/:/g, "")
+        .replace(/[{}]/g, "")
+        .replace(/_$/, "");
+    return `${lambda}_${method.toLowerCase()}_${sanitizedPath || "root"}`;
+}
+/**
+ * Generate manifest by introspecting built lambda modules
+ */
+export async function generateManifest(lambdaFiles, outputDir, openapiEnabled = true, apiName = "") {
+    const manifest = {
+        lambdas: [],
+        routes: [],
+    };
+    // Track routes with their source lambda for conflict detection
+    const routeOwners = new Map();
+    const conflicts = [];
+    const sortedFiles = [...lambdaFiles].sort();
+    for (const file of sortedFiles) {
+        const originalName = file.replace(/\.ts$/, "");
+        // Use prefixed bundle name for file lookup
+        const bundleName = apiName ? getLambdaBundleName(apiName, originalName) : originalName;
+        const modulePath = isAbsolute(outputDir)
+            ? join(outputDir, `${bundleName}.js`)
+            : join(process.cwd(), outputDir, `${bundleName}.js`);
+        // Add cache-busting query param to force fresh import
+        const module = await import(`${modulePath}?t=${Date.now()}`);
+        const lambdaManifest = {
+            name: bundleName,
+            routes: [],
+        };
+        // Find all exported Elysia routes (objects with .routes array)
+        const exportedRoutes = Object.values(module).filter((exp) => exp !== null &&
+            typeof exp === "object" &&
+            "routes" in exp &&
+            Array.isArray(exp.routes));
+        for (const route of exportedRoutes) {
+            for (const r of route.routes) {
+                const method = r.method.toUpperCase();
+                const path = r.path;
+                const routeKey = `${method} ${path}`;
+                const pathParameters = extractPathParameters(path);
+                lambdaManifest.routes.push({
+                    method,
+                    path,
+                    pathParameters,
+                });
+                // Determine which lambda should handle this route
+                let targetLambda = bundleName;
+                // OpenAPI routes always go to the __openapi__ lambda if enabled
+                if (openapiEnabled && path.startsWith("/openapi")) {
+                    targetLambda = apiName ? getLambdaBundleName(apiName, "__openapi__") : "__openapi__";
+                }
+                else if (originalName === "__openapi__") {
+                    // Skip non-openapi routes from the openapi aggregator lambda
+                    continue;
+                }
+                // Check for route conflicts
+                const existingOwner = routeOwners.get(routeKey);
+                if (existingOwner && existingOwner !== targetLambda) {
+                    const existingConflict = conflicts.find((c) => c.route === routeKey);
+                    if (existingConflict) {
+                        if (!existingConflict.lambdas.includes(targetLambda)) {
+                            existingConflict.lambdas.push(targetLambda);
+                        }
+                    }
+                    else {
+                        conflicts.push({
+                            route: routeKey,
+                            lambdas: [existingOwner, targetLambda],
+                        });
+                    }
+                    continue;
+                }
+                if (!routeOwners.has(routeKey)) {
+                    routeOwners.set(routeKey, targetLambda);
+                    manifest.routes.push({
+                        method,
+                        path,
+                        lambda: targetLambda,
+                        pathParameters,
+                        apiGatewayPath: convertToApiGatewayPath(path),
+                    });
+                }
+            }
+        }
+        manifest.lambdas.push(lambdaManifest);
+    }
+    // Report conflicts and fail if any exist
+    if (conflicts.length > 0) {
+        const conflictMessages = conflicts
+            .map((c) => `  ${c.route} is defined in: ${c.lambdas.join(", ")}`)
+            .join("\n");
+        throw new Error(`Route conflicts detected:\n${conflictMessages}\n\nEach route must be handled by exactly one lambda.`);
+    }
+    return manifest;
+}
+/**
+ * Write manifest to JSON file
+ */
+export async function writeManifest(manifest, outputPath) {
+    await Bun.write(outputPath, JSON.stringify(manifest, null, 2));
+}

package/dist/core/naming.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Naming utilities for lambda bundles
+ */
+/**
+ * Generate the prefixed lambda name for bundle files
+ * Format: {apiName}-{lambdaName}
+ */
+export declare function getLambdaBundleName(apiName: string, lambdaName: string): string;
+/**
+ * Extract the original lambda name from a prefixed bundle name
+ */
+export declare function getOriginalLambdaName(apiName: string, bundleName: string): string;

package/dist/core/naming.js

@@ -0,0 +1,20 @@
+/**
+ * Naming utilities for lambda bundles
+ */
+/**
+ * Generate the prefixed lambda name for bundle files
+ * Format: {apiName}-{lambdaName}
+ */
+export function getLambdaBundleName(apiName, lambdaName) {
+    return `${apiName}-${lambdaName}`;
+}
+/**
+ * Extract the original lambda name from a prefixed bundle name
+ */
+export function getOriginalLambdaName(apiName, bundleName) {
+    const prefix = `${apiName}-`;
+    if (bundleName.startsWith(prefix)) {
+        return bundleName.slice(prefix.length);
+    }
+    return bundleName;
+}

package/dist/core/openapi.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OpenAPI auto-aggregation
+ *
+ * Automatically generates an OpenAPI lambda that aggregates all routes
+ * from all other lambdas to provide a complete API specification.
+ */
+import type { ResolvedConfig } from "./config";
+/**
+ * Generate the OpenAPI aggregator lambda source code
+ */
+export declare function generateOpenApiLambdaSource(lambdaFiles: 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>;
+/**
+ * Check if OpenAPI aggregator needs to be generated
+ */
+export declare function shouldGenerateOpenApi(config: ResolvedConfig): boolean;
+/**
+ * Clean up the generated OpenAPI lambda file
+ */
+export declare function cleanupOpenApiLambda(lambdasDir: string): Promise<void>;

package/dist/core/openapi.js

@@ -0,0 +1,85 @@
+/**
+ * OpenAPI auto-aggregation
+ *
+ * Automatically generates an OpenAPI lambda that aggregates all routes
+ * from all other lambdas to provide a complete API specification.
+ */
+import { join } from "path";
+/**
+ * Generate the OpenAPI aggregator lambda source code
+ */
+export function generateOpenApiLambdaSource(lambdaFiles, 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}";`;
+    })
+        .join("\n");
+    const uses = routeFiles.map((_, index) => `.use(route${index})`).join("\n\t\t");
+    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";
+
+${imports}
+
+const app = new Elysia()
+	.use(
+		openapi({
+			documentation: {
+				info: {
+					title: ${JSON.stringify(config.openapi.title)},
+					version: ${JSON.stringify(config.openapi.version)},
+					description: ${JSON.stringify(config.openapi.description)},
+				},
+			},
+		}),
+	)
+	${uses ? `\t${uses}` : ""};
+
+export default app;
+
+// Lambda handler
+const api = new Hono().mount("/", app.fetch);
+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");
+    await Bun.write(outputPath, source);
+    return outputPath;
+}
+/**
+ * Check if OpenAPI aggregator needs to be generated
+ */
+export function shouldGenerateOpenApi(config) {
+    return config.openapi.enabled;
+}
+/**
+ * Clean up the generated OpenAPI lambda file
+ */
+export async function cleanupOpenApiLambda(lambdasDir) {
+    const openApiPath = join(lambdasDir, "__openapi__.ts");
+    try {
+        const file = Bun.file(openApiPath);
+        if (await file.exists()) {
+            await Bun.write(openApiPath, ""); // Clear content
+            const { unlinkSync } = await import("fs");
+            unlinkSync(openApiPath);
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}

package/dist/core/packager.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Lambda packager - creates zip files for AWS Lambda deployment
+ */
+export interface PackageResult {
+    name: string;
+    zipPath: string;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Package a bundled lambda into a zip file
+ */
+export declare function packageLambda(name: string, jsFilePath: string, outputDir: string): Promise<PackageResult>;
+/**
+ * Package all bundled lambdas
+ */
+export declare function packageAllLambdas(lambdaNames: string[], outputDir: string): Promise<PackageResult[]>;

package/dist/core/packager.js

@@ -0,0 +1,54 @@
+/**
+ * Lambda packager - creates zip files for AWS Lambda deployment
+ */
+import { execSync } from "child_process";
+import { join } from "path";
+import { mkdirSync, rmSync, existsSync, copyFileSync } from "fs";
+/**
+ * Package a bundled lambda into a zip file
+ */
+export async function packageLambda(name, jsFilePath, outputDir) {
+    const lambdaDir = join(outputDir, `__${name}_pkg__`);
+    const zipPath = join(outputDir, `${name}.zip`);
+    try {
+        // Create temp directory for packaging
+        mkdirSync(lambdaDir, { recursive: true });
+        // Copy JS file as index.mjs (Lambda expects this name)
+        copyFileSync(jsFilePath, join(lambdaDir, "index.mjs"));
+        // Create zip file
+        execSync(`zip -qj "${zipPath}" "${join(lambdaDir, "index.mjs")}"`, {
+            cwd: outputDir,
+        });
+        // Clean up temp directory
+        rmSync(lambdaDir, { recursive: true, force: true });
+        return {
+            name,
+            zipPath,
+            success: true,
+        };
+    }
+    catch (error) {
+        // Clean up on error
+        if (existsSync(lambdaDir)) {
+            rmSync(lambdaDir, { recursive: true, force: true });
+        }
+        return {
+            name,
+            zipPath,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Package all bundled lambdas
+ */
+export async function packageAllLambdas(lambdaNames, outputDir) {
+    const results = [];
+    for (const name of lambdaNames) {
+        const jsFilePath = join(outputDir, `${name}.js`);
+        const result = await packageLambda(name, jsFilePath, outputDir);
+        results.push(result);
+    }
+    return results;
+}

package/dist/core/terraform.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Terraform output generation
+ */
+import type { ApiManifest } from "./manifest";
+import type { ResolvedConfig } from "./config";
+/**
+ * Generate Terraform tfvars content from manifest
+ */
+export declare function generateTerraformVars(manifest: ApiManifest, config: ResolvedConfig): string;
+/**
+ * Write Terraform tfvars file
+ */
+export declare function writeTerraformVars(manifest: ApiManifest, config: ResolvedConfig): Promise<string>;

package/dist/core/terraform.js

@@ -0,0 +1,44 @@
+/**
+ * Terraform output generation
+ */
+import { join } from "path";
+import { generateRouteName } from "./manifest";
+/**
+ * Generate Terraform tfvars content from manifest
+ */
+export function generateTerraformVars(manifest, config) {
+    // Get unique lambda names from routes (excludes __openapi__ prefix for cleaner naming)
+    const lambdaNames = [...new Set(manifest.routes.map((r) => r.lambda))];
+    const routeEntries = manifest.routes.map((route) => {
+        const routeName = generateRouteName(route.lambda, route.method, route.path);
+        const apiGatewayRouteKey = `${route.method} ${route.apiGatewayPath}`;
+        return `  ${routeName} = {
+    lambda_key      = "${route.lambda}"
+    route_key       = "${apiGatewayRouteKey}"
+    path_parameters = ${JSON.stringify(route.pathParameters)}
+  }`;
+    });
+    return `# Auto-generated by elysian - DO NOT EDIT
+# Generated at: ${new Date().toISOString()}
+
+lambda_names = ${JSON.stringify(lambdaNames)}
+
+api_routes = {
+${routeEntries.join("\n")}
+}
+
+# Lambda configuration defaults
+lambda_runtime     = "${config.lambda.runtime}"
+lambda_memory_size = ${config.lambda.memorySize}
+lambda_timeout     = ${config.lambda.timeout}
+`;
+}
+/**
+ * Write Terraform tfvars file
+ */
+export async function writeTerraformVars(manifest, config) {
+    const tfvarsContent = generateTerraformVars(manifest, config);
+    const outputPath = join(process.cwd(), config.terraform.outputDir, config.terraform.tfvarsFilename);
+    await Bun.write(outputPath, tfvarsContent);
+    return outputPath;
+}

package/dist/core/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Package version - read from jsr.json or package.json
+ */
+declare let version: string;
+export { version };

package/dist/core/version.js

@@ -0,0 +1,30 @@
+/**
+ * Package version - read from jsr.json or package.json
+ */
+import { createRequire } from "module";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+let version = "0.0.0";
+try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const require = createRequire(import.meta.url);
+    // Try jsr.json first (for JSR published package - src/core/version.ts -> ../../jsr.json)
+    try {
+        const jsr = require(join(__dirname, "../../jsr.json"));
+        version = jsr.version;
+    }
+    catch {
+        // Try package.json (for npm/local - dist/core/version.js -> ../../package.json)
+        try {
+            const pkg = require(join(__dirname, "../../package.json"));
+            version = pkg.version;
+        }
+        catch {
+            // Fallback already set to 0.0.0
+        }
+    }
+}
+catch {
+    // Fallback if nothing works
+}
+export { version };

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * elysian - Automatic Lambda bundler for Elysia with API Gateway integration
+ *
+ * Main library exports for use in configuration and lambda files.
+ */
+import Elysia from "elysia";
+export { defineConfig, type ElysianConfig, type ResolvedConfig } from "./core/config";
+export { t } from "elysia";
+export type { AnyElysia } from "elysia";
+export { createHandler } from "./runtime/adapter";
+/**
+ * Set the OpenAPI configuration (called by build process)
+ */
+export declare function setOpenApiConfig(config: {
+    title?: string;
+    version?: string;
+    description?: string;
+}): void;
+/**
+ * Create a new Elysia instance pre-configured for Lambda use
+ *
+ * This is the main entry point for defining Lambda routes.
+ * The returned Elysia instance has OpenAPI support built-in.
+ *
+ * @example
+ * ```ts
+ * import { createLambda, t } from "@actuallyjamez/elysian";
+ *
+ * export default createLambda()
+ *   .get("/hello", () => "Hello World", {
+ *     response: t.String(),
+ *   })
+ *   .get("/users/:id", ({ params }) => getUser(params.id), {
+ *     params: t.Object({ id: t.String() }),
+ *   });
+ * ```
+ */
+export declare function createLambda(): Elysia;