node-server-engine 1.0.5

package/src/entities/Storage/Storage.ts

@@ -0,0 +1,219 @@
+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

@@ -0,0 +1,57 @@
+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

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

package/src/entities/ValidationError/ValidationError.ts

@@ -0,0 +1,34 @@
+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

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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,9 @@
+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

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

package/src/entities/index.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,4 @@
+export * from './const';
+export * from './entities';
+export * from './utils';
+export * as middleware from './middleware';

package/src/metrics/debug.ts

@@ -0,0 +1,10 @@
+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

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

package/src/metrics/request.ts

@@ -0,0 +1,17 @@
+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/authAdmin/authAdmin.test.ts

@@ -0,0 +1,199 @@
+import { factory, generateAccessToken, 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 { authAdmin } from './authAdmin';
+import {} from './authAdmin.types';
+
+describe('Middleware - Auth Admin', () => {
+  it('should authenticate with a JWT (auth-service)', async () => {
+    const email = faker.internet.email();
+    const permission = faker.lorem.word();
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permission }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+
+    expect(next).to.have.been.calledOnceWithExactly();
+  });
+
+  it('should populate the admin object in the request (auth-service)', async () => {
+    const email = faker.internet.email();
+    const permission = faker.lorem.word();
+    const permissions = [permission, faker.lorem.word(), faker.lorem.word()];
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permissions }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+
+    expect(request.admin?.email).to.equal(email);
+    expect(request.admin?.permissions).to.deep.members(permissions);
+  });
+
+  it('should throw an error if there is no token', async () => {
+    const request = { headers: {} } as unknown as Request;
+    const next = fake();
+
+    await expect(
+      authAdmin({ permission: faker.lorem.word() })(
+        request,
+        undefined as unknown as Response,
+        next
+      )
+    ).to.eventually.be.rejected;
+  });
+
+  it('should throw an error if the audience is not valid', async () => {
+    const user = factory.build('user');
+    const permission = faker.lorem.word();
+    const request = {
+      headers: {
+        authorization: getBearer(
+          user.id,
+          { audience: faker.internet.url() },
+          { per: permission }
+        )
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await expect(
+      authAdmin({ permission })(request, undefined as unknown as Response, next)
+    ).to.eventually.be.rejected;
+  });
+
+  it('should check user has permission', async () => {
+    const email = faker.internet.email();
+    const permissions = [faker.lorem.word(), faker.lorem.word()];
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permissions }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission: permissions[0] })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+
+    expect(request.admin?.email).to.equal(email);
+    expect(request.admin?.permissions).to.deep.members(permissions);
+  });
+
+  it('should all user has endpoint permission', async () => {
+    const email = faker.internet.email();
+    const permission = faker.lorem.word();
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permission }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+
+    expect(request.admin?.email).to.equal(email);
+    expect(request.admin?.permissions).to.includes(permission);
+  });
+
+  it('should throw error if user does not have permission', async () => {
+    const email = faker.internet.email();
+    const permissions = [faker.lorem.word(), faker.lorem.word()];
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permissions }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await expect(
+      authAdmin({ permission: faker.lorem.word() })(
+        request,
+        undefined as unknown as Response,
+        next
+      )
+    ).to.eventually.rejected;
+  });
+
+  it('should allow wildcard permissions', async () => {
+    const email = faker.internet.email();
+    const permission = faker.lorem.word();
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: `${permission}:*` }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission: `${permission}:${faker.lorem.word()}` })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+  });
+});