@things-factory/figure-service 10.1.178 → 10.1.180

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.178",
+  "version": "10.1.180",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -27,16 +27,16 @@
   "dependencies": {
     "@hatiolab/figure-model": "^0.7.2",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.178",
-    "@things-factory/attachment-base": "^10.1.178",
-    "@things-factory/auth-base": "^10.1.178",
+    "@things-factory/ai-client-base": "^10.1.179",
+    "@things-factory/attachment-base": "^10.1.179",
+    "@things-factory/auth-base": "^10.1.179",
     "@things-factory/env": "^10.1.149",
-    "@things-factory/setting-base": "^10.1.178",
-    "@things-factory/shell": "^10.1.178",
+    "@things-factory/setting-base": "^10.1.179",
+    "@things-factory/shell": "^10.1.179",
     "graphql-scalars": "^1.22.4",
     "graphql-upload": "^15.0.2",
     "jszip": "^3.10.1",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "d57448d3f3045f72a9f24b877a3e306eb34cbaf1"
+  "gitHead": "2549e50c0790c05a75781d133f5d975cff3b02f9"
 }

package/server/index.ts

@@ -42,3 +42,5 @@ process.on('bootstrap-module-start' as any, () => {
 export * from './service/index.js'
 export * from './migrations/index.js'
 export { registerFigureToolCategories } from './service/figure/figure-tools.js'
+export { registerFigureCategories, figureCategories } from './service/figure/figure-categories.js'
+export { registerFigureReleaseCheck, type FigureReleaseCheck, type FigureReleaseCheckInput, type GateFinding } from './service/figure/figure-format.js'

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

@@ -6,6 +6,7 @@ import { getRepository } from '@things-factory/shell'
 import { meshAttachmentOf } from '../service/figure/figure-mesh-store.js'
 import { GLB_MIMETYPE } from '../service/figure/figure-glb.js'
 import { thumbnailFiles, type ThumbnailFiles } from '../service/figure/figure-thumbnail-store.js'
+import { publicDomainsOfFile } from '../service/figure/figure-public.js'
 
 /**
  * A mesh part's file, by its hash (ADR-0129 decision 8): what the modeller and a board draw a mesh part from, on the
@@ -38,7 +39,10 @@ export async function sendFigureMesh(
     context.status = 404
     return
   }
-  const kept = await meshAttachmentOf({ getRepository }, [domain.id, domain.parentId].filter(Boolean) as string[], hash)
+  /* Its own or its parent's, or kept by a domain whose public figure's releases draw from it (G2). */
+  const kept =
+    (await meshAttachmentOf({ getRepository }, [domain.id, domain.parentId].filter(Boolean) as string[], hash)) ??
+    (await meshAttachmentOf({ getRepository }, await publicDomainsOfFile(hash, domain), hash))
   if (!kept) {
     context.status = 404
     return

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

@@ -9,6 +9,7 @@ import { readFileSync } from 'fs'
 import { Figure } from '../service/figure/figure.js'
 import { thumbnailAttachmentOf, thumbnailFiles, type ThumbnailFiles } from '../service/figure/figure-thumbnail-store.js'
 import { recipeTemplates } from '../service/figure-recipe/figure-recipe-templates.js'
+import { readableFigure } from '../service/figure/figure-public.js'
 
 /**
  * 썸네일을 **그림으로** 내보내는 길.
@@ -80,11 +81,8 @@ export async function sendFigureThumbnail(
     읽기는 부모 도메인까지 본다 — `figure` 질의와 같은 범위다. 물려받은 형상을 목록에는 보여 주고
     그림만 404 를 내면, 화면은 「그림이 아직 없다」고 거짓말하게 된다.
   */
-  const found = await getRepository(Figure).findOne({
-    where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id },
-    relations: { domain: true },
-    select: { id: true, thumbnailHash: true, thumbnailUpdatedAt: true, domain: { id: true } }
-  })
+  /* Another domain's public figure is read too (G2): its card is what a reader chooses it by. */
+  const found = await readableFigure(domain, id, { id: true, thumbnailHash: true, thumbnailUpdatedAt: true, public: true, domain: { id: true } })
   if (!found?.thumbnailHash) {
     context.status = 404
     return

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

@@ -0,0 +1,50 @@
+import { Refusal } from '@things-factory/shell'
+
+/*
+ * The categories an app allows (LV figure-server design G5). Without a registration a category is free text, as
+ * operato-figure has it. An app that registers its vocabulary -- the LV figure-server: EQUIPMENT, CARRIER, UTILITY,
+ * COMPONENT -- gets three rules: a category outside it is refused, a category once set is not changed, and a figure
+ * is not released without one. The vocabulary is the app's; this module does not know what the words mean.
+ */
+
+let registered: readonly string[] | null = null
+
+/** Registers the categories this server allows. Called once at the top of the app's server module. */
+export function registerFigureCategories(codes: readonly string[]): void {
+  const cleaned = codes.map(code => (typeof code === 'string' ? code.trim() : ''))
+  if (!cleaned.length || cleaned.some(code => !code) || new Set(cleaned).size !== cleaned.length) {
+    throw new Error(`registerFigureCategories needs distinct non-empty codes, not ${JSON.stringify(codes)}.`)
+  }
+  registered = Object.freeze([...cleaned])
+}
+
+/** The categories registered, or null when a category is free text. */
+export function figureCategories(): readonly string[] | null {
+  return registered
+}
+
+/** For tests: back to free text. */
+export function clearFigureCategories(): void {
+  registered = null
+}
+
+/** A category being set on a figure: refused outside the vocabulary, and when the figure already has another. */
+export function assertFigureCategory(next: string | null | undefined, current?: string | null): void {
+  if (!registered || next === undefined) return
+  const wanted = (next ?? '').trim()
+  const had = (current ?? '').trim()
+  if (had && wanted !== had) {
+    throw new Refusal('figure-category-fixed', { category: had }, 'the category {category} is set once and does not change.')
+  }
+  if (wanted && !registered.includes(wanted)) {
+    throw new Refusal('figure-category-unknown', { category: wanted, allowed: registered.join(', ') }, '{category} is not a category here. use one of {allowed}.')
+  }
+}
+
+/** A figure going out: with a vocabulary registered it carries one of its categories. */
+export function assertReleasableCategory(category: string | null | undefined, type: string): void {
+  if (!registered) return
+  if (!(category ?? '').trim()) {
+    throw new Refusal('figure-category-missing', { type, allowed: registered.join(', ') }, '{type} has no category. choose one of {allowed} before releasing.')
+  }
+}

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

@@ -0,0 +1,127 @@
+/**
+ * An app's category vocabulary (LV figure-server design G5), on sqlite: without one a category is free text; with one,
+ * a category outside it is refused, a category once set does not change, and a figure goes out only with one.
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const settingBase = require('@things-factory/setting-base')
+const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, proposeFigureOccupancy } = require('@hatiolab/figure-model')
+
+let dataSource: DataSource | null = null
+let Figure: any
+let FigureHistory: any
+let FigureNamespace: any
+let FigureMutation: any
+let FigureQuery: any
+let categories: 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먼저 빌드할 것:\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
+  FigureNamespace = loadCompiled('service/figure/figure-namespace-entity').FigureNamespace
+  const Subscriber = loadCompiled('service/figure/event-subscriber').FigureHistoryEntitySubscriber
+  ;({ FigureMutation } = loadCompiled('service/figure/figure-mutation'))
+  ;({ FigureQuery } = loadCompiled('service/figure/figure-query'))
+  categories = loadCompiled('service/figure/figure-categories')
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory, FigureNamespace],
+    subscribers: [Subscriber],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+afterAll(async () => {
+  categories?.clearFigureCategories()
+  await dataSource?.destroy()
+  dataSource = null
+})
+afterEach(() => categories.clearFigureCategories())
+
+const releasable = () => {
+  let a = addFigureBox(createFigureAsset('Mixer'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'body', face: 'bottom', to: { plane: 'mounting-plane' } })
+  return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a, { over: 'range' }), placement: 'floor' }))
+}
+let seq = 0
+async function context() {
+  const name = `cat-${++seq}`
+  const domain = await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name })
+  return { state: { domain, user: undefined, tx: dataSource!.manager } }
+}
+const draft = (ctx: any, type: string) =>
+  new FigureMutation().saveFigure(releasable(), ctx, undefined, undefined, require('crypto').randomUUID(), undefined, type)
+const LV = ['EQUIPMENT', 'CARRIER', 'UTILITY', 'COMPONENT']
+
+describe('categories', () => {
+  it('are free text without a vocabulary: any, changed at will, not needed to release', async () => {
+    const ctx = await context()
+    expect(await new FigureQuery().figureCategories()).toBeNull()
+    const figure = await draft(ctx, 'free')
+    await new FigureMutation().updateFigure(figure.id, { category: 'conveyors' }, ctx)
+    await new FigureMutation().updateFigure(figure.id, { category: 'lines' }, ctx)
+    await expect(new FigureMutation().releaseFigure(figure.id, 'one', ctx)).resolves.toMatchObject({ version: 1 })
+  })
+
+  it('with a vocabulary: one of it, set once, and needed to release', async () => {
+    categories.registerFigureCategories(LV)
+    expect(await new FigureQuery().figureCategories()).toEqual(LV)
+    const ctx = await context()
+    const figure = await draft(ctx, 'mixer')
+    await expect(new FigureMutation().releaseFigure(figure.id, 'one', ctx)).rejects.toMatchObject({ code: 'figure-category-missing' })
+    await expect(new FigureMutation().updateFigure(figure.id, { category: 'conveyors' }, ctx)).rejects.toMatchObject({ code: 'figure-category-unknown' })
+    await new FigureMutation().updateFigure(figure.id, { category: 'EQUIPMENT' }, ctx)
+    await expect(new FigureMutation().updateFigure(figure.id, { category: 'CARRIER' }, ctx)).rejects.toMatchObject({ code: 'figure-category-fixed' })
+    await expect(new FigureMutation().updateFigure(figure.id, { category: 'EQUIPMENT', description: 'same category again' }, ctx)).resolves.toBeTruthy()
+    await expect(new FigureMutation().releaseFigure(figure.id, 'one', ctx)).resolves.toMatchObject({ version: 1 })
+  })
+
+  it('with a vocabulary, creating directly refuses a category outside it', async () => {
+    categories.registerFigureCategories(LV)
+    const ctx = await context()
+    await expect(new FigureMutation().createFigure({ type: 'odd', name: 'o', source: releasable(), category: 'misc' }, ctx)).rejects.toMatchObject({ code: 'figure-category-unknown' })
+    const made = await new FigureMutation().createFigure({ type: 'carrier-roll', name: 'r', source: releasable(), category: 'CARRIER' }, ctx)
+    expect(made.figure.category).toBe('CARRIER')
+  })
+
+  it('a vocabulary is distinct non-empty codes', () => {
+    expect(() => categories.registerFigureCategories([])).toThrow()
+    expect(() => categories.registerFigureCategories(['A', 'A'])).toThrow()
+    expect(() => categories.registerFigureCategories(['A', ' '])).toThrow()
+  })
+})
+
+describe('an app release check, on the way out', () => {
+  it('a blocking finding refuses the release; taken off, it goes out', async () => {
+    const { registerFigureReleaseCheck } = loadCompiled('service/figure/figure-format')
+    const take = registerFigureReleaseCheck(() => [{ code: 'app-origin-off', message: 'the origin is off the middle', blocking: true }])
+    try {
+      const ctx = await context()
+      const figure = await draft(ctx, 'checked')
+      await expect(new FigureMutation().releaseFigure(figure.id, 'one', ctx)).rejects.toThrow(/origin is off the middle/)
+      take()
+      await expect(new FigureMutation().releaseFigure(figure.id, 'one', ctx)).resolves.toMatchObject({ version: 1 })
+    } finally {
+      take()
+    }
+  })
+})

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

@@ -10,6 +10,7 @@ const authBase = require('@things-factory/auth-base')
 const settingBase = require('@things-factory/setting-base')
 const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, proposeFigureOccupancy } = require('@hatiolab/figure-model')
 
+let FigureNamespace: any
 let dataSource: DataSource | null = null
 let Figure: any
 let FigureHistory: any
@@ -28,6 +29,7 @@ function loadCompiled(modulePath: string): any {
 
 beforeAll(async () => {
   Figure = loadCompiled('service/figure/figure').Figure
+  FigureNamespace = loadCompiled('service/figure/figure-namespace-entity').FigureNamespace
   FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
   Subscriber = loadCompiled('service/figure/event-subscriber').FigureHistoryEntitySubscriber
   ;({ FigureMutation, assertNames } = loadCompiled('service/figure/figure-mutation'))
@@ -37,7 +39,7 @@ beforeAll(async () => {
     synchronize: true,
     dropSchema: true,
     namingStrategy: new shell.NamingStrategy(),
-    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory],
+    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory, FigureNamespace],
     subscribers: [Subscriber],
     logging: false
   })
@@ -49,9 +51,9 @@ afterAll(async () => {
   dataSource = null
 })
 
-/** The domain setting every figure here is created under (ADR-0114). */
+/** The domain's own default namespace, its subdomain, that every figure here is created and released under (G1). */
 async function namespaced(domain: any) {
-  await dataSource!.getRepository(settingBase.Setting).save({ domain, name: 'figure-namespace', category: 'figure', value: 'system' })
+  await dataSource!.getRepository(FigureNamespace).save({ domain, name: domain.subdomain, state: 'active', isDefault: true })
   return domain
 }
 
@@ -66,7 +68,7 @@ async function released(type: string) {
   const name = `retire-${++seq}`
   const domain = await namespaced(await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name }))
   const context = { state: { domain, user: undefined, tx: dataSource!.manager } }
-  const figure = await dataSource!.getRepository(Figure).save({ namespace: 'system', type, name: 'mixer', source: releasable(), state: 'draft', version: 0, domain })
+  const figure = await dataSource!.getRepository(Figure).save({ namespace: domain.subdomain, type, name: 'mixer', source: releasable(), state: 'draft', version: 0, domain })
   await new FigureMutation().releaseFigure(figure.id, 'one', context)
   return { figure, context, domain }
 }
@@ -75,7 +77,7 @@ const historyCount = (id: string) => dataSource!.getRepository(FigureHistory).co
 describe('retiring a figure', () => {
   it('stays released, writes no history row, and names what to use instead', async () => {
     const { figure, context, domain } = await released('OLD_MIXER')
-    await dataSource!.getRepository(Figure).save({ namespace: 'system', type: 'NEW_MIXER', name: 'new', source: releasable(), state: 'draft', version: 0, domain })
+    await dataSource!.getRepository(Figure).save({ namespace: domain.subdomain, type: 'NEW_MIXER', name: 'new', source: releasable(), state: 'draft', version: 0, domain })
     const retired = await new FigureMutation().setFigureDeprecation(figure.id, true, context, 'NEW_MIXER')
     expect([retired.deprecated, retired.supersededBy, retired.state, retired.version]).toEqual([true, 'NEW_MIXER', 'released', 1])
     expect(await historyCount(figure.id)).toBe(1)
@@ -104,7 +106,7 @@ describe('names by language', () => {
     const name = `names-${++seq}`
     const domain = await namespaced(await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name }))
     const context = { state: { domain, user: undefined, tx: dataSource!.manager } }
-    const figure = await dataSource!.getRepository(Figure).save({ namespace: 'system', type: 'NAMED', name: 'mixer', source: releasable(), state: 'draft', version: 0, domain })
+    const figure = await dataSource!.getRepository(Figure).save({ namespace: domain.subdomain, type: 'NAMED', name: 'mixer', source: releasable(), state: 'draft', version: 0, domain })
     await new FigureMutation().updateFigure(figure.id, { names: { en: 'Mixer', ko: '믹서' } }, context)
     await new FigureMutation().releaseFigure(figure.id, 'one', context)
     const [row] = await dataSource!.getRepository(FigureHistory).find({ where: { originalId: figure.id } })
@@ -112,3 +114,105 @@ describe('names by language', () => {
     await expect(new FigureMutation().updateFigure(figure.id, { names: { English: 'x' } }, context)).rejects.toThrow(/English/)
   })
 })
+
+describe('deleting a figure', () => {
+  const draftOnly = async (type: string) => {
+    const name = `delete-${++seq}`
+    const domain = await namespaced(await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name }))
+    const context = { state: { domain, user: undefined, tx: dataSource!.manager } }
+    const figure = await dataSource!.getRepository(Figure).save({ namespace: domain.subdomain, type, name: 'mixer', source: releasable(), state: 'draft', version: 0, domain })
+    return { figure, context }
+  }
+  const stillThere = (id: string) => dataSource!.getRepository(Figure).findOne({ where: { id } })
+
+  it('deletes a figure that has never been released', async () => {
+    const { figure, context } = await draftOnly('NEVER_RELEASED')
+    expect(await new FigureMutation().deleteFigure(figure.id, context)).toBe(true)
+    expect(await stillThere(figure.id)).toBeNull()
+    const row = await dataSource!.getRepository(Figure).findOne({ where: { id: figure.id }, withDeleted: true })
+    expect(row?.deletedAt).toBeTruthy()
+  })
+
+  it('refuses a released figure and leaves it and its release as they were', async () => {
+    const { figure, context } = await released('SHIPPED_MIXER')
+    await expect(new FigureMutation().deleteFigure(figure.id, context)).rejects.toMatchObject({
+      code: 'figure-released-not-deletable',
+      params: { type: 'SHIPPED_MIXER' }
+    })
+    expect((await stillThere(figure.id))?.version).toBe(1)
+    expect(await historyCount(figure.id)).toBe(1)
+  })
+
+  it('refuses a released figure whose draft was edited again', async () => {
+    const { figure, context } = await released('EDITED_MIXER')
+    await new FigureMutation().updateFigure(figure.id, { description: 'changed after release' }, context)
+    expect((await stillThere(figure.id))?.state).toBe('draft')
+    await expect(new FigureMutation().deleteFigure(figure.id, context)).rejects.toMatchObject({ code: 'figure-released-not-deletable' })
+    expect(await stillThere(figure.id)).not.toBeNull()
+  })
+
+  it('refuses by the release rows even when the figure says version 0', async () => {
+    const { figure, context } = await released('ROWS_SAY_RELEASED')
+    await dataSource!.getRepository(Figure).createQueryBuilder().update(Figure).set({ version: 0 }).where('id = :id', { id: figure.id }).callListeners(false).execute()
+    await expect(new FigureMutation().deleteFigure(figure.id, context)).rejects.toMatchObject({ code: 'figure-released-not-deletable' })
+  })
+})
+
+/*
+ * A domain reads its parent's figures and writes only its own (LV figure-server design G3): updating, releasing and
+ * retiring a parent's figure from a child domain are refused as not found, as saving its draft always was.
+ */
+describe('writes stay in the domain that owns the figure', () => {
+  async function parentAndChild() {
+    const parent = await namespaced(await dataSource!.getRepository(shell.Domain).save({ name: `parent-${++seq}`, subdomain: `parent-${seq}` }))
+    const saved = await dataSource!.getRepository(shell.Domain).save({ name: `child-${seq}`, subdomain: `child-${seq}`, parent })
+    const child = await namespaced(await dataSource!.getRepository(shell.Domain).findOneOrFail({ where: { id: saved.id } }))
+    expect(child.parentId).toBe(parent.id)
+    const figure = await dataSource!.getRepository(Figure).save({ namespace: parent.subdomain, type: `parents-${seq}`, name: 'mixer', source: releasable(), state: 'draft', version: 0, domain: parent })
+    const as = (domain: any) => ({ state: { domain, user: undefined, tx: dataSource!.manager } })
+    return { figure, parentContext: as(parent), childContext: as(child) }
+  }
+
+  it('a child domain cannot update, release or retire its parent figure', async () => {
+    const { figure, childContext } = await parentAndChild()
+    await expect(new FigureMutation().updateFigure(figure.id, { description: 'from the child' }, childContext)).rejects.toThrow(/찾을 수 없다/)
+    await expect(new FigureMutation().releaseFigure(figure.id, 'from the child', childContext)).rejects.toThrow(/찾을 수 없다/)
+    await expect(new FigureMutation().setFigureDeprecation(figure.id, true, childContext)).rejects.toThrow(/찾을 수 없다/)
+    const row = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    expect([row.description ?? null, row.version, row.deprecated]).toEqual([null, 0, false])
+    expect(await historyCount(figure.id)).toBe(0)
+  })
+
+  it('the owning domain still does all three', async () => {
+    const { figure, parentContext } = await parentAndChild()
+    await new FigureMutation().updateFigure(figure.id, { description: 'from the owner' }, parentContext)
+    await new FigureMutation().releaseFigure(figure.id, 'one', parentContext)
+    const retired = await new FigureMutation().setFigureDeprecation(figure.id, true, parentContext)
+    expect([retired.description, retired.version, retired.deprecated]).toEqual(['from the owner', 1, true])
+  })
+
+  it('a child figure may still name a parent figure to use instead', async () => {
+    const { figure: parentFigure, childContext } = await parentAndChild()
+    const child = childContext.state.domain
+    const own = await dataSource!.getRepository(Figure).save({ namespace: child.subdomain, type: `childs-${seq}`, name: 'own', source: releasable(), state: 'draft', version: 0, domain: child })
+    await new FigureMutation().releaseFigure(own.id, 'one', childContext)
+    const retired = await new FigureMutation().setFigureDeprecation(own.id, true, childContext, parentFigure.type)
+    expect(retired.supersededBy).toBe(parentFigure.type)
+  })
+})
+
+/* Releasing and retiring are their own gate (LV figure-server design G6); editing a draft stays under figure:mutation. */
+describe('who may release', () => {
+  const declarationOf = (method: string) => {
+    const { readFileSync } = require('fs')
+    const { join } = require('path')
+    const source = readFileSync(join(__dirname, 'figure-mutation.ts'), 'utf-8')
+    const preceding = source.slice(0, source.indexOf(`async ${method}(`))
+    return preceding.slice(preceding.lastIndexOf("@Directive('@privilege("))
+  }
+
+  it('releasing and retiring ask figure-release, editing asks figure', () => {
+    for (const method of ['releaseFigure', 'setFigureDeprecation']) expect(declarationOf(method)).toContain('category: "figure-release", privilege: "mutation"')
+    for (const method of ['saveFigure', 'createFigure', 'updateFigure', 'deleteFigure', 'revertFigureVersion']) expect(declarationOf(method)).toContain('category: "figure", privilege: "mutation"')
+  })
+})

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

@@ -51,6 +51,45 @@ export interface Inspection {
   blocked: boolean
 }
 
+/** What an app's release check is shown: the figure's asset, its row's type and category, and the reader's words. */
+export interface FigureReleaseCheckInput {
+  asset: FigureAsset
+  type?: string
+  category?: string | null
+  t?: Translate
+}
+
+/**
+ * A check an app adds to releasing (LV figure-server design G10): findings in the gate's own shape, blocking or said.
+ * The LV figure-server refuses an origin off the middle of the room, which operato-figure only says (ADR-0104
+ * decision 4: refusing is the receiving side's), and says its carrier and budget advice.
+ */
+export type FigureReleaseCheck = (input: FigureReleaseCheckInput) => GateFinding[]
+
+const releaseChecks: FigureReleaseCheck[] = []
+
+/** Adds a check to every release verdict (`inspectFigure`, `releaseFigure`). Returns the way to take it off again. */
+export function registerFigureReleaseCheck(check: FigureReleaseCheck): () => void {
+  releaseChecks.push(check)
+  return () => {
+    const at = releaseChecks.indexOf(check)
+    if (at >= 0) releaseChecks.splice(at, 1)
+  }
+}
+
+/** The app's checks on an asset the kernel passed. A check that throws blocks, by name: a check is never skipped. */
+function appFindings(input: FigureReleaseCheckInput): GateFinding[] {
+  const found: GateFinding[] = []
+  for (const check of releaseChecks) {
+    try {
+      found.push(...check(input))
+    } catch (e) {
+      found.push({ code: 'release-check-failed', message: `a release check failed: ${(e as Error)?.message ?? String(e)}`, blocking: true })
+    }
+  }
+  return found
+}
+
 /**
  * That the source is JSON and names the format.
  *
@@ -214,7 +253,9 @@ export function inspectSource(
   releasedJson?: string | null,
   t?: Translate,
   /** The row's `type` -- the only place the name lives, since the asset carries none. */
-  rowType?: string
+  rowType?: string,
+  /** The row's category, for an app's release checks (G10). */
+  rowCategory?: string | null
 ): Inspection {
   if (!sourceJson) {
     return { blocked: true, findings: [{ code: 'no-source', message: '저장된 정본이 없다. 저장하면 발행할 수 있다', blocking: true }] }
@@ -296,6 +337,7 @@ export function inspectSource(
     })
   }
   if (releasedJson) findings.push(...figureContractFindings(asset!, releasedJson, say))
+  findings.push(...appFindings({ asset: asset!, type: rowType, category: rowCategory, t }))
   return { blocked: findings.some(finding => finding.blocking), findings }
 }
 

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

@@ -14,6 +14,7 @@ const settingBase = require('@things-factory/setting-base')
 const JSZip = require('jszip')
 const { createFigureAsset, addFigurePrimitive, serializeFigureAsset, readFigurePackage } = require('@hatiolab/figure-model')
 
+let FigureNamespace: any
 let dataSource: DataSource | null = null
 let Figure: any, FigureHistory: any, FigureReplacedDraft: any, FigureMutation: any
 let keepMesh: any, useThumbnailFiles: any, sha256Of: any, sendFigureMesh: any, figurePackageOf: any
@@ -87,6 +88,7 @@ let files: ReturnType<typeof mapFiles>
 let restore: any
 beforeAll(async () => {
   Figure = loadCompiled('service/figure/figure').Figure
+  FigureNamespace = loadCompiled('service/figure/figure-namespace-entity').FigureNamespace
   FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
   FigureReplacedDraft = loadCompiled('service/figure/figure-replaced-draft').FigureReplacedDraft
   FigureMutation = loadCompiled('service/figure/figure-mutation').FigureMutation
@@ -100,7 +102,7 @@ beforeAll(async () => {
     synchronize: true,
     dropSchema: true,
     namingStrategy: new shell.NamingStrategy(),
-    entities: [...shell.entities, ...authBase.entities, ...attachmentBase.entities, ...settingBase.entities, Figure, FigureHistory, FigureReplacedDraft],
+    entities: [...shell.entities, ...authBase.entities, ...attachmentBase.entities, ...settingBase.entities, Figure, FigureHistory, FigureReplacedDraft, FigureNamespace],
     logging: false
   })
   await dataSource.initialize()
@@ -126,7 +128,7 @@ const newDomain = async (parent?: any) => {
   const name = `mesh-${++seq}`
   const saved = await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name, ...(parent ? { parent } : {}) })
   const domain = await dataSource!.getRepository(shell.Domain).findOneOrFail({ where: { id: saved.id } })
-  await dataSource!.getRepository(settingBase.Setting).save({ domain, name: 'figure-namespace', category: 'figure', value: 'system' })
+  await dataSource!.getRepository(FigureNamespace).save({ domain, name: domain.subdomain, state: 'active', isDefault: true })
   return domain
 }
 const meshRows = (domainId: string) => dataSource!.getRepository(attachmentBase.Attachment).find({ where: { refType: 'figure-mesh', domain: { id: domainId } } })