zibri 2.3.0 → 2.4.1

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

@@ -4,13 +4,19 @@ import { EncodedJwtAccessToken } from './encoded-jwt-access-token.model';
 import { JwtAccessTokenPayload } from './jwt-access-token-payload.model';
 import { JwtAuthData } from './jwt-auth-data.model';
 import { JwtConfirmPasswordResetData } from './jwt-confirm-password-reset-data.model';
-import { JwtCredentials, JwtCredentialsDto } from './jwt-credentials.model';
+import { JwtCredentials, JwtCredentialsCreateData, JwtCredentialsDto } from './jwt-credentials.model';
 import { JwtRefreshLoginData } from './jwt-refresh-login-data.model';
+import { JwtRefreshTokenCleanupCronJob } from './jwt-refresh-token-cleanup.cron-job';
 import { JwtRefreshTokenPayload } from './jwt-refresh-token-payload.model';
 import { JwtRefreshToken, JwtRefreshTokenCreateDto } from './jwt-refresh-token.model';
 import { JwtRequestPasswordResetData } from './jwt-request-password-reset-data.model';
 import { JwtUtilities } from './jwt.utilities';
+import { ZibriApplication } from '../../../application';
+import { HttpRequestContext } from '../../../context/request/http-request.context';
+import { WebsocketRequestContext } from '../../../context/request/websocket-request.context';
+import { RepositoryTypeForEntity } from '../../../data-source/data-sources/data-source.interface';
 import { Repository } from '../../../data-source/repository';
+import { Transaction } from '../../../data-source/transaction/transaction.model';
 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';
@@ -22,19 +28,18 @@ 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 { HttpRequest } from '../../../http/http-request.model';
 import { OpenApiSecuritySchemeObject } from '../../../open-api/open-api.model';
 import { Newable } from '../../../types/newable.type';
+import { OmitStrict } from '../../../types/omit-strict.type';
 import { Ms } from '../../../utilities/ms';
-import { UUIDUtilities } from '../../../utilities/uuid.utilities';
-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 { 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';
+import { UUIDUtilities } from '../../../utilities/uuid.utilities';
+import { type HashServiceInterface } from '../../hash/hash-service.interface';
 
 /**
  * Jwt auth strategy implementation of Zibri.
@@ -51,7 +56,7 @@ implements AuthStrategyInterface<
     JwtRequestPasswordResetData<RoleType, UserType>,
     JwtConfirmPasswordResetData,
     JwtRefreshLoginData,
-    JwtRefreshLoginData
+    OmitStrict<JwtRefreshLoginData, 'transaction'>
 > {
     // eslint-disable-next-line jsdoc/require-jsdoc
     readonly name: string = 'jwt';
@@ -75,17 +80,19 @@ implements AuthStrategyInterface<
         @InjectRepository(PasswordResetToken)
         private readonly passwordResetTokenRepository: Repository<PasswordResetToken, PasswordResetTokenCreateData>,
         @InjectRepository(JwtCredentials)
-        private readonly credentialsRepository: Repository<JwtCredentials>,
+        private readonly credentialsRepository: Repository<JwtCredentials, JwtCredentialsCreateData>,
         @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)
+        @Inject(ZIBRI_DI_TOKENS.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
+        private readonly emailService: EmailServiceInterface,
+        @Inject(ZIBRI_DI_TOKENS.HASH_SERVICE)
+        private readonly hashService: HashServiceInterface
     ) {
         const accessTokenSecret: string | undefined = inject(ZIBRI_DI_TOKENS.JWT_ACCESS_TOKEN_SECRET);
         if (!accessTokenSecret) {
@@ -95,15 +102,15 @@ implements AuthStrategyInterface<
         if (!refreshTokenSecret) {
             throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_REFRESH_TOKEN_SECRET, []);
         }
-        const confirmPasswordResetUrl: string | undefined = inject(ZIBRI_DI_TOKENS.JWT_CONFIRM_PASSWORD_RESET_URL);
+        const confirmPasswordResetUrl: string | undefined = inject(ZIBRI_DI_TOKENS.CONFIRM_PASSWORD_RESET_URL);
         if (!confirmPasswordResetUrl) {
-            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_CONFIRM_PASSWORD_RESET_URL, []);
+            throw new NoProviderError(ZIBRI_DI_TOKENS.CONFIRM_PASSWORD_RESET_URL, []);
         }
         const PasswordResetEmail: PasswordResetEmailTemplate<RoleType, UserType> | undefined = inject(
-            ZIBRI_DI_TOKENS.JWT_PASSWORD_RESET_EMAIL_TEMPLATE
+            ZIBRI_DI_TOKENS.PASSWORD_RESET_EMAIL_TEMPLATE
         );
         if (!PasswordResetEmail) {
-            throw new NoProviderError(ZIBRI_DI_TOKENS.JWT_PASSWORD_RESET_EMAIL_TEMPLATE, []);
+            throw new NoProviderError(ZIBRI_DI_TOKENS.PASSWORD_RESET_EMAIL_TEMPLATE, []);
         }
 
         this.accessTokenSecret = accessTokenSecret;
@@ -112,18 +119,25 @@ implements AuthStrategyInterface<
         this.PasswordResetEmail = PasswordResetEmail;
     }
 
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    init(app: ZibriApplication): void {
+        if (!app.options.cronJobs.includes(JwtRefreshTokenCleanupCronJob)) {
+            app.options.cronJobs.push(JwtRefreshTokenCleanupCronJob);
+        }
+    }
+
     // eslint-disable-next-line jsdoc/require-jsdoc
     async login(credentials: JwtCredentialsDto): Promise<JwtAuthData<RoleType>> {
         try {
             const foundUser: UserType = await this.userService.findByEmail(credentials.email);
             const credentialsFound: JwtCredentials = await this.userService.resolveCredentialsFor(foundUser);
-            const passwordMatched: boolean = await HashUtilities.equal(credentials.password, credentialsFound.password);
+            const passwordMatched: boolean = await this.hashService.equal(credentials.password, credentialsFound.password);
             if (!passwordMatched) {
                 throw new UnauthorizedError('Invalid email or password.');
             }
             const accessTokenValue: string = await this.generateAccessToken(foundUser);
             const refreshTokenValue: string = await this.generateRefreshToken(foundUser);
-            await this.createRefreshToken(foundUser, refreshTokenValue);
+            await this.createRefreshToken(foundUser, refreshTokenValue, UUIDUtilities.generate(), undefined);
 
             return {
                 accessToken: {
@@ -144,10 +158,12 @@ implements AuthStrategyInterface<
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async logout(data: JwtRefreshLoginData): Promise<void> {
+    async logout(data: OmitStrict<JwtRefreshLoginData, 'transaction'>): Promise<void> {
         try {
-            const refreshToken: JwtRefreshToken | undefined
-                = await this.refreshTokenRepository.findOne({ where: { value: data.refreshToken } }, false);
+            const refreshToken: JwtRefreshToken | undefined = await this.refreshTokenRepository.findOne(
+                { where: { value: data.refreshToken } },
+                false
+            );
             if (!refreshToken) {
                 return;
             }
@@ -158,20 +174,25 @@ implements AuthStrategyInterface<
         }
     }
 
-    private async createRefreshToken(foundUser: UserType, refreshTokenValue: string): Promise<JwtRefreshToken> {
+    private async createRefreshToken(
+        foundUser: UserType,
+        refreshTokenValue: string,
+        familyId: string,
+        transaction: Transaction | undefined
+    ): Promise<JwtRefreshToken> {
         const data: JwtRefreshTokenCreateDto = {
             userId: foundUser.id,
             value: refreshTokenValue,
-            familyId: UUIDUtilities.generate(),
+            familyId,
             blacklisted: false,
             expirationDate: new Date(Date.now() + this.refreshTokenExpiresInMs)
         };
-        return await this.refreshTokenRepository.create(data);
+        return await this.refreshTokenRepository.create(data, { transaction });
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     async refreshLogin(data: JwtRefreshLoginData): Promise<JwtAuthData<RoleType>> {
-        const refreshToken: JwtRefreshToken = await this.verifyAndResolveRefreshToken(data.refreshToken);
+        const refreshToken: JwtRefreshToken = await this.verifyAndResolveRefreshToken(data.refreshToken, data.transaction);
         const user: UserType = await this.userService.findById(refreshToken.userId);
         const accessTokenValue: string = await this.generateAccessToken(user);
 
@@ -189,10 +210,13 @@ implements AuthStrategyInterface<
         };
     }
 
-    private async verifyAndResolveRefreshToken(tokenValue: string): Promise<JwtRefreshToken> {
-        await JwtUtilities.verify(tokenValue, this.refreshTokenSecret);
+    private async verifyAndResolveRefreshToken(tokenValue: string, transaction: Transaction): Promise<JwtRefreshToken> {
+        const encoded: EncodedJwtAccessToken<string> | undefined = await JwtUtilities.verify(tokenValue, this.refreshTokenSecret);
+        if (!encoded) {
+            throw new UnauthorizedError('Error verifying token: Invalid Token');
+        }
         const refreshToken: JwtRefreshToken | undefined = await this.refreshTokenRepository.findOne(
-            { where: { value: tokenValue } },
+            { where: { value: tokenValue }, transaction },
             false
         );
 
@@ -200,32 +224,25 @@ implements AuthStrategyInterface<
             throw new UnauthorizedError('Error verifying token: Invalid Token');
         }
         if (refreshToken.blacklisted) {
-            await this.refreshTokenRepository.deleteAll({ familyId: refreshToken.familyId });
+            await this.refreshTokenRepository.deleteAll({ familyId: refreshToken.familyId }, { transaction });
             throw new UnauthorizedError('The given refresh token has already been used.');
         }
-
-        if (!this.isRefreshTokenExpired(refreshToken)) {
-            return refreshToken;
+        if (new Date(refreshToken.expirationDate).getTime() <= Date.now()) {
+            await this.refreshTokenRepository.deleteAll({ familyId: refreshToken.familyId }, { transaction });
+            throw new UnauthorizedError('The given refresh token is expired.');
         }
 
         const user: UserType = await this.userService.findById(refreshToken.userId);
         const refreshTokenValue: string = await this.generateRefreshToken(user);
 
-        const res: JwtRefreshToken = await this.createRefreshToken(user, refreshTokenValue);
-        await this.refreshTokenRepository.updateById(refreshToken.id, { blacklisted: true });
-        await this.refreshTokenRepository.deleteAll({ expirationDate: { before: new Date() } });
+        const res: JwtRefreshToken = await this.createRefreshToken(user, refreshTokenValue, refreshToken.familyId, transaction);
+        await this.refreshTokenRepository.updateById(refreshToken.id, { blacklisted: true }, { transaction });
         return res;
     }
 
-    private isRefreshTokenExpired(refreshToken: JwtRefreshToken): boolean {
-        const createdAt: Date = new Date(new Date(refreshToken.expirationDate).getTime() - this.refreshTokenExpiresInMs);
-        const refreshTokenLifeTimeInMs: number = Date.now() - createdAt.getTime();
-        return refreshTokenLifeTimeInMs > this.refreshTokenExpiresInMs;
-    }
-
     // eslint-disable-next-line jsdoc/require-jsdoc
     async requestPasswordReset(data: JwtRequestPasswordResetData<RoleType, UserType>): Promise<void> {
-        if (await this.activePasswordResetTokenAlreadyExists(data.user)) {
+        if (await this.activePasswordResetTokenAlreadyExists(data.user, data.transaction)) {
             throw new TooManyRequestsError('A password reset has already been requested for this account.');
         }
 
@@ -234,7 +251,10 @@ implements AuthStrategyInterface<
             userId: data.user.id,
             expirationDate: new Date(Date.now() + this.passwordResetTokenExpiresInMs)
         };
-        const resetToken: PasswordResetToken = await this.passwordResetTokenRepository.create(resetTokenData);
+        const resetToken: PasswordResetToken = await this.passwordResetTokenRepository.create(
+            resetTokenData,
+            { transaction: data.transaction }
+        );
 
         const html: string = PreactUtilities.renderEmail(
             this.PasswordResetEmail,
@@ -249,50 +269,50 @@ implements AuthStrategyInterface<
             subject: 'Password Reset',
             html,
             priority: EmailPriority.HIGH,
-            ...data
+            ...data.emailData
         });
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     async confirmPasswordReset(data: JwtConfirmPasswordResetData): Promise<void> {
-        // eslint-disable-next-line stylistic/max-len
-        const resetToken: PasswordResetToken | undefined = await this.passwordResetTokenRepository.findOne({ where: { value: data.resetToken } }, false);
+        const resetToken: PasswordResetToken | undefined = await this.passwordResetTokenRepository.findOne(
+            { where: { value: data.resetToken }, transaction: data.transaction },
+            false
+        );
         if (!resetToken) {
             throw new UnauthorizedError('Link invalid');
         }
         if (new Date(resetToken.expirationDate).getTime() <= Date.now()) {
-            await this.passwordResetTokenRepository.deleteById(resetToken.id);
+            await this.passwordResetTokenRepository.deleteById(resetToken.id, { transaction: data.transaction });
             throw new UnauthorizedError('Link expired');
         }
 
         const user: UserType = await this.userService.findById(resetToken.userId);
         const credentials: JwtCredentials = await this.userService.resolveCredentialsFor(user);
-        const hashedPassword: string = await HashUtilities.hash(data.newPassword);
-        credentials.password = hashedPassword;
 
-        await this.credentialsRepository.updateById(credentials.id, credentials);
-        await this.passwordResetTokenRepository.deleteById(resetToken.id);
-        await this.refreshTokenRepository.deleteAll({ userId: resetToken.userId });
+        await this.credentialsRepository.updateById(credentials.id, { password: data.newPassword }, { transaction: data.transaction });
+        await this.passwordResetTokenRepository.deleteById(resetToken.id, { transaction: data.transaction });
+        await this.refreshTokenRepository.deleteAll({ userId: resetToken.userId }, { transaction: data.transaction });
         // TODO: set require password change to false
     }
 
-    private async activePasswordResetTokenAlreadyExists(user: BaseUser<RoleType>): Promise<boolean> {
+    private async activePasswordResetTokenAlreadyExists(user: BaseUser<RoleType>, transaction: Transaction): Promise<boolean> {
         const existingToken: PasswordResetToken | undefined = await this.passwordResetTokenRepository.findOne(
-            { where: { userId: user.id } },
+            { where: { userId: user.id }, transaction },
             false
         );
         if (existingToken) {
             if (new Date(existingToken.expirationDate).getTime() > Date.now()) {
                 return true;
             }
-            await this.passwordResetTokenRepository.deleteById(existingToken.id);
+            await this.passwordResetTokenRepository.deleteById(existingToken.id, { transaction });
         }
         return false;
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async resolveUser(request: HttpRequest | WebsocketRequest): Promise<UserType | undefined> {
-        const jwt: string | undefined = this.extractAccessTokenFromRequest(request);
+    async resolveUser(context: HttpRequestContext | WebsocketRequestContext): Promise<UserType | undefined> {
+        const jwt: string | undefined = this.extractAccessTokenFromRequestContext(context);
         if (!jwt) {
             return undefined;
         }
@@ -305,8 +325,8 @@ implements AuthStrategyInterface<
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async isLoggedIn(request: HttpRequest | WebsocketRequest): Promise<boolean> {
-        const jwt: string | undefined = this.extractAccessTokenFromRequest(request);
+    async isLoggedIn(context: HttpRequestContext | WebsocketRequestContext): Promise<boolean> {
+        const jwt: string | undefined = this.extractAccessTokenFromRequestContext(context);
         if (!jwt) {
             return false;
         }
@@ -315,8 +335,8 @@ implements AuthStrategyInterface<
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async hasRole(request: HttpRequest | WebsocketRequest, allowedRoles: RoleType[]): Promise<boolean> {
-        const jwt: string | undefined = this.extractAccessTokenFromRequest(request);
+    async hasRole(context: HttpRequestContext | WebsocketRequestContext, allowedRoles: RoleType[]): Promise<boolean> {
+        const jwt: string | undefined = this.extractAccessTokenFromRequestContext(context);
         if (!jwt) {
             return false;
         }
@@ -329,12 +349,12 @@ implements AuthStrategyInterface<
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     async belongsTo<TargetEntity extends Newable<BaseEntity>>(
-        request: HttpRequest | WebsocketRequest,
+        context: HttpRequestContext | WebsocketRequestContext,
         targetEntity: TargetEntity,
         targetUserIdKey: keyof InstanceType<TargetEntity>,
         targetIdParamKey: string
     ): Promise<boolean> {
-        const jwt: string | undefined = this.extractAccessTokenFromRequest(request);
+        const jwt: string | undefined = this.extractAccessTokenFromRequestContext(context);
         if (!jwt) {
             return false;
         }
@@ -343,12 +363,12 @@ implements AuthStrategyInterface<
             return false;
         }
         try {
-            const repo: Repository<InstanceType<TargetEntity>> = inject(repositoryTokenFor(targetEntity));
-            const targetId: string | undefined = request.params?.[targetIdParamKey];
+            const repo: RepositoryTypeForEntity<InstanceType<TargetEntity>> = inject(repositoryTokenFor(targetEntity));
+            const targetId: string | undefined = context.request.params?.[targetIdParamKey];
             if (targetId == undefined) {
                 throw new Error(`Could not find the target id specified as path param "${targetId}"`);
             }
-            const foundTarget: InstanceType<TargetEntity> = await repo.findById(targetId);
+            const foundTarget: InstanceType<TargetEntity> = await repo.findById(targetId) as InstanceType<TargetEntity>;
             const userIdProperty: unknown = foundTarget[targetUserIdKey];
             if (Array.isArray(userIdProperty)) {
                 return userIdProperty.includes(jwtData.payload.id);
@@ -360,10 +380,10 @@ implements AuthStrategyInterface<
         }
     }
 
-    private extractAccessTokenFromRequest(
-        request: HttpRequest | WebsocketRequest
+    private extractAccessTokenFromRequestContext(
+        context: HttpRequestContext | WebsocketRequestContext
     ): string | undefined {
-        const authHeader: string | string[] | undefined = request.headers.Authorization;
+        const authHeader: string | string[] | undefined = context.request.headers.authorization;
         if (authHeader == undefined || typeof authHeader !== 'string') {
             return undefined;
         }
@@ -400,7 +420,8 @@ implements AuthStrategyInterface<
 
         return await JwtUtilities.sign(payload, this.refreshTokenSecret, {
             expiresIn: this.refreshTokenExpiresInMs / Ms.SECOND,
-            issuer: GlobalRegistry.getAppData('name')
+            issuer: GlobalRegistry.getAppData('name'),
+            jwtid: UUIDUtilities.generate()
         });
     }
 }

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

@@ -32,11 +32,16 @@ export class BackupResourceEntity extends BaseEntity {
     /**
      * The backup that this resource belongs to.
      */
-    @Property.belongsToOne({ target: () => BackupEntity, inverseSide: 'resources' })
+    @Property.belongsToOne({ target: () => BackupEntity, joinColumn: 'backupId', inverseSide: 'resources' })
     backup!: BackupEntity;
+    /**
+     * The id of the backup that this resource belongs to.
+     */
+    @Property.string({ format: 'uuid' })
+    backupId!: string;
 }
 
 /**
  * The data required to create a new backup resource.
  */
-export type BackupResourceEntityCreateData = OmitStrict<BackupResourceEntity, 'id' | 'completed' | 'backup' | 'size'>;
+export type BackupResourceEntityCreateData = OmitStrict<BackupResourceEntity, 'id' | 'completed' | 'backup' | 'backupId' | 'size'>;

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

@@ -8,7 +8,7 @@ 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 { PostgresDataSource, PostgresOptions } from '../data-source/data-sources/postgres-typeorm-data-source.model';
 import { DataSource } from '../data-source/decorators/data-source.decorator';
 import { Repository } from '../data-source/repository';
 import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';

package/src/backup/backup.service.ts

@@ -7,7 +7,7 @@ import { BackupResourceEntity, BackupResourceEntityCreateData } from './backup-r
 import { BackupResourceInterface } from './backup-resource.interface';
 import { BackupCreateData, BackupServiceInterface } from './backup-service.interface';
 import { ZibriApplication } from '../application';
-import { PostgresDataSource } from '../data-source/data-sources/postgres-data-source.model';
+import { PostgresDataSource } from '../data-source/data-sources/postgres-typeorm-data-source.model';
 import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
 import { Inject } from '../di/decorators/inject.decorator';
 import { Injectable } from '../di/decorators/injectable.decorator';
@@ -24,6 +24,7 @@ import { BackupTransportInterface } from './transports/backup-transport.interfac
 import { Repository } from '../data-source/repository';
 import { OnAppInit } from '../global/on-app-init.interface';
 import { OnAppShutdown } from '../global/on-app-shutdown.interface';
+import { JsonUtilities } from '../utilities/json.utilities';
 import { Ms } from '../utilities/ms';
 
 /**
@@ -266,7 +267,7 @@ export class BackupService implements BackupServiceInterface, OnAppInit, OnAppSh
                     [
                         `Could not resolve backup data for resource "${resource.name}" from transport: ${transport.name}.`,
                         'Cause:',
-                        error instanceof Error ? error.message : JSON.stringify(error)
+                        error instanceof Error ? error.message : JsonUtilities.stringify(error)
                     ].join('\n')
                 );
             }

package/src/backup/transports/fs.backup-transport.ts

@@ -7,6 +7,7 @@ import { ZIBRI_DI_TOKENS } from '../../di/default/zibri-di-tokens.default';
 import { inject } from '../../di/inject.function';
 import { LoggerInterface } from '../../logging/logger.interface';
 import { FsUtilities, FsPath } from '../../utilities/fs.utilities';
+import { JsonUtilities } from '../../utilities/json.utilities';
 import { BackupEntity } from '../backup-entity.model';
 import { BackupResourceEntity } from '../backup-resource-entity.model';
 
@@ -43,7 +44,7 @@ export class FsBackupTransport implements BackupTransportInterface {
                 return;
             }
             const json: string = await FsUtilities.readFile(p);
-            return JSON.parse(json) as BackupEntity;
+            return JsonUtilities.parse<BackupEntity>(json);
         }))).filter(b => b != undefined);
         return res;
     }
@@ -52,7 +53,7 @@ export class FsBackupTransport implements BackupTransportInterface {
     async storeData(data: Readable, backup: BackupEntity, resource: BackupResourceEntity): Promise<void> {
         const p: FsPath = this.getResourcePath(backup, resource);
         await FsUtilities.mkdir(this.getBackupPath(backup));
-        await FsUtilities.createFile(this.getBackupMetadataPath(backup), JSON.stringify(backup));
+        await FsUtilities.createFile(this.getBackupMetadataPath(backup), JsonUtilities.stringify(backup));
 
         await pipeline(
             data,