Deploy to AWS Lambda

npm create metascript@latest my-lambda -- --template lambda
cd my-lambda

my-lambda/
├── src/
│   ├── handler.ms       # Lambda handlers
│   └── lib/             # Shared code
├── build.ms             # Build config
├── template.yaml        # SAM template
└── package.json

import { lambda, APIGatewayEvent, Context } from "@metascript/lambda"

export const hello = lambda.handler(
  async (event: APIGatewayEvent, context: Context) => {
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: "Hello from MetaScript!",
        requestId: context.awsRequestId,
      }),
    }
  }
)

import { lambda, APIGatewayEvent } from "@metascript/lambda"

@derive(Serialize, Deserialize)
class CreateUserRequest {
  name: string
  email: string
}

@derive(Serialize)
class CreateUserResponse {
  id: string
  name: string
}

export const createUser = lambda.handler(
  async (event: APIGatewayEvent) => {
    // Type-safe body parsing
    const body = lambda.parseBody<CreateUserRequest>(event)

    const user = await db.users.create({
      name: body.name,
      email: body.email,
    })

    return lambda.json<CreateUserResponse>({
      id: user.id,
      name: user.name,
    })
  }
)

import { lambda, HttpError } from "@metascript/lambda"

export const getUser = lambda.handler(async (event) => {
  const id = event.pathParameters?.id

  if (!id) {
    throw new HttpError(400, "Missing user ID")
  }

  const user = await db.users.find(id)

  if (!user) {
    throw new HttpError(404, "User not found")
  }

  return lambda.json(user)
})

# template.yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Globals:
  Function:
    Timeout: 10
    MemorySize: 128
    Runtime: provided.al2
    Architectures:
      - arm64

Resources:
  HelloFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: bootstrap
      CodeUri: dist/
      Events:
        Api:
          Type: Api
          Properties:
            Path: /hello
            Method: get

// build.ms
export const package = {
  name: "my-lambda",
  version: "1.0.0",
  backends: ["c"],
};

export const deps = {};

export const deps_c = {
  // Native dependencies if needed
};

# Build and start local API
msc lambda dev

# Or use SAM
sam local start-api

# Build optimized binary
msc build --target=c --release

# Package for Lambda
msc lambda package

# Deploy with SAM
sam deploy --guided

# Or direct to Lambda
msc lambda deploy --function my-function

import { lambda, Middleware } from "@metascript/lambda"

const auth: Middleware = async (event, context, next) => {
  const token = event.headers.Authorization

  if (!token) {
    return { statusCode: 401, body: "Unauthorized" }
  }

  // Add user to context
  context.user = await validateToken(token)

  return next()
}

const logging: Middleware = async (event, context, next) => {
  const start = Date.now()
  const result = await next()
  console.log(`${event.path} took ${Date.now() - start}ms`)
  return result
}

export const handler = lambda
  .use(logging)
  .use(auth)
  .handler(async (event, context) => {
    return lambda.json({ user: context.user })
  })

import { lambda } from "@metascript/lambda"
import { db } from "./db"

// Connection reused across warm invocations
let connection: Connection | null = null

const getConnection = async () => {
  if (!connection) {
    connection = await db.connect(process.env.DATABASE_URL)
  }
  return connection
}

export const handler = lambda.handler(async (event) => {
  const conn = await getConnection()
  const users = await conn.query("SELECT * FROM users")
  return lambda.json(users)
})

import { lambda, SQSEvent } from "@metascript/lambda"

export const processQueue = lambda.handler(
  async (event: SQSEvent) => {
    for (const record of event.Records) {
      const body = JSON.parse(record.body)
      await processMessage(body)
    }

    return { batchItemFailures: [] }
  }
)

Architectures:
  - arm64

# Check binary size
ls -lh dist/bootstrap

# Should be <2MB for most functions

ProvisionedConcurrencyConfig:
  ProvisionedConcurrentExecutions: 5

SnapStart:
  ApplyOn: PublishedVersions