@things-factory/figure-service 10.1.27 → 10.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.27",
+  "version": "10.1.29",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,15 +23,15 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.21",
+    "@hatiolab/figure-model": "^0.1.27",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.26",
-    "@things-factory/auth-base": "^10.1.27",
+    "@things-factory/ai-client-base": "^10.1.29",
+    "@things-factory/auth-base": "^10.1.29",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/shell": "^10.1.27",
+    "@things-factory/shell": "^10.1.29",
     "graphql-scalars": "^1.22.4",
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "d04dc762cacf2aac8ba0b0f5d768eca365fc09da"
+  "gitHead": "e6bf9dec003fe5e794746aaeb5852b3b50478232"
 }

package/server/service/figure/figure-gate.ts

@@ -1,4 +1,4 @@
-import { blocksRelease, compile, sizingReport, validate } from '@hatiolab/figure-model'
+import { blocksRelease, compile, contractChanges, sizingReport, validate } from '@hatiolab/figure-model'
 import type { Axis, FigureSource } from '@hatiolab/figure-model'
 
 /** Service transport shape. It deliberately contains only an explicit, reversible FigureSource edit. */
@@ -127,8 +127,11 @@ function measuredFixes(source: FigureSource, factor: number): GateFix[] {
  *
  * 정본이 없거나(아직 저장 전) JSON 이 아니면 **막는다** — 발행할 대상이 없는 것이다. 그 경우를
  * 조용히 통과시키면 빈 것이 발행된다.
+ *
+ * `releasedJson` 은 **직전 발행판의 정본**이다. 주면 그것과 견주어 「이미 놓인 인스턴스를 깨는
+ * 발행인가」를 함께 낸다(ADR-0063 결정 3). 한 번도 발행된 적 없으면 견줄 것이 없으므로 안 준다.
  */
-export function inspectSource(sourceJson?: string | null): Inspection {
+export function inspectSource(sourceJson?: string | null, releasedJson?: string | null): Inspection {
   if (!sourceJson) {
     return {
       blocked: true,
@@ -187,11 +190,48 @@ export function inspectSource(sourceJson?: string | null): Inspection {
         how: finding.how,
         /* 숫자가 아니라 자리를 말한다 — 어느 부품들이 갈라져 나왔나. */
         at: finding.clumps.map(clump => [...clump].sort().join('+')).join(' | ') || undefined,
-        fixes: finding.code === 'sizing-splits' ? fixes.filter(fix => fix.findingWay === finding.way) : undefined,
+          fixes: finding.code === 'sizing-splits' ? fixes.filter(fix => fix.findingWay === finding.way) : undefined,
         blocking: finding.code === 'sizing-splits'
       })
     }
+
+    findings.push(...contractFindings(source, releasedJson))
   }
 
   return { findings, blocked: findings.some(finding => finding.blocking) }
 }
+
+/**
+ * 직전 발행판과 견준 것 — **약속을 깨는 발행인가**(ADR-0063 결정 3).
+ *
+ * 무엇이 달라졌고 그것이 막는 것인지는 형식이 정한다(`contractChanges`). 여기서는 화면과 발행 문이
+ * 읽는 모양으로 옮기기만 한다.
+ *
+ * **앞 판을 오늘 형식으로 못 읽으면 조용히 넘어가지 않는다.** 판 1 은 오늘 형식이 거절하는 판으로
+ * 적혀 있을 수 있고, 그때 견주기를 건너뛰면 아무 말 없이 관문이 없는 것이 된다. 막지는 않는다 —
+ * 그러면 그 도형은 영영 다시 발행할 수 없다.
+ */
+function contractFindings(source: FigureSource, releasedJson?: string | null): GateFinding[] {
+  if (!releasedJson) return []
+
+  let released: FigureSource
+  try {
+    released = JSON.parse(releasedJson) as FigureSource
+    return contractChanges(released, source).map(change => ({
+      code: change.code,
+      message: change.message,
+      why: change.why,
+      at: change.subject,
+      blocking: change.blocking
+    }))
+  } catch (e) {
+    return [
+      {
+        code: 'released-unreadable',
+        message: `직전 발행판을 오늘 형식으로 읽을 수 없어 견주지 못했다: ${(e as Error).message}`,
+        why: '이 발행이 이미 놓인 인스턴스를 깨는지는 확인되지 않았다.',
+        blocking: false
+      }
+    ]
+  }
+}

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

@@ -8,6 +8,7 @@ import { FigureHistory } from './figure-history.js'
 import { FigurePatch, FigureSaveResult, NewFigure } from './figure-type.js'
 import { FigureProposal, ProposeRequest } from './figure-propose-type.js'
 import { inspectSource } from './figure-gate.js'
+import { renameDraftType, renameFacts } from './figure-rename.js'
 import { parseSource } from './figure-source.js'
 import { ProposeFailure, proposeFigure } from './figure-propose.js'
 
@@ -78,6 +79,23 @@ export class FigureMutation {
       violations = parsed.violations
     }
 
+    /*
+      **타입은 발행 전에만 바뀐다** — ADR-0063 결정 4.
+
+      발행된 뒤에는 이미 배치된 도면이 이 이름을 가리키고, 바꾸면 그 도면이 아무 오류 없이
+      빈 자리가 된다. 발행된 적 없는 도형은 가리키는 도면이 있을 수 없다 — 도면은 최신
+      발행판을 그리므로 그려질 자리가 없다.
+
+      행과 정본 둘 다 고친다. 정본 안에도 `type` 이 있어서 한쪽만 고치면 저장된 JSON 과
+      행이 다른 이름을 말하고, 발행할 때 어느 쪽이 도면에 적히는지가 갈린다.
+    */
+    let renamed: string | undefined
+    if (patch.type !== undefined && patch.type !== figure.type) {
+      const change = await this.renameType(figure, domain, patch.type, source, tx)
+      renamed = change.type
+      source = change.source
+    }
+
     /*
       **판 번호는 여기서 손대지 않는다.** 저장은 저작이고, 판은 발행에서 생긴다(`releaseFigure`).
       board 의 `updateBoard` 도 같다 — 저장 경로에는 version 이 없다.
@@ -93,6 +111,8 @@ export class FigureMutation {
       domain,
       ...figure,
       ...patch,
+      /* 앞뒤 공백을 떼고 겹침까지 본 이름. `patch.type` 을 그대로 두면 다듬기 전 값이 들어간다. */
+      ...(renamed !== undefined ? { type: renamed } : {}),
       source,
       /*
         **고치면 발행이 풀린다.**
@@ -114,6 +134,30 @@ export class FigureMutation {
     return { figure: saved, violations }
   }
 
+  /**
+   * 초안의 타입을 고친다 — 규칙은 `figure-rename.ts`, 여기서는 그 규칙이 볼 **사실만** 읽는다.
+   *
+   * 겹침은 DB 인덱스(`ix_figure_1`)도 잡지만 먼저 읽어 본다. 인덱스가 던지는 말은 저작자가
+   * 읽을 것이 못 되고, 어느 이름이 이미 쓰였는지도 안 알려 준다.
+   */
+  private async renameType(
+    figure: Figure,
+    domain: { id: string },
+    wanted: string,
+    source: string,
+    tx: { getRepository: <T>(target: new () => T) => any }
+  ): Promise<{ type: string; source: string }> {
+    /* 읽어 온 엔티티에는 관계가 안 실려 있다 — 도메인은 문맥에서 온 것을 쓴다. */
+    const facts = await renameFacts(
+      { figures: tx.getRepository(Figure), histories: tx.getRepository(FigureHistory) },
+      figure,
+      domain,
+      wanted
+    )
+
+    return renameDraftType({ type: figure.type, source }, wanted, facts)
+  }
+
   /**
    * 발행한다 — **판이 생기는 유일한 자리.**
    *
@@ -168,7 +212,19 @@ export class FigureMutation {
 
       막는 이유는 사유와 함께 낸다. 「발행할 수 없습니다」로 뭉치면 무엇을 고쳐야 하는지 모른다.
     */
-    const inspection = inspectSource(figure.source)
+    /*
+      직전 발행판을 먼저 꺼낸다. 판 번호를 세는 데도 쓰고, **약속을 깨는 발행인가**를 견주는 데도
+      쓴다(ADR-0063 결정 3) — 도면은 type 만 적고 늘 최신 발행판을 그리므로, 다시 발행하는 것은
+      그 type 을 놓아 둔 모든 도면에게 같은 약속을 다시 하는 일이다.
+    */
+    const released = await historyRepository
+      .createQueryBuilder('history')
+      .where('history.originalId = :id', { id: figure.id })
+      .orderBy('history.version', 'DESC')
+      .limit(1)
+      .getOne()
+
+    const inspection = inspectSource(figure.source, released?.source)
     if (inspection.blocked) {
       const reasons = inspection.findings
         .filter(finding => finding.blocking)
@@ -177,13 +233,7 @@ export class FigureMutation {
       throw new Error(`Figure '${figure.type}' 은 아직 발행할 수 없다 — ${reasons.join(' · ')}`)
     }
 
-    const highest = await historyRepository
-      .createQueryBuilder('history')
-      .select('MAX(history.version)', 'max')
-      .where('history.originalId = :id', { id: figure.id })
-      .getRawOne()
-
-    const nextVersion = highest?.max ? Number(highest.max) + 1 : 1
+    const nextVersion = released?.version ? Number(released.version) + 1 : 1
 
     return await repository.save({
       /*

package/server/service/figure/figure-propose.ts

@@ -188,7 +188,7 @@ export function rulesPrompt(palette: string[]): string {
     'Hard limits — exceeding these makes the figure unusable at scale:',
     `  parts        by detailLevel: ${partLimits}`,
     `  material groups (distinct token+preset+slot combinations)  <= ${LIMITS.materialGroups}`,
-    `  animated parts  <= ${LIMITS.animatedParts}`,
+    `  independently transformed parts  <= ${LIMITS.independentParts}`,
     `  transparent materials  <= ${LIMITS.transparentMaterials}`,
     '',
     'Geometry rules:',

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

@@ -113,7 +113,18 @@ export class FigureQuery {
       throw new Error(`Figure ${id} 를 찾을 수 없다`)
     }
 
-    return inspectSource(figure.source)
+    /*
+      **화면이 발행 문과 같은 것을 본다.** 직전 발행판을 여기서도 함께 넘기지 않으면, 저작 화면은
+      조용한데 발행을 누른 순간 계약 위반으로 막힌다 — 그때는 이미 열 군데를 고친 뒤다.
+    */
+    const released = await getRepository(FigureHistory)
+      .createQueryBuilder('history')
+      .where('history.originalId = :id', { id })
+      .orderBy('history.version', 'DESC')
+      .limit(1)
+      .getOne()
+
+    return inspectSource(figure.source, released?.source)
   }
 
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')

package/server/service/figure/figure-rename-db.test.ts

@@ -0,0 +1,138 @@
+/**
+ * 이름을 바꾸기 전에 읽는 사실 셋 — **sqlite 를 실제로 들고** 확인한다.
+ *
+ * 규칙(`renameDraftType`)은 사실을 받아 판단하므로 DB 없이 시험한다. 그런데 그 사실을 읽는
+ * 질의가 틀리면 저작자에게는 저장 실패로만 보인다. 실제로 그랬다 — 판본을 `figure: { id }` 로
+ * 물었고 `FigureHistory` 는 관계 칸이 아니라 `originalId` 로 가리킨다. TypeORM 이 「그런 속성이
+ * 없다」로 던졌고, 순수 시험은 전부 초록이었다.
+ *
+ * 그래서 여기서는 질의를 **돌려 본다.**
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+
+let dataSource: DataSource | null = null
+let Figure: any
+let FigureHistory: any
+let renameFacts: any
+
+function loadCompiled(modulePath: string): any {
+  const { existsSync } = require('fs')
+  const { join } = require('path')
+  const resolved = join(__dirname, '..', '..', '..', 'dist-server', `${modulePath}.js`)
+
+  if (!existsSync(resolved)) {
+    throw new Error(
+      `figure-service 산출물이 없다: ${resolved}\n` +
+        `이 시험은 tsc 산출물을 든다. 먼저 빌드할 것:\n` +
+        `  yarn workspace @things-factory/figure-service build:server`
+    )
+  }
+
+  return require(resolved)
+}
+
+beforeAll(async () => {
+  Figure = loadCompiled('service/figure/figure').Figure
+  FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
+  renameFacts = loadCompiled('service/figure/figure-rename').renameFacts
+
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, Figure, FigureHistory],
+    logging: false
+  })
+
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+beforeEach(async () => {
+  await dataSource!.synchronize(true)
+  await seedDomain()
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+  dataSource = null
+})
+
+let DOMAIN: { id: string }
+
+/* 도형이 도메인을 가리킨다 — 행이 없으면 외래키가 먼저 막는다. */
+async function seedDomain() {
+  const saved = await dataSource!.getRepository(shell.Domain).save({ name: 'rename-probe', subdomain: 'rename-probe' })
+  DOMAIN = { id: saved.id }
+}
+
+async function seedFigure(over: Record<string, unknown> = {}) {
+  return await dataSource!.getRepository(Figure).save({
+    type: 'FIGURE_MU6SZ5DL',
+    name: '초안',
+    source: '{}',
+    state: 'draft',
+    version: 0,
+    domain: DOMAIN,
+    ...over
+  })
+}
+
+const facts = async (figure: any, wanted: string) =>
+  await renameFacts(
+    { figures: dataSource!.getRepository(Figure), histories: dataSource!.getRepository(FigureHistory) },
+    figure,
+    DOMAIN,
+    wanted
+  )
+
+describe('이름을 바꾸기 전에 읽는 사실', () => {
+  it('★ 판본 질의가 실제로 돈다 — 칸 이름이 틀리면 여기서 던진다', async () => {
+    const figure = await seedFigure()
+
+    expect(await facts(figure, 'ROBOT_ARM')).toEqual({ version: 0, hasHistory: false, takenByAnother: false })
+  })
+
+  it('★ 판본이 있으면 그것을 읽어 온다', async () => {
+    const figure = await seedFigure()
+    await dataSource!.getRepository(FigureHistory).save({
+      originalId: figure.id,
+      version: 1,
+      type: figure.type,
+      name: figure.name,
+      source: '{}',
+      domain: DOMAIN
+    })
+
+    expect((await facts(figure, 'ROBOT_ARM')).hasHistory).toBe(true)
+  })
+
+  it('같은 도메인에서 그 이름을 쓰는 다른 도형을 찾는다', async () => {
+    const figure = await seedFigure()
+    await seedFigure({ type: 'CONVEYOR', name: '컨베이어' })
+
+    expect((await facts(figure, 'CONVEYOR')).takenByAnother).toBe(true)
+  })
+
+  it('자기 이름은 겹침이 아니다', async () => {
+    const figure = await seedFigure()
+
+    expect((await facts(figure, figure.type)).takenByAnother).toBe(false)
+  })
+
+  it('빈 이름은 겹침을 묻지 않는다 — 규칙이 먼저 거절한다', async () => {
+    const figure = await seedFigure()
+
+    expect((await facts(figure, '   ')).takenByAnother).toBe(false)
+  })
+})

package/server/service/figure/figure-rename.test.ts

@@ -0,0 +1,99 @@
+/*
+ * 초안의 타입을 고치는 규칙 — ADR-0063 결정 4.
+ *
+ * 이 규칙이 지키는 것은 하나다: **발행된 이름은 안 바뀐다.** 도면은 그 이름 하나로 도형을
+ * 찾으므로, 바뀌면 배치된 자리가 아무 오류 없이 빈다.
+ */
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+import { FigureRenameRefused, renameDraftType } from './figure-rename'
+
+const draft = (over: Record<string, unknown> = {}) => ({
+  type: 'FIGURE_MU6RJH47',
+  source: JSON.stringify({ version: 2, type: 'FIGURE_MU6RJH47', base: { x: 1, y: 1, z: 1 }, parts: [] }),
+  ...over
+})
+
+const never = { version: 0, hasHistory: false, takenByAnother: false }
+
+describe('초안의 type 고치기', () => {
+  it('★ 행과 정본이 함께 바뀐다 — 한쪽만 바뀌면 발행 때 어느 이름이 나갈지 갈린다', () => {
+    const result = renameDraftType(draft(), 'ROBOT_ARM', never)
+
+    expect(result.type).toBe('ROBOT_ARM')
+    expect(JSON.parse(result.source).type).toBe('ROBOT_ARM')
+  })
+
+  it('정본의 다른 값은 건드리지 않는다', () => {
+    const before = JSON.parse(draft().source)
+    const after = JSON.parse(renameDraftType(draft(), 'ROBOT_ARM', never).source)
+
+    expect({ ...after, type: before.type }).toEqual(before)
+  })
+
+  it('앞뒤 공백을 뗀다. 대소문자는 저작자가 적은 대로 둔다', () => {
+    expect(renameDraftType(draft(), '  ROBOT_ARM  ', never).type).toBe('ROBOT_ARM')
+    expect(renameDraftType(draft(), 'Robot_Arm', never).type).toBe('Robot_Arm')
+  })
+
+  it('★ 한 번이라도 발행됐으면 거절한다 — 판 번호로', () => {
+    expect(() => renameDraftType(draft(), 'ROBOT_ARM', { ...never, version: 1 })).toThrow(FigureRenameRefused)
+  })
+
+  it('★ 판 번호가 도로 0 이어도 이력이 있으면 거절한다 — 되돌리기가 그 자리를 만든다', () => {
+    try {
+      renameDraftType(draft(), 'ROBOT_ARM', { ...never, hasHistory: true })
+      throw new Error('거절하지 않았다')
+    } catch (e) {
+      expect((e as FigureRenameRefused).code).toBe('already-released')
+    }
+  })
+
+  it('같은 도메인에서 쓰는 이름이면 거절하고, 어느 이름인지 말한다', () => {
+    try {
+      renameDraftType(draft(), 'CONVEYOR', { ...never, takenByAnother: true })
+      throw new Error('거절하지 않았다')
+    } catch (e) {
+      expect((e as FigureRenameRefused).code).toBe('type-taken')
+      expect((e as Error).message).toContain('CONVEYOR')
+    }
+  })
+
+  it('빈 이름은 거절한다 — 도면에 적히는 이름이다', () => {
+    for (const empty of ['', '   ']) {
+      try {
+        renameDraftType(draft(), empty, never)
+        throw new Error('거절하지 않았다')
+      } catch (e) {
+        expect((e as FigureRenameRefused).code).toBe('empty-type')
+      }
+    }
+  })
+})
+
+/*
+ * 규칙이 문에 붙어 있는가. 셈이 맞아도 문이 안 부르면 저작자는 그대로 막혀 있다.
+ */
+describe('문이 이 규칙을 지난다', () => {
+  const source = (name: string) => readFileSync(join(__dirname, name), 'utf8')
+
+  it('updateFigure 가 type 을 받고 규칙을 부른다', () => {
+    const mutation = source('figure-mutation.ts')
+
+    expect(/renameDraftType/.test(mutation)).toBe(true)
+    expect(/patch\.type !== undefined && patch\.type !== figure\.type/.test(mutation)).toBe(true)
+  })
+
+  it('다듬은 이름이 저장된다 — patch 의 날값이 아니라', () => {
+    const mutation = source('figure-mutation.ts')
+
+    expect(/renamed !== undefined \? \{ type: renamed \}/.test(mutation)).toBe(true)
+  })
+
+  it('문이 type 을 받는 칸을 갖는다', () => {
+    const type = source('figure-type.ts')
+
+    expect(/class FigurePatch \{[\s\S]{0,400}type\?: string/.test(type)).toBe(true)
+  })
+})

package/server/service/figure/figure-rename.ts

@@ -0,0 +1,98 @@
+/**
+ * 초안의 타입을 고치는 규칙 — ADR-0063 결정 4.
+ *
+ * ## 왜 발행 전에만인가
+ *
+ * `type` 은 도면에 적히는 이름이다. 도면은 `{ type, left, top, width, height }` 만 갖고 늘 최신
+ * 발행판을 그리므로, 발행된 도형의 이름을 바꾸면 이미 배치된 도면이 아무 오류 없이 빈 자리가
+ * 된다. 한 번도 발행되지 않은 도형은 그려질 자리가 없으니 가리키는 도면도 있을 수 없다.
+ *
+ * ## 왜 열어야 했나
+ *
+ * 닫아 두었더니 저작자가 이름을 **한 번도** 정하지 못했다. 새 Figure 에는 기계가 지은 이름이
+ * 붙고(`FIGURE_MU6RJH47`) 칸에 자물쇠가 걸려서, 그 이름이 그대로 도면에 적히는 이름이 됐다.
+ * 그렇게 남은 초안이 14 개다.
+ *
+ * ## 셈은 여기, 질의는 부르는 쪽
+ *
+ * 이 파일은 저장소를 모른다 — 판 번호 · 이력 유무 · 같은 이름의 주인을 **사실로 받는다.**
+ * 그래야 규칙을 DB 없이 시험한다. 문(`figure-mutation.ts`)이 그 셋을 읽어 넘긴다.
+ */
+
+/** 이름을 바꿀 때 알아야 하는 사실. 부르는 쪽이 저장소에서 읽어 온다. */
+export interface RenameFacts {
+  /** 발행 판 번호. 0 이면 한 번도 발행되지 않았다. */
+  version?: number
+  /** 판본이 하나라도 있나. 되돌리기로 판 번호가 도로 낮아져도 이력은 남는다. */
+  hasHistory: boolean
+  /** 같은 도메인에서 그 이름을 이미 쓰는 **다른** 도형이 있나. */
+  takenByAnother: boolean
+}
+
+export class FigureRenameRefused extends Error {
+  constructor(
+    readonly code: 'empty-type' | 'already-released' | 'type-taken',
+    message: string
+  ) {
+    super(message)
+    this.name = 'FigureRenameRefused'
+  }
+}
+
+/**
+ * 고친 이름과 정본. 못 고치면 **까닭과 함께 던진다** — 조용히 옛 이름으로 두지 않는다.
+ *
+ * 정본 안에도 `type` 이 있어서 함께 고친다. 한쪽만 고치면 저장된 JSON 과 행이 다른 이름을
+ * 말하고, 발행할 때 어느 쪽이 도면에 적히는지가 갈린다.
+ */
+export function renameDraftType(
+  current: { type: string; source: string },
+  wanted: string,
+  facts: RenameFacts
+): { type: string; source: string } {
+  const next = wanted.trim()
+
+  if (!next) {
+    throw new FigureRenameRefused('empty-type', 'type 이 비어 있다 — 도면에 적히는 이름이라 비울 수 없다')
+  }
+
+  if ((facts.version ?? 0) > 0 || facts.hasHistory) {
+    throw new FigureRenameRefused(
+      'already-released',
+      '발행된 도형의 type 은 바꿀 수 없다 — 이미 배치된 도면이 이 이름을 가리킨다'
+    )
+  }
+
+  if (facts.takenByAnother) {
+    throw new FigureRenameRefused('type-taken', `type 「${next}」 는 이 도메인에서 이미 쓰고 있다`)
+  }
+
+  const parsed = JSON.parse(current.source) as { type?: string }
+  parsed.type = next
+
+  return { type: next, source: JSON.stringify(parsed) }
+}
+
+/**
+ * 사실 셋을 저장소에서 읽는다.
+ *
+ * 규칙에서 떼어 둔 자리이지만 **질의의 모양이 틀리면 저작자에게는 저장 실패로만 보인다.**
+ * 실제로 그랬다 — 판본을 `figure: { id }` 로 물었고, `FigureHistory` 는 관계 칸이 아니라
+ * `originalId` 로 가리킨다. TypeORM 이 「그런 속성이 없다」로 던졌고 화면에는 영문 오류 한 줄이
+ * 떴다. 그래서 이 함수를 내보내 sqlite 를 들고 왕복까지 본다.
+ */
+export async function renameFacts(
+  repositories: {
+    figures: { findOne(options: any): Promise<{ id: string } | null> }
+    histories: { count(options: any): Promise<number> }
+  },
+  figure: { id?: string; version?: number },
+  domain: { id: string },
+  wanted: string
+): Promise<RenameFacts> {
+  const next = wanted.trim()
+  const hasHistory = (await repositories.histories.count({ where: { originalId: figure.id } })) > 0
+  const taken = next ? await repositories.figures.findOne({ where: { domain: { id: domain.id }, type: next } }) : null
+
+  return { version: figure.version, hasHistory, takenByAnother: !!taken && taken.id !== figure.id }
+}