@things-factory/figure-service 10.1.116 → 10.1.121

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

@@ -0,0 +1,181 @@
+/**
+ * Full figure names on the authoring server (ADR-0114): the namespace a figure is created under, the batch door
+ * `figureBlueprints`, and the package a board server imports. sqlite, history subscriber on.
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const { createHash } = require('crypto')
+const JSZip = require('jszip')
+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, readFigurePackage } = require('@hatiolab/figure-model')
+
+let dataSource: DataSource | null = null
+let Figure: any
+let FigureMutation: any
+let FigureQuery: any
+let figurePackageOf: 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
+  const FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
+  const Subscriber = loadCompiled('service/figure/event-subscriber').FigureHistoryEntitySubscriber
+  ;({ FigureMutation } = loadCompiled('service/figure/figure-mutation'))
+  ;({ FigureQuery } = loadCompiled('service/figure/figure-query'))
+  ;({ figurePackageOf } = loadCompiled('service/figure/figure-package-export'))
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory],
+    subscribers: [Subscriber],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+afterAll(async () => {
+  await dataSource?.destroy()
+  dataSource = null
+})
+
+const releasable = (label = 'Conveyor') => {
+  let a = addFigureBox(createFigureAsset(label), { 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 domainWith(namespace: string | null) {
+  const name = `ns-${++seq}`
+  const domain = await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name })
+  if (namespace !== null) {
+    await dataSource!.getRepository(settingBase.Setting).save({ domain, name: 'figure-namespace', category: 'figure', value: namespace })
+  }
+  const context = { state: { domain, user: undefined, tx: dataSource!.manager } }
+  return { domain, context }
+}
+
+const creationId = () => require('crypto').randomUUID()
+const setNamespace = (domain: any, value: string) =>
+  dataSource!.getRepository(settingBase.Setting).update({ domain: { id: domain.id }, name: 'figure-namespace' }, { value })
+
+async function releasedFigure(context: any, type: string) {
+  const figure = await new FigureMutation().saveFigure(releasable(type), context, undefined, undefined, creationId(), undefined, type)
+  await new FigureMutation().releaseFigure(figure.id, 'first', context)
+  return figure
+}
+
+describe('the namespace a figure is created under', () => {
+  it('is copied from the domain setting onto a new figure', async () => {
+    const { context } = await domainWith('hatiolab.com')
+    const figure = await new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'conveyor')
+    expect(figure.namespace).toBe('hatiolab.com')
+    expect(figure.type).toBe('conveyor')
+  })
+
+  it('is refused by name when the domain has none, or an invalid one', async () => {
+    for (const value of [null, 'Hatiolab.COM']) {
+      const { context } = await domainWith(value)
+      await expect(
+        new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'conveyor')
+      ).rejects.toMatchObject({ code: 'figure-namespace-missing' })
+    }
+  })
+
+  it('cannot change: a new figure or a release is refused while the setting disagrees with the figures already made', async () => {
+    const { domain, context } = await domainWith('hatiolab.com')
+    const draft = await new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'conveyor')
+    await setNamespace(domain, 'other.com')
+    await expect(
+      new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'lifter')
+    ).rejects.toMatchObject({ code: 'figure-namespace-changed' })
+    await expect(new FigureMutation().releaseFigure(draft.id, 'c', context)).rejects.toMatchObject({ code: 'figure-namespace-changed' })
+
+    await setNamespace(domain, 'hatiolab.com')
+    await expect(new FigureMutation().releaseFigure(draft.id, 'c', context)).resolves.toMatchObject({ version: 1 })
+  })
+
+  it('refuses an upper-case type when creating directly', async () => {
+    const { context } = await domainWith('hatiolab.com')
+    await expect(
+      new FigureMutation().createFigure({ type: 'CONVEYOR', name: 'c', source: releasable() }, context)
+    ).rejects.toMatchObject({ code: 'figure-type-malformed' })
+  })
+})
+
+describe('figureBlueprints answers each full name, an item or a refusal', () => {
+  it('gives released figures by full name and refuses the rest by cause, none taking another away', async () => {
+    const { context } = await domainWith('hatiolab.com')
+    await releasedFigure(context, 'conveyor')
+    await new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'draft-only')
+
+    const answer = await new FigureQuery().figureBlueprints(
+      ['hatiolab.com/conveyor', 'hatiolab.com/draft-only', 'other.com/conveyor', 'CONVEYOR', 'hatiolab.com/conveyor'],
+      context
+    )
+
+    expect(answer.release).toBeNull()
+    expect(answer.items.map((item: any) => [item.type, item.ref])).toEqual([['hatiolab.com/conveyor', 'hatiolab.com/conveyor@1']])
+    expect(answer.items[0].asset.version).toBe('figure-asset-1')
+    expect(answer.refused.map((r: any) => [r.type, r.code])).toEqual([
+      ['hatiolab.com/draft-only', 'figure-not-released'],
+      ['other.com/conveyor', 'figure-not-released'],
+      ['CONVEYOR', 'figure-name-malformed']
+    ])
+  })
+})
+
+describe('the figure package', () => {
+  const sha256 = (bytes: Uint8Array) => createHash('sha256').update(bytes).digest('hex')
+
+  it('carries the release a board server reads back whole, and names the server it came from', async () => {
+    const { domain, context } = await domainWith('hatiolab.com')
+    const figure = await releasedFigure(context, 'trailer-22')
+
+    const { name, bytes } = await figurePackageOf({
+      refs: ['hatiolab.com/trailer-22@1'],
+      domain,
+      exportedBy: 'author',
+      sourceUrl: 'https://figure.hatiolab.com',
+      files: { put: async () => ({}), send: async () => {}, read: async () => Buffer.alloc(0) }
+    })
+    expect(name).toBe('hatiolab.com_trailer-22_1.figpkg')
+
+    const zip = await JSZip.loadAsync(bytes)
+    const files = new Map<string, Uint8Array>()
+    for (const path of Object.keys(zip.files)) if (!zip.files[path].dir) files.set(path, await zip.files[path].async('uint8array'))
+    const read = readFigurePackage(files, sha256)
+
+    expect(read.problems).toEqual([])
+    expect(read.refused).toEqual([])
+    expect(read.manifest.source).toEqual({ url: 'https://figure.hatiolab.com', domain: domain.subdomain })
+    expect(read.releases.map((r: any) => r.ref)).toEqual(['hatiolab.com/trailer-22@1'])
+    const stored = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    expect(read.releases[0].source).toBe(stored.source)
+  })
+
+  it('refuses a release this domain cannot read, and a malformed reference', async () => {
+    const { domain, context } = await domainWith('hatiolab.com')
+    await releasedFigure(context, 'conveyor')
+    const ask = (refs: string[]) => figurePackageOf({ refs, domain, exportedBy: null, sourceUrl: 'x' })
+    await expect(ask(['hatiolab.com/conveyor@2'])).rejects.toMatchObject({ code: 'figure-package-release-not-found' })
+    await expect(ask(['other.com/conveyor@1'])).rejects.toMatchObject({ code: 'figure-package-release-not-found' })
+    await expect(ask(['CONVEYOR@1'])).rejects.toMatchObject({ code: 'figure-ref-malformed' })
+  })
+})

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

@@ -0,0 +1,59 @@
+import { EntityManager, Not } from 'typeorm'
+
+import { isFigureNamespace } from '@hatiolab/figure-model'
+import { Domain, Refusal } from '@things-factory/shell'
+import { Setting } from '@things-factory/setting-base'
+
+import { Figure } from './figure.js'
+
+/** The domain setting that names the namespace this domain's figures are published under (ADR-0114). */
+export const FIGURE_NAMESPACE_SETTING = 'figure-namespace'
+
+/**
+ * The namespace a new figure is created under.
+ *
+ * It is read from the domain setting and copied onto the figure, so the full name `{namespace}/{type}` a board stores
+ * never moves. The setting is set once: a value that differs from the namespace this domain's figures already carry
+ * is refused, so editing it on the settings screen cannot rename anything.
+ */
+export async function namespaceForNewFigure(tx: EntityManager, domain: Domain): Promise<string> {
+  const setting = await tx.getRepository(Setting).findOne({
+    where: { domain: { id: domain.id }, name: FIGURE_NAMESPACE_SETTING }
+  })
+  const namespace = setting?.value?.trim() ?? ''
+  if (!isFigureNamespace(namespace)) {
+    throw new Refusal(
+      'figure-namespace-missing',
+      { setting: FIGURE_NAMESPACE_SETTING, value: namespace },
+      'this domain has no valid figure namespace. set {setting} first, for example hatiolab.com.'
+    )
+  }
+  await assertNamespaceUnchanged(tx, domain, namespace)
+  return namespace
+}
+
+/** Refuses when the domain's figures already carry another namespace than the setting now says. */
+export async function assertNamespaceUnchanged(tx: EntityManager, domain: Domain, namespace: string): Promise<void> {
+  const other = await tx.getRepository(Figure).findOne({
+    where: { domain: { id: domain.id }, namespace: Not(namespace) }
+  })
+  if (other?.namespace) {
+    throw new Refusal(
+      'figure-namespace-changed',
+      { setting: FIGURE_NAMESPACE_SETTING, value: namespace, namespace: other.namespace },
+      'the figure namespace of this domain is {namespace} and cannot change. set {setting} back to {namespace}.'
+    )
+  }
+}
+
+/** The namespace a figure already carries, refused when it has none (a figure made before namespaces). */
+export function namespaceOf(figure: Figure): string {
+  if (!figure.namespace) {
+    throw new Refusal(
+      'figure-namespace-missing',
+      { setting: FIGURE_NAMESPACE_SETTING, value: '' },
+      'this figure has no namespace. run the figure name migration first.'
+    )
+  }
+  return figure.namespace
+}

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

@@ -0,0 +1,116 @@
+import JSZip from 'jszip'
+import { In } from 'typeorm'
+
+import {
+  formatFigureRef,
+  parseFigureRef,
+  writeFigurePackage,
+  type FigurePackageBlobFile,
+  type FigurePackageRelease,
+  type FigureRef
+} from '@hatiolab/figure-model'
+import { getRepository, Refusal } from '@things-factory/shell'
+
+import { Figure } from './figure.js'
+import { FigureHistory } from './figure-history.js'
+import { sha256Of, thumbnailAttachmentOf, thumbnailFiles, type ThumbnailFiles } from './figure-thumbnail-store.js'
+
+/** The most releases one package carries. */
+export const FIGURE_PACKAGE_MAX = 200
+
+export interface FigurePackageRequest {
+  readonly refs: readonly string[]
+  readonly domain: { id: string; parentId?: string; subdomain?: string }
+  readonly exportedBy: string | null
+  /** The address a board server can get these releases from again (`figure.publicUrl`). */
+  readonly sourceUrl: string
+  readonly now?: Date
+  readonly files?: ThumbnailFiles
+}
+
+/**
+ * Released figures as one package file a board server imports (ADR-0114 결정 3·16).
+ *
+ * Only released versions travel, read from the release history -- the draft being edited is never exported. The
+ * figures are the ones this domain can read: its own and its parent's, the scope of `figureBlueprint`.
+ */
+export async function figurePackageOf(request: FigurePackageRequest): Promise<{ name: string; bytes: Buffer }> {
+  const refs = [...new Set(request.refs)]
+  if (refs.length === 0 || refs.length > FIGURE_PACKAGE_MAX) {
+    throw new Refusal('figure-package-size', { count: refs.length, max: FIGURE_PACKAGE_MAX }, 'a package carries 1 to {max} releases, not {count}.')
+  }
+
+  const files = request.files ?? thumbnailFiles()
+  const releases: FigurePackageRelease[] = []
+  const blobs = new Map<string, FigurePackageBlobFile>()
+
+  for (const text of refs) {
+    const ref = parseFigureRef(text)
+    if (!ref) throw new Refusal('figure-ref-malformed', { ref: text }, '{ref} is not a release reference of the form namespace/type@version.')
+    const { figure, history } = await releaseOf(ref, request.domain)
+    if (history.thumbnailHash && !blobs.has(history.thumbnailHash)) {
+      const picture = await thumbnailAttachmentOf({ getRepository }, figure.domainId!, history.thumbnailHash)
+      if (picture) {
+        const bytes = await files.read(picture.path)
+        if (sha256Of(bytes) === history.thumbnailHash) blobs.set(history.thumbnailHash, { bytes, contentType: picture.mimetype })
+      }
+    }
+    releases.push(packageReleaseOf(ref, figure, history, blobs))
+  }
+
+  const packed = writeFigurePackage(
+    {
+      source: { url: request.sourceUrl, domain: request.domain.subdomain ?? '' },
+      exportedAt: (request.now ?? new Date()).toISOString(),
+      exportedBy: request.exportedBy,
+      releases,
+      blobs
+    },
+    bytes => sha256Of(Buffer.from(bytes))
+  )
+
+  const zip = new JSZip()
+  for (const [path, bytes] of packed) zip.file(path, bytes, { createFolders: false })
+  const bytes = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+  const name = refs.length === 1 ? `${refs[0]!.replace(/[/@]/g, '_')}.figpkg` : `figures-${refs.length}.figpkg`
+  return { name, bytes }
+}
+
+async function releaseOf(ref: FigureRef, domain: FigurePackageRequest['domain']): Promise<{ figure: Figure; history: FigureHistory }> {
+  const figure = await getRepository(Figure).findOne({
+    where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, type: ref.type, namespace: ref.namespace }
+  })
+  const history = figure
+    ? await getRepository(FigureHistory).findOne({ where: { originalId: figure.id, state: 'released', version: ref.version } })
+    : null
+  if (!figure || !history?.source) {
+    throw new Refusal('figure-package-release-not-found', { ref: formatFigureRef(ref) }, '{ref} is not a release this domain can read.')
+  }
+  return { figure, history }
+}
+
+function packageReleaseOf(
+  ref: FigureRef,
+  figure: Figure,
+  history: FigureHistory,
+  blobs: ReadonlyMap<string, FigurePackageBlobFile>
+): FigurePackageRelease {
+  const json = (text: string | null | undefined) => (text ? JSON.parse(text) : null)
+  return {
+    ref: formatFigureRef(ref),
+    name: history.name ?? figure.name ?? formatFigureRef(ref),
+    names: history.names ?? null,
+    description: history.description ?? null,
+    category: history.category ?? null,
+    source: history.source!,
+    assetFormat: history.assetFormat ?? json(history.source)?.version ?? '',
+    kernelVersion: history.kernelVersion ?? null,
+    metrics: json(history.metrics),
+    topView: json(history.topView),
+    changes: json(history.changes),
+    thumbnail: history.thumbnailHash && blobs.has(history.thumbnailHash) ? history.thumbnailHash : null,
+    deprecated: !!figure.deprecated,
+    supersededBy: figure.supersededBy && figure.namespace ? `${figure.namespace}/${figure.supersededBy}` : null,
+    releasedAt: new Date(history.createdAt ?? Date.now()).toISOString()
+  }
+}

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

@@ -8,6 +8,7 @@ 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 } = require('@hatiolab/figure-model')
 
 let dataSource: DataSource | null = null
@@ -38,7 +39,7 @@ beforeAll(async () => {
     synchronize: true,
     dropSchema: true,
     namingStrategy: new shell.NamingStrategy(),
-    entities: [...shell.entities, ...authBase.entities, Figure, FigureHistory, FigureProposalRecord],
+    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory, FigureProposalRecord],
     logging: false
   })
   await dataSource.initialize()
@@ -49,10 +50,16 @@ afterAll(async () => {
   dataSource = null
 })
 
+/** The domain setting every figure here is created under (ADR-0114). */
+async function namespaced(domain: any) {
+  await dataSource!.getRepository(settingBase.Setting).save({ domain, name: 'figure-namespace', category: 'figure', value: 'system' })
+  return domain
+}
+
 let DOMAIN: { id: string }
 beforeEach(async () => {
   await dataSource!.synchronize(true)
-  DOMAIN = { id: (await dataSource!.getRepository(shell.Domain).save({ name: 'proposal-probe', subdomain: 'proposal-probe' })).id }
+  DOMAIN = { id: (await namespaced(await dataSource!.getRepository(shell.Domain).save({ name: 'proposal-probe', subdomain: 'proposal-probe' }))).id }
 })
 
 const text = (name: string, height = 100) =>

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

@@ -8,8 +8,10 @@ import {
   getRepository,
   ListParam,
   Refusal,
-  SpeakRefusals
+  SpeakRefusals,
+  refusalKey
 } from '@things-factory/shell'
+import { formatFigureRef, parseFigureName, type FigureName } from '@hatiolab/figure-model'
 
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
@@ -304,6 +306,77 @@ export class FigureQuery {
       )
     }
   }
+
+  /**
+   * Released figures a board asks for together, by full name `{namespace}/{type}` (ADR-0114 결정 14).
+   *
+   * One answer per name: an item, or a refusal that names why. A refusal never takes another item away -- the board
+   * draws what it got and a stand-in with the reason for the rest. This server keeps its policy: the latest release,
+   * shadowed by the child domain as `figureBlueprint` does. `release` is null; a type map is the board server's.
+   */
+  @Directive('@privilege(category: "figure-published", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => GraphQLJSON, {
+    description:
+      'Released figures asked together by full name {namespace}/{type}: { release: null, items: [{ type, ref, asset }], refused: [{ type, code, message }] }. The latest release of each; one refusal never removes another item.'
+  })
+  async figureBlueprints(
+    @Arg('types', type => [String], { description: 'Full figure names {namespace}/{type}. At most 500.' }) types: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<any> {
+    const { domain } = context.state
+    const names = [...new Set(types)]
+    if (names.length > FIGURE_BLUEPRINTS_MAX) {
+      throw new Refusal('figure-names-too-many', { count: names.length, max: FIGURE_BLUEPRINTS_MAX }, 'at most {max} figure names can be asked at once, not {count}.')
+    }
+
+    const items: { type: string; ref: string; asset: unknown }[] = []
+    const refused: { type: string; code: string; message: string }[] = []
+    /* Plain text: a board draws the reason on a canvas, so a name with `/` is not escaped. */
+    const refuse = (type: string, refusal: Refusal) =>
+      refused.push({
+        type,
+        code: refusal.code,
+        message: context.t
+          ? context.t(refusalKey(refusal.code), { ...refusal.params, defaultValue: refusal.message, interpolation: { escapeValue: false } })
+          : refusal.message
+      })
+
+    for (const type of names) {
+      const name = parseFigureName(type)
+      if (!name) {
+        refuse(type, new Refusal('figure-name-malformed', { type }, '{type} is not a full figure name of the form namespace/type.'))
+        continue
+      }
+      const found =
+        (await releasedSourceOfName(domain.id, name)) ?? (domain.parentId ? await releasedSourceOfName(domain.parentId, name) : null)
+      if (!found) {
+        refuse(type, new Refusal('figure-not-released', { type }, 'no release is published here.'))
+        continue
+      }
+      try {
+        items.push({ type, ref: formatFigureRef({ ...name, version: found.version }), asset: consumablePayloadOf(found.source).asset })
+      } catch {
+        refuse(
+          type,
+          new Refusal(
+            'figure-release-does-not-compile',
+            { type, figureId: found.figure.id, version: found.version },
+            'the released source of {type} does not compile. open it in the modeller and release it again.'
+          )
+        )
+      }
+    }
+
+    return { release: null, items, refused }
+  }
+}
+
+const FIGURE_BLUEPRINTS_MAX = 500
+
+/** The released source of a full name in one domain: the type there, published under that namespace. */
+async function releasedSourceOfName(domainId: string, name: FigureName) {
+  const found = await releasedSourceOf(domainId, name.type)
+  return found && found.figure.namespace === name.namespace ? found : null
 }
 
 /** One numbered release of a figure, or null when it has none by that number. */

package/server/service/figure/figure-release-record-db.test.ts

@@ -7,6 +7,7 @@ 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, palletizerRobotFigure, FIGURE_KERNEL_VERSION } = require('@hatiolab/figure-model')
 
 let dataSource: DataSource | null = null
@@ -37,7 +38,7 @@ beforeAll(async () => {
     synchronize: true,
     dropSchema: true,
     namingStrategy: new shell.NamingStrategy(),
-    entities: [...shell.entities, ...authBase.entities, Figure, FigureHistory],
+    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory],
     subscribers: [Subscriber],
     logging: false
   })
@@ -49,11 +50,17 @@ afterAll(async () => {
   dataSource = null
 })
 
+/** The domain setting every figure here is created under (ADR-0114). */
+async function namespaced(domain: any) {
+  await dataSource!.getRepository(settingBase.Setting).save({ domain, name: 'figure-namespace', category: 'figure', value: 'system' })
+  return domain
+}
+
 const SOURCE = serializeFigureAsset(addFigureBox(createFigureAsset('Probe'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }))
 
 async function release(extra: Record<string, unknown>) {
   const domain = await dataSource!.getRepository(shell.Domain).save({ name: `d-${Math.random()}`, subdomain: `d${Date.now()}${Math.random()}` })
-  const figure = await dataSource!.getRepository(Figure).save({ type: 'RECORD_PROBE', name: 'probe', source: SOURCE, state: 'draft', version: 0, domain })
+  const figure = await dataSource!.getRepository(Figure).save({ namespace: 'system', type: 'RECORD_PROBE', name: 'probe', source: SOURCE, state: 'draft', version: 0, domain })
   await dataSource!.getRepository(Figure).save({ ...figure, domain, version: 1, state: 'released', __releaseComment: 'first', ...extra })
   return dataSource!.getRepository(FigureHistory).findOneOrFail({ where: { originalId: figure.id } })
 }
@@ -84,10 +91,10 @@ describe('releaseFigure records it', () => {
     return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a, { over: 'range' }), placement: 'floor' }))
   }
   it('first release: [], the second: the wider room', async () => {
-    const domain = await dataSource!.getRepository(shell.Domain).save({ name: 'release-door', subdomain: 'release-door' })
+    const domain = await namespaced(await dataSource!.getRepository(shell.Domain).save({ name: 'release-door', subdomain: 'release-door' }))
     const tx = dataSource!.manager
     const context = { state: { domain, user: undefined, tx } }
-    const figure = await dataSource!.getRepository(Figure).save({ type: 'RELEASE_DOOR', name: 'door', source: releasable(100), state: 'draft', version: 0, domain })
+    const figure = await dataSource!.getRepository(Figure).save({ namespace: 'system', type: 'RELEASE_DOOR', name: 'door', source: releasable(100), state: 'draft', version: 0, domain })
     await new FigureMutation().releaseFigure(figure.id, 'one', context)
     await dataSource!.getRepository(Figure).save({ ...(await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })), domain, source: releasable(300), state: 'draft' })
     await new FigureMutation().releaseFigure(figure.id, 'two', context)
@@ -116,9 +123,9 @@ describe('a release of a figure that moves keeps its joint list', () => {
     return serializeFigureAsset(applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j4, axis: j4Axis } }))
   }
   it('schema 2, the wrist following -(j2 + j3), controls with both units; another axis is refused', async () => {
-    const domain = await dataSource!.getRepository(shell.Domain).save({ name: 'release-joints', subdomain: 'release-joints' })
+    const domain = await namespaced(await dataSource!.getRepository(shell.Domain).save({ name: 'release-joints', subdomain: 'release-joints' }))
     const context = { state: { domain, user: undefined, tx: dataSource!.manager } }
-    const figure = await dataSource!.getRepository(Figure).save({ type: 'PALLETIZER', name: 'palletizer', source: palletizer(), state: 'draft', version: 0, domain })
+    const figure = await dataSource!.getRepository(Figure).save({ namespace: 'system', type: 'PALLETIZER', name: 'palletizer', source: palletizer(), state: 'draft', version: 0, domain })
     await new FigureMutation().releaseFigure(figure.id, 'one', context)
 
     const [row] = await dataSource!.getRepository(FigureHistory).find({ where: { originalId: figure.id } })

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

@@ -13,6 +13,7 @@ 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')
 
 let dataSource: DataSource | null = null
 let Figure: any
@@ -46,7 +47,7 @@ beforeAll(async () => {
     synchronize: true,
     dropSchema: true,
     namingStrategy: new shell.NamingStrategy(),
-    entities: [...shell.entities, ...authBase.entities, Figure, FigureHistory],
+    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory],
     logging: false
   })
 
@@ -68,17 +69,24 @@ afterAll(async () => {
   dataSource = null
 })
 
+/** The domain setting every figure here is created under (ADR-0114). */
+async function namespaced(domain: any) {
+  await dataSource!.getRepository(settingBase.Setting).save({ domain, name: 'figure-namespace', category: 'figure', value: 'system' })
+  return domain
+}
+
 let DOMAIN: { id: string }
 
 /* 도형이 도메인을 가리킨다 — 행이 없으면 외래키가 먼저 막는다. */
 async function seedDomain() {
-  const saved = await dataSource!.getRepository(shell.Domain).save({ name: 'rename-probe', subdomain: 'rename-probe' })
+  const saved = await namespaced(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',
+    namespace: 'system',
+    type: 'figure-mu6sz5dl',
     name: '초안',
     source: '{}',
     state: 'draft',
@@ -100,7 +108,7 @@ describe('이름을 바꾸기 전에 읽는 사실', () => {
   it('★ 판본 질의가 실제로 돈다 — 칸 이름이 틀리면 여기서 던진다', async () => {
     const figure = await seedFigure()
 
-    expect(await facts(figure, 'ROBOT_ARM')).toEqual({ version: 0, hasHistory: false, takenByAnother: false })
+    expect(await facts(figure, 'robot-arm')).toEqual({ version: 0, hasHistory: false, takenByAnother: false })
   })
 
   it('★ 판본이 있으면 그것을 읽어 온다', async () => {
@@ -114,14 +122,14 @@ describe('이름을 바꾸기 전에 읽는 사실', () => {
       domain: DOMAIN
     })
 
-    expect((await facts(figure, 'ROBOT_ARM')).hasHistory).toBe(true)
+    expect((await facts(figure, 'robot-arm')).hasHistory).toBe(true)
   })
 
   it('같은 도메인에서 그 이름을 쓰는 다른 도형을 찾는다', async () => {
     const figure = await seedFigure()
-    await seedFigure({ type: 'CONVEYOR', name: '컨베이어' })
+    await seedFigure({ type: 'conveyor', name: '컨베이어' })
 
-    expect((await facts(figure, 'CONVEYOR')).takenByAnother).toBe(true)
+    expect((await facts(figure, 'conveyor')).takenByAnother).toBe(true)
   })
 
   it('자기 이름은 겹침이 아니다', async () => {
@@ -165,13 +173,13 @@ describe('처음 저장에 타입 이름을 받는다', () => {
   const ids = ['8a1f2c3d-4b5e-4f60-8a71-92b3c4d5e6f7', '9b2e3d4c-5a6f-4e71-9b82-a3c4d5e6f708']
 
   it('준 이름으로 만든다 — 앞뒤 빈칸은 뺀다', async () => {
-    const saved = await save(ids[0], '  ROBOT_ARM ')
-    expect(saved.type).toBe('ROBOT_ARM')
+    const saved = await save(ids[0], '  robot-arm ')
+    expect(saved.type).toBe('robot-arm')
   })
 
   it('★ 이미 쓰는 이름이면 저장하지 않는다 — 임시 이름으로 남기지 않는다', async () => {
-    await seedFigure({ type: 'CONVEYOR', name: '컨베이어' })
-    await expect(save(ids[1], 'CONVEYOR')).rejects.toThrow(/이미 쓰고 있다/)
+    await seedFigure({ type: 'conveyor', name: '컨베이어' })
+    await expect(save(ids[1], 'conveyor')).rejects.toThrow(/이미 쓰고 있다/)
     expect(await dataSource!.getRepository(Figure).count({ where: { id: ids[1] } })).toBe(0)
   })