node-server-engine 1.4.9 → 1.5.1

package/src/entities/Localizator/guessNamingConvention/guessNamingConvention.ts

@@ -1,58 +0,0 @@
-import {
-  LocalizatorLocalizationData,
-  LocalizatorScripts,
-  LocalizatorNamingConventions
-} from '../Localizator.types';
-
-export const DEFAULT_NAMING_CONVENTION = {
-  regular: '{firstName} {lastName}',
-  formal: '{firstName}',
-  casual: '{firstName}'
-};
-
-/** Guess the naming convention to use for a given name and locale */
-export function guessNamingConvention(
-  scripts: LocalizatorScripts,
-  localeData: LocalizatorLocalizationData,
-  name: string,
-  locale: string
-): LocalizatorNamingConventions {
-  // When the locale has a specific script
-  // Check if the name matches that script, and use its naming convention
-  if (localeData[locale]?.script) {
-    const defaultScript = localeData[locale].script as string;
-    if (
-      testScriptMatch(scripts, defaultScript, name) &&
-      scripts[defaultScript].names
-    ) {
-      return scripts[defaultScript].names;
-    }
-  }
-
-  // Check if there is a match with any given script and use its naming convention
-  for (const script of Object.keys(scripts)) {
-    if (testScriptMatch(scripts, script, name) && scripts[script].names) {
-      return scripts[script].names;
-    }
-  }
-
-  // Use the current locale's fallback convention
-  if (localeData[locale]?.names?.fallback) {
-    return localeData[locale].names.fallback as LocalizatorNamingConventions;
-  }
-
-  // If everything fails, use the default convention
-  return DEFAULT_NAMING_CONVENTION;
-}
-
-/** Test if a given string is in a given script */
-function testScriptMatch(
-  scripts: LocalizatorScripts,
-  script: string,
-  string: string
-): boolean {
-  if (scripts[script]?.rangeRegex) {
-    return (scripts[script].rangeRegex as RegExp).test(string);
-  }
-  return false;
-}

package/src/entities/Localizator/guessNamingConvention/index.ts

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

package/src/entities/Localizator/index.ts

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

package/src/entities/MessageHandler/MessageHandler.test.ts

@@ -1,130 +0,0 @@
-import Ajv, { JSONSchemaType } from 'ajv';
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { fake, match } from 'sinon';
-import { MessageHandler } from './MessageHandler';
-import { SocketClient } from 'entities/SocketClient';
-
-const ajv = new Ajv();
-
-/** */
-interface TestPayload {
-  /** */
-  test?: string;
-}
-
-type TestSchema = JSONSchemaType<TestPayload>;
-
-const schema: TestSchema = {
-  type: 'object',
-  properties: {
-    test: { type: 'string', nullable: true }
-  }
-};
-
-const validator = ajv.compile(schema);
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-const client = { isAuthenticated: () => true } as SocketClient;
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-const unauthenticatedClient = { isAuthenticated: () => false } as SocketClient;
-
-describe('Entities - Message Handler', () => {
-  it('should call the handler', async () => {
-    const type = faker.lorem.word();
-    const handler = fake();
-    const entity = new MessageHandler(type, handler, validator);
-    const message = { type, payload: {} };
-
-    await entity.handle(message, client);
-
-    expect(handler).to.have.been.calledOnceWithExactly(
-      message.payload,
-      match(client)
-    );
-  });
-
-  it('should not call the handler if the type is different', async () => {
-    const handler = fake();
-    const entity = new MessageHandler(faker.lorem.word(), handler, validator);
-    const message = { type: faker.lorem.word(), payload: {} };
-
-    await entity.handle(message, client);
-
-    expect(handler).to.not.have.been.called;
-  });
-
-  it('should not call the handler if the client is not authenticated', async () => {
-    const type = faker.lorem.word();
-    const handler = fake();
-    const entity = new MessageHandler(type, handler, validator);
-    const message = { type, payload: {} };
-
-    await entity.handle(message, unauthenticatedClient);
-
-    expect(handler).to.not.have.been.called;
-  });
-
-  it('should call the handler if the client is not authenticated, but that it is not required', async () => {
-    const type = faker.lorem.word();
-    const handler = fake();
-    const entity = new MessageHandler(type, handler, validator, {
-      authenticated: false
-    });
-    const message = { type, payload: {} };
-
-    await entity.handle(message, unauthenticatedClient);
-
-    expect(handler).to.have.been.calledOnceWithExactly(
-      message.payload,
-      match(unauthenticatedClient)
-    );
-  });
-
-  describe('schema validation', () => {
-    /** */
-    interface TestPayload {
-      /** */
-      test: string;
-    }
-
-    type TestSchema = JSONSchemaType<TestPayload>;
-
-    const schema: TestSchema = {
-      type: 'object',
-      properties: {
-        test: { type: 'string' }
-      },
-      required: ['test']
-    };
-
-    const validator = ajv.compile(schema);
-
-    it('should call the handler if the payload passes validation', async () => {
-      const type = faker.lorem.word();
-      const handler = fake();
-      const entity = new MessageHandler(type, handler, validator);
-      const message = { type, payload: { test: faker.lorem.word() } };
-
-      await entity.handle(message, client);
-
-      expect(handler).to.have.been.calledOnceWithExactly(
-        message.payload,
-        match(client)
-      );
-    });
-
-    it('should throw an error if the payload does not pass validation', async () => {
-      const type = faker.lorem.word();
-      const handler = fake();
-      const entity = new MessageHandler(type, handler, validator);
-      const message = { type, payload: { test: faker.number.int() } };
-
-      const result = entity.handle(message, client);
-      await expect(result).to.be.rejected;
-    });
-  });
-});

package/src/entities/MessageHandler/MessageHandler.ts

@@ -1,72 +0,0 @@
-import { ValidateFunction } from 'ajv';
-import { EngineError } from '../EngineError';
-import {
-  MessageHandlerOptions,
-  MessageHandlerHandler
-} from './MessageHandler.types';
-import { SocketMessage, SocketClient } from 'entities/SocketClient';
-import { WebError } from 'entities/WebError';
-
-/**
- * Message handlers should be used to define how messages should be handled in web socket servers
- */
-export class MessageHandler {
-  /** The type of messages that are handled by the instance */
-  public readonly type: string;
-  /** Function that should handle the message */
-  private handler: MessageHandlerHandler;
-  /** Schema against which incoming messages should be validated */
-  private validator: ValidateFunction;
-  /** Indicates that this handler should only run when the client is authenticated */
-  private authenticated: boolean;
-
-  /** Create a new websocket message handler */
-  public constructor(
-    type: string,
-    handler: MessageHandlerHandler,
-    validator: ValidateFunction,
-    options: MessageHandlerOptions = {}
-  ) {
-    if (!type)
-      throw new EngineError({ message: 'MessageHandler has no type defined' });
-    this.type = type;
-    if (!handler)
-      throw new EngineError({
-        message: 'MessageHandler should have a handler function'
-      });
-    this.handler = handler;
-    this.validator = validator;
-    this.authenticated = options.authenticated ?? true;
-  }
-
-  /** Handle received messages, and propagate them to the handler if needed  */
-  public async handle(
-    message: SocketMessage,
-    client: SocketClient
-  ): Promise<void> {
-    const valid = this.validator(message.payload);
-    if (!valid) {
-      const hint = this.validator.errors?.reduce(
-        (hint, error) => ({
-          ...hint,
-          [error.instancePath]: error.message
-            ? `${error.keyword}: ${error.message}`
-            : error.keyword
-        }),
-        {}
-      );
-      throw new WebError({
-        statusCode: 400,
-        errorCode: 'invalid-message',
-        message: 'Message validation failed',
-        data: hint,
-        hint
-      });
-    }
-    // Do not handle if it not for this type of handler
-    if (this.type !== message.type) return;
-    // When handler requires authentication but that client is not authenticated, do not handle the message.
-    if (this.authenticated && !client.isAuthenticated()) return;
-    await this.handler(message.payload ?? {}, client);
-  }
-}

package/src/entities/MessageHandler/MessageHandler.types.ts

@@ -1,15 +0,0 @@
-import { ValidateFunction } from 'ajv';
-import { SocketClient } from 'entities/SocketClient';
-
-/** Initialization options for the message handler */
-export interface MessageHandlerOptions {
-  /** The handler will only be called for authenticated clients (default: true) */
-  authenticated?: boolean;
-  /** Schema to validate the message before passing it to the handler */
-  validator?: ValidateFunction;
-}
-
-export type MessageHandlerHandler = (
-  payload: unknown,
-  client: SocketClient
-) => unknown | Promise<unknown>;

package/src/entities/MessageHandler/index.ts

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

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

@@ -1,297 +0,0 @@
-import {
-  PubSub as PubsubClient,
-  IAM,
-  Topic,
-  Subscription
-} from '@google-cloud/pubsub';
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { stub, fake, match, SinonSpy, SinonStub } from 'sinon';
-import { PubSub } from './PubSub';
-import { EngineError } from 'entities/EngineError';
-
-describe('Entities - Pub/Sub', function () {
-  let topicExistsFake: SinonSpy;
-  let topicIamFake: SinonSpy;
-  let topicPublishFake: SinonSpy;
-  let topicFlushFake: SinonSpy;
-  let topicStub: SinonStub;
-  let subscriptionExistsFake: SinonSpy;
-  let subscriptionIamFake: SinonSpy;
-  let subscriptionOnFake: SinonSpy;
-  let subscriptionCloseFake: SinonSpy;
-  let subscriptionStub: SinonStub;
-
-  beforeEach(() => {
-    topicExistsFake = fake.resolves([true]);
-
-    topicIamFake = fake(async (permissions: Array<string>) =>
-      permissions.reduce(
-        (result, permission) => {
-          result[0][permission] = true;
-          return result;
-        },
-        [{} as Record<string, boolean>]
-      )
-    );
-    topicPublishFake = fake.resolves(undefined);
-    topicFlushFake = fake.resolves(undefined);
-    topicStub = stub(PubsubClient.prototype, 'topic').callsFake(
-      () =>
-        ({
-          exists: topicExistsFake,
-          iam: { testPermissions: topicIamFake } as unknown as IAM,
-          publishMessage: topicPublishFake,
-          flush: topicFlushFake
-        }) as unknown as Topic
-    );
-
-    subscriptionExistsFake = fake.resolves([true]);
-
-    subscriptionIamFake = fake(async (permissions: Array<string>) =>
-      permissions.reduce(
-        (result, permission) => {
-          result[0][permission] = true;
-          return result;
-        },
-        [{} as Record<string, boolean>]
-      )
-    );
-    subscriptionOnFake = fake();
-    subscriptionCloseFake = fake.resolves(undefined);
-    subscriptionStub = stub(PubsubClient.prototype, 'subscription').callsFake(
-      () =>
-        ({
-          exists: subscriptionExistsFake,
-          iam: { testPermissions: subscriptionIamFake } as unknown as IAM,
-          on: subscriptionOnFake,
-          close: subscriptionCloseFake
-        }) as unknown as Subscription
-    );
-  });
-
-  afterEach(async () => {
-    await PubSub.shutdown();
-  });
-
-  describe('addPublisher', () => {
-    it('should register a publisher only once', () => {
-      const topic = faker.lorem.slug();
-
-      PubSub.addPublisher(topic);
-      PubSub.addPublisher(topic);
-      PubSub.addPublisher(topic);
-
-      expect(topicStub).to.have.been.calledOnceWithExactly(topic, match.object);
-    });
-
-    it('should register multiple publishers', () => {
-      const [topic1, topic2, topic3] = [
-        faker.lorem.slug(),
-        faker.lorem.slug(),
-        faker.lorem.slug()
-      ];
-
-      PubSub.addPublisher(topic1);
-      PubSub.addPublisher([topic2, topic3]);
-
-      expect(topicStub).to.have.been.callCount(3);
-      expect(topicStub).to.have.been.calledWithExactly(topic1, match.object);
-      expect(topicStub).to.have.been.calledWithExactly(topic2, match.object);
-      expect(topicStub).to.have.been.calledWithExactly(topic3, match.object);
-    });
-  });
-
-  describe('addSubscriber', () => {
-    it('should register a subscription only once', () => {
-      const subscription = faker.lorem.slug();
-      const handler = fake();
-
-      PubSub.addSubscriber(subscription, handler);
-      PubSub.addSubscriber(subscription, handler);
-      PubSub.addSubscriber(subscription, handler);
-
-      expect(subscriptionStub).to.have.been.calledOnceWithExactly(
-        subscription,
-        match.object
-      );
-    });
-
-    it('should register a subscription and making them run first when a new message arrives', () => {
-      const subscription = faker.lorem.slug();
-      const handler = fake();
-
-      PubSub.addSubscriber(subscription, handler, { first: true });
-      expect(subscriptionStub).to.have.been.calledOnceWithExactly(
-        subscription,
-        match.object
-      );
-    });
-
-    it('should register a subscription with debezium events', () => {
-      const subscription = faker.lorem.slug();
-      const handler = fake();
-
-      PubSub.addSubscriber(subscription, handler, { isDebezium: true });
-      expect(subscriptionStub).to.have.been.calledOnceWithExactly(
-        subscription,
-        match.object
-      );
-    });
-
-    it('should register multiple subscriptions', () => {
-      const handler = fake();
-      const [subscription1, subscription2, subscription3] = [
-        faker.lorem.slug(),
-        faker.lorem.slug(),
-        faker.lorem.slug()
-      ];
-
-      PubSub.addSubscriber(subscription1, handler);
-      PubSub.addSubscriber(subscription2, handler);
-      PubSub.addSubscriber(subscription3, handler);
-
-      expect(subscriptionStub).to.have.been.callCount(3);
-      expect(subscriptionStub).to.have.been.calledWithExactly(
-        subscription1,
-        match.object
-      );
-      expect(subscriptionStub).to.have.been.calledWithExactly(
-        subscription2,
-        match.object
-      );
-      expect(subscriptionStub).to.have.been.calledWithExactly(
-        subscription3,
-        match.object
-      );
-    });
-  });
-
-  describe('init', () => {
-    it('should throw an error if a topic does not exist', async () => {
-      topicExistsFake = fake.resolves([false]);
-
-      PubSub.addPublisher(faker.lorem.slug());
-
-      await expect(PubSub.init()).to.be.rejectedWith(EngineError);
-    });
-
-    it('should throw an error if an instance has no permission on the topic', async () => {
-      topicIamFake = fake(async (permissions: Array<string>) =>
-        permissions.reduce(
-          (result, permission) => {
-            result[0][permission] = false;
-            return result;
-          },
-          [{} as Record<string, boolean>]
-        )
-      );
-
-      PubSub.addPublisher(faker.lorem.slug());
-
-      await expect(PubSub.init()).to.be.rejectedWith(EngineError);
-    });
-
-    it('should throw an error if a subscription does not exist', async () => {
-      const handler = fake();
-      subscriptionExistsFake = fake.resolves([false]);
-
-      PubSub.addSubscriber(faker.lorem.slug(), handler);
-
-      await expect(PubSub.init()).to.be.rejectedWith(EngineError);
-    });
-
-    it('should throw an error if an instance has no permission on the subscription', async () => {
-      const handler = fake();
-
-      subscriptionIamFake = fake(async (permissions: Array<string>) =>
-        permissions.reduce(
-          (result, permission) => {
-            result[0][permission] = false;
-            return result;
-          },
-          [{} as Record<string, boolean>]
-        )
-      );
-
-      PubSub.addSubscriber(faker.lorem.slug(), handler);
-
-      await expect(PubSub.init()).to.be.rejectedWith(EngineError);
-    });
-
-    it('should successfully init', async () => {
-      const topic = faker.lorem.slug();
-      const subscription = faker.lorem.slug();
-      const subscriptionHandler = fake();
-
-      PubSub.addPublisher(topic);
-      PubSub.addSubscriber(subscription, subscriptionHandler);
-
-      await PubSub.init();
-
-      expect(topicExistsFake).to.have.been.calledOnceWithExactly();
-      expect(topicIamFake).to.have.been.calledOnceWithExactly([
-        'pubsub.topics.publish'
-      ]);
-      expect(subscriptionExistsFake).to.have.been.calledOnceWithExactly();
-      expect(subscriptionIamFake).to.have.been.calledOnceWithExactly([
-        'pubsub.subscriptions.consume'
-      ]);
-      expect(subscriptionOnFake).to.have.been.calledOnceWithExactly(
-        'message',
-        match.func
-      );
-    });
-  });
-
-  describe('shutdown', () => {
-    it('should flush all publishers', async () => {
-      PubSub.addPublisher([
-        faker.lorem.slug(),
-        faker.lorem.slug(),
-        faker.lorem.slug()
-      ]);
-
-      await PubSub.shutdown();
-
-      expect(topicFlushFake).to.have.callCount(3);
-    });
-
-    it('should close all subscriptions', async () => {
-      const handler = fake();
-      PubSub.addSubscriber(faker.lorem.slug(), handler);
-      PubSub.addSubscriber(faker.lorem.slug(), handler);
-      PubSub.addSubscriber(faker.lorem.slug(), handler);
-
-      await PubSub.shutdown();
-
-      expect(subscriptionCloseFake).to.have.callCount(3);
-    });
-  });
-
-  describe('publish', () => {
-    it('should throw an error if the topi was not previously declared', async () => {
-      const message = { [faker.lorem.word()]: faker.lorem.word() };
-      const attributes = { [faker.lorem.word()]: faker.lorem.word() };
-
-      await expect(
-        PubSub.publish(faker.lorem.slug(), message, attributes)
-      ).to.be.rejectedWith(EngineError);
-    });
-
-    it('should publish a message', async () => {
-      const topic = faker.lorem.slug();
-      const message = { [faker.lorem.word()]: faker.lorem.word() };
-      const attributes = { [faker.lorem.word()]: faker.lorem.word() };
-
-      PubSub.addPublisher(topic);
-      await PubSub.publish(topic, message, attributes);
-
-      expect(topicPublishFake).to.have.been.calledOnceWithExactly({
-        json: message,
-        attributes,
-        orderingKey: undefined
-      });
-    });
-  });
-});