@things-factory/board-import 10.0.0-beta.71 → 10.0.0-beta.73

package/server/service/import-session/import-session-resolver.ts

@@ -9,14 +9,95 @@
  *
  * 비동기 worker 는 단일 프로세스 내 setImmediate 기반. 추후 큐(Redis/BullMQ) 로 이전 가능.
  */
-import { Resolver, Query, Mutation, Arg, Ctx, Directive, Field, InputType } from 'type-graphql'
+import {
+  Resolver,
+  Query,
+  Mutation,
+  Arg,
+  Ctx,
+  Directive,
+  Field,
+  ID,
+  InputType,
+  ObjectType
+} from 'type-graphql'
 import { GraphQLJSON } from 'graphql-scalars'
+import { Like } from 'typeorm'
 import '@things-factory/auth-base'
 
 import { getRepository } from '@things-factory/shell'
+import { Board, Group } from '@things-factory/board-service'
+import { Attachment } from '@things-factory/attachment-base'
+
+import { ImportSession } from './import-session'
+import { materializeFromSession } from './materialize-from-session'
+import {
+  suggestBoardName,
+  suggestBoardMeta,
+  type SuggestBoardMetaResult,
+  type SuggestBoardRepoLike
+} from './suggest-board-name'
+import {
+  startImportJobAsync,
+  fetchImportSession,
+  listImportSessionsByChatSession
+} from './import-actions'
 
-import { ImportSession } from './import-session.js'
-import { runImportJob } from './import-worker.js'
+@InputType()
+class MaterializeImportSessionInput {
+  @Field(() => ID, { description: 'ImportSession id (must be in completed state).' })
+  sessionId!: string
+
+  @Field({ description: 'New Board name.' })
+  name!: string
+
+  @Field({ nullable: true, description: 'Optional Board description.' })
+  description?: string
+
+  @Field(() => ID, { nullable: true, description: 'Optional Group id to attach the Board to.' })
+  groupId?: string
+
+  @Field({ nullable: true, description: "Board type — 'main' | 'sub' | 'popup'. Default 'main'." })
+  type?: 'main' | 'sub' | 'popup'
+
+  @Field({ nullable: true, description: 'Base64 thumbnail. If omitted, board-service default empty thumbnail is used.' })
+  thumbnail?: string
+
+  @Field({
+    nullable: true,
+    description:
+      "ImportSession 의 결과 시안 중 하나의 id. 'as-is' / 'scene' / 'auto-fit'. " +
+      '미지정 시 default variant (보통 \'scene\') 사용.'
+  })
+  variantId?: string
+}
+
+@ObjectType()
+class BoardMetaSuggestion {
+  @Field({ description: 'Suggested short board name (collision-free with current domain).' })
+  name!: string
+
+  @Field({
+    description:
+      'Suggested detailed description — combines user prompt, AI importStrategy narrative, and category distribution stats.'
+  })
+  description!: string
+}
+
+@InputType()
+class SuggestBoardNameInput {
+  @Field(() => ID, {
+    nullable: true,
+    description: 'ImportSession id — 있으면 거기서 userPrompt / VLM reasoning / attachment.name 추출.'
+  })
+  sessionId?: string
+
+  @Field({
+    nullable: true,
+    description: '명시 hint. session 정보보다 우선. 사용자가 직접 적은 메모를 기반으로 추천받고 싶을 때.'
+  })
+  hint?: string
+}
 
 @InputType()
 class ImportBoardAsyncInput {
@@ -43,6 +124,14 @@ class ImportBoardAsyncInput {
 
   @Field(() => GraphQLJSON, { nullable: true, description: 'Adapter parse options (excludeLayers, maxEntities, ...).' })
   parseOptions?: any
+
+  @Field({
+    nullable: true,
+    description:
+      'User-provided context / hints about the drawing — passed to VLM as additional guidance. ' +
+      'e.g. "fab lithography zone, central rectangles are stockers, thin lines are OHT rails."'
+  })
+  userPrompt?: string
 }
 
 @Resolver()
@@ -54,7 +143,7 @@ export class ImportSessionResolver {
     @Ctx() context: ResolverContext
   ): Promise<ImportSession | null> {
     const { domain } = context.state
-    return (await getRepository(ImportSession).findOneBy({ id, domain: { id: domain.id } })) ?? null
+    return await fetchImportSession(id, { domain, user: context.state.user }, getRepository(ImportSession) as any)
   }
 
   @Query(() => [ImportSession], { description: 'List recent import sessions for a chat session.' })
@@ -63,12 +152,8 @@ export class ImportSessionResolver {
     @Arg('chatSessionId') chatSessionId: string,
     @Ctx() context: ResolverContext
   ): Promise<ImportSession[]> {
-    const { domain } = context.state
-    return await getRepository(ImportSession).find({
-      where: { chatSessionId, domain: { id: domain.id } },
-      order: { createdAt: 'DESC' },
-      take: 50
-    })
+    const { domain, user } = context.state
+    return await listImportSessionsByChatSession(chatSessionId, { domain, user }, getRepository(ImportSession) as any)
   }
 
   @Mutation(() => ImportSession, {
@@ -80,34 +165,81 @@ export class ImportSessionResolver {
     @Ctx() context: ResolverContext
   ): Promise<ImportSession> {
     const { domain, user } = context.state
-    const repo = getRepository(ImportSession)
-
-    const session = await repo.save({
-      domain,
-      attachmentId: input.attachmentId,
-      chatSessionId: input.chatSessionId,
-      status: 'queued',
-      progress: 0,
-      message: 'Queued',
-      optionsJson: JSON.stringify({
-        scopes: input.scopes,
-        normalizeOrigin: input.normalizeOrigin,
-        flipY: input.flipY,
-        scale: input.scale,
-        applyBinding: input.applyBinding,
-        parseOptions: input.parseOptions
-      }),
-      creator: user
-    } as any)
-
-    // 비동기 worker 시작 — 응답은 이미 즉시 반환됨
-    setImmediate(() => {
-      runImportJob(session.id!).catch(err => {
-        // worker 내부에서 처리되지만 안전망
-        console.error('[board-import] runImportJob unhandled:', err)
-      })
-    })
-
-    return session
+    return await startImportJobAsync(input, { domain, user }, getRepository(ImportSession) as any)
+  }
+
+  @Query(() => String, {
+    description:
+      '@deprecated suggestBoardMeta 사용 권장. 단순 string name 만 반환하는 구버전 query.'
+  })
+  @Directive('@privilege(category: "board-import", privilege: "query")')
+  async suggestBoardName(
+    @Arg('input') input: SuggestBoardNameInput,
+    @Ctx() context: ResolverContext
+  ): Promise<string> {
+    const { domain } = context.state
+    const deps = this._buildSuggestDeps()
+    return await suggestBoardName(input, { domain }, deps)
+  }
+
+  @Query(() => BoardMetaSuggestion, {
+    description:
+      '도메인 안에서 충돌하지 않는 Board name + 상세 description 제안. ' +
+      'name 은 짧고 심플 (30자 이내, 충돌 회피 (n) suffix), description 은 자세히 ' +
+      '(사용자 prompt + AI importStrategy + 카테고리 분포 통계 합성).'
+  })
+  @Directive('@privilege(category: "board-import", privilege: "query")')
+  async suggestBoardMeta(
+    @Arg('input') input: SuggestBoardNameInput,
+    @Ctx() context: ResolverContext
+  ): Promise<SuggestBoardMetaResult> {
+    const { domain } = context.state
+    const deps = this._buildSuggestDeps()
+    return await suggestBoardMeta(input, { domain }, deps)
+  }
+
+  /** 두 query 가 공유하는 deps wiring — typeorm find idiomatic 패턴 (distinctAlias 회귀 회피). */
+  private _buildSuggestDeps() {
+    const sessionRepo = getRepository(ImportSession) as any
+    const attachmentRepo = getRepository(Attachment) as any
+    const boardRepo: SuggestBoardRepoLike = {
+      findExistingNames: async ({ domainId, basePrefix }) => {
+        // 도메인 격리 + 'basePrefix' 로 시작하는 name 후보 한 번에 조회.
+        // 단순 find({ where, select }) — take 없음 → DISTINCT 서브쿼리 미발생.
+        const escaped = basePrefix.replace(/[%_\\]/g, ch => '\\' + ch)
+        const items = await getRepository(Board).find({
+          select: ['name'],
+          where: { domain: { id: domainId }, name: Like(`${escaped}%`) }
+        })
+        return items.map(b => b.name as string)
+      }
+    }
+    return { sessionRepo, attachmentRepo, boardRepo }
+  }
+
+  @Mutation(() => Board, {
+    description:
+      '완료된 ImportSession 의 결과 boardModel 을 새 Board entity 로 영속화한다. ' +
+      '검수 단계 (사용자/AI 가 import 결과를 확인 후 명시적으로 호출) 에서 사용. ' +
+      'Board.state="draft" 로 생성되므로 release mutation 으로 별도 발행 필요.'
+  })
+  @Directive('@privilege(category: "board-import", privilege: "mutation")')
+  async materializeImportSession(
+    @Arg('input') input: MaterializeImportSessionInput,
+    @Ctx() context: ResolverContext
+  ): Promise<Board> {
+    const { domain, user } = context.state
+    const sessionRepo = getRepository(ImportSession)
+    const boardRepo = getRepository(Board)
+    const groupRepo = getRepository(Group)
+
+    const session = await sessionRepo.findOneBy({ id: input.sessionId, domain: { id: domain.id } })
+
+    return (await materializeFromSession(
+      session as any,
+      input,
+      { domain, user },
+      { boardRepo: boardRepo as any, groupRepo: groupRepo as any }
+    )) as Board
   }
 }

package/server/service/import-session/import-worker.ts

@@ -15,8 +15,8 @@ import { getRepository } from '@things-factory/shell'
 import { Attachment } from '@things-factory/attachment-base'
 import { STORAGE } from '@things-factory/attachment-base'
 
-import { importBoard } from '../pipeline/index.js'
-import { ImportSession } from './import-session.js'
+import { importBoardVariants } from '../pipeline/index'
+import { ImportSession } from './import-session'
 
 export async function runImportJob(sessionId: string): Promise<void> {
   const repo = getRepository(ImportSession)
@@ -34,8 +34,9 @@ export async function runImportJob(sessionId: string): Promise<void> {
       throw new Error(`Attachment ${session.attachmentId} not found`)
     }
 
-    // attachment-base STORAGE.readFile 으로 본문 로드 (Buffer)
-    const fileBuffer = STORAGE.readFile(attachment.path!, null) as Buffer
+    // attachment-base STORAGE.readFile 으로 본문 로드 (Buffer).
+    // file storage 는 sync, db/s3/azure 는 async — await 으로 양쪽 다 흡수.
+    const fileBuffer = (await STORAGE.readFile(attachment.path!, null)) as Buffer
 
     await update(repo, sessionId, { status: 'parsing', progress: 20, message: 'Parsing drawing' })
 
@@ -45,7 +46,15 @@ export async function runImportJob(sessionId: string): Promise<void> {
     // importBoard 는 내부에서 stage 1~4 모두 수행. 단계별 progress 는 우선 거시적 업데이트.
     await update(repo, sessionId, { status: 'mapping', progress: 50, message: 'Mapping entities' })
 
-    const result = await importBoard({
+    // userPrompt 는 parseOptions 로 합류 — image-adapter 가 VLM 프롬프트에 사용.
+    // 다른 adapter (DXF) 에는 무해 (몰라도 무시).
+    const mergedParseOptions = {
+      ...(opts.parseOptions || {}),
+      ...(opts.userPrompt ? { userPrompt: opts.userPrompt } : {})
+    }
+    // AI 가 같은 도면을 다른 관점으로 해석한 multi-variant. parse 한 번, 시안별 mapping + assemble.
+    // DXF 등 single-variant adapter 는 1 boardModel 만.
+    const result = await importBoardVariants({
       file: fileBuffer,
       filename,
       scopes: opts.scopes,
@@ -53,22 +62,57 @@ export async function runImportJob(sessionId: string): Promise<void> {
       flipY: opts.flipY,
       scale: opts.scale,
       applyBinding: opts.applyBinding,
-      parseOptions: opts.parseOptions
+      parseOptions: mergedParseOptions
+    })
+
+    await update(repo, sessionId, { status: 'assembling', progress: 80, message: 'Assembling boards' })
+
+    // 시안별 카테고리 분포 — 각 variant 의 entities 가 다르므로.
+    const variantsWithStats = result.variants.map((v, i) => {
+      const dist: Record<string, number> = {}
+      for (const c of v.boardModel.components ?? []) {
+        const k = c.category ?? 'unknown'
+        dist[k] = (dist[k] ?? 0) + 1
+      }
+      return { variant: v, mapping: result.mappings[i], categoryDistribution: dist }
     })
 
-    await update(repo, sessionId, { status: 'assembling', progress: 80, message: 'Assembling board' })
+    // default variantId — 첫 variant.
+    const defaultVariantId = result.variants[0]?.id
 
+    // resultJson 구조:
+    //   - variants: 풀 시안 데이터 (선택용 — boardModel + subject + importStrategy + stats + categoryDist)
+    //   - boardModel: default variant 의 boardModel (back-compat)
+    //   - defaultVariantId: 첫 variant 의 id
+    //   - metadata: viewType / aiClientId / userPrompt 등 시안 무관 공통
+    const defaultVariant = variantsWithStats[0]
     const resultJson = JSON.stringify({
-      boardModel: result.boardModel,
-      stats: result.mapping.stats,
-      warnings: result.mapping.warnings
+      variants: variantsWithStats.map(({ variant, mapping, categoryDistribution }) => ({
+        id: variant.id,
+        label: variant.label,
+        description: variant.description,
+        subjectName: variant.subjectName,
+        subjectDescription: variant.subjectDescription,
+        importStrategy: variant.importStrategy,
+        boardModel: variant.boardModel,
+        stats: mapping.stats,
+        warnings: mapping.warnings,
+        categoryDistribution
+      })),
+      defaultVariantId,
+      boardModel: defaultVariant?.variant.boardModel,
+      stats: defaultVariant?.mapping.stats,
+      warnings: defaultVariant?.mapping.warnings,
+      metadata: result.parse.metadata,
+      categoryDistribution: defaultVariant?.categoryDistribution
     })
 
+    const totalAcross = result.mappings.reduce((s, m) => s + (m.stats.total ?? 0), 0)
     await update(repo, sessionId, {
       status: 'completed',
       progress: 100,
-      message: `Completed: ${result.mapping.stats.matched} matched, ${result.mapping.stats.generic} generic`,
-      totalEntities: result.mapping.stats.total,
+      message: `Completed: ${result.variants.length} variants, ${totalAcross} entities total`,
+      totalEntities: defaultVariant?.mapping.stats.total ?? 0,
       resultJson,
       completedAt: new Date()
     })

package/server/service/import-session/index.ts

@@ -1,8 +1,24 @@
-import { ImportSession } from './import-session.js'
-import { ImportSessionResolver } from './import-session-resolver.js'
+import { ImportSession } from './import-session'
+import { ImportSessionResolver } from './import-session-resolver'
 
 export { ImportSession, ImportSessionResolver }
-export { runImportJob } from './import-worker.js'
+export { runImportJob } from './import-worker'
+export {
+  startImportJobAsync,
+  fetchImportSession,
+  listImportSessionsByChatSession,
+  describeAdapter,
+  type StartImportJobInput,
+  type ImportActionsContext,
+  type SessionRepoLike,
+  type AdapterInfo
+} from './import-actions'
+export {
+  materializeFromSession,
+  type MaterializeRequest,
+  type MaterializeContext,
+  type MaterializeDeps
+} from './materialize-from-session'
 
 export const entities = [ImportSession]
 export const resolverClasses = [ImportSessionResolver]

package/server/service/import-session/materialize-from-session.test.ts

@@ -0,0 +1,274 @@
+/**
+ * materializeFromSession — 단위 테스트.
+ *
+ * Resolver IO (typeorm getRepository, ResolverContext) 와 분리된 순수 비즈니스 로직 검증.
+ * mock repository 로 검증 시나리오 / Board persist 정책 / 예외 케이스 회귀 방지.
+ */
+import {
+  materializeFromSession,
+  type BoardRepoLike,
+  type GroupRepoLike,
+  type MaterializeContext,
+  type SessionLike
+} from './materialize-from-session'
+
+// ── Test fixtures ────────────────────────────────────────────────────
+
+const DOMAIN = { id: 'domain-1', name: 'test-domain' }
+const USER = { id: 'user-1', name: 'tester' }
+const CONTEXT: MaterializeContext = { domain: DOMAIN, user: USER }
+
+const SESSION_BASE: SessionLike = {
+  id: 'session-1',
+  status: 'completed',
+  result: {
+    boardModel: {
+      width: 1920,
+      height: 1080,
+      components: [{ refid: 1, type: 'rect' }]
+    }
+  }
+}
+
+function makeBoardRepo(overrides: Partial<BoardRepoLike> = {}): BoardRepoLike & {
+  saveCalls: any[]
+  findOneByCalls: any[]
+} {
+  const findOneByCalls: any[] = []
+  const saveCalls: any[] = []
+  const repo: any = {
+    findOneByCalls,
+    saveCalls,
+    findOneBy: async (criteria: any) => {
+      findOneByCalls.push(criteria)
+      return null
+    },
+    save: async (entity: any) => {
+      saveCalls.push(entity)
+      return { ...entity, id: 'new-board-1' }
+    },
+    ...overrides
+  }
+  return repo
+}
+
+function makeGroupRepo(overrides: Partial<GroupRepoLike> = {}): GroupRepoLike {
+  return {
+    findOneBy: async () => null,
+    ...overrides
+  }
+}
+
+const baseInput = {
+  sessionId: 'session-1',
+  name: 'New Imported Board'
+}
+
+// ── 검증 / 예외 ──────────────────────────────────────────────────────
+
+describe('materializeFromSession — 검증', () => {
+  test('session 이 null 이면 not found 에러', async () => {
+    await expect(
+      materializeFromSession(null, baseInput, CONTEXT, {
+        boardRepo: makeBoardRepo(),
+        groupRepo: makeGroupRepo()
+      })
+    ).rejects.toThrow(/not found/)
+  })
+
+  test("status 가 'completed' 가 아니면 cannot materialize 에러", async () => {
+    const session: SessionLike = { ...SESSION_BASE, status: 'parsing' }
+    await expect(
+      materializeFromSession(session, baseInput, CONTEXT, {
+        boardRepo: makeBoardRepo(),
+        groupRepo: makeGroupRepo()
+      })
+    ).rejects.toThrow(/cannot materialize/)
+  })
+
+  test('result.boardModel 이 없으면 no boardModel 에러', async () => {
+    const session: SessionLike = { ...SESSION_BASE, result: { boardModel: undefined } }
+    await expect(
+      materializeFromSession(session, baseInput, CONTEXT, {
+        boardRepo: makeBoardRepo(),
+        groupRepo: makeGroupRepo()
+      })
+    ).rejects.toThrow(/no boardModel/)
+  })
+
+  test('이름이 같은 도메인에 이미 있으면 already taken 에러', async () => {
+    const boardRepo = makeBoardRepo({
+      findOneBy: async () => ({ id: 'existing-1', name: baseInput.name })
+    })
+    await expect(
+      materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+        boardRepo: boardRepo as any,
+        groupRepo: makeGroupRepo()
+      })
+    ).rejects.toThrow(/already taken/)
+  })
+})
+
+// ── 정상 흐름 ────────────────────────────────────────────────────────
+
+describe('materializeFromSession — Board 생성 정책', () => {
+  test("저장 시 state='draft' + sourceImportSessionId=session.id", async () => {
+    const boardRepo = makeBoardRepo()
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    expect(boardRepo.saveCalls).toHaveLength(1)
+    const saved = boardRepo.saveCalls[0]
+    expect(saved.state).toBe('draft')
+    expect(saved.sourceImportSessionId).toBe('session-1')
+  })
+
+  test('boardModel 이 JSON 문자열로 직렬화되어 model 필드에 저장됨', async () => {
+    const boardRepo = makeBoardRepo()
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    const saved = boardRepo.saveCalls[0]
+    expect(typeof saved.model).toBe('string')
+    expect(JSON.parse(saved.model)).toEqual(SESSION_BASE.result!.boardModel)
+  })
+
+  test("type 미지정 시 default 'main'", async () => {
+    const boardRepo = makeBoardRepo()
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    expect(boardRepo.saveCalls[0].type).toBe('main')
+  })
+
+  test("type='popup' 입력 시 그대로 저장", async () => {
+    const boardRepo = makeBoardRepo()
+    await materializeFromSession(
+      SESSION_BASE,
+      { ...baseInput, type: 'popup' },
+      CONTEXT,
+      { boardRepo: boardRepo as any, groupRepo: makeGroupRepo() }
+    )
+    expect(boardRepo.saveCalls[0].type).toBe('popup')
+  })
+
+  test('thumbnail 미지정 시 기본 empty thumbnail 사용', async () => {
+    const boardRepo = makeBoardRepo()
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    expect(boardRepo.saveCalls[0].thumbnail).toMatch(/^data:image\/gif;base64,/)
+  })
+
+  test('thumbnail 지정 시 그대로 저장', async () => {
+    const boardRepo = makeBoardRepo()
+    const customThumbnail = 'data:image/png;base64,custom'
+    await materializeFromSession(
+      SESSION_BASE,
+      { ...baseInput, thumbnail: customThumbnail },
+      CONTEXT,
+      { boardRepo: boardRepo as any, groupRepo: makeGroupRepo() }
+    )
+    expect(boardRepo.saveCalls[0].thumbnail).toBe(customThumbnail)
+  })
+
+  test('groupId 지정 시 groupRepo 조회 결과를 group 으로 attach', async () => {
+    const boardRepo = makeBoardRepo()
+    const group = { id: 'group-1', name: 'test-group' }
+    const groupRepo = makeGroupRepo({ findOneBy: async () => group })
+    await materializeFromSession(
+      SESSION_BASE,
+      { ...baseInput, groupId: 'group-1' },
+      CONTEXT,
+      { boardRepo: boardRepo as any, groupRepo }
+    )
+    expect(boardRepo.saveCalls[0].group).toEqual(group)
+  })
+
+  test('groupId 미지정 시 group=undefined 로 저장', async () => {
+    const boardRepo = makeBoardRepo()
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    expect(boardRepo.saveCalls[0].group).toBeUndefined()
+  })
+
+  test('createQueryBuilder 미지원 환경에서 sortOrder=0 fallback', async () => {
+    const boardRepo = makeBoardRepo()
+    expect(boardRepo.createQueryBuilder).toBeUndefined()
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    expect(boardRepo.saveCalls[0].sortOrder).toBe(0)
+  })
+
+  test('createQueryBuilder 지원 환경에서 sortOrder = MIN(sortOrder) - 1', async () => {
+    const boardRepo = makeBoardRepo({
+      createQueryBuilder: () =>
+        ({
+          select: function (this: any) {
+            return this
+          },
+          where: function (this: any) {
+            return this
+          },
+          getRawOne: async () => ({ minSortOrder: 5 })
+        }) as any
+    })
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    expect(boardRepo.saveCalls[0].sortOrder).toBe(4)
+  })
+
+  test('빈 보드 (minSortOrder=null) 환경에서 sortOrder=0', async () => {
+    const boardRepo = makeBoardRepo({
+      createQueryBuilder: () =>
+        ({
+          select: function (this: any) {
+            return this
+          },
+          where: function (this: any) {
+            return this
+          },
+          getRawOne: async () => ({ minSortOrder: null })
+        }) as any
+    })
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    expect(boardRepo.saveCalls[0].sortOrder).toBe(0)
+  })
+
+  test('domain 과 creator/updater 가 context 에서 그대로 전파', async () => {
+    const boardRepo = makeBoardRepo()
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    const saved = boardRepo.saveCalls[0]
+    expect(saved.domain).toBe(DOMAIN)
+    expect(saved.creator).toBe(USER)
+    expect(saved.updater).toBe(USER)
+  })
+
+  test('이름 충돌 검사가 도메인 id 기반', async () => {
+    const boardRepo = makeBoardRepo()
+    await materializeFromSession(SESSION_BASE, baseInput, CONTEXT, {
+      boardRepo: boardRepo as any,
+      groupRepo: makeGroupRepo()
+    })
+    expect(boardRepo.findOneByCalls[0]).toEqual({
+      name: baseInput.name,
+      domain: { id: DOMAIN.id }
+    })
+  })
+})