Class Signature
class App<E extends Record<string, unknown>>
Type Parameters
The type of the exposed services object. This is inferred from the expose schema passed to createApp.
Properties
name
public readonly name: string
debug
public readonly debug: boolean
false.
timezone
public readonly timezone: string
"UTC". This value is also set to process.env.timezone.
emitter
public readonly emitter: Emitter
'app:ready'.
Object containing exposed services as defined in the expose schema. Provides type-safe access to registered services.
Methods
init()
async init(): Promise<void>
expose schema. This method is called automatically by createApp() and typically doesn’t need to be called manually.
Returns a Promise that resolves when initialization is complete.
- Iterates through the expose schema
- Resolves each token from the dependency injection container
- Assigns the resolved instances to the
$ object
rootPath()
rootPath(...paths: string[]): string
Path segments to join. Backslashes are automatically converted to forward slashes for cross-platform compatibility.
The absolute path joined from the root directory and provided segments.
app.rootPath(); // Returns cwd()
app.rootPath('config'); // Returns /path/to/app/config
app.rootPath('config', 'database.json'); // Returns /path/to/app/config/database.json
app.rootPath('config\\log'); // Returns /path/to/app/config/log (backslashes converted)
runtimePath()
runtimePath(...paths: string[]): string
{root}/runtime).
Path segments to join. Backslashes are automatically converted to forward slashes.
The absolute path joined from the runtime directory and provided segments.
app.runtimePath(); // Returns /path/to/app/runtime
app.runtimePath('cache'); // Returns /path/to/app/runtime/cache
app.runtimePath('logs', 'app.log'); // Returns /path/to/app/runtime/logs/app.log
get()
get<T>(token: Token<T>): T
The dependency injection token for the service to retrieve.
The resolved service instance.
const LOGGER = Symbol('LOGGER') as Token<LoggerService>;
const app = await createApp({
name: 'MyApp',
providers: [
{ token: LOGGER, factory: () => new LoggerService() }
]
});
const logger = app.get(LOGGER);
logger.log('Hello');
run()
async run(): Promise<void>
'app:ready' event.
Returns a Promise that resolves when all bootstrap functions complete.
- Executes all bootstrap functions from registered extensions in parallel
- Emits the
'app:ready' event when bootstrapping completes
- Is idempotent - calling multiple times has no additional effect
- If any bootstrap function throws an error, the Promise rejects
Example:
const app = await createApp({
name: 'MyApp',
extensions: [
{
name: 'database',
bootstrap: async (context) => {
// Connect to database
console.log('Database connected');
}
}
]
});
await app.run(); // Logs: "Database connected"
await app.run(); // No effect - bootstrap functions only run once
dispose()
async dispose(): Promise<void>
Returns a Promise that resolves when cleanup is complete.
- Calls
dispose() on the dependency injection container (which calls dispose() on all services that implement it)
- Removes all event listeners from the emitter using
emitter.offAll()
Example:
const DB = Symbol('DB') as Token<DatabaseService>;
const app = await createApp({
name: 'MyApp',
providers: [
{
token: DB,
factory: () => ({
connection: connectToDb(),
dispose: () => {
console.log('Disconnecting from database');
}
})
}
]
});
await app.run();
// When shutting down:
await app.dispose(); // Logs: "Disconnecting from database"
See Also
- createApp - Factory function to create App instances
- AppContext - Context object provided to extensions
- Extension - Extension interface for extending application functionality