@tstdl/base 0.92.167 → 0.93.0

package/lock/mongo/index.d.ts

@@ -1,5 +0,0 @@
-export * from './lock.js';
-export * from './model.js';
-export * from './module.js';
-export * from './mongo-lock-repository.js';
-export * from './provider.js';

package/lock/mongo/index.js

@@ -1,5 +0,0 @@
-export * from './lock.js';
-export * from './model.js';
-export * from './module.js';
-export * from './mongo-lock-repository.js';
-export * from './provider.js';

package/lock/mongo/lock.d.ts

@@ -1,14 +0,0 @@
-import type { AcquireResult, LockedFunction, UsingResult } from '../../lock/index.js';
-import { Lock } from '../../lock/index.js';
-import { Logger } from '../../logger/index.js';
-import { MongoLockRepository } from './mongo-lock-repository.js';
-export declare class MongoLock extends Lock {
-    #private;
-    constructor(lockRepository: MongoLockRepository, resource: string, logger: Logger);
-    acquire<Throw extends boolean>(timeout: number | undefined, throwOnFail: Throw): Promise<AcquireResult<Throw>>;
-    use<Throw extends boolean, R>(timeout: number | undefined, throwOnFail: Throw, func: LockedFunction<R>): Promise<UsingResult<Throw, R>>;
-    exists(): Promise<boolean>;
-    private tryAcquireOrRefresh;
-    private tryRefresh;
-    private release;
-}

package/lock/mongo/lock.js

@@ -1,125 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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);
-};
-import { CancellationToken } from '../../cancellation/index.js';
-import { Injectable } from '../../injector/decorators.js';
-import { Lock } from '../../lock/index.js';
-import { Logger } from '../../logger/index.js';
-import { Alphabet } from '../../utils/alphabet.js';
-import { currentTimestamp } from '../../utils/date-time.js';
-import { getRandomString } from '../../utils/random.js';
-import { Timer } from '../../utils/timer.js';
-import { cancelableTimeoutUntil, timeout as utilsTimeout } from '../../utils/timing.js';
-import { assertStringPass, isObject, isUndefined } from '../../utils/type-guards.js';
-import { MongoLockRepository } from './mongo-lock-repository.js';
-import { MongoLockProvider } from './provider.js';
-const expirationTime = 10000;
-const renewBuffer = expirationTime / 2;
-let MongoLock = class MongoLock extends Lock {
-    #lockRepository;
-    #logger;
-    constructor(lockRepository, resource, logger) {
-        super(resource);
-        this.#lockRepository = lockRepository;
-        this.#logger = logger;
-    }
-    async acquire(timeout, throwOnFail) {
-        const key = getRandomString(15, Alphabet.LowerUpperCaseNumbers);
-        const timeoutDuration = Math.max(50, Math.min(1000, (timeout ?? 0) / 10));
-        let result = false;
-        const timer = new Timer(true);
-        while ((result == false) && (isUndefined(timeout) || (timer.milliseconds < timeout))) {
-            result = await this.tryAcquireOrRefresh(this.resource, key);
-            if ((result == false) && isUndefined(timeout)) {
-                break;
-            }
-            if (result == false) {
-                await utilsTimeout(timeoutDuration);
-            }
-        }
-        if (result == false) {
-            if (throwOnFail) {
-                throw new Error('Failed to acquire lock.');
-            }
-            return false;
-        }
-        let expiration = result;
-        const releaseToken = new CancellationToken();
-        const controller = {
-            get lost() {
-                return currentTimestamp() >= expiration.valueOf();
-            },
-            release: async () => {
-                releaseToken.set();
-                await this.release(this.resource, key);
-            }
-        };
-        void (async () => {
-            await cancelableTimeoutUntil(expiration.valueOf() - renewBuffer, releaseToken);
-            while (!releaseToken.isSet && !controller.lost) {
-                try {
-                    const refreshResult = await this.tryRefresh(this.resource, key);
-                    expiration = (refreshResult == false) ? new Date(0) : refreshResult;
-                }
-                catch (error) {
-                    this.#logger.error(error);
-                }
-                finally {
-                    await cancelableTimeoutUntil(Math.max(currentTimestamp() + 1000, expiration.valueOf() - renewBuffer), releaseToken);
-                }
-            }
-        })();
-        return controller;
-    }
-    async use(timeout, throwOnFail, func) {
-        const controller = await this.acquire(timeout, throwOnFail);
-        if (controller == false) {
-            return { success: false, result: undefined };
-        }
-        try {
-            const result = await func(controller);
-            return { success: true, result };
-        }
-        finally {
-            await controller.release();
-        }
-    }
-    async exists() {
-        return this.#lockRepository.exists(this.resource);
-    }
-    async tryAcquireOrRefresh(resource, key) {
-        const expirationDate = getExpirationDate();
-        return this.#lockRepository.tryInsertOrRefresh(resource, key, expirationDate);
-    }
-    async tryRefresh(resource, key) {
-        const expiration = getExpirationDate();
-        return this.#lockRepository.tryUpdateExpiration(resource, key, expiration);
-    }
-    async release(resource, key) {
-        return this.#lockRepository.deleteByResource(resource, key);
-    }
-};
-MongoLock = __decorate([
-    Injectable({
-        provider: {
-            useFactory: (argument, context) => {
-                const arg = argument;
-                const prefix = isObject(arg) ? assertStringPass(arg.prefix, 'invalid lock argument') : undefined;
-                const resource = assertStringPass(isObject(arg) ? arg.resource : arg, 'invalid lock argument');
-                const provider = context.resolve(MongoLockProvider, prefix);
-                return provider.get(resource);
-            }
-        }
-    }),
-    __metadata("design:paramtypes", [MongoLockRepository, String, Logger])
-], MongoLock);
-export { MongoLock };
-function getExpirationDate() {
-    return new Date(currentTimestamp() + expirationTime);
-}

package/lock/mongo/model.d.ts

@@ -1,6 +0,0 @@
-import type { Entity } from '../../database/index.js';
-export type MongoLockEntity = Entity & {
-    resource: string;
-    key: string;
-    expiration: Date;
-};

package/lock/mongo/model.js

@@ -1 +0,0 @@
-export {};

package/lock/mongo/module.d.ts

@@ -1,12 +0,0 @@
-import type { MongoRepositoryConfig } from '../../database/mongo/index.js';
-import type { MongoLockEntity } from './model.js';
-export type MongoLockModuleConfig = {
-    lockEntityRepositoryConfig: MongoRepositoryConfig<MongoLockEntity> | undefined;
-};
-export declare const mongoLockModuleConfig: MongoLockModuleConfig;
-/**
- * configure mongo lock module
- * @param lockRepositoryConfig repository configuration for locks
- * @param register whether to register for {@link Lock} and {@link LockProvider}
- */
-export declare function configureMongoLock(lockRepositoryConfig: MongoRepositoryConfig<MongoLockEntity>, register?: boolean): void;

package/lock/mongo/module.js

@@ -1,20 +0,0 @@
-import { Injector } from '../../injector/injector.js';
-import { Lock } from '../lock.js';
-import { LockProvider } from '../provider.js';
-import { MongoLock } from './lock.js';
-import { MongoLockProvider } from './provider.js';
-export const mongoLockModuleConfig = {
-    lockEntityRepositoryConfig: undefined
-};
-/**
- * configure mongo lock module
- * @param lockRepositoryConfig repository configuration for locks
- * @param register whether to register for {@link Lock} and {@link LockProvider}
- */
-export function configureMongoLock(lockRepositoryConfig, register = true) {
-    mongoLockModuleConfig.lockEntityRepositoryConfig = lockRepositoryConfig;
-    if (register) {
-        Injector.registerSingleton(LockProvider, { useToken: MongoLockProvider });
-        Injector.register(Lock, { useToken: MongoLock });
-    }
-}

package/lock/mongo/mongo-lock-repository.d.ts

@@ -1,14 +0,0 @@
-import type { CollectionArgument } from '../../database/mongo/index.js';
-import { Collection, MongoEntityRepository } from '../../database/mongo/index.js';
-import { resolveArgumentType } from '../../injector/index.js';
-import type { Resolvable } from '../../injector/interfaces.js';
-import { Logger } from '../../logger/index.js';
-import type { MongoLockEntity } from './model.js';
-export declare class MongoLockRepository extends MongoEntityRepository<MongoLockEntity> implements Resolvable<CollectionArgument<MongoLockEntity>> {
-    readonly [resolveArgumentType]: CollectionArgument<MongoLockEntity>;
-    constructor(collection: Collection<MongoLockEntity>, logger: Logger);
-    tryInsertOrRefresh(resource: string, key: string, newExpirationDate: Date): Promise<false | Date>;
-    exists(resource: string): Promise<boolean>;
-    tryUpdateExpiration(resource: string, key: string, expirationDate: Date): Promise<false | Date>;
-    deleteByResource(resource: string, key: string): Promise<boolean>;
-}

package/lock/mongo/mongo-lock-repository.js

@@ -1,67 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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 { getNewId } from '../../database/index.js';
-import { Collection, MongoEntityRepository, noopTransformer } from '../../database/mongo/index.js';
-import { ForwardArg, Singleton, resolveArgumentType } from '../../injector/index.js';
-import { Logger } from '../../logger/index.js';
-import { now } from '../../utils/date-time.js';
-import { MongoError } from 'mongodb';
-const indexes = [
-    { key: { resource: 1 }, unique: true },
-    { key: { expiration: 1 }, expireAfterSeconds: 1 }
-];
-let MongoLockRepository = class MongoLockRepository extends MongoEntityRepository {
-    constructor(collection, logger) {
-        super(collection, noopTransformer, { logger, indexes });
-    }
-    async tryInsertOrRefresh(resource, key, newExpirationDate) {
-        const filter = {
-            $and: [
-                { resource },
-                {
-                    $or: [
-                        { key },
-                        { expiration: { $lte: now() } }
-                    ]
-                }
-            ]
-        };
-        try {
-            const { upsertedCount, modifiedCount } = await this.baseRepository.collection.updateOne(filter, { $set: { expiration: newExpirationDate }, $setOnInsert: { _id: getNewId(), key } }, { upsert: true });
-            return ((upsertedCount > 0) || (modifiedCount > 0)) ? newExpirationDate : false;
-        }
-        catch (error) {
-            if (error instanceof MongoError && error.code == 11000) {
-                return false;
-            }
-            throw error;
-        }
-    }
-    async exists(resource) {
-        return this.baseRepository.hasByFilter({ resource, expiration: { $gt: now() } });
-    }
-    async tryUpdateExpiration(resource, key, expirationDate) {
-        const filter = { resource, key };
-        const result = await this.baseRepository.update(filter, { $set: { expiration: expirationDate } });
-        return (result.modifiedCount > 0) ? expirationDate : false;
-    }
-    async deleteByResource(resource, key) {
-        return this.baseRepository.deleteByFilter({ resource, key });
-    }
-};
-MongoLockRepository = __decorate([
-    Singleton(),
-    __param(0, ForwardArg()),
-    __metadata("design:paramtypes", [Collection, Logger])
-], MongoLockRepository);
-export { MongoLockRepository };

package/lock/mongo/provider.d.ts

@@ -1,8 +0,0 @@
-import type { Lock } from '../../lock/index.js';
-import { LockProvider } from '../../lock/index.js';
-export declare class MongoLockProvider extends LockProvider {
-    #private;
-    prefix(prefix: string): MongoLockProvider;
-    get(resource: string): Lock;
-    private getResourceString;
-}

package/lock/mongo/provider.js

@@ -1,36 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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 MongoLockProvider_1;
-import { Singleton } from '../../injector/decorators.js';
-import { inject, injectArgument } from '../../injector/inject.js';
-import { Injector } from '../../injector/injector.js';
-import { LockProvider } from '../../lock/index.js';
-import { Logger } from '../../logger/index.js';
-import { assertDefinedPass, isDefined } from '../../utils/type-guards.js';
-import { MongoLock } from './lock.js';
-import { mongoLockModuleConfig } from './module.js';
-import { MongoLockRepository } from './mongo-lock-repository.js';
-let MongoLockProvider = MongoLockProvider_1 = class MongoLockProvider extends LockProvider {
-    #injector = inject(Injector);
-    #lockRepository = inject(MongoLockRepository, assertDefinedPass(mongoLockModuleConfig.lockEntityRepositoryConfig, 'mongo lock module not configured'));
-    #logger = inject(Logger, 'MongoLock');
-    #prefix = injectArgument(this, { optional: true });
-    prefix(prefix) {
-        return this.#injector.resolve(MongoLockProvider_1, this.getResourceString(prefix));
-    }
-    get(resource) {
-        return new MongoLock(this.#lockRepository, this.getResourceString(resource), this.#logger);
-    }
-    getResourceString(resource) {
-        const prefixDivider = (isDefined(this.#prefix) && (this.#prefix.length > 0)) ? ':' : '';
-        return `${this.#prefix}${prefixDivider}${resource}`;
-    }
-};
-MongoLockProvider = MongoLockProvider_1 = __decorate([
-    Singleton()
-], MongoLockProvider);
-export { MongoLockProvider };

package/logger/console/index.d.ts

@@ -1 +0,0 @@
-export * from './logger.js';

package/logger/console/index.js

@@ -1 +0,0 @@
-export * from './logger.js';

package/logger/console/logger.d.ts

@@ -1,11 +0,0 @@
-import { LogLevel } from '../level.js';
-import type { LogErrorOptions, LoggerForkOptions } from '../logger.js';
-import { Logger } from '../logger.js';
-export declare class ConsoleLogger extends Logger {
-    private readonly entryPrefix;
-    constructor(level: LogLevel, module?: string | string[], prefix?: string);
-    fork(options: LoggerForkOptions): ConsoleLogger;
-    subModule(subModule: string): ConsoleLogger;
-    prefix(prefix: string): ConsoleLogger;
-    protected log(level: LogLevel, entryOrError: string | unknown, errorOptions?: LogErrorOptions): void;
-}

package/logger/console/logger.js

@@ -1,64 +0,0 @@
-/* eslint-disable no-console */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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 ConsoleLogger_1;
-import { Singleton } from '../../injector/decorators.js';
-import { now } from '../../utils/date-time.js';
-import { formatError } from '../../utils/format-error.js';
-import { isDefined, isObject, isString } from '../../utils/type-guards.js';
-import { LogLevel } from '../level.js';
-import { Logger } from '../logger.js';
-import { LOG_LEVEL } from '../tokens.js';
-const consoleLevelFuncMap = {
-    [LogLevel.Error]: 'error',
-    [LogLevel.Warn]: 'warn',
-    [LogLevel.Info]: 'info',
-    [LogLevel.Verbose]: 'info',
-    [LogLevel.Debug]: 'debug',
-    [LogLevel.Trace]: 'debug'
-};
-let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger extends Logger {
-    entryPrefix;
-    constructor(level, module, prefix) {
-        super(level, module, prefix);
-        const modulePrefix = isDefined(this.module) ? this.module.map((m) => `[${m}]`).join(' ') : '';
-        this.entryPrefix = `${modulePrefix}${modulePrefix.length > 0 ? ' ' : ''}${this.logPrefix}`;
-    }
-    fork(options) {
-        const level = options.level ?? this.level;
-        const module = isDefined(options.subModule) ? [...(this.module ?? []), options.subModule] : this.module;
-        return new ConsoleLogger_1(level, module, isDefined(options.subModule) ? options.prefix : (options.prefix ?? this.logPrefix));
-    }
-    subModule(subModule) {
-        return new ConsoleLogger_1(this.level, [...(this.module ?? []), subModule]);
-    }
-    prefix(prefix) {
-        return new ConsoleLogger_1(this.level, this.module, `${prefix}${this.logPrefix}`);
-    }
-    log(level, entryOrError, errorOptions) {
-        const entry = isString(entryOrError) ? entryOrError : formatError(entryOrError, errorOptions);
-        const dateString = now().toISOString();
-        console[consoleLevelFuncMap[level]](`${dateString} - ${this.entryPrefix}${entry}`);
-    }
-};
-ConsoleLogger = ConsoleLogger_1 = __decorate([
-    Singleton({
-        provider: {
-            useFactory: (argument, context) => {
-                if (isObject(argument)) {
-                    return new ConsoleLogger(argument.level ?? context.resolve(LOG_LEVEL), argument.module, argument.prefix);
-                }
-                return new ConsoleLogger(context.resolve(LOG_LEVEL), argument, undefined);
-            }
-        }
-    }),
-    __metadata("design:paramtypes", [Number, Object, String])
-], ConsoleLogger);
-export { ConsoleLogger };

package/logger/noop/index.d.ts

@@ -1 +0,0 @@
-export * from './logger.js';

package/logger/noop/index.js

@@ -1 +0,0 @@
-export * from './logger.js';

package/logger/noop/logger.d.ts

@@ -1,9 +0,0 @@
-import { Logger } from '../logger.js';
-export declare class NoopLogger extends Logger {
-    constructor();
-    fork(): Logger;
-    subModule(): Logger;
-    prefix(): Logger;
-    protected log(): void;
-}
-export declare const noopLogger: NoopLogger;

package/logger/noop/logger.js

@@ -1,21 +0,0 @@
-/* eslint-disable class-methods-use-this, @typescript-eslint/no-empty-function */
-import { LogLevel } from '../level.js';
-import { Logger } from '../logger.js';
-export class NoopLogger extends Logger {
-    constructor() {
-        super(LogLevel.Trace, '', '');
-    }
-    fork() {
-        return this;
-    }
-    subModule() {
-        return this;
-    }
-    prefix() {
-        return this;
-    }
-    log() {
-        // noop
-    }
-}
-export const noopLogger = new NoopLogger();

package/migration/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Application database migration
- *
- * @module Migration
- */
-export * from './migration-state-repository.js';
-export * from './migration-state.js';
-export * from './migrator.js';
-export * from './mongo/index.js';

package/migration/index.js

@@ -1,9 +0,0 @@
-/**
- * Application database migration
- *
- * @module Migration
- */
-export * from './migration-state-repository.js';
-export * from './migration-state.js';
-export * from './migrator.js';
-export * from './mongo/index.js';

package/migration/migration-state-repository.d.ts

@@ -1,4 +0,0 @@
-import { EntityRepository } from '../database/index.js';
-import type { MigrationState } from './migration-state.js';
-export declare abstract class MigrationStateRepository extends EntityRepository<MigrationState> {
-}

package/migration/migration-state-repository.js

@@ -1,3 +0,0 @@
-import { EntityRepository } from '../database/index.js';
-export class MigrationStateRepository extends EntityRepository {
-}

package/migration/migration-state.d.ts

@@ -1,6 +0,0 @@
-import type { Entity, NewEntity } from '../database/index.js';
-export type MigrationState = Entity & {
-    name: string;
-    revision: number;
-};
-export type NewMigrationState = NewEntity<MigrationState>;

package/migration/migration-state.js

@@ -1 +0,0 @@
-export {};

package/migration/migrator.d.ts

@@ -1,23 +0,0 @@
-export type MigrationDefinition<T = void> = {
-    name: string;
-    migrations: Migration<T>[];
-};
-export type Migration<T = void> = {
-    from: 'init' | number | number[];
-    to: number;
-    migrator: (control: MigrationControl) => Promise<T> | T;
-};
-export type MigrationControl = {
-    restart: () => void;
-};
-export type MigrationResult<T> = {
-    from: 'init' | number;
-    to: number;
-    time: number;
-    result: T;
-    restartRequested: boolean;
-};
-export declare class Migrator {
-    #private;
-    migrate<T>({ name, migrations }: MigrationDefinition<T>): Promise<MigrationResult<T>[]>;
-}

package/migration/migrator.js

@@ -1,76 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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;
-};
-import { CancellationToken } from '../cancellation/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';
-import { compareByValueSelectionDescending } from '../utils/comparison.js';
-import { round } from '../utils/math.js';
-import { Timer } from '../utils/timer.js';
-import { isDefined } from '../utils/type-guards.js';
-import { MigrationStateRepository } from './migration-state-repository.js';
-let Migrator = class Migrator {
-    #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.');
-        }
-        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 = [];
-            while (true) {
-                const restartToken = new CancellationToken();
-                const control = {
-                    restart: () => restartToken.set()
-                };
-                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) {
-                    break;
-                }
-                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.`);
-                }
-                const migration = suitableMigrations.sort(compareByValueSelectionDescending((m) => m.to))[0];
-                this.#logger.warn(`Starting migration for "${name}" from revision ${currentRevision} to ${migration.to}.`);
-                let migratorResult;
-                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.');
-                    continue;
-                }
-                if (isDefined(currentState)) {
-                    await this.#migrationStateRepository.patchByFilter({ name }, { revision: migration.to });
-                }
-                else {
-                    const newState = {
-                        name,
-                        revision: migration.to
-                    };
-                    await this.#migrationStateRepository.insert(newState);
-                }
-                this.#logger.warn(`Finished migration in ${round(time / 1000, 2)} seconds.`);
-            }
-            return results;
-        });
-        return result;
-    }
-};
-Migrator = __decorate([
-    Singleton()
-], Migrator);
-export { Migrator };

package/migration/mongo/index.d.ts

@@ -1,2 +0,0 @@
-export * from './migration-state-repository.js';
-export * from './module.js';

package/migration/mongo/index.js

@@ -1,2 +0,0 @@
-export * from './migration-state-repository.js';
-export * from './module.js';

package/migration/mongo/migration-state-repository.d.ts

@@ -1,11 +0,0 @@
-import type { Resolvable } from '../../injector/index.js';
-import { resolveArgumentType } from '../../injector/index.js';
-import { Logger } from '../../logger/index.js';
-import type { MigrationState, MigrationStateRepository } from '../../migration/index.js';
-import type { CollectionArgument } from '../../database/mongo/classes.js';
-import { Collection } from '../../database/mongo/classes.js';
-import { MongoEntityRepository } from '../../database/mongo/mongo-entity-repository.js';
-export declare class MongoMigrationStateRepository extends MongoEntityRepository<MigrationState> implements MigrationStateRepository, Resolvable<CollectionArgument<MigrationState>> {
-    readonly [resolveArgumentType]: CollectionArgument<MigrationState>;
-    constructor(collection: Collection<MigrationState>, logger: Logger);
-}