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) => Promise<boolean>)

Type declaration

    • (error): Promise<boolean>
    • Parameters

      • error: Error

      Returns Promise<boolean>

exceptionFormat: string

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

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

Type declaration

    • (error): Promise<boolean>
    • Parameters

      • error: Error

      Returns Promise<boolean>

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

Type declaration

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

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

Type declaration

    • (error): Promise<boolean>
    • Parameters

      • error: any

      Returns Promise<boolean>

include: ((options, stash) => Promise<null | SafeString>)

Type declaration

inspect: ((object, options) => string)

Type declaration

    • (object, options): string
    • Parameters

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

      Returns string

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

Type declaration

    • (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, config) => Promise<void>)

Type declaration

proxyPost: ((url, config) => Promise<void>)

Type declaration

proxyRequest: ((config) => 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) => Promise<boolean>)

Type declaration

    • (error): Promise<boolean>
    • Parameters

      • error: Error

      Returns Promise<boolean>

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

Type declaration

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

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

Type declaration

    • (error): Promise<boolean>
    • Parameters

      • error: any

      Returns Promise<boolean>

Accessors

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

    Returns Record<string, any>

    Example

    // Longer version
    const config = ctx.app.config;
  • get home(): default
  • Home directory shortcut.

    Returns default

    Example

    // Generate path
    const path = ctx.home.child('views', 'foo', 'bar.html.tmpl');
  • 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.

    Returns MojoModels

    Example

    // Access arbitrary model objects
    const db = await ctx.models.pg.db();
  • 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).

    Parameters

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

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

    Since

    v0.1.26

  • Append partial content to ctx.content buffers.

    Parameters

    Returns Promise<void>

    Example

    // Add content for "head" section
    await ctx.contentFor('head', '<link rel="icon" href="/static/favicon.ico">');
  • 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.

    import { EventEmitter } from 'node: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

    Parameters

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

    Returns boolean

    Since

    v0.1.26

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

    import { EventEmitter } from 'node: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) ]

    Returns (string | symbol)[]

    Since

    v6.0.0

  • Data storage persistent only for the next request.

    Returns Promise<Record<string, any>>

    Example

    // Show message after redirect
    const flash = await ctx.flash();
    flash.message = 'User created successfully!';
    await ctx.redirectTo('show_user', {values: {id: 23}});
  • Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to defaultMaxListeners.

    Returns number

    Since

    v1.0.0

  • Handle WebSocket upgrade, used by servers.

    Parameters

    Returns void

  • Accept WebSocket connection and activate JSON mode.

    Parameters

    • fn: WebSocketHandler

    Returns MojoContext

    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);
    }
    }
    });
  • Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

    Parameters

    • eventName: string | symbol

      The name of the event being listened for

    • Optional listener: Function

      The event handler function

    Returns number

    Since

    v3.2.0

  • 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] ]

    Parameters

    • eventName: string | symbol

    Returns Function[]

    Since

    v0.1.26

  • Alias for emitter.removeListener().

    Parameters

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

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

    Since

    v10.0.0

  • 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.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args) => void)

      The callback function

        • (...args): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

    Since

    v0.1.101

  • 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.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args) => void)

      The callback function

        • (...args): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

    Since

    v0.3.0

  • GET and POST parameters.

    Parameters

    • options: UploadOptions & {
          notEmpty?: boolean;
      } = {}

    Returns Promise<Params>

    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});
  • Accept WebSocket connection.

    Parameters

    • fn: WebSocketHandler

    Returns MojoContext

    Example

    // Echo incoming WebSocket messages
    ctx.plain(async ws => {
    for await (const message of ws) {
    await ws.send(`echo: ${message}`);
    }
    });
  • 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.

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args) => void)

      The callback function

        • (...args): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

    Since

    v6.0.0

  • 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.

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args) => void)

      The callback function

        • (...args): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

    Since

    v6.0.0

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

    import { EventEmitter } from 'node:events';
    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');

    Parameters

    • eventName: string | symbol

    Returns Function[]

    Since

    v9.4.0

  • Send 302 redirect response.

    Parameters

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

    Returns Promise<void>

    Example

    // Moved Permanently
    await ctx.redirect_to('some_route', {status: 301});
  • 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.

    Parameters

    • Optional event: string | symbol

    Returns MojoContext

    Since

    v0.1.26

  • 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.

    import { EventEmitter } from 'node:events';
    class MyEmitter extends EventEmitter {}
    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:

    import { EventEmitter } from 'node:events';
    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.

    Parameters

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

          • Rest ...args: any[]

          Returns void

    Returns MojoContext

    Since

    v0.1.26

  • Render dynamic content.

    Parameters

    Returns Promise<boolean>

    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'});
  • Try to render dynamic content to string.

    Parameters

    Returns Promise<null | string>

  • Automatically select best possible representation for resource.

    Parameters

    Returns Promise<void>

  • 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.

    Parameters

    • n: number

    Returns MojoContext

    Since

    v0.3.5

  • Generate URL for route or path.

    Parameters

    Returns string

    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'});
  • 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.

    Parameters

    Returns string

    Example

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

Generated using TypeDoc