node-server-engine 1.1.1 → 1.1.3

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

@@ -1,35 +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: Partial<Request> = { user: { id: me.id } };
-
-    // Call the resolver with the mocked request
-    await userResolver(request as 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;
-  // });
-});
+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: Partial<Request> = { user: { id: me.id } };
+
+    // Call the resolver with the mocked request
+    await userResolver(request as 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

@@ -1,35 +1,35 @@
-import { Request, Response, NextFunction } from 'express';
-import { EngineError } from 'entities/EngineError';
-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,
-    ...user
-  };
-
-  next();
-}
+import { Request, Response, NextFunction } from 'express';
+import { EngineError } from 'entities/EngineError';
+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,
+    ...user
+  };
+
+  next();
+}

package/src/middleware/validate/index.ts

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

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

@@ -1,43 +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);
-  });
-});
+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

@@ -1,25 +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));
-  }
-];
+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

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

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

@@ -1,23 +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 });
-  });
-});
+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

@@ -1,12 +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 });
-  });
-}
+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

@@ -1,49 +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) });
-}
+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

@@ -1,24 +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;
-  });
-});
+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

@@ -1,34 +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);
-  }
-}
+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

@@ -1,17 +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() });
-  }
-}
+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

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

package/src/utils/createSortedObject/createSortedObject.ts

@@ -1,20 +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;
-}
+/** 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;
+}