@things-factory/i18n-base 8.0.5 → 9.0.0-beta.12

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
-}