node-server-engine 1.1.2 → 1.1.4

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

@@ -1,48 +1,48 @@
-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;
-  });
-});
+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 +1,24 @@
-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();
-  }
-};
+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 +1,5 @@
-/** 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>;
-}
+/** 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 +1,2 @@
-export { LifecycleController } from './LifecycleController';
-export * from './LifecycleController.types';
+export { LifecycleController } from './LifecycleController';
+export * from './LifecycleController.types';

package/src/entities/Localizator/Localizator.ts

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