@actuallyjamez/elysian 0.2.1

package/dist/cli/commands/init.js

@@ -0,0 +1,295 @@
+/**
+ * Init command - Initialize a new elysian project
+ */
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+export const initCommand = defineCommand({
+    meta: {
+        name: "init",
+        description: "Initialize a new elysian project",
+    },
+    args: {
+        name: {
+            type: "string",
+            description: "API name",
+            default: "my-api",
+        },
+        force: {
+            type: "boolean",
+            description: "Overwrite existing files",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const cwd = process.cwd();
+        const apiName = args.name;
+        consola.start(`Initializing elysian project: ${apiName}`);
+        // Check for existing config
+        const configPath = join(cwd, "elysian.config.ts");
+        if (existsSync(configPath) && !args.force) {
+            consola.error("elysian.config.ts already exists. Use --force to overwrite.");
+            process.exit(1);
+        }
+        // Create directories
+        const lambdasDir = join(cwd, "src/lambdas");
+        const terraformDir = join(cwd, "terraform");
+        mkdirSync(lambdasDir, { recursive: true });
+        mkdirSync(terraformDir, { recursive: true });
+        consola.success("Created src/lambdas/");
+        consola.success("Created terraform/");
+        // Write config file
+        const configContent = `import { defineConfig } from "@actuallyjamez/elysian";
+
+export default defineConfig({
+	apiName: "${apiName}",
+
+	// Lambda source directory
+	lambdasDir: "src/lambdas",
+
+	// Build output directory
+	outputDir: "dist",
+
+	// OpenAPI configuration
+	openapi: {
+		enabled: true,
+		title: "${apiName}",
+		version: "1.0.0",
+		description: "API powered by Elysia and AWS Lambda",
+	},
+
+	// Terraform configuration
+	terraform: {
+		outputDir: "terraform",
+		tfvarsFilename: "api-routes.auto.tfvars",
+	},
+
+	// Lambda defaults
+	lambda: {
+		runtime: "nodejs20.x",
+		memorySize: 256,
+		timeout: 30,
+	},
+});
+`;
+        await Bun.write(configPath, configContent);
+        consola.success("Created elysian.config.ts");
+        // Write example lambda
+        const exampleLambdaPath = join(lambdasDir, "hello.ts");
+        if (!existsSync(exampleLambdaPath) || args.force) {
+            const exampleLambdaContent = `import { createLambda, t } from "@actuallyjamez/elysian";
+
+/**
+ * Example Lambda - Hello World
+ *
+ * Routes defined here will be automatically:
+ * - Bundled into a Lambda function
+ * - Mapped to API Gateway routes
+ * - Included in OpenAPI documentation
+ */
+export default createLambda()
+	.get("/hello", ({ query }) => {
+		return \`Hello, \${query.name ?? "World"}!\`;
+	}, {
+		response: t.String(),
+		query: t.Object({
+			name: t.Optional(t.String()),
+		}),
+		detail: {
+			summary: "Say hello",
+			description: "Returns a greeting message",
+			tags: ["Greeting"],
+		},
+	});
+`;
+            await Bun.write(exampleLambdaPath, exampleLambdaContent);
+            consola.success("Created src/lambdas/hello.ts");
+        }
+        // Write Terraform main.tf template
+        const terraformMainPath = join(terraformDir, "main.tf");
+        if (!existsSync(terraformMainPath) || args.force) {
+            const terraformContent = `terraform {
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "~> 5.0"
+    }
+  }
+}
+
+provider "aws" {
+  region = var.region
+}
+
+variable "region" {
+  type    = string
+  default = "eu-west-2"
+}
+
+variable "lambda_names" {
+  type    = list(string)
+  default = []
+}
+
+variable "api_routes" {
+  type = map(object({
+    lambda_key      = string
+    route_key       = string
+    path_parameters = list(string)
+  }))
+  default = {}
+}
+
+variable "lambda_runtime" {
+  type    = string
+  default = "nodejs20.x"
+}
+
+variable "lambda_memory_size" {
+  type    = number
+  default = 256
+}
+
+variable "lambda_timeout" {
+  type    = number
+  default = 30
+}
+
+variable "api_name" {
+  type    = string
+  default = "${apiName}"
+}
+
+variable "tags" {
+  type    = map(string)
+  default = {}
+}
+
+locals {
+  lambda_functions = {
+    for name in var.lambda_names : name => {
+      filename         = "\${path.module}/../dist/\${name}.zip"
+      handler          = "index.handler"
+      source_code_hash = filebase64sha256("\${path.module}/../dist/\${name}.zip")
+    }
+  }
+}
+
+# API Gateway
+resource "aws_apigatewayv2_api" "this" {
+  name          = var.api_name
+  protocol_type = "HTTP"
+  description   = "API Gateway for \${var.api_name}"
+  tags          = var.tags
+}
+
+# IAM Role for Lambda
+resource "aws_iam_role" "lambda" {
+  name = "\${var.api_name}-lambda-role"
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [{
+      Action = "sts:AssumeRole"
+      Effect = "Allow"
+      Principal = {
+        Service = "lambda.amazonaws.com"
+      }
+    }]
+  })
+
+  tags = var.tags
+}
+
+resource "aws_iam_role_policy_attachment" "lambda_basic" {
+  role       = aws_iam_role.lambda.name
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
+}
+
+# Lambda Functions
+resource "aws_lambda_function" "this" {
+  for_each = local.lambda_functions
+
+  filename         = each.value.filename
+  function_name    = "\${var.api_name}-\${each.key}"
+  role             = aws_iam_role.lambda.arn
+  handler          = each.value.handler
+  source_code_hash = each.value.source_code_hash
+  runtime          = var.lambda_runtime
+  memory_size      = var.lambda_memory_size
+  timeout          = var.lambda_timeout
+
+  tags = var.tags
+}
+
+# API Gateway Integrations
+resource "aws_apigatewayv2_integration" "this" {
+  for_each = local.lambda_functions
+
+  api_id             = aws_apigatewayv2_api.this.id
+  integration_type   = "AWS_PROXY"
+  integration_uri    = aws_lambda_function.this[each.key].invoke_arn
+  integration_method = "POST"
+  payload_format_version = "2.0"
+}
+
+# Lambda Permissions
+resource "aws_lambda_permission" "apigateway" {
+  for_each = local.lambda_functions
+
+  statement_id  = "AllowExecutionFromAPIGateway-\${each.key}"
+  action        = "lambda:InvokeFunction"
+  function_name = aws_lambda_function.this[each.key].function_name
+  principal     = "apigateway.amazonaws.com"
+  source_arn    = "\${aws_apigatewayv2_api.this.execution_arn}/*/*"
+}
+
+# API Gateway Routes
+resource "aws_apigatewayv2_route" "this" {
+  for_each = var.api_routes
+
+  api_id    = aws_apigatewayv2_api.this.id
+  route_key = each.value.route_key
+  target    = "integrations/\${aws_apigatewayv2_integration.this[each.value.lambda_key].id}"
+}
+
+# API Gateway Stage
+resource "aws_apigatewayv2_stage" "this" {
+  api_id      = aws_apigatewayv2_api.this.id
+  name        = "$default"
+  auto_deploy = true
+
+  tags = var.tags
+
+  depends_on = [
+    aws_apigatewayv2_route.this,
+    aws_lambda_permission.apigateway
+  ]
+}
+
+# Outputs
+output "api_endpoint" {
+  value = aws_apigatewayv2_stage.this.invoke_url
+}
+
+output "lambda_functions" {
+  value = { for k, v in aws_lambda_function.this : k => v.arn }
+}
+`;
+            await Bun.write(terraformMainPath, terraformContent);
+            consola.success("Created terraform/main.tf");
+        }
+        // Print next steps
+        console.log("");
+        consola.box("Project initialized!\n\n" +
+            "Next steps:\n\n" +
+            "1. Install dependencies:\n" +
+            "   bun add elysia @actuallyjamez/elysian\n\n" +
+            "2. Add more lambdas in src/lambdas/\n\n" +
+            "3. Build your lambdas:\n" +
+            "   bunx elysian build\n\n" +
+            "4. Deploy with Terraform:\n" +
+            "   cd terraform && terraform init && terraform apply");
+    },
+});

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+/**
+ * elysian CLI entry point
+ */
+export {};

package/dist/cli/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+/**
+ * elysian CLI entry point
+ */
+import { defineCommand, runMain } from "citty";
+import { buildCommand } from "./commands/build";
+import { devCommand } from "./commands/dev";
+import { initCommand } from "./commands/init";
+import { generateIacCommand } from "./commands/generate-iac";
+import { version } from "../core/version";
+const main = defineCommand({
+    meta: {
+        name: "elysian",
+        version,
+        description: "Automatic Lambda bundler for Elysia with API Gateway integration",
+    },
+    subCommands: {
+        build: buildCommand,
+        dev: devCommand,
+        init: initCommand,
+        "generate-iac": generateIacCommand,
+    },
+});
+runMain(main);

package/dist/core/bundler.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lambda bundler using Bun.build
+ */
+import type { ResolvedConfig } from "./config";
+export interface BundleResult {
+    name: string;
+    outputPath: string;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Bundle a single lambda file
+ */
+export declare function bundleLambda(name: string, inputPath: string, outputDir: string, config: ResolvedConfig): Promise<BundleResult>;
+/**
+ * Bundle all lambda files in a directory
+ */
+export declare function bundleAllLambdas(lambdaFiles: string[], lambdasDir: string, outputDir: string, config: ResolvedConfig): Promise<BundleResult[]>;

package/dist/core/bundler.js

@@ -0,0 +1,62 @@
+/**
+ * Lambda bundler using Bun.build
+ */
+import { build } from "bun";
+import { join } from "path";
+import { createHandlerWrapperPlugin } from "./handler-wrapper";
+/**
+ * Bundle a single lambda file
+ */
+export async function bundleLambda(name, inputPath, outputDir, config) {
+    try {
+        const result = await build({
+            entrypoints: [inputPath],
+            outdir: outputDir,
+            naming: `${name}.js`,
+            format: "esm",
+            target: "bun",
+            external: config.build.external,
+            sourcemap: config.build.sourcemap ? "external" : "none",
+            minify: config.build.minify,
+            plugins: [createHandlerWrapperPlugin()],
+        });
+        if (!result.success) {
+            const errors = result.logs
+                .filter((log) => log.level === "error")
+                .map((log) => log.message)
+                .join("\n");
+            return {
+                name,
+                outputPath: join(outputDir, `${name}.js`),
+                success: false,
+                error: errors || "Unknown build error",
+            };
+        }
+        return {
+            name,
+            outputPath: join(outputDir, `${name}.js`),
+            success: true,
+        };
+    }
+    catch (error) {
+        return {
+            name,
+            outputPath: join(outputDir, `${name}.js`),
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Bundle all lambda files in a directory
+ */
+export async function bundleAllLambdas(lambdaFiles, lambdasDir, outputDir, config) {
+    const results = [];
+    for (const file of lambdaFiles) {
+        const name = file.replace(/\.ts$/, "");
+        const inputPath = join(lambdasDir, file);
+        const result = await bundleLambda(name, inputPath, outputDir, config);
+        results.push(result);
+    }
+    return results;
+}

package/dist/core/config.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Configuration types and loader for elysian
+ */
+export interface OpenAPIConfig {
+    /** Enable OpenAPI auto-aggregation (default: true) */
+    enabled?: boolean;
+    /** API title for OpenAPI spec */
+    title?: string;
+    /** API version for OpenAPI spec */
+    version?: string;
+    /** API description for OpenAPI spec */
+    description?: string;
+}
+export interface BuildConfig {
+    /** Minify output (default: true in production) */
+    minify?: boolean;
+    /** Generate sourcemaps (default: true in development) */
+    sourcemap?: boolean;
+    /** External packages to exclude from bundle (default: ["@aws-sdk/*"]) */
+    external?: string[];
+}
+export interface LambdaConfig {
+    /** Lambda runtime (default: "nodejs20.x") */
+    runtime?: string;
+    /** Lambda memory size in MB (default: 256) */
+    memorySize?: number;
+    /** Lambda timeout in seconds (default: 30) */
+    timeout?: number;
+}
+export interface TerraformConfig {
+    /** Output directory for Terraform files (default: "terraform") */
+    outputDir?: string;
+    /** Name for the generated tfvars file (default: "api-routes.auto.tfvars") */
+    tfvarsFilename?: string;
+}
+export interface ElysianConfig {
+    /** Name of the API (used for resource naming) */
+    apiName: string;
+    /** Directory containing lambda files (default: "src/lambdas") */
+    lambdasDir?: string;
+    /** Output directory for built lambdas (default: "dist") */
+    outputDir?: string;
+    /** OpenAPI configuration */
+    openapi?: OpenAPIConfig;
+    /** Build configuration */
+    build?: BuildConfig;
+    /** Lambda defaults */
+    lambda?: LambdaConfig;
+    /** Terraform configuration */
+    terraform?: TerraformConfig;
+}
+export interface ResolvedConfig {
+    apiName: string;
+    lambdasDir: string;
+    outputDir: string;
+    openapi: Required<OpenAPIConfig>;
+    build: Required<BuildConfig>;
+    lambda: Required<LambdaConfig>;
+    terraform: Required<TerraformConfig>;
+}
+/**
+ * Define configuration with type safety and defaults
+ */
+export declare function defineConfig(config: ElysianConfig): ElysianConfig;
+/**
+ * Resolve configuration with defaults applied
+ */
+export declare function resolveConfig(config: ElysianConfig): ResolvedConfig;
+/**
+ * Load configuration from elysian.config.ts
+ */
+export declare function loadConfig(cwd?: string): Promise<ResolvedConfig>;

package/dist/core/config.js

@@ -0,0 +1,84 @@
+/**
+ * Configuration types and loader for elysian
+ */
+const DEFAULT_CONFIG = {
+    lambdasDir: "src/lambdas",
+    outputDir: "dist",
+    openapi: {
+        enabled: true,
+        title: "API",
+        version: "1.0.0",
+        description: "",
+    },
+    build: {
+        minify: process.env.NODE_ENV === "production",
+        sourcemap: process.env.NODE_ENV !== "production",
+        external: ["@aws-sdk/*"],
+    },
+    lambda: {
+        runtime: "nodejs20.x",
+        memorySize: 256,
+        timeout: 30,
+    },
+    terraform: {
+        outputDir: "terraform",
+        tfvarsFilename: "api-routes.auto.tfvars",
+    },
+};
+/**
+ * Define configuration with type safety and defaults
+ */
+export function defineConfig(config) {
+    return config;
+}
+/**
+ * Resolve configuration with defaults applied
+ */
+export function resolveConfig(config) {
+    return {
+        apiName: config.apiName,
+        lambdasDir: config.lambdasDir ?? DEFAULT_CONFIG.lambdasDir,
+        outputDir: config.outputDir ?? DEFAULT_CONFIG.outputDir,
+        openapi: {
+            enabled: config.openapi?.enabled ?? DEFAULT_CONFIG.openapi.enabled,
+            title: config.openapi?.title ?? DEFAULT_CONFIG.openapi.title,
+            version: config.openapi?.version ?? DEFAULT_CONFIG.openapi.version,
+            description: config.openapi?.description ?? DEFAULT_CONFIG.openapi.description,
+        },
+        build: {
+            minify: config.build?.minify ?? DEFAULT_CONFIG.build.minify,
+            sourcemap: config.build?.sourcemap ?? DEFAULT_CONFIG.build.sourcemap,
+            external: config.build?.external ?? DEFAULT_CONFIG.build.external,
+        },
+        lambda: {
+            runtime: config.lambda?.runtime ?? DEFAULT_CONFIG.lambda.runtime,
+            memorySize: config.lambda?.memorySize ?? DEFAULT_CONFIG.lambda.memorySize,
+            timeout: config.lambda?.timeout ?? DEFAULT_CONFIG.lambda.timeout,
+        },
+        terraform: {
+            outputDir: config.terraform?.outputDir ?? DEFAULT_CONFIG.terraform.outputDir,
+            tfvarsFilename: config.terraform?.tfvarsFilename ??
+                DEFAULT_CONFIG.terraform.tfvarsFilename,
+        },
+    };
+}
+/**
+ * Load configuration from elysian.config.ts
+ */
+export async function loadConfig(cwd = process.cwd()) {
+    const configPath = `${cwd}/elysian.config.ts`;
+    try {
+        const configModule = await import(configPath);
+        const config = configModule.default;
+        if (!config.apiName) {
+            throw new Error("apiName is required in elysian.config.ts");
+        }
+        return resolveConfig(config);
+    }
+    catch (error) {
+        if (error.code === "ERR_MODULE_NOT_FOUND") {
+            throw new Error(`Configuration file not found: ${configPath}\nRun 'elysian init' to create one.`);
+        }
+        throw error;
+    }
+}

package/dist/core/handler-wrapper.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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__);
+ */
+import type { BunPlugin } from "bun";
+/**
+ * Create a Bun plugin that wraps default Elysia exports with a Lambda handler
+ */
+export declare function createHandlerWrapperPlugin(): BunPlugin;
+/**
+ * Transform source code to add handler export
+ * This is called after the initial bundle to add the handler wrapper
+ */
+export declare function wrapWithHandler(code: string): string;
+/**
+ * Alternative approach: Transform the bundle output directly
+ * This rewrites the code to capture the default export and wrap it
+ */
+export declare function transformBundleForLambda(code: string, lambdaName: string): string;
+/**
+ * Create a wrapper entry file that imports and re-exports with handler
+ */
+export declare function createWrapperEntry(originalPath: string): string;