@flightdev/adapter-aws 0.0.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Flight Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,167 @@
+# @flight-framework/adapter-aws
+
+AWS Lambda deployment adapter for Flight Framework. Deploy to Lambda with API Gateway or Lambda URLs.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [Deployment Options](#deployment-options)
+- [Build Output](#build-output)
+- [Deployment](#deployment)
+- [License](#license)
+
+---
+
+## Installation
+
+```bash
+npm install @flight-framework/adapter-aws
+```
+
+---
+
+## Quick Start
+
+```typescript
+// flight.config.ts
+import { defineConfig } from '@flight-framework/core';
+import aws from '@flight-framework/adapter-aws';
+
+export default defineConfig({
+    adapter: aws(),
+});
+```
+
+---
+
+## Configuration
+
+```typescript
+aws({
+    // Lambda runtime
+    runtime: 'nodejs20.x',
+    
+    // Memory allocation (MB)
+    memory: 512,
+    
+    // Timeout (seconds)
+    timeout: 30,
+    
+    // Architecture
+    architecture: 'arm64',  // or 'x86_64'
+    
+    // Region
+    region: 'us-east-1',
+    
+    // Use Lambda URLs (simpler, no API Gateway)
+    lambdaUrl: true,
+    
+    // Streaming responses
+    streaming: true,
+});
+```
+
+---
+
+## Deployment Options
+
+### Lambda Function URLs
+
+Simplest option, no API Gateway needed:
+
+```typescript
+aws({
+    lambdaUrl: true,
+});
+```
+
+### API Gateway HTTP API
+
+For custom domains and API features:
+
+```typescript
+aws({
+    apiGateway: 'http',  // HTTP API (v2)
+});
+```
+
+### API Gateway REST API
+
+Full control with request/response transformations:
+
+```typescript
+aws({
+    apiGateway: 'rest',  // REST API (v1)
+});
+```
+
+---
+
+## Build Output
+
+```
+.aws/
+├── lambda/
+│   ├── index.mjs        # Lambda handler
+│   └── chunks/          # Code-split chunks
+├── static/              # S3 static assets
+└── template.yaml        # SAM template (optional)
+```
+
+---
+
+## Deployment
+
+### AWS SAM
+
+```bash
+# Install SAM CLI
+brew install aws-sam-cli
+
+# Build
+npm run build
+
+# Deploy
+sam deploy --guided
+```
+
+### SST (Recommended)
+
+```typescript
+// sst.config.ts
+export default {
+    config() {
+        return { name: 'my-flight-app', region: 'us-east-1' };
+    },
+    stacks(app) {
+        app.stack(({ stack }) => {
+            const site = new SsrSite(stack, 'Site', {
+                path: '.',
+            });
+            stack.addOutputs({ URL: site.url });
+        });
+    },
+};
+```
+
+### Terraform
+
+```hcl
+resource "aws_lambda_function" "app" {
+  filename         = ".aws/lambda.zip"
+  function_name    = "my-flight-app"
+  role             = aws_iam_role.lambda.arn
+  handler          = "index.handler"
+  runtime          = "nodejs20.x"
+  memory_size      = 512
+  timeout          = 30
+}
+```
+
+---
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import { FlightAdapter } from '@flightdev/core/adapters';
+
+/**
+ * Flight Adapter - AWS
+ *
+ * Deploy to AWS Lambda, Amplify Hosting, or API Gateway.
+ * Full AWS ecosystem integration with zero lock-in.
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from '@flightdev/core';
+ * import aws from '@flightdev/adapter-aws';
+ *
+ * export default defineConfig({
+ *   adapter: aws({
+ *     target: 'lambda', // 'lambda' | 'amplify' | 'lambda-streaming'
+ *     region: 'us-east-1',
+ *   }),
+ * });
+ * ```
+ */
+
+interface AWSAdapterOptions {
+    /**
+     * Deployment target
+     * - 'lambda': Standard AWS Lambda
+     * - 'lambda-streaming': Lambda with response streaming (Node 18+)
+     * - 'amplify': AWS Amplify Hosting
+     * @default 'lambda'
+     */
+    target?: 'lambda' | 'lambda-streaming' | 'amplify';
+    /**
+     * AWS Region
+     * @default 'us-east-1'
+     */
+    region?: string;
+    /**
+     * Lambda memory size in MB
+     * @default 1024
+     */
+    memory?: number;
+    /**
+     * Lambda timeout in seconds
+     * @default 10
+     */
+    timeout?: number;
+    /**
+     * Lambda architecture
+     * @default 'x86_64'
+     */
+    architecture?: 'x86_64' | 'arm64';
+    /**
+     * Enable Lambda@Edge for CloudFront
+     * @default false
+     */
+    edge?: boolean;
+}
+declare function awsAdapter(options?: AWSAdapterOptions): FlightAdapter;
+
+export { type AWSAdapterOptions, awsAdapter, awsAdapter as default };

package/dist/index.js

@@ -0,0 +1,245 @@
+// src/index.ts
+import { createAdapter } from "@flightdev/core/adapters";
+function awsAdapter(options = {}) {
+  const {
+    target = "lambda",
+    region = "us-east-1",
+    memory = 1024,
+    timeout = 10,
+    architecture = "x86_64",
+    edge = false
+  } = options;
+  return createAdapter({
+    name: "@flightdev/adapter-aws",
+    async adapt(builder) {
+      const { outDir, log } = builder;
+      log.info(`Generating AWS ${target} output...`);
+      switch (target) {
+        case "amplify":
+          await adaptForAmplify(builder, options);
+          break;
+        case "lambda-streaming":
+          await adaptForLambdaStreaming(builder, options);
+          break;
+        default:
+          await adaptForLambda(builder, options);
+      }
+      await builder.copy(`${outDir}/client`, `${outDir}/public`);
+      const samTemplate = generateSAMTemplate({ region, memory, timeout, architecture, edge });
+      await builder.writeFile("template.yaml", samTemplate);
+      log.info("Created SAM template.yaml");
+      log.info(`
+AWS adapter complete!
+
+Output: ${outDir}
+
+To deploy with SAM:
+  sam build
+  sam deploy --guided
+
+To deploy with CDK:
+  cdk deploy
+
+To deploy with Amplify:
+  amplify push
+`);
+    },
+    emulate: () => ({
+      env: {
+        AWS_REGION: region,
+        AWS_LAMBDA_FUNCTION_NAME: "flight-local",
+        _HANDLER: "index.handler"
+      }
+    }),
+    supports: {
+      read: () => true,
+      streaming: () => target === "lambda-streaming",
+      websockets: () => false,
+      node: () => true,
+      edge: () => edge
+    }
+  });
+}
+async function adaptForLambda(builder, _options) {
+  const { log } = builder;
+  log.info("Generating Lambda handler...");
+  const handler = `
+// Flight + AWS Lambda Handler
+// Compatible with API Gateway v2 (HTTP API) and v1 (REST API)
+
+export const handler = async (event, context) => {
+  const path = event.rawPath || event.path || '/';
+  const method = event.requestContext?.http?.method || event.httpMethod || 'GET';
+  const headers = event.headers || {};
+  const body = event.body;
+  const isBase64 = event.isBase64Encoded;
+  
+  // Create Web API Request
+  const url = new URL(path, 'http://localhost');
+  if (event.queryStringParameters) {
+    Object.entries(event.queryStringParameters).forEach(([k, v]) => {
+      url.searchParams.set(k, v);
+    });
+  }
+  
+  const request = new Request(url.toString(), {
+    method,
+    headers,
+    body: body ? (isBase64 ? Buffer.from(body, 'base64') : body) : undefined,
+  });
+  
+  // TODO: Integrate with Flight render engine
+  
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'text/html',
+    },
+    body: \`
+      <!DOCTYPE html>
+      <html>
+        <head><title>Flight on AWS Lambda</title></head>
+        <body>
+          <h1>Flight \u2708\uFE0F + AWS Lambda</h1>
+          <p>Path: \${path}</p>
+          <p>Region: \${context.invokedFunctionArn?.split(':')[3] || 'local'}</p>
+        </body>
+      </html>
+    \`,
+    isBase64Encoded: false,
+  };
+};
+`;
+  await builder.writeFile(".output/server/index.mjs", handler);
+  log.info("Created .output/server/index.mjs");
+}
+async function adaptForLambdaStreaming(builder, _options) {
+  const { log } = builder;
+  log.info("Generating Lambda Streaming handler...");
+  const handler = `
+// Flight + AWS Lambda Streaming Handler
+// Uses Lambda Web Adapter for streaming responses
+
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+
+export const handler = awslambda.streamifyResponse(async (event, responseStream, context) => {
+  const path = event.rawPath || '/';
+  
+  // Set response metadata
+  const metadata = {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'text/html',
+      'Transfer-Encoding': 'chunked',
+    },
+  };
+  
+  responseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
+  
+  // TODO: Integrate with Flight render engine for streaming
+  
+  responseStream.write('<!DOCTYPE html><html><body>');
+  responseStream.write('<h1>Flight \u2708\uFE0F + Lambda Streaming</h1>');
+  responseStream.write('<p>Path: ' + path + '</p>');
+  responseStream.write('</body></html>');
+  responseStream.end();
+});
+`;
+  await builder.writeFile(".output/server/index.mjs", handler);
+  log.info("Created streaming handler");
+}
+async function adaptForAmplify(builder, _options) {
+  const { log } = builder;
+  log.info("Generating Amplify configuration...");
+  const amplifyConfig = {
+    version: 1,
+    applications: [{
+      frontend: {
+        phases: {
+          build: {
+            commands: ["npm ci", "npm run build"]
+          }
+        },
+        artifacts: {
+          baseDirectory: ".output/public",
+          files: ["**/*"]
+        },
+        cache: {
+          paths: ["node_modules/**/*"]
+        }
+      }
+    }]
+  };
+  await builder.writeFile("amplify.yml", JSON.stringify(amplifyConfig, null, 2));
+  const handler = `
+export async function handler(event) {
+  const path = event.rawPath || '/';
+  
+  return {
+    statusCode: 200,
+    headers: { 'Content-Type': 'text/html' },
+    body: '<h1>Flight + Amplify</h1>',
+  };
+}
+`;
+  await builder.writeFile(".output/server/index.mjs", handler);
+  log.info("Created Amplify handler");
+}
+function generateSAMTemplate(options) {
+  return `# Flight + AWS SAM Template
+# Generated by @flightdev/adapter-aws
+
+AWSTemplateFormatVersion: '2010-09-09'
+Transform: AWS::Serverless-2016-10-31
+Description: Flight Framework Application
+
+Globals:
+  Function:
+    Timeout: ${options.timeout}
+    MemorySize: ${options.memory}
+    Runtime: nodejs20.x
+    Architectures:
+      - ${options.architecture}
+
+Resources:
+  FlightFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      Handler: index.handler
+      CodeUri: .output/server/
+      Description: Flight Framework SSR Handler
+      Events:
+        Api:
+          Type: HttpApi
+          Properties:
+            Path: /{proxy+}
+            Method: ANY
+        Root:
+          Type: HttpApi
+          Properties:
+            Path: /
+            Method: ANY
+
+  StaticAssets:
+    Type: AWS::S3::Bucket
+    Properties:
+      BucketName: !Sub '\${AWS::StackName}-assets'
+      PublicAccessBlockConfiguration:
+        BlockPublicAcls: false
+      WebsiteConfiguration:
+        IndexDocument: index.html
+
+Outputs:
+  ApiUrl:
+    Description: "API Gateway endpoint URL"
+    Value: !Sub "https://\${ServerlessHttpApi}.execute-api.\${AWS::Region}.amazonaws.com/"
+  FunctionArn:
+    Description: "Lambda Function ARN"
+    Value: !GetAtt FlightFunction.Arn
+`;
+}
+export {
+  awsAdapter,
+  awsAdapter as default
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@flightdev/adapter-aws",
+  "version": "0.0.6",
+  "description": "AWS adapter for Flight Framework - deploy to Lambda, Amplify, or API Gateway",
+  "keywords": [
+    "flight",
+    "adapter",
+    "aws",
+    "lambda",
+    "amplify",
+    "serverless"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@flightdev/core": "0.6.7"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "rimraf": "^6.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}