node-server-engine 1.4.9 → 1.5.1

package/src/entities/PubSub/PubSub.ts

@@ -1,202 +0,0 @@
-import {
-  Attributes,
-  PubSub as PubsubClient,
-  Message
-} from '@google-cloud/pubsub';
-import { handleMessage } from './handleMessage';
-import {
-  PubSubTopicsMap,
-  PubSubSubscriptionsMap,
-  PubSubAddSubscriberOptions,
-  PubSubMessageHandler
-} from './PubSub.types';
-import { EngineError } from 'entities/EngineError';
-import { LifecycleController } from 'entities/LifecycleController';
-import { reportDebug, reportError } from 'utils';
-
-const namespace = 'engine:PubSub';
-
-/**
- * Associative containing all the subscriptions sorted by topic registered for publishing
- */
-const subscriptions: PubSubSubscriptionsMap = {};
-
-/**
- * Associative containing all the topics registered for publishing
- */
-const topics: PubSubTopicsMap = {};
-
-const pubSubClient = new PubsubClient();
-
-/**
- * This is a singleton service who's role is to manage pub/sub connections
- * It is the preferred way to interact with Pub/Sub as it manages the underlying subscription and handler objects
- * It avoids potential subscription splitting on an instance
- */
-export const PubSub = {
-  /**
-   * Initialize the registered publishers and subscribers
-   */
-  async init(): Promise<void> {
-    reportDebug({ namespace, message: `Initializing Pub/Sub` });
-    // Check that all topics/permissions exist, and that we have permission on them
-    await Promise.all([
-      // Test that all topics actually exist and that we have permissions
-      ...Object.values(topics).map(async (topic) => {
-        const [exists] = await topic.exists();
-        if (!exists)
-          throw new EngineError(`Topic ${topic.name} does not exist`);
-        // Test permission ton publish to topic
-        const [permissions] = await topic.iam.testPermissions([
-          'pubsub.topics.publish'
-        ]);
-        const hasPermissions = Object.values(permissions).every(
-          (success) => success
-        );
-        if (!hasPermissions)
-          throw new EngineError(
-            `Instance does not have appropriate permissions to publish to topic ${topic.name}`
-          );
-      }),
-      // Test that all subscriptions actually exist and that we have permissions
-      ...Object.values(subscriptions).map(async ({ subscription }) => {
-        const [exists] = await subscription.exists();
-        if (!exists)
-          throw new EngineError(
-            `Subscription ${subscription.name} does not exist`
-          );
-        // Test permission ton consume subscription
-        const [permissions] = await subscription.iam.testPermissions([
-          'pubsub.subscriptions.consume'
-        ]);
-        const hasPermissions = Object.values(permissions).every(
-          (success) => success
-        );
-        if (!hasPermissions)
-          throw new EngineError(
-            `Instance does not have appropriate permissions to subscribe to subscription ${subscription.name}`
-          );
-      })
-    ]);
-
-    // Register handlers on the subscriptions to activate them
-    for (const { subscription, handlers, isDebezium } of Object.values(
-      subscriptions
-    )) {
-      subscription.on('message', (message) => {
-        handleMessage(
-          message as Message,
-          subscription,
-          handlers,
-          isDebezium
-        ).catch((error) => {
-          reportError(error);
-        });
-      });
-    }
-
-    LifecycleController.register(PubSub);
-  },
-
-  /**
-   * Shutdown the registered publishers and subscribers
-   */
-  async shutdown(): Promise<void> {
-    reportDebug({ namespace, message: `Shutting down Pub/Sub` });
-    // Flush all pending messages and shut down connections
-    await Promise.all([
-      ...Object.values(topics).map(async (topic) => topic.flush()),
-      ...Object.values(subscriptions).map(async ({ subscription }) =>
-        subscription.close()
-      )
-    ]);
-    // Delete the stored topics/subscriptions
-    Object.keys(topics).forEach((topic) => delete topics[topic]);
-    Object.keys(subscriptions).forEach(
-      (subscription) => delete subscriptions[subscription]
-    );
-    // Close the client
-    await pubSubClient.close();
-  },
-
-  /**
-   * Creates a publisher if it does not exist yet
-   */
-  addPublisher(topic: string | Array<string>): void {
-    const topicArray = topic instanceof Array ? topic : [topic];
-    reportDebug({
-      namespace,
-      message: `Registering publisher for topics '${topicArray.join("', '")}'`
-    });
-    // Register a new topic if it does not exist yet
-    for (const topic of topicArray) {
-      if (!Object.keys(topics).includes(topic)) {
-        topics[topic] = pubSubClient.topic(topic, {
-          enableOpenTelemetryTracing: true
-        });
-      }
-    }
-  },
-
-  /**
-   * Add message handlers to a subscription
-   * @param subscription - Name of the Pub/Sub subscription
-   * @param handler - Function or list of functions to set as message handlers
-   * @param options - Indicates that the additional options need to handle on Subscriber
-   */
-  addSubscriber<T>(
-    subscription: string,
-    handler: PubSubMessageHandler<T> | Array<PubSubMessageHandler<T>>,
-    options: PubSubAddSubscriberOptions = {}
-  ): void {
-    const handlers = handler instanceof Array ? handler : [handler];
-    const isDebezium = options?.isDebezium ?? false;
-    const first = options?.first ?? false;
-
-    reportDebug({
-      namespace,
-      message: `Registering subscriber for subscription '${subscription}'`,
-      data: { first, handlersCount: handlers.length, isDebezium }
-    });
-    if (!Object.keys(subscriptions).includes(subscription)) {
-      subscriptions[subscription] = {
-        subscription: pubSubClient.subscription(subscription, {
-          enableOpenTelemetryTracing: true
-        }),
-        handlers: []
-      };
-    }
-
-    if (isDebezium) subscriptions[subscription].isDebezium = true;
-
-    if (first) subscriptions[subscription].handlers.push(...handlers);
-    else subscriptions[subscription].handlers.unshift(...handlers);
-  },
-
-  /**
-   * Send a message to a Pub/Sub topic
-   * @param topic - Name of the topic
-   * @param message - Content of the message, must be an object that can be JSON stringified
-   * @param attributes - Attributes for this message, can be used to filter messages on the subscription
-   * @param orderingKey - Enforce order guarantee of messages sent with the same key
-   */
-  async publish(
-    topic: string,
-    message: unknown,
-    attributes?: Attributes,
-    orderingKey?: string
-  ): Promise<void> {
-    if (!topics[topic])
-      throw new EngineError(`No publisher was registered for topic '${topic}'`);
-    reportDebug({
-      namespace,
-      message: `Sending message to topic '${topic}'`,
-      data: { message, attributes, orderingKey }
-    });
-    await topics[topic].publishMessage({
-      json: message,
-      attributes,
-      orderingKey
-    });
-  }
-};

package/src/entities/PubSub/PubSub.types.ts

@@ -1,76 +0,0 @@
-import { Topic, Subscription, Attributes } from '@google-cloud/pubsub';
-import { DebeziumEvent } from 'const/DebeziumEvent';
-
-/** List of all active topics */
-export interface PubSubTopicsMap {
-  [topic: string]: Topic;
-}
-
-/** List of subscriptions handled for each topic */
-export interface PubSubSubscriptionsMap {
-  [topic: string]: {
-    /** The Pub/Sub subscription object */
-    subscription: Subscription;
-    /** The message handling functions */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handlers: Array<PubSubMessageHandler<any>>;
-    /** Indicates that the subscription from Debezium events */
-    isDebezium?: boolean;
-  };
-}
-
-/** Options to setup a subscription  */
-export interface PubSubAddSubscriberOptions {
-  /** Should the handlers declared here be added to the top of the queue, and called first when an new message arrives */
-  first?: boolean;
-  /** Indicates that the topic is a Debezium CDC topic, additional processing is done on the message */
-  isDebezium?: boolean;
-}
-
-export type PubSubMessageHandler<T> = (
-  message: T,
-  attributes: Attributes,
-  publishedAt: Date
-) => void | Promise<void>;
-
-/** Debezium create event payload */
-interface PubSubDebeziumCreatePayload<T> {
-  /** The instance properties before the operation */
-  before: null;
-  /** The instance properties after the operation */
-  after: T;
-  /** The operation that was executed */
-  op: DebeziumEvent.Create;
-  /** List of fields that have changed */
-  diff: Array<string>;
-}
-
-/** Debezium update event payload */
-interface PubSubDebeziumUpdatePayload<T> {
-  /** The instance properties before the operation */
-  before: T;
-  /** The instance properties after the operation */
-  after: T;
-  /** The operation that was executed */
-  op: DebeziumEvent.Update;
-  /** List of fields that have changed */
-  diff: Array<string>;
-}
-
-/** Debezium delete event payload */
-interface PubSubDebeziumDeletePayload<T> {
-  /** The instance properties before the operation */
-  before: T;
-  /** The instance properties after the operation */
-  after: null;
-  /** The operation that was executed */
-  op: DebeziumEvent.Delete;
-  /** List of fields that have changed */
-  diff: Array<string>;
-}
-
-/** Payload of Debezium messages */
-export type PubSubDebeziumPayload<T> =
-  | PubSubDebeziumCreatePayload<T>
-  | PubSubDebeziumUpdatePayload<T>
-  | PubSubDebeziumDeletePayload<T>;

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

@@ -1,102 +0,0 @@
-import { PreciseDate } from '@google-cloud/precise-date';
-import {
-  Subscription,
-  PubSub,
-  Attributes,
-  Message
-} from '@google-cloud/pubsub';
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { fake, SinonSpy } from 'sinon';
-import { handleMessage } from './handleMessage';
-
-describe('Entities - Pub/Sub - Handle Message', () => {
-  let subscription: Subscription;
-  let payload: Record<string, unknown>;
-  let attributes: Attributes;
-  let ack: SinonSpy;
-  let message: Message;
-  let publishTime: PreciseDate;
-
-  beforeEach(() => {
-    subscription = new Subscription(new PubSub(), faker.lorem.slug());
-
-    payload = { [faker.lorem.word()]: faker.lorem.word() };
-
-    attributes = { [faker.lorem.word()]: faker.lorem.word() };
-    const data = Buffer.from(JSON.stringify(payload));
-
-    publishTime = new PreciseDate(faker.date.recent());
-
-    ack = fake();
-    message = {
-      id: faker.string.uuid(),
-      ack,
-      ackId: faker.string.uuid(),
-      data,
-      attributes,
-      publishTime,
-      deliveryAttempt: 0,
-      received: 0
-    } as unknown as Message;
-  });
-
-  it('should parse the message and forward it to all the handlers', async () => {
-    const handlers = [fake(), fake(), fake()];
-
-    await handleMessage(message, subscription, handlers);
-
-    for (const handler of handlers) {
-      expect(handler).to.have.been.calledOnceWithExactly(
-        payload,
-        attributes,
-        publishTime
-      );
-    }
-  });
-
-  it('should parse a debezium message [create]', async () => {
-    const handler = fake();
-    payload = { before: null, after: { a: 'a', b: 'b', c: 'c' } };
-    message.data = Buffer.from(JSON.stringify(payload), 'utf-8');
-
-    await handleMessage(message, subscription, [handler], true);
-
-    expect(handler).to.have.been.calledOnceWithExactly(
-      { ...payload, diff: ['a', 'b', 'c'] },
-      attributes,
-      publishTime
-    );
-  });
-
-  it('should parse a debezium message [destroy]', async () => {
-    const handler = fake();
-    payload = { before: { a: 'a', b: 'b', c: 'c' }, after: null };
-    message.data = Buffer.from(JSON.stringify(payload), 'utf-8');
-
-    await handleMessage(message, subscription, [handler], true);
-
-    expect(handler).to.have.been.calledOnceWithExactly(
-      { ...payload, diff: ['a', 'b', 'c'] },
-      attributes,
-      publishTime
-    );
-  });
-
-  it('should parse a debezium message [update]', async () => {
-    const handler = fake();
-    payload = {
-      before: { a: 'a', b: 'b', c: 'c' },
-      after: { a: 'a', b: 'y', c: 'c' }
-    };
-    message.data = Buffer.from(JSON.stringify(payload), 'utf-8');
-
-    await handleMessage(message, subscription, [handler], true);
-
-    expect(handler).to.have.been.calledOnceWithExactly(
-      { ...payload, diff: ['b'] },
-      attributes,
-      publishTime
-    );
-  });
-});

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