@things-factory/figure-service 10.1.178 → 10.1.180

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

@@ -13,8 +13,9 @@ import { revertKeepingDraft, undoRevert } from './figure-revert.js'
 import { recordProposals } from './figure-proposal.js'
 import { FigureProposal, ProposeRequest } from './figure-propose-type.js'
 import { inspectSource, releaseRecordOf } from './figure-format.js'
-import { renameDraftType, renameFacts } from './figure-rename.js'
-import { namespaceForNewFigure, namespaceOf } from './figure-namespace.js'
+import { releasedBeforeMessage, renameDraftType, renameFacts, typeReleasedBefore } from './figure-rename.js'
+import { assertReleasableNamespace, namespaceForNewFigure, namespaceOf } from './figure-namespace.js'
+import { assertFigureCategory, assertReleasableCategory } from './figure-categories.js'
 import { parseSource } from './figure-format.js'
 import { ProposeFigureFailure, proposalFailureForPerson, proposeFigureSteps } from './figure-propose-steps.js'
 import { prepareFigureWrite, compareAndSwapFigure, pictureOf } from './figure-write.js'
@@ -48,6 +49,19 @@ export function assertNames(names: unknown): asserts names is Record<string, str
   }
 }
 
+/**
+ * The figure a write may touch: one of this domain's own (LV figure-server design G3). A domain reads its parent's
+ * figures but does not change them -- updating, releasing or retiring one from a child domain is refused as not found,
+ * the same answer saving its draft has always given.
+ */
+async function ownFigure(repository: { findOne(options: any): Promise<Figure | null> }, domain: { id: string }, id: string): Promise<Figure> {
+  const figure = await repository.findOne({ where: { domain: { id: domain.id }, id } })
+  if (!figure) {
+    throw new Error(`Figure ${id} 를 찾을 수 없다`)
+  }
+  return figure
+}
+
 @Resolver(Figure)
 @UseMiddleware(SpeakRefusals)
 export class FigureMutation {
@@ -67,9 +81,11 @@ export class FigureMutation {
       nullable: true,
       description: "Keys of the AI proposals whose steps this source holds: recorded with the save, in its transaction."
     })
-    proposalKeys?: string[]
+    proposalKeys?: string[],
+    @Arg('namespace', { nullable: true, description: "The domain's namespace a new figure is created under; its default when none. Ignored for an existing one." })
+    namespace?: string
   ): Promise<Figure> {
-    const saved = await this.writeSource(context, source, id, expectedSource, creationId, thumbnail, type)
+    const saved = await this.writeSource(context, source, id, expectedSource, creationId, thumbnail, type, namespace)
     await recordProposals(context.state.tx, context.state.domain, saved.id!, proposalKeys)
     return saved
   }
@@ -81,7 +97,8 @@ export class FigureMutation {
     expectedSource?: string,
     creationId?: string,
     thumbnail?: string,
-    type?: string
+    type?: string,
+    chosenNamespace?: string
   ): Promise<Figure> {
     const { domain, user, tx } = context.state
     const repository = tx.getRepository(Figure)
@@ -107,7 +124,7 @@ export class FigureMutation {
         name or not at all -- a taken name refuses the save, rather than saving under the temporary one and failing a
         rename after. Without a name (a caller that has none to give) it is the temporary one, renamed later.
       */
-      const namespace = await namespaceForNewFigure(tx, domain)
+      const namespace = await namespaceForNewFigure(tx, domain, chosenNamespace, user)
       const named = type?.trim()
       if (named) {
         const facts = await renameFacts(
@@ -179,7 +196,8 @@ export class FigureMutation {
         '{type} is not a figure type. use lower-case letters, digits and single hyphens, {min} to {max} characters, starting with a letter.'
       )
     }
-    const namespace = await namespaceForNewFigure(tx, domain)
+    assertFigureCategory(figure.category)
+    const namespace = await namespaceForNewFigure(tx, domain, figure.namespace, user)
 
     // 타입 이름은 도메인 안에서 유일하다. 유니크 인덱스가 있지만 여기서 먼저 본다 —
     // DB 오류 문구는 저작자에게 아무 말도 해 주지 못한다.
@@ -187,6 +205,9 @@ export class FigureMutation {
     if (taken) {
       throw new Error(`타입 이름 '${figure.type}' 은 이미 쓰이고 있다. 만든 뒤에는 고칠 수 없으므로 다른 이름을 고른다`)
     }
+    if (await typeReleasedBefore({ figures: repository, histories: tx.getRepository(FigureHistory) }, domain, figure.type!)) {
+      throw new Error(releasedBeforeMessage(figure.type!))
+    }
 
     // 형식을 어기면 여기서 던진다. 파생값은 서버가 계산한다.
     const { source, derived, violations } = parseSource(figure.source)
@@ -219,12 +240,7 @@ export class FigureMutation {
     const { domain, user, tx } = context.state
     const repository = tx.getRepository(Figure)
 
-    const figure = await repository.findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
-    })
-    if (!figure) {
-      throw new Error(`Figure ${id} 를 찾을 수 없다`)
-    }
+    const figure = await ownFigure(repository, domain, id)
 
     /*
       **그림만 바꾸면 발행이 풀리지 않는다.** 미리보기에서 사람이 돌려 놓은 각도로 찍은 그림이 그렇게 온다.
@@ -264,6 +280,8 @@ export class FigureMutation {
       행이 다른 이름을 말하고, 발행할 때 어느 쪽이 도면에 적히는지가 갈린다.
     */
     if (patch.names !== undefined) assertNames(patch.names)
+    /* An app's category vocabulary (G5): a category outside it is refused, and one once set does not change. */
+    assertFigureCategory(patch.category, figure.category)
     /* The picture is kept by its content; the patch's data URL is never written to the row. */
     const { thumbnail: picturePatch, ...patchRest } = patch
     const picture = await pictureOf(tx, domain, user, picturePatch, figure)
@@ -360,7 +378,8 @@ export class FigureMutation {
    * `inspectFigure` 로 미리 물어 이유를 보여 준다.
    */
   @Directive('@transaction')
-  @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
+  /* Releasing, retiring and making public are their own gate (LV figure-server design G6): an author who edits drafts need not be one who sends releases out. */
+  @Directive('@privilege(category: "figure-release", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Figure, { description: 'Releases a figure — raises its version and keeps the released state as history.' })
   async releaseFigure(
     @Arg('id') id: string,
@@ -371,27 +390,16 @@ export class FigureMutation {
     const repository = tx.getRepository(Figure)
     const historyRepository = tx.getRepository(FigureHistory)
 
-    const figure = await repository.findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
-    })
-    if (!figure) {
-      throw new Error(`Figure ${id} 를 찾을 수 없다`)
-    }
+    const figure = await ownFigure(repository, domain, id)
 
     if (figure.state === 'released') {
       throw new Error(`Figure '${figure.type}' 은 이미 발행되어 있다. 고쳐서 다시 내려면 초안으로 되돌린 뒤 발행한다`)
     }
 
-    /* A release promises boards the full name {namespace}/{type}; it is refused while the domain setting disagrees. */
+    /* A release promises boards the full name {namespace}/{type}: it goes out only under a namespace the domain owns and has active. */
     const namespace = namespaceOf(figure)
-    const current = await namespaceForNewFigure(tx, domain)
-    if (current !== namespace) {
-      throw new Refusal(
-        'figure-namespace-changed',
-        { setting: 'figure-namespace', value: current, namespace },
-        'the figure namespace of this domain is {namespace} and cannot change. set {setting} back to {namespace}.'
-      )
-    }
+    await assertReleasableNamespace(tx, domain, namespace, user)
+    assertReleasableCategory(figure.category, figure.type)
 
     /*
       ── 게이트는 여기 있어야 한다 ────────────────────────────────────────────
@@ -412,7 +420,7 @@ export class FigureMutation {
       .limit(1)
       .getOne()
 
-    const inspection = inspectSource(figure.source, released?.source, context.t, figure.type)
+    const inspection = inspectSource(figure.source, released?.source, context.t, figure.type, figure.category)
     if (inspection.blocked) {
       const reasons = inspection.findings
         .filter(finding => finding.blocking)
@@ -503,12 +511,24 @@ export class FigureMutation {
 
   @Directive('@transaction')
   @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'Soft-deletes a figure.' })
+  @Mutation(returns => Boolean, { description: 'Soft-deletes a figure that has never been released. A released figure is refused: it is retired instead.' })
   async deleteFigure(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    // 소프트 삭제다 — 이미 배치된 도면이 이 타입을 참조할 수 있으므로 행을 지우지
-    // 않는다. 되살릴 길을 남긴다.
+    /*
+      A figure once released is not deleted, only retired (LV figure-server design G4, fmsim design 01 D5). Its releases
+      have gone out in packages as `ns/type@n`; deleting it would let the same type be made again and numbered from 1,
+      and the same reference would then name other content, which an importing server refuses.
+    */
+    const figure = await tx.getRepository(Figure).findOne({ where: { domain: { id: domain.id }, id } })
+    if (figure) {
+      const releases = await tx.getRepository(FigureHistory).count({ where: { originalId: figure.id } })
+      if (releases > 0 || Number(figure.version) > 0) {
+        throw new Refusal('figure-released-not-deletable', { type: figure.type }, '{type} has been released and cannot be deleted.')
+      }
+    }
+
+    // 소프트 삭제다 — 행을 지우지 않고 되살릴 길을 남긴다.
     await tx.getRepository(Figure).softDelete({ domain: { id: domain.id }, id })
 
     return true
@@ -519,10 +539,10 @@ export class FigureMutation {
    *
    * 표시일 뿐이다. 발행판은 그대로 남고 받는 쪽은 그대로 받는다 — 발행판은 지우지 않는다. 그래서 **발행을 풀지 않는다**:
    * 행을 엔티티로 저장하지 않고 질의로 고친다. 엔티티로 저장하면 발행된 행이라 판본 구독자가 같은 번호로 판본을 또
-   * 뜬다. 대신 쓸 것(`supersededBy`)은 같은 도메인(또는 상위)에 있는 다른 type 이어야 한다.
+   * 뜬다. 대신 쓸 것(`supersededBy`)은 같은 도메인(또는 상위)에 있는 다른 type 이어야 한다. 퇴역은 소유 도메인의 figure 만 한다.
    */
   @Directive('@transaction')
-  @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@privilege(category: "figure-release", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Figure, { description: 'Retires a figure or brings it back. It stays released and served; supersededBy names the type to use instead.' })
   async setFigureDeprecation(
     @Arg('id') id: string,
@@ -532,9 +552,9 @@ export class FigureMutation {
   ): Promise<Figure> {
     const { domain, tx } = context.state
     const repository = tx.getRepository(Figure)
+    const figure = await ownFigure(repository, domain, id)
+    /* What to use instead may be the parent domain's: a domain reads its parent's figures, it writes only its own. */
     const scope = { id: In([domain.id, domain.parentId].filter(Boolean)) }
-    const figure = await repository.findOne({ where: { domain: scope, id } })
-    if (!figure) throw new Error(`Figure ${id} 를 찾을 수 없다`)
     const instead = deprecated ? supersededBy?.trim() || null : null
     if (instead) {
       if (instead === figure.type) throw new Error(`Figure '${figure.type}' 는 자기 자신으로 대신할 수 없다`)
@@ -545,6 +565,28 @@ export class FigureMutation {
     return await repository.findOneOrFail({ where: { id } })
   }
 
+  /**
+   * Makes a released figure public, or private again (LV figure-server design G2). Public, other domains read its
+   * releases, package them and draw it by full name; its draft stays this domain's, and only this domain changes it.
+   * Like retiring, it is a mark on the row: no release is written and the release state is not undone.
+   */
+  @Directive('@transaction')
+  @Directive('@privilege(category: "figure-release", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Figure, { description: 'Makes a released figure public to other domains, or private again. Its draft is never shown to them.' })
+  async setFigurePublic(@Arg('id') id: string, @Arg('public') isPublic: boolean, @Ctx() context: ResolverContext): Promise<Figure> {
+    const { domain, tx } = context.state
+    const repository = tx.getRepository(Figure)
+    const figure = await ownFigure(repository, domain, id)
+    if (isPublic) {
+      const releases = await tx.getRepository(FigureHistory).count({ where: { originalId: figure.id } })
+      if (!releases && !(Number(figure.version) > 0)) {
+        throw new Refusal('figure-public-unreleased', { type: figure.type }, '{type} has no release yet: only released figures are made public.')
+      }
+    }
+    await repository.createQueryBuilder().update(Figure).set({ public: isPublic }).where('id = :id', { id }).callListeners(false).execute()
+    return await repository.findOneOrFail({ where: { id } })
+  }
+
   /**
    * 저작 보조에게 제안을 시킨다(ADR-0094).
    *

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

@@ -1,5 +1,5 @@
 /**
- * Full figure names on the authoring server (ADR-0114): the namespace a figure is created under, the batch door
+ * Full figure names on the authoring server (ADR-0114, LV figure-server design G1): the namespaces a domain owns and the one 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'
@@ -18,6 +18,7 @@ let FigureMutation: any
 let FigureQuery: any
 let figurePackageOf: any
 let FigureHistory: any
+let FigureNamespace: any
 
 function loadCompiled(modulePath: string): any {
   const { existsSync } = require('fs')
@@ -31,6 +32,7 @@ function loadCompiled(modulePath: string): any {
 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'))
@@ -41,7 +43,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
   })
@@ -62,119 +64,160 @@ const releasable = (label = 'Conveyor') => {
 }
 
 let seq = 0
+/** A domain owning one namespace, its default (or none). Namespaces are unique on the server, so each test names its own. */
 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 })
+    await dataSource!.getRepository(FigureNamespace).save({ domain, name: namespace, state: 'active', isDefault: true })
   }
   const context = { state: { domain, user: undefined, tx: dataSource!.manager } }
-  return { domain, context }
+  return { domain, context, namespace: namespace ?? '' }
 }
+const unique = (stem: string) => `${stem}-${++seq}.hatiolab.com`
 
 const creationId = () => require('crypto').randomUUID()
-const setNamespace = (domain: any, value: string) =>
-  dataSource!.getRepository(settingBase.Setting).update({ domain: { id: domain.id }, name: 'figure-namespace' }, { value })
+const save = (context: any, type: string, namespace?: string) =>
+  new FigureMutation().saveFigure(releasable(type), context, undefined, undefined, creationId(), undefined, type, undefined, namespace)
 
 async function releasedFigure(context: any, type: string) {
-  const figure = await new FigureMutation().saveFigure(releasable(type), context, undefined, undefined, creationId(), undefined, type)
+  const figure = await save(context, type)
   await new FigureMutation().releaseFigure(figure.id, 'first', context)
   return figure
 }
 
+const resolver = () => new (loadCompiled('service/figure/figure-namespace-resolver').FigureNamespaceResolver)()
+
 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('with no setting, or an empty one, is the subdomain', async () => {
-    for (const value of [null, '', '  ']) {
-      const { domain, context } = await domainWith(value)
-      const figure = await new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'conveyor')
-      expect(figure.namespace).toBe(domain.subdomain)
-    }
+  it("is the domain's default", async () => {
+    const ns = unique('default')
+    const { context } = await domainWith(ns)
+    const figure = await save(context, 'conveyor')
+    expect([figure.namespace, figure.type]).toEqual([ns, 'conveyor'])
   })
 
-  it('is refused by name when the setting is not a namespace, or there is none and the subdomain is not one either', async () => {
-    const { context } = await domainWith('Hatiolab.COM')
-    await expect(
-      new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'conveyor')
-    ).rejects.toMatchObject({ code: 'figure-namespace-missing' })
+  it('in a domain owning none, the first figure makes the subdomain its default namespace', async () => {
+    const { domain, context } = await domainWith(null)
+    const figure = await save(context, 'conveyor')
+    expect(figure.namespace).toBe(domain.subdomain)
+    expect((await resolver().figureNamespaces(context)).map((n: any) => [n.name, n.isDefault, n.state])).toEqual([[domain.subdomain, true, 'active']])
+  })
+
+  it('is refused by name when the domain owns none and its subdomain is not a namespace', async () => {
     const odd = await dataSource!.getRepository(shell.Domain).save({ name: `odd-${++seq}`, subdomain: 'Odd_Sub' })
-    await expect(
-      new FigureMutation().saveFigure(releasable(), { state: { domain: odd, user: undefined, tx: dataSource!.manager } }, undefined, undefined, creationId(), undefined, 'conveyor')
-    ).rejects.toMatchObject({ code: 'figure-namespace-missing' })
+    await expect(save({ state: { domain: odd, user: undefined, tx: dataSource!.manager } }, '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' })
+  it('may be another namespace the domain owns, named when it is created', async () => {
+    const { context } = await domainWith(unique('first'))
+    const second = unique('second')
+    await resolver().createFigureNamespace(second, context)
+    expect((await save(context, 'lifter', second)).namespace).toBe(second)
+    const created = await new FigureMutation().createFigure({ type: 'shuttle', name: 's', source: releasable(), namespace: second }, context)
+    expect(created.figure.namespace).toBe(second)
+  })
+
+  it("is refused when named and not the domain's own, or suspended", async () => {
+    const { context } = await domainWith(unique('mine'))
+    const theirs = unique('theirs')
+    await domainWith(theirs)
+    await expect(save(context, 'conveyor', theirs)).rejects.toMatchObject({ code: 'figure-namespace-not-owned' })
+    const resting = unique('resting')
+    await resolver().createFigureNamespace(resting, context)
+    await resolver().setFigureNamespaceState(resting, 'suspended', context)
+    await expect(save(context, 'conveyor', resting)).rejects.toMatchObject({ code: 'figure-namespace-suspended' })
+  })
 
-    await setNamespace(domain, 'hatiolab.com')
+  it('a release goes out only under an active namespace of the domain', async () => {
+    const { context } = await domainWith(unique('main'))
+    const side = unique('side')
+    await resolver().createFigureNamespace(side, context)
+    const draft = await save(context, 'conveyor', side)
+    await resolver().setFigureNamespaceState(side, 'suspended', context)
+    await expect(new FigureMutation().releaseFigure(draft.id, 'c', context)).rejects.toMatchObject({ code: 'figure-namespace-suspended' })
+    await resolver().setFigureNamespaceState(side, 'active', context)
     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')
+    const { context } = await domainWith(unique('upper'))
     await expect(
       new FigureMutation().createFigure({ type: 'CONVEYOR', name: 'c', source: releasable() }, context)
     ).rejects.toMatchObject({ code: 'figure-type-malformed' })
   })
 })
 
-describe('the namespace setting, as the setting screen reads and writes it', () => {
-  const resolver = () => new (loadCompiled('service/figure/figure-namespace-resolver').FigureNamespaceResolver)()
+describe('the namespaces a domain owns', () => {
+  it('adds one: not a namespace, or another domain\'s, is refused; the first is the default and the list starts with it', async () => {
+    const { context } = await domainWith(null)
+    await expect(resolver().createFigureNamespace('Hatiolab.COM', context)).rejects.toMatchObject({ code: 'figure-namespace-invalid' })
+    const taken = unique('taken')
+    await domainWith(taken)
+    await expect(resolver().createFigureNamespace(taken, context)).rejects.toMatchObject({ code: 'figure-namespace-taken' })
+    const a = unique('a')
+    const b = unique('b')
+    expect(await resolver().createFigureNamespace(`  ${a} `, context, 'first one')).toMatchObject({ name: a, isDefault: true, state: 'active', description: 'first one' })
+    expect(await resolver().createFigureNamespace(b, context)).toMatchObject({ name: b, isDefault: false })
+    expect((await resolver().figureNamespaces(context)).map((n: any) => n.name)).toEqual([a, b])
+  })
 
-  it('reads the subdomain when nothing is written, and is not fixed before a figure is made', async () => {
-    const { domain, context } = await domainWith(null)
-    expect(await resolver().figureNamespace(context)).toEqual({ namespace: domain.subdomain, written: '', subdomain: domain.subdomain, fixed: false })
+  it('moves the default when a new one asks for it, or when another is made the default', async () => {
+    const a = unique('a')
+    const { context } = await domainWith(a)
+    const b = unique('b')
+    await resolver().createFigureNamespace(b, context, undefined, true)
+    expect((await resolver().figureNamespaces(context)).map((n: any) => [n.name, n.isDefault])).toEqual([[b, true], [a, false]])
+    await resolver().setDefaultFigureNamespace(a, context)
+    expect((await resolver().figureNamespaces(context)).map((n: any) => [n.name, n.isDefault])).toEqual([[a, true], [b, false]])
+    expect((await save(context, 'conveyor')).namespace).toBe(a)
   })
 
-  it('writes a namespace, and empty goes back to the subdomain; a new figure takes what it says', async () => {
-    const { domain, context } = await domainWith(null)
-    expect(await resolver().setFigureNamespace('  hatiolab.com ', context)).toMatchObject({ namespace: 'hatiolab.com', written: 'hatiolab.com', fixed: false })
-    expect(await resolver().setFigureNamespace('', context)).toMatchObject({ namespace: domain.subdomain, written: '', fixed: false })
-    await resolver().setFigureNamespace('hatiolab.com', context)
-    const figure = await new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'conveyor')
-    expect(figure.namespace).toBe('hatiolab.com')
-    expect(await resolver().figureNamespace(context)).toMatchObject({ namespace: 'hatiolab.com', fixed: true })
-  })
-
-  it('refuses what is not a namespace, and another namespace once figures carry one; the setting is left as it was', async () => {
-    const { context } = await domainWith('hatiolab.com')
-    await expect(resolver().setFigureNamespace('Hatiolab.COM', context)).rejects.toMatchObject({ code: 'figure-namespace-invalid' })
-    await new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'conveyor')
-    await expect(resolver().setFigureNamespace('other.com', context)).rejects.toMatchObject({ code: 'figure-namespace-changed' })
-    expect(await resolver().figureNamespace(context)).toMatchObject({ namespace: 'hatiolab.com', written: 'hatiolab.com', fixed: true })
-    /* The same one again is not a change. */
-    await expect(resolver().setFigureNamespace('hatiolab.com', context)).resolves.toMatchObject({ namespace: 'hatiolab.com' })
+  it('suspends and activates one; the default is not suspended, nor made default while suspended; another domain\'s is not touched', async () => {
+    const a = unique('a')
+    const { context } = await domainWith(a)
+    const b = unique('b')
+    await resolver().createFigureNamespace(b, context)
+    await expect(resolver().setFigureNamespaceState(a, 'suspended', context)).rejects.toMatchObject({ code: 'figure-namespace-default-suspended' })
+    await expect(resolver().setFigureNamespaceState(b, 'resting', context)).rejects.toMatchObject({ code: 'figure-namespace-state' })
+    expect(await resolver().setFigureNamespaceState(b, 'suspended', context)).toMatchObject({ name: b, state: 'suspended' })
+    await expect(resolver().setDefaultFigureNamespace(b, context)).rejects.toMatchObject({ code: 'figure-namespace-suspended' })
+    const theirs = unique('theirs')
+    await domainWith(theirs)
+    await expect(resolver().setFigureNamespaceState(theirs, 'suspended', context)).rejects.toMatchObject({ code: 'figure-namespace-not-owned' })
+    await expect(resolver().setDefaultFigureNamespace(theirs, context)).rejects.toMatchObject({ code: 'figure-namespace-not-owned' })
+  })
+
+  it('reading them is authoring; changing them is figure-namespace:mutation', () => {
+    const { readFileSync } = require('fs')
+    const { join } = require('path')
+    const source = readFileSync(join(__dirname, 'figure-namespace-resolver.ts'), 'utf-8')
+    const declarationOf = (method: string) => {
+      const preceding = source.slice(0, source.indexOf(`async ${method}(`))
+      return preceding.slice(preceding.lastIndexOf("@Directive('@privilege("))
+    }
+    expect(declarationOf('figureNamespaces')).toContain('category: "figure", privilege: "query"')
+    for (const method of ['createFigureNamespace', 'setDefaultFigureNamespace', 'setFigureNamespaceState'])
+      expect(declarationOf(method)).toContain('category: "figure-namespace", privilege: "mutation"')
   })
 })
 
 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')
+    const ns = unique('blue')
+    const { context } = await domainWith(ns)
     await releasedFigure(context, 'conveyor')
-    await new FigureMutation().saveFigure(releasable(), context, undefined, undefined, creationId(), undefined, 'draft-only')
+    await save(context, 'draft-only')
 
     const answer = await new FigureQuery().figureBlueprints(
-      ['hatiolab.com/conveyor', 'hatiolab.com/draft-only', 'other.com/conveyor', 'CONVEYOR', 'hatiolab.com/conveyor'],
+      [`${ns}/conveyor`, `${ns}/draft-only`, 'other.com/conveyor', 'CONVEYOR', `${ns}/conveyor`],
       context
     )
 
     expect(Object.keys(answer).sort()).toEqual(['items', 'refused'])
-    expect(answer.items.map((item: any) => [item.type, item.ref])).toEqual([['hatiolab.com/conveyor', 'hatiolab.com/conveyor@1']])
+    expect(answer.items.map((item: any) => [item.type, item.ref])).toEqual([[`${ns}/conveyor`, `${ns}/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'],
+      [`${ns}/draft-only`, 'figure-not-released'],
       ['other.com/conveyor', 'figure-not-released'],
       ['CONVEYOR', 'figure-name-malformed']
     ])
@@ -185,17 +228,18 @@ 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 ns = unique('pkg')
+    const { domain, context } = await domainWith(ns)
     const figure = await releasedFigure(context, 'trailer-22')
 
     const { name, bytes } = await figurePackageOf({
-      refs: ['hatiolab.com/trailer-22@1'],
+      refs: [`${ns}/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')
+    expect(name).toBe(`${ns}_trailer-22_1.figpkg`)
 
     const zip = await JSZip.loadAsync(bytes)
     const files = new Map<string, Uint8Array>()
@@ -205,13 +249,14 @@ describe('the figure package', () => {
     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'])
+    expect(read.releases.map((r: any) => r.ref)).toEqual([`${ns}/trailer-22@1`])
     const stored = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
     expect(read.releases[0].source).toBe(stored.source)
   })
 
   it('dates each release when it was released, not when the figure was made, and carries its note', async () => {
-    const { domain, context } = await domainWith('hatiolab.com')
+    const ns = unique('pkg')
+    const { domain, context } = await domainWith(ns)
     const figure = await releasedFigure(context, 'trailer-23')
     /* sqlite keeps these times to the second */
     await new Promise(resolve => setTimeout(resolve, 1100))
@@ -220,7 +265,7 @@ describe('the figure package', () => {
     await new FigureMutation().releaseFigure(figure.id, 'wider body', context)
 
     const { bytes } = await figurePackageOf({
-      refs: ['hatiolab.com/trailer-23@1', 'hatiolab.com/trailer-23@2'],
+      refs: [`${ns}/trailer-23@1`, `${ns}/trailer-23@2`],
       domain,
       exportedBy: 'author',
       sourceUrl: 'x',
@@ -239,11 +284,32 @@ describe('the figure package', () => {
   })
 
   it('refuses a release this domain cannot read, and a malformed reference', async () => {
-    const { domain, context } = await domainWith('hatiolab.com')
+    const ns = unique('pkg')
+    const { domain, context } = await domainWith(ns)
     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([`${ns}/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' })
   })
 })
+
+/*
+ * A domain whose figures were made before namespaces were rows (the setting days): it owns no namespace row, and its
+ * figures carry its subdomain. Releasing one is the first need of a namespace, so the subdomain becomes its first, as
+ * creating a figure does -- seen on :3300 after 10.1.179, where the system domain owned none.
+ */
+describe('a domain that owns no namespace row yet', () => {
+  it('releases a figure carrying its subdomain, and the subdomain becomes its default', async () => {
+    const { domain, context } = await domainWith(null)
+    const figure = await dataSource!.getRepository(Figure).save({ namespace: domain.subdomain, type: 'older', name: 'older', source: releasable(), state: 'draft', version: 0, domain })
+    await expect(new FigureMutation().releaseFigure(figure.id, 'first', context)).resolves.toMatchObject({ version: 1 })
+    expect((await resolver().figureNamespaces(context)).map((n: any) => [n.name, n.isDefault])).toEqual([[domain.subdomain, true]])
+  })
+
+  it('a figure carrying another namespace than its subdomain is still refused by name', async () => {
+    const { domain, context } = await domainWith(null)
+    const figure = await dataSource!.getRepository(Figure).save({ namespace: unique('elsewhere'), type: 'stray', name: 'stray', source: releasable(), state: 'draft', version: 0, domain })
+    await expect(new FigureMutation().releaseFigure(figure.id, 'first', context)).rejects.toMatchObject({ code: 'figure-namespace-not-owned' })
+  })
+})