npm package: @gluuten/i18next-gluuten-backend
Description: i18next-gluuten-backend is a backend layer for i18next to use gluuten service which can be used in node.js, in the browser and for deno.
Author: Gratify
Latest version: 0.9.1

This is an i18next backend to be used for [gluuten](http://gluuten.com) service. It will load resources from gluuten server using xhr.

It will allow you to save missing keys containing both **default value** and **context information** by calling:

```js
i18next.t(key, defaultValue, tDescription);
i18next.t(key, { defaultValue, tDescription });
```

# Troubleshooting

**SaveMissing is not working**

Per default only `localhost` is allowed to send them (to avoid you're using this feature accidentally in production. If you're not using `localhost` during development you will have to set the `allowedAddOrUpdateHosts: ['localhost']` for the [backend options](https://github.com/gluuten/i18next-gluuten-backend#backend-options).

# Getting started

Source can be loaded via [npm](https://www.npmjs.com/package/i18next-gluuten-backend), bower or [downloaded](https://cdn.rawgit.com/gluuten/i18next-gluuten-backend/master/i18nextGluutenBackend.min.js) from this repo.

```bash
# npm package
$ npm install @gluuten/i18next-gluuten-backend

# bower
$ bower install @gluuten/i18next-gluuten-backend
```

Wiring up:

```js
import i18next from 'i18next';
import Gluuten from '@gluuten/i18next-gluuten-backend';
// or
const i18next = require('i18next');
const Gluuten = require('@gluuten/i18next-gluuten-backend');

i18next.use(Gluuten).init(i18nextOptions);
```

- As with all modules you can either pass the constructor function (class) to the i18next.use or a concrete instance.
- If you don't use a module loader it will be added to `window.i18nextGluutenBackend`

## Backend Options

**IMPORTANT** make sure you do not add your apiKey in the production build to avoid misuse by strangers

```js
{
  // the id of your gluuten project
  projectId: '[PROJECTID]',

  // add an api key if you want to send missing keys
  apiKey: '[APIKEY]',

  // the reference language of your project
  referenceLng: '[LNG]',

  // version - defaults to latest
  version: '[VERSION]',

  // private - set to true if you version on gluuten is set to use private publish
  private: false,

  // hostnames that are allowed to create, update keys
  // please keep those to your local system, staging, test servers (not production)
  // can be array of allowed hosts or a function (hostname) => { return true; // or false if not allowed }
  allowedAddOrUpdateHosts: ['localhost'],

  // optional event triggered on saved to backend
  onSaved: (lng, ns) => { ... }
}
```

To load translations only `projectId` needs to be filled. To use the **saveMissing** feature of i18next additional to the projectId both `apiKey` and `referenceLng` have to be set.

Options can be passed in:

**preferred** - by setting options.backend in i18next.init:

```js
import i18next from "i18next";
import Gluuten from "@gluuten/i18next-gluuten-backend";

i18next.use(Gluuten).init({
  backend: options
});
```

on construction:

```js
import Gluuten from "@gluuten/i18next-gluuten-backend";
const gluuten = new Gluuten(options);
```

via calling init:

```js
import Gluuten from "@gluuten/i18next-gluuten-backend";
const gluuten = new Gluuten();
gluuten.init(options);
```

## Additional API endpoints

### backend.getLanguages

Will return a list of all languages in your project including percentage of translations done per version.

```js
import Gluuten from "@gluuten/i18next-gluuten-backend";
const gluuten = new Gluuten(options);

gluuten.getLanguages((err, data) => {
  /*
  data is:

  {
    "en": {
      "name": "English",
      "nativeName": "English",
      "isReferenceLanguage": true,
      "translated": {
        "latest": 1
      }
    },
    "de": {
      "name": "German",
      "nativeName": "Deutsch",
      "isReferenceLanguage": false,
      "translated": {
        "latest": 0.9
      }
    }
  }
  */
});

// or
i18next.services.backendConnector.backend.getLanguages(callback);
```

### backend.getOptions

Will return an object containing useful informations for the i18next init options.

```js
import Gluuten from "@gluuten/i18next-gluuten-backend";
const gluuten = new Gluuten(options);

gluuten.getOptions((err, data) => {
  /*
  data is:

  {
    fallbackLng: 'en',
    referenceLng: 'en',
    supportedLngs: ['en', 'de'],
    load: 'languageOnly|all' // depending on your supportedLngs has locals having region like en-US
  }
  */
});

// or
i18next.services.backendConnector.backend.getOptions(callback);
```

You can set a threshold for languages to be added to supportedLngs by setting translatedPercentageThreshold in backend options (eg: 1 = 100% translated, 0.9 = 90% translated).

## SPECIAL - let the backend determine some options to improve loading

You can load some information from the backend to eg. set supportedLngs for i18next just supporting languages you got in your gluuten project.

You will get i18next options for (same as above backend.getOptions):

- fallbackLng
- supportedLngs
- load

```js
import i18next from "i18next";
import Gluuten from "@gluuten/i18next-gluuten-backend";

const gluuten = new Gluuten(
  {
    projectId: "[PROJECTID]",
    apiKey: "[APIKEY]",
    version: "[VERSION]"
    // referenceLng -> not needed as will be loaded from API
  },
  (err, opts) => {
    i18next.use(gluuten).init({ ...opts, ...yourOptions }); // yourOptions should not include backendOptions!
  }
);
```

## IMPORTANT ADVICE FOR SERVERLESS environments - AWS lambda, Google Cloud Functions, Azure Functions, etc...

<font color="red">
  <b>Please be aware</b>
</font>

Due to how serverless functions work, you cannot guarantee that a cached version of your data is available. Serverless functions are short-lived, and can shut down at any time, purging any in-memory or filesystem cache. This may be an acceptable trade-off, but sometimes it isn't acceptable.

**Because of this we suggest to download the translations in your CI/CD pipeline (via [cli](https://github.com/gluuten/gluuten-cli#download-current-published-files) or via [api](https://docs.gluuten.com/integration/api#list-all-namespace-resources)) and package them with your serverless function.**

### For example with [i18next-fs-backend](https://github.com/i18next/i18next-fs-backend)

```js
import i18next from 'i18next';
import Backend from 'i18next-fs-backend';

const backend = new Backend({
  // path where resources get loaded from
  loadPath: '/locales/{{lng}}/{{ns}}.json'
});

i18next
  .use(backend)
  .init({
    // initImmediate: false, // setting initImediate to false, will load the resources synchronously
    ...opts,
    ...yourOptions
  }); // yourOptions should not include backendOptions!
```

### or just [import/require](https://www.i18next.com/how-to/add-or-load-translations#add-on-init) your files directly

```js
import i18next from 'i18next';
import en from './locales/en.json'
import de from './locales/de.json'

i18next
  .init({
    ...opts,
    ...yourOptions,
    resources: {
      en,
      de
    }
  });
```