@things-factory/i18n-base 7.0.0-alpha.8 → 7.0.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@things-factory/i18n-base",
-  "version": "7.0.0-alpha.8",
+  "version": "7.0.0",
   "main": "dist-server/index.js",
-  "browser": "client/index.js",
+  "browser": "dist-client/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
   "description": "Server side for handling translation.",
@@ -17,15 +17,19 @@
     "directory": "packages/i18n-base"
   },
   "scripts": {
-    "build": "tsc --p tsconfig.json",
-    "build:server": "npm run clean:server && tsc",
-    "clean:server": "rm -rf dist-server",
-    "clean": "npm run clean:server",
+    "build": "npm run build:server && npm run build:client",
+    "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
+    "build:client": "npm run copy:files && npx tsc --p ./client/tsconfig.json",
+    "build:server": "npx tsc --p ./server/tsconfig.json",
+    "clean:client": "npx rimraf dist-client",
+    "clean:server": "npx rimraf dist-server",
+    "clean": "npm run clean:server && npm run clean:client",
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@operato/i18n": "^2.0.0-alpha.0",
-    "@things-factory/shell": "^7.0.0-alpha.8"
+    "@operato/i18n": "^7.0.0",
+    "@things-factory/auth-base": "^7.0.0",
+    "@things-factory/shell": "^7.0.0"
   },
-  "gitHead": "b4981ea2721e7eaf4dbd618b6c77316ebc000ee5"
+  "gitHead": "00f3917ca132679e3571f3f4fd16f4caf84f488e"
 }

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

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

package/server/routes.ts

@@ -1,4 +1,27 @@
 import i18next from 'i18next'
+import { ILike } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+import { config } from '@things-factory/env'
+
+const disableCustomTerminologyFeature = config.get('i18n/disableCustomTerminologyFeature')
+
+import { Terminology } from './service/terminology/terminology'
+
+const path = require('path')
+const cacheFS = require('fs')
+var fs = require('fs')
+
+process.on('client-rebuilt' as any, (app, compilerFileSystem) => {
+  /* change filesystem whenever webpacking assets done. only for development mode. */
+  fs = compilerFileSystem
+
+  const cacheFileFolder = path.join('cache', 'translations')
+
+  if (cacheFS.existsSync(cacheFileFolder)) {
+    cacheFS.rmSync(cacheFileFolder, { recursive: true })
+  }
+})
 
 process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
   globalPublicRouter.get('/translations/translate/:lng/:key', async (context, next) => {
@@ -9,10 +32,71 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
   })
 
   globalPublicRouter.get('/translations/translate/:key', async (context, next) => {
-    const { lng } = context.state
     const { key } = context.params
     const translated = context.t(key)
 
     context.body = translated
   })
 })
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  domainPublicRouter.get('/domain/:subdomain/translations/:filename', async (context, next) => {
+    const { subdomain, 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', 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/service/index.ts

@@ -1,18 +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 } from './terminology'
+import {
+  entities as TerminologyEntities,
+  resolvers as TerminologyResolvers,
+  subscribers as TerminologySubscribers
+} from './terminology'
 
-export const entities = [  
+export const entities = [
   /* ENTITIES */
-	...TerminologyEntities,
-] 
+  ...TerminologyEntities
+]
 
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...TerminologySubscribers
+]
 
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
-		...TerminologyResolvers,
-  ] 
+    ...TerminologyResolvers
+  ]
 }

package/server/service/terminology/index.ts

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

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

@@ -4,22 +4,39 @@ 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
 
-    return await tx.getRepository(Terminology).save({
+    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,
@@ -33,14 +50,19 @@ export class TerminologyMutation {
       where: { domain: { id: domain.id }, id }
     })
 
-    return await repository.save({
+    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[],
@@ -83,19 +105,36 @@ export class TerminologyMutation {
       }
     }
 
+    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
@@ -105,10 +144,13 @@ export class TerminologyMutation {
       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[],
@@ -122,6 +164,8 @@ export class TerminologyMutation {
       })
     )
 
+    clearCache(domain.subdomain)
+
     return true
   }
 }

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

@@ -1,6 +1,7 @@
 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'
@@ -17,7 +18,7 @@ export class TerminologyQuery {
   }
 
   @Query(returns => TerminologyList, { description: 'To fetch multiple Terminologies' })
-  async terminologies(@Args() params: ListParam, @Ctx() context: any): Promise<TerminologyList> {
+  async terminologies(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<TerminologyList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -36,4 +37,14 @@ export class TerminologyQuery {
   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

@@ -31,14 +31,14 @@ export class TerminologyPatch {
   @Field({ nullable: true })
   description?: string
 
-  @Field()
-  locale: string
+  @Field({ nullable: true })
+  locale?: string
 
-  @Field()
-  category: string
+  @Field({ nullable: true })
+  category?: string
 
-  @Field()
-  display: string
+  @Field({ nullable: true })
+  display?: string
 
   @Field({ nullable: true })
   cuFlag?: string

package/server/service/terminology/terminology.ts

@@ -1,7 +1,17 @@
 import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+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' })
@@ -15,7 +25,7 @@ export class Terminology {
   readonly id: string
 
   @ManyToOne(type => Domain)
-  @Field({ nullable: true })
+  @Field(type => Domain)
   domain?: Domain
 
   @RelationId((terminology: Terminology) => terminology.domain)
@@ -23,25 +33,23 @@ export class Terminology {
 
   @Column()
   @Field()
-  name: string
+  name?: string
 
-  @Column({
-    nullable: true
-  })
+  @Column({ nullable: true })
   @Field({ nullable: true })
   description?: string
 
   @Field()
   @Column({ length: 20 })
-  locale: string
+  locale?: string
 
   @Field()
   @Column({ length: 20 })
-  category: string
+  category?: string
 
   @Field()
   @Column()
-  display: string
+  display?: string
 
   @CreateDateColumn()
   @Field({ nullable: true })
@@ -50,4 +58,18 @@ export class Terminology {
   @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
 }

package/things-factory.config.js

@@ -1,5 +1,13 @@
-import bootstrap from './client/bootstrap'
+import bootstrap from './dist-client/bootstrap'
+import route from './dist-client/route'
 
 export default {
-  bootstrap
+  bootstrap,
+  route,
+  routes: [
+    {
+      tagname: 'terminology-page',
+      page: 'terminology-page'
+    }
+  ]
 }

package/translations/en.json

@@ -0,0 +1,8 @@
+{
+  "button.clear-cache": "clear cache",
+  "field.category": "category",
+  "field.display": "display",
+  "field.locale": "locale",
+  "text.clearing-cache": "clearing cache",
+  "title.terminology": "terminology"
+}

package/translations/ja.json

@@ -0,0 +1,8 @@
+{
+  "button.clear-cache": "キャッシュをクリア",
+  "field.category": "カテゴリー",
+  "field.display": "表示",
+  "field.locale": "ロケール",
+  "text.clearing-cache": "キャッシュをクリア",
+  "title.terminology": "用語"
+}

package/translations/ko.json

@@ -0,0 +1,8 @@
+{
+  "button.clear-cache": "캐시 삭제",
+  "field.category": "카테고리",
+  "field.display": "표시",
+  "field.locale": "로케일",
+  "text.clearing-cache": "캐시클리어",
+  "title.terminology": "용어"
+}

package/translations/ms.json

@@ -0,0 +1,8 @@
+{
+  "button.clear-cache": "kosongkan cache",
+  "field.category": "kategori",
+  "field.display": "paparan",
+  "field.locale": "lokaliti",
+  "text.clearing-cache": "sedang mengosongkan cache",
+  "title.terminology": "istilah"
+}

package/translations/zh.json

@@ -0,0 +1,8 @@
+{
+  "button.clear-cache": "清除缓存",
+  "field.category": "类别",
+  "field.display": "显示",
+  "field.locale": "语言环境",
+  "text.clearing-cache": "正在清除缓存",
+  "title.terminology": "术语"
+}

package/client/bootstrap.js

@@ -1,10 +0,0 @@
-import { PageView } from '@things-factory/shell'
-
-export default function bootstrap() {
-  /*
-   * PageView의 lifecycle에 languageUpdate를 추가한다.
-   */
-  PageView.prototype.languageUpdated = function(i18next) {
-    this.pageReset()
-  }
-}

package/client/components/i18n-msg.js

@@ -1,9 +0,0 @@
-/**
- * @license Copyright © HatioLab Inc. All rights reserved.
- */
-
-import { OxI18n } from '@operato/i18n/ox-i18n.js'
-
-class I18nMsg extends OxI18n {}
-
-customElements.define('i18n-msg', I18nMsg)