node-server-engine 1.4.9 → 1.5.0

package/src/entities/PubSub/handleMessage/handleMessage.ts

@@ -1,65 +0,0 @@
-import { Subscription, Message } from '@google-cloud/pubsub';
-import { PubSubMessageHandler, PubSubDebeziumPayload } from '../PubSub.types';
-import { LogSeverity } from 'const';
-import { EngineError } from 'entities/EngineError';
-import { reportDebug, reportError } from 'utils';
-
-const namespace = 'engine:PubSub:handleMessage';
-
-/**
- * handle the pubSubClients on message event
- * @param message - Message to parse and handle
- * @param subscription - The related Pub/Sub subscription object
- * @param handlers - Message handlers
- * @param isDebezium - Indicates that the subscription from Debezium events
- */
-export async function handleMessage(
-  message: Message,
-  subscription: Subscription,
-  handlers: Array<PubSubMessageHandler<unknown>>,
-  isDebezium = false
-): Promise<void> {
-  reportDebug({
-    namespace,
-    message: `Received message from Pub/Sub [${subscription.name}]`
-  });
-
-  message.ack();
-
-  let payload;
-  try {
-    payload = JSON.parse(message.data.toString()) as unknown;
-
-    // When handling Debezium message, we calculate automatically the keys that have changed between the previous and current state
-    if (isDebezium) {
-      payload = payload as PubSubDebeziumPayload<Record<string, unknown>>;
-      const { before, after } = payload;
-      if (before && after)
-        payload.diff = Object.keys(after).filter(
-          (key) => after[key] !== before[key]
-        );
-      else if (before) payload.diff = Object.keys(before);
-      else if (after) payload.diff = Object.keys(after);
-      else
-        throw new EngineError({
-          severity: LogSeverity.WARNING,
-          message: `Debezium Pub/Sub message did not include before nor after value [${subscription.name}]`,
-          data: { subscription, message: message.data.toString() }
-        });
-    }
-  } catch {
-    throw new EngineError({
-      severity: LogSeverity.WARNING,
-      message: `Pub/Sub message is not valid JSON ${subscription.name}`,
-      data: { subscription, message: message.data.toString() }
-    });
-  }
-
-  for (const handler of handlers) {
-    try {
-      await handler(payload, message.attributes, message.publishTime);
-    } catch (error) {
-      reportError(error);
-    }
-  }
-}

package/src/entities/PubSub/handleMessage/index.ts

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

package/src/entities/PubSub/index.ts

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

package/src/entities/PushNotification/PushNotification.test.ts

@@ -1,35 +0,0 @@
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { stub, SinonStub } from 'sinon';
-import { PushNotification } from './PushNotification';
-import { PushNotificationNotification } from './PushNotification.types';
-import { PubSub } from 'entities/PubSub/PubSub';
-
-describe('Entities - PushNotification', function () {
-  let notification: PushNotificationNotification;
-  let publishStub: SinonStub;
-  let userId: string;
-
-  beforeEach(() => {
-    process.env.CHART = 'test';
-    process.env.PUBSUB_PUSH_NOTIFICATION_QUEUE_TOPIC = 'notification_queue';
-    userId = faker.string.uuid();
-    notification = {
-      title: faker.lorem.word(),
-      body: faker.lorem.word()
-    };
-
-    publishStub = stub(PubSub, 'publish');
-  });
-
-  it('should send push notification to the user', async () => {
-    await PushNotification.sendPush(userId, notification);
-    expect(publishStub).to.have.been.calledOnceWithExactly(
-      'notification_queue',
-      {
-        ...notification,
-        userId
-      }
-    );
-  });
-});

package/src/entities/PushNotification/PushNotification.ts

@@ -1,44 +0,0 @@
-import { PushNotificationNotification } from './PushNotification.types';
-import { EngineError } from 'entities';
-import { PubSub } from 'entities/PubSub';
-import { reportDebug } from 'utils';
-
-const namespace = 'engine:PushNotification';
-
-export const PushNotification = {
-  /** Initialize the push notification entity */
-  init(): void {
-    reportDebug({ namespace, message: 'Initializing PushNotification' });
-    if (!process.env.PUBSUB_PUSH_NOTIFICATION_QUEUE_TOPIC)
-      throw new EngineError({
-        message:
-          'Environment variable PUBSUB_PUSH_NOTIFICATION_QUEUE_TOPIC is not defined'
-      });
-    // Register publisher
-    PubSub.addPublisher(process.env.PUBSUB_PUSH_NOTIFICATION_QUEUE_TOPIC);
-  },
-
-  /**
-   * Send a push notification through the push service
-   * @param userId - ID of the user that should receive the notification
-   * @param notification - Notification that should be sent
-   */
-  async sendPush(
-    userId: string,
-    notification: PushNotificationNotification
-  ): Promise<void> {
-    reportDebug({
-      namespace,
-      message: `Received data to send notification to user with Id '${userId}'`,
-      data: { userId, notification }
-    });
-
-    await PubSub.publish(
-      process.env.PUBSUB_PUSH_NOTIFICATION_QUEUE_TOPIC as string,
-      {
-        ...notification,
-        userId
-      }
-    );
-  }
-};

package/src/entities/PushNotification/PushNotification.types.ts

@@ -1,25 +0,0 @@
-/** Notification to send to the user's device */
-export interface PushNotificationNotification {
-  /** Title of the notification */
-  title?: string;
-  /** Body of the notification */
-  body?: string;
-  /** Data payload of the notification */
-  payload?: unknown;
-  /** Indicates that the notification is a VOIP notification */
-  voip?: boolean;
-  /** Indicate that it is a background notification (data only, low priority) */
-  background?: boolean;
-  /** Push token can be specified here is we want to send to a given user */
-  token?: string;
-  /** Indicates that the data content can be mutated by the client (iOS) */
-  mutable?: boolean;
-  /** Indicates that the notification requires some client side processing to be displayed (iOS) */
-  contentAvailable?: boolean;
-  /** Time to live of the notification in seconds. After this the notification will not be distributed */
-  ttl?: number;
-  /** Indicate that it is a high priority notification */
-  priority?: boolean;
-  /** Notifications with the same string here will be collapsed in the system tray */
-  collapseId?: string;
-}

package/src/entities/PushNotification/index.ts

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

package/src/entities/Redis/Redis.ts

@@ -1,71 +0,0 @@
-import { Redis as RedisClient } from 'ioredis';
-import { RedisInterface, RedisCreateOptions } from './Redis.types';
-import { validateRedisEnvironment } from './Redis.validate';
-import { EngineError } from 'entities/EngineError';
-import { LifecycleController } from 'entities/LifecycleController';
-
-export let redisClient: undefined | RedisClient;
-
-/**
- * We use a proxy to extend the Redis behavior and allow initialization of the client only when needed while keeping the same interface
- */
-export const Redis = new Proxy<RedisInterface>(
-  // 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;
-      // Create the redis client if it does not exist
-      if (!redisClient)
-        throw new EngineError({ message: 'Redis client was not initialized' });
-      // Call the function on the redis client
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      return redisClient[property] as unknown;
-    }
-  }
-);
-
-/**
- * On init create client anc connect
- */
-export function init(): void {
-  // Ignore if already initialized
-  if (redisClient) return;
-  redisClient = createRedisClient();
-  LifecycleController.register(Redis);
-}
-
-/**
- * On shutdown close connection and clear client
- */
-export async function shutdown(): Promise<void> {
-  if (redisClient) await redisClient.quit();
-  redisClient = undefined;
-}
-
-/**
- * Create Redis client
- */
-export function createRedisClient(
-  options: RedisCreateOptions = {}
-): RedisClient {
-  // Check that environment variables are correctly set
-  validateRedisEnvironment(options);
-  // Throw an error if there is no host initial
-  if (!process.env.REDIS_HOST)
-    throw new EngineError({
-      message: 'Host required to initialize Redis connection'
-    });
-
-  return new RedisClient({
-    port: process.env.REDIS_PORT ? parseInt(process.env.REDIS_PORT) : undefined,
-    host: process.env.REDIS_HOST,
-    username: process.env.REDIS_USERNAME,
-    password: process.env.REDIS_PASSWORD,
-    db: 0
-  });
-}

package/src/entities/Redis/Redis.types.ts

@@ -1,19 +0,0 @@
-import { Redis as IoRedis, Cluster, RedisOptions } from 'ioredis';
-
-export type RedisInterface = IoRedis &
-  Cluster & {
-    /** Start the redis service */
-    init: () => void;
-    /** Stop the redis service */
-    shutdown: () => Promise<void>;
-  };
-
-/** Options to initialize a Redis client */
-export interface RedisCreateOptions {
-  /** Redis client settings */
-  redis?: RedisOptions;
-  /** Should the client perform readiness check when establishing the connection */
-  enableReadyCheck?: boolean;
-  /** Cluster mode read operation settings, can make reads on masters, slaves, or both */
-  scaleReads?: string;
-}

package/src/entities/Redis/Redis.validate.ts

@@ -1,17 +0,0 @@
-import { RedisCreateOptions } from './Redis.types';
-import { EngineError } from 'entities/EngineError';
-
-/**
- * Verify that the environment variables to connect to a Redis server are properly set
- */
-export function validateRedisEnvironment(options: RedisCreateOptions): void {
-  const host = process.env.REDIS_HOST ?? options.redis?.host;
-  if (typeof host !== 'string')
-    throw new EngineError({ message: 'No host specified for Redis instance' });
-
-  const port = process.env.REDIS_PORT
-    ? parseInt(process.env.REDIS_PORT)
-    : options.redis?.port;
-  if (typeof port !== 'number')
-    throw new EngineError({ message: 'No port specified for Redis instance' });
-}

package/src/entities/Redis/index.ts

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

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'];