node-server-engine 1.0.5

package/src/utils/tlsConfig/tlsConfig.ts

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import https, { Agent } from 'https';
+import { TlsConfig } from './tlsConfig.types';
+import { validateTlsConfig } from './tlsConfig.validate';
+import { EngineError } from 'entities/EngineError';
+
+export let tlsConfig: undefined | TlsConfig;
+export let httpsAgent: undefined | Agent;
+
+/**
+ * Load TLS config by its Environment setting.
+ */
+export function loadTlsConfig(): void {
+  // Check that environment variables are correctly set
+  validateTlsConfig();
+  tlsConfig = undefined;
+
+  if (process.env.TLS_REQUEST_KEY || process.env.TLS_SERVER_KEY) {
+    tlsConfig = {
+      key: fs.readFileSync(
+        (process.env.TLS_REQUEST_KEY ?? process.env.TLS_SERVER_KEY) as string,
+        'utf-8'
+      ),
+      cert: fs.readFileSync(
+        (process.env.TLS_REQUEST_CERT ?? process.env.TLS_SERVER_CERT) as string,
+        'utf-8'
+      ),
+      ca: fs.readFileSync(
+        (process.env.TLS_REQUEST_CA ?? process.env.TLS_CA) as string,
+        'utf-8'
+      ),
+      passphrase: (process.env.TLS_REQUEST_KEY_PASSPHRASE ??
+        process.env.TLS_SERVER_KEY_PASSPHRASE) as string
+    } as TlsConfig;
+    httpsAgent = new https.Agent({
+      key: tlsConfig.key,
+      cert: tlsConfig.cert,
+      ca: tlsConfig.ca,
+      passphrase: tlsConfig.passphrase
+    });
+  }
+  if (!tlsConfig || !(tlsConfig.ca && tlsConfig.cert && tlsConfig.key)) {
+    throw new EngineError({
+      message: 'TLS environment variables are not set correctly'
+    });
+  }
+}

package/src/utils/tlsConfig/tlsConfig.types.ts

@@ -0,0 +1,11 @@
+/** TLS properties */
+export interface TlsConfig {
+  /** Path to the private key file */
+  key: string;
+  /** Path to the certificate file */
+  cert: string;
+  /** Path to the CA certificate file */
+  ca: string;
+  /** Passphrase to use to unwrap the private key */
+  passphrase?: string;
+}

package/src/utils/tlsConfig/tlsConfig.validate.ts

@@ -0,0 +1,25 @@
+import { assertEnvironment, envAssert } from 'utils';
+/**
+ * Verify that the environment variables
+ */
+export function validateTlsConfig(): void {
+  // We only check if there is at least the host specified
+  if (process.env.TLS_REQUEST_CERT) {
+    assertEnvironment({ TLS_REQUEST_KEY: envAssert.isPath() });
+    assertEnvironment({ TLS_REQUEST_CERT: envAssert.isPath() });
+    assertEnvironment({ TLS_REQUEST_CA: envAssert.isPath() });
+    // Optional variables
+    if (process.env.TLS_REQUEST_KEY_PASSPHRASE) {
+      assertEnvironment({ TLS_REQUEST_KEY_PASSPHRASE: envAssert.isString() });
+    }
+  } else if (process.env.TLS_SERVER_CERT) {
+    // if no TLS Request setting, TLS Server setting is essential.
+    assertEnvironment({ TLS_SERVER_KEY: envAssert.isPath() });
+    assertEnvironment({ TLS_SERVER_CERT: envAssert.isPath() });
+    assertEnvironment({ TLS_CA: envAssert.isPath() });
+    // Optional variables
+    if (process.env.TLS_SERVER_KEY_PASSPHRASE) {
+      assertEnvironment({ TLS_SERVER_KEY_PASSPHRASE: envAssert.isString() });
+    }
+  }
+}

package/src/utils/tlsRequest/index.ts

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

package/src/utils/tlsRequest/tlsRequest.test.ts

@@ -0,0 +1,63 @@
+import path from 'path';
+import { AxiosRequestConfig } from 'axios';
+import { expect } from 'chai';
+import { tlsRequest } from './tlsRequest';
+import { Endpoint, EndpointAuthType, EndpointMethod } from 'entities/Endpoint';
+import { Server } from 'entities/Server';
+import { stubPubSub } from 'test';
+import { loadTlsConfig } from 'utils/tlsConfig';
+
+describe('utils - TLS Request', () => {
+  let server: Server;
+  const testPath = '/test';
+  const success = { success: true };
+  let option: AxiosRequestConfig;
+
+  before(async () => {
+    process.env.TLS_SERVER_KEY = path.resolve('certs/server.key');
+    process.env.TLS_SERVER_CERT = path.resolve('certs/server.crt');
+    process.env.TLS_CA = path.resolve('certs/ca.crt');
+
+    const endpoint = new Endpoint({
+      path: testPath,
+      method: EndpointMethod.GET,
+      authType: EndpointAuthType.TLS,
+      handler: (request, response): void => {
+        response.json(success);
+      },
+      validator: {}
+    });
+    server = new Server({ endpoints: [endpoint] });
+
+    await server.init();
+  });
+
+  beforeEach(() => {
+    delete process.env.TLS_REQUEST_KEY;
+    delete process.env.TLS_REQUEST_CERT;
+    delete process.env.TLS_REQUEST_CA;
+    delete process.env.TLS_SERVER_KEY;
+    delete process.env.TLS_SERVER_CERT;
+    delete process.env.TLS_CA;
+    option = {
+      url: testPath,
+      baseURL: `https://localhost:${process.env.PORT as string}`
+    };
+    stubPubSub();
+  });
+
+  after(async () => {
+    await server.shutdown();
+  });
+
+  it('should successfully establish a TLS connection', async () => {
+    process.env.TLS_REQUEST_KEY = path.resolve('certs/client.key');
+    process.env.TLS_REQUEST_CERT = path.resolve('certs/client.crt');
+    process.env.TLS_REQUEST_CA = path.resolve('certs/ca.crt');
+
+    loadTlsConfig();
+
+    const { data } = await tlsRequest(option);
+    expect(data).to.deep.equal(success);
+  });
+});

package/src/utils/tlsRequest/tlsRequest.ts

@@ -0,0 +1,12 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { request } from 'utils/request';
+import { httpsAgent, loadTlsConfig } from 'utils/tlsConfig';
+
+/** Make a network request using TLS, this exposes the server client certificates to the destination */
+export async function tlsRequest<T = unknown>(
+  options: AxiosRequestConfig
+): Promise<AxiosResponse<T>> {
+  // if the config is not initial, will do that.
+  if (!httpsAgent) loadTlsConfig();
+  return request<T>({ httpsAgent, ...options });
+}

package/src/utils/trimPathSlash/index.ts

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

package/src/utils/trimPathSlash/trimPathSlash.test.ts

@@ -0,0 +1,26 @@
+import { expect } from 'chai';
+import { faker } from '@faker-js/faker';
+import { trimPathSlash } from './trimPathSlash';
+
+describe('Trim Path Slash', function () {
+  it('should remove starting slash', function () {
+    const result = trimPathSlash(`/${faker.lorem.word()}`);
+    expect(result[0]).to.not.equal('/');
+  });
+
+  it('should remove ending slash', function () {
+    const result = trimPathSlash(`${faker.lorem.word()}/`);
+    expect(result[result.length]).to.not.equal('/');
+  });
+
+  it('should remove both slash', function () {
+    const result = trimPathSlash(`/${faker.lorem.word()}/`);
+    expect(result[0]).to.not.equal('/');
+    expect(result[result.length]).to.not.equal('/');
+  });
+
+  it('should preserve slash in the string', function () {
+    const result = trimPathSlash(`${faker.lorem.word()}/${faker.lorem.word()}`);
+    expect(result).to.include('/');
+  });
+});

package/src/utils/trimPathSlash/trimPathSlash.ts

@@ -0,0 +1,8 @@
+/**
+ * Remove slashes if they are the first or last chars of a string
+ * @param url - URL to which slashes should be stripped
+ * @return Cleaned-up string
+ */
+export function trimPathSlash(url: string): string {
+  return url.replace(/\/$/, '').replace(/^\//, '');
+}

package/test/env.ts

@@ -0,0 +1,56 @@
+import path from 'path';
+import { faker } from '@faker-js/faker';
+
+const audience = faker.internet.url();
+
+/** Load a test environment */
+process.env = {
+  SILENCE_REPORT: 'true',
+  // DEBUG: 'engine:*',
+  PORT: '3030',
+  SECONDARY_PORT: '3031',
+  NODE_ENV: 'test',
+  WEBSOCKET_CLOSE_TIMEOUT: '0',
+  JWT_SECRET: faker.lorem.word(),
+  PAYLOAD_SIGNATURE_SECRET: faker.lorem.word(),
+  ACCESS_TOKEN_AUDIENCE: audience,
+  ACCESS_TOKEN_ISSUER: faker.lorem.word(),
+  ADMIN_API_ACCESS_TOKEN_AUDIENCE: audience,
+  ADMIN_ACCESS_TOKEN_ISSUER: faker.lorem.word(),
+  AUTH_SERVICE_PUBLIC_URL: faker.internet.url(),
+  ADMIN_API_PUBLIC_URL: faker.internet.url(),
+  VALID_IPS: '::ffff:127.0.0.1,127.0.0.1,::1',
+  REDIS_HOST: process.env.REDIS_HOST ?? '127.0.0.1',
+  REDIS_PORT: '6379',
+  REDIS_CLUSTER: 'false',
+  LOCALES_BUCKET: faker.lorem.word(),
+  USER_SERVICE_URL: faker.internet.url(),
+  PUBSUB_CACHE_TOPIC: faker.lorem.word(),
+  PUBSUB_EVENT_TOPIC: faker.lorem.word(),
+  TLS_SERVER_KEY: path.resolve('certs/server.key'),
+  TLS_SERVER_CERT: path.resolve('certs/server.crt'),
+  TLS_CA: path.resolve('certs/ca.crt'),
+  TLS_REQUEST_KEY_PASSPHRASE: path.resolve('certs/ecdsa.key.pub'),
+  ECDSA_PRIVATE_KEY: path.resolve('certs/ecdsa.key'),
+  ECDSA_PUBLIC_KEY: path.resolve('certs/ecdsa.key.pub'),
+  ADMIN_API_ECDSA_PUBLIC_KEY: path.resolve('certs/ecdsa.key.pub'),
+  GITHUB_WEBHOOK_SECRET: faker.lorem.word(),
+  LINKS_SERVICE_URL: faker.internet.url(),
+  STATIC_TOKEN: faker.lorem.word(),
+  HOSTNAME: faker.lorem.slug(),
+  ELASTIC_SEARCH_HOST:
+    process.env.ELASTIC_SEARCH_HOST ?? 'http://localhost:9200/',
+  ELASTIC_SEARCH_USERNAME: 'elastic',
+  ELASTIC_SEARCH_PASSWORD: 'changeme',
+  ELASTIC_SEARCH_MIGRATION_PATH: faker.lorem.word(),
+  RUN_MIGRATION: 'false',
+  UNDO_MIGRATION: 'false',
+  SQL_HOST: process.env.SQL_HOST ?? '127.0.0.1',
+  SQL_PORT: '3306',
+  SQL_USER: 'tao',
+  SQL_PASSWORD: 'abc@123',
+  SQL_DB: 'testDb',
+  SQL_TYPE: 'mysql',
+  DEFAULT_MESSAGE_AUDIENCE: audience,
+  ...process.env
+};

package/test/factory/index.ts

@@ -0,0 +1,8 @@
+import { factory } from 'factory-waifu';
+import { defineSequelizeMetaFactory } from './sequelizeMeta';
+
+/** Generates and defines a factory object that can create all of our data models */
+defineSequelizeMetaFactory(factory);
+
+export default factory;
+export { factory };

package/test/factory/sequelizeMeta.ts

@@ -0,0 +1,12 @@
+import { Factory } from 'factory-waifu';
+import { faker } from '@faker-js/faker';
+import { SequelizeMeta } from 'db/models';
+
+/** Defines all the sequelize meta schematics for a factory */
+export function defineSequelizeMetaFactory(factory: Factory): void {
+  factory.define('sequelizeMeta', SequelizeMeta, () => {
+    return {
+      name: faker.lorem.word()
+    };
+  });
+}

package/test/hooks.ts

@@ -0,0 +1,37 @@
+import {
+  generatePkiEnvironment,
+  generateEcdsaKeyPair
+} from 'backend-test-tools';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import sinon from 'sinon';
+import sinonChai from 'sinon-chai';
+import { factory } from './factory';
+import { sequelize } from 'entities/Sequelize';
+import * as models from 'db/models';
+
+chai.use(chaiAsPromised);
+chai.use(sinonChai);
+
+// Save a copy to revert the environment variables to their original state before each test
+const savedEnv = { ...process.env };
+const modelArray = Object.values(models);
+
+before(async () => {
+  factory.init(sequelize);
+  generatePkiEnvironment();
+  generateEcdsaKeyPair();
+  sequelize.init();
+  sequelize.addModels(modelArray);
+});
+
+beforeEach(async () => {
+  process.env = { ...savedEnv };
+  sequelize.init();
+  sequelize.addModels(modelArray);
+});
+
+afterEach(async () => {
+  sinon.restore();
+  await sequelize.shutdown();
+});

package/test/index.ts

@@ -0,0 +1,3 @@
+export * from './stub';
+export * from './utils';
+export * from './factory';

package/test/stub/index.ts

@@ -0,0 +1,3 @@
+export * from './stubLocales';
+export * from './stubStorage';
+export * from './stubPubSub';

package/test/stub/stubLocales.ts

@@ -0,0 +1,68 @@
+import { randomBytes } from 'crypto';
+import { faker } from '@faker-js/faker';
+import sinon, { SinonStub } from 'sinon';
+import { Storage } from 'entities/Storage/Storage';
+import { StorageUploadedFile } from 'entities/Storage/Storage.types';
+
+/**
+ * Locales server stubbing
+ * Will return fake content based on paths
+ */
+export function stubLocales(): SinonStub {
+  return sinon
+    .stub(Storage, 'get')
+    .callsFake(async (bucket: string, path: string) => {
+      let content;
+
+      switch (path) {
+        case 'locales.json':
+          content = { 'en-US': 'English' };
+          break;
+        case 'index.json':
+          content = ['emails.json'];
+          break;
+        case 'localeData.json':
+          content = {
+            'en-US': {
+              enabled: true,
+              display: 'English',
+              names: {
+                firstNameFirst: true,
+                spacing: true
+              }
+            }
+          };
+          break;
+        case 'scripts.json':
+          content = {};
+          break;
+        case 'en-US/emails.json':
+          content = {
+            welcome: {
+              subject: '🎊 {USER_FIRST_NAME} your account is ready!',
+              header: '{USER_FIRST_NAME}, your account is ready!',
+              body: 'Congratulations {USER_FIRST_NAME}!\n\nYou have successfully created an account with {USER_EMAIL}\n\nPlease return to the screen where you signed up, and you will be signed in.',
+              footer:
+                'This email was sent to {USER_EMAIL}.\nYou received this email because you successfully signed up.'
+            }
+          };
+          break;
+        default:
+          throw new Error(`No match for path '${path}' on locales server`);
+      }
+
+      const metadata: StorageUploadedFile = {
+        bucket,
+        name: path,
+        contentType: faker.system.mimeType(),
+        size: `${faker.number.int()}`,
+        timeCreated: new Date().toISOString(),
+        updated: new Date().toISOString(),
+        md5Hash: randomBytes(32).toString('base64'),
+        crc32c: randomBytes(32).toString('base64'),
+        storageClass: 'normal'
+      };
+
+      return { data: Buffer.from(JSON.stringify(content), 'utf-8'), metadata };
+    });
+}

package/test/stub/stubPubSub.ts

@@ -0,0 +1,7 @@
+import { stub } from 'sinon';
+import { PubSub } from 'entities/PubSub';
+
+/** Create a stub for Pub/Sub entity */
+export function stubPubSub(): void {
+  stub(PubSub, 'init').resolves();
+}

package/test/stub/stubStorage.ts

@@ -0,0 +1,77 @@
+import { randomUUID, randomBytes } from 'crypto';
+import { Readable } from 'stream';
+import { CreateWriteStreamOptions } from '@google-cloud/storage';
+import { faker } from '@faker-js/faker';
+import { stub } from 'sinon';
+import { StubbedStorage } from './stubStorage.types';
+import { Storage } from 'entities/Storage/Storage';
+import {
+  UploadDestinationOptions,
+  StorageUploadedFile
+} from 'entities/Storage/Storage.types';
+
+/** Create a stub for the Storage entity */
+export function stubStorage(
+  uploadOverride: Partial<StorageUploadedFile> = {}
+): StubbedStorage {
+  const upload = stub(Storage, 'upload').callsFake(
+    async (
+      readStream: Readable,
+      bucket: string,
+      destinationOptions: UploadDestinationOptions = {},
+      storageOptions: CreateWriteStreamOptions = {}
+    ) => {
+      readStream.resume(); // Pause the stream
+      const path = Storage.generateFileDestination(destinationOptions);
+      return {
+        kind: 'storage#object',
+        id: `${bucket}/${path}/${randomUUID()}`,
+        selfLink: `https://www.googleapis.com/storage/v1/b/${bucket}/o/${encodeURIComponent(path)}`,
+        mediaLink: `https://storage.googleapis.com/download/storage/v1/b/${bucket}/o/${encodeURIComponent(
+          path
+        )}?generation=1610116408152540&alt=media`,
+        name: path,
+        bucket,
+        generation: randomUUID(),
+        metageneration: '1',
+        contentType: (
+          storageOptions.metadata as {
+            /** file type */
+            fileType: string;
+          }
+        )?.fileType,
+        storageClass: 'STANDARD',
+        size: '4',
+        md5Hash: 'CY9rzUYh03PK3k6DJie09g==',
+        crc32c: 'hqBywA==',
+        etag: 'CNyjuITHjO4CEAE=',
+        timeCreated: new Date().toISOString(),
+        updated: new Date().toISOString(),
+        timeStorageClassUpdated: new Date().toISOString(),
+        ...uploadOverride
+      };
+    }
+  );
+  const remove = stub(Storage, 'delete').resolves();
+
+  const download = stub(Storage, 'download').callsFake(
+    async (bucket: string, path: string) => {
+      const stream = new Readable();
+      stream.push(faker.lorem.paragraph());
+      stream.push(null); // EOF
+      const metadata: StorageUploadedFile = {
+        bucket,
+        name: path,
+        contentType: faker.system.mimeType(),
+        size: `${faker.number.int()}`,
+        timeCreated: new Date().toISOString(),
+        updated: new Date().toISOString(),
+        md5Hash: randomBytes(32).toString('base64'),
+        crc32c: randomBytes(32).toString('base64'),
+        storageClass: 'normal'
+      };
+      return { stream, metadata };
+    }
+  );
+  return { upload, remove, download };
+}

package/test/stub/stubStorage.types.ts

@@ -0,0 +1,11 @@
+import { SinonStub } from 'sinon';
+
+/** Stubbed Storage module */
+export interface StubbedStorage {
+  /** upload stub */
+  upload: SinonStub;
+  /** remove stub */
+  remove: SinonStub;
+  /** download stub */
+  download: SinonStub;
+}

package/test/utils/app.ts

@@ -0,0 +1,31 @@
+import express, { Application, Request, Response } from 'express';
+import {
+  Endpoint,
+  EndpointMethod,
+  EndpointOptions,
+  EndpointAuthType
+} from 'entities/Endpoint';
+import { error } from 'middleware';
+
+/**
+ * Create a test application with the given endpoint and error handling
+ */
+
+export function createTestApp(
+  config: Partial<EndpointOptions<EndpointAuthType.NONE>>
+): Application {
+  const app = express();
+  const endpoint = new Endpoint({
+    path: '/test',
+    method: EndpointMethod.POST,
+    handler: (req: Request, res: Response): void => {
+      res.sendStatus(200);
+    },
+    authType: EndpointAuthType.NONE,
+    validator: {},
+    ...config
+  });
+  endpoint.register(app);
+  app.use(error);
+  return app;
+}

package/test/utils/index.ts

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

package/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"],
+  "exclude": ["**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "baseUrl": "src",
+    "paths": {
+      "test": ["../test"],
+      "test/*": ["../test/*"]
+    },
+    "target": "ES6",
+    "lib": ["ES2023"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  },
+  "include": ["src", "test"]
+}