@things-factory/i18n-base 8.0.0-beta.1 → 8.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/i18n-base",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.4",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -28,8 +28,8 @@
   },
   "dependencies": {
     "@operato/i18n": "^8.0.0-beta",
-    "@things-factory/auth-base": "^8.0.0-beta.1",
-    "@things-factory/shell": "^8.0.0-beta.1"
+    "@things-factory/auth-base": "^8.0.0-beta.4",
+    "@things-factory/shell": "^8.0.0-beta.4"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "d83d12ed4ba07177dff1dac26e37be347d156b43"
 }

package/client/bootstrap.ts

@@ -1,16 +0,0 @@
-import { PageView } from '@operato/shell'
-
-declare module '@operato/shell' {
-  interface PageView {
-    languageUpdated(i18next: any): void
-  }
-}
-
-export default function bootstrap() {
-  /*
-   * PageView의 lifecycle에 languageUpdate를 추가한다.
-   */
-  PageView.prototype.languageUpdated = function (i18next) {
-    this.pageReset()
-  }
-}

package/client/index.ts

@@ -1,6 +0,0 @@
-/**
- * @license Copyright © HatioLab Inc. All rights reserved.
- */
-
-export { i18next } from '@operato/i18n/config.js'
-export * from '@operato/i18n/localize.js'

package/client/page/terminology-page.ts

@@ -1,408 +0,0 @@
-import '@material/web/icon/icon.js'
-
-import '@operato/data-grist'
-import '@operato/context/ox-context-page-toolbar.js'
-import '@operato/input/ox-input-select-buttons.js'
-
-import { css, html } from 'lit'
-import { customElement, query, state } from 'lit/decorators.js'
-import { connect } from 'pwa-helpers/connect-mixin.js'
-import gql from 'graphql-tag'
-
-import { store, CustomAlert, PageView } from '@operato/shell'
-import { client } from '@operato/graphql'
-import { DataGrist, FetchOption, GristRecord } from '@operato/data-grist'
-import { i18next, localize } from '@operato/i18n'
-import { CommonHeaderStyles, ScrollbarStyles } from '@operato/styles'
-import { isMobileDevice } from '@operato/utils'
-import { getLanguages } from '@things-factory/auth-base/dist-client'
-
-@customElement('terminology-page')
-export class TerminologyPage extends connect(store)(localize(i18next)(PageView)) {
-  static styles = [
-    ScrollbarStyles,
-    CommonHeaderStyles,
-    css`
-      :host {
-        display: flex;
-        flex-direction: column;
-
-        overflow: hidden;
-
-        --grid-header-padding: 2px 0 2px 9px;
-      }
-
-      ox-grist {
-        overflow-y: auto;
-        flex: 1;
-      }
-
-      .header {
-        grid-template-areas: 'filters actions';
-      }
-    `
-  ]
-
-  @state() private gristConfig: any
-  @state() private mode: 'CARD' | 'GRID' | 'LIST' = isMobileDevice() ? 'CARD' : 'GRID'
-  @state() private state?: string[]
-
-  @query('ox-grist') private grist!: DataGrist
-
-  get context() {
-    return {
-      title: i18next.t('title.terminology'),
-      search: {
-        handler: (search: string) => {
-          this.grist.searchText = search
-        },
-        value: this.grist?.searchText || ''
-      },
-      filter: {
-        handler: () => {
-          this.grist.toggleHeadroom()
-        }
-      },
-      help: 'mfg-warehouse/term-page',
-      actions: [
-        {
-          title: i18next.t('button.clear-cache'),
-          action: this.clearCache.bind(this),
-          icon: 'ink_eraser'
-        },
-        {
-          title: i18next.t('button.save'),
-          action: this.save.bind(this),
-          icon: 'save'
-        },
-        {
-          title: i18next.t('button.delete'),
-          action: this.delete.bind(this),
-          icon: 'delete',
-          emphasis: {
-            danger: true
-          }
-        }
-      ],
-      exportable: {
-        name: i18next.t('button.export'),
-        data: this.exportHandler.bind(this)
-      },
-      toolbar: false
-    }
-  }
-
-  async getFilterStatus() {
-    return (await getLanguages()).map(({ code, display }) => {
-      return { value: code, display }
-    })
-  }
-
-  render() {
-    const mode = this.mode || (isMobileDevice() ? 'LIST' : 'GRID')
-
-    return html`
-      <ox-grist .mode=${mode} .config=${this.gristConfig} .fetchHandler=${this.fetchHandler.bind(this)}>
-        <div slot="headroom" class="header">
-          <div class="filters">
-            <ox-filters-form autofocus without-search></ox-filters-form>
-          </div>
-
-          <ox-context-page-toolbar class="actions" .context=${this.context}></ox-context-page-toolbar>
-        </div>
-      </ox-grist>
-    `
-  }
-
-  async pageInitialized(lifecycle) {
-    this.gristConfig = {
-      list: {
-        fields: ['name', 'description'],
-        details: ['active', 'updatedAt']
-      },
-      columns: [
-        { type: 'gutter', gutterName: 'sequence' },
-        { type: 'gutter', gutterName: 'row-selector', multiple: true },
-        {
-          type: 'string',
-          name: 'id',
-          header: i18next.t('field.id'),
-          hidden: true,
-          width: 0
-        },
-        {
-          type: 'string',
-          name: 'name',
-          header: i18next.t('field.name'),
-          record: {
-            editable: true
-          },
-          filter: 'search',
-          sortable: true,
-          width: 250
-        },
-        {
-          type: 'select',
-          name: 'locale',
-          header: i18next.t('field.locale'),
-          record: {
-            editable: true,
-            options: [{ display: '', value: '' }, ...(await this.getFilterStatus())]
-          },
-          width: 90,
-          filter: {
-            type: 'select-buttons',
-            operator: 'in'
-          }
-        },
-        {
-          type: 'select',
-          name: 'category',
-          label: true,
-          header: i18next.t('field.category'),
-          record: {
-            editable: true,
-            options: ['', 'button', 'field', 'label', 'menu', 'text', 'title']
-          },
-          width: 90,
-          filter: 'in',
-          imex: true
-        },
-        {
-          type: 'string',
-          name: 'display',
-          label: true,
-          header: i18next.t('field.display'),
-          record: {
-            editable: true
-          },
-          filter: 'search',
-          sortable: true,
-          width: 380
-        },
-        {
-          type: 'resource-object',
-          name: 'updater',
-          header: i18next.t('field.updater'),
-          record: {
-            editable: false
-          },
-          sortable: true,
-          width: 120
-        },
-        {
-          type: 'datetime',
-          name: 'updatedAt',
-          header: i18next.t('field.updated_at'),
-          record: {
-            editable: false
-          },
-          sortable: true,
-          width: 180
-        }
-      ],
-      rows: {
-        appendable: true,
-        selectable: {
-          multiple: true
-        }
-        /*handlers: {
-          click: (columns, data, column, record, rowIndex) => {
-            // TODO Implement the desired sub-view(like item-view) and use it in the popup content after importing
-            const popup = openPopup(html` 
-                <item-view item-id=${record.id} style="background-color: white;">
-                </item-view> 
-              `, {
-              backdrop: true,
-              size: 'large',
-              title: i18next.t('text.item view')
-            })
-            popup.onclosed = () => {
-              this.grist.fetch()
-            }
-          }
-        }*/
-      },
-      sorters: [
-        {
-          name: 'name',
-          desc: true
-        }
-      ]
-    }
-  }
-
-  async pageUpdated(changes: any, lifecycle: any) {
-    if (this.active) {
-      // do something here when this page just became as active
-    }
-  }
-
-  async fetchHandler({ page = 1, limit = 100, sortings = [], filters = [] }: FetchOption) {
-    const response = await client.query({
-      query: gql`
-        query ($filters: [Filter!], $pagination: Pagination, $sortings: [Sorting!]) {
-          terminologies(filters: $filters, pagination: $pagination, sortings: $sortings) {
-            items {
-              id
-              name
-              locale
-              category
-              display
-              creator {
-                id
-                name
-              }
-              createdAt
-              updater {
-                id
-                name
-              }
-              updatedAt
-            }
-
-            total
-          }
-        }
-      `,
-      variables: {
-        filters,
-        pagination: { page, limit },
-        sortings
-      }
-    })
-
-    return {
-      total: response.data.terminologies.total || 0,
-      records: response.data.terminologies.items || []
-    }
-  }
-
-  exportHandler() {
-    let records = [] as GristRecord
-    if (this.grist.selected && this.grist.selected.length > 0) {
-      records = this.grist.selected
-    } else {
-      records = this.grist.data.records
-    }
-
-    var headerSetting = this.grist.compiledConfig.columns
-      .filter(column => column.type !== 'gutter' && column.record !== undefined && column.imex !== undefined)
-      .map(column => {
-        return column.imex === true
-          ? {
-              header: column.header.renderer(column),
-              key: column.name,
-              width: column.width,
-              type: column.type
-            }
-          : column.imex
-      })
-
-    var data = records.map(item => {
-      return {
-        id: item.id,
-        ...this.gristConfig.columns
-          .filter(column => column.type !== 'gutter' && column.record !== undefined && column.imex !== undefined)
-          .reduce((record, column) => {
-            const key = column.imex === true ? column.name : column.imex.key
-            record[key] = key
-              .split('.')
-              .reduce((obj, key) => (obj && obj[key] !== 'undefined' ? obj[key] : undefined), item)
-            return record
-          }, {})
-      }
-    })
-
-    return { header: headerSetting, data: data }
-  }
-
-  async delete() {
-    const selectedRecords = this.grist.selected
-
-    if (!selectedRecords || selectedRecords.length == 0) {
-      this.showToast(i18next.t('text.NOTHING_SELECTED'))
-    } else {
-      const answer = await CustomAlert({
-        type: 'question',
-        title: i18next.t('button.delete'),
-        text: i18next.t('text.are_you_sure'),
-        confirmButton: { text: i18next.t('button.delete') },
-        cancelButton: { text: i18next.t('button.cancel') }
-      })
-
-      if (!answer) {
-        return
-      }
-
-      let ids = selectedRecords.map(record => record.id)
-
-      const response = await client.mutate({
-        mutation: gql`
-          mutation ($ids: [String!]!) {
-            deleteTerminologies(ids: $ids)
-          }
-        `,
-        variables: {
-          ids
-        }
-      })
-
-      this.grist.fetch()
-
-      return response.data.deleteTerminologies
-    }
-  }
-
-  async clearCache() {
-    const response = await client.mutate({
-      mutation: gql`
-        mutation {
-          clearTranslationsCache
-        }
-      `
-    })
-
-    if (!response.errors) {
-      this.showToast(i18next.t('text.info_x_successfully', { x: i18next.t('text.clearing-cache') }))
-    }
-  }
-
-  async save() {
-    let changedRecords = this.grist.dirtyRecords
-
-    if (!changedRecords || changedRecords.length == 0) {
-      this.showToast(i18next.t('text.nothing_changed'))
-    } else {
-      const patches = changedRecords.map(patch => {
-        const patchField: any = patch.id ? { id: patch.id } : {}
-        const dirtyFields = patch.__dirtyfields__
-        for (let key in dirtyFields) {
-          patchField[key] = dirtyFields[key].after
-        }
-        patchField.cuFlag = patch.__dirty__
-
-        return patchField
-      })
-
-      const response = await client.mutate({
-        mutation: gql`
-          mutation ($patches: [TerminologyPatch!]!) {
-            updateMultipleTerminologies(patches: $patches) {
-              id
-            }
-          }
-        `,
-        variables: {
-          patches
-        }
-      })
-
-      this.grist.fetch()
-    }
-  }
-
-  showToast(message: string) {
-    document.dispatchEvent(new CustomEvent('notify', { detail: { message } }))
-  }
-}

package/client/route.ts

@@ -1,7 +0,0 @@
-export default function route(page) {
-  switch (page) {
-    case 'terminology-page':
-      import('./page/terminology-page.js')
-      return page
-  }
-}

package/server/apis/index.ts

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

package/server/apis/t.ts

@@ -1,36 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

package/server/middlewares/index.ts

@@ -1,36 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/* 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

@@ -1,7 +0,0 @@
-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 = []

package/server/service/terminology/terminology-mutation.ts

@@ -1,171 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Terminology } from './terminology'
-import { NewTerminology, TerminologyPatch } from './terminology-type'
-
-import { clearTranslationCacheForCertainDomain } from '../../controllers/clear-cache-for-translation'
-
-function clearCache(subdomain: string) {
-  /** multiple update/delete시 모든 엔티티에 대해서 subscription 이 걸리므로, EventSubscriber를 사용하지 않음. */
-  try {
-    clearTranslationCacheForCertainDomain(subdomain)
-  } catch (err) {
-    console.error('Failed to delete the translations cache directory:', err)
-  }
-}
-
-@Resolver(Terminology)
-export class TerminologyMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "terminology", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Terminology, { description: 'To create new Terminology' })
-  async createTerminology(@Arg('terminology') terminology: NewTerminology, @Ctx() context: any): Promise<Terminology> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(Terminology).save({
-      ...terminology,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    clearCache(domain.subdomain)
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "terminology", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Terminology, { description: 'To modify Terminology information' })
-  async updateTerminology(
-    @Arg('id') id: string,
-    @Arg('patch') patch: TerminologyPatch,
-    @Ctx() context: any
-  ): Promise<Terminology> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Terminology)
-    const terminology = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...terminology,
-      ...patch,
-      updater: user
-    })
-
-    clearCache(domain.subdomain)
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "terminology", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => [Terminology], { description: "To modify multiple Terminologies' information" })
-  async updateMultipleTerminologies(
-    @Arg('patches', type => [TerminologyPatch]) patches: TerminologyPatch[],
-    @Ctx() context: any
-  ): Promise<Terminology[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const terminologyRepo = tx.getRepository(Terminology)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await terminologyRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const terminology = await terminologyRepo.findOneBy({ id: newRecord.id })
-
-        const result = await terminologyRepo.save({
-          ...terminology,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    clearCache(domain.subdomain)
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To clear translations cache' })
-  async clearTranslationsCache(@Ctx() context: any): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    clearCache(domain.subdomain)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "terminology", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete Terminology' })
-  async deleteTerminology(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Terminology).delete({ domain: { id: domain.id }, id })
-
-    clearCache(domain.subdomain)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "terminology", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Terminologies' })
-  async deleteTerminologies(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Terminology).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    clearCache(domain.subdomain)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "terminology", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple Terminologies' })
-  async importTerminologies(
-    @Arg('terminologies', type => [TerminologyPatch]) terminologies: TerminologyPatch[],
-    @Ctx() context: any
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      terminologies.map(async (terminology: TerminologyPatch) => {
-        const createdTerminology: Terminology = await tx.getRepository(Terminology).save({ domain, ...terminology })
-      })
-    )
-
-    clearCache(domain.subdomain)
-
-    return true
-  }
-}

package/server/service/terminology/terminology-query.ts

@@ -1,50 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-import { Terminology } from './terminology'
-import { TerminologyList } from './terminology-type'
-
-@Resolver(Terminology)
-export class TerminologyQuery {
-  @Query(returns => Terminology, { description: 'To fetch a Terminology' })
-  async terminology(@Arg('id') id: string, @Ctx() context: any): Promise<Terminology> {
-    const { domain } = context.state
-
-    return await getRepository(Terminology).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => TerminologyList, { description: 'To fetch multiple Terminologies' })
-  async terminologies(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<TerminologyList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Terminology),
-      searchables: ['name', 'category', 'display']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() terminology: Terminology): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: terminology.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() terminology: Terminology): Promise<User> {
-    return await getRepository(User).findOneBy({ id: terminology.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() terminology: Terminology): Promise<User> {
-    return await getRepository(User).findOneBy({ id: terminology.creatorId })
-  }
-}

package/server/service/terminology/terminology-type.ts

@@ -1,54 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { Terminology } from './terminology'
-
-@InputType()
-export class NewTerminology {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field()
-  locale: string
-
-  @Field()
-  category: string
-
-  @Field()
-  display: string
-}
-
-@InputType()
-export class TerminologyPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  locale?: string
-
-  @Field({ nullable: true })
-  category?: string
-
-  @Field({ nullable: true })
-  display?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class TerminologyList {
-  @Field(type => [Terminology])
-  items: Terminology[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/terminology/terminology.ts

@@ -1,75 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-@Entity()
-@ObjectType({ description: 'Entity for Terminology' })
-@Index('ix_term_0', (term: Terminology) => [term.domain, term.locale, term.category, term.name], { unique: true })
-@Index('ix_term_1', (term: Terminology) => [term.domain])
-@Index('ix_term_2', (term: Terminology) => [term.domain, term.locale])
-@Index('ix_term_3', (term: Terminology) => [term.domain, term.locale, term.name])
-export class Terminology {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((terminology: Terminology) => terminology.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Field()
-  @Column({ length: 20 })
-  locale?: string
-
-  @Field()
-  @Column({ length: 20 })
-  category?: string
-
-  @Field()
-  @Column()
-  display?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((terminology: Terminology) => terminology.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((terminology: Terminology) => terminology.updater)
-  updaterId?: string
-}