@transifex/express 2.4.1

package/.eslintrc.json

@@ -0,0 +1,8 @@
+{
+  "extends": ["airbnb-base"],
+  "rules": {
+    "import/no-extraneous-dependencies": "off",
+    "no-plusplus": "off",
+    "no-underscore-dangle": "off"
+  }
+}

package/README.md

@@ -0,0 +1,472 @@
+# Transifex Native integration for Express JS
+
+## Quick start
+
+Install the necessary express packages:
+
+```shell
+npm install --save express cookie-parser body-parser ...
+```
+
+And the Transifex Native integration:
+
+```shell
+npm install --save @transifex/native @transifex/express
+```
+
+Create an express app and attach the necessary middleware:
+
+```javascript
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const bodyParser = require('body-parser');
+
+const app = express();
+app.use(cookieParser());
+app.use(bodyParser.urlencoded({ extended: false }));
+```
+
+Import the Transifex Native libraries and set up:
+
+```javascript
+const { TxExpress } = require('@transifex/express');
+
+const txExpress = new TxExpress({ token: '...' });
+app.use(txExpress.middleware());
+app.post('/i18n', txExpress.setLocale());
+```
+
+> All options passed to the `TxExpress`'s constructor that are not handled by it
+> will be passed on to `tx.init` internally. If you have already initialized the
+> `tx` object, you do not have to supply these options.
+>
+> ```javascript
+> const txExpress = new TxExpress({
+>   // TxExpress options
+>   daemon: true,
+>   ttl: 2 * 60,
+>
+>   // tx options
+>   token: '...',
+>   filterTags: 'mytags',
+> });
+>
+> // is equivalent to
+>
+> const { tx } from '@transifex/native';
+> tx.init({ token: '...', filterTags: 'mytags' })
+> const txExpress = new TxExpress({ daemon: true, ttl: 2 * 60 });
+> ```
+
+Finally, fetch available languages and translations and start the server:
+
+```javascript
+txExpress.fetch().then(() => {
+  app.listen(3000, () => {
+    console.log('App listening on port 3000');
+  });
+});
+```
+
+### `txExpress.middleware()` middleware
+
+```javascript
+app.use(txExpress.middleware());
+```
+
+The middleware will make sure that you have a `req.t` function to translate the
+argument to the user's selected language.
+
+```javascript
+app.get('/', (req, res) => {
+  res.send(req.t('Hello world!'));
+});
+```
+
+The `t`-function has the same interface as `@transifex/native`'s `t`-function.
+So, you can pass all extra arguments, like this:
+
+```javascript
+app.get('/', (req, res) => {
+  res.send(req.t('Hello world!', { _context: 'foo', _tags: 'bar' }));
+});
+```
+
+The middleware will also make sure that any templates that are rendered by
+Express will have a `t`-function and a `tx` object in their context. The
+`t`-function will take care of translation (in the same way as `req.t` does)
+and the `tx` object holds a list of available languages and the currently
+selected language code (`tx.languages` and `tx.currentLocale` respectively).
+Using this, you can do:
+
+```javascript
+// index.js
+app.set('views', './views');
+app.set('view engine', 'pug');
+
+app.get('/', (req, res) => {
+  res.render('index.pug');
+});
+```
+
+
+```pug
+// views/index.pug
+html
+  body
+    form(method='POST' action='/i18n')
+      select(name='locale')
+        each locale in tx.languages
+          option(
+            value=locale.code
+            selected=locale.code === tx.currentLocale
+          )= locale.name
+      input(type='submit' value="Change language")
+    p= t('Hello World!')
+```
+
+This will render a language-select dropdown (with the list of languages
+dynamically fetched by Transifex Native) and a translated string.
+
+This (having `t` and `tx` available in the template's context) works regardless
+of which template engine is being used.
+
+### Escaping strings
+
+Normally, interpolating strings in HTML that is to be rendered by a browser can
+make your application vulnerable to XSS attacks. For this purpose, the
+`t`-function in the express integration (both `req.t` and the `t`-function that
+is available to the template's context) return the escaped version of the
+rendered string. If you are confident that your string is safe to use inside
+HTML or that your template engine takes care of escaping for you, then you must
+use `ut` (available both as `req.ut` and as the `ut` function in your
+templates). Also, be careful of double escaping:
+
+```javascript
+// index.js
+
+app.get('/', (req, res) => {
+  // This will send 'hello &lt;world&gt;' and it will appear as 'hello <world>'
+  // in the browser
+  res.send(req.t('hello <world>'));
+
+  // This will send 'hello <world>' and it is dangerous to show in the browser
+  res.send(req.ut('hello <world>'));
+})
+```
+
+```pug
+// views/index.pug
+
+// These will send 'hello &amp;lt;world&amp;gt;' and they will appear as
+// 'hello &lt;world&gt;' in the browser
+p #{t('hello <world>')}
+p= t('hello <world>')
+
+// These will send 'hello &lt;world&gt;' and they will appear as
+// 'hello <world>' in the browser
+p #{ut('hello <world>')}
+p= ut('hello <world>')
+
+// These will send 'hello &lt;world&gt;' and they will appear as
+// 'hello <world>' in the browser
+p !{t('hello <world>')}
+p!= t('hello <world>')
+
+// These will send 'hello <world>' and they are dangerous to show in the
+// browser
+p !{ut('hello <world>')}
+p!= ut('hello <world>')
+```
+
+### `txExpress.setLocale()` handler
+
+```javascript
+app.post('/i18n', txExpress.setLocale());
+```
+
+The `txExpress.setLocale()` endpoint handler (mapped to `/i18n` in the example)
+is used by the user to change their selected language. The form to make this
+happen could look like this:
+
+```html
+<form method="POST" action="/i18n">
+  <input type="hidden" name="next" value="/current_url" />
+  <select name="locale">
+    <option value="en">English</option>
+    <option value="el">Greek</option>
+    <option value="fr">French</option>
+  </select>
+  <input type="submit" value="change language" />
+</form>
+```
+
+The value of `next` will determine where the user will be redirected to after
+the form is submitted. If `next` is missing, then the user will be redirected
+to the value of `req.headers.referer` which is the page where the form
+originated from.
+
+If you make an AJAX POST request with a JSON Content-Type to this endpoint with
+a `locale` field, the server will respond with a `{"status": "success"}` reply,
+after having changed the user's selected language (it will be up to you to
+reload the page if you want to).
+
+## Modes
+
+The user's selected language can be saved and retrieved with a number of
+available modes:
+
+### Cookie (default)
+
+This saves the selected language on a cookie named after the value of 'options.name'.
+
+```javascript
+const { TxExpress, CookieMode } = require('@transifex/express');
+const txExpress = new TxExpress({
+  mode: CookieMode({ name: 'my-tx-cookie' }),
+});
+```
+
+It must be used alongside `cookie-parser`:
+
+```javascript
+const express = require('express');
+const bodyParser = require('body-parser');
+const app = express();
+app.use(bodyParser.urlencoded({ extended: false }));
+
+const cookieParser = require('cookie-parser');
+app.use(cookieParser());
+
+const { TxExpress, CookieMode } = require('@transifex/express');
+const txExpress = new TxExpress({
+  token: '...',
+  mode: CookieMode({ name: 'my-tx-cookie' }),
+});
+
+app.use(txExpress.middleware());
+app.post('/i18n', txExpress.setLocale());
+app.get('/', (req, res) => { res.send(req.t('Hello world!')); });
+```
+
+Also accepts the `cookieOptions` option which will be forwarded to `req.cookie()`.
+
+### Signed cookie
+
+This saves the selected language on a signed cookie named after the value of
+'options.name'.
+
+```javascript
+const { TxExpress, SignedCookieMode } = require('@transifex/express');
+const txExpress = new TxExpress({
+  mode: SignedCookieMode({ name: 'my-tx-cookie' }),
+});
+```
+
+It must be used alongside `cookie-parser` which needs to be supplied with a secret:
+
+```javascript
+const express = require('express');
+const bodyParser = require('body-parser');
+const app = express();
+app.use(bodyParser.urlencoded({ extended: false }));
+
+const cookieParser = require('cookie-parser');
+app.use(cookieParser('mysecret'));
+
+const { TxExpress, SignedCookieMode } = require('@transifex/express');
+const txExpress = new TxExpress({
+  token: '...',
+  mode: SignedCookieMode({ name: 'my-tx-cookie' }),
+});
+
+app.use(txExpress.middleware());
+app.post('/i18n', txExpress.setLocale());
+app.get('/', (req, res) => { res.send(req.t('Hello world!')); });
+```
+
+Also accepts the `cookieOptions` option which will be forwarded to `req.cookie()`.
+
+### Session
+
+This saves the selected language on a session variable named after the value of
+'options.name'.
+
+```javascript
+const { TxExpress, SessionMode } = require('@transifex/express');
+const txExpress = new TxExpress({
+  mode: SessionMode({ name: 'my-tx-cookie' }),
+});
+```
+
+It must be used alongside `express-session` or `cookie-session`:
+
+```javascript
+const express = require('express');
+const bodyParser = require('body-parser');
+const app = express();
+app.use(bodyParser.urlencoded({ extended: false }));
+
+const session = require('express-session');
+// or
+const cookieSession = require('cookie-session');
+
+app.use(session({ secret: 'mysecret', ... }));
+// or
+app.use(cookieSession({ keys: ['mysecret'], ... }));
+
+const { TxExpress, SessionMode } = require('@transifex/express');
+
+const txExpress = new TxExpress({
+  token: '...',
+  mode: SessionMode({ name: 'my-tx-cookie' }),
+});
+
+app.use(txExpress.middleware());
+app.post('/i18n', txExpress.setLocale());
+app.get('/', (req, res) => { res.send(req.t('Hello world!')); });
+```
+
+### Custom modes
+
+The values for the `mode` options are objects that implement the
+`setLocale(req, res, locale)` and `getLocale(req, res)` functions. You can
+easily implement your own. A sample implementation could look like this:
+
+```javascript
+const myMode = {
+  userLocales: {}, // User ID to selected locale map
+  setLocale(req, res, locale) {
+    this.userLocales[req.cookies.userId] = locale;
+  },
+  getLocale(req, res) {
+    return this.userLocales[req.cookies.userId];
+  },
+};
+
+const txExpress = new TxExpress({ mode: myMode });
+```
+
+## Extracting strings with `txjs-cli`
+
+The `txjs-cli` program from the `@transifex/cli` package will manage to extract
+invocations of the `req.t` function in your source code, as well as invocations
+of the `t` function in '.pug' and '.ejs' templates.
+
+```shell
+➜  npm install @transifex/cli
+
+➜  npx txjs-cli push views -v
+
+    Parsing all files to detect translatable content...
+    ✓ Processed 2 file(s) and found 2 translatable phrases.
+    ✓ Content detected in 2 file(s).
+    /views/index.ejs
+      └─ This string originated from a EJS file
+        └─ occurrences: ["/views/index.ejs"]
+    /views/index.pug
+      └─ This string originated from a PUG file
+        └─ occurrences: ["/views/index.pug"]
+
+    Uploading content to Transifex... Success
+    ✓ Successfully pushed strings to Transifex:
+      Created strings: 2
+```
+
+It is easy to enhance support for express template engines in `txjs-cli`,
+especially if the template engine in question works by converting a template to
+javascript code that can be then fed to the normal extraction process. In fact,
+this in the only piece of code that was needed in order to extend support to
+.pug and .ejs templates:
+
+```javascript
+// transifex-javascript/packages/cli/src/api/extract.js
+
+function extractPhrases(file, relativeFile, options = {}) {
+
+  // ...
+
+  let source = fs.readFileSync(file, 'utf8');
+
+  if (path.extname(file) === '.pug') {
+    source = pug.compileClient(source);
+  } else if (path.extname(file) === '.ejs') {
+    const template = new ejs.Template(source);
+    template.generateSource();
+    source = template.source;
+  }
+
+  // ...
+}
+```
+
+So, if your template engine of choice is not supported by `txjs-cli` yet,
+please consider contributing a pull request 😉.
+
+## API
+
+### TxExpress
+
+```javascript
+new TxExpress({
+
+  // How to save the selected language. Must implement the `setLocale(req, res,
+  // locale)` and `getLocale(req, res)` methods. Builtin modes: `CookieMode`,
+  // `SignedCookieMode`, `SessionMode`.
+  mode: Object,
+
+  // Whether to fall back to the request's 'Accept-Language' header (set by the
+  // browser) if the selected language isn't set, default: true
+  fallBackToAcceptLanguage: Boolean
+
+  // The locale to fall back to if both the mode and the 'Accept-Language'
+  // header fail to produce a result, default: 'en'
+  sourceLocale: String,
+
+  // If the server should periodically refetch translations from Transifex,
+  // default: true
+  daemon: Boolean,
+
+  // If daemon is true, how often to refetch translations in seconds, default:
+  // 10 minutes
+  ttl: Integer,
+
+  // How to display log messages; a straightforward option would be
+  // `console.log`, default: noop
+  logging: Function
+})
+```
+
+### CookieMode
+
+```javascript
+CookieMode({
+  // The name of the cookie to be used
+  name: String,
+
+  // Extra options passed to the `req.cookie()` function
+  cookieOptions: Object,
+});
+```
+
+### SignedCookieMode
+
+```javascript
+SignedCookieMode({
+  // The name of the cookie to be used
+  name: String,
+
+  // Extra options passed to the `req.cookie()` function; the `signed: true`
+  // option will always be set
+  cookieOptions: Object,
+});
+```
+
+### SessionMode
+
+```javascript
+SessionMode({
+  // The name of the session field to be used
+  name: String,
+});
+```

package/jest.config.js

@@ -0,0 +1,194 @@
+/*
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+module.exports = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/tmp/jest_rs",
+
+  // Automatically clear mock calls, instances and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: "v8",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // This option sets the URL for the jsdom environment. It is reflected in properties such as location.href
+  // testURL: "http://localhost",
+
+  // Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"
+  // timers: "real",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@transifex/express",
+  "version": "2.4.1",
+  "description": "Transifex Native for Express JS",
+  "keywords": [
+    "transifex",
+    "i18n",
+    "l10n",
+    "localization"
+  ],
+  "author": "Transifex",
+  "homepage": "https://github.com/transifex/transifex-javascript/tree/master/packages/express",
+  "license": "Apache-2.0",
+  "main": "src/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": "git://github.com/transifex/transifex-javascript.git",
+  "scripts": {
+    "lint": "eslint src/",
+    "build": "",
+    "test": "jest",
+    "publish-npm": "npm publish"
+  },
+  "bugs": {
+    "url": "https://github.com/transifex/transifex-javascript/issues"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "devDependencies": {
+    "@transifex/native": "^2.4.1",
+    "eslint": "^8.10.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.25.4",
+    "jest": "^27.5.1"
+  },
+  "dependencies": {
+    "type-is": "^1.6.18"
+  },
+  "peerDependencies": {
+    "@transifex/native": "^2.4.1"
+  }
+}

package/src/index.js

@@ -0,0 +1,180 @@
+const { tx, escape } = require('@transifex/native');
+const typeis = require('type-is');
+
+function CookieMode({ name = 'tx-locale', cookieOptions } = {}) {
+  return {
+    setLocale(req, res, locale) {
+      res.cookie(name, locale, cookieOptions);
+    },
+    getLocale(req) {
+      return req.cookies[name];
+    },
+  };
+}
+
+function SignedCookieMode({ name = 'tx-locale', cookieOptions } = {}) {
+  return {
+    setLocale(req, res, locale) {
+      res.cookie(name, locale, { ...cookieOptions, signed: true });
+    },
+    getLocale(req) {
+      return req.signedCookies[name];
+    },
+  };
+}
+
+function SessionMode({ name = 'tx-locale' } = {}) {
+  return {
+    setLocale(req, res, locale) {
+      req.session[name] = locale;
+    },
+    getLocale(req) {
+      return req.session[name];
+    },
+  };
+}
+
+function noop() {}
+
+class TxExpress {
+  constructor(options = {}) {
+    // https://www.kbairak.net/programming/python/2020/09/16/global-singleton-vs-instance-for-libraries.html
+    this.mode = CookieMode();
+    this.fallBackToAcceptLanguage = true;
+    this.sourceLocale = 'en';
+    this.daemon = true;
+    this.ttl = 10 * 60;
+    this.logging = noop;
+    this.setup(options);
+  }
+
+  setup({
+    mode,
+    fallBackToAcceptLanguage,
+    sourceLocale,
+    daemon,
+    ttl,
+    logging,
+    ...txOptions
+  } = {}) {
+    if (txOptions) {
+      tx.init(txOptions);
+    }
+    if (mode) {
+      this.mode = mode;
+    }
+    if (fallBackToAcceptLanguage !== undefined) {
+      this.fallBackToAcceptLanguage = fallBackToAcceptLanguage;
+    }
+    if (sourceLocale) {
+      this.sourceLocale = sourceLocale;
+    }
+    if (daemon !== undefined) {
+      this.daemon = daemon;
+    }
+    if (ttl) {
+      this.ttl = ttl;
+    }
+    if (logging) {
+      this.logging = logging;
+    }
+  }
+
+  middleware() {
+    return (req, res, next) => {
+      let locale = this.mode.getLocale(req, res);
+
+      if (
+        !locale
+        && this.fallBackToAcceptLanguage
+        && req.headers['accept-language']
+      ) {
+        // The header looks like: 'da, en-gb;q=0.8, en;'
+        // Locales without a 'q' value will be considered first, the rest will
+        // be sorted based on their q value. After sorting, we will use the
+        // first locale that is supported by Transifex Native.
+        const locales = req.headers['accept-language']
+          .split(',')
+          .map((section) => section.trim())
+          .map((section) => section.split(';'));
+        const localesWithoutQ = locales
+          .filter(([, q]) => !q)
+          .map(([code]) => code);
+        const localesWithQ = locales.filter(([, q]) => !!q)
+          .sort(([, left], [, right]) => (
+            parseFloat(right.substring(2)) - parseFloat(left.substring(2))
+          ))
+          .map(([code]) => code);
+        const finalLocales = localesWithoutQ.concat(localesWithQ);
+
+        for (let i = 0; i < finalLocales.length; i++) {
+          const current = finalLocales[i];
+          if (tx.locales.indexOf(current) !== -1) {
+            locale = current;
+            break;
+          }
+        }
+      }
+
+      if (!locale) { locale = this.sourceLocale; }
+
+      const ut = (...args) => tx.translateLocale(locale, ...args);
+      const t = (...args) => escape(ut(...args));
+
+      req.ut = ut;
+      req.t = t;
+
+      const oldRender = res.render.bind(res);
+      res.render = (view, locals, ...args) => {
+        const actualLocals = locals || {};
+        Object.assign(actualLocals, {
+          ut,
+          t,
+          tx: { languages: tx.languages, currentLocale: locale },
+        });
+        return oldRender(view, actualLocals, ...args);
+      };
+
+      next();
+    };
+  }
+
+  setLocale() {
+    return (req, res) => {
+      const locale = req.body.locale || this.sourceLocale;
+
+      this.mode.setLocale(req, res, locale);
+      if (typeis(req, ['json'])) {
+        res.json({ status: 'success' });
+      } else {
+        res.redirect(req.body.next || req.headers.referer);
+      }
+    };
+  }
+
+  async fetch() {
+    const _fetch = async () => {
+      await tx.getLocales();
+      for (let i = 0; i < tx.locales.length; i++) {
+        const locale = tx.locales[i];
+        /* eslint-disable no-await-in-loop */
+        await tx.fetchTranslations(locale);
+        /* eslint-enable */
+      }
+    };
+
+    this.logging('Transifex Native: fetching translations');
+    await _fetch();
+    this.logging('Transifex Native: done');
+    if (this.daemon) {
+      setInterval(_fetch, this.ttl * 1000);
+    }
+  }
+}
+
+module.exports = {
+  TxExpress,
+  CookieMode,
+  SignedCookieMode,
+  SessionMode,
+};

package/tests/express.test.js

@@ -0,0 +1,303 @@
+/* globals jest test expect */
+
+const typeis = require('type-is');
+
+const { tx } = require('@transifex/native');
+
+const {
+  TxExpress,
+  CookieMode,
+  SignedCookieMode,
+  SessionMode,
+} = require('../src');
+
+jest.mock('type-is');
+
+test('TxExpress default values', () => {
+  const txExpress = new TxExpress();
+
+  // Ideally this should work but the functions are not considered equal and we
+  // have no data members to compare
+  // expect(txExpress.mode).toEqual(CookieMode());
+
+  expect(txExpress.fallBackToAcceptLanguage).toBe(true);
+  expect(txExpress.sourceLocale).toBe('en');
+  expect(txExpress.daemon).toBe(true);
+  expect(txExpress.ttl).toBe(10 * 60);
+});
+
+test('TxExpress custom values', () => {
+  const customOptions = {
+    mode: 'other',
+    fallBackToAcceptLanguage: false,
+    sourceLocale: 'other',
+    daemon: false,
+    ttl: 3,
+    logging: 'other',
+  };
+  let txExpress = new TxExpress(customOptions);
+  expect(txExpress).toEqual(customOptions);
+
+  txExpress = new TxExpress();
+  txExpress.setup(customOptions);
+  expect(txExpress).toEqual(customOptions);
+});
+
+test('Middleware with cookies', () => {
+  const languages = [{ code: 'en', name: 'English' }, { code: 'fr', name: 'French' }];
+  tx.languages = languages;
+  tx.cache.update('fr', { foo: 'translation' });
+
+  const txExpress = new TxExpress({ mode: CookieMode({ name: 'tx-locale' }) });
+  const req = {
+    cookies: { 'tx-locale': 'fr' },
+    headers: {},
+  };
+  const res = {
+    render(view, locals) {
+      return [locals.t('foo', { _key: 'foo' }), locals.tx];
+    },
+  };
+  let nextCalled = false;
+  function next() { nextCalled = true; }
+
+  txExpress.middleware()(req, res, next);
+
+  expect(req.t('foo', { _key: 'foo' })).toBe('translation');
+  expect(res.render()).toEqual(['translation', { languages, currentLocale: 'fr' }]);
+  expect(nextCalled).toBe(true);
+});
+
+test('Middleware with signed cookies', () => {
+  const languages = [{ code: 'en', name: 'English' }, { code: 'fr', name: 'French' }];
+  tx.languages = languages;
+  tx.cache.update('fr', { foo: 'translation' });
+
+  const txExpress = new TxExpress({ mode: SignedCookieMode({ name: 'tx-locale' }) });
+  const req = {
+    signedCookies: { 'tx-locale': 'fr' },
+    headers: {},
+  };
+  const res = {
+    render(view, locals) {
+      return [locals.t('foo', { _key: 'foo' }), locals.tx];
+    },
+  };
+  let nextCalled = false;
+  function next() { nextCalled = true; }
+
+  txExpress.middleware()(req, res, next);
+
+  expect(req.t('foo', { _key: 'foo' })).toBe('translation');
+  expect(res.render()).toEqual(['translation', { languages, currentLocale: 'fr' }]);
+  expect(nextCalled).toBe(true);
+});
+
+test('Middleware with sessions', () => {
+  const languages = [{ code: 'en', name: 'English' }, { code: 'fr', name: 'French' }];
+  tx.languages = languages;
+  tx.cache.update('fr', { foo: 'translation' });
+
+  const txExpress = new TxExpress({ mode: SessionMode({ name: 'tx-locale' }) });
+  const req = {
+    session: { 'tx-locale': 'fr' },
+    headers: {},
+  };
+  const res = {
+    render(view, locals) {
+      return [locals.t('foo', { _key: 'foo' }), locals.tx];
+    },
+  };
+  let nextCalled = false;
+  function next() { nextCalled = true; }
+
+  txExpress.middleware()(req, res, next);
+
+  expect(req.t('foo', { _key: 'foo' })).toBe('translation');
+  expect(res.render()).toEqual(['translation', { languages, currentLocale: 'fr' }]);
+  expect(nextCalled).toBe(true);
+});
+
+test('Middleware falls back to header', () => {
+  const languages = [{ code: 'en', name: 'English' }, { code: 'fr', name: 'French' }];
+  tx.languages = languages;
+  tx.locales = ['en', 'fr'];
+  tx.cache.update('fr', { foo: 'translation' });
+
+  const txExpress = new TxExpress({ mode: CookieMode({ name: 'tx-locale' }) });
+  const req = {
+    cookies: {},
+    headers: { 'accept-language': 'de, en;q=0.6, fr;q=0.8' },
+  };
+  const res = {
+    render(view, locals) {
+      return [locals.t('foo', { _key: 'foo' }), locals.tx];
+    },
+  };
+  let nextCalled = false;
+  function next() { nextCalled = true; }
+
+  txExpress.middleware()(req, res, next);
+
+  expect(req.t('foo', { _key: 'foo' })).toBe('translation');
+  expect(res.render()).toEqual(['translation', { languages, currentLocale: 'fr' }]);
+  expect(nextCalled).toBe(true);
+});
+
+test('setLocale with cookie and form with next', () => {
+  typeis.mockReturnValue(false);
+
+  const txExpress = new TxExpress({ mode: CookieMode({ name: 'tx-locale' }) });
+  const req = {
+    body: { locale: 'fr', next: 'next' },
+  };
+  let redirectTo = '';
+  const res = {
+    cookies: {},
+    cookie(key, value) { this.cookies[key] = value; },
+    redirect(path) { redirectTo = path; },
+  };
+
+  txExpress.setLocale()(req, res);
+
+  expect(res.cookies).toEqual({ 'tx-locale': 'fr' });
+  expect(redirectTo).toBe('next');
+});
+
+test('setLocale with cookie and form without next', () => {
+  typeis.mockReturnValue(false);
+
+  const txExpress = new TxExpress({ mode: CookieMode({ name: 'tx-locale' }) });
+  const req = {
+    body: { locale: 'fr' },
+    headers: { referer: 'referer' },
+  };
+  let redirectTo = '';
+  const res = {
+    cookies: {},
+    cookie(key, value) { this.cookies[key] = value; },
+    redirect(path) { redirectTo = path; },
+  };
+
+  txExpress.setLocale()(req, res);
+
+  expect(res.cookies).toEqual({ 'tx-locale': 'fr' });
+  expect(redirectTo).toBe('referer');
+});
+
+test('setLocale with cookie and cookie options and form with next', () => {
+  typeis.mockReturnValue(false);
+
+  const txExpress = new TxExpress({
+    mode: CookieMode({ name: 'tx-locale', cookieOptions: { some: 'option' } }),
+  });
+  const req = {
+    body: { locale: 'fr', next: 'next' },
+  };
+  let cookieOptions = {};
+  let redirectTo = '';
+  const res = {
+    cookies: {},
+    cookie(key, value, options) {
+      this.cookies[key] = value;
+      cookieOptions = options;
+    },
+    redirect(path) { redirectTo = path; },
+  };
+
+  txExpress.setLocale()(req, res);
+
+  expect(res.cookies).toEqual({ 'tx-locale': 'fr' });
+  expect(cookieOptions).toEqual({ some: 'option' });
+  expect(redirectTo).toBe('next');
+});
+
+test('setLocale with cookie and json', () => {
+  typeis.mockReturnValue(true);
+
+  const txExpress = new TxExpress({ mode: CookieMode({ name: 'tx-locale' }) });
+  const req = {
+    body: { locale: 'fr' },
+  };
+  let jsonResponse = {};
+  const res = {
+    cookies: {},
+    cookie(key, value) { this.cookies[key] = value; },
+    json(data) { jsonResponse = data; },
+  };
+
+  txExpress.setLocale()(req, res);
+
+  expect(res.cookies).toEqual({ 'tx-locale': 'fr' });
+  expect(jsonResponse).toEqual({ status: 'success' });
+});
+
+test('setLocale with signed cookie and form with next', () => {
+  typeis.mockReturnValue(false);
+
+  const txExpress = new TxExpress({ mode: SignedCookieMode({ name: 'tx-locale' }) });
+  const req = {
+    body: { locale: 'fr', next: 'next' },
+  };
+  let cookieOptions = {};
+  let redirectTo = '';
+  const res = {
+    cookies: {},
+    cookie(key, value, options) {
+      this.cookies[key] = value;
+      cookieOptions = options;
+    },
+    redirect(path) { redirectTo = path; },
+  };
+
+  txExpress.setLocale()(req, res);
+
+  expect(res.cookies).toEqual({ 'tx-locale': 'fr' });
+  expect(cookieOptions).toEqual({ signed: true });
+  expect(redirectTo).toBe('next');
+});
+
+test('setLocale with session and form with next', () => {
+  typeis.mockReturnValue(false);
+
+  const txExpress = new TxExpress({ mode: SessionMode({ name: 'tx-locale' }) });
+  const req = {
+    session: {},
+    body: { locale: 'fr', next: 'next' },
+  };
+  let redirectTo = '';
+  const res = {
+    redirect(path) { redirectTo = path; },
+  };
+
+  txExpress.setLocale()(req, res);
+
+  expect(req.session).toEqual({ 'tx-locale': 'fr' });
+  expect(redirectTo).toBe('next');
+});
+
+test('t vs ut', () => {
+  const languages = [{ code: 'en', name: 'English' }, { code: 'fr', name: 'French' }];
+  tx.languages = languages;
+  tx.cache.update('fr', { foo: 'A <rich>string</rich>' });
+
+  const txExpress = new TxExpress();
+  const req = {
+    cookies: { 'tx-locale': 'fr' },
+    headers: {},
+  };
+  const res = {
+    render(view, locals) {
+      return [locals.t('foo', { _key: 'foo' }), locals.ut('foo', { _key: 'foo' })];
+    },
+  };
+
+  txExpress.middleware()(req, res, () => {});
+
+  expect(req.t('foo', { _key: 'foo' })).toBe('A &lt;rich&gt;string&lt;/rich&gt;');
+  expect(req.ut('foo', { _key: 'foo' })).toBe('A <rich>string</rich>');
+  expect(res.render()).toEqual([
+    'A &lt;rich&gt;string&lt;/rich&gt;',
+    'A <rich>string</rich>',
+  ]);
+});