node-server-engine 1.4.9 → 1.5.1

package/src/entities/Endpoint/Endpoint.ts

@@ -1,221 +0,0 @@
-import {
-  RequestHandler,
-  ErrorRequestHandler,
-  Application,
-  Request,
-  Response,
-  NextFunction
-} from 'express';
-import { Schema } from 'express-validator';
-import { EngineError } from '../EngineError';
-import {
-  EndpointOptions,
-  EndpointAuthType,
-  EndpointAuthTypes,
-  EndpointMethod,
-  EndpointMethods,
-  EndpointAuthParams,
-  Middleware,
-  MiddlewareChainElement,
-  SafeMiddleWareChain,
-  EndpointAuthHandlers,
-  EndpointAuthHandler,
-  EndpointRequestType,
-  EndpointHandler
-} from './Endpoint.types';
-import { LogSeverity } from 'const';
-import {
-  validate,
-  fileUploader,
-  requestMetrics,
-  multiPartFileUploader
-} from 'middleware';
-import { FileUploaderConfig } from 'middleware/fileUploader';
-import { MultiPartFileUploaderConfig } from 'middleware/multiPartFileUploader';
-import { reportDebug, reportError, reportInfo } from 'utils/report';
-
-const namespace = 'engine:Endpoint';
-
-/**
- * Object representing a REST endpoint served by server
- */
-export class Endpoint<T extends EndpointAuthType> {
-  /** Path at which the endpoint is reachable */
-  public readonly path: string;
-  /** HTTP method of the endpoint */
-  public readonly method: EndpointMethod;
-  /** Authentication system required by this endpoint */
-  public readonly authType: T;
-  /** Function handling the endpoint's business logic */
-  private handler: EndpointHandler<T>;
-  /** Validation schema that the request must pass before reaching the handler */
-  private validator: Schema;
-  /** Authentication related options for this endpoint */
-  private authParams?: EndpointAuthParams<T>;
-  /** Settings to upload files through this endpoint (this will automatically switch the expected request to be a multipart) */
-  private files?: Array<FileUploaderConfig>;
-  /** Settings to upload file parts (Chunks) through this endpoint (this will automatically switch the expected request to be a multipart) */
-  private multiPartFile?: MultiPartFileUploaderConfig;
-  /** Express request handlers that should run on this endpoint before the business logic, they will run after the global middleware */
-  private middleware?: Array<Middleware<T>>;
-  /** Express error handlers that should be registered for this endpoint. they will run before the global error handler */
-  private errorMiddleware?: Array<ErrorRequestHandler>;
-
-  /** Create a REST endpoint */
-  public constructor(config: EndpointOptions<T>) {
-    reportDebug({
-      namespace,
-      message: `Creating Endpoint [${config.method} - ${config.path}]`,
-      data: {
-        method: config.method,
-        path: config.path,
-        authType: config.authType,
-        authParams: config.authParams,
-        file: config.file,
-        files: config.files,
-        multiPartFile: config.multiPartFile
-      }
-    });
-
-    if (typeof config.path !== 'string')
-      throw new EngineError({
-        message: 'Endpoint path was not declared as a string'
-      });
-    this.path = config.path;
-
-    if (!EndpointMethods.includes(config.method))
-      throw new EngineError({
-        message: 'Endpoint method is not a valid HTTP method'
-      });
-    this.method = config.method;
-
-    if (typeof config.handler !== 'function')
-      throw new EngineError({ message: 'Endpoint handler is not a function' });
-    this.handler = config.handler;
-
-    if (!EndpointAuthTypes.includes(config.authType))
-      throw new EngineError({ message: 'Endpoint auth type is not valid' });
-    this.authType = config.authType;
-
-    this.validator = config.validator;
-    this.authParams = config.authParams;
-    this.files = config.file ? [config.file] : config.files;
-
-    // Middleware can both be function or arrays
-    if (typeof config.middleware === 'function')
-      this.middleware = [config.middleware];
-    if (config.middleware instanceof Array) this.middleware = config.middleware;
-    if (typeof config.errorMiddleware === 'function')
-      this.errorMiddleware = [config.errorMiddleware];
-    if (config.errorMiddleware instanceof Array)
-      this.errorMiddleware = config.errorMiddleware;
-  }
-
-  /**
-   * Register the endpoint to a react app
-   */
-  public register(app: Application): void {
-    // First initialize the handling calculation
-    const middlewareChain: Array<MiddlewareChainElement<T>> = [requestMetrics];
-    // Register auth middleware
-    middlewareChain.push(...this.getAuthMiddleware(this.authType));
-    if (this.files) {
-      // Register file upload
-      // Validation is included in the file upload process as this uses multipart/form-data
-      middlewareChain.push(fileUploader(this.files, this.validator));
-    }
-
-    if (this.multiPartFile) {
-      middlewareChain.push(
-        multiPartFileUploader(this.multiPartFile, this.validator)
-      );
-    }
-
-    if (!this.files && !this.multiPartFile) {
-      // Register validator for regular cases
-      middlewareChain.push(validate(this.validator));
-    }
-
-    // Register additional middleware
-    if (this.middleware) {
-      middlewareChain.push(...this.middleware);
-    }
-    // Register handler
-    middlewareChain.push(this.handler);
-    // Wrap middleware to await any async execution and catch any errors thrown
-    const safeMiddlewareChain: SafeMiddleWareChain =
-      this.catchExceptionForExpress(middlewareChain);
-    // Register error middleware
-    if (this.errorMiddleware) {
-      safeMiddlewareChain.push(...this.errorMiddleware);
-    }
-    app[this.method](
-      this.path,
-      ...(safeMiddlewareChain.flat() as Array<
-        RequestHandler | ErrorRequestHandler
-      >)
-    );
-  }
-
-  /**
-   * Catch exceptions thrown inside of middleware and pass them properly to express
-   */
-  private catchExceptionForExpress(
-    middlewareChain: Array<MiddlewareChainElement<T>>
-  ): SafeMiddleWareChain {
-    return middlewareChain.map((middleware) => {
-      if (middleware instanceof Array) {
-        return this.catchExceptionForExpress(middleware);
-      }
-      if (typeof middleware === 'function') {
-        return (req: Request, res: Response, next: NextFunction) => {
-          (async (): Promise<void> => {
-            try {
-              await middleware(req as EndpointRequestType[T], res, next);
-            } catch (err) {
-              next(err);
-            }
-          })().catch((error) => {
-            reportError(error);
-          });
-        };
-      }
-      throw new EngineError({
-        message: 'Middleware is not a function nor an array',
-        data: { type: typeof middleware }
-      });
-    });
-  }
-
-  /**
-   * Get the authentication middleware for a given type of authentication
-   */
-  private getAuthMiddleware(authType: EndpointAuthType): Array<RequestHandler> {
-    const middlewareChain: Array<RequestHandler> = [];
-
-    const handler = EndpointAuthHandlers[authType] as EndpointAuthHandler<T>;
-    if (!handler) {
-      reportInfo({
-        severity: LogSeverity.WARNING,
-        message: `Endpoint "${this.method} - ${this.path}" was declared with no authentication method`
-      });
-      return [];
-    }
-
-    const middleware = handler(this.authParams);
-
-    middlewareChain.push(
-      async (request: Request, response: Response, next: NextFunction) => {
-        try {
-          await middleware(request, response, next);
-        } catch (error) {
-          if (!this.authParams?.acceptInvalid) throw error;
-          reportError(error);
-          next();
-        }
-      }
-    );
-
-    return middlewareChain;
-  }
-}

package/src/entities/Endpoint/Endpoint.types.ts

@@ -1,181 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-  ErrorRequestHandler,
-  Request,
-  Response,
-  NextFunction,
-  RequestHandler
-} from 'express';
-import { ParamsDictionary } from 'express-serve-static-core';
-import { Schema } from 'express-validator';
-import { ParsedQs } from 'qs';
-
-import {
-  authJwt,
-  authHmac,
-  authTls,
-  authStatic,
-  FileUploaderConfig
-} from 'middleware';
-import { MultiPartFileUploaderConfig } from 'middleware/multiPartFileUploader/multiPartFileUploader.types';
-
-export enum EndpointMethod {
-  GET = 'get',
-  POST = 'post',
-  PUT = 'put',
-  PATCH = 'patch',
-  DELETE = 'delete',
-  HEAD = 'head',
-  ALL = 'all'
-}
-
-export const EndpointMethods = Object.values(EndpointMethod);
-
-export enum EndpointAuthType {
-  NONE = 'none',
-  JWT = 'jwt',
-  TLS = 'tls',
-  HMAC = 'hmac',
-  STATIC = 'static'
-}
-
-export const EndpointAuthTypes = Object.values(EndpointAuthType);
-
-export type Middleware<T extends EndpointAuthType> = (
-  request: EndpointRequestType[T],
-  response: Response,
-  next: NextFunction
-) => unknown | Promise<unknown>;
-
-export type MiddlewareChainElement<T extends EndpointAuthType> =
-  | Array<Middleware<T>>
-  | Middleware<T>
-  | any;
-
-/** Auth related parameters used with HMAC authentication  */
-interface EndpointAuthHmacParams {
-  /** [HMAC] Secret used for signature */
-  secret?: string;
-  /** [HMAC] For Github webhook, the standard differs slightly, so this option must be selected */
-  isGithub?: boolean;
-}
-
-/** Auth related parameters used with mTLS authentication  */
-interface EndpointAuthTlsParams {
-  /** [TLS] List oh hosts that are allowed to use the endpoint, this is compared to the claims in the certificate */
-  whitelist?: Array<string>;
-}
-
-/** Mapping used to get auth specific parameters depending on the auth type used  */
-interface EndpointAuthSpecificParams {
-  /** Auth parameters for no authentication */
-  [EndpointAuthType.NONE]: any;
-  /** Auth parameters for JWT authentication */
-  [EndpointAuthType.JWT]: any;
-  /** Auth parameters for mTLS authentication */
-  [EndpointAuthType.TLS]: EndpointAuthTlsParams;
-  /** Auth parameters for HMAC authentication */
-  [EndpointAuthType.HMAC]: EndpointAuthHmacParams;
-  /** Auth parameters for static authentication */
-  [EndpointAuthType.STATIC]: any;
-}
-
-export type EndpointAuthParams<T extends EndpointAuthType> =
-  EndpointAuthSpecificParams[T] & {
-    /** This will allow the business logic to run event if the authentication fails */
-    acceptInvalid?: boolean;
-  };
-
-export type EndpointAuthHandler<T extends EndpointAuthType> = (
-  options?: EndpointAuthParams<T>
-) => (
-  request: Request,
-  response: Response,
-  next: NextFunction
-) => void | Promise<void>;
-
-export const EndpointAuthHandlers = {
-  /** Auth handler for no authentication */
-  [EndpointAuthType.NONE]: undefined,
-  /** Auth handler for JWT authentication */
-  [EndpointAuthType.JWT]: authJwt,
-  /** Auth handler for mTLS authentication */
-  [EndpointAuthType.TLS]: authTls,
-  /** Auth handler for HMAC authentication */
-  [EndpointAuthType.HMAC]: authHmac,
-  /** Auth handler for static authentication */
-  [EndpointAuthType.STATIC]: authStatic
-};
-
-export type EndpointHandler<T extends EndpointAuthType> = (
-  request: EndpointRequestType[T],
-  response: Response
-) => void | Promise<void>;
-
-/** Endpoint initialization options */
-export interface EndpointOptions<T extends EndpointAuthType> {
-  /** Path at which the endpoint is reachable */
-  path: string;
-  /** HTTP method of the endpoint */
-  method: EndpointMethod;
-  /** Function handling the endpoint's business logic */
-  handler: EndpointHandler<T>;
-  /** Validation schema that the request must pass before reaching the handler */
-  validator: Schema;
-  /** Authentication system required by this endpoint */
-  authType: T;
-  /** Authentication related options for this endpoint */
-  authParams?: EndpointAuthParams<T>;
-  /** @deprecated Setting to upload a file through this endpoint */
-  file?: FileUploaderConfig;
-  /** Settings to upload files through this endpoint (this will automatically switch the expected request to be a multipart) */
-  files?: Array<FileUploaderConfig>;
-  /** Settings to upload file parts (Chunks) through this endpoint (this will automatically switch the expected request to be a multipart) */
-  multiPartFile?: MultiPartFileUploaderConfig;
-  /** Express request handlers that should run on this endpoint before the business logic, they will run after the global middleware */
-  middleware?: MiddlewareChainElement<T>;
-  /** Express error handlers that should be registered for this endpoint. they will run before the global error handler */
-  errorMiddleware?: ErrorRequestHandler | Array<ErrorRequestHandler>;
-}
-
-/** Request type when using JWT authentication */
-export interface JwtRequest<
-  P = ParamsDictionary,
-  ResBody = any,
-  ReqBody = any,
-  ReqQuery = ParsedQs,
-  Locals extends Record<string, any> = Record<string, any>
-> extends Request<P, ResBody, ReqBody, ReqQuery, Locals> {
-  /** User that identified using a JWT */
-  user: Record<string, any> | any;
-}
-
-/** Request type when using mTLS authentication */
-export interface TlsRequest<
-  P = ParamsDictionary,
-  ResBody = any,
-  ReqBody = any,
-  ReqQuery = ParsedQs,
-  Locals extends Record<string, any> = Record<string, any>
-> extends Request<P, ResBody, ReqBody, ReqQuery, Locals> {
-  /** Host names provided by the mTLS authenticated client */
-  hosts: Array<string>;
-}
-
-/** Mapping of request types in endpoints based on auth type used */
-export interface EndpointRequestType {
-  /** Request type for no authentication */
-  [EndpointAuthType.NONE]: Request;
-  /** Request type when using JWT authentication */
-  [EndpointAuthType.JWT]: JwtRequest;
-  /** Request type when using mTLS authentication */
-  [EndpointAuthType.TLS]: TlsRequest;
-  /** Request type when using HMAC authentication */
-  [EndpointAuthType.HMAC]: Request;
-  /** Auth handler for static authentication */
-  [EndpointAuthType.STATIC]: Request;
-}
-
-export type SafeMiddleWareChain = Array<
-  RequestHandler | ErrorRequestHandler | SafeMiddleWareChain
->;

package/src/entities/Endpoint/index.ts

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

package/src/entities/EngineError/EngineError.ts

@@ -1,28 +0,0 @@
-import { EngineErrorOptions } from './EngineError.types';
-import { LogSeverity } from 'const';
-
-/**
- * Base error type for engine related errors
- */
-export class EngineError extends Error {
-  /** Severity of the log entry */
-  public severity: LogSeverity;
-  /** If this error is wrapping another one, this will contain the original error */
-  public error?: Error;
-  /** Additional contextual data for debugging */
-  public data?: unknown;
-  /** Human readable error message sent to the client */
-  public hint?: unknown;
-
-  /** Create an EngineError, these errors represent errors in the engine itself */
-  public constructor(config: EngineErrorOptions | string) {
-    const options: EngineErrorOptions =
-      typeof config === 'string' ? { message: config } : config;
-    super(options.message);
-
-    this.severity = options.severity ?? LogSeverity.CRITICAL;
-    this.data = options.data;
-    this.error = options.error;
-    this.hint = options.hint;
-  }
-}

package/src/entities/EngineError/EngineError.types.ts

@@ -1,15 +0,0 @@
-import { LogSeverity } from 'const';
-
-/** EngineError initialization options */
-export interface EngineErrorOptions {
-  /** Main logged message */
-  message: string;
-  /** Severity of the log entry */
-  severity?: LogSeverity;
-  /** If this error is wrapping another one, this will contain the original error */
-  error?: Error;
-  /** Additional contextual data for debugging */
-  data?: unknown;
-  /** Human readable error message sent to the client */
-  hint?: unknown;
-}

package/src/entities/EngineError/index.ts

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

package/src/entities/KeySet/KeySet.test.ts

@@ -1,126 +0,0 @@
-import { randomUUID, createPublicKey } from 'crypto';
-import { readFileSync } from 'fs';
-import { readFile } from 'fs/promises';
-import { AxiosResponse } from 'axios';
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { stub, SinonStub } from 'sinon';
-import { KeySet } from './KeySet';
-import { JWKS } from './KeySet.types';
-import * as request from 'utils/request/request';
-import * as tlsRequest from 'utils/tlsRequest/tlsRequest';
-
-// We test with both an RSA key and an EC key
-const TEST_JWKS = {
-  data: {
-    keys: [
-      {
-        alg: 'RS256',
-        kty: 'RSA',
-        use: 'sig',
-        n:
-          'u18mjw63ELk8xA4C2Qbi1WTtqcx853iRv9Gfd-zKKmlU2wStnOGnIfnHkrNbl5y8vTMNBKNuqLh3Y_el' +
-          'PVSUIWGcy3KByw7VRnBTAze2bsmI0Dvz-89Ar1C2g0Ui6DOYyEa0iiXer4gSQgJ5ddsbIAMJMBT5j96G' +
-          '1mhbjM2mqekORRyjCZHGeNbofnTvKcJRTStsBPXQ2WEkAf6J1eNZ2-QnNYMVVO44-KXfhQsfaqRoporj' +
-          '4LvTkNX0kkxyfC3V1R8Qrk-_pHhzPtKtQxiRj2axTVXFoj5I1Po7WgQz2_vBZnWZ-0AIzHXN6F_fmMhy' +
-          'PBPk3pbuN7cHBe2cKh_nHQ',
-        e: 'AQAB',
-        kid: 'Q0ZCQzEwRTFCOUE3QjI0MUZEREQ0N0I4MTI3OTVFRDkyNTIxQjQ3MA'
-      },
-      {
-        crv: 'P-256',
-        kty: 'EC',
-        x: 'ruky13qVa2GM9jnWsBYP_OTsk6fyV_HWC2AjvUkyCv8',
-        y: 'kIAW58dw6pjO1dy4czpNdsaL8DUc3RKo6Hmses5O_Bc',
-        kid: '3d-GYUhTwkAfCi9JdvMieQ',
-        alg: 'EC256',
-        use: 'sig'
-      }
-    ]
-  }
-};
-
-const TEST_PEMS = TEST_JWKS.data.keys.map((key) =>
-  createPublicKey({ key, format: 'jwk' }).export({
-    format: 'pem',
-    type: 'spki'
-  })
-);
-
-describe('Entity - KeySet', function () {
-  let url: string;
-  let requestStub: SinonStub;
-  let tlsRequestStub: SinonStub;
-
-  beforeEach(() => {
-    url = faker.internet.url();
-
-    requestStub = stub(request, 'request').resolves(
-      TEST_JWKS as unknown as AxiosResponse<JWKS>
-    );
-    tlsRequestStub = stub(tlsRequest, 'tlsRequest').resolves(
-      TEST_JWKS as unknown as AxiosResponse<JWKS>
-    );
-  });
-
-  it('should create a key set when fetching', async () => {
-    const keySet = new KeySet(url);
-    await keySet.init();
-
-    const keys = keySet.getKeys();
-    expect(Object.values(keys)).to.have.length(2);
-    Object.values(keys).forEach((key) => {
-      expect(TEST_PEMS).to.include(key);
-    });
-  });
-
-  it('should make a regular request by default', async () => {
-    const keySet = new KeySet(url);
-
-    await keySet.init();
-
-    expect(requestStub).to.have.been.calledOnceWithExactly({
-      url,
-      method: 'get'
-    });
-    expect(tlsRequestStub).to.not.have.been.called;
-  });
-
-  it('should make a TLS request for internal keysets', async () => {
-    const keySet = new KeySet(url, { internal: true });
-
-    await keySet.init();
-
-    expect(tlsRequestStub).to.have.been.calledOnceWithExactly({
-      url,
-      method: 'get'
-    });
-    expect(requestStub).to.not.have.been.called;
-  });
-
-  it('should read a key from a PEM string', async () => {
-    const pem = await readFile(
-      process.env.ECDSA_PUBLIC_KEY as string,
-      'utf-8'
-    );
-
-    const keySet = new KeySet(pem, { pem: true });
-
-    await keySet.init();
-
-    expect(tlsRequestStub).to.not.have.been.called;
-    expect(requestStub).to.not.have.been.called;
-    expect(Object.keys(keySet.getKeys())).to.have.length(1);
-    for (const key of Object.values(keySet.getKeys())) {
-      expect(key).to.equal(pem);
-    }
-  });
-
-  it('should not fail if the init did not complete and a key is asked', () => {
-    const keySet = new KeySet(faker.internet.url());
-
-    const result = keySet.getKey(randomUUID());
-
-    expect(result).to.be.undefined;
-  });
-});