node-server-engine 1.4.8 → 1.5.0

package/src/middleware/version/version.test.ts

@@ -1,23 +0,0 @@
-import express from 'express';
-import { describe } from 'mocha';
-import request from 'supertest';
-import { version as engineVersion } from '../../../package.json';
-import { version } from './version';
-
-describe('Middleware - version', () => {
-  let serviceVersion: string;
-
-  beforeEach(() => {
-    serviceVersion = '1.0.1';
-    process.env.BUILD_ID = serviceVersion;
-  });
-
-  it('should fetch the current version of the service', async () => {
-    const app = express();
-    app.use(version());
-
-    await request(app)
-      .get('/version')
-      .expect(200, { version: serviceVersion, engineVersion });
-  });
-});

package/src/middleware/version/version.ts

@@ -1,12 +0,0 @@
-import { Router, Request, Response } from 'express';
-import { version as engineVersion } from '../../../package.json';
-
-/**
- * Path returning the version of the service
- * @return {Router}
- */
-export function version(): Router {
-  return Router().use('/version', (req: Request, res: Response) => {
-    res.json({ version: process.env.BUILD_ID, engineVersion });
-  });
-}

package/src/utils/checkEnvironment/index.ts

@@ -1,49 +0,0 @@
-import { cleanEnv, ReporterOptions } from 'envalid';
-import { EngineError } from 'entities/EngineError';
-import { reportError } from 'utils/report';
-
-/**
- * Create an Envalid reporter
- * @param shouldExit - should the reporter exit the process on fail
- * @return Envalid reporter function
- */
-function createReporter(shouldExit: boolean) {
-  return (reporter: ReporterOptions<unknown>): void => {
-    const { errors } = reporter;
-    const failedChecks = Object.keys(errors);
-    const message = failedChecks.join(', ');
-    if (failedChecks.length == 0) return;
-    if (shouldExit) {
-      reportError(
-        new EngineError({
-          message: `Check Environment Failed:  ${message}`,
-          data: failedChecks
-        })
-      );
-      process.exit(1);
-    }
-    throw new EngineError({
-      message: `Check Environment Failed:  ${message}`,
-      data: failedChecks
-    });
-  };
-}
-
-/**
- * Ensure the process.env is valid using Envalid.
- * if the validation fails it will log a helpful EngineError.emergency()
- * and exit the process with status-code 1.
- * @param validators - Envalid validators
- */
-export function checkEnvironment(validators = {}): void {
-  cleanEnv(process.env, validators, { reporter: createReporter(true) });
-}
-
-/**
- * Ensure the process.env is valid using Envalid.
- * if the validation fails it will throw a EngineError.emergency()
- * @param validators - Envalid validators
- */
-export function assertEnvironment(validators = {}): void {
-  cleanEnv({ ...process.env }, validators, { reporter: createReporter(false) });
-}

package/src/utils/createHttpServer/createHttpServer.test.ts

@@ -1,24 +0,0 @@
-import { Server } from 'http';
-import { Server as SecureServer } from 'https';
-import { expect } from 'chai';
-import { createHttpServer } from './createHttpServer';
-import { validateHttpEnvironment } from './createHttpServer.validate';
-
-describe('App - httpServer', () => {
-  it('should create an httpServer', () => {
-    delete process.env.TLS_SERVER_KEY;
-    delete process.env.TLS_SERVER_CERT;
-    const httpServer = createHttpServer();
-    expect(httpServer instanceof Server).to.be.ok;
-  });
-
-  it('should create an httpsServer', () => {
-    const httpServer = createHttpServer();
-    expect(httpServer instanceof SecureServer).to.be.ok;
-  });
-
-  it('should accept TLS environment variables', () => {
-    process.env.TLS_SERVER_KEY_PASSPHRASE = 'password';
-    expect(validateHttpEnvironment).to.not.throw;
-  });
-});

package/src/utils/createHttpServer/createHttpServer.ts

@@ -1,34 +0,0 @@
-import fs from 'fs';
-import { createServer, RequestListener, Server } from 'http';
-import {
-  createServer as createSecureServer,
-  Server as SecureServer
-} from 'https';
-import { Application } from 'express';
-import { validateHttpEnvironment } from './createHttpServer.validate';
-
-/** Create and configure an http/https server */
-export function createHttpServer(
-  handler?: Application | RequestListener
-): Server | SecureServer {
-  // Validate the environment variables
-  validateHttpEnvironment();
-  // Create a https server if env var are specified
-  if (process.env.TLS_SERVER_KEY && process.env.TLS_SERVER_CERT) {
-    return createSecureServer(
-      {
-        key: fs.readFileSync(process.env.TLS_SERVER_KEY),
-        passphrase: process.env.TLS_SERVER_KEY_PASSPHRASE,
-        cert: fs.readFileSync(process.env.TLS_SERVER_CERT),
-        ca: process.env.TLS_CA
-          ? fs.readFileSync(process.env.TLS_CA)
-          : undefined,
-        requestCert: true,
-        rejectUnauthorized: true
-      },
-      handler
-    );
-  } else {
-    return createServer(handler);
-  }
-}

package/src/utils/createHttpServer/createHttpServer.validate.ts

@@ -1,17 +0,0 @@
-import { assertEnvironment, envAssert } from 'utils';
-
-/**
- * Environment variable validator for the creation of a HTTP(S) server
- */
-export function validateHttpEnvironment(): void {
-  // We only check if there is at least the host specified
-  if (process.env.TLS_SERVER_CERT && process.env.TLS_SERVER_CERT) {
-    assertEnvironment({ TLS_SERVER_KEY: envAssert.isPath() });
-    assertEnvironment({ TLS_SERVER_CERT: envAssert.isPath() });
-    // Optional variables
-    if (process.env.TLS_SERVER_KEY_PASSPHRASE) {
-      assertEnvironment({ TLS_SERVER_KEY_PASSPHRASE: envAssert.isString() });
-    }
-    if (process.env.TLS_CA) assertEnvironment({ TLS_CA: envAssert.isPath() });
-  }
-}

package/src/utils/createHttpServer/index.ts

@@ -1 +0,0 @@
-export * from './createHttpServer';

package/src/utils/createSortedObject/createSortedObject.ts

@@ -1,20 +0,0 @@
-/** Deep sort the objects keys alphabetically */
-export function createSortedObject<T>(data: T): T {
-  if (!(data instanceof Object)) throw new Error('Non');
-  const result: Record<string, unknown> = {};
-  Object.keys(data)
-    .sort()
-    .forEach((key: string) => {
-      const value = (data as Record<string, unknown>)[key];
-      if (
-        typeof value !== 'object' ||
-        value instanceof Array ||
-        value === null
-      ) {
-        result[key] = value;
-      } else {
-        result[key] = createSortedObject(value);
-      }
-    });
-  return result as T;
-}

package/src/utils/createSortedObject/createSortedObjet.test.ts

@@ -1,47 +0,0 @@
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { createSortedObject } from './createSortedObject';
-
-describe('Utils - createSortedObject', () => {
-  it('should sort an object', () => {
-    const object: { [key: string]: string } = {};
-    for (let i = 0; i < 20; i++) {
-      object[faker.lorem.word()] = faker.lorem.word();
-    }
-    const sorted = createSortedObject(object);
-    const expectedKeys = Object.keys(object).sort();
-    const sortedKeys = Object.keys(sorted);
-
-    expectedKeys.forEach((value, index) => {
-      expect(value).to.equal(sortedKeys[index]);
-    });
-  });
-
-  it('should deeply sort an object', () => {
-    const object: {
-      /** */
-      x: { [key: string]: string };
-    } = { x: {} };
-    for (let i = 0; i < 20; i++) {
-      object.x[faker.lorem.word()] = faker.lorem.word();
-    }
-    const sorted = createSortedObject(object);
-    const expectedKeys = Object.keys(object.x).sort();
-    const sortedKeys = Object.keys(sorted.x);
-
-    expectedKeys.forEach((value, index) => {
-      expect(value).to.equal(sortedKeys[index]);
-    });
-  });
-
-  it('should handle null values', () => {
-    const object = { a: null };
-    expect(() => createSortedObject(object)).to.not.throw();
-  });
-
-  it('should not sort arrays', () => {
-    const object = { a: ['z', 'a', 'o', 'd'] };
-    const sorted = createSortedObject(object);
-    expect(object).to.deep.equal(sorted);
-  });
-});

package/src/utils/createSortedObject/index.ts

@@ -1 +0,0 @@
-export * from './createSortedObject';

package/src/utils/dbMigration/dbMigration.test.ts

@@ -1,209 +0,0 @@
-// import path from 'path';
-// import { expect } from 'chai';
-// import mockFs, { restore } from 'mock-fs';
-// import mockRequire from 'mock-require';
-// import {
-//   runPendingMigrations,
-//   rollbackMigrations,
-//   testClearDB
-// } from './dbMigration';
-// import { SequelizeMeta } from 'db/models';
-// import { factory } from 'test';
-
-// describe('Utils - DB Migration', function () {
-//   beforeEach(async () => {
-//     await testClearDB({ includeMetadata: true });
-
-//     process.env.BUILD_ID = '1.5.0';
-
-//     const basePath = path.join(process.cwd(), './src/db/migrations');
-//     // Requires use the real filesystem and need to be mocked
-//     const requiredContent = {
-//       // eslint-disable-next-line @typescript-eslint/no-empty-function
-//       up: async (): Promise<void> => {},
-//       // eslint-disable-next-line @typescript-eslint/no-empty-function
-//       down: async (): Promise<void> => {}
-//     };
-//     mockRequire(`${basePath}/1-test.js`, requiredContent);
-//     mockRequire(`${basePath}/2-test.js`, requiredContent);
-//     mockRequire(`${basePath}/3-test.ts`, requiredContent);
-//     // Umzug checks that the files is on the FS
-//     mockFs({
-//       [basePath]: { '1-test.js': '', '2-test.js': '', '3-test.ts': '' }
-//     });
-//   });
-
-//   afterEach(() => {
-//     restore();
-//     mockRequire.stopAll();
-//   });
-
-//   describe('runPendingMigrations', function () {
-//     // it('should run the migrations when there are no history', async () => {
-//     //   await runPendingMigrations();
-
-//     //   const migrations = await SequelizeMeta.findAll();
-
-//     //   expect(migrations).to.have.length(3);
-//     //   migrations.forEach((migration) => {
-//     //     expect(['1-test.js', '2-test.js', '3-test.ts']).to.include(migration.name);
-//     //     expect(migration.version).to.equal(process.env.BUILD_ID);
-//     //   });
-//     // });
-
-//     it('should prefer migrations in the prod directory', async () => {
-//       const prodBasePath = path.join(process.cwd(), './dist/db/migrations');
-//       // Requires use the real filesystem and need to be mocked
-//       const requiredContent = {
-//         // eslint-disable-next-line @typescript-eslint/no-empty-function
-//         up: async (): Promise<void> => {},
-//         // eslint-disable-next-line @typescript-eslint/no-empty-function
-//         down: async (): Promise<void> => {}
-//       };
-//       mockRequire(`${prodBasePath}/1-prod-test.js`, requiredContent);
-//       mockRequire(`${prodBasePath}/2-prod-test.js`, requiredContent);
-//       mockRequire(`${prodBasePath}/3-prod-test.js`, requiredContent);
-//       // Umzug checks that the files is on the FS
-//       mockFs({
-//         [prodBasePath]: {
-//           '1-prod-test.js': '',
-//           '2-prod-test.js': '',
-//           '3-prod-test.js': ''
-//         }
-//       });
-
-//       await runPendingMigrations();
-
-//       const migrations = await SequelizeMeta.findAll();
-
-//       expect(migrations).to.have.length(3);
-//       migrations.forEach((migration) => {
-//         expect([
-//           '1-prod-test.js',
-//           '2-prod-test.js',
-//           '3-prod-test.js'
-//         ]).to.include(migration.name);
-//         expect(migration.version).to.equal(process.env.BUILD_ID);
-//       });
-
-//       it('should allow to specify a custom directory', async () => {
-//         const customBasePath = path.join(process.cwd(), './migrations');
-//         process.env.DB_MIGRATIONS_DIR = customBasePath;
-
-//         // Requires use the real filesystem and need to be mocked
-//         const requiredContent = {
-//           // eslint-disable-next-line @typescript-eslint/no-empty-function
-//           up: async (): Promise<void> => {},
-//           // eslint-disable-next-line @typescript-eslint/no-empty-function
-//           down: async (): Promise<void> => {}
-//         };
-//         mockRequire(`${customBasePath}/1-custom-test.js`, requiredContent);
-//         mockRequire(`${customBasePath}/2-custom-test.js`, requiredContent);
-//         mockRequire(`${customBasePath}/3-custom-test.js`, requiredContent);
-//         // Umzug checks that the files is on the FS
-//         mockFs({
-//           [customBasePath]: {
-//             '1-custom-test.js': '',
-//             '2-custom-test.js': '',
-//             '3-custom-test.js': ''
-//           }
-//         });
-
-//         await runPendingMigrations();
-
-//         const migrations = await SequelizeMeta.findAll();
-
-//         expect(migrations).to.have.length(3);
-//         migrations.forEach((migration) => {
-//           expect([
-//             '1-custom-test.js',
-//             '2-custom-test.js',
-//             '3-custom-test.js'
-//           ]).to.include(migration.name);
-//           expect(migration.version).to.equal(process.env.BUILD_ID);
-//         });
-//       });
-//     });
-//   });
-
-//   describe('rollbackMigrations', function () {
-//     it('should not rollback previous migrations', async () => {
-//       await factory.create('sequelizeMeta', {
-//         name: '1-test.js',
-//         version: '1.4.0'
-//       });
-//       await factory.create('sequelizeMeta', {
-//         name: '2-test.js',
-//         version: process.env.BUILD_ID
-//       });
-
-//       await rollbackMigrations();
-
-//       // expect(rolledBack).to.have.length(0);
-//     });
-
-//     it('should rollback the higher migrations', async () => {
-//       await factory.create('sequelizeMeta', {
-//         name: '1-test.js',
-//         version: '1.5.0'
-//       });
-//       await factory.create('sequelizeMeta', {
-//         name: '2-test.js',
-//         version: process.env.BUILD_ID
-//       });
-//       await factory.create('sequelizeMeta', {
-//         name: '3-test.ts',
-//         version: '1.5.1'
-//       });
-
-//       await rollbackMigrations();
-
-//       // expect(rolledBack).to.have.length(1);
-//       // expect(rolledBack[0].file).to.equal('3-test.ts');
-//     });
-
-//     it('should rollback multiple migrations with higher version', async () => {
-//       await factory.create('sequelizeMeta', {
-//         name: '1-test.js',
-//         version: process.env.BUILD_ID
-//       });
-//       await factory.create('sequelizeMeta', {
-//         name: '2-test.js',
-//         version: '1.5.2'
-//       });
-//       await factory.create('sequelizeMeta', {
-//         name: '3-test.ts',
-//         version: '1.6.0'
-//       });
-
-//       await rollbackMigrations();
-
-//       // expect(rolledBack).to.have.length(2);
-//       // rolledBack.forEach((migration) => {
-//       //   expect(['2-test.js', '3-test.ts']).to.include(migration.file);
-//       // });
-//     });
-
-//     it('should handle pre-release (alpha<beta)', async () => {
-//       process.env.BUILD_ID = '1.5.0-alpha.2';
-
-//       await factory.create('sequelizeMeta', {
-//         name: '1-test.js',
-//         version: '1.5.0-alpha.1'
-//       });
-//       await factory.create('sequelizeMeta', {
-//         name: '2-test.js',
-//         version: process.env.BUILD_ID
-//       });
-//       await factory.create('sequelizeMeta', {
-//         name: '3-test.ts',
-//         version: '1.5.0-beta.1'
-//       });
-
-//       await rollbackMigrations();
-
-//       // expect(rolledBack).to.have.length(1);
-//       // expect(rolledBack[0].file).to.equal('3-test.ts');
-//     });
-//   });
-// });

package/src/utils/dbMigration/dbMigration.ts

@@ -1,199 +0,0 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-// Register ts-node at the top of runMigrations.ts
-require('ts-node/register');
-
-import { existsSync, lstatSync } from 'fs';
-import { join } from 'path';
-import { Sequelize, Transaction } from 'sequelize';
-import { Umzug, SequelizeStorage } from 'umzug';
-import { ClearDbOptions, RecreateDbOptions } from './dbMigration.types';
-import { migrateMetadataTable } from './migrateMetadataTable';
-import { SequelizeMeta } from 'db/models';
-import { EngineError } from 'entities/EngineError';
-import { sequelize } from 'entities/Sequelize';
-import { reportDebug } from 'utils/report';
-import { semverCompare } from 'utils/semverCompare';
-
-const namespace = 'engine:utils:dbMigration';
-
-function getMigrationPaths(): Array<string> | undefined {
-  // We look between possibilities for the first directory that exists and matches our expectations
-  // First a user specified one, then the production default, then the development default
-  const prodDefaultPath = join(process.cwd(), './dist/db/migrations');
-  const devDefaultPath = join(process.cwd(), './src/db/migrations');
-  const path = [
-    process.env.DB_MIGRATIONS_DIR,
-    process.env.NODE_ENV === 'prod' ? prodDefaultPath : devDefaultPath
-  ].filter((path) => path && existsSync(path) && lstatSync(path).isDirectory());
-  reportDebug({
-    namespace,
-    message: 'Obtaining Umzug migration options',
-    data: {
-      path,
-      prodPath: prodDefaultPath,
-      devPath: devDefaultPath,
-      customPath: process.env.DB_MIGRATIONS_DIR
-    }
-  });
-  return path.map((p) =>
-    process.env.NODE_ENV === 'prod' ? `${p}/*.js` : `${p}/*.ts`
-  );
-}
-
-/** Run all the non-executed migrations one by one */
-export async function runPendingMigrations(): Promise<void> {
-  if (!sequelize)
-    throw new EngineError({ message: 'Sequelize is not initialized' });
-  // First make sure that the metadata table is up to date
-  await migrateMetadataTable(sequelize);
-  const migrationPaths = getMigrationPaths();
-
-  if (!migrationPaths || migrationPaths.length <= 0) {
-    reportDebug({
-      namespace,
-      message: 'No valid migration paths found.',
-      data: { migrationPaths }
-    });
-    return;
-  }
-
-  migrationPaths?.forEach(async (path) => {
-    const migrator = new Umzug({
-      migrations: {
-        glob: path,
-        resolve: ({ name, path, context }) => {
-          // Use require to import the migration file
-          const migration = require(path || '');
-          return {
-            name,
-            up: async () => migration.up(context),
-            down: async () => migration.down(context)
-          };
-        }
-      },
-      context: sequelize.getQueryInterface(),
-      storage: new SequelizeStorage({ sequelize }),
-      logger: console
-    });
-
-    reportDebug({
-      namespace,
-      message: 'Starting pending database migrations',
-      data: { path }
-    });
-    await migrator.up();
-    console.log('Db Migration Completed');
-  });
-}
-
-/** Rollback all migrations up to a specified target version */
-export async function rollbackMigrations(): Promise<void> {
-  if (!sequelize)
-    throw new EngineError({ message: 'Sequelize is not initialized' });
-  if (!process.env.BUILD_ID)
-    throw new EngineError({ message: 'BUILD_ID is not defined' });
-
-  // Fetch executed migrations in ascending order
-  const migrations = await SequelizeMeta.findAll({
-    order: [['name', 'ASC']],
-    raw: true
-  });
-  const rollbackUntil = migrations.find(
-    (migration) =>
-      migration.version &&
-      semverCompare(migration.version, process.env.BUILD_ID as string) === 1
-  );
-
-  if (!rollbackUntil) {
-    reportDebug({
-      namespace,
-      message: 'No rollback target found for the current BUILD_ID.',
-      data: { buildId: process.env.BUILD_ID }
-    });
-    return;
-  }
-
-  const migrationPaths = getMigrationPaths();
-
-  if (!migrationPaths || migrationPaths.length <= 0) {
-    reportDebug({
-      namespace,
-      message: 'No valid migration paths found for rollback.',
-      data: { migrationPaths }
-    });
-    return;
-  }
-
-  migrationPaths.forEach(async (path) => {
-    const migrator = new Umzug({
-      migrations: {
-        glob: path,
-        resolve: ({ name, path, context }) => {
-          const migration = require(path || '');
-          return {
-            name,
-            up: async () => migration.up(context),
-            down: async () => migration.down(context)
-          };
-        }
-      },
-      context: sequelize.getQueryInterface(),
-      storage: new SequelizeStorage({ sequelize }),
-      logger: console
-    });
-
-    reportDebug({
-      namespace,
-      message: `Rolling back migrations up to: ${rollbackUntil.name}`,
-      data: { path }
-    });
-
-    await migrator.down({ to: rollbackUntil.name });
-  });
-}
-
-/**
- * Recreate the whole database
- * Quick way to make sure that we are working on a clean database
- * /!\ Should only be used when running tests
- */
-export async function testRecreateDB(
-  options: RecreateDbOptions = {}
-): Promise<void> {
-  if (!sequelize)
-    throw new EngineError({ message: 'Sequelize is not initialized' });
-  await sequelize.query(
-    `DROP SCHEMA public${process.env.SQL_TYPE === 'postgres' ? ' CASCADE' : ''}`
-  );
-  await sequelize.query(`CREATE SCHEMA public`);
-  if (!options.clean) await runPendingMigrations();
-}
-
-/**
- * Empty all the schemas in the database
- * Quick way to flush the database data while keep the structure
- * /!\ Should only be used when running tests
- */
-export async function testClearDB(options: ClearDbOptions = {}): Promise<void> {
-  if (!sequelize)
-    throw new EngineError({ message: 'Sequelize is not initialized' });
-  await sequelize.transaction(clearDbTransaction(sequelize, options));
-}
-
-/** DB clearing transaction */
-function clearDbTransaction(sequelize: Sequelize, options: ClearDbOptions) {
-  return async (t: Transaction): Promise<void> => {
-    for (const model of Object.keys(sequelize.models)) {
-      // We ignore the migration metadata schema
-      if (!options.includeMetadata && model === 'sequelizeMeta') continue;
-      const table = sequelize.models[model].tableName;
-      await sequelize.query(
-        `TRUNCATE ${table}${process.env.SQL_TYPE === 'postgres' ? ' CASCADE' : ''};`,
-        {
-          raw: true,
-          transaction: t
-        }
-      );
-    }
-  };
-}

package/src/utils/dbMigration/dbMigration.types.ts

@@ -1,11 +0,0 @@
-/** Options to recreate the database */
-export interface RecreateDbOptions {
-  /** Do not run the migrations, leave the DB empty */
-  clean?: boolean;
-}
-
-/** Options to clear the database */
-export interface ClearDbOptions {
-  /** Also truncate the migration metadata table. This should only be used when testing on the metadata table itself */
-  includeMetadata?: boolean;
-}

package/src/utils/dbMigration/index.ts

@@ -1,2 +0,0 @@
-export * from './dbMigration';
-export * from './dbMigration.types';

package/src/utils/dbMigration/migrateMetadataTable/index.ts

@@ -1 +0,0 @@
-export * from './migrateMetadataTable';