zibri 2.3.0 → 2.4.0

package/src/context/request/request-context-token.model.ts

@@ -0,0 +1,110 @@
+import { randomBytes } from 'node:crypto';
+
+import { HttpRequestContext } from './http-request.context';
+import { WebsocketRequestContext } from './websocket-request.context';
+import { TwoFactorServiceInterface } from '../../auth/2fa/two-factor-service.interface';
+import { AuthServiceInterface } from '../../auth/auth-service.interface';
+import { CurrentUserMetadata } from '../../auth/decorators/current-user.decorator';
+import { BaseUser } from '../../auth/models/base-user.model';
+import { IsLoggedInMetadata } from '../../auth/models/is-logged-in-metadata.model';
+import { ZIBRI_DI_TOKENS } from '../../di/default/zibri-di-tokens.default';
+import { inject } from '../../di/inject.function';
+import { KnownHeader } from '../../http/known-header.enum';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { UUIDUtilities } from '../../utilities/uuid.utilities';
+
+const allRequestContextTokenKeys: Set<string> = new Set();
+
+/**
+ * Defines a request context token for the given key.
+ */
+export class RequestContextToken<T> {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    protected readonly __brand?: T;
+
+    constructor(
+        readonly key: string,
+        readonly fn: (ctx: HttpRequestContext | WebsocketRequestContext) => T
+    ) {
+        if (allRequestContextTokenKeys.has(key)) {
+            throw new Error([`A RequestContextToken with the key "${key}" already exists.`].join('\n'));
+        }
+        allRequestContextTokenKeys.add(key);
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    toString(): string {
+        return this.key;
+    }
+}
+
+/**
+ * Tokens for the current request.
+ */
+// eslint-disable-next-line typescript/typedef
+export const ZIBRI_REQUEST_CONTEXT_TOKENS = {
+    NONCE: new RequestContextToken(
+        'nonce',
+        () => randomBytes(16).toString('base64')
+    ),
+    CORRELATION_ID: new RequestContextToken<string>(
+        'correlation_id',
+        ctx => {
+            const correlationIdHeader: string = inject(ZIBRI_DI_TOKENS.CORRELATION_ID_HEADER);
+            return ctx.request.headers[correlationIdHeader as KnownHeader] ?? UUIDUtilities.generate();
+        }
+    ),
+    CURRENT_USER: new RequestContextToken(
+        'current_user',
+        async ctx => {
+            const authService: AuthServiceInterface = inject(ZIBRI_DI_TOKENS.AUTH_SERVICE);
+            if (!ctx.controllerClass || !ctx.controllerMethod) {
+                return await authService.getCurrentUser(ctx, authService.strategies, false);
+            }
+
+            const currentUserMetadata: CurrentUserMetadata | undefined = MetadataUtilities.getRouteCurrentUser(
+                ctx.controllerClass,
+                ctx.controllerMethod
+            );
+
+            return await authService.getCurrentUser(
+                ctx,
+                currentUserMetadata?.allowedStrategies ?? authService.strategies,
+                currentUserMetadata?.required ?? false
+            );
+        }
+    ),
+    IS_LOGGED_IN: new RequestContextToken(
+        'is_logged_in',
+        async ctx => {
+            const authService: AuthServiceInterface = inject(ZIBRI_DI_TOKENS.AUTH_SERVICE);
+            if (!ctx.controllerClass || !ctx.controllerMethod) {
+                return await authService.isLoggedIn(ctx, authService.strategies);
+            }
+
+            const isLoggedInMetadata: IsLoggedInMetadata | undefined = await authService.resolveIsLoggedInMetadata(
+                ctx.controllerClass,
+                ctx.controllerMethod
+            );
+            return await authService.isLoggedIn(
+                ctx,
+                isLoggedInMetadata?.allowedStrategies ?? authService.strategies
+            );
+        }
+    ),
+    HAS_2FA: new RequestContextToken(
+        'has_2fa',
+        async (ctx): Promise<boolean> => {
+            const twoFactorService: TwoFactorServiceInterface = inject(ZIBRI_DI_TOKENS.TWO_FACTOR_SERVICE);
+            if (!ctx.controllerClass || !ctx.controllerMethod) {
+                return false;
+            }
+
+            const user: BaseUser<string> | undefined = await ctx.get(ZIBRI_REQUEST_CONTEXT_TOKENS.CURRENT_USER);
+            if (!user) {
+                return false;
+            }
+            return await twoFactorService.has2fa(user, ctx);
+        }
+    )
+} as const satisfies Record<string, RequestContextToken<unknown>>;

package/src/context/request/websocket-request.context.ts

@@ -0,0 +1,43 @@
+import { RequestContextToken } from './request-context-token.model';
+import { Newable } from '../../types/newable.type';
+import { BaseWebsocketConnection } from '../../websocket/models/connection/base-websocket-connection.model';
+import { WebsocketRequest } from '../../websocket/models/websocket-request.model';
+import { BaseContext } from '../base-context';
+
+/**
+ * The context of an incoming websocket request.
+ */
+export class WebsocketRequestContext extends BaseContext<'websocket-request'> {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    readonly type: 'websocket-request' = 'websocket-request';
+
+    constructor(
+        readonly request: WebsocketRequest,
+        readonly connection: BaseWebsocketConnection | undefined,
+        readonly controllerClass: Newable<unknown> | undefined,
+        readonly controllerMethod: string | undefined
+    ) {
+        super();
+    }
+
+    /**
+     * Whether or not a value for the given token has been cached.
+     * @param token - The token to check.
+     * @returns True if a value has been cached, false otherwise.
+     */
+    has<T>(token: RequestContextToken<T>): boolean {
+        return this.tokenValues.has(token.key);
+    }
+
+    /**
+     * Either returns the cached value for the given token or initializes and caches a new value.
+     * @param token - The token to get the value of.
+     * @returns Either the cached or a new value.
+     */
+    get<T>(token: RequestContextToken<T>): T {
+        if (!this.has(token)) {
+            this.tokenValues.set(token.key, token.fn(this));
+        }
+        return this.tokenValues.get(token.key) as T;
+    }
+}

package/src/cron/cron-expression.utilities.ts

@@ -0,0 +1,238 @@
+import { IntRange } from '../types/percentage.type';
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+type CronUnit = 'seconds' | 'minutes' | 'hours' | 'days' | 'months';
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+type DayOfWeek = 'Sunday' | 'Monday' | 'Tuesday' | 'Wednesday'
+    | 'Thursday' | 'Friday' | 'Saturday';
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+type MonthName = | 'January' | 'February' | 'March' | 'April'
+    | 'May' | 'June' | 'July' | 'August'
+    | 'September' | 'October' | 'November' | 'December';
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+export type CronExpressionString = string & {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    __brand: 'CronExpression'
+};
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+type CronFields = [
+    second: string,
+    minute: string,
+    hour: string,
+    day: string,
+    month: string,
+    weekday: string
+];
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+type RangeForCronUnit<T extends CronUnit> = T extends 'seconds'
+    ? IntRange<0, 60>
+    : T extends 'minutes'
+        ? IntRange<0, 60>
+        : T extends 'hours'
+            ? IntRange<0, 24>
+            : T extends 'days'
+                ? IntRange<1, 32>
+                : T extends 'months'
+                    ? IntRange<1, 13>
+                    : never;
+
+const UNIT_FIELD_INDEX: Record<CronUnit, number> = {
+    seconds: 0,
+    minutes: 1,
+    hours: 2,
+    days: 3,
+    months: 4
+};
+
+const DAY_VALUES: Record<DayOfWeek, number> = {
+    Sunday: 0,
+    Monday: 1,
+    Tuesday: 2,
+    Wednesday: 3,
+    Thursday: 4,
+    Friday: 5,
+    Saturday: 6
+};
+
+const MONTH_VALUES: Record<MonthName, number> = {
+    January: 1,
+    February: 2,
+    March: 3,
+    April: 4,
+    May: 5,
+    June: 6,
+    July: 7,
+    August: 8,
+    September: 9,
+    October: 10,
+    November: 11,
+    December: 12
+};
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function withField(
+    fields: CronFields,
+    index: number,
+    value: string
+): CronFields {
+    const next: CronFields = [...fields];
+    next[index] = value;
+    return next;
+}
+
+/**
+ * Utility class for creating cron expressions with guardrails.
+ */
+export class CronExpression {
+    private readonly _fields: CronFields;
+
+    private constructor(fields: CronFields) {
+        this._fields = fields;
+    }
+
+    private static blank(): CronExpression {
+        return new CronExpression(['*', '*', '*', '*', '*', '*']);
+    }
+
+    // ── Static entry points ──────────────────────────────────────────────────
+
+    /**
+     * Runs every N units.
+     * @param value - The interval at which to run.
+     * @param unit - The unit, like 'minutes', 'hours', 'days' etc.
+     * @example
+     * CronExpression.every(5, 'minutes')  // "* *\/5 * * * *"
+     * CronExpression.every(2, 'hours')    // "* * *\/2 * * *"
+     * @returns A cron expression to either continue working with or building the result string.
+     */
+    static every<T extends CronUnit>(value: RangeForCronUnit<T>, unit: T): CronExpression {
+        const idx: number = UNIT_FIELD_INDEX[unit];
+        const field: string = value === 1 ? '*' : `*/${value}`;
+        return new CronExpression(
+            withField(CronExpression.blank()._fields, idx, field)
+        );
+    }
+
+    /**
+     * Runs once a day. Default: midnight (00:00:00).
+     * Chain `.at()` to set the time.
+     * @example
+     * CronExpression.daily().at(9, 'hours').at(30, 'minutes')  // "0 30 9 * * *"
+     * @returns A cron expression to either continue working with or building the result string.
+     */
+    static daily(): CronExpression {
+        return new CronExpression(['0', '0', '0', '*', '*', '*']);
+    }
+
+    /**
+     * Runs once a week. Default: Sunday midnight.
+     * Chain `.on()` and `.at()` to customize.
+     * @example
+     * CronExpression.weekly().on('Monday').at(8, 'hours')  // "0 0 8 * * 1"
+     * @returns A cron expression to either continue working with or building the result string.
+     */
+    static weekly(): CronExpression {
+        return new CronExpression(['0', '0', '0', '*', '*', '0']);
+    }
+
+    /**
+     * Runs once a month. Default: 1st of the month at midnight.
+     * @example
+     * CronExpression.monthly().at(15, 'days').at(6, 'hours')  // "0 0 6 15 * *"
+     * @returns A cron expression to either continue working with or building the result string.
+     */
+    static monthly(): CronExpression {
+        return new CronExpression(['0', '0', '0', '1', '*', '*']);
+    }
+
+    /**
+     * Builds a CronExpression from a raw node-cron string (for interop / parsing).
+     * @param expression - The raw expression too build from.
+     * @returns The final CronExpressionString.
+     * @throws If there are more than 6 parts provided.
+     */
+    static fromString(expression: string): CronExpressionString {
+        const parts: string[] = expression.trim().split(/\s+/);
+        if (parts.length !== 6) {
+            throw new Error(
+                `Expected 6 fields for node-cron expression, got ${parts.length}: "${expression}"`
+            );
+        }
+        return new CronExpression(parts as CronFields).build();
+    }
+
+    // ── Instance modifiers ───────────────────────────────────────────────────
+
+    /**
+     * Fixes a specific field to a concrete value.
+     * @param value - The concrete value.
+     * @param unit - The unit, like 'minutes', 'hours', 'days' etc.
+     * @example
+     * CronExpression.every(1, 'hours').at(30, 'minutes')  // "* 30 * * * *" (at :30 past every hour)
+     * CronExpression.daily().at(9, 'hours')               // "0 0 9 * * *"
+     * @returns A cron expression to either continue working with or building the result string.
+     */
+    at<T extends CronUnit>(value: RangeForCronUnit<T>, unit: T): CronExpression {
+        const idx: number = UNIT_FIELD_INDEX[unit];
+        return new CronExpression(withField(this._fields, idx, String(value)));
+    }
+
+    /**
+     * Restricts execution to a range of values for a given unit.
+     * @param from - The value at which the range starts.
+     * @param to - The value at which the range ends.
+     * @param unit - The unit, like 'minutes', 'hours', 'days' etc.
+     * @example
+     * CronExpression.every(1, 'minutes').between(9, 17, 'hours')  // "* * 9-17 * * *" (business hours only)
+     * @returns A cron expression to either continue working with or building the result string.
+     * @throws If the "from" value is smaller than the "to" value.
+     */
+    between<T extends CronUnit>(from: RangeForCronUnit<T>, to: RangeForCronUnit<T>, unit: T): CronExpression {
+        if (from >= to) {
+            throw new RangeError(`'from' (${from}) must be less than 'to' (${to})`);
+        }
+        const idx: number = UNIT_FIELD_INDEX[unit];
+        return new CronExpression(
+            withField(this._fields, idx, `${from}-${to}`)
+        );
+    }
+
+    /**
+     * Restricts execution to specific days of the week.
+     * @param days - The days on which the execution should happen.
+     * @example
+     * CronExpression.daily().on('Monday', 'Wednesday', 'Friday')  // "0 0 0 * * 1,3,5"
+     * @returns A cron expression to either continue working with or building the result string.
+     */
+    on(...days: [DayOfWeek, ...DayOfWeek[]]): CronExpression {
+        const value: string = days.map(d => DAY_VALUES[d]).join(',');
+        return new CronExpression(withField(this._fields, 5, value));
+    }
+
+    /**
+     * Restricts execution to specific months.
+     * @param months - The months in which the execution should happen.
+     * @example
+     * CronExpression.monthly().in('March', 'June', 'September', 'December')  // "0 0 0 1 3,6,9,12 *"
+     * @returns A cron expression to either continue working with or building the result string.
+     */
+    in(...months: [MonthName, ...MonthName[]]): CronExpression {
+        const value: string = months.map(m => MONTH_VALUES[m]).join(',');
+        return new CronExpression(withField(this._fields, 4, value));
+    }
+
+    // ── Output ───────────────────────────────────────────────────────────────
+
+    /**
+     * Builds the final result from the builder input.
+     * @returns The branded node-cron expression string.
+     */
+    build(): CronExpressionString {
+        return this._fields.join(' ') as CronExpressionString;
+    }
+}

package/src/cron/cron-job-entity.model.ts

@@ -1,3 +1,4 @@
+import { type CronExpressionString } from './cron-expression.utilities';
 import { BaseEntity } from '../entity/base-entity.model';
 import { Entity } from '../entity/decorators/entity.decorator';
 import { Property } from '../entity/decorators/property.decorator';
@@ -18,7 +19,7 @@ export class CronJobEntity extends BaseEntity {
      * The cron expression.
      */
     @Property.string()
-    cron!: string;
+    cron!: CronExpressionString;
 
     /**
      * Whether or not the cron job is currently active.

package/src/cron/cron-job.model.ts

@@ -1,12 +1,10 @@
 
 import cron, { ScheduledTask } from 'node-cron';
 
+import { type CronExpressionString } from './cron-expression.utilities';
 import { CreateCronJobEntityData, CronJobEntity } from './cron-job-entity.model';
 import { CronUpdateData } from './cron.service';
 import { Repository } from '../data-source/repository';
-import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
-import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
-import { inject } from '../di/inject.function';
 import { unknownToErrorString } from '../error-handling/unknown-to-error-string.function';
 import { type LoggerInterface } from '../logging/logger.interface';
 import { OmitStrict } from '../types/omit-strict.type';
@@ -53,12 +51,12 @@ export abstract class CronJob {
     /**
      * The repository for syncing cron jobs back and forth to the db.
      */
-    protected readonly cronJobRepository: Repository<CronJobEntity, CreateCronJobEntityData>;
+    protected cronJobRepository!: Repository<CronJobEntity, CreateCronJobEntityData>;
 
     /**
      * A logger instance.
      */
-    protected readonly logger: LoggerInterface;
+    protected logger!: LoggerInterface;
 
     // eslint-disable-next-line jsdoc/require-returns
     /**
@@ -97,15 +95,16 @@ export abstract class CronJob {
         return this.entity.active;
     }
 
-    constructor(protected readonly overrideName?: string) {
-        this.cronJobRepository = inject(repositoryTokenFor(CronJobEntity));
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
-    }
+    constructor(protected readonly overrideName?: string) {}
 
     /**
      * Initializes the cron job.
+     * @param logger - A logger instance.
+     * @param repo - The cron job repository to sync to a data source.
      */
-    async init(): Promise<void> {
+    async init(logger: LoggerInterface, repo: Repository<CronJobEntity, CreateCronJobEntityData>): Promise<void> {
+        this.logger = logger;
+        this.cronJobRepository = repo;
         if (this.entity) {
             throw new Error('the cron job has already been initialized.');
         }
@@ -245,7 +244,7 @@ export abstract class CronJob {
      * Changes the cron expression.
      * @param cronExpression - The new cron expression to change to.
      */
-    async changeCron(cronExpression: string): Promise<void> {
+    async changeCron(cronExpression: CronExpressionString): Promise<void> {
         if (!this.entity || !this.task) {
             throw new Error(NOT_INITIALIZED_MESSAGE);
         }

package/src/cron/cron-service.interface.ts

@@ -1,3 +1,4 @@
+import { CronExpressionString } from './cron-expression.utilities';
 import { CronJob } from './cron-job.model';
 import { CronUpdateData } from './cron.service';
 
@@ -24,7 +25,7 @@ export interface CronServiceInterface {
     /**
      * Changes the cron expression of the cron job with the given name.
      */
-    changeCron: (name: string, cron: string) => Promise<void>,
+    changeCron: (name: string, cron: CronExpressionString) => Promise<void>,
     /**
      * Updates the cron job with the given name.
      */

package/src/cron/cron.service.ts

@@ -2,6 +2,8 @@ import { CronJobEntity } from './cron-job-entity.model';
 import { CronJob } from './cron-job.model';
 import { CronServiceInterface } from './cron-service.interface';
 import { ZibriApplication } from '../application';
+import { CronExpressionString } from './cron-expression.utilities';
+import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
 import { Inject } from '../di/decorators/inject.decorator';
 import { Injectable } from '../di/decorators/injectable.decorator';
 import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
@@ -42,7 +44,7 @@ export class CronService implements CronServiceInterface, AfterAppInit, BeforeAp
         for (const cronJobClass of cronJobs) {
             register({ token: cronJobClass, useClass: cronJobClass });
             const cronJob: CronJob = inject(cronJobClass);
-            await cronJob.init();
+            await cronJob.init(this.logger, inject(repositoryTokenFor(CronJobEntity)));
             await this.logger.info(`  -  ${cronJobClass.name} (${cronJob.active ? 'active' : 'not active'})`);
             this.cronJobs.push(cronJob);
         }
@@ -55,7 +57,7 @@ export class CronService implements CronServiceInterface, AfterAppInit, BeforeAp
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     async schedule(cronJob: CronJob): Promise<void> {
-        await cronJob.init();
+        await cronJob.init(this.logger, inject(repositoryTokenFor(CronJobEntity)));
         this.cronJobs.push(cronJob);
     }
 
@@ -78,7 +80,7 @@ export class CronService implements CronServiceInterface, AfterAppInit, BeforeAp
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async changeCron(name: string, cron: string): Promise<void> {
+    async changeCron(name: string, cron: CronExpressionString): Promise<void> {
         const foundJob: CronJob | undefined = this.cronJobs.find(c => c.name === name);
         if (!foundJob) {
             throw new Error(`Could not find cron job with name ${name}`);

package/src/data-source/cascade-delete.test.ts

@@ -1,58 +1,33 @@
 import { beforeAll, afterAll, describe, it, expect } from '@jest/globals';
-import { PostgreSqlContainer, StartedPostgreSqlContainer } from '@testcontainers/postgresql';
 
 import { Repository } from './repository';
-import { BaseEntity } from '../entity/base-entity.model';
-import { PostgresDataSource, PostgresOptions } from './data-sources/postgres-data-source.model';
-import { DataSource } from './decorators/data-source.decorator';
-import { MigrationEntity } from './migration/migration-entity.model';
-import { POSTGRES_TEST_IMAGE } from '../__testing__/constants';
 import { Child } from '../__testing__/mocks/entities/child.entity';
 import { Company } from '../__testing__/mocks/entities/company.entity';
 import { Parent } from '../__testing__/mocks/entities/parent.entity';
 import { Profile } from '../__testing__/mocks/entities/profile.entity';
 import { Role } from '../__testing__/mocks/entities/role.entity';
 import { User, UserCreateData, mockCreateUserData } from '../__testing__/mocks/entities/user.entity';
+import { createTestDataSource, defaultTestServerEntities } from '../__testing__/test-server/create-test-data-source.function';
+import { StartedTestServer, startTestServer } from '../__testing__/test-server/start-test-server.function';
+import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
 import { inject } from '../di/inject.function';
-import { Newable } from '../types/newable.type';
-
-@DataSource()
-class TestDataSource extends PostgresDataSource {
-    options: PostgresOptions = {
-        host: 'localhost',
-        username: 'postgres',
-        password: 'password',
-        database: 'db',
-        synchronize: true
-    };
-    entities: Newable<BaseEntity>[] = [MigrationEntity, Parent, Child, User, Company, Profile, Role];
-}
 
 describe('cascade delete', () => {
-    let container: StartedPostgreSqlContainer;
-    let ds: TestDataSource;
+    let server: StartedTestServer;
 
     beforeAll(async () => {
-        container = await new PostgreSqlContainer(POSTGRES_TEST_IMAGE)
-            .withDatabase('db')
-            .withUsername('postgres')
-            .withPassword('password')
-            .start();
-        ds = inject(TestDataSource);
-        ds.options = {
-            ...ds.options,
-            port: container.getMappedPort(5432)
-        };
-        await ds.init();
-    }, 20000);
+        server = await startTestServer({
+            dataSources: [createTestDataSource({ entities: [...defaultTestServerEntities, Parent, Child, User, Company, Profile, Role] })]
+        });
+    }, 15000);
 
     afterAll(async () => {
-        await container.stop();
+        await server?.shutdown();
     });
 
     it('deletes children when parent removed', async () => {
-        const parentRepo: Repository<Parent> = ds.getRepository(Parent);
-        const childRepo: Repository<Child> = ds.getRepository(Child);
+        const parentRepo: Repository<Parent> = inject(repositoryTokenFor(Parent));
+        const childRepo: Repository<Child> = inject(repositoryTokenFor(Child));
         const parent: Parent = await parentRepo.create({ name: 'p1' });
         await childRepo.create({ name: 'c1', parent: { id: parent.id } });
         await childRepo.create({ name: 'c2', parent });
@@ -69,8 +44,8 @@ describe('cascade delete', () => {
     });
 
     it('deletes profile when user removed', async () => {
-        const userRepo: Repository<User, UserCreateData> = ds.getRepository(User);
-        const profileRepo: Repository<Profile> = ds.getRepository(Profile);
+        const userRepo: Repository<User, UserCreateData> = inject(repositoryTokenFor(User));
+        const profileRepo: Repository<Profile> = inject(repositoryTokenFor(Profile));
 
         const user: User = await userRepo.create(mockCreateUserData());
         const profile: Profile = await profileRepo.create({ bio: 'Bio', user });
@@ -87,8 +62,8 @@ describe('cascade delete', () => {
     });
 
     it('removes user from roles when user removed', async () => {
-        const userRepo: Repository<User, UserCreateData> = ds.getRepository(User);
-        const roleRepo: Repository<Role> = ds.getRepository(Role);
+        const userRepo: Repository<User, UserCreateData> = inject(repositoryTokenFor(User));
+        const roleRepo: Repository<Role> = inject(repositoryTokenFor(Role));
 
         const user1: User = await userRepo.create(mockCreateUserData());
         const user2: User = await userRepo.create(mockCreateUserData());

package/src/data-source/data-sources/data-source.interface.ts

@@ -1,5 +1,3 @@
-import { IsolationLevel } from 'typeorm/driver/types/IsolationLevel';
-
 import { BackupResourceInterface } from '../../backup/backup-resource.interface';
 import { BaseEntity } from '../../entity/base-entity.model';
 import { PropertyMetadataInput, PropertyMetadata, RelationMetadata } from '../../entity/decorators/property.decorator';
@@ -10,6 +8,16 @@ import { Migration } from '../migration/migration.model';
 import { Repository } from '../repository';
 import { Transaction } from '../transaction/transaction.model';
 
+/**
+ * The isolation level of any data source calls made inside a transaction.
+ */
+export enum IsolationLevel {
+    READ_UNCOMMITTED = 'READ UNCOMMITTED',
+    READ_COMMITTED = 'READ COMMITTED',
+    REPEATABLE_READ = 'REPEATABLE READ',
+    SERIALIZABLE = 'SERIALIZABLE'
+}
+
 /**
  * Definition for a data source.
  */