Interface MojoContext

Context class.

Hierarchy

Indexable

[key: string]: any

Properties

_flash: undefined | SessionData = undefined
_nestedHelpersCache: Record<string, ScopedNestedHelpers> = {}
_params: undefined | Params = undefined
_session: undefined | Record<string, any> = undefined
_ws: null | WeakRef<WebSocket> = null
app: App

Application this context belongs to.

backend: BackendInfo

Backend information for server that received the request.

Example

// Backend name (usually "server", "cgi", or "mock")
const {name} = ctx.backend;

// Use low level Node.js APIs with "server" backend
const {res} = ctx.backend;
res.writeHead(200);
res.end('Hello World!');
content: Record<string, string> = ...

Partial content. Always returns at least an empty string, even for sections that have not been defined with ctx.contentFor().

Example

// Get content for "head" section
const head = ctx.content.head;
currentRoute: (() => null | string)

Type declaration

    • (): null | string
    • Returns null | string

exception: ((error: Error) => Promise<boolean>)

Type declaration

    • (error: Error): Promise<boolean>
    • Parameters

      • error: Error

      Returns Promise<boolean>

exceptionFormat: string

Format for HTTP exceptions ("html", "json", or "txt").

htmlException: ((error: Error) => Promise<boolean>)

Type declaration

    • (error: Error): Promise<boolean>
    • Parameters

      • error: Error

      Returns Promise<boolean>

htmlNotFound: (() => Promise<boolean>)

Type declaration

    • (): Promise<boolean>
    • Returns Promise<boolean>

httpException: ((error: any) => Promise<boolean>)

Type declaration

    • (error: any): Promise<boolean>
    • Parameters

      • error: any

      Returns Promise<boolean>

include: ((options: MojoRenderOptions, stash: Record<string, any>) => Promise<null | SafeString>)

Type declaration

inspect: ((object: Record<string, any>, options: InspectOptions) => string)

Type declaration

    • (object: Record<string, any>, options: InspectOptions): string
    • Parameters

      • object: Record<string, any>
      • options: InspectOptions

      Returns string

jsonException: ((error: Error) => Promise<boolean>)

Type declaration

    • (error: Error): Promise<boolean>
    • Parameters

      • error: Error

      Returns Promise<boolean>

jsonMode: boolean = false

WebSocket JSON mode.

jsonNotFound: (() => Promise<boolean>)

Type declaration

    • (): Promise<boolean>
    • Returns Promise<boolean>

Logger with request id.

Example

// Pass logger with context to model
const log = ctx.log;
ctx.model.users.create({name: 'kraih'}, log);
notFound: (() => Promise<boolean>)

Type declaration

    • (): Promise<boolean>
    • Returns Promise<boolean>

plan: null | Plan = null

Router dispatch plan.

proxyGet: ((url: string | URL, config: UserAgentRequestOptions) => Promise<void>)

Type declaration

proxyPost: ((url: string | URL, config: UserAgentRequestOptions) => Promise<void>)

Type declaration

proxyRequest: ((config: UserAgentRequestOptions) => Promise<void>)

Type declaration

HTTP request information.

Example

// Extract request information
const id = ctx.req.requestId;
const method = ctx.req.method;
const baseURL = ctx.req.baseURL;
const url = ctx.req.url;
const query = ctx.req.query;
const info = ctx.req.userinfo;
const agent = ctx.req.get('User-Agent');
const buffer = await ctx.req.buffer();
const text = await ctx.req.text();
const form = await ctx.req.form();
const value = await ctx.req.json();
const html = await ctx.req.html();
const xml = await ctx.req.xml();

HTTP response information.

Example

// Force file download by setting a response header
ctx.res.set('Content-Disposition', 'attachment; filename=foo.png;');

// Make sure response is cached correctly
ctx.res.set('Cache-Control', 'public, max-age=300');
ctx.res.headers.append('Vary', 'Accept-Encoding');
stash: Record<string, any> = {}

Non-persistent data storage and exchange for the current request.

tags: MojoTags
txtException: ((error: Error) => Promise<boolean>)

Type declaration

    • (error: Error): Promise<boolean>
    • Parameters

      • error: Error

      Returns Promise<boolean>

txtNotFound: (() => Promise<boolean>)

Type declaration

    • (): Promise<boolean>
    • Returns Promise<boolean>

websocketException: ((error: any) => Promise<boolean>)

Type declaration

    • (error: any): Promise<boolean>
    • Parameters

      • error: any

      Returns Promise<boolean>

Accessors

  • get config(): Record<string, any>
  • Application config shortcut.

    Example

    // Longer version
    const config = ctx.app.config;

    Returns Record<string, any>

  • get home(): default
  • Home directory shortcut.

    Example

    // Generate path
    const path = ctx.home.child('views', 'foo', 'bar.html.tmpl');

    Returns default

  • get isAccepted(): boolean
  • Check if WebSocket connection has been accepted.

    Returns boolean

  • get isEstablished(): boolean
  • Check if WebSocket connection has been established.

    Returns boolean

  • get isSessionActive(): boolean
  • Check if session is active.

    Returns boolean

  • get isWebSocket(): boolean
  • Check if HTTP request is a WebSocket handshake.

    Returns boolean

  • get models(): MojoModels
  • Model shortcut.

    Example

    // Access arbitrary model objects
    const db = await ctx.models.pg.db();

    Returns MojoModels

  • get ua(): UserAgent
  • HTTP/WebSocket user-agent shortcut.

    Returns UserAgent

  • get ws(): null | WebSocket
  • Established WebSocket connection.

    Returns null | WebSocket

Methods

  • Parameters

    • error: Error

    Returns void

  • Parameters

    Returns string

  • Select best possible representation for resource.

    Parameters

    • Optional allowed: string[]

    Returns null | string[]

  • Alias for emitter.on(eventName, listener).

    Since

    v0.1.26

    Parameters

    • eventName: string | symbol
    • listener: ((...args: any[]) => void)
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

  • Append partial content to ctx.content buffers.

    Example

    // Add content for "head" section
    await ctx.contentFor('head', '<link rel="icon" href="/static/favicon.ico">');

    Parameters

    Returns Promise<void>

  • Synchronously calls each of the listeners registered for the event namedeventName, in the order they were registered, passing the supplied arguments to each.

    Returns true if the event had listeners, false otherwise.

    const EventEmitter = require('events');
    const myEmitter = new EventEmitter();

    // First listener
    myEmitter.on('event', function firstListener() {
    console.log('Helloooo! first listener');
    });
    // Second listener
    myEmitter.on('event', function secondListener(arg1, arg2) {
    console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
    });
    // Third listener
    myEmitter.on('event', function thirdListener(...args) {
    const parameters = args.join(', ');
    console.log(`event with parameters ${parameters} in third listener`);
    });

    console.log(myEmitter.listeners('event'));

    myEmitter.emit('event', 1, 2, 3, 4, 5);

    // Prints:
    // [
    // [Function: firstListener],
    // [Function: secondListener],
    // [Function: thirdListener]
    // ]
    // Helloooo! first listener
    // event with parameters 1, 2 in second listener
    // event with parameters 1, 2, 3, 4, 5 in third listener

    Since

    v0.1.26

    Parameters

    • eventName: string | symbol
    • Rest ...args: any[]

    Returns boolean

  • Returns an array listing the events for which the emitter has registered listeners. The values in the array are strings or Symbols.

    const EventEmitter = require('events');
    const myEE = new EventEmitter();
    myEE.on('foo', () => {});
    myEE.on('bar', () => {});

    const sym = Symbol('symbol');
    myEE.on(sym, () => {});

    console.log(myEE.eventNames());
    // Prints: [ 'foo', 'bar', Symbol(symbol) ]

    Since

    v6.0.0

    Returns (string | symbol)[]

  • Data storage persistent only for the next request.

    Example

    // Show message after redirect
    const flash = await ctx.flash();
    flash.message = 'User created successfully!';
    await ctx.redirectTo('show_user', {values: {id: 23}});

    Returns Promise<Record<string, any>>

  • Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to defaultMaxListeners.

    Since

    v1.0.0

    Returns number

  • Handle WebSocket upgrade, used by servers.

    Parameters

    Returns void

  • Accept WebSocket connection and activate JSON mode.

    Example

    // Echo WebSocket messages
    ctx.json(async ws => {
    for await (const data of ws) {
    // Add a Futurama quote to JSON objects
    if (typeof data === 'object') {
    data.quote = 'Shut up and take my money!';
    await ws.send(data);
    }
    }
    });

    Parameters

    • fn: WebSocketHandler

    Returns MojoContext

  • Returns the number of listeners listening to the event named eventName.

    Since

    v3.2.0

    Parameters

    • eventName: string | symbol

      The name of the event being listened for

    Returns number

  • Returns a copy of the array of listeners for the event named eventName.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });
    console.log(util.inspect(server.listeners('connection')));
    // Prints: [ [Function] ]

    Since

    v0.1.26

    Parameters

    • eventName: string | symbol

    Returns Function[]

  • Alias for emitter.removeListener().

    Since

    v10.0.0

    Parameters

    • eventName: string | symbol
    • listener: ((...args: any[]) => void)
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

  • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventNameand listener will result in the listener being added, and called, multiple times.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. Theemitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Since

    v0.1.101

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args: any[]) => void)

      The callback function

        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

  • Adds a one-timelistener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. Theemitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Since

    v0.3.0

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args: any[]) => void)

      The callback function

        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

  • GET and POST parameters.

    Example

    // Get a specific parameter
    const params = await ctx.params();
    const foo = params.get('foo');

    // Ignore all empty parameters
    const params = await ctx.params({notEmpty: true});

    Parameters

    Returns Promise<Params>

  • Accept WebSocket connection.

    Example

    // Echo incoming WebSocket messages ctx.plain(async ws => { for await (const message of ws) { await ws.send(echo: ${message}); } });

    Parameters

    • fn: WebSocketHandler

    Returns MojoContext

  • Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventNameand listener will result in the listener being added, and called, multiple times.

    server.prependListener('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    Since

    v6.0.0

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args: any[]) => void)

      The callback function

        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

  • Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

    server.prependOnceListener('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    Since

    v6.0.0

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args: any[]) => void)

      The callback function

        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

  • Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

    const emitter = new EventEmitter();
    emitter.once('log', () => console.log('log once'));

    // Returns a new Array with a function `onceWrapper` which has a property
    // `listener` which contains the original listener bound above
    const listeners = emitter.rawListeners('log');
    const logFnWrapper = listeners[0];

    // Logs "log once" to the console and does not unbind the `once` event
    logFnWrapper.listener();

    // Logs "log once" to the console and removes the listener
    logFnWrapper();

    emitter.on('log', () => console.log('log persistently'));
    // Will return a new Array with a single function bound by `.on()` above
    const newListeners = emitter.rawListeners('log');

    // Logs "log persistently" twice
    newListeners[0]();
    emitter.emit('log');

    Since

    v9.4.0

    Parameters

    • eventName: string | symbol

    Returns Function[]

  • Send 302 redirect response.

    Example

    // Moved Permanently
    await ctx.redirect_to('some_route', {status: 301});

    Parameters

    • target: string
    • options: MojoURLOptions & {
          status?: number;
      } = {}

    Returns Promise<void>

  • Removes all listeners, or those of the specified eventName.

    It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

    Returns a reference to the EventEmitter, so that calls can be chained.

    Since

    v0.1.26

    Parameters

    • Optional event: string | symbol

    Returns MojoContext

  • Removes the specified listener from the listener array for the event namedeventName.

    const callback = (stream) => {
    console.log('someone connected!');
    };
    server.on('connection', callback);
    // ...
    server.removeListener('connection', callback);

    removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

    Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that anyremoveListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them fromemit() in progress. Subsequent events behave as expected.

    const myEmitter = new MyEmitter();

    const callbackA = () => {
    console.log('A');
    myEmitter.removeListener('event', callbackB);
    };

    const callbackB = () => {
    console.log('B');
    };

    myEmitter.on('event', callbackA);

    myEmitter.on('event', callbackB);

    // callbackA removes listener callbackB but it will still be called.
    // Internal listener array at time of emit [callbackA, callbackB]
    myEmitter.emit('event');
    // Prints:
    // A
    // B

    // callbackB is now removed.
    // Internal listener array [callbackA]
    myEmitter.emit('event');
    // Prints:
    // A

    Because listeners are managed using an internal array, calling this will change the position indices of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

    When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping')listener is removed:

    const ee = new EventEmitter();

    function pong() {
    console.log('pong');
    }

    ee.on('ping', pong);
    ee.once('ping', pong);
    ee.removeListener('ping', pong);

    ee.emit('ping');
    ee.emit('ping');

    Returns a reference to the EventEmitter, so that calls can be chained.

    Since

    v0.1.26

    Parameters

    • eventName: string | symbol
    • listener: ((...args: any[]) => void)
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

  • Render dynamic content.

    Example

    // Render text
    await ctx.render({text: 'Hello World!'});

    // Render JSON
    await ctx.render({json: {hello: 'world'}});

    // Render view "users/list.*.*" and pass it a stash value
    await ctx.render({view: 'users/list'}, {foo: 'bar'});

    Parameters

    Returns Promise<boolean>

  • Try to render dynamic content to string.

    Parameters

    Returns Promise<null | string>

  • Get JSON schema validation function.

    Parameters

    • schema: string | Record<string, any>

    Returns ValidatorFunction

  • Send static file.

    Parameters

    • file: default

    Returns Promise<void>

  • Persistent data storage for the next few requests.

    Returns Promise<SessionData>

  • By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set toInfinity (or 0) to indicate an unlimited number of listeners.

    Returns a reference to the EventEmitter, so that calls can be chained.

    Since

    v0.3.5

    Parameters

    • n: number

    Returns MojoContext

  • Generate URL for route or path.

    Example

    // Current URL with query parameter
    const url = ctx.urlFor('current', {query: {foo: 'bar'}});

    // URL for route with placeholder values
    const url = ctx.urlFor('users', {values: {id: 23}});

    // Absolute URL for path with fragment
    const url = ctx.urlFor('/some/path', {absolute: true, fragment: 'whatever'});

    Parameters

    Returns string

  • Generate URL for static asset.

    Parameters

    Returns string

  • Generate URL for static file.

    Parameters

    Returns string

  • Generate URL for route or path and preserve the current query parameters.

    Example

    // Remove a specific query parameter
    const url = ctx.urlWith('current', {query: {foo: null}});

    Parameters

    Returns string

Generated using TypeDoc