@actuallyjamez/elysian 0.3.0 → 0.5.0

package/dist/cli/commands/init.js

@@ -1,21 +1,20 @@
 /**
- * Init command - Initialize a new elysian project
+ * Init command - Interactive wizard to initialize elysian projects
  */
 import { defineCommand } from "citty";
 import consola from "consola";
+import pc from "picocolors";
 import { existsSync, mkdirSync } from "fs";
-import { join } from "path";
+import { resolve, basename } from "path";
+import { detectProject, } from "./init/detect";
+import { promptTargetDirectory, runFreshProjectWizard, runExistingProjectWizard, } from "./init/prompts";
+import { scaffoldProject, installDependencies, printResults, } from "./init/scaffold";
 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",
@@ -23,273 +22,85 @@ export const initCommand = defineCommand({
         },
     },
     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) {
+        const originalCwd = process.cwd();
+        // Step 1: Get target directory
+        const targetDir = await promptTargetDirectory(basename(originalCwd));
+        if (!targetDir) {
+            consola.info("Cancelled");
+            process.exit(0);
+        }
+        // Resolve the target directory
+        const cwd = resolve(originalCwd, targetDir);
+        const name = basename(cwd);
+        // Create directory if it doesn't exist
+        if (!existsSync(cwd)) {
+            mkdirSync(cwd, { recursive: true });
+            consola.success(`Created directory: ${targetDir}`);
+        }
+        // Detect project state in target directory
+        const info = await detectProject(cwd);
+        // Check for existing config (unless force)
+        if (info.hasElysianConfig && !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");
+        // Run appropriate wizard based on whether directory is empty
+        let answers;
+        if (info.isEmpty) {
+            const result = await runFreshProjectWizard(name);
+            if (!result) {
+                consola.info("Cancelled");
+                process.exit(0);
+            }
+            answers = {
+                targetDir,
+                ...result,
+            };
+        }
+        else {
+            const result = await runExistingProjectWizard(name, info.packageManager);
+            if (!result) {
+                consola.info("Cancelled");
+                process.exit(0);
+            }
+            answers = {
+                targetDir,
+                ...result,
+            };
         }
-        // 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");
+        // Scaffold files
+        const scaffoldResult = await scaffoldProject(cwd, info, answers, args.force);
+        // Print results
+        printResults(cwd, scaffoldResult);
+        // Install dependencies if requested
+        if (answers.installDeps) {
+            try {
+                await installDependencies(cwd, answers.packageManager);
+            }
+            catch (error) {
+                consola.error(error instanceof Error ? error.message : "Failed to install dependencies");
+                consola.info(`You can manually install with: ${answers.packageManager} add elysia @actuallyjamez/elysian`);
+            }
         }
         // 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");
+        const pm = answers.packageManager;
+        const runCmd = pm === "npm" ? "npm run" : pm;
+        // If we created in a subdirectory, tell user to cd into it
+        const cdStep = targetDir !== "." ? `cd ${targetDir}\n\n` : "";
+        console.log(`  ${pc.green("✓")} Project initialized!`);
+        console.log();
+        console.log(`  ${pc.bold("Next steps")}:`);
+        console.log();
+        if (cdStep) {
+            console.log(`    ${cdStep}`);
+        }
+        if (!answers.installDeps) {
+            console.log(`    ${pm} add elysia @actuallyjamez/elysian`);
+            console.log();
+        }
+        console.log(`    ${runCmd} elysian build`);
+        console.log();
+        console.log(`    cd terraform && terraform init && terraform apply`);
     },
 });

package/dist/core/config.d.ts

@@ -4,9 +4,9 @@
 export interface OpenAPIConfig {
     /** Enable OpenAPI auto-aggregation (default: true) */
     enabled?: boolean;
-    /** API title for OpenAPI spec */
+    /** API title for OpenAPI spec (defaults to name if not provided) */
     title?: string;
-    /** API version for OpenAPI spec */
+    /** API version for OpenAPI spec (defaults to package.json version if not provided) */
     version?: string;
     /** API description for OpenAPI spec */
     description?: string;
@@ -20,7 +20,7 @@ export interface BuildConfig {
     external?: string[];
 }
 export interface LambdaConfig {
-    /** Lambda runtime (default: "nodejs20.x") */
+    /** Lambda runtime (default: "nodejs22.x") */
     runtime?: string;
     /** Lambda memory size in MB (default: 256) */
     memorySize?: number;
@@ -35,7 +35,7 @@ export interface TerraformConfig {
 }
 export interface ElysianConfig {
     /** Name of the API (used for resource naming) */
-    apiName: string;
+    name: string;
     /** Directory containing lambda files (default: "src/lambdas") */
     lambdasDir?: string;
     /** Output directory for built lambdas (default: "dist") */
@@ -50,7 +50,7 @@ export interface ElysianConfig {
     terraform?: TerraformConfig;
 }
 export interface ResolvedConfig {
-    apiName: string;
+    name: string;
     lambdasDir: string;
     outputDir: string;
     openapi: Required<OpenAPIConfig>;
@@ -65,7 +65,7 @@ export declare function defineConfig(config: ElysianConfig): ElysianConfig;
 /**
  * Resolve configuration with defaults applied
  */
-export declare function resolveConfig(config: ElysianConfig): ResolvedConfig;
+export declare function resolveConfig(config: ElysianConfig, cwd: string): Promise<ResolvedConfig>;
 /**
  * Load configuration from elysian.config.ts
  */

package/dist/core/config.js

@@ -16,7 +16,7 @@ const DEFAULT_CONFIG = {
         external: ["@aws-sdk/*"],
     },
     lambda: {
-        runtime: "nodejs20.x",
+        runtime: "nodejs22.x",
         memorySize: 256,
         timeout: 30,
     },
@@ -25,6 +25,19 @@ const DEFAULT_CONFIG = {
         tfvarsFilename: "api-routes.auto.tfvars",
     },
 };
+/**
+ * Read version from package.json
+ */
+async function readPackageVersion(cwd) {
+    const packagePath = `${cwd}/package.json`;
+    try {
+        const content = await Bun.file(packagePath).json();
+        return content.version || null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Define configuration with type safety and defaults
  */
@@ -34,15 +47,16 @@ export function defineConfig(config) {
 /**
  * Resolve configuration with defaults applied
  */
-export function resolveConfig(config) {
+export async function resolveConfig(config, cwd) {
+    const pkgVersion = await readPackageVersion(cwd);
     return {
-        apiName: config.apiName,
+        name: config.name,
         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,
+            title: config.openapi?.title ?? config.name,
+            version: config.openapi?.version ?? pkgVersion ?? DEFAULT_CONFIG.openapi.version,
             description: config.openapi?.description ?? DEFAULT_CONFIG.openapi.description,
         },
         build: {
@@ -70,10 +84,10 @@ export async function loadConfig(cwd = process.cwd()) {
     try {
         const configModule = await import(configPath);
         const config = configModule.default;
-        if (!config.apiName) {
-            throw new Error("apiName is required in elysian.config.ts");
+        if (!config.name) {
+            throw new Error("name is required in elysian.config.ts");
         }
-        return resolveConfig(config);
+        return resolveConfig(config, cwd);
     }
     catch (error) {
         if (error.code === "ERR_MODULE_NOT_FOUND") {

package/dist/core/manifest.d.ts

@@ -36,7 +36,7 @@ export declare function generateRouteName(lambda: string, method: string, path:
 /**
  * Generate manifest by introspecting built lambda modules
  */
-export declare function generateManifest(lambdaFiles: string[], outputDir: string, openapiEnabled?: boolean, apiName?: string): Promise<ApiManifest>;
+export declare function generateManifest(lambdaFiles: string[], outputDir: string, openapiEnabled?: boolean, name?: string): Promise<ApiManifest>;
 /**
  * Write manifest to JSON file
  */

package/dist/core/manifest.js

@@ -31,7 +31,7 @@ export function generateRouteName(lambda, method, path) {
 /**
  * Generate manifest by introspecting built lambda modules
  */
-export async function generateManifest(lambdaFiles, outputDir, openapiEnabled = true, apiName = "") {
+export async function generateManifest(lambdaFiles, outputDir, openapiEnabled = true, name = "") {
     const manifest = {
         lambdas: [],
         routes: [],
@@ -43,7 +43,7 @@ export async function generateManifest(lambdaFiles, outputDir, openapiEnabled =
     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 bundleName = name ? getLambdaBundleName(name, originalName) : originalName;
         const modulePath = isAbsolute(outputDir)
             ? join(outputDir, `${bundleName}.js`)
             : join(process.cwd(), outputDir, `${bundleName}.js`);
@@ -71,12 +71,12 @@ export async function generateManifest(lambdaFiles, outputDir, openapiEnabled =
                 });
                 // Determine which lambda should handle this route
                 let targetLambda = bundleName;
-                // OpenAPI routes always go to the __openapi__ lambda if enabled
+                // OpenAPI routes always go to __openapi__ lambda if enabled
                 if (openapiEnabled && path.startsWith("/openapi")) {
-                    targetLambda = apiName ? getLambdaBundleName(apiName, "__openapi__") : "__openapi__";
+                    targetLambda = name ? getLambdaBundleName(name, "__openapi__") : "__openapi__";
                 }
                 else if (originalName === "__openapi__") {
-                    // Skip non-openapi routes from the openapi aggregator lambda
+                    // Skip non-openapi routes from openapi aggregator lambda
                     continue;
                 }
                 // Check for route conflicts

package/dist/core/naming.d.ts

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

package/dist/core/naming.js

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

package/package.json

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