node-server-engine 1.4.9 → 1.5.1

package/src/entities/Storage/Storage.ts

@@ -1,219 +0,0 @@
-import { randomUUID } from 'crypto';
-import { Readable } from 'stream';
-import {
-  Storage as CloudStorage,
-  CreateWriteStreamOptions,
-  File
-} from '@google-cloud/storage';
-import fileSizeParser from 'filesize-parser';
-import mimeTypes from 'mime-types';
-import {
-  UploadDestinationOptions,
-  StorageUploadedFile,
-  UploaderOptions,
-  StorageGetResponse,
-  StorageDownloadResponse
-} from './Storage.types';
-import { WebError } from 'entities/WebError';
-import { reportDebug } from 'utils/report';
-import { trimPathSlash } from 'utils/trimPathSlash';
-
-const namespace = 'engine:storage';
-
-export const Storage = {
-  cloudStorage: new CloudStorage({
-    projectId: process.env.GC_PROJECT,
-    keyFilename: process.env.GOOGLE_APPLICATION_CREDENTIALS
-  }),
-
-  /**
-   * Upload a file to the cloud storage
-   * @param readStream - Stream of the file content
-   * @param  bucket - Bucket in which the file should be stored
-   * @param  destinationOptions - Options for the destination generator [see: generateFileDestination(options)]
-   * @param  storageOptions - Storage library options
-   * @param  uploaderOptions - Options for this service's specific behavior
-   * @return {Promise<Object>} - Details regarding the uploaded file's metadata
-   */
-  async upload(
-    readStream: Readable,
-    bucket: string,
-    destinationOptions: UploadDestinationOptions = {},
-    storageOptions: CreateWriteStreamOptions = {},
-    uploaderOptions: UploaderOptions = {}
-  ): Promise<StorageUploadedFile> {
-    const { maxSize } = uploaderOptions;
-
-    let file: File;
-    reportDebug({
-      namespace,
-      message: 'Uploading file to storage',
-      data: { bucket, destinationOptions, storageOptions, uploaderOptions }
-    });
-
-    // Generate the file path
-    // We either use a given file name, or we generate a random file name
-    const { fileName, directory } = destinationOptions;
-
-    // Upload file with given file name
-    if (fileName) {
-      // Only keep required slashes in full path
-      const trimmedDirectory = trimPathSlash(directory ?? '/');
-      const path = `${trimmedDirectory}/${fileName}`;
-      file = this.cloudStorage.bucket(bucket).file(path);
-    }
-    // Generate random destination for file and check that it is not already occupied
-    else {
-      do {
-        const path = this.generateFileDestination(destinationOptions);
-        file = this.cloudStorage.bucket(bucket).file(path);
-      } while ((await file.exists())[0]);
-    }
-
-    // Pipe user's file stream to the storage
-    return new Promise((resolve, reject) => {
-      let receivedSize = 0;
-      const writeStream = file.createWriteStream(storageOptions);
-      const intMaxSize = maxSize && fileSizeParser(maxSize);
-      // Calculate transferred size and write to storage stream
-      readStream.on('data', function (data: Buffer) {
-        receivedSize += data.length;
-        // Fail if transferred data over max size
-        if (intMaxSize && receivedSize > intMaxSize) {
-          reject(
-            new WebError({
-              statusCode: 413,
-              errorCode: 'file-too-large',
-              message: 'Request contains a file that is over the maximum size',
-              hint: { maxSize },
-              data: {
-                bucket,
-                destinationOptions,
-                storageOptions,
-                receivedSize,
-                maxSize
-              }
-            })
-          );
-          return;
-        }
-        writeStream.write(data);
-      });
-      // Error handling
-      readStream.on('error', (err) => {
-        reject(err);
-      });
-      writeStream.on('error', (err) => {
-        reject(err);
-      });
-      // Graceful termination of the read
-      readStream.on('end', () => {
-        writeStream.end();
-      });
-      // Graceful termination of the write
-      writeStream.on('finish', () => {
-        (async (): Promise<void> => {
-          const [metadata] = (await file.getMetadata()) as [
-            StorageUploadedFile,
-            unknown
-          ];
-          reportDebug({
-            namespace,
-            message: 'File uploaded to storage',
-            data: metadata
-          });
-          resolve(metadata);
-        })().catch((error) => {
-          reject(error);
-        });
-      });
-    });
-  },
-
-  /**
-   * Return the read stream for a given file and bucket
-   */
-  async get(bucket: string, path: string): Promise<StorageGetResponse> {
-    const file = this.cloudStorage.bucket(bucket).file(path);
-    const [[metadata], [data]] = (await Promise.all([
-      file.getMetadata(),
-      file.download()
-    ])) as [[StorageUploadedFile, unknown], [Buffer]];
-    reportDebug({
-      namespace,
-      message: 'Downloaded file from storage',
-      data: { bucket, path, metadata }
-    });
-    return {
-      data,
-      metadata
-    };
-  },
-
-  /**
-   * Return the read stream for a given file and bucket
-   */
-  async download(
-    bucket: string,
-    path: string
-  ): Promise<StorageDownloadResponse> {
-    const file = this.cloudStorage.bucket(bucket).file(path);
-    const [metadata] = (await file.getMetadata()) as [
-      StorageUploadedFile,
-      unknown
-    ];
-    reportDebug({
-      namespace,
-      message: 'Fetched file stream from storage',
-      data: { bucket, path, metadata }
-    });
-    return {
-      stream: file.createReadStream(),
-      metadata
-    };
-  },
-
-  /**
-   * Return the read stream for a given file path and bucket
-   * @param {String} bucket
-   * @param {String} path
-   */
-  getFileStream(bucket: string, path: string): Readable {
-    const file = this.cloudStorage.bucket(bucket).file(path);
-    reportDebug({
-      namespace,
-      message: "Fetched file stream from storage's bucket",
-      data: { bucket, path }
-    });
-    return file.createReadStream();
-  },
-
-  /**
-   * Delete a file from the cloud storage
-   */
-  async delete(bucket: string, path: string): Promise<void> {
-    reportDebug({
-      namespace,
-      message: 'Deleting file from storage',
-      data: { bucket, path }
-    });
-    await this.cloudStorage.bucket(bucket).file(path).delete();
-  },
-
-  /**
-   * Builds the full file path on the cloud and generates it a random name
-   */
-  generateFileDestination(options: UploadDestinationOptions = {}): string {
-    const { directory = '/', mime, noExtension = false } = options;
-
-    // use provided mime type default otherwise
-    const extension =
-      mime && mimeTypes.extension(mime) ? mimeTypes.extension(mime) : undefined;
-    // Build the full name
-    const fullName =
-      extension && !noExtension ? `${randomUUID()}.${extension}` : randomUUID();
-    // Only keep required slashes in full path
-    const trimmedDirectory = trimPathSlash(directory);
-    return `${trimmedDirectory ? `${trimmedDirectory}/` : ''}${fullName}`;
-  }
-};

package/src/entities/Storage/Storage.types.ts

@@ -1,57 +0,0 @@
-import { Readable } from 'stream';
-
-/** Options to set where an uploaded file is stored in the bucket */
-export interface UploadDestinationOptions {
-  /** Directory of the bucket in which the file is stored. Defaults to the root directory */
-  directory?: string;
-  /** Name under which the file is stored. If specified, the file is stored with that name. Otherwise random name generation is done */
-  fileName?: string;
-  /** When using random file name generation (ie: fileName is undefined). We use the MIME type to determine which is the best extension to apply to the file */
-  mime?: string;
-  /** When using random file name generation (ie: fileName is undefined), use this parameter to skip adding an extension to the file */
-  noExtension?: boolean;
-}
-
-/** Options of the file uploader */
-export interface UploaderOptions {
-  /** Maximum size of the file (ex: 2MB) */
-  maxSize?: string;
-}
-
-/** Object representing a file that has been uploaded */
-export interface StorageUploadedFile {
-  /** Bucket in which the file has been uploaded */
-  bucket: string;
-  /** Name of the stored object with path */
-  name: string;
-  /** Content-type of the file */
-  contentType: string;
-  /** Byte size of the file */
-  size: string;
-  /** ISO string of the creation date */
-  timeCreated: string;
-  /** ISO string of the update date */
-  updated: string;
-  /** MD5 hash of the content */
-  md5Hash: string;
-  /** CRC32C hash of the content */
-  crc32c: string;
-  /** Storage class applied */
-  storageClass: string;
-}
-
-/** Return type for a file download */
-export interface StorageGetResponse {
-  /** The file raw binary content */
-  data: Buffer;
-  /** The file's metadata */
-  metadata: StorageUploadedFile;
-}
-
-/** Return time for a file streaming fetching */
-export interface StorageDownloadResponse {
-  /** A readable stream with the file's content */
-  stream: Readable;
-  /** The file's metadata */
-  metadata: StorageUploadedFile;
-}

package/src/entities/Storage/index.ts

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

package/src/entities/ValidationError/ValidationError.ts

@@ -1,34 +0,0 @@
-import {
-  ValidationError as ExpressValidationError,
-  Result
-} from 'express-validator';
-import { LogSeverity } from 'const';
-import { EngineError } from 'entities/EngineError';
-import { WebError } from 'entities/WebError';
-
-/** Error class for request/message validation errors */
-export class ValidationError extends WebError {
-  /** Create an ValidationError this represents errors in parsing incoming messages/requests */
-  public constructor(validationResult: Result<ExpressValidationError>) {
-    if (validationResult.isEmpty())
-      throw new EngineError({
-        message:
-          'Attempted to create a validation error while validation was successful'
-      });
-
-    const errors = validationResult.array();
-    // Hint that is sent to the client as logged as data
-    const hint = errors.reduce(
-      (hint, error) => ({ ...hint, [error.type]: error.msg as string }),
-      {}
-    );
-    super({
-      message: 'Request did not pass validation',
-      errorCode: 'invalid-request',
-      statusCode: 400,
-      severity: LogSeverity.WARNING,
-      data: hint,
-      hint
-    });
-  }
-}

package/src/entities/ValidationError/index.ts

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

package/src/entities/WebError/WebError.test.ts

@@ -1,18 +0,0 @@
-import { expect } from 'chai';
-import { WebError } from './WebError';
-
-describe('Entity - WebError', () => {
-  it('should set the error code and message', () => {
-    const statusCode = 401;
-    const errorCode = 'example-errorCode';
-    const message = 'this is an example message';
-    const error = new WebError({
-      message,
-      errorCode,
-      statusCode
-    });
-    expect(error.message).to.equal(message);
-    expect(error.errorCode).to.equal(errorCode);
-    expect(error.statusCode).to.equal(statusCode);
-  });
-});

package/src/entities/WebError/WebError.ts

@@ -1,23 +0,0 @@
-import { WebErrorOptions } from './WebError.types';
-import { LogSeverity } from 'const';
-import { EngineError } from 'entities/EngineError';
-
-/**
- * Error class used when errors should be reported to the client
- */
-export class WebError extends EngineError {
-  /** Machine readable error code that will be sent to the client */
-  public errorCode: string;
-  /** HTTP status code associated with this error */
-  public statusCode: number;
-
-  /**
-   * Create a WebError, these errors are best suited for runtime errors
-   */
-  public constructor(config: WebErrorOptions) {
-    super({ ...config, severity: config.severity ?? LogSeverity.WARNING });
-
-    this.statusCode = config.statusCode ?? 400;
-    this.errorCode = config.errorCode;
-  }
-}

package/src/entities/WebError/WebError.types.ts

@@ -1,9 +0,0 @@
-import { EngineErrorOptions } from 'entities/EngineError';
-
-/** Options to create a Web Error */
-export interface WebErrorOptions extends EngineErrorOptions {
-  /** Machine readable error code that will be sent to the client */
-  errorCode: string;
-  /** HTTP status code associated with this error (default: 400) */
-  statusCode?: number;
-}

package/src/entities/WebError/index.ts

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

package/src/entities/index.ts

@@ -1,16 +0,0 @@
-export * from './EngineError';
-export * from './WebError';
-export * from './ValidationError';
-export * from './KeySet';
-export * from './Endpoint';
-export * from './MessageHandler';
-export * from './SocketClient';
-export * from './Server';
-export * from './Redis';
-export * from './Localizator';
-export * from './Storage';
-export * from './Sequelize';
-export * from './ElasticSearch';
-export * from './LifecycleController';
-export * from './PubSub';
-export * from './PushNotification';

package/src/index.ts

@@ -1,6 +0,0 @@
-// src/index.ts
-export * from './const';
-export * from './entities';
-export * from './utils';
-export * from './utils/tlsRequest';
-export * as middleware from './middleware';

package/src/metrics/debug.ts

@@ -1,10 +0,0 @@
-import { Gauge } from 'prom-client';
-import { instanceRegistry } from 'const';
-
-export const debugActivated = new Gauge({
-  name: 'debug_activated',
-  help: 'Debug is activated',
-  registers: [instanceRegistry]
-});
-
-debugActivated.set(process.env.DEBUG?.length ? 1 : 0);

package/src/metrics/index.ts

@@ -1,2 +0,0 @@
-export * from './request';
-export * from './debug';

package/src/metrics/request.ts

@@ -1,17 +0,0 @@
-import { Counter, Histogram } from 'prom-client';
-import { instanceRegistry } from 'const';
-
-export const httpRequestCount = new Counter({
-  name: 'http_requests_total',
-  help: 'Total count of request received',
-  registers: [instanceRegistry],
-  labelNames: ['service', 'path', 'method', 'status']
-});
-
-export const httpRequestDuration = new Histogram({
-  name: 'http_requests_duration',
-  help: 'Duration of the request received',
-  registers: [instanceRegistry],
-  labelNames: ['service', 'path', 'method', 'status'],
-  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 0.5, 1, 2.5, 5, 10]
-});

package/src/middleware/authHmac/authHmac.test.ts

@@ -1,86 +0,0 @@
-import crypto from 'crypto';
-import express, { json, Request, Response, Application } from 'express';
-import { faker } from '@faker-js/faker';
-import request from 'supertest';
-import {
-  Endpoint,
-  EndpointAuthType,
-  EndpointMethod,
-  EndpointOptions
-} from 'entities/Endpoint';
-import { signPayload } from 'utils/hmac';
-
-describe('Middleware - authHmac', () => {
-  let app: Application;
-
-  const PATH = '/test';
-  const config: EndpointOptions<EndpointAuthType.HMAC> = {
-    path: PATH,
-    method: EndpointMethod.POST,
-    handler: (req: Request, res: Response) => {
-      res.sendStatus(200);
-    },
-    authType: EndpointAuthType.HMAC,
-    validator: {}
-  };
-
-  beforeEach(() => {
-    app = express();
-    app.use(json());
-    process.env.PAYLOAD_SIGNATURE_SECRET = faker.lorem.slug();
-  });
-
-  it('should allow properly signed requests', async () => {
-    const payload = signPayload({ test: 'test' });
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.HMAC
-    });
-    endpoint.register(app);
-    await request(app).post(PATH).send(payload).expect(200);
-  });
-
-  it('should allow properly signed requests with a custom secret', async () => {
-    const secret = faker.lorem.word();
-    const payload = signPayload({ test: 'test' }, { secret });
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.HMAC,
-      authParams: { secret }
-    });
-    endpoint.register(app);
-    await request(app).post(PATH).send(payload);
-  });
-
-  it('should not allow wrongly signed requests', async () => {
-    const payload = signPayload({ test: 'test' }, { secret: 'hacker' });
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.HMAC
-    });
-    endpoint.register(app);
-    await request(app).post(PATH).send(payload).expect(401);
-  });
-
-  it('should allow signed requests from Github', async () => {
-    const payload = {
-      z: faker.lorem.word(),
-      a: { z: faker.lorem.word(), a: faker.lorem.word() }
-    };
-    const signature = crypto
-      .createHmac('sha1', process.env.PAYLOAD_SIGNATURE_SECRET as string)
-      .update(JSON.stringify(payload))
-      .digest('hex');
-    const endpoint = new Endpoint({
-      ...config,
-      authType: EndpointAuthType.HMAC,
-      authParams: { isGithub: true }
-    });
-    endpoint.register(app);
-    await request(app)
-      .post(PATH)
-      .send(payload)
-      .set({ 'X-Hub-Signature': `sha1=${signature}` })
-      .expect(200);
-  });
-});

package/src/middleware/authHmac/authHmac.ts

@@ -1,56 +0,0 @@
-import { BinaryToTextEncoding } from 'crypto';
-import { Request, Response, NextFunction } from 'express';
-import { HmacPayload } from './authHmac.types';
-import { EndpointAuthParams, EndpointAuthType } from 'entities/Endpoint';
-import { WebError } from 'entities/WebError';
-import { verifySignature } from 'utils/hmac';
-import { reportDebug } from 'utils/report';
-
-const namespace = 'engine:middleware:authHmac';
-
-/** Generate an HMAC authentication middleware */
-export function authHmac(
-  options: EndpointAuthParams<EndpointAuthType.HMAC> = {}
-): (req: Request, res: Response, next: NextFunction) => void {
-  return (req: Request, res: Response, next: NextFunction): void => {
-    const payload = (
-      req.method === 'GET' ? req.query : req.body
-    ) as HmacPayload;
-    let signature: string | undefined;
-    let signatureSettings;
-    if (options.isGithub) {
-      // For GitHub, the signature is in the header and is has specific settings
-      signature =
-        req.headers['x-hub-signature'] &&
-        (req.headers['x-hub-signature'] as string).substr(5);
-      signatureSettings = {
-        algorithm: 'sha1',
-        sort: false,
-        encode: 'hex' as BinaryToTextEncoding
-      };
-    } else {
-      // In our standard authentication, the signature is included in the payload
-      signature = payload.signature;
-      delete payload.signature;
-    }
-    const settings = { secret: options.secret, ...signatureSettings };
-    if (!signature)
-      throw new WebError({
-        message: 'No signature was provided',
-        errorCode: 'unauthorized',
-        statusCode: 401
-      });
-    reportDebug({
-      namespace,
-      message: 'Performing HMAC authentication',
-      data: { payload, signature, settings }
-    });
-    if (!verifySignature(payload, signature, settings))
-      throw new WebError({
-        message: 'Signature does not match hmac of payload',
-        errorCode: 'unauthorized',
-        statusCode: 401
-      });
-    next();
-  };
-}

package/src/middleware/authHmac/authHmac.types.ts

@@ -1,7 +0,0 @@
-/** Options for HMAC auth */
-export interface HmacPayload {
-  /** Generic object payload */
-  [key: string]: unknown;
-  /** HMAC signature of the whole payload */
-  signature?: string;
-}

package/src/middleware/authHmac/index.ts

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

package/src/middleware/authJwt/authJwt.test.ts

@@ -1,54 +0,0 @@
-import { factory, getBearer } from 'backend-test-tools';
-import { expect } from 'chai';
-import { Request, Response } from 'express';
-import { faker } from '@faker-js/faker';
-import { fake } from 'sinon';
-import { authJwt } from './authJwt';
-
-describe('Middleware - Auth JWT', () => {
-  it('should authenticate with a JWT (auth-service)', async () => {
-    const user = factory.build('user');
-    const request = { headers: { authorization: getBearer(user.id) } };
-    const next = fake();
-
-    await authJwt()(request as Request, undefined as unknown as Response, next);
-
-    expect(next).to.have.been.calledOnceWithExactly();
-  });
-
-  it('should populate the user object in the request (auth-service)', async () => {
-    const user = factory.build('user');
-    const request = {
-      headers: { authorization: getBearer(user.id) }
-    } as Request;
-    const next = fake();
-
-    await authJwt()(request, undefined as unknown as Response, next);
-
-    expect(request.user).to.not.be.undefined;
-    expect(request.user?.id).to.equal(user.id);
-  });
-
-  it('should throw an error if there is no token', async () => {
-    const request = { headers: {} };
-    const next = fake();
-
-    await expect(
-      authJwt()(request as Request, undefined as unknown as Response, next)
-    ).to.eventually.rejected;
-  });
-
-  it('should throw an error if the audience is not valid', async () => {
-    const user = factory.build('user');
-    const request = {
-      headers: {
-        authorization: getBearer(user.id, { audience: faker.internet.url() })
-      }
-    };
-    const next = fake();
-
-    await expect(
-      authJwt()(request as Request, undefined as unknown as Response, next)
-    ).to.eventually.rejected;
-  });
-});