The main application container.
The Unit classes registered with the app.
The fully-qualified path to the base directory of the app.
Resolved universal path to the base directory of the app.
Collection of factories registered with this container.
If true, the "Starting Extollo..." messages will always be logged.
Collection of singleton instances produced by this container.
Instances of the units registered with this app.
Collection of static-class overrides registered with this container.
Collection of created objects that should have lifecycle events called on them, if they still exist.
Collection of callbacks waiting for a dependency key to be resolved.
The 100 most recent dependency keys that were
make'd. Used to help with
debugging cyclic dependency errors.
List of dependency keys currently being
make'd as a reverse stack.
This is used to detect dependency cycles.
Set to true when we're realizing a container.
Used to prevent infinite recursion when
getContainer() is accidentally called
from somewhere within the
Returns a UniversalPath to the
app/ directory in the application.
Get an instance of the RunLevelErrorHandler.
Return a UniversalPath to the root of the application.
Initialize the environment variable library and read from the
makeStack for duplicates and throw an error if a dependency cycle is
detected. This is used to prevent infinite mutual recursion when cyclic dependencies
Perform any cleanup necessary to destroy this container instance.
Stop all units in the application, one at a time, in reverse order.
Get a value from the loaded environment variables. If no value could be found, the default value will be returned.
Wrap a base Error instance into an ErrorWithContext.
Get a collection of dependency keys required by the given target, if it is registered with this container.
Get the already-produced value for the given key, if one exists.
Returns true if the container has an already-produced value for the given key.
Returns true if the container has a factory for the given key.
Returns true if a static override exists for the given base class.
Returns true if the given unit class is registered with the application.
Create an instance of the given target. The target can either be a DependencyKey registered with this container (in which case, the singleton value will be returned), or an instantiable class.
If the instantiable class has the Injectable decorator, its injectable parameters will be automatically injected into the instance.
Get the registered instance of the static override of a given class.
Create a new instance of the dependency key using this container, ignoring any pre-existing instances in this container.
Get a Promise that resolves the first time the given dependency key is resolved by the application. If it has already been resolved, the Promise will resolve immediately.
Given a factory and manually-provided parameters, resolve the dependencies for the factory and produce its value.
Purge all factories and instances of the given key from this container.
Register the given function as a factory within the container.
unique name to identify the factory in the container
factory to produce a value
Register a value as a singleton in the container. It will not be instantiated, but can be injected by its unique name.
unique name to identify the singleton in the container
Register a static class to the container along with its already-instantiated instance that will be used to resolve the class.
Remove all stored instances of the given key from this container.
Find the factory for the given key, if one is registered with this container.
Resolve the dependency key. If a singleton value for that key already exists in this container, return that value. Otherwise, use the factory an given parameters to produce and return the value.
Run the application by starting all units in order, then stopping them in reverse order.
Set up the bare essentials to get the application up and running.
Initialize the logger and load the logging level from the environment.
Start a single unit, setting its status.
Stop a single unit, setting its status.
Start all units in the application, one at a time, in order.
Get the global application instance.
Given a Container instance, apply the ContainerBlueprint to it.