Run mion as a Bun Http Server

Run mion type safe APIs using bun's native http server to take advantage of bun's performance. Check the benchmarks section for results.

npm install
npm i @mionkit/bun

Start a Bun Server

init Bun
import {BunHttpOptions, startBunServer} from '@mionkit/bun';
import './myApi.routes';

// init a bun server with options specific for bun
const bunOptions: Partial<BunHttpOptions> = {port: 3000};
startBunServer(bunOptions);
./myApi.routes.ts
import {RpcError} from '@mionkit/core';
import {RouterOptions, initMionRouter, headersHook, hook, route} from '@mionkit/router';

export type User = {id: string; name: string; surname: string};

// set options and init router
export const routerOptions: Partial<RouterOptions> = {prefix: 'api/v1'};
export const myApi = initMionRouter(
    // all function parameters will be automatically validated before the function is called
    {
        auth: headersHook('authorization', (ctx, token: string): void => {
            if (!token) throw new RpcError({statusCode: 401, message: 'Not Authorized'});
        }),
        users: {
            sayHello: route((ctx, user: User): string => `Hello ${user.name} ${user.surname}`),
        },
        log: hook((ctx): void => console.log(Date.now(), ctx.path, ctx.response.statusCode), {runOnError: true}),
    },
    routerOptions
);

// Export the type of the Api (used by the client)
export type MyApi = typeof myApi;
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!

Run Types Loader

mion requires extending typescript compiler to emit the runtime type metadata. This can be done either following the quick start guide and compiling typescript before running your application with bun. Or either using the included run types loader so bun can emit the runtime type metadata on the fly.

To use bun's loader and emit runtime type metadata on the fly, you need to create a bun-preload.ts file in the root of your project as follows:

import {plugin} from 'bun';
import {runTypesLoader} from '@mionkit/bun/loader/runtypes-loader';
import {join} from 'path';

const tsConfig = join(__dirname, './tsconfig.json');

plugin(runTypesLoader({tsConfig}));
Important!

Please note bun is still new and at the moment SourceMaps are not working correctly when using the bun Run Types Loader. The issue has been reported into bun's repo here

We recommend compiling first to js using tsc and then run in Bun!

Type Reference

RouterOptions

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 */
    useValidation: boolean;
    /** Enables serialization/deserialization */
    useSerialization: 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;
    /** client routes are initialized by default */
    skipClientRoutes: boolean;
}

BunHttpOptions

export interface BunHttpOptions {
    port: number;
    /** Bun's native Server Options */
    options: Omit<Serve, 'fetch' | 'error'>;
    /** Set of default response header to add to every response*/
    defaultResponseHeaders: Record<string, string>;
    /**
     * 256KB by default, same as lambda payload
     * @link https://docs.aws.amazon.com/lambda/latest/operatorguide/payload.html
     * */
    maxBodySize: number; // default 256KB
}
Table of Contents