@tstdl/base 0.85.26 → 0.86.0-beta10

package/core.d.ts

@@ -1,8 +1,10 @@
-import type { InjectionToken } from './container/index.js';
 import { AsyncDisposer } from './disposable/async-disposer.js';
+import { Injector } from './injector/injector.js';
+import type { InjectionToken } from './injector/token.js';
 import type { LoggerArgument } from './logger/index.js';
 import { LogLevel, Logger } from './logger/index.js';
-export declare const CORE_LOGGER: InjectionToken<Logger, any>;
+export declare const CORE_LOGGER: InjectionToken<Logger, never>;
+export declare const rootInjector: Injector;
 export declare const disposer: AsyncDisposer;
 export declare function isDevMode(): boolean;
 export declare function isProdMode(): boolean;

package/core.js

@@ -25,16 +25,20 @@ __export(core_exports, {
   disposer: () => disposer,
   enableProdMode: () => enableProdMode,
   isDevMode: () => isDevMode,
-  isProdMode: () => isProdMode
+  isProdMode: () => isProdMode,
+  rootInjector: () => rootInjector
 });
 module.exports = __toCommonJS(core_exports);
-var import_container = require("./container/index.js");
 var import_async_disposer = require("./disposable/async-disposer.js");
+var import_injector = require("./injector/injector.js");
+var import_token = require("./injector/token.js");
 var import_logger = require("./logger/console/logger.js");
 var import_logger2 = require("./logger/index.js");
+var import_process_shutdown = require("./process-shutdown.js");
 var import_timing = require("./utils/timing.js");
 var import_type_guards = require("./utils/type-guards.js");
-const CORE_LOGGER = (0, import_container.injectionToken)("core logger");
+const CORE_LOGGER = (0, import_token.injectionToken)("core logger");
+const rootInjector = new import_injector.Injector("RootInjector");
 const disposer = new import_async_disposer.AsyncDisposer();
 let _isDevMode = true;
 function isDevMode() {
@@ -73,12 +77,15 @@ function configureTstdl(config = {}) {
   if (config.production == true) {
     enableProdMode();
   }
-  import_container.container.register(import_logger2.Logger, { useToken: config.logger ?? import_logger.ConsoleLogger });
-  import_container.container.registerSingleton(import_logger2.LogLevel, { useFactory: (level) => (0, import_type_guards.assertDefinedPass)(level, "LogLevel argument not provided") }, { defaultArgumentProvider: () => config.logLevel ?? import_logger2.LogLevel.Trace });
+  const logger = rootInjector.resolve(CORE_LOGGER);
+  (0, import_process_shutdown.setProcessShutdownLogger)(logger);
+  (0, import_process_shutdown.initializeSignals)();
+  import_injector.Injector.register(import_logger2.Logger, { useToken: config.logger ?? import_logger.ConsoleLogger });
+  import_injector.Injector.registerSingleton(import_logger2.LogLevel, { useFactory: (level) => (0, import_type_guards.assertDefinedPass)(level, "LogLevel argument not provided") }, { defaultArgumentProvider: () => config.logLevel ?? import_logger2.LogLevel.Trace });
   if ((0, import_type_guards.isDefined)(config.coreLogPrefix)) {
     coreLogPrefix = config.coreLogPrefix;
   }
 }
-import_container.container.register(import_logger2.Logger, { useToken: import_logger.ConsoleLogger });
-import_container.container.register(import_logger2.LogLevel, { useValue: import_logger2.LogLevel.Trace });
-import_container.container.register(CORE_LOGGER, { useToken: import_logger2.Logger, argumentProvider: () => coreLogPrefix });
+import_injector.Injector.register(import_logger2.Logger, { useToken: import_logger.ConsoleLogger });
+import_injector.Injector.register(import_logger2.LogLevel, { useValue: import_logger2.LogLevel.Trace });
+import_injector.Injector.register(CORE_LOGGER, { useToken: import_logger2.Logger, defaultArgumentProvider: () => coreLogPrefix });

package/database/mongo/classes.d.ts

@@ -1,6 +1,6 @@
-import type { Injectable } from '../../container/index.js';
-import { type resolveArgumentType } from '../../container/index.js';
+import { resolveArgumentType } from '../../injector/interfaces.js';
 import type { Entity } from '../../database/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
 import { Db, Collection as MongoCollection, MongoClient as MongoMongoClient } from 'mongodb';
 import type { MongoDocument } from './model/document.js';
 import type { MongoConnection, MongoRepositoryConfig } from './types.js';
@@ -11,12 +11,12 @@ export type DatabaseArgument = string | {
     database?: string;
 };
 export type CollectionArgument<T extends Entity<any> = Entity, TDb extends Entity<any> = T> = MongoRepositoryConfig<T, TDb>;
-export declare class MongoClient extends MongoMongoClient implements Injectable<MongoClientArgument> {
+export declare class MongoClient extends MongoMongoClient implements Resolvable<MongoClientArgument> {
     readonly [resolveArgumentType]: MongoClientArgument;
 }
-export declare class Database extends Db implements Injectable<DatabaseArgument> {
+export declare class Database extends Db implements Resolvable<DatabaseArgument> {
     readonly [resolveArgumentType]: DatabaseArgument;
 }
-export declare class Collection<T extends Entity<any> = Entity, TDb extends Entity<any> = T> extends MongoCollection<MongoDocument<TDb>> implements Injectable<CollectionArgument<T, TDb>> {
+export declare class Collection<T extends Entity<any> = Entity, TDb extends Entity<any> = T> extends MongoCollection<MongoDocument<TDb>> implements Resolvable<CollectionArgument<T, TDb>> {
     readonly [resolveArgumentType]: CollectionArgument<T, TDb>;
 }

package/database/mongo/classes.js

@@ -23,7 +23,8 @@ __export(classes_exports, {
   MongoClient: () => MongoClient
 });
 module.exports = __toCommonJS(classes_exports);
-var import_container = require("../../container/index.js");
+var import_interfaces = require("../../injector/interfaces.js");
+var import_decorators = require("../../injector/decorators.js");
 var import_mongodb = require("mongodb");
 var __decorate = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -38,15 +39,15 @@ var __decorate = function(decorators, target, key, desc) {
 let MongoClient = class MongoClient2 extends import_mongodb.MongoClient {
 };
 MongoClient = __decorate([
-  (0, import_container.replaceClass)(import_mongodb.MongoClient)
+  (0, import_decorators.ReplaceClass)(import_mongodb.MongoClient)
 ], MongoClient);
 let Database = class Database2 extends import_mongodb.Db {
 };
 Database = __decorate([
-  (0, import_container.replaceClass)(import_mongodb.Db)
+  (0, import_decorators.ReplaceClass)(import_mongodb.Db)
 ], Database);
 let Collection = class Collection2 extends import_mongodb.Collection {
 };
 Collection = __decorate([
-  (0, import_container.replaceClass)(import_mongodb.Collection)
+  (0, import_decorators.ReplaceClass)(import_mongodb.Collection)
 ], Collection);

package/database/mongo/module.js

@@ -22,8 +22,8 @@ __export(module_exports, {
   mongoModuleConfig: () => mongoModuleConfig
 });
 module.exports = __toCommonJS(module_exports);
-var import_container = require("../../container/index.js");
 var import_core = require("../../core.js");
+var import_injector = require("../../injector/injector.js");
 var import_logger = require("../../logger/index.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_classes = require("./classes.js");
@@ -37,43 +37,51 @@ function configureMongo(config) {
   mongoModuleConfig.defaultConnection = config.defaultConnection ?? mongoModuleConfig.defaultConnection;
   mongoModuleConfig.logPrefix = config.logPrefix ?? mongoModuleConfig.logPrefix;
 }
-import_container.container.registerSingleton(import_classes.MongoClient, {
-  useFactory: async (argument, context) => {
+import_injector.Injector.registerSingleton(import_classes.MongoClient, {
+  useFactory(argument, context) {
     (0, import_type_guards.assertDefined)(argument, "mongo connection resolve argument missing");
     const { url, ...options } = argument;
     const logger = context.resolve(import_logger.Logger, mongoModuleConfig.logPrefix);
     const client = new import_classes.MongoClient(url, options);
     client.on("fullsetup", () => logger.verbose("connection setup")).on("reconnect", () => logger.warn("reconnected")).on("timeout", () => logger.warn("connection timed out")).on("close", () => logger.verbose("connection closed"));
-    import_core.disposer.add(async () => client.close());
-    await (0, import_core.connect)(`mongo at ${url}`, async () => client.connect(), logger);
+    context.addDisposeHandler(async () => client.close());
+    context.context.logger = logger;
+    context.context.url = url;
     return client;
+  },
+  async afterResolve(client, _argument, context) {
+    await (0, import_core.connect)(`mongo at ${context.url}`, async () => client.connect(), context.logger);
   }
 }, {
   defaultArgumentProvider: () => mongoModuleConfig.defaultConnection,
   argumentIdentityProvider: JSON.stringify
 });
-import_container.container.registerSingleton(import_classes.Database, {
-  useFactory: async (argument, context) => {
+import_injector.Injector.registerSingleton(import_classes.Database, {
+  useFactory: (argument, context) => {
     const connection = (0, import_type_guards.isObject)(argument) ? argument.connection : mongoModuleConfig.defaultConnection;
     const name = ((0, import_type_guards.isString)(argument) ? argument : (0, import_type_guards.isObject)(argument) ? argument.database : void 0) ?? mongoModuleConfig.defaultDatabase;
-    const client = await context.resolveAsync(import_classes.MongoClient, connection);
+    const client = context.resolve(import_classes.MongoClient, connection);
     return client.db(name);
-  }
+  },
+  defaultArgumentProvider: () => ({ database: mongoModuleConfig.defaultDatabase, connection: mongoModuleConfig.defaultConnection })
 }, {
-  defaultArgumentProvider: () => ({ database: mongoModuleConfig.defaultDatabase, connection: mongoModuleConfig.defaultConnection }),
   argumentIdentityProvider: JSON.stringify
 });
-import_container.container.registerSingleton(import_classes.Collection, {
-  useFactory: async (config, context) => {
+import_injector.Injector.registerSingleton(import_classes.Collection, {
+  useFactory: (config, context) => {
     (0, import_type_guards.assertDefined)(config, "mongo repository config resolve argument missing");
-    const database = await context.resolveAsync(import_classes.Database, config);
-    const existingCollections = await database.collections();
+    const database = context.resolve(import_classes.Database, config);
+    context.context.database = database;
+    return database.collection(config.collection);
+  },
+  async afterResolve(_, config, context) {
+    const existingCollections = await context.database.collections();
     for (const collection of existingCollections) {
       if (collection.collectionName == config.collection) {
-        return collection;
+        return;
       }
     }
-    return database.createCollection(config.collection);
+    await context.database.createCollection(config.collection);
   }
 }, {
   argumentIdentityProvider: JSON.stringify

package/database/mongo/mongo-entity-repository.d.ts

@@ -1,7 +1,7 @@
-import type { AfterResolve } from '../../container/index.js';
-import { afterResolve } from '../../container/index.js';
 import type { Entity, EntityPatch, MaybeNewEntity, Query, QueryOptions, UpdateOptions } from '../../database/index.js';
 import { EntityRepository } from '../../database/index.js';
+import type { AfterResolve } from '../../injector/index.js';
+import { afterResolve } from '../../injector/index.js';
 import type { Logger } from '../../logger/index.js';
 import type { Collection } from './classes.js';
 import { MongoBaseRepository } from './mongo-base.repository.js';

package/database/mongo/mongo-entity-repository.js

@@ -25,8 +25,8 @@ __export(mongo_entity_repository_exports, {
   noopTransformerFunction: () => noopTransformerFunction
 });
 module.exports = __toCommonJS(mongo_entity_repository_exports);
-var import_container = require("../../container/index.js");
 var import_database = require("../../database/index.js");
+var import_injector = require("../../injector/index.js");
 var import_equals = require("../../utils/equals.js");
 var import_object = require("../../utils/object/object.js");
 var import_throw = require("../../utils/throw.js");
@@ -60,7 +60,7 @@ class MongoEntityRepository extends import_database.EntityRepository {
     this.baseRepository = new import_mongo_base_repository.MongoBaseRepository(collection);
     this.transformerMappingMap = new Map((0, import_object.objectEntries)(transformer.mapping ?? {}));
   }
-  async [import_container.afterResolve]() {
+  async [import_injector.afterResolve]() {
     await this.initialize();
   }
   async initialize() {

package/disposable/async-disposer.d.ts

@@ -3,10 +3,10 @@ import { CancellationToken } from '../utils/cancellation-token.js';
 import type { AsyncDisposable, Disposable } from './disposable.js';
 import { disposeAsync } from './disposable.js';
 declare const deferrerToken: unique symbol;
-export type TaskFunction = () => any;
-export type AsyncDisposeHandler = TaskFunction | Disposable | AsyncDisposable;
-export type Task = {
-    taskFunction: TaskFunction;
+export type AsyncDisposeTaskFunction = () => any;
+export type AsyncDisposeHandler = AsyncDisposeTaskFunction | Disposable | AsyncDisposable;
+export type AsyncDisposeTask = {
+    taskFunction: AsyncDisposeTaskFunction;
 };
 export type Deferrer = {
     [deferrerToken]: CancellationToken;

package/distributed-loop/distributed-loop.d.ts

@@ -1,12 +1,12 @@
-import type { Injectable } from '../container/index.js';
-import { type resolveArgumentType } from '../container/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+import type { Resolvable } from '../injector/interfaces.js';
 import { LockProvider } from '../lock/index.js';
 import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import type { LoopController } from './controller.js';
 export type LoopFunction = (controller: LoopController) => any | Promise<any>;
 /** loop key */
 export type DistributedLoopArgument = string;
-export declare class DistributedLoop implements Injectable<DistributedLoopArgument> {
+export declare class DistributedLoop implements Resolvable<DistributedLoopArgument> {
     private readonly key;
     private readonly lockProvider;
     readonly [resolveArgumentType]: string;

package/distributed-loop/distributed-loop.js

@@ -21,7 +21,7 @@ __export(distributed_loop_exports, {
   DistributedLoop: () => DistributedLoop
 });
 module.exports = __toCommonJS(distributed_loop_exports);
-var import_container = require("../container/index.js");
+var import_injector = require("../injector/index.js");
 var import_lock = require("../lock/index.js");
 var import_deferred_promise = require("../promise/deferred-promise.js");
 var import_cancellation_token = require("../utils/cancellation-token.js");
@@ -105,7 +105,7 @@ let DistributedLoop = class DistributedLoop2 {
   }
 };
 DistributedLoop = __decorate([
-  (0, import_container.injectable)(),
-  __param(0, (0, import_container.injectArg)()),
+  (0, import_injector.Injectable)(),
+  __param(0, (0, import_injector.InjectArg)()),
   __metadata("design:paramtypes", [String, import_lock.LockProvider])
 ], DistributedLoop);

package/distributed-loop/provider.js

@@ -21,7 +21,7 @@ __export(provider_exports, {
   DistributedLoopProvider: () => DistributedLoopProvider
 });
 module.exports = __toCommonJS(provider_exports);
-var import_container = require("../container/index.js");
+var import_decorators = require("../injector/decorators.js");
 var import_lock = require("../lock/index.js");
 var import_distributed_loop = require("./distributed-loop.js");
 var __decorate = function(decorators, target, key, desc) {
@@ -48,6 +48,6 @@ let DistributedLoopProvider = class DistributedLoopProvider2 {
   }
 };
 DistributedLoopProvider = __decorate([
-  (0, import_container.singleton)(),
+  (0, import_decorators.Singleton)(),
   __metadata("design:paramtypes", [import_lock.LockProvider])
 ], DistributedLoopProvider);

package/examples/api/authentication.js

@@ -6,14 +6,16 @@ var import_client = require("../../authentication/client/index.js");
 var import_server2 = require("../../authentication/server/index.js");
 var import_mongo_authentication_credentials_repository = require("../../authentication/server/mongo/mongo-authentication-credentials.repository.js");
 var import_mongo_authentication_session_repository = require("../../authentication/server/mongo/mongo-authentication-session.repository.js");
-var import_container = require("../../container/index.js");
 var import_undici_http_client_adapter = require("../../http/client/adapters/undici-http-client.adapter.js");
 var import_module = require("../../http/client/module.js");
 var import_module2 = require("../../http/server/node/module.js");
+var import_inject = require("../../injector/inject.js");
 var import_module3 = require("../../message-bus/local/module.js");
 var import_web_server_module = require("../../module/modules/web-server.module.js");
+var import_configure = require("../../signals/implementation/configure.js");
 var import_timing = require("../../utils/timing.js");
 var import_undici = require("undici");
+(0, import_configure.configureDefaultSignalsImplementation)();
 (0, import_server2.configureAuthenticationServer)({
   serviceOptions: { secret: "djp0fq23576aq" },
   credentialsRepository: import_mongo_authentication_credentials_repository.MongoAuthenticationCredentialsRepository,
@@ -21,29 +23,34 @@ var import_undici = require("undici");
 });
 (0, import_mongo_authentication_credentials_repository.configureMongoAuthenticationCredentialsRepository)({ collection: "credentials" });
 (0, import_mongo_authentication_session_repository.configureMongoAuthenticationSessionRepository)({ collection: "sessions" });
-(0, import_client.configureAuthenticationClient)({
-  authenticationApiClient: import_api_client.AuthenticationApiClient
-});
 (0, import_module3.configureLocalMessageBus)();
 async function serverTest() {
-  const authenticationService = await import_container.container.resolveAsync(import_server2.AuthenticationService);
+  const authenticationService = await (0, import_inject.injectAsync)(import_server2.AuthenticationService);
   await authenticationService.setCredentials("foobar", "mysuperdupersecret-fvhc54w");
 }
 async function clientTest() {
-  await (0, import_timing.timeout)(250);
-  const authenticationService = import_container.container.resolve(import_client.AuthenticationService);
+  const authenticationService = (0, import_inject.inject)(import_client.AuthenticationService);
   authenticationService.initialize();
+  await (0, import_timing.timeout)(250);
   const passwordCheckResult = await authenticationService.checkSecret("123456");
   console.log({ 'password check for "123456"': passwordCheckResult });
   await authenticationService.login("foobar", "mysuperdupersecret-fvhc54w");
   authenticationService.token$.subscribe((token) => console.log({ token }));
 }
+async function test() {
+  await Promise.all([
+    serverTest(),
+    clientTest()
+  ]);
+  await import_application.Application.shutdown();
+}
 function main() {
+  (0, import_client.configureAuthenticationClient)({
+    authenticationApiClient: import_api_client.AuthenticationApiClient
+  });
   (0, import_module2.configureNodeHttpServer)();
   (0, import_server.configureApiServer)({ controllers: [import_server2.AuthenticationApiController] });
   (0, import_undici_http_client_adapter.configureUndiciHttpClientAdapter)({ dispatcher: new import_undici.Agent({ keepAliveMaxTimeout: 1 }) });
   (0, import_module.configureHttpClient)({ baseUrl: "http://localhost:8000" });
-  import_application.Application.run(import_web_server_module.WebServerModule);
 }
-main();
-void serverTest().then(async () => clientTest()).catch((error) => console.error(error)).then(async () => import_application.Application.shutdown());
+import_application.Application.run(main, test, import_web_server_module.WebServerModule);

package/examples/api/basic-overview.js

@@ -3,10 +3,10 @@ var import_client = require("../../api/client/index.js");
 var import_api = require("../../api/index.js");
 var import_server = require("../../api/server/index.js");
 var import_application = require("../../application/application.js");
-var import_container = require("../../container/index.js");
 var import_undici_http_client_adapter = require("../../http/client/adapters/undici-http-client.adapter.js");
 var import_module = require("../../http/client/module.js");
 var import_module2 = require("../../http/server/node/module.js");
+var import_inject = require("../../injector/inject.js");
 var import_web_server_module = require("../../module/modules/web-server.module.js");
 var import_schema = require("../../schema/index.js");
 var import_timing = require("../../utils/timing.js");
@@ -87,21 +87,20 @@ UserApi = __decorate([
 ], UserApi);
 const UserApiClient = (0, import_client.compileClient)(usersApiDefinition);
 async function clientTest() {
+  const userApiClient = (0, import_inject.inject)(UserApiClient);
   await (0, import_timing.timeout)(250);
-  const userApiClient = import_container.container.resolve(UserApiClient);
   const allUsers = await userApiClient.loadAll();
   console.log(allUsers);
   await userApiClient.delete({ id: allUsers[0].id });
   const allUsersAfterDelete = await userApiClient.loadAll();
   console.log(allUsersAfterDelete);
+  import_application.Application.requestShutdown();
 }
 async function main() {
   (0, import_module2.configureNodeHttpServer)();
   (0, import_server.configureApiServer)({ controllers: [UserApi] });
   (0, import_undici_http_client_adapter.configureUndiciHttpClientAdapter)({ dispatcher: new import_undici.Agent({ keepAliveMaxTimeout: 1 }) });
   (0, import_module.configureHttpClient)({ baseUrl: "http://localhost:8000" });
-  import_application.Application.registerModule(import_web_server_module.WebServerModule);
-  await import_application.Application.run();
+  import_application.Application.run(import_web_server_module.WebServerModule, clientTest);
 }
 void main();
-void clientTest().catch((error) => console.error(error)).then(async () => (0, import_timing.timeout)(1e3)).then(async () => import_application.Application.shutdown());

package/examples/api/custom-authentication.js

@@ -8,13 +8,15 @@ var import_authentication_service = require("../../authentication/server/authent
 var import_module = require("../../authentication/server/module.js");
 var import_mongo_authentication_credentials_repository = require("../../authentication/server/mongo/mongo-authentication-credentials.repository.js");
 var import_mongo_authentication_session_repository = require("../../authentication/server/mongo/mongo-authentication-session.repository.js");
-var import_container = require("../../container/index.js");
 var import_undici_http_client_adapter = require("../../http/client/adapters/undici-http-client.adapter.js");
 var import_module2 = require("../../http/client/module.js");
 var import_module3 = require("../../http/server/node/module.js");
+var import_decorators = require("../../injector/decorators.js");
+var import_inject = require("../../injector/inject.js");
 var import_module4 = require("../../message-bus/local/module.js");
 var import_modules = require("../../module/modules/index.js");
 var import_schema = require("../../schema/index.js");
+var import_configure = require("../../signals/implementation/configure.js");
 var import_timing = require("../../utils/timing.js");
 var import_undici = require("undici");
 var __decorate = function(decorators, target, key, desc) {
@@ -51,7 +53,7 @@ let CustomTokenPayloadProvider = class CustomTokenPayloadProvider2 extends impor
   }
 };
 CustomTokenPayloadProvider = __decorate([
-  (0, import_container.singleton)()
+  (0, import_decorators.Singleton)()
 ], CustomTokenPayloadProvider);
 (0, import_module.configureAuthenticationServer)({
   serviceOptions: { secret: "djp0fq23576aq" },
@@ -67,22 +69,23 @@ const CustomAuthenticationApiClient = (0, import_client.getAuthenticationApiClie
 });
 (0, import_module4.configureLocalMessageBus)();
 async function serverTest() {
-  const authenticationService = await import_container.container.resolveAsync(import_authentication_service.AuthenticationService);
+  const authenticationService = await (0, import_inject.injectAsync)(import_authentication_service.AuthenticationService);
   await authenticationService.setCredentials("foobar", "supersecret");
 }
 async function clientTest() {
+  const authenticationService = (0, import_inject.inject)(import_client.AuthenticationService);
   await (0, import_timing.timeout)(250);
-  const authenticationService = import_container.container.resolve(import_client.AuthenticationService);
   authenticationService.initialize();
   await authenticationService.login("foobar", "supersecret", { deviceId: "my-device" });
   authenticationService.token$.subscribe((token) => console.log({ token }));
+  import_application.Application.requestShutdown();
 }
 function main() {
+  (0, import_configure.configureDefaultSignalsImplementation)();
   (0, import_module3.configureNodeHttpServer)();
   (0, import_server.configureApiServer)({ controllers: [import_authentication_api_controller.AuthenticationApiController] });
   (0, import_undici_http_client_adapter.configureUndiciHttpClientAdapter)({ dispatcher: new import_undici.Agent({ keepAliveMaxTimeout: 1 }) });
   (0, import_module2.configureHttpClient)({ baseUrl: "http://localhost:8000" });
-  import_application.Application.run(import_modules.WebServerModule);
+  import_application.Application.run(import_modules.WebServerModule, serverTest, clientTest);
 }
 main();
-void serverTest().then(async () => clientTest()).catch((error) => console.error(error)).then(async () => import_application.Application.shutdown());

package/examples/api/streaming.js

@@ -3,12 +3,12 @@ var import_client = require("../../api/client/client.js");
 var import_api = require("../../api/index.js");
 var import_server = require("../../api/server/index.js");
 var import_application = require("../../application/application.js");
-var import_container = require("../../container/index.js");
 var import_core = require("../../core.js");
 var import_undici_http_client_adapter = require("../../http/client/adapters/undici-http-client.adapter.js");
 var import_module = require("../../http/client/module.js");
 var import_server2 = require("../../http/server/index.js");
 var import_node = require("../../http/server/node/index.js");
+var import_inject = require("../../injector/inject.js");
 var import_web_server_module = require("../../module/modules/web-server.module.js");
 var import_sse = require("../../sse/index.js");
 var import_encoding = require("../../utils/encoding.js");
@@ -26,7 +26,8 @@ var __decorate = function(decorators, target, key, desc) {
         r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-const logger = import_container.container.resolve(import_core.CORE_LOGGER);
+(0, import_core.configureTstdl)();
+const logger = import_core.rootInjector.resolve(import_core.CORE_LOGGER);
 const streamingApiDefinition = (0, import_api.defineApi)({
   resource: "streams",
   endpoints: {
@@ -76,8 +77,8 @@ async function* counter() {
 }
 const StreamingApiClient = (0, import_client.compileClient)(streamingApiDefinition);
 async function clientTest() {
+  const streamingApiClient = (0, import_inject.inject)(StreamingApiClient);
   await (0, import_timing.timeout)(250);
-  const streamingApiClient = import_container.container.resolve(StreamingApiClient);
   const response = await streamingApiClient.echo(void 0, (0, import_stream.getReadableStreamFromIterable)(counter()).pipeThrough((0, import_encoding.encodeUtf8Stream)()));
   for await (const responseChunk of (0, import_stream.getReadableStreamIterable)(response.pipeThrough((0, import_encoding.decodeTextStream)()))) {
     logger.info(`response: "${responseChunk}"
@@ -90,10 +91,9 @@ function main() {
   (0, import_server.configureApiServer)({ controllers: [StreamingApi] });
   (0, import_undici_http_client_adapter.configureUndiciHttpClientAdapter)({ dispatcher: new import_undici.Agent({ keepAliveMaxTimeout: 1 }) });
   (0, import_module.configureHttpClient)({ baseUrl: "http://localhost:8000" });
-  import_application.Application.run(import_web_server_module.WebServerModule);
+  import_application.Application.run(import_web_server_module.WebServerModule, clientTest);
 }
 main();
-void clientTest().catch((error) => logger.error(error));
 function eventsSource() {
   const events = new import_sse.ServerSentEventsSource();
   void (async () => {

package/examples/browser/basic.js

@@ -1,22 +1,22 @@
 "use strict";
-var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
 var import_application = require("../../application/index.js");
 var import_browser_service = require("../../browser/browser.service.js");
-var import_container = require("../../container/container.js");
+var import_inject = require("../../injector/inject.js");
 var import_logger = require("../../logger/logger.js");
 var import_timing = require("../../utils/timing.js");
 async function main() {
-  const browserService = await import_container.container.resolveAsync(import_browser_service.BrowserService);
+  const logger = (0, import_inject.inject)(import_logger.Logger).subModule("BROWSER");
+  const browserService = await (0, import_inject.injectAsync)(import_browser_service.BrowserService);
   const browser = await browserService.newBrowser({ headless: false });
   const context = await browser.newContext();
   const page = await context.newPage();
-  const logger = import_container.container.resolve(import_logger.Logger).subModule("BROWSER");
   page.attachLogger(logger);
   await page.navigate("https://google.com");
   await page.getBySelector("//div[text() = 'Alle ablehnen']").click();
   await (0, import_timing.timeout)(1e3);
   const pdf = await page.renderPdf();
-  (0, import_node_fs.writeFileSync)("/tmp/pdf.pdf", pdf);
+  await (0, import_promises.writeFile)("/tmp/pdf.pdf", pdf);
   await page.navigate("file:///tmp/pdf.pdf");
   await page.waitForClose();
 }

package/examples/http/client.js

@@ -1,16 +1,18 @@
 "use strict";
-var import_container = require("../../container/index.js");
+var import_application = require("../../application/application.js");
 var import_undici_http_client_adapter = require("../../http/client/adapters/undici-http-client.adapter.js");
 var import_client = require("../../http/client/index.js");
+var import_inject = require("../../injector/inject.js");
 (0, import_undici_http_client_adapter.configureUndiciHttpClientAdapter)();
 async function main() {
-  const httpClient = import_container.container.resolve(import_client.HttpClient);
+  const httpClient = (0, import_inject.inject)(import_client.HttpClient);
   const response = await httpClient.get("https://httpbin.org/anything/:whatever", {
     parameters: {
       whatever: "foobar",
       anotherParameter: "hello-world"
     }
   });
-  console.log(response.asObject());
+  const body = await response.body.readAsJson();
+  console.log(response.asObject(), body);
 }
-void main();
+import_application.Application.run(main);

package/examples/mail/basic.js

@@ -1,14 +1,18 @@
 "use strict";
 var import_node_path = require("node:path");
 var import_node_url = require("node:url");
-var import_container = require("../../container/index.js");
+var import_application = require("../../application/application.js");
+var import_inject = require("../../injector/inject.js");
 var import_nodemailer_mail_client = require("../../mail/clients/nodemailer.mail-client.js");
 var import_mail = require("../../mail/index.js");
 var import_templates = require("../../templates/index.js");
 var import_file_template_provider = require("../../templates/providers/file.template-provider.js");
 var import_handlebars_template_renderer = require("../../templates/renderers/handlebars.template-renderer.js");
+var import_jsx_template_renderer = require("../../templates/renderers/jsx.template-renderer.js");
 var import_mjml_template_renderer = require("../../templates/renderers/mjml.template-renderer.js");
+var import_string_template_renderer = require("../../templates/renderers/string.template-renderer.js");
 var import_file_template_resolver = require("../../templates/resolvers/file.template-resolver.js");
+var import_string_template_resolver = require("../../templates/resolvers/string.template-resolver.js");
 var import_config_parser = require("../../utils/config-parser.js");
 var import_core = require("../../core.js");
 const import_meta = {};
@@ -32,13 +36,14 @@ try {
 });
 (0, import_templates.configureTemplates)({
   templateProvider: import_file_template_provider.FileTemplateProvider,
-  templateRenderers: [import_mjml_template_renderer.MjmlTemplateRenderer, import_handlebars_template_renderer.HandlebarsTemplateRenderer]
+  templateRenderers: [import_mjml_template_renderer.MjmlTemplateRenderer, import_handlebars_template_renderer.HandlebarsTemplateRenderer, import_jsx_template_renderer.JsxTemplateRenderer, import_string_template_renderer.StringTemplateRenderer],
+  templateResolvers: [import_string_template_resolver.StringTemplateResolver]
 });
 (0, import_file_template_provider.configureFileTemplateProvider)({ basePath: (0, import_node_path.resolve)(dirname, "templates") });
 (0, import_file_template_resolver.configureFileTemplateResolver)({ basePath: (0, import_node_path.resolve)(dirname.replace("/dist", "/source"), "templates") });
 async function test() {
-  const service = await import_container.container.resolveAsync(import_mail.MailService);
+  const service = await (0, import_inject.injectAsync)(import_mail.MailService);
   const result = await service.sendTemplate("hello-name", { from: (0, import_config_parser.string)("FROM", (0, import_config_parser.string)("USER", "user@example.com")), to: (0, import_config_parser.string)("TO", "user@example.com") }, { name: "Max Mustermann" });
   console.log(result);
 }
-void test();
+import_application.Application.run(test);