@tstdl/base 0.89.5 → 0.89.7

package/application/application.d.ts

@@ -7,9 +7,10 @@ import type { FunctionModuleFunction } from '../module/modules/function.module.j
 import type { OneOrMany, Type } from '../types.js';
 export type BootstrapFn = () => void | Promise<void>;
 export type RunOptions = {
-    bootstrap?: BootstrapFn;
+    bootstrap?: OneOrMany<BootstrapFn>;
 };
-export declare class Application implements Resolvable<LoggerArgument> {
+export type ApplicationArgument = LoggerArgument;
+export declare class Application implements Resolvable<ApplicationArgument> {
     #private;
     static _instance: Application | undefined;
     private static get instance();

package/application/application.js

@@ -16,6 +16,7 @@ import { ModuleState } from '../module/module.js';
 import { FunctionModule } from '../module/modules/function.module.js';
 import { getShutdownSignal, getShutdownToken } from '../process-shutdown.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
+import { toArray } from '../utils/array/array.js';
 import { mapAsync } from '../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
 import { isDefined, isFunction, isObject, isUndefined } from '../utils/type-guards.js';
@@ -68,6 +69,9 @@ let Application = class Application {
         this.registerModule(module);
     }
     run(...optionsFunctionsAndModules) {
+        if (this.#shutdownToken.isSet) {
+            throw new Error('Application was shut down.');
+        }
         const options = ((optionsFunctionsAndModules.length > 0) && isObject(optionsFunctionsAndModules[0])) ? optionsFunctionsAndModules[0] : undefined;
         const functionsAndModules = (isUndefined(options) ? optionsFunctionsAndModules : optionsFunctionsAndModules.slice(1));
         void this._run(functionsAndModules, options);
@@ -95,7 +99,9 @@ let Application = class Application {
             }
         }
         if (isDefined(options.bootstrap)) {
-            await runInInjectionContext(this.#injector, options.bootstrap);
+            for (const fn of toArray(options.bootstrap)) {
+                await runInInjectionContext(this.#injector, fn);
+            }
         }
         const modules = await toArrayAsync(mapAsync(this.#moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? this.#injector.resolveAsync(instanceOrType) : instanceOrType)));
         try {

package/migration/migrator.d.ts

@@ -1,6 +1,3 @@
-import { LockProvider } from '../lock/index.js';
-import { Logger } from '../logger/index.js';
-import { MigrationStateRepository } from './migration-state-repository.js';
 export type MigrationDefinition<T = void> = {
     name: string;
     migrations: Migration<T>[];
@@ -21,9 +18,6 @@ export type MigrationResult<T> = {
     restartRequested: boolean;
 };
 export declare class Migrator {
-    private readonly migrationStateRepository;
-    private readonly lockProvider;
-    private readonly logger;
-    constructor(migrationStateRepository: MigrationStateRepository, lockProvider: LockProvider, logger: Logger);
+    #private;
     migrate<T>({ name, migrations }: MigrationDefinition<T>): Promise<MigrationResult<T>[]>;
 }

package/migration/migrator.js

@@ -4,14 +4,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) 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;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
 import { CancellationToken } from '../cancellation/index.js';
-import { ResolveArg, Singleton } from '../injector/index.js';
+import { Injector, Singleton, inject, runInInjectionContext } from '../injector/index.js';
 import { LockProvider } from '../lock/index.js';
 import { Logger } from '../logger/index.js';
 import { toArray } from '../utils/array/array.js';
@@ -21,20 +15,16 @@ import { Timer } from '../utils/timer.js';
 import { isDefined } from '../utils/type-guards.js';
 import { MigrationStateRepository } from './migration-state-repository.js';
 let Migrator = class Migrator {
-    migrationStateRepository;
-    lockProvider;
-    logger;
-    constructor(migrationStateRepository, lockProvider, logger) {
-        this.migrationStateRepository = migrationStateRepository;
-        this.lockProvider = lockProvider;
-        this.logger = logger;
-    }
+    #injector = inject(Injector);
+    #migrationStateRepository = inject(MigrationStateRepository);
+    #lockProvider = inject(LockProvider, 'migrator:');
+    #logger = inject(Logger, 'Migrator');
     // eslint-disable-next-line max-statements, max-lines-per-function
     async migrate({ name, migrations }) {
         if (migrations.length == 0) {
-            throw new Error('no migrations provided');
+            throw new Error('No migrations provided.');
         }
-        const lock = this.lockProvider.get(`${name}`);
+        const lock = this.#lockProvider.get(`${name}`);
         // eslint-disable-next-line max-statements, max-lines-per-function
         const { result } = await lock.use(30000, true, async () => {
             const results = [];
@@ -43,7 +33,7 @@ let Migrator = class Migrator {
                 const control = {
                     restart: () => restartToken.set()
                 };
-                const currentState = await this.migrationStateRepository.tryLoadByFilter({ name });
+                const currentState = await this.#migrationStateRepository.tryLoadByFilter({ name });
                 const currentRevision = currentState?.revision ?? 'init';
                 const latestRevision = migrations.sort(compareByValueSelectionDescending((migration) => migration.to))[0].to;
                 if (currentRevision == latestRevision) {
@@ -51,29 +41,29 @@ let Migrator = class Migrator {
                 }
                 const suitableMigrations = migrations.filter((migration) => toArray(migration.from).includes(currentRevision));
                 if (suitableMigrations.length == 0) {
-                    throw new Error(`no suitable migration path from current revision ${currentRevision} to latest revision ${latestRevision} found`);
+                    throw new Error(`No suitable migration path from current revision ${currentRevision} to latest revision ${latestRevision} found.`);
                 }
                 const migration = suitableMigrations.sort(compareByValueSelectionDescending((m) => m.to))[0];
-                this.logger.warn(`starting migration for "${name}" from revision ${currentRevision} to ${migration.to}`);
+                this.#logger.warn(`Starting migration for "${name}" from revision ${currentRevision} to ${migration.to}.`);
                 let migratorResult;
-                const time = await Timer.measureAsync(async () => (migratorResult = await migration.migrator(control)));
+                const time = await Timer.measureAsync(async () => (migratorResult = await runInInjectionContext(this.#injector, async () => migration.migrator(control))));
                 results.push({ from: currentRevision, to: migration.to, time, result: migratorResult, restartRequested: restartToken.isSet });
                 if (restartToken.isSet) {
-                    this.logger.warn(`finished migration in ${round(time / 1000, 2)} seconds`);
-                    this.logger.warn('migration-restart requested');
+                    this.#logger.warn(`Finished migration in ${round(time / 1000, 2)} seconds.`);
+                    this.#logger.warn('Migration-restart requested.');
                     continue;
                 }
                 if (isDefined(currentState)) {
-                    await this.migrationStateRepository.patchByFilter({ name }, { revision: migration.to });
+                    await this.#migrationStateRepository.patchByFilter({ name }, { revision: migration.to });
                 }
                 else {
                     const newState = {
                         name,
                         revision: migration.to
                     };
-                    await this.migrationStateRepository.insert(newState);
+                    await this.#migrationStateRepository.insert(newState);
                 }
-                this.logger.warn(`finished migration in ${round(time / 1000, 2)} seconds`);
+                this.#logger.warn(`Finished migration in ${round(time / 1000, 2)} seconds.`);
             }
             return results;
         });
@@ -81,9 +71,6 @@ let Migrator = class Migrator {
     }
 };
 Migrator = __decorate([
-    Singleton(),
-    __param(1, ResolveArg('migrator:')),
-    __param(2, ResolveArg('Migrator')),
-    __metadata("design:paramtypes", [MigrationStateRepository, LockProvider, Logger])
+    Singleton()
 ], Migrator);
 export { Migrator };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.89.5",
+  "version": "0.89.7",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -130,7 +130,7 @@
     "typescript": "5.2"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.9",
+    "@elastic/elasticsearch": "^8.10",
     "@koa/router": "^12.0",
     "@tstdl/angular": "^0.89",
     "@zxcvbn-ts/core": "^3.0",
@@ -146,7 +146,7 @@
     "mongodb": "^6.1",
     "nodemailer": "^6.9",
     "playwright": "^1.38",
-    "preact": "^10.17",
+    "preact": "^10.18",
     "preact-render-to-string": "^6.2",
     "undici": "^5.25",
     "urlpattern-polyfill": "^9.0"