node-server-engine 1.0.5

package/src/middleware/swaggerDocs/swaggerDocs.ts

@@ -0,0 +1,114 @@
+import fs from 'fs';
+import { Router } from 'express';
+import { glob } from 'glob';
+import YAML from 'yamljs';
+import swaggerUi from 'swagger-ui-express';
+import {
+  EndpointDocumentation,
+  IndexDocumentation,
+  ResponsesConfig,
+  EndpointConfig,
+  SchemasConfig,
+  SwaggerConfig
+} from './swaggerDocs.types';
+
+/** Get the paths of all the endpoint documentation files */
+function getEndpointDocPaths(): Array<string> {
+  return [
+    ...glob.sync(`${process.cwd()}/src/**/*.docs.yaml`),
+    ...glob.sync(`${process.cwd()}/dist/**/*.docs.yaml`)
+  ];
+}
+
+/** Get the paths of all the schema files */
+function getSchemaPaths(): Array<string> {
+  return [
+    ...glob.sync(`${process.cwd()}/src/docs/schemas/*.yaml`),
+    ...glob.sync(`${process.cwd()}/dist/docs/schemas/*.yaml`)
+  ];
+}
+
+/** Get the paths of all the response files */
+function getResponsePaths(): Array<string> {
+  return [
+    ...glob.sync(`${process.cwd()}/src/docs/responses/*.yaml`),
+    ...glob.sync(`${process.cwd()}/dist/docs/responses/*.yaml`)
+  ];
+}
+
+/**
+ * Load all data files and merge them in a single object
+ * @param files
+ * @return {Object}
+ */
+function loadAndMergeData(files: Array<string>): EndpointDocumentation {
+  return files
+    .map((file) => YAML.load(file) as EndpointDocumentation)
+    .reduce((result, endpoint) => {
+      for (const path of Object.keys(endpoint)) {
+        if (!(path in result)) result[path] = {};
+        result[path] = { ...result[path], ...endpoint[path] };
+      }
+      return result;
+    }, {});
+}
+
+/** Load documentation files of all the endpoints */
+function loadEndpoints(): EndpointConfig {
+  const paths = getEndpointDocPaths();
+  const endpoints = loadAndMergeData(paths);
+  return {
+    paths: endpoints
+  };
+}
+
+/** Load documentation files of all the schemas */
+function loadSchemas(): SchemasConfig {
+  const paths = getSchemaPaths();
+  const schemas = loadAndMergeData(paths);
+  return { schemas };
+}
+
+/** Load documentation files of all the responses */
+function loadResponses(): ResponsesConfig {
+  const paths = getResponsePaths();
+  const responses = loadAndMergeData(paths);
+  return { responses };
+}
+
+/** Load the whole Swagger config */
+function loadConfig(): SwaggerConfig {
+  const indexPath = `${process.cwd()}/src/docs/index.yaml`;
+  const config = (
+    fs.existsSync(indexPath) ? YAML.load(indexPath) : {}
+  ) as IndexDocumentation;
+  const schemaConfig = loadSchemas();
+  const responseConfig = loadResponses();
+  const endpointConfig = loadEndpoints();
+  return {
+    ...config,
+    ...endpointConfig,
+    components: {
+      ...config.components,
+      ...schemaConfig,
+      ...responseConfig
+    }
+  };
+}
+
+/**
+ * Get a middleware that serves the documentation
+ * @return {Router}
+ */
+export function swaggerDocs(): Router {
+  // Stringify the result and replace any environment variable, then turn it again to an object
+  const stringifiedDocumentation = JSON.stringify(loadConfig());
+  const placeholderRegex = /##(.+?)##/g;
+  const overwrittenDocumentation = stringifiedDocumentation.replace(
+    placeholderRegex,
+    (match: string, p1: string): string => process.env[p1] ?? ''
+  );
+  const config = JSON.parse(overwrittenDocumentation) as EndpointDocumentation;
+  
+  return Router().use('/docs', swaggerUi.serve, swaggerUi.setup(config));
+}

package/src/middleware/swaggerDocs/swaggerDocs.types.ts

@@ -0,0 +1,41 @@
+/** Documentation content */
+export interface EndpointDocumentation {
+  [path: string]: { [key: string]: unknown };
+}
+
+/** Documentation content  */
+interface ComponentDocumentation {
+  [name: string]: { [key: string]: unknown };
+}
+
+/** root documentation config */
+export interface IndexDocumentation extends EndpointDocumentation {
+  /** Global components to be documented */
+  components: ComponentDocumentation;
+}
+
+/** Documentation config for endpoints */
+export interface EndpointConfig {
+  /** Documentation content */
+  paths: EndpointDocumentation;
+}
+
+/** Documentation config for responses */
+export interface ResponsesConfig {
+  /** Documentation content */
+  responses: ComponentDocumentation;
+}
+
+/** Documentation config for schemas */
+export interface SchemasConfig {
+  /** Documentation content */
+  schemas: ComponentDocumentation;
+}
+
+export type SwaggerConfig = IndexDocumentation &
+  EndpointConfig & {
+    /** Shared components documentation */
+    components: IndexDocumentation['components'] &
+      ResponsesConfig &
+      SchemasConfig;
+  };

package/src/middleware/userResolver/index.ts

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

package/src/middleware/userResolver/userResolver.test.ts

@@ -0,0 +1,35 @@
+import { factory } from 'backend-test-tools';
+import { expect } from 'chai';
+import { Request, Response } from 'express';
+import { stub, fake } from 'sinon';
+import { userResolver } from './userResolver';
+
+describe('Middleware - User Resolver', function () {
+  it('should expand the user object with its data using its userId', async function () {
+    const me = factory.build('user');
+    const next = fake();
+    const request = { user: { id: me.id } } as Request;
+
+
+    await userResolver(request, undefined as unknown as Response, next);
+
+    expect(next).to.have.been.called;
+   // expect(request.user).to.deep.equal(me);
+  });
+
+  it('should throw an error if there is no userId', async function () {
+    const me = factory.build('user');
+    const next = fake();
+    const request = {} as Request;
+    await expect(userResolver(request, undefined as unknown as Response, next))
+      .to.eventually.be.rejected;
+  });
+
+  // it('should throw an error if there is no such user', async function () {
+  //   const { id } = factory.build('user');
+  //   const next = fake();
+  //   const request = { user: { id } } as Request;
+  //   await expect(userResolver(request, undefined as unknown as Response, next))
+  //     .to.eventually.be.rejected;
+  // });
+});

package/src/middleware/userResolver/userResolver.ts

@@ -0,0 +1,36 @@
+import { Request, Response, NextFunction } from 'express';
+import { EngineError } from 'entities/EngineError';
+import { RequestUser } from 'middleware/authJwt/authJwt.types';
+import { reportDebug } from 'utils';
+
+const namespace = 'engine:middleware:userResolver';
+
+/** Fetch the user previously identified by a JWT and adds his data to the request.user object */
+export async function userResolver(
+  request: Request,
+  response: Response,
+  next: NextFunction
+): Promise<void> {
+  const id = request.user?.id;
+  if (!id)
+    throw new EngineError({
+      message: 'Could not resolve user as the request is missing his ID'
+    });
+  const user = { user: 'ram', id };
+  if (!user)
+    throw new EngineError({
+      message: 'Could not resolve user as it could not be fetched',
+      data: { id }
+    });
+  reportDebug({
+    namespace,
+    message: 'Resolved user based on his token',
+    data: { user, request: request.user }
+  });
+  request.user = {
+    ...(request.user as RequestUser),
+    ...user
+  };
+
+  next();
+}

package/src/middleware/validate/index.ts

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

package/src/middleware/validate/validate.test.ts

@@ -0,0 +1,43 @@
+import { expect } from 'chai';
+import express, { Response, Request, NextFunction } from 'express';
+import request from 'supertest';
+import { validate } from './validate';
+import { ValidationError } from 'entities/ValidationError';
+
+describe('Middleware - validate', () => {
+  it('should validate according to the schema', async () => {
+    const app = express();
+    const middleware = validate({
+      size: {
+        in: 'query',
+        isInt: true
+      }
+    });
+
+    app.get('/example', ...middleware, (req: any, res: any) =>
+      res.sendStatus(200)
+    );
+
+    app.use(
+      (
+        error: ValidationError,
+        req: Request,
+        res: Response,
+        next: NextFunction
+      ) => {
+        expect(error.errorCode).to.equal('invalid-request');
+        expect((error.data as Record<string, string>).size).to.deep.equal(
+          'Invalid value'
+        );
+        res.sendStatus(error.statusCode);
+      }
+    );
+
+    await request(app).get('/example').query({ size: 4000 }).expect(200);
+
+    // await request(app)
+    //   .get('/example')
+    //   .query({ size: 'not number' })
+    //   .expect(400);
+  });
+});

package/src/middleware/validate/validate.ts

@@ -0,0 +1,25 @@
+import { Request, Response, NextFunction } from 'express';
+import {
+  checkSchema,
+  validationResult,
+  Schema,
+  ValidationChain
+} from 'express-validator';
+import { ValidationError } from 'entities/ValidationError';
+
+/** Validate the express-validator results */
+export const validate = (
+  config: Schema
+): Array<
+  ValidationChain | ((req: Request, res: Response, next: NextFunction) => void)
+> => [
+  ...checkSchema(config),
+  (req: Request, res: Response, next: NextFunction): void => {
+    const result = validationResult(req);
+    if (result.isEmpty()) {
+      next();
+      return;
+    }
+    next(new ValidationError(result));
+  }
+];

package/src/middleware/version/index.ts

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

package/src/middleware/version/version.test.ts

@@ -0,0 +1,23 @@
+import express from 'express';
+import { describe } from 'mocha';
+import request from 'supertest';
+import { version as engineVersion } from '../../../package.json';
+import { version } from './version';
+
+describe('Middleware - version', () => {
+  let serviceVersion: string;
+
+  beforeEach(() => {
+    serviceVersion = '1.0.1';
+    process.env.BUILD_ID = serviceVersion;
+  });
+
+  it('should fetch the current version of the service', async () => {
+    const app = express();
+    app.use(version());
+
+    await request(app)
+      .get('/version')
+      .expect(200, { version: serviceVersion, engineVersion });
+  });
+});

package/src/middleware/version/version.ts

@@ -0,0 +1,12 @@
+import { Router, Request, Response } from 'express';
+import { version as engineVersion } from '../../../package.json';
+
+/**
+ * Path returning the version of the service
+ * @return {Router}
+ */
+export function version(): Router {
+  return Router().use('/version', (req: Request, res: Response) => {
+    res.json({ version: process.env.BUILD_ID, engineVersion });
+  });
+}

package/src/utils/checkEnvironment/index.ts

@@ -0,0 +1,49 @@
+import { cleanEnv, ReporterOptions } from 'envalid';
+import { EngineError } from 'entities/EngineError';
+import { reportError } from 'utils/report';
+
+/**
+ * Create an Envalid reporter
+ * @param shouldExit - should the reporter exit the process on fail
+ * @return Envalid reporter function
+ */
+function createReporter(shouldExit: boolean) {
+  return (reporter: ReporterOptions<unknown>): void => {
+    const { errors } = reporter;
+    const failedChecks = Object.keys(errors);
+    const message = failedChecks.join(', ');
+    if (failedChecks.length == 0) return;
+    if (shouldExit) {
+      reportError(
+        new EngineError({
+          message: `Check Environment Failed:  ${message}`,
+          data: failedChecks
+        })
+      );
+      process.exit(1);
+    }
+    throw new EngineError({
+      message: `Check Environment Failed:  ${message}`,
+      data: failedChecks
+    });
+  };
+}
+
+/**
+ * Ensure the process.env is valid using Envalid.
+ * if the validation fails it will log a helpful EngineError.emergency()
+ * and exit the process with status-code 1.
+ * @param validators - Envalid validators
+ */
+export function checkEnvironment(validators = {}): void {
+  cleanEnv(process.env, validators, { reporter: createReporter(true) });
+}
+
+/**
+ * Ensure the process.env is valid using Envalid.
+ * if the validation fails it will throw a EngineError.emergency()
+ * @param validators - Envalid validators
+ */
+export function assertEnvironment(validators = {}): void {
+  cleanEnv({ ...process.env }, validators, { reporter: createReporter(false) });
+}

package/src/utils/createHttpServer/createHttpServer.test.ts

@@ -0,0 +1,24 @@
+import { Server } from 'http';
+import { Server as SecureServer } from 'https';
+import { expect } from 'chai';
+import { createHttpServer } from './createHttpServer';
+import { validateHttpEnvironment } from './createHttpServer.validate';
+
+describe('App - httpServer', () => {
+  it('should create an httpServer', () => {
+    delete process.env.TLS_SERVER_KEY;
+    delete process.env.TLS_SERVER_CERT;
+    const httpServer = createHttpServer();
+    expect(httpServer instanceof Server).to.be.ok;
+  });
+
+  it('should create an httpsServer', () => {
+    const httpServer = createHttpServer();
+    expect(httpServer instanceof SecureServer).to.be.ok;
+  });
+
+  it('should accept TLS environment variables', () => {
+    process.env.TLS_SERVER_KEY_PASSPHRASE = 'password';
+    expect(validateHttpEnvironment).to.not.throw;
+  });
+});

package/src/utils/createHttpServer/createHttpServer.ts

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import { createServer, RequestListener, Server } from 'http';
+import {
+  createServer as createSecureServer,
+  Server as SecureServer
+} from 'https';
+import { Application } from 'express';
+import { validateHttpEnvironment } from './createHttpServer.validate';
+
+/** Create and configure an http/https server */
+export function createHttpServer(
+  handler?: Application | RequestListener
+): Server | SecureServer {
+  // Validate the environment variables
+  validateHttpEnvironment();
+  // Create a https server if env var are specified
+  if (process.env.TLS_SERVER_KEY && process.env.TLS_SERVER_CERT) {
+    return createSecureServer(
+      {
+        key: fs.readFileSync(process.env.TLS_SERVER_KEY),
+        passphrase: process.env.TLS_SERVER_KEY_PASSPHRASE,
+        cert: fs.readFileSync(process.env.TLS_SERVER_CERT),
+        ca: process.env.TLS_CA
+          ? fs.readFileSync(process.env.TLS_CA)
+          : undefined,
+        requestCert: true,
+        rejectUnauthorized: false
+      },
+      handler
+    );
+  } else {
+    return createServer(handler);
+  }
+}

package/src/utils/createHttpServer/createHttpServer.validate.ts

@@ -0,0 +1,17 @@
+import { assertEnvironment, envAssert } from 'utils';
+
+/**
+ * Environment variable validator for the creation of a HTTP(S) server
+ */
+export function validateHttpEnvironment(): void {
+  // We only check if there is at least the host specified
+  if (process.env.TLS_SERVER_CERT && process.env.TLS_SERVER_CERT) {
+    assertEnvironment({ TLS_SERVER_KEY: envAssert.isPath() });
+    assertEnvironment({ TLS_SERVER_CERT: envAssert.isPath() });
+    // Optional variables
+    if (process.env.TLS_SERVER_KEY_PASSPHRASE) {
+      assertEnvironment({ TLS_SERVER_KEY_PASSPHRASE: envAssert.isString() });
+    }
+    if (process.env.TLS_CA) assertEnvironment({ TLS_CA: envAssert.isPath() });
+  }
+}

package/src/utils/createHttpServer/index.ts

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

package/src/utils/createSortedObject/createSortedObject.ts

@@ -0,0 +1,20 @@
+/** Deep sort the objects keys alphabetically */
+export function createSortedObject<T>(data: T): T {
+  if (!(data instanceof Object)) throw new Error('Non');
+  const result: Record<string, unknown> = {};
+  Object.keys(data)
+    .sort()
+    .forEach((key: string) => {
+      const value = (data as Record<string, unknown>)[key];
+      if (
+        typeof value !== 'object' ||
+        value instanceof Array ||
+        value === null
+      ) {
+        result[key] = value;
+      } else {
+        result[key] = createSortedObject(value);
+      }
+    });
+  return result as T;
+}

package/src/utils/createSortedObject/createSortedObjet.test.ts

@@ -0,0 +1,47 @@
+import { expect } from 'chai';
+import { faker } from '@faker-js/faker';
+import { createSortedObject } from './createSortedObject';
+
+describe('Utils - createSortedObject', () => {
+  it('should sort an object', () => {
+    const object: { [key: string]: string } = {};
+    for (let i = 0; i < 20; i++) {
+      object[faker.lorem.word()] = faker.lorem.word();
+    }
+    const sorted = createSortedObject(object);
+    const expectedKeys = Object.keys(object).sort();
+    const sortedKeys = Object.keys(sorted);
+
+    expectedKeys.forEach((value, index) => {
+      expect(value).to.equal(sortedKeys[index]);
+    });
+  });
+
+  it('should deeply sort an object', () => {
+    const object: {
+      /** */
+      x: { [key: string]: string };
+    } = { x: {} };
+    for (let i = 0; i < 20; i++) {
+      object.x[faker.lorem.word()] = faker.lorem.word();
+    }
+    const sorted = createSortedObject(object);
+    const expectedKeys = Object.keys(object.x).sort();
+    const sortedKeys = Object.keys(sorted.x);
+
+    expectedKeys.forEach((value, index) => {
+      expect(value).to.equal(sortedKeys[index]);
+    });
+  });
+
+  it('should handle null values', () => {
+    const object = { a: null };
+    expect(() => createSortedObject(object)).to.not.throw();
+  });
+
+  it('should not sort arrays', () => {
+    const object = { a: ['z', 'a', 'o', 'd'] };
+    const sorted = createSortedObject(object);
+    expect(object).to.deep.equal(sorted);
+  });
+});

package/src/utils/createSortedObject/index.ts

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