Class Jimpex

Jimpex is a mix of Jimple, a Javascript port of Pimple dependency injection container, and Express, one of the most popular web frameworks for Node.

Todo

Implement helmet.

Hierarchy

  • Jimple
    • Jimpex

Constructors

constructor

Properties

_configReady _controlledRoutes _express _instance? _mountQueue _options _server?

Accessors

eventsHub express instance logger options routes

Methods

_addStaticsFolder _configurePath _emitEvent _init _initOptions _loadCredentials _loadESMModules _mountResources _reduceWithEvent _setupConfig _setupCoreServices _setupExpress boot disableTLSValidation getConfig getRouter isHealthy listen mount on once start stop use

Constructors

constructor

  • new Jimpex(options?, config?): Jimpex

  • Parameters

    • options: DeepPartial<JimpexOptions> = {}

      Preferences to customize the application.

    • config: unknown = {}

      The default settings for the configuration service. It's a shortcuit for options.config.default

    Returns Jimpex

Properties

Protected_configReady

_configReady: boolean = false

Since the configuration service has an async initialization, the class uses this flag internally to validate if the configuration has been initialized or not.

Protected_controlledRoutes

_controlledRoutes: string[] = []

A list with all the top routes controlled by the application. Every time a controller is mounted, its route will be added here.

Protected_express

_express: Express

The Express application Jimpex uses under the hood.

Protected Optional_instance

_instance?: JimpexServerInstance

The instance of the server that is listening for requests.

Protected_mountQueue

_mountQueue: ((server: Express) => void)[] = []

A list of functions that implement controllers and middlewares. When the application starts, the queue will be processed and those controllers and middlewares will be added to the server instance. The reason they are not added directly like with a regular Express implementation is that services on Jimple use lazy loading, and adding middlewares and controllers as they come could cause errors if they depend on services that are not yet registered.

Protected_options

_options: JimpexOptions

The customization settings for the application.

Protected Optional_server

_server?: JimpexServer

A reference to the actuall HTTP the application will use. This can vary depending on whether HTTPS, or HTTP2 are enabled. If HTTPS is not enabled, it will be the same as the express property; if HTTPS is enabled, it will be an https server; and if HTTP2 is enabled, it will be an spdy server.

Accessors

eventsHub

express

  • get express(): Express

  • The Express application Jimpex uses under the hood.

    Returns Express

instance

logger

options

routes

  • get routes(): string[]

  • A list of the routes that have controllers mounted on them.

    Returns string[]

Methods

Protected_addStaticsFolder

  • _addStaticsFolder(route, folder?, onHome?): void

  • Adds a static folder to the application.

    Parameters

    • route: string

      The route to add the folder to.

    • folder: string = ''

      The path to the folder in the file system. If not defined, it will be use the same value as route. The path could be relative to the project root, or where the application executable is located, depending on the value of the onHome parameter.

    • onHome: boolean = false

      If true, the path to the folder will be relative to the project root. If false, it will be relative to where the application executable is located.

    Returns void

Protected_configurePath

  • _configurePath(): void

  • This helper method validates the path options in order to register the app location in the pathUtils service. The app location should be the path to where the application executable is located, but due to how ESM works, we can't infer it from the module object, so we need either recieved as the appPath setting, or try to get it from the parent module.

    Returns void

    Throws

    If the method should use the path from the parent module, but can't find it.

Protected_emitEvent

Protected_init

  • _init(): void

  • This method is like a "lifecycle method", it gets executed on the constructor right before the "boot step". The idea is for the method to be a helper when the application is defined by subclassing Jimpex: the application could register all important services here and the routes on boot, then, if the implementation needs to access or overwrite a something, it can send boot: false, access/register what it needs, and then call boot(). That would be impossible for an application without overwriting the constructor and the boot functionality.

    Returns void

Protected_initOptions

  • _initOptions(): DeepPartial<JimpexOptions>

  • It generates overwrites for the application options when it gets created. This method is a helper for when the application is defined by subclassing Jimpex: It's highly probable that if the application needs to change the default options, it would want to do it right from the class, instead of having to do it on every implementation. A way to do it would be overwriting the constructor and calling super with the custom overwrites, but this method exists so that won't be necessary: when creating the options, the constructor will merge the result of this method on top of the default ones.

    Returns DeepPartial<JimpexOptions>

Protected_loadCredentials

  • _loadCredentials(credentialsInfo, onHome?): Promise<JimpexHTTPSCredentials>

  • Loads the contents of a dictionary of credentials files that need to be used to configure HTTPS.

    Parameters

    • credentialsInfo: JimpexHTTPSCredentials

      The dictionary where the keys are the type of credentials (ca, cert, key) and the values are the paths to the files.

    • onHome: boolean = true

      If this is true, the path of the files will be relative to the project root. If it is false, it will be relative to where the application executable is located.

    Returns Promise<JimpexHTTPSCredentials>

Protected_loadESMModules

  • _loadESMModules(): Promise<void>

  • Loads the ESM modules that are needed by Jimpex. This is called just before the starting the application so they'll be available for all the services.

    Returns Promise<void>

Protected_mountResources

Protected_reduceWithEvent

Protected_setupConfig

  • _setupConfig(): Promise<void>

  • Setups the configuration service. The new configuration service requires async calls in order to load the configuration files (as it uses import instead of require), so it can't be instantiated as the other services. This method is called just before starting the application.

    Returns Promise<void>

Protected_setupCoreServices

  • _setupCoreServices(): void

  • Registers the "core services" on the container: logger, events, utils, etc.

    Returns void

Protected_setupExpress

  • _setupExpress(): void

  • Configures the Express application based on the class options.

    Returns void

boot

  • boot(): void

  • This is where the app would register all its specific services, middlewares and controllers.

    Returns void

disableTLSValidation

  • disableTLSValidation(): void

  • Disables the server TLS validation. Meant to be used for development purposes.

    Returns void

getConfig

  • getConfig(): SimpleConfig

  • Returns SimpleConfig

  • getConfig<T>(setting, asArray?): T

  • Type Parameters

    • T = unknown

    Parameters

    • setting: string | string[]
    • OptionalasArray: boolean

    Returns T

getRouter

isHealthy

listen

  • listen(port?, onStart?): Promise<JimpexServerInstance>

  • This is an alias of start. The idea is for it to be used on serverless platforms, where you don't get to start your app, you just have export it.

    Parameters

    • Optionalport: number

      In case the configuration doesn't already have it, this is the port where the application will use to run. If this parameter is used, the method will overwrite the port setting on the configuration service.

    • OptionalonStart: JimpexStartCallback

      A callback function to be called when the server starts.

    Returns Promise<JimpexServerInstance>

    The server instance.

mount

  • mount(route, controller): void

  • Mounts a route controller or a middleware into a server routes.

    Parameters

    • route: string

      The route for the controller/middleware.

    • controller: ControllerLike

      The controller/middleware resource to be mounted.

    Returns void

on

  • on<EventName>(eventName, listener): (() => boolean)

  • Adds a listener for an application event.

    Type Parameters

    • EventName extends JimpexEventNameLike

      The name of the event, to match the type of the listener function.

    Parameters

    Returns (() => boolean)

    A function to unsubscribe the listener.

      • (): boolean

      • Returns boolean

once

  • once<EventName>(eventName, listener): (() => boolean)

  • Adds a listener for an application event that will only be execuded once: the first time the event is triggered.

    Type Parameters

    • EventName extends JimpexEventNameLike

      The name of the event, to match the type of the listener function.

    Parameters

    Returns (() => boolean)

    A function to unsubscribe the listener.

      • (): boolean

      • Returns boolean

start

stop

use

  • use(middleware): void

  • Adds a global middleware to the application.

    Parameters

    Returns void

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods