Completely restructured project

Author: luca-vogels

.github/workflows/on-push.yml

@@ -0,0 +1,39 @@
+name: On Push
+on: [push]
+jobs:
+  build:
+    name: Building
+    runs-on: Linux
+    steps:
+      - name: Checking out repository
+        uses: actions/checkout@v3
+      - name: "Setup Node"
+        uses: actions/setup-node@v3
+        with:
+          node-version: '16'
+          cache: 'npm'
+      - name: Installing 
+        run: npm install -save --save-dev
+      - name: Building
+        run: npm run build
+      - name: Done
+        run: exit 0
+  
+  testing:
+    name: Testing
+    needs: build
+    runs-on: Linux
+    steps:
+      - name: "Setup Node"
+        uses: actions/setup-node@v3
+        with:
+          node-version: '16'
+          cache: 'npm'
+      - name: Installing 
+        run: npm install -save --save-dev
+      - name: Running linter
+        run: npm run lint
+      - name: Running tests
+        run:  npm run test
+      - name: Done
+        run: exit 0

.gitignore

@@ -1,2 +1,3 @@
 node_modules/
-lib/
+lib/
+coverage/

README.md

@@ -1,3 +1,8 @@
+![GitHub package.json version](https://img.shields.io/github/package-json/v/LupCode/node-lup-language)
+![npm bundle size](https://img.shields.io/bundlephobia/min/lup-language)
+![GitHub Workflow Status](https://img.shields.io/github/workflow/status/LupCode/node-lup-language/On%20Push)
+![NPM](https://img.shields.io/npm/l/lup-language)
+
 # lup-language
 Node express middleware for detecting requested language based on:
 1. URI prefix e.g. /**en**/home/

jestconfig.json

@@ -3,5 +3,6 @@
         "^.+\\.(t|j)sx?$": "ts-jest"
     },
     "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
-    "moduleFileExtensions": ["ts", "tsx", "js", "jsx", "json", "node"]
+    "moduleFileExtensions": ["ts", "tsx", "js", "jsx", "json", "node"],
+    "collectCoverage":true
 }

package-lock.json

@@ -39,7 +39,7 @@
   "homepage": "https://github.com/LupCode/node-lup-language#readme",
   "dependencies": {
     "fs": "0.0.1-security",
-    "lup-root": "^1.3.0"
+    "lup-root": "^1.3.2"
   },
   "devDependencies": {
     "@types/jest": "^27.5.0",

package.json

@@ -0,0 +1,69 @@
+import {ROOT} from 'lup-root';
+import * as lupLang from "../index";
+
+const TRANSLATIONS_DIR = ROOT+"src/__tests__/translations";
+
+test("Loading languages from translations directory", async() => {
+    await expect(lupLang.reloadTranslations(TRANSLATIONS_DIR)).resolves.not.toThrow();
+});
+
+
+describe("Checking loaded translations", () => {
+
+    beforeAll(async() => {
+        await lupLang.reloadTranslations(TRANSLATIONS_DIR);
+    });
+
+    test("Language codes correctly determined", async() => {
+        const languageNames = await lupLang.getLanguageNames(TRANSLATIONS_DIR);
+        expect(languageNames).toBeInstanceOf(Object);
+        const langs = Object.keys(languageNames);
+        expect(langs.length).toBe(2);
+        expect(langs).toContain("en");
+        expect(langs).toContain("de");
+    });
+
+    test("Load all translations if no translation keys are specified", async() => {
+        const TEXT = await lupLang.getTranslations("de", "en", [], TRANSLATIONS_DIR);
+        expect(TEXT).toBeInstanceOf(Object);
+        expect(Object.keys(TEXT).length).toBeGreaterThanOrEqual(3);
+    });
+
+    test("Only load specified translation keys", async() => {
+        const TEXT = await lupLang.getTranslations("de", "en", ["HelloWorld"], TRANSLATIONS_DIR);
+        expect(TEXT).toBeInstanceOf(Object);
+        expect(Object.keys(TEXT).length).toBe(1);
+        expect(TEXT['HelloWorld']).toBeDefined();
+    });
+
+    test("Provide translation key if no translation found", async() => {
+        const TEXT = await lupLang.getTranslations("de", "en", ["GoodNight"], TRANSLATIONS_DIR);
+        expect(TEXT).toBeInstanceOf(Object);
+        expect(TEXT['GoodNight']).toEqual("GoodNight");
+    });
+
+    test("Translation keys in correct language loaded", async() => {
+        const TEXT = await lupLang.getTranslations("de", "en", [], TRANSLATIONS_DIR);
+        expect(TEXT).toBeInstanceOf(Object);
+        expect(TEXT['HelloWorld']).toEqual("Hallo Welt");
+    });
+
+    test("Global variables loaded", async() => {
+        const TEXT = await lupLang.getTranslations("de", "en", [], TRANSLATIONS_DIR);
+        expect(TEXT).toBeInstanceOf(Object);
+        expect(TEXT['NAME']).toEqual("lup-language");
+    });
+
+    test("Language specific translations can overwrite global variables", async() => {
+        const TEXT = await lupLang.getTranslations("de", "en", [], TRANSLATIONS_DIR);
+        expect(TEXT).toBeInstanceOf(Object);
+        expect(TEXT['OverwriteMe']).toEqual("Hab ich gemacht");
+    });
+
+});
+
+
+test("Load HTML file async", async() => {
+    const content = await lupLang.getTranslationFileContent("./html/test-de.html", TRANSLATIONS_DIR);
+    expect(content.indexOf("Hallo Welt")).toBeGreaterThan(-1);
+});

src/__tests__/Basic.test.ts

@@ -0,0 +1,73 @@
+import {ROOT} from 'lup-root';
+import { DEFAULT_COOKIE_NAME, DEFAULT_LANGUAGE, DEFAULT_REQUEST_LANGUAGE_ATTR, DEFAULT_REQUEST_PROCESSED_PATH_ATTR, DEFAULT_REQUEST_TRANSLATIONS_ATTR, LanguageRouter } from '../index';
+
+const TRANSLATIONS_DIR = ROOT+"src/__tests__/translations";
+
+
+var handle: Function;
+beforeAll(async() => {
+  handle = await LanguageRouter({
+    translationsDir: TRANSLATIONS_DIR
+  });
+});
+
+
+const emulateRequestResponse = function(url: string, langCookieValue: string | null, acceptLangHeader: string | null): [req: any, res: any, exec: Function]{
+  const req: any = new Object();
+  req.url = url;
+  req.headers = {};
+  if(acceptLangHeader) req.headers["accept-language"] = acceptLangHeader;
+  if(langCookieValue) req.headers['cookie'] = DEFAULT_COOKIE_NAME+"="+langCookieValue;
+
+  const res: any = new Object();
+  res.get = (key: string) => res[key];
+  res.set = (key: string, value: any) => res[key] = value;
+
+  return [req, res, function(){
+    handle(req, res);
+  }];
+}
+
+
+test("LanguageRouter valid handle", () => {
+  expect(handle).not.toBeNull();
+  expect(handle).toBeInstanceOf(Function);
+});
+
+test("Detect correct language from URI", () => {
+  const [req, _res, exec] = emulateRequestResponse("/de/hello", "en", null);
+  expect(exec).not.toThrow();
+  expect(req[DEFAULT_REQUEST_LANGUAGE_ATTR]).toBe("de");
+});
+
+test("Detect correct language from cookie", () => {
+  const [req, _res, exec] = emulateRequestResponse("/hello", "de", null);
+  expect(exec).not.toThrow();
+  expect(req[DEFAULT_REQUEST_LANGUAGE_ATTR]).toBe("de");
+});
+
+test("Detect correct language from HTTP Accept-Language header field", () => {
+  const [req, _res, exec] = emulateRequestResponse("/hello", null, "de");
+  expect(exec).not.toThrow();
+  expect(req[DEFAULT_REQUEST_LANGUAGE_ATTR]).toBe("de");
+});
+
+test("Fallback to default language if no language detected", () => {
+  const [req, _res, exec] = emulateRequestResponse("/hello", null, null);
+  expect(exec).not.toThrow();
+  expect(req[DEFAULT_REQUEST_LANGUAGE_ATTR]).toBe(DEFAULT_LANGUAGE);
+});
+
+test("Translations attribute set", () => {
+  const [req, _res, exec] = emulateRequestResponse("/de/hello", null, null);
+  expect(exec).not.toThrow();
+  expect(req[DEFAULT_REQUEST_TRANSLATIONS_ATTR]).toBeDefined();
+  expect(req[DEFAULT_REQUEST_TRANSLATIONS_ATTR]['HelloWorld']).toEqual("Hallo Welt");
+});
+
+test("Path attribute set", () => {
+  const [req, _res, exec] = emulateRequestResponse("/de/hello?test", null, null);
+  expect(exec).not.toThrow();
+  expect(req[DEFAULT_REQUEST_PROCESSED_PATH_ATTR]).toBeDefined();
+  expect(req[DEFAULT_REQUEST_PROCESSED_PATH_ATTR]).toEqual("/hello");
+});

src/__tests__/LanguageRouter.test.ts

@@ -0,0 +1,4 @@
+{
+    "HelloWorld": "Hallo Welt",
+    "OverwriteMe": "Hab ich gemacht"
+}

src/__tests__/translations/de.json

@@ -0,0 +1,4 @@
+{
+    "HelloWorld": "Hello World",
+    "OverwriteMe": "Did it"
+}

src/__tests__/translations/en.json

@@ -0,0 +1,4 @@
+{
+    "NAME": "lup-language",
+    "OverwriteMe": "Overwrite me"
+}

src/__tests__/translations/globals.json

@@ -0,0 +1,5 @@
+<html>
+    <body>
+        <h1>Hallo Welt</h1>
+    </body>
+</html>

src/__tests__/translations/html/test-de.html

@@ -0,0 +1,5 @@
+<html>
+    <body>
+        <h1>Hello World</h1>
+    </body>
+</html>

src/__tests__/translations/html/test-en.html

@@ -63,7 +63,7 @@ const DICTONARY: any = {}; // { translationsDir: {lang: {key: translation} } }
  * @param {String} translationsDir Relative path to directory containing JSON files with translations
  * @returns Promise that resolves with a list of language codes that where found after translations have been reloaded from files
  */
-export const reloadTranslations = async (translationsDir: string = DEFAULT_TRANSLATIONS_DIR): Promise<void> => {
+export const reloadTranslations = async (translationsDir: string = DEFAULT_TRANSLATIONS_DIR): Promise<string[]> => {
   if (!translationsDir) translationsDir = DEFAULT_TRANSLATIONS_DIR;
   LANGUAGES[translationsDir] = [];
   DICTONARY[translationsDir] = [];
@@ -135,7 +135,7 @@ const _getTranslations = (
   defaultLang: string,
   translationKeys: string[] | false,
   translationsDir: string = DEFAULT_TRANSLATIONS_DIR,
-) => {
+): {[key: string]: string} => {
   translationKeys = !translationKeys || translationKeys.length === 0 ? false : translationKeys;
   const dictornary = DICTONARY[translationsDir]
     ? DICTONARY[translationsDir][lang] || DICTONARY[translationsDir][defaultLang] || {}
@@ -156,9 +156,9 @@ const _getTranslations = (
 export const getTranslations = async (
   lang: string,
   defaultLang: string,
-  translationKeys = [],
+  translationKeys: string[] = [],
   translationsDir: string = DEFAULT_TRANSLATIONS_DIR,
-): Promise<{}> => {
+): Promise<{[key: string]: string}> => {
   if (!translationsDir) translationsDir = DEFAULT_TRANSLATIONS_DIR;
   if (!DICTONARY[translationsDir]) await reloadTranslations(translationsDir);
   return _getTranslations(lang, defaultLang, translationKeys, translationsDir);
@@ -169,7 +169,7 @@ export const getTranslations = async (
  * Looksup following keys in the translations 'LANGUAGE_NAME_<lang>'
  * @returns {<lang>: "<native name>"}
  */
-export const getLanguageNames = async (translationsDir: string = DEFAULT_TRANSLATIONS_DIR): Promise<{}> => {
+export const getLanguageNames = async (translationsDir: string = DEFAULT_TRANSLATIONS_DIR): Promise<Object> => {
   if (!translationsDir) translationsDir = DEFAULT_TRANSLATIONS_DIR;
   if (!DICTONARY[translationsDir]) await reloadTranslations(translationsDir);
 
@@ -248,7 +248,7 @@ export const getTranslationFileContentSync = (
  *                              (if not defined 'DEFAULT_REQUEST_PROCESSED_PATH_ATTR' will be used) <br>
  * @returns function(req, res, next) that is designed for being set as middleware to pre-handle incoming requests
  */
-export const LanguageRouter = (
+export const LanguageRouter = async(
   options: any = {
     default: DEFAULT_LANGUAGE,
     languages: DEFAULT_LANGUAGES,
@@ -302,13 +302,11 @@ export const LanguageRouter = (
   const languages = new Set(languagesArr);
 
   if (loadTranslations) {
-    reloadTranslations(translationsDir).then((ls: any) => {
-      if (!languagesFromTranslations) return;
-      for (const l of ls) languages.add(l);
-    });
+    const ls = await reloadTranslations(translationsDir);
+    if (languagesFromTranslations) for (const l of ls) languages.add(l);
   }
 
-  return (req: any, res: any, next: any) => {
+  return (req: any, res: any, next?: any) => {
     // Parse URI
     let lang = useUri ? req.url : false;
     if (lang) {
@@ -389,7 +387,7 @@ export const LanguageRouter = (
 
     if (loadTranslations) req[translationsAttr] = _getTranslations(lang, defaultLang, [], translationsDir);
 
-    next();
+    if(next) next();
   };
 };