Convenience method to load configuration objects.

This uses the simple-config-loader package to load, merge, and resolve all configuration files found in options.dirname. For more information regarding the options that the configuration loader takes, see here.

Get a Logger instance by name. If no Logger instance exists with the given name, a new one will be created. All calls to getLogger with the same name will return the same instance.

Add a restore function to app. This method is added to Application by the muteConsole.

Default environment variable. This is used for instance to enable long stack traces using the longjohn module.

This will hold the app child logger used by the applciation instance. The output will be identified with the app id.

Default implementation of a logger factory that is provided by the logger module. Needed to ensure we can run applications if we decide to not load the logger module.

Flag indicating wether to start the application as soon as all core modules are loaded.

Initialize the applciation from the constructor call?

You can create an application instance and delay the boot cycle by initializeing the instance with this value set to false.

If a module has a commands

Name of the application instance. Used by the REPL module to display the prompt or by the logger module to create a child logger asigned to the application context.

Critical errors handled by onErrorHandler will process.exit the application.

Enable long stack traces using the longjohn module.

This module collects a lot of data and it's not resource friendly. It's always disabled in production irregardless of this property value.

Function to sanitize module names.

It ensures the resulting name is a valid JavaScript variable name.

Once a module is registered the application instance will emit an event. The event type is: .

List of modules that will be loaded on boot and are considered to be part of the application context's core.

If you want to override this provide full paths.

Base path used to resolve relative paths like the paths to the modules directory or other directories that need to be loaded by the application instance.

Defualts to current working directory of the Node.js process.

Default paths to load commands and modules. Relative to application path.

Time in seconds aftwer which we reject a call to context.resolve.

If we set it too low we might not give enough time to slower parts of the application to fail, for instance if the ORM module is taking a long time to connect we might abort the app without having the ORM throw an error, thus being hard to debug.

Time in seconds aftwer which we reject a call to context.register.

registration.data can be either an object or a function that returns an object. The object will be sent to the core.io application registry.

Initializes the instance by:

• Registering event listeners
• Configuring the application instance
• Setup long statck traces
• Show ASCII banner
• Mount modules

It will extend options with Application.DEFAULTS, the resulting object will extend the application instance.

Register a module with the application context to be exposed as a property with the name name.

Due to the mount process and auto-wiring, name will often times refer to a npm package name or a file name. Basically anyting that can be required.

This function will:

• Normalize name: ensure name is a valid JavaScript property name.

• If the module exports an alias property it's normalized value will be used instead of name.

• The function looks for a key in context.config with a key matching name.

• If the config object does not export an moduleid property it will create it assigning name to it.

• If the module exports an init function it will be called with a reference to the application context and a configuration object.

• instance is the value of calling require on the module.

• I will Promise.resolve instance, meaning that instance can be either a Promise or an object.

• Once instance is resolved, the function will assign a child logger to it.

• If it does not have an moduleid property it will assing name.

• If instance extends EventEmitter it will register handleModuleError as an error listener.

• Emit an event with the instance as event. The event type will be: .<context.registerReadyEvent>. e.g. "logger.registered"

This will add attr to the application context and ensure that it does not get overwritten unnoticeably.

If we really want to overwrite the given attribute, we can still do so, but explicitly using Object.defineProperty

This will throw an error in strict mode, which is probably what you want.

Checks wether a module with name name has been registered.

Register a callback to get notfied once module has been registered.

Once a module is registered the application instance will fire an event with type <moduleId>.registered, logger.registred for the logger module.

We can't guarantee the other in which modules are going to be loaded since it depends on dependency chain resolution. It might be the case that a module A depends on module B, module A loads after module B. Using onceRegistered module A would still get notified.

Application wide error handler.

Handled errors from registered modules.

During the registration process of a module we add handleModuleError as an event listener.

This will retrhow the error, unless the error object has a handledByModule property set to true.

We give the modules the chance to prevent main app to handle this event. For this to work, and since EventEmitter has no event bubbling we rely on clumsy JS facts:

• Event object is passed by reference.
• event handlers are executed in order they where attached.

So, if we want our module to handle an error before we do here, our module needs to attach it's error listener before returning the module to App core.

Helper function to glob contents of a directory. Returns a Promise that resolves with the files. If the options object contains a handler function then we return the value of calling this function.

This function will collect and process all valid module files found in a given directory. Valid options:

• options.only: Array of modules to select.

This function will collect and process all valid command files in a given directory. It will register them with the application context.

Load commands for a given module

Resolve a dependency, this will return a Proimse that will be resolved once the module(s) is available.

If the module was already loaded the Promise will be resolve immediately. If not it will wait for the module to be registered.

If after context.resolveTimeout milliseconds the module has not been registered the promise will be rejected.

If id is undefined this method will throw an Error. If we are trying to resolve a set of dependencies that might or might not be there you can pass ignoreUndefinedIds as true to not generate an error. This might be the case if we are loading optional dependencies from a user configuration file

Application entry point. This will register a hook listener for the run hook, and once the hook has finalized will call registerApplication.

Register the application instance with the core.io registry service.

Deregister the application instance from the core.io registry service.

Register a command for the given event type.

Command handler functions get bound to the application context.

We can ensure that a given eventType executes a single command by setting unique to true.

Use this function to exit the application gracefully. By default with will deregsiter the application from the registry.

Sanitized version of the given name. It will remove starting digits, and camel case it.

Default configuration object for Logger module.

Function to execute after all configuration references have been solved.

Filter enables masking output from the Logger class. It enables to remove sensitive content from the output.

https://www.npmjs.com/package/data-mask

Logger class providing extra functionality on top of winston.Logger.

Logger moudle provides a wrapper around winston.

Look into pino: https://www.npmjs.com/package/pino

Enforce a column width of length length

Message is the formatter for messages being written to the console transport.

See winston.transports.Console fore more information.

Utility function to mute the native console. It adds a restoreNativeConsole method to the Application instance context.

Wrap native console with a logger instance.

Adds Event management methods to Application.

Creates a wrapper function that will make hooks. This function will wrap an event emitter instance with a hook function

A hook is like an event but with a Lifecycle.

A hook has four stages:

• pre
• post
• execution
• complete

You emit a hook the using the hook method of your emitter.

You register listeners to each stage.

Wraps a chain of events in a Promise.

Function wraps emitter with a chainEvent function. A chain event will listen for a list of events and resolve when all are triggered.

Wraps a chain of events in a Promise.

Handles configuration.

Stores a definition, with configuration options, to be solved later.

The context can be either a literal value or a factory method.

Solve for the provided beanId, it returns a value and solves all dependencies, etc.

The cycle to solve for a beanId is the result of runing the methods in order:

• prepare as a pre process
• build to generate the context
• wire to solve dependencies
• post as a post process

Pre process to consolidate the configuration object for a given beanId.

It will loop over all providers in order the order they were added and call the provider with the Gioc instance as scope. The default provider is the extend method.

Retrieve the context value for the given beanId. If the context is a literal value, we just return it without any further steps. If the context is a function then we execute it with the scope and args provided in the config object.

Goes over the config object's beanIds and for any of its beanIds that has a related solver it will apply the solver method to the target. Meant to be overridden with use. Default solvers are the extend method for the beanId props and solveDependencies for the deps beanId.

Injects a dependency into the provided scope

During the solve cycle, the post process applied after the context has been configured, built, and wired.

Checks to see if beanId is currently mapped. TODO: If we add external solvers, then this check might be outdated. We need to add solver+mapper!

Solve an array of dependencies.

Error handler. If strictErrors is true it will throw the error. Else it will be handled by logger.

Solvers are functions that handle specific beanIds in the configuration bean. We add solvers by beanId.

Add a post solver function.

Extend method. It has a common signature with other methods- taking a beanId as first argument- and ignoring it. Then just merging onto "target" from left to right.

Under the hood, is just doing a normal extend.

Stub method for logger. By default is mapped to console.

Code to be executed on startup

Check point for monitored service. CareTaker expects this function to be called in an interval of time lower than the specified timeout period. In the case that the TTL is expired the instance will execute the terminate function.

This enables connecting to your application using a terminal.

Use poke-repl to create a TCP repl server, to which you can connect using a the poke-repl client.

The REPL serer supports a rudimentary firewall and authentication mechanism.

REPL header:

╔═════════════════════════════════════════════════════════════════════╗
║                      poke-repl remote console √                     ║
║                                                                     ║
║              All connections are monitored and recorded             ║
║      Disconnect IMMEDIATELY if you are not an authorized user       ║
╚═════════════════════════════════════════════════════════════════════╝

Transform a list of files we want into a pattern for multimatch that would exclude files NOT matching those names.

Naive filename sanitize function.

Return name of module from it's path.

Get path to main module.

Get number of listeners an event emitter has for a given event type.

Normalize command object.