11702567709

Committed 06 Nov 2024 11:22AM UTC coverage: 89.129%. Remained the same

Build # 11702567709

Build Type

push

github

Committed by

PooyaRaki

Commit Message

Return value from the TypeOrm transaction callback

Run Details

2635 of 3306 branches covered (79.7%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

8917 of 9655 relevant lines covered (92.36%)

415.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.14

/src/datasources/db/v2/postgres-database.service.ts

import {
  LoggingService,
  type ILoggingService,
} from '@/logging/logging.interface';
import { InjectDataSource } from '@nestjs/typeorm';
import { Inject, Injectable } from '@nestjs/common';
import {
  DataSource,
  type EntityManager,
  type ObjectLiteral,
  type Repository,
} from 'typeorm';

@Injectable()
export class PostgresDatabaseService {
  private transactionManager?: EntityManager = undefined;

  public constructor(
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @InjectDataSource()
    private readonly dataSource: DataSource,
  ) {}

  /**
   * Returns the datasource object
   *
   * @returns {DataSource} Datasource object
   */
  public getDataSource(): DataSource {
    return this.dataSource;
  }

  /**
   * Checks whether the datasource has been initialized or not
   *
   * @returns {boolean} True if the datasource has already been initialized
   */
  public isInitialized(): boolean {
    return this.dataSource.isInitialized;
  }

  /**
   * Initializes the database connection. If the connection is not initialized, it initializes the connection.
   *
   * @returns {Promise<DataSource>} The database connection.
   */
  public async initializeDatabaseConnection(): Promise<DataSource> {
    if (!this.isInitialized()) {
      this.loggingService.info('PostgresDatabaseService initialized...');
      await this.dataSource.initialize();
    }

    return this.dataSource;
  }

  /**
   * Destroys the database connection.
   *
   * @returns {Promise<DataSource>} The database connection.
   */
  public async destroyDatabaseConnection(): Promise<DataSource> {
    if (this.isInitialized()) {
      this.loggingService.info('PostgresDatabaseService destroyed...');
      await this.dataSource.destroy();
    }

    return this.dataSource;
  }

  /**
   * Fetches a repository for the given entity.
   *
   * @param {Object} entity - The entity class.
   *
   * @returns {Promise<Repository<T>>} The repository for the entity.
   */
  public async getRepository<T extends ObjectLiteral>(entity: {
    new (): T;
  }): Promise<Repository<T>> {
    if (!this.isInitialized()) {
      await this.initializeDatabaseConnection();
    }

    return this.dataSource.getRepository<T>(entity);
  }

  public async transaction<T>(
    callback: (transactionManager: EntityManager) => Promise<T>,
  ): Promise<T> {
    return this.dataSource.transaction(
      async (transactionalEntityManager): Promise<T> => {
        this.transactionManager = transactionalEntityManager;
        return await callback(this.transactionManager);
      },
    );
  }

  public getTransactionRunner(): EntityManager {
    if (!this.transactionManager) {
      throw new Error('Query runner is not initialized...');
    }

    return this.transactionManager;
  }
}

1	import {	106✔
2	LoggingService,
3	type ILoggingService,
4	} from '@/logging/logging.interface';
5	import { InjectDataSource } from '@nestjs/typeorm';	106✔
6	import { Inject, Injectable } from '@nestjs/common';	106✔
7	import {	106✔
8	DataSource,
9	type EntityManager,
10	type ObjectLiteral,
11	type Repository,
12	} from 'typeorm';
13
14	@Injectable()
15	export class PostgresDatabaseService {	106✔
16	private transactionManager?: EntityManager = undefined;	18✔
17
18	public constructor(
19	@Inject(LoggingService) private readonly loggingService: ILoggingService,	18✔
20	@InjectDataSource()
21	private readonly dataSource: DataSource,	18✔
22	) {}
23
24	/**
25	* Returns the datasource object
26	*
27	* @returns {DataSource} Datasource object
28	*/
29	public getDataSource(): DataSource {
30	return this.dataSource;	2✔
31	}
32
33	/**
34	* Checks whether the datasource has been initialized or not
35	*
36	* @returns {boolean} True if the datasource has already been initialized
37	*/
38	public isInitialized(): boolean {
39	return this.dataSource.isInitialized;	72✔
40	}
41
42	/**
43	* Initializes the database connection. If the connection is not initialized, it initializes the connection.
44	*
45	* @returns {Promise<DataSource>} The database connection.
46	*/
47	public async initializeDatabaseConnection(): Promise<DataSource> {
48	if (!this.isInitialized()) {	24✔
49	this.loggingService.info('PostgresDatabaseService initialized...');	24✔
50	await this.dataSource.initialize();	24✔
51	}
52
53	return this.dataSource;	24✔
54	}
55
56	/**
57	* Destroys the database connection.
58	*
59	* @returns {Promise<DataSource>} The database connection.
60	*/
61	public async destroyDatabaseConnection(): Promise<DataSource> {
62	if (this.isInitialized()) {	34✔
63	this.loggingService.info('PostgresDatabaseService destroyed...');	14✔
64	await this.dataSource.destroy();	14✔
65	}
66
67	return this.dataSource;	34✔
68	}
69
70	/**
71	* Fetches a repository for the given entity.
72	*
73	* @param {Object} entity - The entity class.
74	*
75	* @returns {Promise<Repository<T>>} The repository for the entity.
76	*/
77	public async getRepository<T extends ObjectLiteral>(entity: {
78	new (): T;
79	}): Promise<Repository<T>> {
80	if (!this.isInitialized()) {	2✔
81	await this.initializeDatabaseConnection();	2✔
82	}
83
84	return this.dataSource.getRepository<T>(entity);	2✔
85	}
86
87	public async transaction<T>(
88	callback: (transactionManager: EntityManager) => Promise<T>,
89	): Promise<T> {
UNCOV 90	return this.dataSource.transaction(	×
91	async (transactionalEntityManager): Promise<T> => {
92	this.transactionManager = transactionalEntityManager;	×
NEW 93	return await callback(this.transactionManager);	×
94	},
95	);
96	}
97
98	public getTransactionRunner(): EntityManager {
99	if (!this.transactionManager) {	×
100	throw new Error('Query runner is not initialized...');	×
101	}
102
103	return this.transactionManager;	×
104	}
105	}

safe-global / safe-client-gateway / 11702567709

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous