ƒun

Use createFunction from @vercel/fun to start a local serverless execution environment that mimics AWS Lambda. You can specify the function's source code (via Directory or ZipFile), the entry point Handler, the Runtime, environment variables, and MemorySize.

Once created, the returned function instance can be invoked by passing a payload. To clean up processes and shut down the API server, call fn.destroy().

import { createFunction } from '@vercel/fun';

async function main() {
	// Starts up the necessary server to be able to invoke the function
	const fn = await createFunction({
		Code: {
			// `ZipFile` works, or an already unzipped directory may be specified
			Directory: __dirname + '/example'
		},
		Handler: 'index.handler',
		Runtime: 'nodejs8.10',
		Environment: {
			Variables: {
				HELLO: 'world'
			}
		},
		MemorySize: 512
	});

	// Invoke the function with a custom payload
	const res = await fn({ hello: 'world' });

	console.log(res);

	// Clean up processes and shut down the API server
	await fn.destroy();
}

main().catch(console.error);

ƒun supports a wide range of runtimes. Use the corresponding string identifier in the Runtime option of createFunction:

Node.js

• nodejs: Uses the system node binary
• nodejs6.10: Uses a downloaded Node v6.10.0 binary
• nodejs8.10: Uses a downloaded Node v8.10.0 binary
• nodejs10.x: Uses a downloaded Node v10.15.3 binary
• nodejs12.x: Uses a downloaded Node v12.22.7 binary
• nodejs14.x: Uses a downloaded Node v14.18.1 binary

Python

• python: Uses the system python binary
• python2.7: Uses a downloaded Python v2.7.12 binary
• python3: Uses the system python3 binary (or fallback to python)
• python3.6: Uses a downloaded Python v3.6.8 binary
• python3.7: Uses a downloaded Python v3.7.2 binary

Other

• go1.x: For Go functions (binary must be compiled for your platform)
• provided: For custom runtimes
• executable: For executables powered by Fluid compute

Use createFunction(params: LambdaParams) to initialize a new Lambda instance. This function selects the appropriate provider (defaulting to 'native') and runtime based on the provided parameters. It also handles environment variable validation, ensuring no reserved AWS Lambda environment variables are included.

Key behaviors:

• Runtime Initialization: Automatically calls initializeRuntime for the specified runtime.
• Environment Validation: Throws a ValidationError if any keys in params.Environment.Variables match the reserved AWS list (e.g., _HANDLER, AWS_REGION, TZ).
• Code Extraction: If params.Code.ZipFile is provided, the function is automatically unzipped to a temporary directory.
• Returned Object: Returns a Lambda function that can be called directly with a payload, or used via its attached properties like .invoke() and .destroy().

import { createFunction } from '@vercel/fun';

const fn = await createFunction({
  FunctionName: 'my-function',
  Runtime: 'nodejs18.x', // Example runtime
  Provider: 'native',
  Code: { ZipFile: buffer },
  Environment: {
    Variables: {
      MY_VAR: 'hello'
    }
  }
});

// You can call the function directly
const result = await fn({ key: 'value' });

When dealing with failures during Lambda runtime initialization or execution, you can use the LambdaError class to wrap error details. This class allows you to reconstruct an error from a payload containing an error message, an error type, and a stack trace (either as a single string or an array of strings).

Constructing a LambdaError with a payload ensures that the name and stack properties are correctly set to match the original runtime error, which is useful for consistent error reporting and troubleshooting.

import { LambdaError } from './errors';

const error = new LambdaError({
  errorMessage: 'Database connection failed',
  errorType: 'RuntimeError',
  stackTrace: ['Error: connection timeout at line 10', 'at main.ts:5:1']
});

console.log(error.name);    // 'RuntimeError'
console.log(error.message); // 'Database connection failed'
console.log(error.stack);   // 'RuntimeError: Database connection failed\nError: connection timeout at line 10\nat main.ts:5:1'

The LambdaParams interface defines the configuration for a Lambda function. Use this to specify the code source, runtime environment, and resource constraints.

Key Configuration Options:

• Code: Must provide either a ZipFile (as a Buffer or string) or a Directory path.
• Runtime: Specifies the execution environment (e.g., nodejs, python3.7, go1.x, provided).
• MemorySize: The amount of memory in MB. Must be a multiple of 64 MB. Increasing memory also increases CPU allocation. Default is 128 MB.
• Timeout: Execution time limit in seconds. Default is 3 seconds; maximum is 900 seconds.
• Provider: Choose between native or docker.
• Environment: An object containing Variables for environment variables.
• AccessKeyId & SecretAccessKey: AWS credentials used for authentication via the AWS SDK.

const params: LambdaParams = {
  FunctionName: 'my-function',
  Code: { Directory: './dist' },
  Handler: 'index.handler',
  Runtime: 'nodejs12.x',
  MemorySize: 512,
  Timeout: 30,
  Environment: { Variables: { NODE_ENV: 'production' } }
};