@things-factory/ai-assistant 10.1.6

package/server/service/session-anchor.test.ts

@@ -0,0 +1,133 @@
+/*
+ * 세션 앵커 검증 — 대화가 무엇에 매달리는가.
+ *
+ * 대화는 보드에만 매달리지 않는다. 저작 대화는 보드에, 운영 대화는 공간(사이트와 그 공간에서
+ * 도는 트윈들)에 매달린다. 앵커가 대화의 성격과 **이력 경계**를 정한다.
+ *
+ * 이 테스트가 지키는 것:
+ *  ① **하위호환** — 앵커 컬럼이 빈 옛 행(boardId 만 있는 행)도 board 앵커 조회에 잡혀야 한다.
+ *     백필 마이그레이션 없이 컬럼 추가만으로 끝내는 것이 이 설계의 전제다.
+ *  ② **dual-write** — board 앵커 세션은 anchorId 와 boardId 를 함께 써야 한다. 그래야 기존
+ *     조회·인덱스·소비자(operato-board 등)가 그대로 동작한다.
+ *  ③ 공간·인스턴스 앵커는 boardId 를 오염시키지 않는다(보드 조회에 섞이면 이력 경계가 무너진다).
+ */
+import { anchorColumns, anchorWhere, isSessionAnchorType, SESSION_ANCHOR_TYPES } from './chat-session/session-anchor'
+
+describe('앵커 저장 값 (anchorColumns)', () => {
+  it('board 앵커는 anchorId 와 boardId 에 같은 값을 쓴다 — 기존 조회 하위호환', () => {
+    expect(anchorColumns('board', 'B1')).toEqual({ anchorType: 'board', anchorId: 'B1', boardId: 'B1' })
+  })
+
+  it('space 앵커는 boardId 를 쓰지 않는다 — 보드 조회에 섞이면 이력 경계가 무너진다', () => {
+    expect(anchorColumns('space', 'busan')).toEqual({ anchorType: 'space', anchorId: 'busan', boardId: undefined })
+  })
+
+  it('instance 앵커도 boardId 를 쓰지 않는다', () => {
+    expect(anchorColumns('instance', 'busan-wms')).toEqual({
+      anchorType: 'instance',
+      anchorId: 'busan-wms',
+      boardId: undefined
+    })
+  })
+
+  it('앵커 종류 미지정은 none — 임의로 board 로 승격하지 않는다(잘못된 소속 방지)', () => {
+    expect(anchorColumns(undefined, 'X')).toEqual({ anchorType: 'none', anchorId: 'X', boardId: undefined })
+  })
+
+  /*
+   * This case used to assert that an empty id was normalised to undefined, and it was green while
+   * encoding the defect. Storing ('space', NULL) is not harmless: `anchorWhere` then searches for
+   * the empty string it was handed, misses the row it just wrote, and the caller creates another
+   * session on every call — with no error anywhere. An anchor is a pointer, so no id is a caller
+   * error and the only correct answer is a refusal.
+   */
+  it('an anchor with no id is refused — normalising it would hide a lookup that misses its own row', () => {
+    for (const type of ['board', 'space', 'instance', 'domain']) {
+      expect(() => anchorColumns(type, '')).toThrow(/was given no id/)
+      expect(() => anchorColumns(type, undefined)).toThrow(/was given no id/)
+    }
+  })
+
+  it("'none' is the one anchor that may have no id — it means not addressable by anchor", () => {
+    expect(anchorColumns('none', '')).toEqual({ anchorType: 'none', anchorId: undefined, boardId: undefined })
+    expect(anchorColumns(undefined, undefined)).toEqual({
+      anchorType: 'none',
+      anchorId: undefined,
+      boardId: undefined
+    })
+  })
+
+  it("'domain' anchors a conversation whose subject is the whole tenant", () => {
+    /* A factory-wide question has nothing narrower to point at, but it still needs a history
+     * boundary and a bucket in the inbox — which is what 'none' cannot give it. */
+    expect(anchorColumns('domain', 'dom-1')).toEqual({
+      anchorType: 'domain',
+      anchorId: 'dom-1',
+      boardId: undefined
+    })
+  })
+})
+
+describe('anchor types are checked, not cast', () => {
+  /*
+   * `anchorColumns` used to do `(anchorType || 'none') as SessionAnchorType`. The type existed and
+   * nothing enforced it, so any string reached a nullable varchar and was stored. What makes that
+   * expensive is not one bad row: the anchor decides which conversations are listed together, so a
+   * typo writes a session into a bucket nothing queries — the conversation is simply absent from
+   * the list and no error is raised on either side.
+   */
+  it('an unknown anchor type is refused on the write path', () => {
+    expect(() => anchorColumns('facility', 'F1')).toThrow(/is not an anchor type/)
+  })
+
+  it('an unknown anchor type is refused on the read path too — otherwise it reads as 0 rows', () => {
+    expect(() => anchorWhere('dom-1', 'facility', 'F1')).toThrow(/is not an anchor type/)
+  })
+
+  it('the refusal names what is allowed — a lane should not have to read this file', () => {
+    let message = ''
+    try {
+      anchorColumns('plant', 'P1')
+    } catch (e: any) {
+      message = String(e?.message)
+    }
+    for (const type of SESSION_ANCHOR_TYPES) expect(message).toContain(type)
+    expect(message).toMatch(/raise it/)
+  })
+
+  it('defaulting to none is not the fallback — a typo must not become "about nothing"', () => {
+    expect(() => anchorColumns('spaces', 'busan')).toThrow()
+  })
+
+  it('isSessionAnchorType accepts exactly the declared set', () => {
+    for (const type of SESSION_ANCHOR_TYPES) expect(isSessionAnchorType(type)).toBe(true)
+    for (const bad of ['', 'Board', 'facility', 'plant', null, undefined, 0, {}]) {
+      expect(isSessionAnchorType(bad)).toBe(false)
+    }
+  })
+})
+
+describe('앵커 조회 조건 (anchorWhere)', () => {
+  it('board 앵커는 boardId 로 찾는다 — 앵커 컬럼이 빈 옛 행도 잡힌다', () => {
+    /* 신규 행은 dual-write 로 boardId 도 채워지므로 같은 조건에 함께 걸린다. */
+    expect(anchorWhere('dom-1', 'board', 'B1')).toEqual({ boardId: 'B1', domain: { id: 'dom-1' } })
+  })
+
+  it('space 앵커는 앵커 컬럼으로 찾는다', () => {
+    expect(anchorWhere('dom-1', 'space', 'busan')).toEqual({
+      anchorType: 'space',
+      anchorId: 'busan',
+      domain: { id: 'dom-1' }
+    })
+  })
+
+  it('모든 조회에 domain 조건이 포함된다 — 빠지면 남의 테넌트 대화가 보인다', () => {
+    for (const type of SESSION_ANCHOR_TYPES) {
+      expect(anchorWhere('dom-9', type, 'X').domain).toEqual({ id: 'dom-9' })
+    }
+  })
+
+  it('공간 앵커 조회 조건에는 boardId 가 없다 — 보드 세션을 끌어오지 않는다', () => {
+    expect(anchorWhere('dom-1', 'space', 'busan').boardId).toBeUndefined()
+  })
+})

package/server/service/subscribe-auth.test.ts

@@ -0,0 +1,57 @@
+/**
+ * 구독 도메인 인증 게이트 — 단위 테스트 (보안 핵심: 도메인 격리).
+ * board-patch / chat-message 양쪽 spine 이 공유하는 게이트.
+ *
+ * 회귀 방지: process.superUserGranted 는 async 다. 동기 `!process.superUserGranted(...)` 로
+ * 평가하면 `!Promise` = 항상 false → membership throw 가 죽는다(fail-open). 게이트는 반드시
+ * await 로 평가해야 한다. 아래 superUser 분기 테스트가 그 회귀를 박는다.
+ */
+import { assertDomainSubscribeAllowed } from './subscribe-auth'
+
+const never = async () => false // superUser 아님 (async — 실제 process.superUserGranted 와 동일)
+const always = async () => true // superUser (async)
+
+const domain = { id: 'd1', subdomain: 'acme' }
+const userInDomain = { email: 'a@x.io', domains: [{ subdomain: 'acme' }, { subdomain: 'other' }] }
+const userOutDomain = { email: 'b@x.io', domains: [{ subdomain: 'other' }] }
+
+describe('assertDomainSubscribeAllowed (도메인 격리 게이트)', () => {
+  it('domain 없으면 → reject (domain required)', async () => {
+    await expect(assertDomainSubscribeAllowed(undefined, userInDomain, never)).rejects.toThrow('domain required')
+    await expect(assertDomainSubscribeAllowed(null, userInDomain, never)).rejects.toThrow('domain required')
+  })
+
+  it('user 가 해당 subdomain 소속 → 통과 (superUser 검사 불필요)', async () => {
+    await expect(assertDomainSubscribeAllowed(domain, userInDomain, never)).resolves.toBeUndefined()
+  })
+
+  it('user 가 미소속 + superUser 아님 → reject (격리 — 핵심)', async () => {
+    await expect(assertDomainSubscribeAllowed(domain, userOutDomain, never)).rejects.toThrow(
+      'domain(acme) is not working for user(b@x.io).'
+    )
+  })
+
+  it('user 가 미소속이어도 superUser(async resolve true) 면 → 통과 (await 회귀 방지)', async () => {
+    await expect(assertDomainSubscribeAllowed(domain, userOutDomain, always)).resolves.toBeUndefined()
+  })
+
+  it('user.domains 없음 + superUser 아님 → reject', async () => {
+    await expect(assertDomainSubscribeAllowed(domain, { email: 'c@x.io' }, never)).rejects.toThrow(
+      'domain(acme) is not working for user(c@x.io).'
+    )
+  })
+
+  it('user.domains 없음 + superUser → 통과', async () => {
+    await expect(assertDomainSubscribeAllowed(domain, { email: 'c@x.io' }, always)).resolves.toBeUndefined()
+  })
+
+  it('isSuperUser 는 domain+user 를 받아 호출되고 await 된다', async () => {
+    const calls: any[] = []
+    const spy = async (d: any, u: any) => {
+      calls.push([d, u])
+      return true
+    }
+    await assertDomainSubscribeAllowed(domain, userOutDomain, spy)
+    expect(calls).toEqual([[domain, userOutDomain]])
+  })
+})

package/server/service/subscribe-auth.ts

@@ -0,0 +1,34 @@
+/*
+ * 구독 도메인 인증 게이트 — 순수 로직 (데코레이터·pubsub 없음 → 테스트 가능).
+ *
+ * 실시간 구독(@Subscription)은 같은 도메인 구성원만 허용해야 한다(도메인 격리 = 보안 핵심).
+ * 이 게이트는 board-patch / chat-message 양쪽 spine 의 subscribe 클로저가 공유한다
+ * (reuse — fork 금지). superUserGranted 는 process 전역 의존이라 주입받아 순수성 유지.
+ */
+
+/**
+ * 구독 허용 여부 단언. 불가 시 throw (graphql-ws 가 구독 거부).
+ * - domain 없음 → 거부.
+ * - user 가 해당 subdomain 의 도메인 소속이 아니고 superUser 도 아니면 → 거부.
+ *
+ * 주의(버그 수정): process.superUserGranted 는 async(Promise<boolean>) 다. 기존 양쪽 spine 은
+ * `!process.superUserGranted(...)` 로 동기 평가해 `!Promise` = 항상 false → membership throw 가
+ * 발동하지 않는 fail-open 상태였다. 여기서는 await 로 제대로 평가한다 → subscribe 는 async.
+ *
+ * @param domain  context.state.domain
+ * @param user    context.state.user (domains[] / email 사용)
+ * @param isSuperUser  (domain, user) → boolean | Promise<boolean> (process.superUserGranted 주입)
+ */
+export async function assertDomainSubscribeAllowed(
+  domain: any,
+  user: any,
+  isSuperUser: (domain: any, user: any) => boolean | Promise<boolean>
+): Promise<void> {
+  if (!domain) {
+    throw new Error('domain required')
+  }
+  const subdomain = domain?.subdomain
+  if (!user?.domains?.find((d: any) => d.subdomain === subdomain) && !(await isSuperUser(domain, user))) {
+    throw new Error(`domain(${subdomain}) is not working for user(${user?.email}).`)
+  }
+}

package/server/service/types.ts

@@ -0,0 +1,15 @@
+/*
+ * 대화 한 줄 — 도메인을 모르는 가장 작은 모양.
+ *
+ * `board-ai/types.ts` 에 있었고, 그래서 대화 이력을 다루는 순수 함수(`llm-history`)가 보드 편집기의
+ * 타입 파일을 봐야 했다. 그 파일은 `BoardComponent`·`BoardModel` 을 들고 있다 — 이력을 접는 일과
+ * 아무 상관이 없다.
+ *
+ * 옮겨도 소비처는 그대로다: `board-ai` 가 이 이름을 재수출한다.
+ */
+
+/** 모델과 주고받는 한 줄. `system` 은 여기 없다 — 그것은 프롬프트이지 대화가 아니다. */
+export interface LLMMessage {
+  role: 'user' | 'assistant'
+  content: string
+}

package/things-factory.config.js

@@ -0,0 +1 @@
+export default {}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig-base.json",
+  "compilerOptions": {
+    "outDir": "./dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./server/**/*"],
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+}