node-server-engine 1.4.9 → 1.5.1

package/src/entities/Sequelize/Sequelize.config.ts

@@ -1,59 +0,0 @@
-import { Options, Dialect } from 'sequelize';
-import { validateSequelizeEnvironment } from './Sequelize.validate';
-
-// Check that environment variables are correctly set
-validateSequelizeEnvironment();
-
-const config: Options = {
-  username: process.env.SQL_USER,
-  password: process.env.SQL_PASSWORD,
-  database: process.env.SQL_DB,
-  host: process.env.SQL_HOST,
-  port: process.env.SQL_PORT ? parseInt(process.env.SQL_PORT) : 5432, // Default port for PostgreSQL
-  dialect: (process.env.SQL_TYPE ?? 'postgres') as Dialect, // Dynamically set the dialect (postgres, mysql, mssql)
-  logging: false, // Set to true for debugging SQL queries
-  define: {
-    freezeTableName: false, // Prevent automatic pluralization of table names
-    charset: 'utf8mb4', // Set character set for MySQL/MariaDB
-    collate: 'utf8mb4_unicode_ci' // Set collation for MySQL/MariaDB
-  },
-  retry: {
-    max: 5 // Maximum retry attempts for failed queries
-  },
-  dialectOptions: {},
-  pool: {
-    max: 5,
-    min: 0,
-    acquire: 30000, // Maximum time to wait for a connection
-    idle: 10000 // Maximum idle time for connections
-  },
-};
-
-// Additional configurations for MSSQL
-if (config.dialect === 'mssql') {
-  config.dialectOptions = {
-    requestTimeout: 30000, // Increase request timeout for MSSQL
-    connectTimeout: 30000, // Increase connection timeout for MSSQL
-    encrypt: true, // Use encryption for MSSQL (set to false if not needed)
-    trustServerCertificate: true, // Set to true if using self-signed certificates
-  };
-}
-
-// Add specific dialect configurations if necessary for MySQL/PostgreSQL
-if (config.dialect === 'mysql') {
-  config.dialectOptions = {
-    timezone: 'Z', // Set timezone for MySQL
-  };
-}
-
-if (config.dialect === 'postgres') {
-  config.dialectOptions = {
-    ssl: process.env.PG_SSL === 'true' ? { rejectUnauthorized: false } : false, // SSL options for PostgreSQL (if required)
-  };
-}
-
-export const development = config;
-export const staging = config;
-export const production = config;
-export const test = config;
-export default config;

package/src/entities/Sequelize/Sequelize.test.ts

@@ -1,21 +0,0 @@
-import { expect } from 'chai';
-import { validateSequelizeEnvironment } from './Sequelize.validate';
-
-describe('Entity - Sequelize', () => {
-  it('Should validate process env if needed', () => {
-    process.env.SQL_HOST = '127.0.0.1';
-    process.env.SQL_PORT = '5423';
-    process.env.SQL_PASSWORD = 'password';
-    process.env.SQL_DB = 'db';
-    process.env.SQL_USER = 'sql';
-    expect(validateSequelizeEnvironment).not.to.throw();
-  });
-
-  it('Should allow only required variables', () => {
-    process.env.SQL_HOST = '127.0.0.1';
-    process.env.SQL_PASSWORD = 'password';
-    process.env.SQL_DB = 'db';
-    process.env.SQL_USER = 'sql';
-    expect(validateSequelizeEnvironment).not.to.throw();
-  });
-});

package/src/entities/Sequelize/Sequelize.ts

@@ -1,75 +0,0 @@
-import { Sequelize, ModelCtor } from 'sequelize-typescript';
-import dbConfig from './Sequelize.config';
-import { Sequelize as SequelizeInterface } from './Sequelize.types';
-import { validateSequelizeEnvironment } from './Sequelize.validate';
-import { EngineError } from 'entities/EngineError';
-import { LifecycleController } from 'entities/LifecycleController';
-
-export let sequelizeClient: undefined | Sequelize;
-
-/**
- * We use a proxy to extend the Sequelize behavior and allow initialization of the client only when needed while keeping the same interface
- */
-export const sequelize = new Proxy<SequelizeInterface>(
-  // Due to how we do the proxying, we are forced to ignore ts-errors, we could never create an object that respects the interface properly
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  {},
-  {
-    get: function (target, property): unknown {
-      if (property === 'init') return init;
-      if (property === 'shutdown') return shutdown;
-      if (property === 'addModels') return addModels;
-      // Create the sequelize client if it does not exist
-      if (!sequelizeClient)
-        throw new EngineError({
-          message: 'Sequelize client was not initialized'
-        });
-      // Call the function on the sequelize client
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      return sequelizeClient[property] as unknown;
-    }
-  }
-);
-
-/** On init create client and connect */
-export function init(): void {
-  // Ignore if already initialized
-  if (sequelizeClient) return;
-  sequelizeClient = createSequelizeClient();
-  sequelizeClient
-    .authenticate()
-    .then(() => console.log('Connected to database.'))
-    .catch((err: Error) =>
-      console.error('Unable to connect to the database:', err)
-    );
-  LifecycleController.register(sequelize);
-}
-
-/** On shutdown close connection and clear client */
-export async function shutdown(): Promise<void> {
-  if (sequelizeClient) await sequelizeClient.close();
-  sequelizeClient = undefined;
-}
-
-export function addModels(models: Array<ModelCtor>): void {
-  if (!sequelizeClient)
-    throw new EngineError({
-      message: 'Sequelize client was not initialized'
-    });
-  sequelizeClient.addModels(models);
-  sequelizeClient.sync();
-}
-
-/** Create Sequelize client */
-export function createSequelizeClient(): Sequelize {
-  // Throw an error if there is no host initial
-  validateSequelizeEnvironment();
-  return new Sequelize(
-    process.env.SQL_DB as string,
-    process.env.SQL_USER as string,
-    process.env.SQL_PASSWORD as string,
-    dbConfig
-  );
-}

package/src/entities/Sequelize/Sequelize.types.ts

@@ -1,10 +0,0 @@
-import { Sequelize as SequelizeClass, ModelCtor } from 'sequelize-typescript';
-
-export type Sequelize = SequelizeClass & {
-  /** Start the sequelize service */
-  init: () => void;
-  /** Stop the sequelize service */
-  shutdown: () => Promise<void>;
-  /** Register a model with sequelize */
-  addModels: (models: Array<ModelCtor>) => void;
-};

package/src/entities/Sequelize/Sequelize.validate.ts

@@ -1,15 +0,0 @@
-import { assertEnvironment } from 'utils/checkEnvironment';
-import { envAssert } from 'utils/envAssert';
-
-/**
- * Verify that the environment variables to connect to a SQL server are properly set
- */
-export function validateSequelizeEnvironment(): void {
-  // We only check if there is at least the host specified
-  if (process.env.SQL_HOST) assertEnvironment({ SQL_HOST: envAssert.isHost() });
-  if (process.env.SQL_PASSWORD)
-    assertEnvironment({ SQL_PASSWORD: envAssert.isString() });
-  if (process.env.SQL_DB) assertEnvironment({ SQL_DB: envAssert.isString() });
-  if (process.env.SQL_USER)
-    assertEnvironment({ SQL_USER: envAssert.isString() });
-}

package/src/entities/Sequelize/index.ts

@@ -1,2 +0,0 @@
-export { sequelize } from './Sequelize';
-export * from './Sequelize.types';

package/src/entities/Server/Server.const.ts

@@ -1,56 +0,0 @@
-import { json, urlencoded, ErrorRequestHandler, RequestHandler } from 'express';
-import morgan from 'morgan';
-import {
-  metrics,
-  error,
-  fourOhFour,
-  healthCheck,
-  version,
-  swaggerDocs
-} from 'middleware';
-
-const ACCESS_LOG = JSON.stringify({
-  method: ':method',
-  status: ':status',
-  url: ':url',
-  'http-version': ':http-version',
-  ip: ':remote-addr',
-  'user-agent': ':user-agent',
-  'content-length': ':res[content-length]',
-  referrer: ':referrer',
-  'response-time': ':response-time',
-  severity: 'DEBUG',
-  message: ':method :url [:status]'
-});
-
-// Default middleware that are applied first thing on the primary port, before the business logic endpoints
-export const defaultMiddleware: Array<RequestHandler> = [
-  healthCheck(),
-  json({ limit: process.env.REQUEST_SIZE_LIMIT ?? '1mb' }),
-  urlencoded({
-    extended: true,
-    limit: process.env.REQUEST_SIZE_LIMIT ?? '1mb'
-  }),
-  metrics(),
-  version()
-].filter((val) => val);
-
-// Error handling middleware that are run after the main business logic endpoints
-export const defaultErrorMiddleware: Array<
-  RequestHandler | ErrorRequestHandler
-> = [error, fourOhFour];
-
-// Middleware that are served on the secondary port
-export const secondaryMiddleware: Array<RequestHandler> = [
-  metrics(),
-  version(),
-  swaggerDocs()
-];
-
-// Add morgan logging to default middleware chain when reporting is not silenced
-if (!process.env.SILENCE_REPORT) {
-  defaultMiddleware.unshift(morgan(ACCESS_LOG));
-  secondaryMiddleware.unshift(morgan(ACCESS_LOG));
-}
-
-export const shutdownSignals = ['SIGTERM', 'SIGUSR2', 'SIGINT'];

package/src/entities/Server/Server.test.ts

@@ -1,272 +0,0 @@
-import { randomUUID } from 'crypto';
-// eslint-disable-next-line import/no-unresolved
-import { setTimeout } from 'timers/promises';
-import { generateAccessToken } from 'backend-test-tools';
-import Ajv, { JSONSchemaType } from 'ajv';
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { Sequelize } from 'sequelize';
-import { fake, SinonStub, stub } from 'sinon';
-import supertest from 'supertest';
-import WS from 'ws';
-import { Server } from './Server';
-import { Endpoint, EndpointMethod, EndpointAuthType } from 'entities/Endpoint';
-import { SocketClient, SocketMessage } from 'entities/SocketClient';
-import { stubPubSub } from 'test';
-import { httpsAgent, loadTlsConfig } from 'utils';
-import * as jwt from 'utils/jwt/jwt';
-
-describe('Entity - Server', function () {
-  let token: string;
-  let initKeySetsStub: SinonStub;
-
-  before(() => {
-    if (!httpsAgent) loadTlsConfig();
-
-    const id = randomUUID();
-    token = generateAccessToken(id);
-  });
-
-  beforeEach(() => {
-    initKeySetsStub = stub(jwt, 'initKeySets').resolves();
-    stub(Sequelize.prototype, 'close');
-    stubPubSub();
-  });
-
-  afterEach(() => {
-  });
-
-  it('init and shutdown', async () => {
-    const server = new Server({ endpoints: [] });
-    await server.init();
-    await server.shutdown();
-  });
-
-  it('init with callbacks (async)', async () => {
-    const callbacks = [fake(), fake(), fake()];
-    const server = new Server({
-      endpoints: [],
-      initCallbacks: callbacks,
-      syncCallbacks: false
-    });
-
-    await server.init();
-    await server.shutdown();
-
-    callbacks.forEach((callback) =>
-      expect(callback).to.have.been.calledOnceWithExactly()
-    );
-  });
-
-  it('init with callbacks with parameters (async)', async () => {
-    const callbacks = [
-      {
-        function: fake(),
-        parameters: [faker.lorem.word(), faker.lorem.word(), faker.lorem.word()]
-      }
-    ];
-    const server = new Server({
-      endpoints: [],
-      initCallbacks: callbacks,
-      syncCallbacks: false
-    });
-
-    await server.init();
-    await server.shutdown();
-
-    callbacks.forEach((callback) =>
-      expect(callback.function).to.have.been.calledOnceWithExactly(
-        ...callback.parameters
-      )
-    );
-  });
-
-  it('init with callbacks (sync)', async () => {
-    const callbacks = [fake(), fake(), fake()];
-    const server = new Server({
-      endpoints: [],
-      initCallbacks: callbacks,
-      syncCallbacks: true
-    });
-
-    await server.init();
-    await server.shutdown();
-
-    callbacks.forEach((callback) =>
-      expect(callback).to.have.been.calledOnceWithExactly()
-    );
-  });
-
-  it('init with callbacks with parameters (sync)', async () => {
-    const callbacks = [
-      {
-        function: fake(),
-        parameters: [faker.lorem.word(), faker.lorem.word(), faker.lorem.word()]
-      }
-    ];
-    const server = new Server({
-      endpoints: [],
-      initCallbacks: callbacks,
-      syncCallbacks: true
-    });
-
-    await server.init();
-    await server.shutdown();
-
-    callbacks.forEach((callback) =>
-      expect(callback.function).to.have.been.calledOnceWithExactly(
-        ...callback.parameters
-      )
-    );
-  });
-
-  it('should handle Endpoints', async () => {
-    const sayHello = new Endpoint({
-      method: EndpointMethod.GET,
-      authType: EndpointAuthType.NONE,
-      path: '/hello/:name',
-      handler: (req, res): void => {
-        res.json({ content: 'hello ' + req.params.name });
-      },
-      validator: {
-        name: {
-          in: 'params',
-          isString: true
-        }
-      }
-    });
-
-    const sayGoodbye = new Endpoint({
-      method: EndpointMethod.POST,
-      authType: EndpointAuthType.NONE,
-      path: '/hello',
-      handler: (req, res): void => {
-        res.json({
-          content: `goodbye ${
-            (
-              req.body as {
-                /** */ name: string;
-              }
-            ).name
-          }`
-        });
-      },
-      validator: {
-        name: {
-          in: 'body',
-          isString: true
-        }
-      }
-    });
-
-    const server = new Server({ endpoints: [sayHello, sayGoodbye] });
-
-    await server.init();
-
-    await supertest(server.getApp())
-      .get('/hello/example')
-      .expect(200, { content: 'hello example' });
-
-    await supertest(server.getApp())
-      .post('/hello')
-      .send({ name: 'example' })
-      .expect(200, { content: 'goodbye example' });
-
-    await server.shutdown();
-  });
-
-  it('should handle the cronjob', async () => {
-    const handler = fake();
-    const interval = 0.01; // 10ms
-
-    const server = new Server({
-      endpoints: [],
-      cron: [{ handler, interval }]
-    });
-
-    await server.init();
-    await Promise.resolve();
-    expect(handler).to.have.been.calledOnce;
-
-    await setTimeout(5);
-    await Promise.resolve();
-    expect(handler).to.have.been.calledOnce;
-
-    await setTimeout(5);
-    await Promise.resolve();
-    expect(handler).to.have.been.calledTwice;
-
-    await server.shutdown();
-
-    await setTimeout(20);
-    await Promise.resolve();
-    expect(handler).to.have.been.calledTwice;
-  });
-
-  it('should init the KeySets', async () => {
-    process.env.NODE_ENV = 'development';
-    const server = new Server({ endpoints: [] });
-
-    await server.init();
-
-    expect(initKeySetsStub).to.have.been.called;
-
-    await server.shutdown();
-  });
-
-  it('should not init KeySet in test env', async () => {
-    const server = new Server({ endpoints: [] });
-
-    await server.init();
-
-    expect(initKeySetsStub).to.not.have.been.called;
-
-    await server.shutdown();
-  });
-
-  it('should not init the KeySets when specified', async () => {
-    process.env.NODE_ENV = 'development';
-    const server = new Server({ endpoints: [], auth: { noFetch: true } });
-
-    await server.init();
-
-    expect(initKeySetsStub).to.not.have.been.called;
-
-    await server.shutdown();
-  });
-
-  it('should serve metrics on the secondary IP', async () => {
-    const server = new Server({ endpoints: [] });
-
-    await server.init();
-
-    await supertest(server.getSecondaryApp())
-      .get('/metrics/instance')
-      .expect(200);
-    await supertest(server.getSecondaryApp())
-      .get('/metrics/service')
-      .expect(200);
-
-    await server.shutdown();
-  });
-
-  it('should serve versions on the secondary IP', async () => {
-    const server = new Server({ endpoints: [] });
-
-    await server.init();
-
-    await supertest(server.getSecondaryApp()).get('/version').expect(200);
-
-    await server.shutdown();
-  });
-
-  it('should return 404 on the secondary IP', async () => {
-    const server = new Server({ endpoints: [] });
-
-    await server.init();
-
-    await supertest(server.getSecondaryApp()).get('/random').expect(404);
-
-    await server.shutdown();
-  });
-});