zibri 2.2.1 → 2.3.0

package/src/auth/2fa/methods/two-factor-method.interface.ts

@@ -6,10 +6,6 @@ import { BaseUser } from '../../models/base-user.model';
  * Interface for a two factor method.
  */
 export interface TwoFactorMethod<TwoFactorRequestRegisterData, TwoFactorConfirmRegisterData> {
-    /**
-     * Initializes the two factor method.
-     */
-    init: () => void,
     /**
      * Requests to register the two factor method for the given user.
      */
@@ -35,4 +31,27 @@ export interface TwoFactorMethod<TwoFactorRequestRegisterData, TwoFactorConfirmR
         user: UserType,
         request: HttpRequest | WebsocketRequest
     ) => void | Promise<void>
+}
+
+/**
+ * Checks whether or not the given value is a two factor method.
+ * @param value - The value to check.
+ * @returns True if all keys of the TwoFactorMethod interface are present, false otherwise.
+ */
+export function isTwoFactorMethod(value: unknown): value is TwoFactorMethod<unknown, unknown> {
+    if (value == undefined) {
+        return false;
+    }
+    if (typeof value !== 'object') {
+        return false;
+    }
+
+    const keys: (keyof TwoFactorMethod<unknown, unknown>)[] = [
+        'requestRegisterForUser',
+        'confirmRegisterForUser',
+        'unregisterForUser',
+        'validate'
+    ];
+
+    return !keys.find(key => !(key in value));
 }

package/src/auth/2fa/two-factor-service.interface.ts

@@ -12,10 +12,6 @@ export interface TwoFactorServiceInterface {
      * The different two factor methods provided.
      */
     readonly twoFactorMethods: TwoFactorMethods,
-    /**
-     * Initializes the service.
-     */
-    init: (twoFactorMethods: TwoFactorMethods) => Promise<void>,
     /**
      * Requests the registration of the given two factor method for the given user.
      */

package/src/auth/2fa/two-factor.service.ts

@@ -1,8 +1,12 @@
+import { ZibriApplication } from '../../application';
+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';
 import { inject } from '../../di/inject.function';
 import { register } from '../../di/register.function';
+import { OnAppInit } from '../../global/on-app-init.interface';
 import { HttpRequest } from '../../http/http-request.model';
-import { LoggerInterface } from '../../logging/logger.interface';
+import { type LoggerInterface } from '../../logging/logger.interface';
 import { WebsocketRequest } from '../../websocket/models/websocket-request.model';
 import { BaseUser } from '../models/base-user.model';
 import { TwoFactorMethod } from './methods/two-factor-method.interface';
@@ -12,21 +16,19 @@ import { TwoFactorServiceInterface } from './two-factor-service.interface';
 /**
  * Default implementation of the two factor service.
  */
-export class TwoFactorService implements TwoFactorServiceInterface {
+@Injectable({ register: 'onUse' })
+export class TwoFactorService implements TwoFactorServiceInterface, OnAppInit {
     // eslint-disable-next-line jsdoc/require-jsdoc
     readonly twoFactorMethods: TwoFactorMethods = [];
 
-    /**
-     * A logger.
-     */
-    protected readonly logger: LoggerInterface;
-
-    constructor() {
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
-    }
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.LOGGER)
+        private readonly logger: LoggerInterface
+    ) { }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async init(twoFactorMethods: TwoFactorMethods): Promise<void> {
+    async onAppInit({ options }: ZibriApplication): Promise<void> {
+        const { twoFactorMethods } = options;
         for (const method of twoFactorMethods) {
             register({ token: method, useClass: method });
             this.twoFactorMethods.push(method);
@@ -37,7 +39,6 @@ export class TwoFactorService implements TwoFactorServiceInterface {
             );
             for (const method of twoFactorMethods) {
                 await this.logger.info(`  - ${method.name}`);
-                inject(method).init();
             }
         }
     }

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

@@ -19,10 +19,6 @@ export interface AuthServiceInterface {
      * The different auth strategies provided.
      */
     readonly strategies: AuthStrategies,
-    /**
-     * Initializes the service.
-     */
-    init: (strategies: AuthStrategies) => void | Promise<void>,
     /**
      * Checks if the provided method on the provided controller can be accessed by the current user.
      */

package/src/auth/auth.service.ts

@@ -1,7 +1,8 @@
 import { AuthServiceInterface } from './auth-service.interface';
+import { ZibriApplication } from '../application';
 import { register } from '../di/register.function';
 import { BaseEntity } from '../entity/base-entity.model';
-import { TwoFactorServiceInterface } from './2fa/two-factor-service.interface';
+import { type TwoFactorServiceInterface } from './2fa/two-factor-service.interface';
 import { BaseUser } from './models/base-user.model';
 import { BelongsToMetadata, SkipBelongsToMetadata } from './models/belongs-to-metadata.model';
 import { HasRoleMetadata, SkipHasRoleMetadata } from './models/has-role-metadata.model';
@@ -11,11 +12,14 @@ import { Require2faMetadata, SkipRequire2faMetadata } from './models/require-2fa
 import { SkipAuthMetadata } from './models/skip-auth-metadata.model';
 import { AuthStrategies } from './strategies/auth-strategies.model';
 import { AuthStrategyInterface } from './strategies/auth-strategy.interface';
+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';
 import { inject } from '../di/inject.function';
 import { UnauthorizedError } from '../error-handling/errors/unauthorized.error';
+import { OnAppInit } from '../global/on-app-init.interface';
 import { HttpRequest } from '../http/http-request.model';
-import { LoggerInterface } from '../logging/logger.interface';
+import { type LoggerInterface } from '../logging/logger.interface';
 import { Newable } from '../types/newable.type';
 import { MetadataUtilities } from '../utilities/metadata.utilities';
 import { PromiseUtilities } from '../utilities/promise.utilities';
@@ -24,26 +28,21 @@ import { WebsocketRequest } from '../websocket/models/websocket-request.model';
 /**
  * Default auth service implementation of Zibri.
  */
-export class AuthService implements AuthServiceInterface {
-    /**
-     * A logger.
-     */
-    protected readonly logger: LoggerInterface;
-
+@Injectable({ register: 'onUse' })
+export class AuthService implements AuthServiceInterface, OnAppInit {
     // eslint-disable-next-line jsdoc/require-jsdoc
     readonly strategies: AuthStrategies = [];
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    get twoFactorService(): TwoFactorServiceInterface {
-        return inject(ZIBRI_DI_TOKENS.TWO_FACTOR_SERVICE);
-    }
-
-    constructor() {
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
-    }
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.LOGGER)
+        private readonly logger: LoggerInterface,
+        @Inject(ZIBRI_DI_TOKENS.TWO_FACTOR_SERVICE)
+        private readonly twoFactorService: TwoFactorServiceInterface
+    ) {}
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async init(authStrategies: AuthStrategies): Promise<void> {
+    async onAppInit({ options }: ZibriApplication): Promise<void> {
+        const { authStrategies } = options;
         for (const strategy of authStrategies) {
             register({ token: strategy, useClass: strategy });
             this.strategies.push(strategy);
@@ -54,7 +53,6 @@ export class AuthService implements AuthServiceInterface {
             );
             for (const strategy of authStrategies) {
                 await this.logger.info(`  - ${strategy.name}`);
-                inject(strategy).init();
             }
         }
     }

package/src/auth/models/password-reset-token.model.ts

@@ -6,7 +6,7 @@ import { OmitClass } from '../../entity/omit-class.model';
 /**
  * A short lived token used to confirm a password reset.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class PasswordResetToken extends BaseEntity {
     /**
      * The expiration date of the password reset token.

package/src/auth/strategies/auth-strategy.interface.ts

@@ -1,3 +1,4 @@
+import { AuthStrategies } from './auth-strategies.model';
 import { BaseEntity } from '../../entity/base-entity.model';
 import { HttpRequest } from '../../http/http-request.model';
 import { OpenApiSecuritySchemeObject } from '../../open-api/open-api.model';
@@ -18,10 +19,6 @@ export interface AuthStrategyInterface<
     RefreshLoginDataType,
     LogoutData
 > {
-    /**
-     * Initializes the strategy.
-     */
-    init: () => void,
     /**
      * Resolves the current user.
      */
@@ -71,4 +68,34 @@ export interface AuthStrategyInterface<
      * The name of the auth strategy.
      */
     name: string
+}
+
+/**
+ * Checks whether or not the given value is a auth strategy.
+ * @param value - The value to check.
+ * @returns True if all keys of the AuthStrategyInterface are present, false otherwise.
+ */
+export function isAuthStrategy(value: unknown): value is InstanceType<AuthStrategies[number]> {
+    if (value == undefined) {
+        return false;
+    }
+    if (typeof value !== 'object') {
+        return false;
+    }
+
+    const keys: (keyof InstanceType<AuthStrategies[number]>)[] = [
+        'belongsTo',
+        'confirmPasswordReset',
+        'hasRole',
+        'isLoggedIn',
+        'login',
+        'logout',
+        'name',
+        'refreshLogin',
+        'requestPasswordReset',
+        'resolveUser',
+        'securityScheme'
+    ];
+
+    return !keys.find(key => !(key in value));
 }

package/src/auth/strategies/jwt/jwt-auth.controller.ts

@@ -9,6 +9,7 @@ import { Inject } from '../../../di/decorators/inject.decorator';
 import { ZIBRI_DI_TOKENS } from '../../../di/default/zibri-di-tokens.default';
 import { Property } from '../../../entity/decorators/property.decorator';
 import { Response } from '../../../open-api/decorators/response.decorator';
+import { PreactEmailComponent } from '../../../preact/preact-email-component.model';
 import { Body } from '../../../routing/decorators/body.decorator';
 import { Controller } from '../../../routing/decorators/controller.decorator';
 import { Post } from '../../../routing/decorators/post.decorator';
@@ -18,6 +19,21 @@ import { BaseUser } from '../../models/base-user.model';
 import { PasswordResetToken } from '../../models/password-reset-token.model';
 import { type UserServiceInterface } from '../../user/user-service.interface';
 
+/**
+ * Properties of a password reset email.
+ */
+type PasswordResetEmailTemplateProps<Role extends string, UserType extends BaseUser<Role>> = {
+    confirmPasswordResetLink: string,
+    user: UserType
+};
+
+/**
+ * Definition for a password reset email template.
+ */
+export type PasswordResetEmailTemplate<
+    Role extends string, UserType extends BaseUser<Role>
+> = PreactEmailComponent<PasswordResetEmailTemplateProps<Role, UserType>>;
+
 class JwtRequestPasswordResetInput {
     @Property.string({ format: 'email' })
     email!: string;
@@ -33,7 +49,7 @@ class JwtVerifyPasswordResetTokenResponse {
     isValid!: boolean;
 }
 
-@Controller('/auth')
+@Controller('/auth', { allowOrphan: true })
 export class JwtAuthController implements AuthControllerInterface<
     JwtCredentialsDto,
     JwtAuthData<string>,

package/src/auth/strategies/jwt/jwt-credentials.model.ts

@@ -7,7 +7,7 @@ import { BaseUser } from '../../models/base-user.model';
 /**
  * The credentials used by the jwt auth strategy.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class JwtCredentials extends BaseEntity implements Pick<BaseUser<string>, 'id' | 'email'> {
     /**
      * The id of the user that this credentials belong to.

package/src/auth/strategies/jwt/jwt-refresh-token.model.ts

@@ -6,7 +6,7 @@ import { OmitClass } from '../../../entity/omit-class.model';
 /**
  * The jwt refresh token that gets stored in the data source.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class JwtRefreshToken extends BaseEntity {
     /**
      * The id of the user that this token belongs to.

package/src/auth/strategies/jwt/jwt.auth-strategy.ts

@@ -11,30 +11,30 @@ import { JwtRefreshToken, JwtRefreshTokenCreateDto } from './jwt-refresh-token.m
 import { JwtRequestPasswordResetData } from './jwt-request-password-reset-data.model';
 import { JwtUtilities } from './jwt.utilities';
 import { Repository } from '../../../data-source/repository';
-import { repositoryTokenFor } from '../../../di/decorators/inject-repository.decorator';
+import { InjectRepository, repositoryTokenFor } from '../../../di/decorators/inject-repository.decorator';
+import { Inject } from '../../../di/decorators/inject.decorator';
 import { ZIBRI_DI_TOKENS } from '../../../di/default/zibri-di-tokens.default';
 import { NoProviderError } from '../../../di/errors/no-provider.error';
 import { inject } from '../../../di/inject.function';
-import { EmailServiceInterface } from '../../../email/email-service.interface';
+import { type EmailServiceInterface } from '../../../email/email-service.interface';
 import { EmailPriority } from '../../../email/models/email-priority.enum';
 import { BaseEntity } from '../../../entity/base-entity.model';
 import { TooManyRequestsError } from '../../../error-handling/errors/too-many-requests.error';
 import { UnauthorizedError } from '../../../error-handling/errors/unauthorized.error';
 import { GlobalRegistry } from '../../../global/global-registry';
-import { renderEmailTemplate } from '../../../handlebars/render-template.function';
 import { HttpRequest } from '../../../http/http-request.model';
 import { OpenApiSecuritySchemeObject } from '../../../open-api/open-api.model';
 import { Newable } from '../../../types/newable.type';
 import { Ms } from '../../../utilities/ms';
 import { UUIDUtilities } from '../../../utilities/uuid.utilities';
-import { validateEntitiesRegistered } from '../../../utilities/validate-entities-registered.function';
 import { WebsocketRequest } from '../../../websocket/models/websocket-request.model';
 import { HashUtilities } from '../../hash.utilities';
 import { BaseUser } from '../../models/base-user.model';
 import { PasswordResetToken, PasswordResetTokenCreateData } from '../../models/password-reset-token.model';
-import { UserServiceInterface } from '../../user/user-service.interface';
-import { NO_USER_REPOSITORIES_PROVIDED_ERROR_MESSAGE } from '../../user/user.service';
+import { type UserServiceInterface } from '../../user/user-service.interface';
 import { AuthStrategyInterface } from '../auth-strategy.interface';
+import { PasswordResetEmailTemplate } from './jwt-auth.controller';
+import { PreactUtilities } from '../../../preact/preact.utilities';
 
 /**
  * Jwt auth strategy implementation of Zibri.
@@ -65,65 +65,51 @@ implements AuthStrategyInterface<
     };
 
     private readonly accessTokenSecret: string;
-    private readonly accessTokenExpiresInMs: number;
     private readonly refreshTokenSecret: string;
-    private readonly refreshTokenExpiresInMs: number;
-    private readonly passwordResetTokenExpiresInMs: number;
-    private readonly userService: UserServiceInterface;
-    private readonly emailService: EmailServiceInterface;
     private readonly confirmPasswordResetUrl: string;
-
-    private get refreshTokenRepository(): Repository<JwtRefreshToken> {
-        return inject(repositoryTokenFor(JwtRefreshToken));
-    }
-
-    private get passwordResetTokenRepository(): Repository<PasswordResetToken, PasswordResetTokenCreateData> {
-        return inject(repositoryTokenFor(PasswordResetToken));
-    }
-
-    private get credentialsRepository(): Repository<JwtCredentials> {
-        return inject(repositoryTokenFor(JwtCredentials));
-    }
-
-    constructor() {
+    private readonly PasswordResetEmail: PasswordResetEmailTemplate<RoleType, UserType>;
+
+    constructor(
+        @InjectRepository(JwtRefreshToken)
+        private readonly refreshTokenRepository: Repository<JwtRefreshToken>,
+        @InjectRepository(PasswordResetToken)
+        private readonly passwordResetTokenRepository: Repository<PasswordResetToken, PasswordResetTokenCreateData>,
+        @InjectRepository(JwtCredentials)
+        private readonly credentialsRepository: Repository<JwtCredentials>,
+        @Inject(ZIBRI_DI_TOKENS.JWT_ACCESS_TOKEN_EXPIRES_IN_MS)
+        private readonly accessTokenExpiresInMs: number,
+        @Inject(ZIBRI_DI_TOKENS.JWT_REFRESH_TOKEN_EXPIRES_IN_MS)
+        private readonly refreshTokenExpiresInMs: number,
+        @Inject(ZIBRI_DI_TOKENS.JWT_PASSWORD_RESET_TOKEN_EXPIRES_IN_MS)
+        private readonly passwordResetTokenExpiresInMs: number,
+        @Inject(ZIBRI_DI_TOKENS.USER_SERVICE)
+        private readonly userService: UserServiceInterface,
+        @Inject(ZIBRI_DI_TOKENS.EMAIL_SERVICE)
+        private readonly emailService: EmailServiceInterface
+    ) {
         const accessTokenSecret: string | undefined = inject(ZIBRI_DI_TOKENS.JWT_ACCESS_TOKEN_SECRET);
         if (!accessTokenSecret) {
-            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_ACCESS_TOKEN_SECRET, [JwtAuthStrategy]);
+            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_ACCESS_TOKEN_SECRET, []);
         }
         const refreshTokenSecret: string | undefined = inject(ZIBRI_DI_TOKENS.JWT_REFRESH_TOKEN_SECRET);
         if (!refreshTokenSecret) {
-            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_REFRESH_TOKEN_SECRET, [JwtAuthStrategy]);
+            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_REFRESH_TOKEN_SECRET, []);
         }
         const confirmPasswordResetUrl: string | undefined = inject(ZIBRI_DI_TOKENS.JWT_CONFIRM_PASSWORD_RESET_URL);
         if (!confirmPasswordResetUrl) {
-            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_CONFIRM_PASSWORD_RESET_URL, [JwtAuthStrategy]);
+            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_CONFIRM_PASSWORD_RESET_URL, []);
+        }
+        const PasswordResetEmail: PasswordResetEmailTemplate<RoleType, UserType> | undefined = inject(
+            ZIBRI_DI_TOKENS.JWT_PASSWORD_RESET_EMAIL_TEMPLATE
+        );
+        if (!PasswordResetEmail) {
+            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_PASSWORD_RESET_EMAIL_TEMPLATE, []);
         }
+
         this.accessTokenSecret = accessTokenSecret;
-        this.accessTokenExpiresInMs = inject(ZIBRI_DI_TOKENS.JWT_ACCESS_TOKEN_EXPIRES_IN_MS);
         this.refreshTokenSecret = refreshTokenSecret;
-        this.refreshTokenExpiresInMs = inject(ZIBRI_DI_TOKENS.JWT_REFRESH_TOKEN_EXPIRES_IN_MS);
-        this.passwordResetTokenExpiresInMs = inject(ZIBRI_DI_TOKENS.JWT_PASSWORD_RESET_TOKEN_EXPIRES_IN_MS);
-        this.userService = inject(ZIBRI_DI_TOKENS.USER_SERVICE);
-        this.emailService = inject(ZIBRI_DI_TOKENS.EMAIL_SERVICE);
         this.confirmPasswordResetUrl = confirmPasswordResetUrl;
-    }
-
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    init(): void {
-        if (!this.accessTokenSecret) {
-            throw new Error('No value provided for ZIBRI_DI_TOKENS.JWT_ACCESS_TOKEN_SECRET');
-        }
-        if (!this.refreshTokenSecret) {
-            throw new Error('No value provided for ZIBRI_DI_TOKENS.JWT_REFRESH_TOKEN_SECRET');
-        }
-        if (!this.confirmPasswordResetUrl) {
-            throw new Error('No value provided for ZIBRI_DI_TOKENS.JWT_CONFIRM_PASSWORD_RESET_URL');
-        }
-        if (!GlobalRegistry.userRepositories.length) {
-            throw new Error(NO_USER_REPOSITORIES_PROVIDED_ERROR_MESSAGE);
-        }
-
-        validateEntitiesRegistered(this.constructor.name, JwtRefreshToken, JwtCredentials, PasswordResetToken);
+        this.PasswordResetEmail = PasswordResetEmail;
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
@@ -250,20 +236,18 @@ implements AuthStrategyInterface<
         };
         const resetToken: PasswordResetToken = await this.passwordResetTokenRepository.create(resetTokenData);
 
+        const html: string = PreactUtilities.renderEmail(
+            this.PasswordResetEmail,
+            {
+                user: data.user,
+                confirmPasswordResetLink: `${data.emailData?.confirmPasswordResetUrl ?? this.confirmPasswordResetUrl}/${resetToken.value}`
+            }
+        );
+
         await this.emailService.queue({
             recipients: [data.user.email],
             subject: 'Password Reset',
-            html: await renderEmailTemplate(
-                'password-reset.hbs',
-                {
-                    user: data.user,
-                    confirmPasswordResetUrl: data.emailData?.confirmPasswordResetUrl ?? this.confirmPasswordResetUrl,
-                    resetToken,
-                    base: {
-                        title: 'Password Reset'
-                    }
-                }
-            ),
+            html,
             priority: EmailPriority.HIGH,
             ...data
         });

package/src/auth/user/user.service.ts

@@ -1,4 +1,5 @@
 import { UserServiceInterface } from './user-service.interface';
+import { Injectable } from '../../di/decorators/injectable.decorator';
 import { inject } from '../../di/inject.function';
 import { NotFoundError } from '../../error-handling/errors/not-found.error';
 import { GlobalRegistry } from '../../global/global-registry';
@@ -10,6 +11,7 @@ export const NO_USER_REPOSITORIES_PROVIDED_ERROR_MESSAGE: string = 'No user repo
 /**
  * Default user service implementation of Zibri.
  */
+@Injectable({ register: 'onUse' })
 export class UserService implements UserServiceInterface {
 
     // eslint-disable-next-line jsdoc/require-jsdoc

package/src/backup/backup-entity.model.ts

@@ -10,7 +10,7 @@ import { OmitStrict } from '../types/omit-strict.type';
 /**
  * The entity of a single backup.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class BackupEntity extends BaseEntity {
     /**
      * The name of the backup. Should be unique.

package/src/backup/backup-resource-entity.model.ts

@@ -7,7 +7,7 @@ import { OmitStrict } from '../types/omit-strict.type';
 /**
  * A single resource entity.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class BackupResourceEntity extends BaseEntity {
     /**
      * The name of the resource.

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

@@ -26,10 +26,6 @@ export interface BackupServiceInterface {
      * A subject that contains whether or not a backup is currently being restored.
      */
     isRestoringBackup: BehaviorSubject<boolean>,
-    /**
-     * Initializes the service.
-     */
-    init: () => void | Promise<void>,
     /**
      * Synchronizes backup entities with the data from all transports.
      */

package/src/backup/backup-service.test.ts

@@ -1,25 +1,25 @@
 import { beforeAll, afterAll, describe, it, expect } from '@jest/globals';
-import { PostgreSqlContainer, StartedPostgreSqlContainer } from '@testcontainers/postgresql';
 
 import { BackupEntity } from './backup-entity.model';
 import { BackupResourceEntity } from './backup-resource-entity.model';
-import { BackupServiceInterface } from './backup-service.interface';
-import { POSTGRES_TEST_IMAGE, testFileFolder } from '../__testing__/constants';
+import { BackupService } from './backup.service';
+import { testFileFolder } from '../__testing__/constants';
 import { Backup } from './decorators/backup-resource.decorator';
 import { FsBackupTransport } from './transports/fs.backup-transport';
+import { defaultTestServerEntities } from '../__testing__/test-server/create-test-data-source.function';
+import { StartedTestServer, startTestServer } from '../__testing__/test-server/start-test-server.function';
 import { PostgresDataSource, PostgresOptions } from '../data-source/data-sources/postgres-data-source.model';
 import { DataSource } from '../data-source/decorators/data-source.decorator';
-import { MigrationEntity } from '../data-source/migration/migration-entity.model';
 import { Repository } from '../data-source/repository';
-import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
+import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
 import { inject } from '../di/inject.function';
 import { BaseEntity } from '../entity/base-entity.model';
 import { Entity } from '../entity/decorators/entity.decorator';
 import { Property } from '../entity/decorators/property.decorator';
 import { Newable } from '../types/newable.type';
-import { FsUtilities, Path } from '../utilities/fs.utilities';
+import { FsUtilities, FsPath } from '../utilities/fs.utilities';
 
-const backupFsFolder: Path = FsUtilities.getPath(testFileFolder, 'backups');
+const backupFsFolder: FsPath = FsUtilities.getPath(testFileFolder, 'backups');
 
 @Entity()
 class Item {
@@ -49,40 +49,30 @@ class DbDataSource extends PostgresDataSource {
         database: 'db',
         synchronize: true
     };
-    entities: Newable<BaseEntity>[] = [Item, MigrationEntity, BackupResourceEntity, BackupEntity];
+    entities: Newable<BaseEntity>[] = [...defaultTestServerEntities, Item, BackupResourceEntity, BackupEntity];
 }
 
 describe('Create and restore postgres backup', () => {
-    let dataSource: DbDataSource;
+    let server: StartedTestServer;
+    let backupService: BackupService;
     let itemRepository: Repository<Item>;
     let backupRepository: Repository<BackupEntity>;
-    let container: StartedPostgreSqlContainer;
-    let backupService: BackupServiceInterface;
 
     beforeAll(async () => {
         await FsUtilities.rm(backupFsFolder);
-        container = await new PostgreSqlContainer(POSTGRES_TEST_IMAGE)
-            .withDatabase('db')
-            .withUsername('postgres')
-            .withPassword('password')
-            .start();
-
-        dataSource = inject(DbDataSource);
-        dataSource.options = {
-            ...dataSource.options,
-            port: container.getMappedPort(5432)
-        };
-        await dataSource.init();
-        itemRepository = dataSource.getRepository(Item);
-        backupRepository = dataSource.getRepository(BackupEntity);
+        server = await startTestServer({ dataSources: [DbDataSource] });
+        itemRepository = inject(repositoryTokenFor(Item));
+        backupRepository = inject(repositoryTokenFor(BackupEntity));
+        backupService = inject(BackupService);
 
         // seed one row without `value`
         await itemRepository.create({ value: '42' });
-
-        backupService = inject(ZIBRI_DI_TOKENS.BACKUP_SERVICE);
-        await backupService.init();
     }, 15000);
 
+    afterAll(async () => {
+        await server.shutdown();
+    });
+
     it('should create and restore a backup', async () => {
         expect((await itemRepository.findAll()).length).toEqual(1);
         await backupService.createBackup();
@@ -97,8 +87,4 @@ describe('Create and restore postgres backup', () => {
         await backupService.restore(backup);
         expect((await itemRepository.findAll()).length).toEqual(1);
     }, 15000);
-
-    afterAll(async () => {
-        await container.stop();
-    });
 });