@actuallyjamez/elysian 0.3.0 → 0.5.0

package/dist/cli/commands/init/scaffold.d.ts

@@ -0,0 +1,26 @@
+/**
+ * File scaffolding logic
+ */
+import type { PackageManager, ProjectInfo } from "./detect";
+import type { WizardAnswers } from "./prompts";
+export interface ScaffoldResult {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+}
+/**
+ * Scaffold all project files
+ */
+export declare function scaffoldProject(cwd: string, info: ProjectInfo, answers: WizardAnswers, force: boolean): Promise<ScaffoldResult>;
+/**
+ * Install dependencies using the specified package manager
+ */
+export declare function installDependencies(cwd: string, packageManager: PackageManager): Promise<void>;
+/**
+ * Get relative path for display
+ */
+export declare function getRelativePath(cwd: string, fullPath: string): string;
+/**
+ * Print scaffold results
+ */
+export declare function printResults(cwd: string, result: ScaffoldResult): void;

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

@@ -0,0 +1,196 @@
+/**
+ * File scaffolding logic
+ */
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { spawn } from "bun";
+import consola from "consola";
+import { configTemplate, exampleLambdaTemplate, packageJsonTemplate, gitignoreTemplate, tsconfigTemplate, } from "./templates";
+import { templates as tfTemplates, appendProviders, getMissingVariables, appendMain, appendOutputs, } from "./terraform";
+/**
+ * Read file content or return empty string if not exists
+ */
+async function readFileOrEmpty(path) {
+    if (!existsSync(path)) {
+        return "";
+    }
+    return await Bun.file(path).text();
+}
+/**
+ * Write file and track in result
+ */
+async function writeFile(path, content, result, isUpdate) {
+    await Bun.write(path, content);
+    if (isUpdate) {
+        result.updated.push(path);
+    }
+    else {
+        result.created.push(path);
+    }
+}
+/**
+ * Scaffold all project files
+ */
+export async function scaffoldProject(cwd, info, answers, force) {
+    const result = {
+        created: [],
+        updated: [],
+        skipped: [],
+    };
+    // Create directories
+    const lambdasDir = join(cwd, "src/lambdas");
+    const terraformDir = join(cwd, "terraform");
+    if (!existsSync(lambdasDir)) {
+        mkdirSync(lambdasDir, { recursive: true });
+    }
+    if (!existsSync(terraformDir)) {
+        mkdirSync(terraformDir, { recursive: true });
+    }
+    // For fresh projects, create package.json, .gitignore, tsconfig.json
+    if (info.isEmpty) {
+        const packageJsonPath = join(cwd, "package.json");
+        await writeFile(packageJsonPath, packageJsonTemplate(answers.name), result, false);
+        const gitignorePath = join(cwd, ".gitignore");
+        if (!existsSync(gitignorePath)) {
+            await writeFile(gitignorePath, gitignoreTemplate(), result, false);
+        }
+        const tsconfigPath = join(cwd, "tsconfig.json");
+        if (!existsSync(tsconfigPath)) {
+            await writeFile(tsconfigPath, tsconfigTemplate(), result, false);
+        }
+    }
+    // Create elysian.config.ts
+    const configPath = join(cwd, "elysian.config.ts");
+    if (!existsSync(configPath) || force) {
+        await writeFile(configPath, configTemplate(answers.name), result, existsSync(configPath));
+    }
+    else {
+        result.skipped.push(configPath);
+    }
+    // Create example lambda (only if no lambda files exist)
+    const exampleLambdaPath = join(lambdasDir, "hello.ts");
+    if (!info.hasLambdaFiles) {
+        await writeFile(exampleLambdaPath, exampleLambdaTemplate(), result, false);
+    }
+    // Handle Terraform files
+    await scaffoldTerraform(cwd, info, answers.name, result);
+    return result;
+}
+/**
+ * Scaffold Terraform files with smart appending
+ */
+async function scaffoldTerraform(cwd, info, name, result) {
+    const tfDir = join(cwd, "terraform");
+    // providers.tf
+    const providersPath = join(tfDir, "providers.tf");
+    if (info.terraformFiles.providers) {
+        const existing = await readFileOrEmpty(providersPath);
+        const updated = appendProviders(existing);
+        if (updated !== existing) {
+            await writeFile(providersPath, updated, result, true);
+        }
+        else {
+            result.skipped.push(providersPath);
+        }
+    }
+    else {
+        await writeFile(providersPath, tfTemplates.providers, result, false);
+    }
+    // variables.tf
+    const variablesPath = join(tfDir, "variables.tf");
+    if (info.terraformFiles.variables) {
+        const existing = await readFileOrEmpty(variablesPath);
+        const updated = getMissingVariables(existing, name);
+        if (updated !== existing) {
+            await writeFile(variablesPath, updated, result, true);
+        }
+        else {
+            result.skipped.push(variablesPath);
+        }
+    }
+    else {
+        await writeFile(variablesPath, tfTemplates.variables(name), result, false);
+    }
+    // main.tf
+    const mainPath = join(tfDir, "main.tf");
+    if (info.terraformFiles.main) {
+        const existing = await readFileOrEmpty(mainPath);
+        const updated = appendMain(existing);
+        if (updated !== existing) {
+            await writeFile(mainPath, updated, result, true);
+        }
+        else {
+            result.skipped.push(mainPath);
+        }
+    }
+    else {
+        await writeFile(mainPath, tfTemplates.main, result, false);
+    }
+    // outputs.tf
+    const outputsPath = join(tfDir, "outputs.tf");
+    if (info.terraformFiles.outputs) {
+        const existing = await readFileOrEmpty(outputsPath);
+        const updated = appendOutputs(existing);
+        if (updated !== existing) {
+            await writeFile(outputsPath, updated, result, true);
+        }
+        else {
+            result.skipped.push(outputsPath);
+        }
+    }
+    else {
+        await writeFile(outputsPath, tfTemplates.outputs, result, false);
+    }
+}
+/**
+ * Install dependencies using the specified package manager
+ */
+export async function installDependencies(cwd, packageManager) {
+    const deps = ["elysia", "@actuallyjamez/elysian"];
+    const devDeps = ["@types/bun", "typescript"];
+    const addCmd = packageManager === "npm" ? "install" : "add";
+    const devFlag = packageManager === "npm" ? "--save-dev" : "-D";
+    consola.start("Installing dependencies...");
+    // Install main dependencies
+    const addProc = spawn([packageManager, addCmd, ...deps], {
+        cwd,
+        stdout: "ignore",
+        stderr: "pipe",
+    });
+    await addProc.exited;
+    if (addProc.exitCode !== 0) {
+        const stderr = await new Response(addProc.stderr).text();
+        throw new Error(`Failed to install dependencies: ${stderr}`);
+    }
+    // Install dev dependencies
+    const devProc = spawn([packageManager, addCmd, devFlag, ...devDeps], {
+        cwd,
+        stdout: "ignore",
+        stderr: "pipe",
+    });
+    await devProc.exited;
+    if (devProc.exitCode !== 0) {
+        const stderr = await new Response(devProc.stderr).text();
+        throw new Error(`Failed to install dev dependencies: ${stderr}`);
+    }
+    consola.success("Dependencies installed");
+}
+/**
+ * Get relative path for display
+ */
+export function getRelativePath(cwd, fullPath) {
+    return fullPath.replace(cwd + "/", "");
+}
+/**
+ * Print scaffold results
+ */
+export function printResults(cwd, result) {
+    console.log("");
+    for (const path of result.created) {
+        consola.success(`Created ${getRelativePath(cwd, path)}`);
+    }
+    for (const path of result.updated) {
+        consola.success(`Updated ${getRelativePath(cwd, path)}`);
+    }
+    // Don't print skipped files - too noisy
+}

package/dist/cli/commands/init/templates.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Template strings for generated files
+ */
+/**
+ * elysian.config.ts template
+ */
+export declare function configTemplate(name: string): string;
+/**
+ * Example lambda template
+ */
+export declare function exampleLambdaTemplate(): string;
+/**
+ * package.json template for fresh projects
+ */
+export declare function packageJsonTemplate(name: string): string;
+/**
+ * .gitignore template
+ */
+export declare function gitignoreTemplate(): string;
+/**
+ * tsconfig.json template
+ */
+export declare function tsconfigTemplate(): string;

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

@@ -0,0 +1,99 @@
+/**
+ * Template strings for generated files
+ */
+/**
+ * elysian.config.ts template
+ */
+export function configTemplate(name) {
+    return `import { defineConfig } from "@actuallyjamez/elysian";
+
+export default defineConfig({
+	name: "${name}",
+});
+`;
+}
+/**
+ * Example lambda template
+ */
+export function exampleLambdaTemplate() {
+    return `import { createLambda, t } from "@actuallyjamez/elysian";
+
+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",
+			tags: ["Greeting"],
+		},
+	});
+`;
+}
+/**
+ * package.json template for fresh projects
+ */
+export function packageJsonTemplate(name) {
+    return JSON.stringify({
+        name: name,
+        version: "0.1.0",
+        type: "module",
+        scripts: {
+            build: "elysian build",
+            dev: "elysian dev",
+        },
+    }, null, 2);
+}
+/**
+ * .gitignore template
+ */
+export function gitignoreTemplate() {
+    return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Environment
+.env
+.env.local
+
+# Terraform
+terraform/.terraform/
+terraform/*.tfstate
+terraform/*.tfstate.backup
+terraform/.terraform.lock.hcl
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+`;
+}
+/**
+ * tsconfig.json template
+ */
+export function tsconfigTemplate() {
+    return JSON.stringify({
+        compilerOptions: {
+            target: "ESNext",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            noEmit: true,
+            types: ["bun-types"],
+        },
+        include: ["src/**/*", "elysian.config.ts"],
+        exclude: ["node_modules", "dist"],
+    }, null, 2);
+}

package/dist/cli/commands/init/terraform.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Smart Terraform file handling - append missing blocks
+ */
+/**
+ * Check if content has AWS provider configured
+ */
+export declare function hasAwsProvider(content: string): boolean;
+/**
+ * Check if a variable exists in the content
+ */
+export declare function hasVariable(content: string, name: string): boolean;
+/**
+ * Check if a resource of a given type exists
+ */
+export declare function hasResource(content: string, type: string): boolean;
+/**
+ * Check if an output exists in the content
+ */
+export declare function hasOutput(content: string, name: string): boolean;
+/**
+ * Smart append to providers.tf - only add if AWS provider is missing
+ */
+export declare function appendProviders(existing: string): string;
+/**
+ * Get missing variables and return the block to append
+ */
+export declare function getMissingVariables(existing: string, name: string): string;
+/**
+ * Smart append to main.tf - only add if API Gateway resource is missing
+ */
+export declare function appendMain(existing: string): string;
+/**
+ * Smart append to outputs.tf - only add if api_endpoint output is missing
+ */
+export declare function appendOutputs(existing: string): string;
+/**
+ * Full templates for new files
+ */
+export declare const templates: {
+    providers: string;
+    variables: (name: string) => string;
+    main: string;
+    outputs: string;
+};

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

@@ -0,0 +1,309 @@
+/**
+ * Smart Terraform file handling - append missing blocks
+ */
+/**
+ * Check if content has AWS provider configured
+ */
+export function hasAwsProvider(content) {
+    return /source\s*=\s*["']hashicorp\/aws["']/.test(content);
+}
+/**
+ * Check if a variable exists in the content
+ */
+export function hasVariable(content, name) {
+    const regex = new RegExp(`variable\\s+["']${name}["']`, "i");
+    return regex.test(content);
+}
+/**
+ * Check if a resource of a given type exists
+ */
+export function hasResource(content, type) {
+    const regex = new RegExp(`resource\\s+["']${type}["']`, "i");
+    return regex.test(content);
+}
+/**
+ * Check if an output exists in the content
+ */
+export function hasOutput(content, name) {
+    const regex = new RegExp(`output\\s+["']${name}["']`, "i");
+    return regex.test(content);
+}
+/**
+ * Providers template
+ */
+const PROVIDERS_BLOCK = `
+# Elysian: AWS Provider Configuration
+terraform {
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "~> 6.0"
+    }
+  }
+}
+
+provider "aws" {
+  region = var.region
+}
+`;
+/**
+ * Smart append to providers.tf - only add if AWS provider is missing
+ */
+export function appendProviders(existing) {
+    if (hasAwsProvider(existing)) {
+        return existing; // Already has AWS provider
+    }
+    return existing + "\n" + PROVIDERS_BLOCK;
+}
+/**
+ * Get missing variables and return the block to append
+ */
+export function getMissingVariables(existing, name) {
+    const variables = {
+        region: `
+variable "region" {
+  type    = string
+  default = "eu-west-2"
+}`,
+        lambda_names: `
+variable "lambda_names" {
+  type    = list(string)
+  default = []
+}`,
+        api_routes: `
+variable "api_routes" {
+  type = map(object({
+    lambda_key      = string
+    route_key       = string
+    path_parameters = list(string)
+  }))
+  default = {}
+}`,
+        lambda_runtime: `
+variable "lambda_runtime" {
+  type    = string
+  default = "nodejs22.x"
+}`,
+        lambda_memory_size: `
+variable "lambda_memory_size" {
+  type    = number
+  default = 256
+}`,
+        lambda_timeout: `
+variable "lambda_timeout" {
+  type    = number
+  default = 30
+}`,
+        api_name: `
+	variable "api_name" {
+  type    = string
+  default = "${name}"
+}`,
+        tags: `
+variable "tags" {
+  type    = map(string)
+  default = {}
+}`,
+    };
+    const missing = [];
+    for (const [name, block] of Object.entries(variables)) {
+        if (!hasVariable(existing, name)) {
+            missing.push(block);
+        }
+    }
+    if (missing.length === 0) {
+        return existing;
+    }
+    return existing + "\n# Elysian: Required Variables" + missing.join("");
+}
+/**
+ * Main resources template
+ */
+const MAIN_RESOURCES = `
+# Elysian: Lambda and API Gateway Resources
+
+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" "elysian" {
+  name          = var.api_name
+  protocol_type = "HTTP"
+  tags          = var.tags
+}
+
+# IAM Role for Lambda
+resource "aws_iam_role" "elysian_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" "elysian_lambda_basic" {
+  role       = aws_iam_role.elysian_lambda.name
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
+}
+
+# Lambda Functions
+resource "aws_lambda_function" "elysian" {
+  for_each = local.lambda_functions
+
+  filename         = each.value.filename
+  function_name    = each.key
+  role             = aws_iam_role.elysian_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" "elysian" {
+  for_each = local.lambda_functions
+
+  api_id                 = aws_apigatewayv2_api.elysian.id
+  integration_type       = "AWS_PROXY"
+  integration_uri        = aws_lambda_function.elysian[each.key].invoke_arn
+  integration_method     = "POST"
+  payload_format_version = "2.0"
+}
+
+# Lambda Permissions
+resource "aws_lambda_permission" "elysian_apigateway" {
+  for_each = local.lambda_functions
+
+  statement_id  = "AllowAPIGateway"
+  action        = "lambda:InvokeFunction"
+  function_name = aws_lambda_function.elysian[each.key].function_name
+  principal     = "apigateway.amazonaws.com"
+  source_arn    = "\${aws_apigatewayv2_api.elysian.execution_arn}/*/*"
+}
+
+# API Gateway Routes
+resource "aws_apigatewayv2_route" "elysian" {
+  for_each = var.api_routes
+
+  api_id    = aws_apigatewayv2_api.elysian.id
+  route_key = each.value.route_key
+  target    = "integrations/\${aws_apigatewayv2_integration.elysian[each.value.lambda_key].id}"
+}
+
+# API Gateway Stage
+resource "aws_apigatewayv2_stage" "elysian" {
+  api_id      = aws_apigatewayv2_api.elysian.id
+  name        = "$default"
+  auto_deploy = true
+  tags        = var.tags
+}
+`;
+/**
+ * Smart append to main.tf - only add if API Gateway resource is missing
+ */
+export function appendMain(existing) {
+    // Check for our specific resource or any API Gateway
+    if (hasResource(existing, "aws_apigatewayv2_api") ||
+        hasResource(existing, "aws_lambda_function")) {
+        return existing; // Already has Lambda/API Gateway resources
+    }
+    return existing + MAIN_RESOURCES;
+}
+/**
+ * Outputs template
+ */
+const OUTPUTS_BLOCK = `
+# Elysian: API Endpoint Output
+output "api_endpoint" {
+  description = "API Gateway endpoint URL"
+  value       = aws_apigatewayv2_stage.elysian.invoke_url
+}
+`;
+/**
+ * Smart append to outputs.tf - only add if api_endpoint output is missing
+ */
+export function appendOutputs(existing) {
+    if (hasOutput(existing, "api_endpoint")) {
+        return existing;
+    }
+    return existing + OUTPUTS_BLOCK;
+}
+/**
+ * Full templates for new files
+ */
+export const templates = {
+    providers: PROVIDERS_BLOCK.trim() + "\n",
+    variables: (name) => `# Elysian: Terraform Variables
+
+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 = "nodejs22.x"
+}
+
+variable "lambda_memory_size" {
+  type    = number
+  default = 256
+}
+
+variable "lambda_timeout" {
+  type    = number
+  default = 30
+}
+
+variable "api_name" {
+  type    = string
+  default = "${name}"
+}
+
+variable "tags" {
+  type    = map(string)
+  default = {}
+}
+`,
+    main: MAIN_RESOURCES.trim() + "\n",
+    outputs: `# Elysian: Outputs
+
+output "api_endpoint" {
+  description = "API Gateway endpoint URL"
+  value       = aws_apigatewayv2_stage.elysian.invoke_url
+}
+`,
+};

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

@@ -1,12 +1,7 @@
 /**
- * Init command - Initialize a new elysian project
+ * Init command - Interactive wizard to initialize elysian projects
  */
 export declare const initCommand: import("citty").CommandDef<{
-    name: {
-        type: "string";
-        description: string;
-        default: string;
-    };
     force: {
         type: "boolean";
         description: string;