@things-factory/board-import 10.0.0-beta.108

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

@@ -0,0 +1,24 @@
+import { ImportSession } from './import-session'
+import { ImportSessionResolver } from './import-session-resolver'
+
+export { ImportSession, ImportSessionResolver }
+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 }
+    })
+  })
+})

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

@@ -0,0 +1,158 @@
+/**
+ * materializeFromSession — ImportSession.result.boardModel → 신규 Board 영속화의 **순수 비즈니스
+ * 로직**. typeorm `getRepository` / `ResolverContext` 같은 외부 의존성을 인자로 분리해서 단위
+ * 테스트 가능하도록 구성. resolver 측 mutation 은 IO (repo, ctx) 만 wiring 해서 이 함수를 호출.
+ *
+ * 호출 책임:
+ *   - resolver: getRepository / context.state 에서 도메인/유저 추출
+ *   - 이 함수: 검증 → 정책 적용 → save 호출 → 결과 반환
+ *
+ * 정책:
+ *   - ImportSession.status 가 'completed' 가 아니면 거절
+ *   - result.boardModel 이 없으면 거절
+ *   - Board.name 이 같은 도메인에 이미 있으면 거절 (createBoard 와 동일 정책)
+ *   - 새 보드는 sortOrder = (현재 최소 sortOrder - 1) 또는 0 (createBoard 와 동일 정책)
+ *   - state='draft', sourceImportSessionId=session.id, model=JSON.stringify(boardModel)
+ */
+
+const EMPTY_THUMBNAIL = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
+
+export interface MaterializeRequest {
+  sessionId: string
+  name: string
+  description?: string
+  groupId?: string
+  type?: 'main' | 'sub' | 'popup'
+  thumbnail?: string
+  /** 사용자가 선택한 시안 id. 미지정 시 session.result.defaultVariantId 또는 첫 variant. */
+  variantId?: string
+}
+
+export interface SessionLike {
+  id: string
+  status: string
+  result?: {
+    boardModel?: any
+    variants?: Array<{ id: string; boardModel: any }>
+    defaultVariantId?: string
+  } | null
+}
+
+export interface BoardRepoLike {
+  findOneBy(criteria: any): Promise<any | null>
+  save(entity: any): Promise<any>
+  /** sortOrder 결정용 — 미존재 시 0 으로 fallback. */
+  createQueryBuilder?(alias: string): {
+    select(expr: string, alias: string): any
+    where(cond: string, params: any): any
+    getRawOne(): Promise<any>
+  }
+}
+
+export interface GroupRepoLike {
+  findOneBy(criteria: any): Promise<any | null>
+}
+
+export interface MaterializeContext {
+  domain: { id: string; [k: string]: any }
+  user: any
+}
+
+export interface MaterializeDeps {
+  boardRepo: BoardRepoLike
+  groupRepo: GroupRepoLike
+}
+
+/**
+ * ImportSession 결과를 새 Board 로 저장. 검증 실패 시 throw, 성공 시 저장된 Board 반환.
+ */
+export async function materializeFromSession(
+  session: SessionLike | null,
+  input: MaterializeRequest,
+  context: MaterializeContext,
+  deps: MaterializeDeps
+): Promise<any> {
+  if (!session) {
+    throw new Error(`ImportSession ${input.sessionId} not found`)
+  }
+  if (session.status !== 'completed') {
+    throw new Error(
+      `ImportSession ${input.sessionId} is not completed (status=${session.status}); cannot materialize.`
+    )
+  }
+  const boardModel = pickVariantBoardModel(session.result, input.variantId)
+  if (!boardModel) {
+    throw new Error(`ImportSession ${input.sessionId} has no boardModel in result.`)
+  }
+
+  const existing = await deps.boardRepo.findOneBy({
+    name: input.name,
+    domain: { id: context.domain.id }
+  })
+  if (existing) {
+    throw new Error(`Board name '${input.name}' is already taken`)
+  }
+
+  const group = input.groupId ? (await deps.groupRepo.findOneBy({ id: input.groupId })) ?? undefined : undefined
+
+  const nextSortOrder = await resolveNextSortOrder(deps.boardRepo, context.domain.id)
+
+  return await deps.boardRepo.save({
+    domain: context.domain,
+    name: input.name,
+    description: input.description,
+    type: input.type ?? 'main',
+    thumbnail: input.thumbnail || EMPTY_THUMBNAIL,
+    model: JSON.stringify(boardModel),
+    sourceImportSessionId: session.id,
+    group,
+    sortOrder: nextSortOrder,
+    state: 'draft',
+    creator: context.user,
+    updater: context.user
+  })
+}
+
+/**
+ * 시안 (variant) 선택 — 사용자가 명시한 variantId > session.result.defaultVariantId > 첫 variant
+ * > 구버전 호환 (session.result.boardModel).
+ */
+function pickVariantBoardModel(
+  result: SessionLike['result'],
+  variantId?: string
+): any | undefined {
+  if (!result) return undefined
+  const variants = Array.isArray(result.variants) ? result.variants : []
+  if (variants.length > 0) {
+    if (variantId) {
+      const found = variants.find(v => v.id === variantId)
+      if (found?.boardModel) return found.boardModel
+    }
+    if (result.defaultVariantId) {
+      const found = variants.find(v => v.id === result.defaultVariantId)
+      if (found?.boardModel) return found.boardModel
+    }
+    if (variants[0]?.boardModel) return variants[0].boardModel
+  }
+  // back-compat — 구버전 ImportSession (variants 미존재) 의 단일 boardModel
+  return result.boardModel
+}
+
+/**
+ * sortOrder = MIN(sortOrder) - 1, 미존재 시 0. createBoard 의 "맨 앞에 배치" 정책과 동일.
+ * createQueryBuilder 미지원 환경 (예: 단위 테스트의 minimal mock) 에서는 0 fallback.
+ */
+async function resolveNextSortOrder(repo: BoardRepoLike, domainId: string): Promise<number> {
+  if (!repo.createQueryBuilder) return 0
+  try {
+    const raw = await repo
+      .createQueryBuilder('board')
+      .select('MIN(board.sortOrder)', 'minSortOrder')
+      .where('board.domain = :domainId', { domainId })
+      .getRawOne()
+    const min = raw?.minSortOrder
+    return typeof min === 'number' && Number.isFinite(min) ? min - 1 : 0
+  } catch {
+    return 0
+  }
+}