@things-factory/i18n-base 8.0.0-beta.9 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/i18n-base",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,9 +27,9 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@operato/i18n": "^8.0.0-beta",
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/shell": "^8.0.0-beta.9"
+    "@operato/i18n": "^8.0.0",
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/shell": "^8.0.0"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/apis/index.ts

@@ -0,0 +1 @@
+export * from './t'

package/server/apis/t.ts

@@ -0,0 +1,36 @@
+import { getRepository } from '@things-factory/shell'
+
+import { Terminology } from '../service/terminology/terminology'
+
+export type T_Arugments = {
+  key: String
+  locale: String
+  options?: Object
+}
+
+export async function t({ key, locale = 'en-US', options }: T_Arugments) {
+  let value = await getTerminology({
+    key,
+    locale
+  })
+
+  return value
+}
+
+async function getTerminology({ key, locale }) {
+  const repo = getRepository(Terminology)
+  var value
+  try {
+    let term = await repo.findOne({
+      where: {
+        name: key,
+        locale
+      }
+    })
+    value = term.display
+  } catch (e) {
+    value = key
+  }
+
+  return value
+}

package/server/controllers/clear-cache-for-translation.ts

@@ -0,0 +1,18 @@
+import { config } from '@things-factory/env'
+
+const disableCustomTerminologyFeature = config.get('i18n/disableCustomTerminologyFeature')
+
+const path = require('path')
+var fs = require('fs')
+
+export function clearTranslationCacheForCertainDomain(subdomain: string) {
+  if (disableCustomTerminologyFeature) {
+    return
+  }
+
+  const cacheFileFolder = path.join('cache', 'translations', subdomain)
+
+  if (fs.existsSync(cacheFileFolder)) {
+    fs.rmSync(cacheFileFolder, { recursive: true })
+  }
+}

package/server/index.ts

@@ -0,0 +1,6 @@
+import './routes'
+
+export * from './service'
+export * from './apis'
+export * from './middlewares'
+export * from './controllers/clear-cache-for-translation.js'

package/server/middlewares/index.ts

@@ -0,0 +1,36 @@
+import fs from 'fs'
+import i18next from 'i18next'
+
+import koaI18next from './koa-i18next'
+import { build } from './translations'
+
+i18next.init({
+  debug: false,
+  ns: ['translations'],
+  defaultNS: 'translations',
+  preload: ['ko', 'en', 'jp', 'zh', 'ms'],
+  fallbackLng: 'en',
+  interpolation: {
+    prefix: '{',
+    suffix: '}'
+  },
+  load: 'languageOnly',
+  keySeparator: false
+})
+
+build(fs)
+
+process.on('client-rebuilt' as any, (app, fs) => {
+  /* rebuild once done webpacking assets. only for development mode. */
+  build(fs)
+})
+
+export function initMiddlewares(app: any) {
+  app.use(
+    koaI18next(i18next, {
+      lookupCookie: 'i18next',
+      order: ['cookie', 'header'],
+      next: true // if koa is version 2
+    })
+  )
+}

package/server/middlewares/koa-i18next/detect.ts

@@ -0,0 +1,108 @@
+const DEFAULT_ORDER = ['querystring', 'cookie', 'header']
+
+const detectors = {
+  cookie: function (context, options) {
+    let cookie = options.lookupCookie || 'i18next'
+    return context.cookies.get(cookie)
+  },
+
+  // fork from i18next-express-middleware
+  header: function (context) {
+    let acceptLanguage = context.get('accept-language')
+    let found
+    let locales = []
+    if (acceptLanguage) {
+      let lngs = []
+
+      // associate language tags by their 'q' value (between 1 and 0)
+      acceptLanguage.split(',').forEach(function (l) {
+        let parts = l.split(';') // 'en-GB;q=0.8' -> ['en-GB', 'q=0.8']
+
+        // get the language tag qvalue: 'q=0.8' -> 0.8
+        let qvalue = 1 // default qvalue
+
+        for (let i = 0; i < parts.length; i++) {
+          let part = parts[i].split('=')
+          if (part[0] === 'q' && !isNaN(part[1])) {
+            qvalue = Number(part[1])
+            break
+          }
+        }
+        // add the tag and primary subtag to the qvalue associations
+        lngs.push({
+          lng: parts[0],
+          q: qvalue
+        })
+      })
+
+      lngs.sort(function (a, b) {
+        return b.q - a.q
+      })
+
+      for (let i = 0; i < lngs.length; i++) {
+        locales.push(lngs[i].lng)
+      }
+
+      if (locales.length) found = locales
+    }
+
+    return found
+  },
+  path: function (context, options) {
+    let found
+
+    if (options.lookupPath !== undefined && context.params) {
+      found = context.params[options.lookupPath]
+    }
+
+    if (!found && options.lookupFromPathIndex !== undefined) {
+      let parts = context.path.split('/')
+      if (parts[0] === '') {
+        // Handle paths that start with a slash, i.e., '/foo' -> ['', 'foo']
+        parts.shift()
+      }
+
+      if (parts.length > options.lookupFromPathIndex) {
+        found = parts[options.lookupFromPathIndex]
+      }
+    }
+    return found
+  },
+  querystring: function (context, options) {
+    let name = options.lookupQuerystring || 'lng'
+    return context.query[name]
+  },
+
+  session: function (context, options) {
+    let name = options.lookupSession || 'lng'
+    return context.session && context.session[name]
+  }
+}
+
+export default function (context, options = {}) {
+  let { order, fallback } = options as any
+  order = order && Array.isArray(order) ? order : DEFAULT_ORDER
+
+  let lngs = []
+
+  for (let i = 0, len = order.length; i < len; i++) {
+    let detector = detectors[order[i]]
+    let lng
+    if (detector) {
+      lng = detector(context, options)
+    }
+    if (lng && typeof lng === 'string') {
+      lngs.push(lng)
+    } else {
+      lngs = lngs.concat(lng)
+    }
+  }
+  let found
+  for (let i = 0, len = lngs.length; i < len; i++) {
+    let cleanedLng = context.i18next.services.languageUtils.formatLanguageCode(lngs[i])
+    if (context.i18next.services.languageUtils.isSupportedCode(cleanedLng)) found = cleanedLng
+    if (found) break
+  }
+
+  return found || fallback
+}

package/server/middlewares/koa-i18next/index.ts

@@ -0,0 +1,142 @@
+import detect from './detect'
+
+import { config } from '@things-factory/env'
+
+const disableUserFavoredLanguage = config.get('i18n/disableUserFavoredLanguage', false)
+const defaultLanguage = config.get('i18n/defaultLanguage', 'en-US')
+
+export default function koaI18next(i18next, options = {} as any) {
+  return async function i18nextMiddleware(ctx, next) {
+    ctx.i18next = i18next
+
+    let lng = disableUserFavoredLanguage ? defaultLanguage : detect(ctx, options)
+    lng && setLanguage(ctx, lng, options)
+
+    ctx.t = function (...args) {
+      // do detect path
+      if (!lng && isDetectPath(options.order)) {
+        lng = detect(ctx, Object.assign(options, { order: ['path'] }))
+        lng && setLanguage(ctx, lng, options)
+      }
+
+      if (args.length === 1) {
+        args.push({})
+      }
+
+      for (let i = 0, len = args.length; i < len; i++) {
+        let arg = args[i]
+        if (typeof arg === 'object' && !Array.isArray(arg)) {
+          arg.lng = lng
+        }
+      }
+      return i18next.t.apply(i18next, args)
+    }
+
+    await next()
+  }
+}
+
+function setPath(object, path, newValue) {
+  let stack
+  if (typeof path !== 'string') stack = [].concat(path)
+  if (typeof path === 'string') stack = path.split('.')
+
+  while (stack.length > 1) {
+    let key = stack.shift()
+    if (key.indexOf('###') > -1) key = key.replace(/###/g, '.')
+    if (!object[key]) object[key] = {}
+    object = object[key]
+  }
+
+  let key = stack.shift()
+  if (key.indexOf('###') > -1) key = key.replace(/###/g, '.')
+  object[key] = newValue
+}
+
+koaI18next.getResourcesHandler = function (i18next, options) {
+  options = options || {}
+  let maxAge = options.maxAge || 60 * 60 * 24 * 30
+  const propertyParam = options.propertyParam || 'query'
+
+  return async function (ctx, next) {
+    if (options.path && ctx.path !== options.path) {
+      return await next()
+    }
+    if (!i18next.services.backendConnector) return ctx.throw(404, 'koa-i18next-middleware:: no backend configured')
+
+    let resources = {}
+
+    ctx.type = 'json'
+    if (options.cache !== undefined ? options.cache : process.env.NODE_ENV === 'production') {
+      ctx.set('Cache-Control', 'public, max-age=' + maxAge)
+      ctx.set('Expires', new Date(new Date().getTime() + maxAge * 1000).toUTCString())
+    } else {
+      ctx.set('Pragma', 'no-cache')
+      ctx.set('Cache-Control', 'no-cache')
+    }
+
+    let languages = ctx[propertyParam][options.lngParam || 'lng']
+      ? ctx[propertyParam][options.lngParam || 'lng'].split(' ')
+      : []
+    let namespaces = ctx[propertyParam][options.nsParam || 'ns']
+      ? ctx[propertyParam][options.nsParam || 'ns'].split(' ')
+      : []
+
+    // extend ns
+    namespaces.forEach(ns => {
+      if (i18next.options.ns && i18next.options.ns.indexOf(ns) < 0) i18next.options.ns.push(ns)
+    })
+
+    i18next.services.backendConnector.load(languages, namespaces, function () {
+      languages.forEach(lng => {
+        namespaces.forEach(ns => {
+          setPath(resources, [lng, ns], i18next.getResourceBundle(lng, ns))
+        })
+      })
+      ctx.body = resources
+    })
+  }
+}
+
+koaI18next.getMissingKeyHandler = function (i18next, options) {
+  options = options || {}
+  const propertyParam = options.propertyParam || 'query'
+
+  return async function (ctx, next) {
+    if (options.path && ctx.path !== options.path) {
+      return await next()
+    }
+    let lng = ctx[propertyParam][options.lngParam || 'lng']
+    let ns = ctx[propertyParam][options.nsParam || 'ns']
+
+    if (!i18next.services.backendConnector) return ctx.throw(404, 'koa-i18next-middleware:: no backend configured')
+
+    for (var m in ctx.request.body) {
+      i18next.services.backendConnector.saveMissing([lng], ns, m, ctx.request.body[m])
+    }
+    ctx.body = 'ok'
+  }
+}
+
+function isDetectPath(order = []) {
+  return order.indexOf('path') !== -1
+}
+
+function setLanguage(context, lng, options = {} as any) {
+  const { lookupCookie, lookupPath, lookupSession } = options
+  context.locals = Object.assign(context.locals || {}, { lng })
+  context.state = Object.assign(context.state || {}, { lng })
+  context.language = context.lng = lng
+  context.set('content-language', lng)
+
+  if (lookupCookie) {
+    context.cookies.set(lookupCookie, lng, {
+      httpOnly: false,
+      signed: false,
+      sameSite: 'strict'
+    })
+  }
+  if (lookupSession && context.session) {
+    context.session[lookupSession] = lng
+  }
+}

package/server/middlewares/translations.ts

@@ -0,0 +1,27 @@
+import FS from 'fs'
+import i18next from 'i18next'
+import path from 'path'
+
+const { appRootPath } = require('@things-factory/env')
+
+export function build(fs) {
+  fs = fs || FS
+
+  const PUBLIC_ROOT = path.resolve(appRootPath, 'dist-app') // webpack config output.path
+
+  const ns = 'translations'
+  var folder = path.join(PUBLIC_ROOT, 'translations')
+  try {
+    fs.readdirSync(folder).forEach(file => {
+      try {
+        var lng = file.split('.')[0]
+        var resourcePath = path.join(folder, file)
+        var resources = JSON.parse(fs.readFileSync(resourcePath))
+        i18next.removeResourceBundle(lng, ns)
+        i18next.addResourceBundle(lng, ns, resources, true, true)
+      } catch (e) {
+        console.error(e)
+      }
+    })
+  } catch (e) {}
+}

package/server/routers/translations-router.ts

@@ -0,0 +1,87 @@
+import Router from 'koa-router'
+import { ILike } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+import { Terminology } from '../service/terminology/terminology'
+import { config } from '@things-factory/env'
+
+const path = require('path')
+const cacheFS = require('fs')
+var fs = require('fs')
+
+const disableCustomTerminologyFeature = config.get('i18n/disableCustomTerminologyFeature')
+
+process.on('client-rebuilt' as any, (app, compilerFileSystem) => {
+  /* change filesystem whenever webpacking assets done. only for development mode. */
+  fs = compilerFileSystem
+
+  if (!disableCustomTerminologyFeature) {
+    const cacheFileFolder = path.join('cache', 'translations')
+
+    if (cacheFS.existsSync(cacheFileFolder)) {
+      cacheFS.rmSync(cacheFileFolder, { recursive: true })
+    }
+  }
+})
+
+export const translationsRouter = new Router()
+
+translationsRouter.get('/translations/:filename', async (context, next) => {
+  const { filename } = context.params
+  const { domain } = context.state
+
+  const locale = (filename || 'en.json').split('.')[0]
+
+  // context.set('Cache-Control', 'public, max-age=31536000') // 캐시 기간 설정 : 1년
+  // context.set('Expires', new Date(Date.now() + 31536000000).toUTCString()) // 캐시 만료일 설정
+
+  if (disableCustomTerminologyFeature) {
+    var file = fs.readFileSync(path.resolve(path.join('dist-app', 'translations', filename)))
+
+    context.type = 'application/json'
+    context.body = file
+    return
+  }
+
+  const cacheFileFolder = path.join('cache', 'translations', domain.subdomain)
+  const cacheFilePath = path.join(cacheFileFolder, filename)
+
+  if (cacheFS.existsSync(cacheFilePath)) {
+    var file = cacheFS.readFileSync(cacheFilePath)
+  } else {
+    var file = fs.readFileSync(path.resolve(path.join('dist-app', 'translations', filename)))
+
+    try {
+      const terminologies = await getRepository(Terminology).find({
+        where: { domain: { id: domain.id }, locale: ILike(locale + '%') }
+      })
+
+      const json = JSON.parse(file)
+
+      terminologies.forEach(term => {
+        const { name, category, display } = term
+        json[`${category}.${name}`] = display
+      })
+
+      try {
+        if (!cacheFS.existsSync(cacheFileFolder)) {
+          cacheFS.mkdirSync(cacheFileFolder, { recursive: true })
+        }
+
+        cacheFS.writeFileSync(cacheFilePath, JSON.stringify(json))
+      } catch (err) {
+        console.error(err)
+      }
+
+      context.type = 'application/json'
+      context.body = json
+
+      return
+    } catch (err) {
+      console.error(err)
+    }
+  }
+
+  context.type = 'application/json'
+  context.body = file
+})

package/server/routes.ts

@@ -0,0 +1,31 @@
+import i18next from 'i18next'
+import { config } from '@things-factory/env'
+
+const disableCustomTerminologyFeature = config.get('i18n/disableCustomTerminologyFeature')
+const isPathBaseDomain = !config.get('subdomain') && !config.get('useVirtualHostBasedDomain')
+
+import { translationsRouter } from './routers/translations-router'
+
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
+  globalPublicRouter.get('/translations/translate/:lng/:key', async (context, next) => {
+    const { lng, key } = context.params
+    const translated = i18next.getFixedT(lng, 'translations' /* ns */)(key)
+
+    context.body = translated
+  })
+
+  globalPublicRouter.get('/translations/translate/:key', async (context, next) => {
+    const { key } = context.params
+    const translated = context.t(key)
+
+    context.body = translated
+  })
+})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  if (isPathBaseDomain) {
+    domainPublicRouter.use('/domain/:subdomain', translationsRouter.routes(), translationsRouter.allowedMethods())
+  } else if (!disableCustomTerminologyFeature) {
+    domainPublicRouter.use('', translationsRouter.routes(), translationsRouter.allowedMethods())
+  }
+})

package/server/service/index.ts

@@ -0,0 +1,27 @@
+/* EXPORT ENTITY TYPES */
+export * from './terminology/terminology'
+export * from './terminology/terminology-type'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import {
+  entities as TerminologyEntities,
+  resolvers as TerminologyResolvers,
+  subscribers as TerminologySubscribers
+} from './terminology'
+
+export const entities = [
+  /* ENTITIES */
+  ...TerminologyEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...TerminologySubscribers
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...TerminologyResolvers
+  ]
+}

package/server/service/terminology/index.ts

@@ -0,0 +1,7 @@
+import { Terminology } from './terminology'
+import { TerminologyQuery } from './terminology-query'
+import { TerminologyMutation } from './terminology-mutation'
+
+export const entities = [Terminology]
+export const resolvers = [TerminologyQuery, TerminologyMutation]
+export const subscribers = []