@things-factory/figure-service 10.1.28 → 10.1.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.28",
+  "version": "10.1.31",
   "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.28",
-    "@things-factory/auth-base": "^10.1.28",
+    "@things-factory/ai-client-base": "^10.1.31",
+    "@things-factory/auth-base": "^10.1.31",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/shell": "^10.1.28",
+    "@things-factory/shell": "^10.1.31",
     "graphql-scalars": "^1.22.4",
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "3a260a0f79bc6b41a692a103955bfcc541aff60e"
+  "gitHead": "5213e6f9913b40ea2618a2111d9884b792dbaa01"
 }

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

@@ -40,6 +40,12 @@ const sampleSource = JSON.stringify({
   ]
 })
 
+/** The same box under a different type and part name, so a test can tell the sources apart. */
+const boxNamed = (type: string, part: string) => {
+  const parsed = JSON.parse(sampleSource)
+  return JSON.stringify({ ...parsed, type, parts: [{ ...parsed.parts[0], name: part }] })
+}
+
 beforeAll(async () => {
   Figure = loadCompiled('service/figure/figure').Figure
   FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
@@ -176,13 +182,227 @@ describe('figureBlueprint 질의 — 소비처(board, twin, things-scene)를 위
     expect(result.groups[0].members[0].transform.size.x).toBe(100)
   })
 
+  /*
+    The test above proves a release is reached through history, with one history row. It cannot tell
+    `version: 'DESC'` from `'ASC'`, nor from no ordering at all — with a single row every one of them
+    answers the same. Consumers are promised the LATEST release, so the ordering is the claim, and it
+    needs more than one row to be a claim at all. The rows go in out of order because an ordering bug
+    that reads insertion order would otherwise pass.
+  */
+  it('answers the highest released version when a type has several', async () => {
+    const repo = dataSource!.getRepository(Figure)
+    const historyRepo = dataSource!.getRepository(FigureHistory)
+
+    const figure = await repo.save({
+      domain: testDomain,
+      type: 'MULTI',
+      name: 'in authoring',
+      state: 'draft',
+      source: boxNamed('MULTI', 'unreleased-draft'),
+      version: 3
+    })
+
+    for (const version of [1, 3, 2]) {
+      await historyRepo.save({
+        domain: testDomain,
+        originalId: figure.id,
+        type: 'MULTI',
+        name: `v${version}`,
+        state: 'released',
+        version,
+        source: boxNamed('MULTI', `v${version}`)
+      })
+    }
+
+    const result = await new FigureQuery().figureBlueprint('MULTI', makeContext())
+
+    expect(result).not.toBeNull()
+    expect(result.groups[0].members[0].name).toBe('v3')
+  })
+
+  /*
+    Every edit to a released figure writes a history row, and those rows are not all releases. A
+    draft row sitting at a higher version than the last release is the ordinary state of a figure
+    being worked on, so reading the newest row rather than the newest RELEASED row would hand
+    consumers unreleased work — the leak the whole door exists to stop.
+  */
+  it('skips a draft history that sits above the last release', async () => {
+    const repo = dataSource!.getRepository(Figure)
+    const historyRepo = dataSource!.getRepository(FigureHistory)
+
+    const figure = await repo.save({
+      domain: testDomain,
+      type: 'WIP',
+      name: 'in authoring',
+      state: 'draft',
+      source: boxNamed('WIP', 'unreleased-draft'),
+      version: 5
+    })
+
+    await historyRepo.save({
+      domain: testDomain,
+      originalId: figure.id,
+      type: 'WIP',
+      name: 'v2',
+      state: 'released',
+      version: 2,
+      source: boxNamed('WIP', 'released-v2')
+    })
+    await historyRepo.save({
+      domain: testDomain,
+      originalId: figure.id,
+      type: 'WIP',
+      name: 'v5',
+      state: 'draft',
+      version: 5,
+      source: boxNamed('WIP', 'draft-v5')
+    })
+
+    const result = await new FigureQuery().figureBlueprint('WIP', makeContext())
+
+    expect(result).not.toBeNull()
+    expect(result.groups[0].members[0].name).toBe('released-v2')
+  })
+
+  /*
+    History rows are looked up by originalId, which is a figure id and so already unique. That makes
+    the domain in the same where-clause look redundant, and redundant-looking filters get deleted.
+    It is not redundant: it is the tenant boundary on a door that consumers call, so a test holds it.
+  */
+  it('does not reach a history row that belongs to another domain', async () => {
+    const domainRepo = dataSource!.getRepository(shell.Domain)
+    const other = await domainRepo.save({ name: 'other-domain', subdomain: 'other-domain' })
+
+    const repo = dataSource!.getRepository(Figure)
+    const historyRepo = dataSource!.getRepository(FigureHistory)
+
+    const figure = await repo.save({
+      domain: testDomain,
+      type: 'LEAKY',
+      name: 'never released here',
+      state: 'draft',
+      source: boxNamed('LEAKY', 'unreleased-draft'),
+      version: 0
+    })
+
+    await historyRepo.save({
+      domain: other,
+      originalId: figure.id,
+      type: 'LEAKY',
+      name: 'released elsewhere',
+      state: 'released',
+      version: 1,
+      source: boxNamed('LEAKY', 'other-domain-release')
+    })
+
+    const result = await new FigureQuery().figureBlueprint('LEAKY', makeContext())
+
+    expect(result).toBeNull()
+  })
+
+  /*
+    This used to answer null, and that was the defect. Null says one thing on this door — nobody
+    published this type — and the board reads it that way: it draws the stand-in of ADR-0063 결정 1 and
+    the scene opens. A released figure whose stored source no longer compiles is a different fact. The
+    author published it, the catalogue says released, and with null the only trace was a console line
+    on the server, so the author saw "my figure does not show on the board" and nothing more. That is
+    the silence ADR-0053 refuses (chief architect, ADR-0063 결정 2 보탬).
+
+    So it refuses with a name, and the name carries what someone needs to find the figure: the type,
+    its id, and the edition that does not compile. The sentence is built where the request's language
+    is known, which is why the gate throws no sentence of its own (ADR-0054).
+  */
+  it('refuses with a named refusal when the stored source cannot be compiled', async () => {
+    const repo = dataSource!.getRepository(Figure)
+    const saved = await repo.save({
+      domain: testDomain,
+      type: 'BROKEN',
+      name: 'corrupted',
+      state: 'released',
+      source: '{ this is not json',
+      version: 4
+    })
+
+    const query = new FigureQuery()
+    const spy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    try {
+      await expect(query.figureBlueprint('BROKEN', makeContext())).rejects.toMatchObject({
+        name: 'Refusal',
+        code: 'figure-release-does-not-compile',
+        params: { type: 'BROKEN', figureId: saved.id, version: 4 }
+      })
+    } finally {
+      spy.mockRestore()
+    }
+  })
+
+  /*
+    The edition named in that refusal is the one the board was handed, which is not the row's own
+    version once the author starts editing again: the row moves on to the next draft while the board
+    keeps drawing the last release. Naming the draft would send someone to look at a source that is
+    not the one failing.
+  */
+  it('the refusal names the released edition, not the draft being edited', async () => {
+    const repo = dataSource!.getRepository(Figure)
+    const historyRepo = dataSource!.getRepository(FigureHistory)
+
+    const figure = await repo.save({
+      domain: testDomain,
+      type: 'BROKEN_HISTORY',
+      name: 'in authoring again',
+      state: 'draft',
+      source: boxNamed('BROKEN_HISTORY', 'healthy-draft'),
+      version: 9
+    })
+    await historyRepo.save({
+      domain: testDomain,
+      originalId: figure.id,
+      type: 'BROKEN_HISTORY',
+      name: 'v2',
+      state: 'released',
+      version: 2,
+      source: '{ this is not json'
+    })
+
+    const spy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    try {
+      await expect(new FigureQuery().figureBlueprint('BROKEN_HISTORY', makeContext())).rejects.toMatchObject({
+        code: 'figure-release-does-not-compile',
+        params: { version: 2 }
+      })
+    } finally {
+      spy.mockRestore()
+    }
+  })
+
+  /*
+    A refusal only becomes a sentence in the caller's language by passing through `SpeakRefusals`,
+    which the class declares and which a direct call like the ones above never runs. Without that
+    declaration this refusal reaches the board as Apollo's INTERNAL_SERVER_ERROR carrying the English
+    fallback, and `extensions.refusal` — the thing that tells a client the server refused on purpose —
+    is absent. The tests above stay green either way, so the declaration is read from the source.
+  */
+  it('declares SpeakRefusals on the class, or the refusal arrives as a server error', () => {
+    const { readFileSync } = require('fs')
+    const { join } = require('path')
+    const source = readFileSync(join(__dirname, 'figure-query.ts'), 'utf-8')
+
+    const at = source.indexOf('export class FigureQuery')
+    expect(at).toBeGreaterThan(-1)
+    expect(source.slice(0, at)).toContain('@UseMiddleware(SpeakRefusals)')
+  })
+
   describe('a child domain shadows its parent only with a released version', () => {
     const boxOf = (type: string, part: string) =>
       JSON.stringify({ ...JSON.parse(sampleSource), type, parts: [{ ...JSON.parse(sampleSource).parts[0], name: part }] })
 
+    let childSeq = 0
+
     async function childOf(parent: any) {
       const repo = dataSource!.getRepository(shell.Domain)
-      const saved = await repo.save({ name: 'child-domain', subdomain: 'child-domain', parent })
+      /* A chain needs a distinct subdomain per level; the column is unique. */
+      const name = `child-domain-${++childSeq}`
+      const saved = await repo.save({ name, subdomain: name, parent })
       return repo.findOne({ where: { id: saved.id } })
     }
 
@@ -213,6 +433,54 @@ describe('figureBlueprint 질의 — 소비처(board, twin, things-scene)를 위
 
       expect(result.groups[0].members[0].name).toBe('tenant')
     })
+
+    /*
+      The two cases above give the child a row whose own state decides the answer. This is the case
+      between them: the child released once and is editing again, so its row says draft while a
+      release of its own exists. The fallback must not read "the child row is a draft" as "the child
+      has nothing" — a tenant that starts a second edit would then see the standard figure come back
+      in place of the one it published.
+    */
+    it('uses the child own release when the child row is a draft again', async () => {
+      const child = await childOf(testDomain)
+
+      const repo = dataSource!.getRepository(Figure)
+      const historyRepo = dataSource!.getRepository(FigureHistory)
+
+      await repo.save({ domain: testDomain, type: 'CONVEYOR', name: '표준', state: 'released', source: boxOf('CONVEYOR', 'standard'), version: 1 })
+      const tenant = await repo.save({ domain: child, type: 'CONVEYOR', name: '테넌트', state: 'draft', source: boxOf('CONVEYOR', 'tenant-wip'), version: 1 })
+      await historyRepo.save({
+        domain: child,
+        originalId: tenant.id,
+        type: 'CONVEYOR',
+        name: '테넌트 v1',
+        state: 'released',
+        version: 1,
+        source: boxOf('CONVEYOR', 'tenant-v1')
+      })
+
+      const result = await new FigureQuery().figureBlueprint('CONVEYOR', contextIn(child))
+
+      expect(result).not.toBeNull()
+      expect(result.groups[0].members[0].name).toBe('tenant-v1')
+    })
+
+    /*
+      The lookup consults the caller's domain and its parent, and stops there. A grandchild therefore
+      does not inherit, which is the current rule rather than an oversight — pinning it here means
+      the day someone needs deeper inheritance they change this test on purpose and take the ruling
+      with them, instead of finding the depth by accident in a scene that renders nothing.
+    */
+    it('does not climb past the immediate parent', async () => {
+      const mid = await childOf(testDomain)
+      const leaf = await childOf(mid)
+      expect(leaf.parentId).toBe(mid.id)
+
+      const repo = dataSource!.getRepository(Figure)
+      await repo.save({ domain: testDomain, type: 'CONVEYOR', name: '표준', state: 'released', source: boxOf('CONVEYOR', 'standard'), version: 1 })
+
+      expect(await new FigureQuery().figureBlueprint('CONVEYOR', contextIn(leaf))).toBeNull()
+    })
   })
 
   /*

package/server/service/figure/figure-e2e-smoke.test.ts

@@ -62,7 +62,7 @@ describeIf('AI 로 만든 figure 가 발행까지 가나', () => {
   test('움직이는 것을 만든다 — 문', async () => {
     const { made, gate } = await walk(
       '자동문',
-      'a двух-panel automatic door in a frame. add an animation clip that opens both panels together by sliding them apart.',
+      'a two-panel automatic door in a frame. add an animation clip that opens both panels together by sliding them apart.',
       'AUTO_DOOR_E2E'
     )
     expect(gate.blocked).toBe(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)
+  }
+
   /**
    * 발행한다 — **판이 생기는 유일한 자리.**
    *

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

@@ -1,9 +1,16 @@
 import { In } from 'typeorm'
-import { Args, Arg, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { Args, Arg, Ctx, Directive, Query, Resolver, UseMiddleware } from 'type-graphql'
 import { GraphQLJSON } from 'graphql-scalars'
 import { compile } from '@hatiolab/figure-model'
 
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import {
+  Domain,
+  getQueryBuilderFromListParams,
+  getRepository,
+  ListParam,
+  Refusal,
+  SpeakRefusals
+} from '@things-factory/shell'
 
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
@@ -11,6 +18,7 @@ import { inspectSource } from './figure-gate.js'
 import { FigureInspection, FigureList } from './figure-type.js'
 
 @Resolver(Figure)
+@UseMiddleware(SpeakRefusals)
 export class FigureQuery {
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => Figure, { nullable: true, description: 'Finds a single figure by its ID.' })
@@ -194,14 +202,28 @@ export class FigureQuery {
       return null
     }
 
-    const { figure, source: sourceToCompile } = found
+    const { figure, source: sourceToCompile, version } = found
 
     try {
       const parsed = typeof sourceToCompile === 'string' ? JSON.parse(sourceToCompile) : sourceToCompile
       return compile(parsed)
     } catch (err) {
       console.error(`[figureBlueprint] 타입 '${type}' (figure id: ${figure.id}) 청사진 컴파일 실패:`, err)
-      return null
+
+      /*
+        Null says one thing here: nobody published this type (ADR-0063 결정 2 보탬). A released figure
+        whose stored source no longer compiles is a different fact, and answering null for it makes the
+        board draw a stand-in with the reason nowhere on screen — the author published, the catalogue
+        says released, and the only trace is the line above. That is the silence ADR-0053 refuses.
+
+        The board asks per type inside a Promise.all and collects a rejection into `failed`, so this
+        refusal costs that one figure its drawing and the scene still opens.
+      */
+      throw new Refusal(
+        'figure-release-does-not-compile',
+        { type, figureId: figure.id, version },
+        'the released source of {type} does not compile. open it in the modeller and release it again.'
+      )
     }
   }
 }
@@ -212,12 +234,15 @@ export class FigureQuery {
  * A released row gives its own source; a draft row gives the source of its latest released history.
  * A figure that was never released gives null, because drafts never reach consumers.
  */
-async function releasedSourceOf(domainId: string, type: string): Promise<{ figure: Figure; source: string } | null> {
+async function releasedSourceOf(
+  domainId: string,
+  type: string
+): Promise<{ figure: Figure; source: string; version: number } | null> {
   const figure = await getRepository(Figure).findOne({ where: { domain: { id: domainId }, type } })
   if (!figure) return null
 
   if (figure.state === 'released' && figure.source) {
-    return { figure, source: figure.source }
+    return { figure, source: figure.source, version: figure.version }
   }
 
   const latestReleased = await getRepository(FigureHistory).findOne({
@@ -225,5 +250,9 @@ async function releasedSourceOf(domainId: string, type: string): Promise<{ figur
     order: { version: 'DESC' }
   })
 
-  return latestReleased?.source ? { figure, source: latestReleased.source } : null
+  /* The version travels with the source: a refusal names the edition that does not compile, and the
+     row's own version is the draft being edited, not the one the board was handed. */
+  return latestReleased?.source
+    ? { figure, source: latestReleased.source, version: latestReleased.version }
+    : null
 }

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