@things-factory/figure-service 10.1.4 → 10.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.4",
+  "version": "10.1.6",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,12 +23,14 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.12",
+    "@hatiolab/figure-model": "^0.1.15",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.3",
-    "@things-factory/auth-base": "^10.1.4",
+    "@things-factory/ai-client-base": "^10.1.6",
+    "@things-factory/auth-base": "^10.1.6",
     "@things-factory/env": "^10.1.3",
-    "graphql-upload": "^15.0.2"
+    "@things-factory/shell": "^10.1.4",
+    "graphql-upload": "^15.0.2",
+    "koa-router": "^7.4.0"
   },
-  "gitHead": "c653a2967daa76b3828f1eb7f4eb18934263d4b8"
+  "gitHead": "963aeb9ac470be5aea05bb5842a0a92afcab6036"
 }

package/server/index.ts

@@ -1,2 +1,15 @@
+import './routes.js'
+
+/*
+ * 저작 도구를 어시스턴트 레지스트리에 등록한다.
+ *
+ * 이 패키지가 적재되면 대화면(도크)이 저작 중인 Figure 의 정본·비용·발행 판정을 읽고 후보를
+ * 요청할 수 있다. 능력을 복제하지 않고 figure-service 가 이미 가진 진입점을 투영한다 —
+ * 노출 범위는 대화면이 `toolCategories` 로 고른다(twin-ai · board-import 와 같은 방식).
+ */
+import { registerFigureToolCategories } from './service/figure/figure-tools.js'
+registerFigureToolCategories()
+
 export * from './service/index.js'
 export * from './migrations/index.js'
+export { registerFigureToolCategories } from './service/figure/figure-tools.js'

package/server/routers/figure-thumbnail-router.ts

@@ -0,0 +1,110 @@
+import Router from 'koa-router'
+import { In } from 'typeorm'
+
+import { checkPermission } from '@things-factory/auth-base'
+import { getRepository } from '@things-factory/shell'
+
+import { Figure } from '../service/figure/figure.js'
+
+/**
+ * 썸네일을 **그림으로** 내보내는 길.
+ *
+ * ## 왜 필요한가
+ *
+ * 썸네일은 base64 문자열로 칸에 들어 있다(`Board.thumbnail` 과 같은 방식). 그것을 목록 질의가
+ * 함께 실어 오면 카탈로그를 열 때마다 그림 전부가 JSON 안에 담겨 다시 온다 — data URL 은
+ * 브라우저가 캐시할 수 없다. [확인함] 표본 14개에 227KB, 한 장 최대 20KB.
+ *
+ * 그림으로 내보내면 브라우저가 캐시하고, 부르는 쪽이 `?v=thumbnailUpdatedAt` 을 붙이므로 그림이
+ * 다시 만들어진 것만 다시 받는다. 목록 질의에서는 `thumbnail` 을 아예 고르지 않는다.
+ *
+ * ## board 를 베끼면서 고친 것 셋
+ *
+ * `standalone-board-service-router` 의 `/thumbnail/:id` 가 본이지만 그대로 두면 안 되는 것들이 있다.
+ *
+ *   1. **길 이름이 겹친다.** 이 앱은 board 도 함께 싣는다(메뉴가 board-ui 를 끌어온다).
+ *      `/thumbnail/:id` 로 두면 먼저 등록된 쪽이 이기고, 남의 표에서 id 를 찾아 404 를 낸다.
+ *   2. **행 전체를 읽는다.** board 는 `findOneBy` 로 행을 다 읽는다. figure 행에는 정본(`source`)이
+ *      붙어 있어, 그림 한 장에 정본까지 읽게 된다. 필요한 칸만 고른다.
+ *   3. **png 로 못 박는다.** figure 썸네일은 webp 다(모델러가 그렇게 만든다). data URL 이 스스로
+ *      말하는 형식을 쓴다 — 못 박으면 브라우저가 확장자와 다른 바이트를 받는다.
+ */
+export const figureThumbnailRouter = new Router()
+
+/** `data:image/webp;base64,....` → 형식과 바이트. 아니면 undefined. */
+function decodeDataUrl(dataUrl: string): { type: string; buffer: Buffer } | undefined {
+  const matched = /^data:([^;,]+);base64,(.*)$/s.exec(dataUrl)
+  if (!matched) {
+    return undefined
+  }
+
+  return { type: matched[1], buffer: Buffer.from(matched[2], 'base64') }
+}
+
+figureThumbnailRouter.get('/figure-thumbnail/:id', async (context, next) => {
+  const { domain, user, unsafeIP, prohibitedPrivileges } = context.state
+
+  /*
+    **질의와 같은 문을 쓴다.**
+
+    `User.hasPrivilege('query','figure',…)` 만 보면 안 된다 — figure 질의는
+    `@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)` 로 선언되어 있고,
+    도메인 소유자는 `figure:query` 권한 줄이 없어도 통과한다. 그 허용을 여기서 빼면 목록은 보이는데
+    그림만 403 이 되어, 화면은 「그림이 아직 없다」고 거짓말한다. [확인함] 실제로 카드 14장이 전부
+    403 이었다.
+
+    조건을 손으로 다시 적지 않고 지시자가 쓰는 함수를 그대로 쓴다. 선언이 바뀌면 여기도 함께 바뀐다.
+  */
+  const allowed = await checkPermission(
+    { category: 'figure', privilege: 'query', owner: true },
+    user,
+    domain,
+    unsafeIP,
+    prohibitedPrivileges
+  )
+
+  if (!allowed) {
+    context.status = 403
+    return
+  }
+
+  const { id } = context.params
+
+  /*
+    읽기는 부모 도메인까지 본다 — `figure` 질의와 같은 범위다. 물려받은 형상을 목록에는 보여 주고
+    그림만 404 를 내면, 화면은 「그림이 아직 없다」고 거짓말하게 된다.
+  */
+  const found = await getRepository(Figure).findOne({
+    where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id },
+    select: { id: true, thumbnail: true, thumbnailUpdatedAt: true }
+  })
+
+  const decoded = found?.thumbnail ? decodeDataUrl(found.thumbnail) : undefined
+
+  if (!decoded) {
+    context.status = 404
+    return
+  }
+
+  /*
+    **개인 캐시만 허락한다.** 이 그림은 권한을 본 뒤에 내주는 것이므로 공용 캐시(프록시)에 남으면
+    안 된다. 부르는 쪽이 `?v=` 로 판을 가리므로 오래 두어도 낡은 그림이 남지 않고, `v` 없이 부른
+    경우를 위해 시각을 함께 실어 다시 물어볼 수 있게 한다.
+  */
+  const stamp = found!.thumbnailUpdatedAt
+
+  context.type = decoded.type
+  context.set('Cache-Control', 'private, max-age=31536000')
+  if (stamp) {
+    context.set('Last-Modified', new Date(stamp).toUTCString())
+    context.set('ETag', `"${new Date(stamp).getTime()}"`)
+
+    /* 브라우저가 가진 것이 아직 그것이면 바이트를 보내지 않는다. */
+    if (context.fresh) {
+      context.status = 304
+      return
+    }
+  }
+
+  context.body = decoded.buffer
+})

package/server/routes.ts

@@ -0,0 +1,24 @@
+import { config } from '@things-factory/env'
+import { getRoutePrefixForDomainType } from '@things-factory/shell'
+
+import { figureThumbnailRouter } from './routers/figure-thumbnail-router.js'
+
+/**
+ * 도메인 경로가 주소에 들어가는 배치인가.
+ *
+ * `subdomain` 설정이 있으면 도메인은 호스트 이름으로 갈리므로 경로에 도메인이 없다. 없으면
+ * `/domain/{subdomain}/...` 로 갈린다 — board-service 가 같은 판단을 같은 방식으로 한다.
+ */
+const isPathBaseDomain = !config.get('subdomain')
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  if (isPathBaseDomain) {
+    domainPrivateRouter.use(
+      `/${getRoutePrefixForDomainType()}/:domain`,
+      figureThumbnailRouter.routes(),
+      figureThumbnailRouter.allowedMethods()
+    )
+  } else {
+    domainPrivateRouter.use('', figureThumbnailRouter.routes(), figureThumbnailRouter.allowedMethods())
+  }
+})

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

@@ -0,0 +1,119 @@
+import { compile, sizingReport, validate } from '@hatiolab/figure-model'
+import type { FigureSource } from '@hatiolab/figure-model'
+
+/**
+ * 발행해도 되나 — **서버가 판정한다.**
+ *
+ * ## 왜 서버인가
+ *
+ * 이 검사는 브라우저 하네스에만 있었다(`test/browser/check-figure-scaling.mjs`). 사람이 돌릴 때만
+ * 돌았고, 발행 경로에는 아무 검사도 없었다 — 형식만 맞으면 무엇이든 발행되었다. 발행은 소비처에게
+ * 하는 약속이므로, 그 약속을 지킬 수 있는지는 약속하는 자리가 재야 한다.
+ *
+ * ## 무엇을 막고 무엇을 알리나
+ *
+ * 판정은 `figure-model` 의 `gate.ts` 가 이미 문서로 정해 두었다. 여기서 새로 정하지 않는다.
+ *
+ *   sizing-splits   크기를 바꾸면 조각이 갈라진다   **막는다**
+ *   sizing-loose    1배에서 이미 여러 조각이다      알린다
+ *   violations      형식이 권하지 않는 것          알린다 (저장 때 이미 보여 준 것들)
+ *
+ * 갈라짐을 막는 이유는 사람 눈에 「부서졌다」로 보이기 때문이다 — 시그널타워를 3배로 세우니 램프가
+ * 기둥 위 공중에 떴던 그것이고, 앵커 규칙이 생긴 이유다. 소비처가 형상을 늘려 쓰는 것은 막을 수
+ * 없으니(그것이 이 형식의 값이다), 늘려도 견디는지를 발행 전에 본다.
+ *
+ * ## 재 본 값
+ *
+ * [확인함] 2026-09-09 · 표본 15개(시드 14 + 저작 1)
+ *   형식 오류 0 · 1배 분리 0 · **갈라짐 1**(MIXER, z·y-z 조합) · 조용함 14
+ *
+ * 게이트가 벽이 아니라는 뜻이다. 열넷은 그대로 발행되고, 하나는 고칠 것이 있다.
+ */
+
+/** 게이트가 낸 한 가지. `blocking` 이 참이면 발행이 안 된다. */
+export interface GateFinding {
+  code: string
+  message: string
+  /**
+   * **왜 그것이 문제인가.** 잰 것만 보여 주면 읽는 사람이 「그래서?」에서 멈춘다 — 화면에
+   * 「1 조각이 2 조각으로 갈라진다」만 떴을 때 실제로 그랬다.
+   */
+  why?: string
+  /** **무엇을 바꾸면 되나.** 부품 이름과 값으로. 형식이 만든 문장을 그대로 옮긴다. */
+  how?: string
+  /** 어디를 가리키나 — 갈라짐은 갈라진 부품 이름들, 형식 위반은 정본 안의 경로. */
+  at?: string
+  blocking: boolean
+}
+
+export interface Inspection {
+  findings: GateFinding[]
+  /** 막는 것이 하나라도 있나. 화면이 이것으로 단추를 잠근다. */
+  blocked: boolean
+}
+
+/**
+ * 정본 하나를 판정한다.
+ *
+ * 정본이 없거나(아직 저장 전) JSON 이 아니면 **막는다** — 발행할 대상이 없는 것이다. 그 경우를
+ * 조용히 통과시키면 빈 것이 발행된다.
+ */
+export function inspectSource(sourceJson?: string | null): Inspection {
+  if (!sourceJson) {
+    return {
+      blocked: true,
+      findings: [
+        {
+          code: 'no-source',
+          message: '저장된 정본이 없다. 저장하면 발행할 수 있다',
+          blocking: true
+        }
+      ]
+    }
+  }
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(sourceJson)
+  } catch (e) {
+    return {
+      blocked: true,
+      findings: [{ code: 'source-not-json', message: `정본이 JSON 이 아니다: ${(e as Error).message}`, blocking: true }]
+    }
+  }
+
+  const result = validate(parsed)
+  const findings: GateFinding[] = []
+
+  /*
+    형식 오류는 **저장을 통과할 수 없다**(`parseSource` 가 거절한다). 그래도 여기서 다시 보는 이유는,
+    이 판정이 저장 경로와 독립이어야 하기 때문이다 — 옛 정본이 남아 있거나 형식이 엄해진 뒤라면
+    저장 때는 맞았던 것이 지금은 틀릴 수 있다. 그때 발행이 통과하면 안 된다.
+  */
+  for (const error of result.errors) {
+    findings.push({ code: error.code, message: error.message, at: error.path, blocking: true })
+  }
+
+  for (const violation of result.violations) {
+    findings.push({ code: violation.code, message: violation.message, blocking: false })
+  }
+
+  if (result.errors.length === 0) {
+    const report = sizingReport(compile(parsed as FigureSource))
+
+    for (const finding of report.findings) {
+      findings.push({
+        code: finding.code,
+        message: finding.message,
+        /* 왜·어떻게는 형식이 소유한다. 서버가 다시 쓰면 두 벌이 되고 곧 어긋난다. */
+        why: finding.why,
+        how: finding.how,
+        /* 숫자가 아니라 자리를 말한다 — 어느 부품들이 갈라져 나왔나. */
+        at: finding.clumps.map(clump => [...clump].sort().join('+')).join(' | ') || undefined,
+        blocking: finding.code === 'sizing-splits'
+      })
+    }
+  }
+
+  return { findings, blocked: findings.some(finding => finding.blocking) }
+}

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

@@ -7,6 +7,7 @@ import { Figure } from './figure.js'
 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 { parseSource } from './figure-source.js'
 import { ProposeFailure, proposeFigure } from './figure-propose.js'
 
@@ -130,6 +131,12 @@ export class FigureMutation {
    *
    * 도형의 현재 번호가 아니라 **판본의 최대 번호 + 1** 이다. 되돌리기로 옛 판이 현재가 되어도
    * 다음 발행이 이미 쓴 번호를 다시 쓰지 않는다.
+   *
+   * ## 게이트를 통과해야 한다
+   *
+   * 크기를 바꿨을 때 조각이 갈라지는 도형은 발행되지 않는다(`figure-gate.ts`). 소비처는 형상을
+   * 늘려 쓰므로 — 그것이 이 형식의 값이다 — 늘려도 견디는지가 약속의 일부다. 화면은 같은 판정을
+   * `inspectFigure` 로 미리 물어 이유를 보여 준다.
    */
   @Directive('@transaction')
   @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
@@ -154,6 +161,22 @@ export class FigureMutation {
       throw new Error(`Figure '${figure.type}' 은 이미 발행되어 있다. 고쳐서 다시 내려면 초안으로 되돌린 뒤 발행한다`)
     }
 
+    /*
+      ── 게이트는 여기 있어야 한다 ────────────────────────────────────────────
+      화면도 같은 판정을 미리 물어(`inspectFigure`) 이유를 보여 주지만, **막는 자리는 이곳뿐이다.**
+      물어본 뒤 정본이 바뀌었을 수 있고, 화면을 거치지 않는 부름도 있다.
+
+      막는 이유는 사유와 함께 낸다. 「발행할 수 없습니다」로 뭉치면 무엇을 고쳐야 하는지 모른다.
+    */
+    const inspection = inspectSource(figure.source)
+    if (inspection.blocked) {
+      const reasons = inspection.findings
+        .filter(finding => finding.blocking)
+        .map(finding => (finding.at ? `${finding.message} (${finding.at})` : finding.message))
+
+      throw new Error(`Figure '${figure.type}' 은 아직 발행할 수 없다 — ${reasons.join(' · ')}`)
+    }
+
     const highest = await historyRepository
       .createQueryBuilder('history')
       .select('MAX(history.version)', 'max')

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

@@ -37,22 +37,38 @@ function candidate(over: Record<string, unknown> = {}) {
   }
 }
 
-/** 정해 둔 답을 차례로 내놓는 가짜 모델. */
-function stubClient(answers: unknown[]): AIClient & { calls: number } {
+/**
+ * 정해 둔 답을 차례로 내놓는 가짜 모델.
+ *
+ * **받은 말을 적어 둔다.** 프롬프트에 실려 나가는 지시 중에 지켜져야 할 것이 있어서다 —
+ * 고치는 요청에서 「부품 이름을 바꾸지 말라」가 빠지면 AI 가 이름을 갈아 버리고, 그러면
+ * 이미 배치된 보드의 바인딩이 끊긴다. 답만 보는 모형으로는 그것이 나갔는지 알 수 없다.
+ */
+function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[][]; system?: string } {
   const client = {
     id: 'stub',
     calls: 0,
+    sent: [] as any[][],
+    system: undefined as string | undefined,
     async chat() {
       return ''
     },
-    async generateJSON() {
+    async generateJSON(messages: any[], options?: { systemPrompt?: string }) {
+      client.sent.push(JSON.parse(JSON.stringify(messages)))
+      client.system = options?.systemPrompt
       const answer = answers[client.calls]
       client.calls++
       if (answer instanceof Error) throw answer
       return answer
     }
   }
-  return client as unknown as AIClient & { calls: number }
+  return client as unknown as AIClient & { calls: number; sent: any[][]; system?: string }
+}
+
+/** 첫 요청에 실려 나간 사람 쪽 말. 이어 붙인 것까지 한 덩어리로 본다. */
+function firstAsk(client: { sent: any[][] }): string {
+  const content = client.sent[0]![0]!.content
+  return typeof content === 'string' ? content : JSON.stringify(content)
 }
 
 afterEach(() => setDefaultAIClient(undefined))
@@ -162,3 +178,119 @@ describe('후보를 만들 때', () => {
     )
   })
 })
+
+describe('무엇을 시키는지가 프롬프트에 실린다', () => {
+  /*
+    고치는 요청에서 이 지시가 빠지면 AI 가 부품 이름을 갈아 버린다. 부품 이름은 **저장되는
+    식별자**라서, 이미 배치된 보드의 바인딩·애니메이션이 그 이름을 가리키고 있다. 조용히
+    끊기고, 끊긴 것은 그 보드를 열어 봐야 드러난다.
+  */
+  it('고치는 요청이면 지금 정본과 「이름을 바꾸지 말라」가 함께 나간다', async () => {
+    const client = stubClient([candidate()])
+    setDefaultAIClient(client)
+
+    const base = candidate({ type: 'MIXER' }) as never
+    await proposeFigure({ prompt: '재질을 줄여줘', palette: PALETTE, base })
+
+    const ask = firstAsk(client)
+    expect(ask).toContain('Revise this existing figure')
+    expect(ask).toMatch(/renaming a part breaks bindings/)
+    // 지금 정본이 실제로 실려 나가야 한다 — 없으면 모델이 처음부터 만든다.
+    expect(ask).toContain('"name":"body"')
+  })
+
+  /*
+    타입 이름을 안 주면 `FIGURE` 로 나간다. **조용히 지어지는 값**이라 못 박아 둔다 — 저작면이
+    타입을 늘 주므로 이 자리는 평소 안 보이지만, 안 주는 부르는 쪽이 생기면 모델이 만든 것이
+    전부 `FIGURE` 라는 이름을 갖게 된다. 타입 이름은 저장되는 식별자다.
+  */
+  it('타입을 안 주면 FIGURE 로 나간다 — 조용히 빈 이름을 보내지 않는다', async () => {
+    const client = stubClient([candidate()])
+    setDefaultAIClient(client)
+
+    await proposeFigure({ prompt: '무언가', palette: PALETTE })
+
+    expect(firstAsk(client)).toContain('type "FIGURE"')
+  })
+
+  it('새로 만드는 요청이면 타입 이름이 나가고 고치라는 말은 안 나간다', async () => {
+    const client = stubClient([candidate()])
+    setDefaultAIClient(client)
+
+    await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })
+
+    const ask = firstAsk(client)
+    expect(ask).toContain('type "MIXER"')
+    expect(ask).not.toContain('Revise this existing figure')
+  })
+
+  /*
+    그림은 **비례를 보라고** 주는 것이지 표면 무늬를 베끼라고 주는 것이 아니다. 그 말이 빠지면
+    모델이 사진의 로고·녹·글자까지 부품으로 만들려 들고, 로우폴리에서 그것은 부품 낭비다.
+  */
+  it('그림을 주면 비례를 보라는 말과 함께 나간다', async () => {
+    const client = stubClient([candidate()])
+    setDefaultAIClient(client)
+
+    await proposeFigure({
+      prompt: '이 설비',
+      palette: PALETTE,
+      type: 'MIXER',
+      image: { data: Buffer.from('89504e47', 'hex'), mediaType: 'image/png' }
+    })
+
+    const ask = firstAsk(client)
+    expect(ask).toMatch(/proportions and masses, not for surface detail/)
+    // 그림 자체도 실려야 한다 — 말만 나가고 그림이 빠지면 모델이 볼 것이 없다.
+    expect(ask).toContain('"type":"image"')
+  })
+})
+
+describe('모델이 JSON 을 못 낼 때', () => {
+  /*
+    어댑터가 던지는 경우다. 그것도 사유이므로 **돌려주고 다시 시킨다** — 던져 버리면 저작자는
+    「안 됐다」만 보고, 무엇이 문제였는지도 모델이 고칠 기회도 없다.
+  */
+  it('던진 사유를 돌려주고 다시 시킨다', async () => {
+    const client = stubClient([new Error('unterminated string'), candidate()])
+    setDefaultAIClient(client)
+
+    const result = await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })
+
+    expect(result.attempts).toBe(2)
+    expect(client.calls).toBe(2)
+
+    // 두 번째 요청에 그 사유가 실려야 한다.
+    const retry = JSON.stringify(client.sent[1])
+    expect(retry).toContain('unterminated string')
+    expect(retry).toMatch(/Answer with the JSON object only/)
+  })
+
+  it('세 번 다 던지면 못 만들었다고 말한다', async () => {
+    setDefaultAIClient(stubClient([new Error('a'), new Error('b'), new Error('c')]))
+
+    await expect(proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })).rejects.toThrow(ProposeFailure)
+  })
+})
+
+describe('정책을 넘은 후보는 막지 않고 알린다', () => {
+  /*
+    형식의 두 갈래를 그대로 지킨다 — `errors` 는 막고 `violations` 는 알린다. 정책 위반으로
+    후보를 버리면 저작자가 판단할 기회가 없어진다. 랜드마크 설비 하나는 정교해도 되고, 그
+    대가가 숫자로 보이면 된다.
+  */
+  it('등급 한도를 넘겨도 후보로 오고 위반이 함께 온다', async () => {
+    const many = Array.from({ length: PART_LIMIT.S + 1 }, (_, at) => ({
+      name: `part-${at}`,
+      primitive: PRIMITIVE_KINDS[0],
+      transform: { position: { x: at * 10, y: 0, z: 0 }, size: { x: 20, y: 20, z: 20 } },
+      material: { token: PALETTE[0] }
+    }))
+    setDefaultAIClient(stubClient([candidate({ detailLevel: 'S', parts: many })]))
+
+    const result = await proposeFigure({ prompt: '단순한 것', palette: PALETTE, type: 'MIXER' })
+
+    expect(result.source.parts).toHaveLength(PART_LIMIT.S + 1)
+    expect(result.violations.map(one => one.code)).toContain('too-many-parts')
+  })
+})

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

@@ -5,7 +5,8 @@ import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from
 
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
-import { FigureList } from './figure-type.js'
+import { inspectSource } from './figure-gate.js'
+import { FigureInspection, FigureList } from './figure-type.js'
 
 @Resolver(Figure)
 export class FigureQuery {
@@ -82,6 +83,30 @@ export class FigureQuery {
     })
   }
 
+  /**
+   * 발행해도 되나 — **누르기 전에** 묻는 자리.
+   *
+   * 판정은 `figure-gate.ts` 가 하고 이 자리는 정본을 꺼내 넘긴다. 같은 판정을 `releaseFigure` 도
+   * 부른다 — 화면이 물어 보고 통과했더라도 그 사이에 정본이 바뀌었을 수 있으므로, 막는 것은 언제나
+   * 뮤테이션이다. 이 질의는 **이유를 미리 보여 주기 위한 것**이고 허가증이 아니다.
+   */
+  @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => FigureInspection, { description: 'Whether a figure may be released, with the reasons.' })
+  async inspectFigure(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<FigureInspection> {
+    const { domain } = context.state
+
+    const figure = await getRepository(Figure).findOne({
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id },
+      select: { id: true, source: true }
+    })
+
+    if (!figure) {
+      throw new Error(`Figure ${id} 를 찾을 수 없다`)
+    }
+
+    return inspectSource(figure.source)
+  }
+
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => [String], { description: 'All figure type names in scope — used to check name collisions before create.' })
   async figureTypeNames(@Ctx() context: ResolverContext): Promise<string[]> {