node-server-engine 1.4.9 → 1.5.1

package/src/entities/KeySet/KeySet.ts

@@ -1,172 +0,0 @@
-import { createPublicKey, createHash } from 'crypto';
-import { readFileSync } from 'fs';
-import { Method } from 'axios';
-import { KeySetOptions, KeySetValues, JWKS } from './KeySet.types';
-import { LogSeverity } from 'const';
-import { EngineError } from 'entities/EngineError';
-import { reportDebug, reportError } from 'utils/report';
-import { request } from 'utils/request';
-import { tlsRequest } from 'utils/tlsRequest';
-
-const namespace = 'engine:keySet';
-
-// Number of seconds between each key refresh
-const KEY_REFRESH_INTERVAL = 300;
-
-/**
- * Fetch Json Web Key Sets and cache them
- * Keys can then be used for Json Web Token authentication
- */
-export class KeySet {
-  /** Latest known value for the keys in the set, indexed by the key id */
-  private keySet: KeySetValues = {};
-  /** URL at which the key set can be fetched */
-  private url: string;
-  /** This resource is located on a service inside of our private cluster */
-  private internal: boolean;
-  /** This URL is actually a path to a local key file encoded in PEM  */
-  private file: boolean;
-  /** This input is actually a full PEM string representation of a key */
-  private pem: boolean;
-  /** Timer for the key fetching interval */
-  private interval?: NodeJS.Timeout | string | number | undefined;
-
-  /** Create a new Key Set */
-  public constructor(url: string, options: KeySetOptions = {}) {
-    this.url = url;
-    this.internal = options.internal ?? false;
-    this.file = options.file ?? false;
-    this.pem = options.pem ?? false;
-  }
-
-  /** Calculate key ID from PEM string */
-  private static calculateKeyId(pem: string): string {
-    // We use the md5 hash of the PEM file to defined the key ID
-    const hash = createHash('md5');
-    hash.update(pem.trim());
-    const kid = hash.digest('base64url');
-    reportDebug({
-      namespace,
-      message: `Calculated Key ID: "${kid}"`,
-      data: { key: pem }
-    });
-    return kid;
-  }
-
-  /** Initialize a KeySet, should be run on server startup to avoid any misconfiguration */
-  public async init(): Promise<void> {
-    await this.fetch();
-    this.interval = setInterval(() => {
-      (async (): Promise<void> => {
-        try {
-          await this.fetch();
-        } catch (error) {
-          reportError(error);
-        }
-      })().catch((error) => {
-        reportError(error);
-      });
-    }, KEY_REFRESH_INTERVAL * 1000);
-  }
-
-  /** Clear any pending timers to avoid pending process */
-  public shutdown(): void {
-    if (this.interval) clearInterval(this.interval);
-  }
-
-  /** Get the PEM encoded version of a key by its id */
-  public getKey(keyId: string): string | undefined {
-    return this.keySet[keyId];
-  }
-
-  /** Get all the keys in the set mapped by their ID */
-  public getKeys(): KeySetValues {
-    return this.keySet;
-  }
-
-  /** Fetch the latest version of the key set */
-  private async fetch(): Promise<void> {
-    reportDebug({
-      namespace,
-      message: `Fetching JWKS`,
-      data: { url: this.url }
-    });
-
-    if (this.pem) {
-      // Read the key from the parameter directly
-      reportDebug({
-        namespace,
-        message: 'Processing key from given PEM string'
-      });
-
-      const kid = KeySet.calculateKeyId(this.url);
-
-      this.keySet = { [kid]: this.url };
-    } else if (this.file) {
-      // Read the key from a file
-      reportDebug({
-        namespace,
-        message: `Reading key on disk at path "${this.url}"`
-      });
-      const set = JSON.parse(readFileSync(this.url, 'utf-8'));
-
-      // Check that the returned data has the shape of a JWKS
-      if (!(set.keys && set.keys instanceof Array))
-        throw new EngineError({
-          severity: LogSeverity.ERROR,
-          message: 'Fetched key set is not in an appropriate format',
-          data: { url: this.url, set }
-        });
-
-      // Create a node.crypto public key object for each key in the set
-      this.keySet = set.keys.reduce(
-        (set: { [x: string]: string; }, key: { kid: string | number; }) => {
-          set[key.kid] = createPublicKey({ key, format: 'jwk' }).export({
-            format: 'pem',
-            type: 'spki'
-          }) as string;
-          return set;
-        },
-        {} as Record<string, string>
-      );
-    } else {
-      // Fetch key by making a network request
-      reportDebug({
-        namespace,
-        message: `Making network request to "${this.url}"`
-      });
-
-      const requestOptions = { url: this.url, method: 'get' as Method };
-      // For services inside of our cluster we use the TLS authenticated request method
-      const { data: set } = await (this.internal
-        ? tlsRequest<JWKS>(requestOptions)
-        : request<JWKS>(requestOptions));
-
-      // Check that the returned data has the shape of a JWKS
-      if (!(set.keys && set.keys instanceof Array))
-        throw new EngineError({
-          severity: LogSeverity.ERROR,
-          message: 'Fetched key set is not in an appropriate format',
-          data: { url: this.url, set }
-        });
-
-      // Create a node.crypto public key object for each key in the set
-      this.keySet = set.keys.reduce(
-        (set, key) => {
-          set[key.kid] = createPublicKey({ key, format: 'jwk' }).export({
-            format: 'pem',
-            type: 'spki'
-          }) as string;
-          return set;
-        },
-        {} as Record<string, string>
-      );
-    }
-
-    reportDebug({
-      namespace,
-      message: `Stored ${Object.keys(this.keySet).length} keys`,
-      data: { keyIds: Object.keys(this.keySet) }
-    });
-  }
-}

package/src/entities/KeySet/KeySet.types.ts

@@ -1,28 +0,0 @@
-import { JsonWebKey } from 'crypto';
-
-/** KeySet initialization options */
-export interface KeySetOptions {
-  /** This resource is located on a service inside of our private cluster */
-  internal?: boolean;
-  /** This URL is actually a path to a local key file encoded in PEM  */
-  file?: boolean;
-  /** This input is actually a full PEM string representation of a key */
-  pem?: boolean;
-}
-
-/** Keep a mapping ok keyId => PEM */
-export interface KeySetValues {
-  [id: string]: string;
-}
-
-/** Object holding JWK keys */
-export interface JWKS {
-  /** Key set is JWKS format */
-  keys: Array<JWK>;
-}
-
-/** JWK key with custom claims */
-interface JWK extends JsonWebKey {
-  /** ID of the key */
-  kid: string;
-}

package/src/entities/KeySet/index.ts

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

package/src/entities/LifecycleController/LifecycleController.test.ts

@@ -1,48 +0,0 @@
-import { expect } from 'chai';
-import { Request, Response } from 'express';
-import { stub, SinonStub } from 'sinon';
-import { Endpoint, EndpointMethod, EndpointAuthType } from '../Endpoint';
-import { runningInstances } from './LifecycleController';
-import { Localizator } from 'entities/Localizator';
-import { redisClient } from 'entities/Redis/Redis';
-import { Server } from 'entities/Server';
-import { stubPubSub } from 'test';
-
-describe('Entity - LifecycleController', function () {
-  let localizatorShutdownStub: SinonStub;
-
-  beforeEach(() => {
-    stubPubSub();
-    stub(Localizator, 'synchronize').resolves();
-    localizatorShutdownStub = stub(Localizator, 'shutdown').resolves();
-  });
-
-  it('Shutdown the running entities', async () => {
-    const server = new Server({
-      endpoints: [
-        new Endpoint({
-          method: EndpointMethod.GET,
-          authType: EndpointAuthType.NONE,
-          validator: {},
-          path: '/',
-          handler: (req: Request, res: Response): void => {
-            res.json({ message: 'success' });
-          }
-        })
-      ],
-      initCallbacks: [
-        Localizator.init.bind(Localizator)
-      ]
-    });
-
-    await server.init();
-
-    // Redis will always have been init
-    expect([...runningInstances]).to.include(Localizator);
-
-    await server.shutdown();
-
-    expect(localizatorShutdownStub).to.have.been.calledOnce;
-    expect(redisClient).to.be.undefined;
-  });
-});

package/src/entities/LifecycleController/LifecycleController.ts

@@ -1,24 +0,0 @@
-import { LifecycleControlledInstance } from './LifecycleController.types';
-
-/**  List of initialized entities */
-export const runningInstances: Set<LifecycleControlledInstance> = new Set();
-
-/** LifecycleController is used to shutdown all the entities on server shutdown */
-export const LifecycleController = {
-  /** Add the initialized instances into the runningInstance property */
-  register(instance: LifecycleControlledInstance): void {
-    runningInstances.add(instance);
-  },
-
-  /** Shutdown all the running instances */
-  async shutdownRunningInstances(): Promise<void> {
-    const promises = [];
-    for (const instance of runningInstances) {
-      if (instance) {
-        promises.push(instance.shutdown.bind(instance)());
-      }
-    }
-    await Promise.all(promises);
-    runningInstances.clear();
-  }
-};

package/src/entities/LifecycleController/LifecycleController.types.ts

@@ -1,5 +0,0 @@
-/** Service instance that can be auto-shutdown by the Lifecycle Controller */
-export interface LifecycleControlledInstance {
-  /** Function that will be called on server shutdown, should trigger the instance cleanup */
-  shutdown: () => void | Promise<void>;
-}

package/src/entities/LifecycleController/index.ts

@@ -1,2 +0,0 @@
-export { LifecycleController } from './LifecycleController';
-export * from './LifecycleController.types';

package/src/entities/Localizator/Localizator.ts

@@ -1,139 +0,0 @@
-import { guessNamingConvention } from './guessNamingConvention';
-import {
-  LocalizatorLocalizationData,
-  LocalizatorLocalizationDataElement,
-  LocalizatorScripts,
-  LocalizatorNamingConventions
-} from './Localizator.types';
-import { EngineError } from 'entities/EngineError';
-import { LifecycleController } from 'entities/LifecycleController';
-import { Storage } from 'entities/Storage';
-import { checkEnvironment } from 'utils/checkEnvironment';
-import { envAssert } from 'utils/envAssert';
-import { reportError, reportDebug } from 'utils/report';
-
-const namespace = 'engine:localizator';
-
-const REFRESH_FREQUENCY = 10 * 60 * 1000;
-
-let localeData: undefined | LocalizatorLocalizationData;
-let scripts: undefined | LocalizatorScripts;
-let interval: NodeJS.Timeout | string | number | undefined;
-
-/** Service handling contextual localization */
-export const Localizator = {
-  async init(): Promise<void> {
-    checkEnvironment({ LOCALES_BUCKET: envAssert.isString() });
-    await Localizator.synchronize();
-    // Keep synchronizing
-    interval = setInterval(() => {
-      Localizator.synchronize().catch((error) => {
-        reportError(error);
-      });
-    }, REFRESH_FREQUENCY);
-    LifecycleController.register(Localizator);
-  },
-
-  /**
-   * Fetch a JSON file from the locales bucket
-   */
-  async getLocaleFile<T>(file: string): Promise<T> {
-    reportDebug({
-      namespace,
-      message: `Starting download of localization file [${file}]`,
-      data: { bucket: process.env.LOCALES_BUCKET, file }
-    });
-    const { data } = await Storage.get(
-      process.env.LOCALES_BUCKET as string,
-      file
-    );
-    const stringified = data.toString('utf-8');
-    const result = JSON.parse(stringified) as T;
-    reportDebug({
-      namespace,
-      message: `Fetched localization file [${file}]`,
-      data: { bucket: process.env.LOCALES_BUCKET, file, result }
-    });
-    return result;
-  },
-
-  /**
-   * Synchronizes the localeData and scripts files
-   * Should be called only once on startup
-   */
-  async synchronize(): Promise<void> {
-    reportDebug({ namespace, message: `Starting synchronizing` });
-    const [fetchedLocaleData, fetchedScripts] = await Promise.all([
-      Localizator.getLocaleFile<LocalizatorLocalizationData>('localeData.json'),
-      Localizator.getLocaleFile<LocalizatorScripts>('scripts.json')
-    ]);
-    localeData = fetchedLocaleData;
-    scripts = Localizator.buildRangeRegex(fetchedScripts);
-    reportDebug({ namespace, message: `Finished synchronizing` });
-  },
-
-  /** Transform unicode ranges in scripts data to regex */
-  buildRangeRegex(script: LocalizatorScripts): LocalizatorScripts {
-    for (const i of Object.keys(script)) {
-      const ranges = script[i].ranges;
-      if (ranges) {
-        script[i].rangeRegex = new RegExp(`[${ranges.join('')}]`, 'u');
-      }
-    }
-    return script;
-  },
-
-  /** Guess the naming convention to use for a given name and locale */
-  guessNamingConvention(
-    firstName: string,
-    lastName: string,
-    locale: string
-  ): LocalizatorNamingConventions {
-    if (!scripts || !localeData)
-      throw new EngineError({ message: 'Localizator is not initialized' });
-    const name = firstName + lastName; // merge two names if possible
-    return guessNamingConvention(scripts, localeData, name, locale);
-  },
-
-  /**
-   * Calculate the different display names for a user
-   */
-  getDisplayNames(
-    firstName: string,
-    lastName: string,
-    locale: string
-  ): LocalizatorNamingConventions {
-    const convention = Localizator.guessNamingConvention(
-      firstName,
-      lastName,
-      locale
-    );
-    return Object.keys(convention).reduce((convention, type) => {
-      const safeType = type as keyof LocalizatorNamingConventions;
-      convention[safeType] = convention[safeType]
-        .replace('{firstName}', firstName)
-        .replace('{lastName}', lastName ?? '')
-        .trim();
-      return convention;
-    }, convention);
-  },
-
-  /** Get the localization data for a locale */
-  getLocaleData(locale: string): LocalizatorLocalizationDataElement {
-    if (!localeData)
-      throw new EngineError({ message: 'Localizator is not initialized' });
-    return localeData[locale];
-  },
-
-  /** Check if a locale exists */
-  isValidLocale(locale: string): boolean {
-    if (!localeData)
-      throw new EngineError({ message: 'Localizator is not initialized' });
-    return localeData[locale] !== undefined;
-  },
-
-  /** Cleanup the instance */
-  shutdown(): void {
-    if (interval) clearTimeout(interval);
-  }
-};

package/src/entities/Localizator/Localizator.types.ts

@@ -1,52 +0,0 @@
-/** Defines how a name should be displayed for a locale in diferent context */
-export interface LocalizatorNamingConventions {
-  /** How the name is displayed in a common way */
-  regular: string;
-  /** How the name is displayed in a formal way */
-  formal: string;
-  /** How the name is displayed in a casual way */
-  casual: string;
-}
-
-/** Localization data for each of the locales  */
-export interface LocalizatorLocalizationData {
-  [locale: string]: LocalizatorLocalizationDataElement;
-}
-
-/** Describes localization settings for a locale */
-export interface LocalizatorLocalizationDataElement {
-  /** Is this locale available to the public */
-  enabled: boolean;
-  /** How this locale is displayed to the user */
-  display: string;
-  /** Configuration on how to display names in that locale */
-  names: {
-    /** Should the first name or the last name be displayed first */
-    firstNameFirst: boolean;
-    /** Is there a space between the two parts of the name */
-    spacing: boolean;
-    /** In case the user's name is not displayed in this language's script, how should it be displayed */
-    fallback?: LocalizatorNamingConventions;
-  };
-  /** Script used to identify text written in that language */
-  script?: string;
-  /** Key in google translation to identify that language */
-  cloudTranslationKey: string;
-  /** Unicode CLDR key to identify that language if it is different from the locale */
-  unicode?: string;
-}
-
-/** Script config data indexed by the script id */
-export interface LocalizatorScripts {
-  [script: string]: LocalizatorScript;
-}
-
-/** Localization config for a script */
-export interface LocalizatorScript {
-  /** Unicode range used to detect the script */
-  ranges: Array<string>;
-  /** How names are displayed when written in the script */
-  names: LocalizatorNamingConventions;
-  /** Regex added by the Localizator, used to match with the script unicode ranges */
-  rangeRegex?: RegExp;
-}

package/src/entities/Localizator/guessNamingConvention/guessNamingConvention.test.ts

@@ -1,165 +0,0 @@
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import {
-  LocalizatorScript,
-  LocalizatorLocalizationDataElement
-} from '../Localizator.types';
-import {
-  guessNamingConvention,
-  DEFAULT_NAMING_CONVENTION
-} from './guessNamingConvention';
-
-/** Generate fake script config */
-function generateScriptData(
-  overrides: Partial<LocalizatorScript> = {}
-): LocalizatorScript {
-  return {
-    rangeRegex: new RegExp(`^\b$`, 'u'),
-    ranges: ['a'],
-    names: {
-      casual: faker.lorem.slug(),
-      regular: faker.lorem.slug(),
-      formal: faker.lorem.slug()
-    },
-    ...overrides
-  };
-}
-
-/** Generate locales file random data */
-function generateLocalizationData(
-  overrides: Partial<LocalizatorLocalizationDataElement> = {}
-): LocalizatorLocalizationDataElement {
-  return {
-    script: faker.lorem.word(),
-    enabled: true,
-    display: faker.lorem.word(),
-    names: {
-      firstNameFirst: true,
-      spacing: true
-    },
-    cloudTranslationKey: faker.location.countryCode(),
-    ...overrides
-  };
-}
-
-describe('Service - Localizator - Guess naming convention', function () {
-  it('should return the convention for the locale specifc script', function () {
-    const locale = faker.location.country();
-    const userScript = faker.lorem.word();
-    const name = faker.lorem.word();
-    const scriptData = generateScriptData({
-      rangeRegex: new RegExp(name, 'u')
-    });
-
-    const Localizator = {
-      localeData: {
-        [faker.location.countryCode()]: generateLocalizationData(),
-        [locale]: generateLocalizationData({ script: userScript })
-      },
-      scripts: {
-        [faker.lorem.word()]: generateScriptData(),
-        [userScript]: scriptData
-      }
-    };
-    const result = guessNamingConvention(
-      Localizator.scripts,
-      Localizator.localeData,
-      name,
-      locale
-    );
-
-    expect(result).to.equal(scriptData.names);
-  });
-
-  it('should return the convention for the the script detected in the name if no match wirth the default script', function () {
-    const locale = faker.location.country();
-    const expectedResult = {
-      casual: faker.lorem.word(),
-      regular: faker.lorem.word(),
-      formal: faker.lorem.word()
-    };
-    const userScript = faker.lorem.word();
-    const name = faker.lorem.word();
-    const Localizator = {
-      localeData: {
-        [faker.location.countryCode()]: generateLocalizationData(),
-        [locale]: generateLocalizationData({ script: userScript })
-      },
-      scripts: {
-        [faker.lorem.word()]: generateScriptData(),
-        [userScript]: generateScriptData(),
-        [faker.lorem.word()]: generateScriptData({
-          rangeRegex: new RegExp(name, 'u'),
-          names: expectedResult
-        })
-      }
-    };
-    const result = guessNamingConvention(
-      Localizator.scripts,
-      Localizator.localeData,
-      name,
-      locale
-    );
-    expect(result).to.equal(expectedResult);
-  });
-
-  it('should return the convention for the locale if no script match', function () {
-    const locale = faker.location.country();
-    const expectedResult = {
-      casual: faker.lorem.word(),
-      regular: faker.lorem.word(),
-      formal: faker.lorem.word()
-    };
-    const userScript = faker.lorem.word();
-    const name = faker.lorem.word();
-    const Localizator = {
-      localeData: {
-        [faker.location.countryCode()]: generateLocalizationData({
-          script: faker.lorem.word()
-        }),
-        [locale]: generateLocalizationData({
-          script: userScript,
-          names: {
-            firstNameFirst: true,
-            spacing: true,
-            fallback: expectedResult
-          }
-        })
-      },
-      scripts: {
-        [faker.lorem.word()]: generateScriptData(),
-        [userScript]: generateScriptData()
-      }
-    };
-    const result = guessNamingConvention(
-      Localizator.scripts,
-      Localizator.localeData,
-      name,
-      locale
-    );
-    expect(result).to.equal(expectedResult);
-  });
-
-  it('should use the default if no fallback exist', function () {
-    const locale = faker.location.country();
-    const userScript = faker.lorem.word();
-    const name = faker.lorem.word();
-    const Localizator = {
-      localeData: {
-        [faker.location.countryCode()]: generateLocalizationData(),
-        [locale]: generateLocalizationData({ script: userScript })
-      },
-      scripts: {
-        [faker.lorem.word()]: generateScriptData(),
-        [userScript]: generateScriptData()
-      }
-    };
-    const result = guessNamingConvention(
-      Localizator.scripts,
-      Localizator.localeData,
-      name,
-      locale
-    );
-    expect(result).to.equal(DEFAULT_NAMING_CONVENTION);
-  });
-});