11145458439

Committed 02 Oct 2024 02:10PM UTC coverage: 90.153% (-0.06%) from 90.21%

Build # 11145458439

Build Type

Pull #1988

github

Committed by

PooyaRaki

Commit Message

Refactor database migrator

Pull Request Pull Request #1988: OrmMigrationAndLogger

Run Details

2614 of 3275 branches covered (79.82%)

Branch coverage included in aggregate %.

50 of 77 new or added lines in 9 files covered. (64.94%)

1 existing line in 1 file now uncovered.

8501 of 9054 relevant lines covered (93.89%)

439.06 hits per line

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

81.13

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

import { PostgresDatabaseService } from '@/datasources/db/v2/postgres-database.service';
import {
  LoggingService,
  type ILoggingService,
} from '@/logging/logging.interface';
import { Inject, Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import type { DataSource } from 'typeorm';

interface LockSchema {
  id: number;
  name: number;
}

enum migrationStatus {
  RUNNING = 1,
}

@Injectable()
export class DatabaseMigrator {
  public constructor(
    @Inject(LoggingService) private readonly loggingService: ILoggingService,

    @Inject(PostgresDatabaseService)
    private readonly databaseService: PostgresDatabaseService,

    @Inject(ConfigService)
    private readonly configService: ConfigService,
  ) {
    //
  }

  /**
   * Performs the migration operation.
   *
   * @returns {Promise<void>} A promise that resolves when the migration is complete.
   *
   * @throws {Error} Throws an error if unsuccessful after a specified number of retries."
   */
  public async migrate(): Promise<void> {
    this.loggingService.info('Migrations: Running...');

    const connection =
      await this.databaseService.initializeDatabaseConnection();
    await this.createLockTableIfNotExists(connection);

    let numberOfIterations = 0;
    const numberOfRetries = await this.configService.getOrThrow(
      'db.migrator.numberOfRetries',
    );
    while (numberOfRetries >= numberOfIterations) {
      ++numberOfIterations;
      if (!(await this.lockExists(connection))) {
        await this.insertLock(connection);
        await this.runMigration(connection);
        await this.truncateLocks(connection);

        this.loggingService.info('Migrations: Finished.');
        break;
      } else {
        if (numberOfIterations === numberOfRetries) {
          throw new Error(
            'Migrations: Migrations are still running in another instance!',
          );
        }
        this.loggingService.info('Migrations: Running in another instance...');
        const retryAfter = this.configService.getOrThrow<number>(
          'db.migrator.retryAfter',
        );

        await new Promise((resolve) => setTimeout(resolve, retryAfter));
      }
    }
  }

  /**
   * Creates the locks table in the database if it does not already exist.
   *
   * @param {DataSource} connection The database connection to create the locks table on.
   *
   * @returns {Promise<void>} A promise that resolves when the locks table has been created or confirmed to exist.
   */
  private async createLockTableIfNotExists(
    connection: DataSource,
  ): Promise<void> {
    await connection.query(
      'CREATE TABLE IF NOT EXISTS "_lock" ("id" SERIAL NOT NULL, "status" int NOT NULL, PRIMARY KEY ("id"))',
    );
  }

  /**
   * Inserts a new lock into the database.
   *
   * @param {DataSource} connection The database connection to insert the lock into.
   *
   * @returns {Promise<void>} A promise that resolves when the lock has been inserted.
   */
  private async insertLock(connection: DataSource): Promise<void> {
    await connection.query('INSERT INTO "_lock" (status) VALUES ($1);', [
      migrationStatus.RUNNING,
    ]);
  }

  /**
   * Truncates the locks table in the database.
   *
   * @param {DataSource} connection The database connection to truncate the locks table.
   *
   * @returns {Promise<void>} A promise that resolves when the locks table has been truncated.
   */
  private async truncateLocks(connection: DataSource): Promise<void> {
    await connection.query('TRUNCATE TABLE "_lock";');
  }

  /**
   * Selects and retrieves locks from the database.
   *
   * @param {DataSource} connection The database connection to select locks from.
   *
   * @returns {Promise<Array<LockSchema>>} A promise that resolves to an array of LockSchema objects.
   */
  private async selectLock(connection: DataSource): Promise<Array<LockSchema>> {
    return await connection.query('SELECT "id", "status" FROM "_lock";');
  }

  /**
   * Checks if a lock exists in the database.
   *
   * @param {DataSource} connection The database connection to check for the lock.
   *
   * @returns {Promise<boolean>} A promise that resolves to true if the lock exists, otherwise false.
   */
  private async lockExists(connection: DataSource): Promise<boolean> {
    const lock = await this.selectLock(connection);

    return lock && lock.length > 0;
  }

  /**
   * Runs the migration process for the given database connection.
   *
   * @param {DataSource} connection The database connection to run the migration on.
   *
   * @returns {Promise<void>} An empty promise that resolves when the migration is complete.
   */
  private async runMigration(connection: DataSource): Promise<void> {
    const migrations = await connection.runMigrations({ transaction: 'all' });

    if (migrations && migrations.length > 0) {
      this.loggingService.info(
        `Migrations: Successfully executed ${migrations.length} migrations.`,
      );
    } else {
      this.loggingService.info('Migrations: No migrations to execute.');
    }
  }
}

1	import { PostgresDatabaseService } from '@/datasources/db/v2/postgres-database.service';	98✔
2	import {	98✔
3	LoggingService,
4	type ILoggingService,
5	} from '@/logging/logging.interface';
6	import { Inject, Injectable } from '@nestjs/common';	98✔
7	import { ConfigService } from '@nestjs/config';	98✔
8	import type { DataSource } from 'typeorm';
9
10	interface LockSchema {
11	id: number;
12	name: number;
13	}
14
15	enum migrationStatus {	98✔
16	RUNNING = 1,	98✔
17	}
18
19	@Injectable()
20	export class DatabaseMigrator {	98✔
21	public constructor(
22	@Inject(LoggingService) private readonly loggingService: ILoggingService,	1,592✔
23
24	@Inject(PostgresDatabaseService)
25	private readonly databaseService: PostgresDatabaseService,	1,592✔
26
27	@Inject(ConfigService)
28	private readonly configService: ConfigService,	1,592✔
29	) {
30	//
31	}
32
33	/**
34	* Performs the migration operation.
35	*
36	* @returns {Promise<void>} A promise that resolves when the migration is complete.
37	*
38	* @throws {Error} Throws an error if unsuccessful after a specified number of retries."
39	*/
40	public async migrate(): Promise<void> {
41	this.loggingService.info('Migrations: Running...');	2✔
42
43	const connection =
44	await this.databaseService.initializeDatabaseConnection();	2✔
45	await this.createLockTableIfNotExists(connection);	2✔
46
47	let numberOfIterations = 0;	2✔
48	const numberOfRetries = await this.configService.getOrThrow(	2✔
49	'db.migrator.numberOfRetries',
50	);
51	while (numberOfRetries >= numberOfIterations) {	2✔
52	++numberOfIterations;	2✔
53	if (!(await this.lockExists(connection))) {	2!
54	await this.insertLock(connection);	2✔
55	await this.runMigration(connection);	2✔
56	await this.truncateLocks(connection);	2✔
57
58	this.loggingService.info('Migrations: Finished.');	2✔
59	break;	2✔
60	} else {
NEW 61	if (numberOfIterations === numberOfRetries) {	×
NEW 62	throw new Error(	×
63	'Migrations: Migrations are still running in another instance!',
64	);
65	}
NEW 66	this.loggingService.info('Migrations: Running in another instance...');	×
NEW 67	const retryAfter = this.configService.getOrThrow<number>(	×
68	'db.migrator.retryAfter',
69	);
70
NEW 71	await new Promise((resolve) => setTimeout(resolve, retryAfter));	×
72	}
73	}
74	}
75
76	/**
77	* Creates the locks table in the database if it does not already exist.
78	*
79	* @param {DataSource} connection The database connection to create the locks table on.
80	*
81	* @returns {Promise<void>} A promise that resolves when the locks table has been created or confirmed to exist.
82	*/
83	private async createLockTableIfNotExists(
84	connection: DataSource,
85	): Promise<void> {
86	await connection.query(	2✔
87	'CREATE TABLE IF NOT EXISTS "_lock" ("id" SERIAL NOT NULL, "status" int NOT NULL, PRIMARY KEY ("id"))',
88	);
89	}
90
91	/**
92	* Inserts a new lock into the database.
93	*
94	* @param {DataSource} connection The database connection to insert the lock into.
95	*
96	* @returns {Promise<void>} A promise that resolves when the lock has been inserted.
97	*/
98	private async insertLock(connection: DataSource): Promise<void> {
99	await connection.query('INSERT INTO "_lock" (status) VALUES ($1);', [	2✔
100	migrationStatus.RUNNING,
101	]);
102	}
103
104	/**
105	* Truncates the locks table in the database.
106	*
107	* @param {DataSource} connection The database connection to truncate the locks table.
108	*
109	* @returns {Promise<void>} A promise that resolves when the locks table has been truncated.
110	*/
111	private async truncateLocks(connection: DataSource): Promise<void> {
112	await connection.query('TRUNCATE TABLE "_lock";');	2✔
113	}
114
115	/**
116	* Selects and retrieves locks from the database.
117	*
118	* @param {DataSource} connection The database connection to select locks from.
119	*
120	* @returns {Promise<Array<LockSchema>>} A promise that resolves to an array of LockSchema objects.
121	*/
122	private async selectLock(connection: DataSource): Promise<Array<LockSchema>> {
123	return await connection.query('SELECT "id", "status" FROM "_lock";');	2✔
124	}
125
126	/**
127	* Checks if a lock exists in the database.
128	*
129	* @param {DataSource} connection The database connection to check for the lock.
130	*
131	* @returns {Promise<boolean>} A promise that resolves to true if the lock exists, otherwise false.
132	*/
133	private async lockExists(connection: DataSource): Promise<boolean> {
134	const lock = await this.selectLock(connection);	2✔
135
136	return lock && lock.length > 0;	2✔
137	}
138
139	/**
140	* Runs the migration process for the given database connection.
141	*
142	* @param {DataSource} connection The database connection to run the migration on.
143	*
144	* @returns {Promise<void>} An empty promise that resolves when the migration is complete.
145	*/
146	private async runMigration(connection: DataSource): Promise<void> {
147	const migrations = await connection.runMigrations({ transaction: 'all' });	2✔
148
149	if (migrations && migrations.length > 0) {	2!
NEW 150	this.loggingService.info(	×
151	`Migrations: Successfully executed ${migrations.length} migrations.`,
152	);
153	} else {
154	this.loggingService.info('Migrations: No migrations to execute.');	2✔
155	}
156	}
157	}

safe-global / safe-client-gateway / 11145458439

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