node-server-engine 1.0.5

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

@@ -0,0 +1,65 @@
+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

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

package/src/entities/PubSub/index.ts

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

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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,25 @@
+/** 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

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

package/src/entities/Redis/Redis.ts

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,17 @@
+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

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

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

@@ -0,0 +1,29 @@
+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,
+  dialect: (process.env.SQL_TYPE ?? 'postgres') as Dialect,
+  logging: false,
+  define: {
+    freezeTableName: false,
+    charset: 'utf8mb4',
+    collate: 'utf8mb4_unicode_ci'
+  },
+  retry: {
+    max: 5
+  }
+};
+
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,75 @@
+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 MySQL 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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,15 @@
+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

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

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

@@ -0,0 +1,56 @@
+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'];