@things-factory/i18n-base 10.1.79 → 10.1.106

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/i18n-base",
-  "version": "10.1.79",
+  "version": "10.1.106",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -28,8 +28,8 @@
   },
   "dependencies": {
     "@operato/i18n": "^10.0.0",
-    "@things-factory/auth-base": "^10.1.79",
-    "@things-factory/shell": "^10.1.79"
+    "@things-factory/auth-base": "^10.1.106",
+    "@things-factory/shell": "^10.1.106"
   },
-  "gitHead": "94cde9ba17dfdddb0a16139b71e5a7e370977e4a"
+  "gitHead": "8d78c14708420773ec32d18b8dd44c300771c44d"
 }

package/tests/terminology-entry-targets.test.ts

@@ -0,0 +1,135 @@
+/*
+ * The terminology's AI 입력 declaration. The assistant's own validation is asked through its source file,
+ * which needs only `graphql` - the package keeps no run-time dependency on the assistant.
+ */
+import { parse } from 'graphql'
+
+import { clearEntryTargets, declareEntryTarget } from '../../ai-assistant/server/service/data-entry/entry-target'
+import { terminologyChangeIssues, terminologyIssues } from '../server/ai-entry/terminology-entry-rules'
+import { TERMINOLOGY_CATEGORIES, terminologyEntryTarget, terminologyEntryTargets } from '../server/ai-entry/terminology-entry-targets'
+
+import en from '../translations/en.json'
+import ja from '../translations/ja.json'
+import ko from '../translations/ko.json'
+import ms from '../translations/ms.json'
+import zh from '../translations/zh.json'
+
+const LANGUAGES: Record<string, Record<string, string>> = { en, ja, ko, ms, zh }
+
+const rootFields = (document: string) => {
+  const operations = parse(document).definitions.filter((one: any) => one.kind === 'OperationDefinition') as any[]
+  expect(operations).toHaveLength(1)
+  return operations[0].selectionSet.selections.map((one: any) => one.name.value)
+}
+
+const row = (values: Record<string, unknown>, index = 0) => ({ index, values, sources: [], issues: [] })
+const term = (locale: string, category: string, name: string, display = 'x') => row({ locale, category, name, display })
+
+describe('terminology entry target', () => {
+  afterEach(() => clearEntryTargets())
+
+  it('is accepted by the assistant as it is declared', () => {
+    const [target] = terminologyEntryTargets({ locales: ['ko-KR', 'en-US'] })
+    expect(target.key).toBe('i18n-base.terminology')
+    expect(() => declareEntryTarget(target as any)).not.toThrow()
+  })
+
+  it('without a list given, the locales are the configured languages (or the framework five)', () => {
+    const locale = terminologyEntryTarget().fields.find(field => field.name === 'locale')!
+    expect(locale.type).toBe('enum')
+    expect(locale.values!.length).toBeGreaterThan(0)
+    expect(terminologyEntryTarget().fields.find(field => field.name === 'category')!.values).toEqual(TERMINOLOGY_CATEGORIES)
+  })
+
+  it('every document has one root field', () => {
+    const target = terminologyEntryTarget({ locales: ['ko-KR'] })
+    expect(rootFields(target.mutation)).toEqual(['createTerminology'])
+    expect(rootFields(target.update!.mutation)).toEqual(['updateTerminology'])
+    expect(rootFields(target.update!.read.query)).toEqual(['terminologies'])
+    expect(rootFields(target.update!.find!.query)).toEqual(['terminologies'])
+  })
+
+  it('create and patch carry the declared fields only', () => {
+    const target = terminologyEntryTarget({ locales: ['ko-KR'] })
+    expect(target.variables(row({ locale: 'ko-KR', category: 'label', name: 'department', display: '부서', domain: 'x', id: 'y' }))).toEqual({
+      terminology: { locale: 'ko-KR', category: 'label', name: 'department', display: '부서' }
+    })
+    const { patch } = target.update!.variables({ id: 't-1', record: { id: 't-1' }, values: { display: '부문', cuFlag: 'M', creator: { id: 'u' } } }) as any
+    expect(patch).toEqual({ display: '부문' })
+    expect(Object.keys(patch).every(name => target.update!.fields!.includes(name))).toBe(true)
+  })
+})
+
+describe('terminology checks', () => {
+  it('a (locale, category, name) the domain has keeps the row out; another locale or category does not', () => {
+    const issues = terminologyIssues([term('ko-KR', 'label', 'dept'), term('en-US', 'label', 'dept'), term('ko-KR', 'field', 'dept')], [
+      { locale: 'ko-KR', category: 'label', name: 'dept' }
+    ])
+    expect(issues[0]).toEqual([expect.objectContaining({ code: 'duplicate', blocking: true })])
+    expect(issues[1]).toEqual([])
+    expect(issues[2]).toEqual([])
+  })
+
+  it('a row repeating an earlier row of the proposal is kept out - the later one', () => {
+    const issues = terminologyIssues([term('ko-KR', 'label', 'dept', '부서'), term('ko-KR', 'label', 'dept', '부문')], [])
+    expect(issues[0]).toEqual([])
+    expect(issues[1]).toEqual([expect.objectContaining({ code: 'duplicate-in-proposal', blocking: true })])
+  })
+})
+
+describe('terminology change checks', () => {
+  const existing = [
+    { id: 't1', locale: 'ko-KR', category: 'label', name: 'dept' },
+    { id: 't2', locale: 'ko-KR', category: 'label', name: 'team' }
+  ]
+  const record = (id: string) => existing.find(one => one.id === id)!
+
+  it('a changed (locale, category, name) another term has keeps the change out; the term itself does not', () => {
+    const issues = terminologyChangeIssues(
+      [
+        { id: 't2', record: record('t2'), values: { name: 'dept' } },
+        { id: 't2', record: record('t2'), values: { locale: 'en-US', name: 'dept' } },
+        { id: 't2', record: record('t2'), values: { display: '팀' } }
+      ],
+      existing
+    )
+    expect(issues[0]).toEqual([expect.objectContaining({ code: 'duplicate', blocking: true })])
+    expect(issues[1]).toEqual([])
+    expect(issues[2]).toEqual([])
+    expect(terminologyChangeIssues([{ id: 't1', record: record('t1'), values: { category: 'label', display: 'x' } }], existing)).toEqual([[]])
+  })
+
+  it('two changes landing on the same key - the later one is kept out', () => {
+    const issues = terminologyChangeIssues(
+      [
+        { id: 't1', record: record('t1'), values: { name: 'new' } },
+        { id: 't2', record: record('t2'), values: { name: 'new' } }
+      ],
+      existing
+    )
+    expect(issues[0]).toEqual([])
+    expect(issues[1]).toEqual([expect.objectContaining({ code: 'duplicate-in-proposal', blocking: true })])
+  })
+
+  it('the update declares its check', () => {
+    expect(typeof terminologyEntryTarget({ locales: ['ko-KR'] }).update!.check).toBe('function')
+  })
+})
+
+describe('translations', () => {
+  it('the five languages have the same keys', () => {
+    const reference = Object.keys(en).sort()
+    for (const [language, table] of Object.entries(LANGUAGES)) expect({ language, keys: Object.keys(table).sort() }).toEqual({ language, keys: reference })
+  })
+
+  it('the label and messages the target names are translated in every language', () => {
+    const keys = [
+      terminologyEntryTarget({ locales: ['ko-KR'] }).labelKey,
+      ...terminologyIssues([term('ko-KR', 'label', 'a'), term('ko-KR', 'label', 'b'), term('ko-KR', 'label', 'b')], [{ locale: 'ko-KR', category: 'label', name: 'a' }])
+        .flat()
+        .map(issue => issue.messageKey!)
+    ]
+    expect(keys).toHaveLength(3)
+    for (const key of keys) for (const [language, table] of Object.entries(LANGUAGES)) expect({ language, key, has: key in table }).toEqual({ language, key, has: true })
+  })
+})

package/translations/en.json

@@ -3,8 +3,11 @@
   "field.category": "category",
   "field.display": "display",
   "field.locale": "locale",
+  "label.i18n-entry-terminology": "terminology",
   "text.NOTHING_SELECTED": "nothing is selected",
   "text.clearing-cache": "clearing cache",
+  "text.i18n-entry-terminology-exists": "a term with this locale, category and name already exists",
+  "text.i18n-entry-terminology-repeated": "same locale, category and name as an earlier row",
   "text.item view": "item view",
   "title.terminology": "terminology"
 }

package/translations/ja.json

@@ -3,8 +3,11 @@
   "field.category": "カテゴリー",
   "field.display": "表示",
   "field.locale": "ロケール",
+  "label.i18n-entry-terminology": "用語",
   "text.NOTHING_SELECTED": "選択されていません",
   "text.clearing-cache": "キャッシュをクリア",
+  "text.i18n-entry-terminology-exists": "同じロケール・カテゴリ・名前の用語がすでにあります",
+  "text.i18n-entry-terminology-repeated": "前の行とロケール・カテゴリ・名前が同じです",
   "text.item view": "項目表示",
   "title.terminology": "用語"
 }

package/translations/ko.json

@@ -3,8 +3,11 @@
   "field.category": "카테고리",
   "field.display": "표시",
   "field.locale": "로케일",
+  "label.i18n-entry-terminology": "용어",
   "text.NOTHING_SELECTED": "선택한 것이 없습니다",
   "text.clearing-cache": "캐시클리어",
+  "text.i18n-entry-terminology-exists": "같은 로케일·카테고리·이름의 용어가 이미 있습니다",
+  "text.i18n-entry-terminology-repeated": "앞 행과 로케일·카테고리·이름이 같습니다",
   "text.item view": "항목 보기",
   "title.terminology": "용어"
 }

package/translations/ms.json

@@ -3,8 +3,11 @@
   "field.category": "kategori",
   "field.display": "paparan",
   "field.locale": "lokaliti",
+  "label.i18n-entry-terminology": "istilah",
   "text.NOTHING_SELECTED": "tiada yang dipilih",
   "text.clearing-cache": "sedang mengosongkan cache",
+  "text.i18n-entry-terminology-exists": "istilah dengan lokal, kategori dan nama ini sudah wujud",
+  "text.i18n-entry-terminology-repeated": "lokal, kategori dan nama sama dengan baris sebelumnya",
   "text.item view": "paparan item",
   "title.terminology": "istilah"
 }

package/translations/zh.json

@@ -3,8 +3,11 @@
   "field.category": "类别",
   "field.display": "显示",
   "field.locale": "语言环境",
+  "label.i18n-entry-terminology": "术语",
   "text.NOTHING_SELECTED": "未选择任何项目",
   "text.clearing-cache": "正在清除缓存",
+  "text.i18n-entry-terminology-exists": "已有相同区域、类别和名称的术语",
+  "text.i18n-entry-terminology-repeated": "区域、类别和名称与前面的行相同",
   "text.item view": "项目视图",
   "title.terminology": "术语"
 }