AWS Lambda Handler

AWS Lambda handler for mion APIs! It is just an small wrapper around the mion router.

In contrast to many traditional node.js frameworks that are adapted to work with AWS Lambda but still internally need to use node's http module, this handler does not use any http functionality and just pass the APIGatewayEvent down to the mion router. This results in better performance and faster cold starts.

Init AWS Lambda

init AWS Lambda
import {AwsLambdaOptions, awsLambdaHandler, setAwsLambdaOpts} from '@mionkit/serverless';
import './myApi.routes';

// set options specific for aws lambda
const awsOptions: Partial<AwsLambdaOptions> = {};

// export AWS Lambda Handler
export const handler = awsLambdaHandler;
import {RpcError} from '@mionkit/core';
import {Routes, RouterOptions, initRouter, registerRoutes} from '@mionkit/router';
import {clientRoutes} from '@mionkit/common';

export type User = {id: string; name: string; surname: string};
export type Order = {id: string; date: Date; userId: string; totalUSD: number};

export const routes = {
    auth: {
        headerName: 'authorization',
        hook: (ctx, token: string): void => {
            if (!token) throw new RpcError({statusCode: 401, message: 'Not Authorized', name: ' Not Authorized'});
    users: {
        getById: (ctx, id: string): User => ({id, name: 'John', surname: 'Smith'}),
        delete: (ctx, id: string): string => id,
        create: (ctx, newUser: Omit<User, 'id'>): User => ({id: 'USER-123', ...newUser}),
    orders: {
        getById: (ctx, id: string): Order => ({id, date: new Date(), userId: 'USER-123', totalUSD: 120}),
        delete: (ctx, id: string): string => id,
        create: (ctx, newOrder: Omit<Order, 'id'>): Order => ({id: 'ORDER-123', ...newOrder}),
    utils: {
        sum: (ctx, a: number, b: number): number => a + b,
        sayHello: (ctx, user: User): string => `Hello ${} ${user.surname}`,
    log: {
        forceRunOnError: true,
        hook: (ctx): void => {
            const now =;
            console.log(now, ctx.path, ctx.response.statusCode);
            if (ctx.request.internalErrors.length) console.error(now, ctx.path, ctx.request.internalErrors);
} satisfies Routes;

// set options and init router
export const routerOptions: Partial<RouterOptions> = {prefix: 'api/v1'};

// register routes and exporting the type of the Api (used by the client)
export const myApi = registerRoutes(routes);
export type MyApi = typeof myApi;

// register routes required by client
// these routes serve metadata required for validation and serialization on the client
Quick Tip:
It is a good idea to split the routes definition and server initialization code so mion can be easily configured to run on multiple environments!

Type Reference


Basic options to configure mion router. These options are independent of the environment mion is being used (server or serverless).

export interface RouterOptions<Req = any, SharedData = any> extends CoreOptions {
    /** prefix for all routes, i.e: api/v1.
     * path separator is added between the prefix and the route */
    prefix: string;
    /** suffix for all routes, i.e: .json.
     * Not path separators is added between the route and the suffix */
    suffix: string;
    /** Transform the path before finding a route */
    pathTransform?: (request: Req, path: string) => string;
    /** factory function to initialize shared call context data */
    sharedDataFactory?: SharedDataFactory<SharedData>;
    /** enable automatic parameter validation, defaults to true */
    enableValidation: boolean;
    /** Enables serialization/deserialization */
    enableSerialization: boolean;
    /** Reflection and Deepkit Serialization-Validation options */
    reflectionOptions: ReflectionOptions;
    /** Custom JSON parser, defaults to Native js JSON */
    bodyParser: JsonParser;
    /** Used to return public data structure when adding routes */
    getPublicRoutesData: boolean;
    /** automatically generate and uuid */
    autoGenerateErrorId: boolean;


Most of the options to configure the handler must be set in aws.

export interface AwsLambdaOptions {
    /** Set of default response header to add to every response*/
    defaultResponseHeaders: Record<string, string>;