node-server-engine 1.1.1 → 1.1.3

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

@@ -1,130 +1,130 @@
-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;
-    });
-  });
-});
+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 +1,72 @@
-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);
-  }
-}
+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 +1,15 @@
-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>;
+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 +1,2 @@
-export * from './MessageHandler';
-export * from './MessageHandler.types';
+export * from './MessageHandler';
+export * from './MessageHandler.types';