@things-factory/auth-base 10.1.278 → 10.1.280

package/tests/signin-policy.test.ts

@@ -1,200 +0,0 @@
-/**
- * `signin` 의 상태 정책 — 실 DB 로 잠금까지 몰아 본다.
- *
- * 이 경로는 플랫폼에서 사람이 들어오는 **유일한 문**인데 시험이 하나도 없었다. 정책이 코드에
- * 흩어져 있고(실패 셈, 잠금, `status` 분기 넷), 순서가 결과를 바꾼다 — 그래서 읽기만으로는
- * 「이 계정이 왜 못 들어오나」를 말할 수 없다.
- *
- * ── 실제로 부르는 모양을 그대로 쓴다 ────────────────────────────────────────
- * `signinMiddleware:20` 은 `signin({ username, password })` 를 **context 없이** 부른다.
- * 그래서 시험도 context 를 넘기지 않는다 — 넘기면 시험이 화면보다 나은 조건에서 도는 것이 된다.
- * 그 차이가 아래 「잠금 해제 메일」 케이스의 주제다.
- */
-
-import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
-import { loadCompiled } from './compiled'
-
-const { User } = loadCompiled('service/user/user')
-const { signin } = loadCompiled('controllers/signin')
-const { VerificationToken } = loadCompiled('service/verification-token/verification-token')
-/* 오류 코드는 문자열이고 표기가 제각각이다(`'user not found'` · `'password-not-matched'`).
-   시험이 그 표기를 베껴 쓰면 코드를 고칠 때 시험만 조용히 틀린다 — 상수를 그대로 든다. */
-const CODES = loadCompiled('constants/error-code')
-
-const PASSWORD = 'Passw0rd!'
-const WRONG = 'Wr0ngPass!'
-
-let domain: any
-
-async function seedUser(overrides: any = {}) {
-  const salt = User.generateSalt()
-
-  return await getRepository(User).save({
-    username: 'kim',
-    email: 'kim@example.com',
-    name: 'Kim',
-    salt,
-    password: User.encode(PASSWORD, salt),
-    status: 'activated',
-    domains: [domain],
-    ...overrides
-  })
-}
-
-/** 실 경로와 같게 — context 없이 부른다. */
-const attempt = (password: string, username = 'kim') => signin({ username, password })
-
-async function reload(id: string) {
-  return await getRepository(User).findOneBy({ id })
-}
-
-beforeAll(async () => {
-  await openAuthDatabase()
-})
-
-beforeEach(async () => {
-  await resetAuthDatabase()
-  domain = await getRepository(Domain).save({ name: 'plant-a', subdomain: 'plant-a' })
-})
-
-afterAll(async () => {
-  await closeAuthDatabase()
-})
-
-describe('들어가기', () => {
-  it('맞는 비밀번호로 토큰과 소속 도메인을 받는다', async () => {
-    const user = await seedUser()
-
-    const result = await attempt(PASSWORD)
-
-    expect(result.token).toBeTruthy()
-    expect(result.user.id).toBe(user.id)
-    expect(result.domains.map((d: any) => d.subdomain)).toEqual(['plant-a'])
-  })
-
-  it('username 이 아니라 email 로도 들어간다', async () => {
-    await seedUser()
-
-    const result = await attempt(PASSWORD, 'kim@example.com')
-
-    expect(result.token).toBeTruthy()
-  })
-})
-
-describe('실패 셈과 잠금', () => {
-  it('틀릴 때마다 셈이 하나 오른다', async () => {
-    const user = await seedUser()
-
-    for (const expected of [1, 2, 3, 4]) {
-      await expect(attempt(WRONG)).rejects.toThrow()
-      expect((await reload(user.id)).failCount).toBe(expected)
-    }
-
-    /* 4회까지는 아직 열려 있다. */
-    expect((await reload(user.id)).status).toBe('activated')
-  })
-
-  it('다섯 번째에 잠긴다', async () => {
-    const user = await seedUser()
-
-    for (let i = 0; i < 5; i++) {
-      await expect(attempt(WRONG)).rejects.toThrow()
-    }
-
-    const locked = await reload(user.id)
-    expect(locked.status).toBe('locked')
-    expect(locked.failCount).toBe(5)
-  })
-
-  it('잠긴 뒤에는 **맞는 비밀번호도** 거절한다', async () => {
-    /* 잠금 검사가 비밀번호 대조보다 먼저 온다(signin.ts:39). 그래서 남이 남의 계정을
-       잠글 수 있고, 잠긴 뒤 본인도 못 들어온다 — 지금 정책이 그렇다. */
-    const user = await seedUser({ status: 'locked' })
-
-    await expect(attempt(PASSWORD)).rejects.toThrow()
-    expect((await reload(user.id)).status).toBe('locked')
-  })
-
-  it('성공하면 셈이 0 으로 돌아간다', async () => {
-    const user = await seedUser()
-
-    await expect(attempt(WRONG)).rejects.toThrow()
-    await expect(attempt(WRONG)).rejects.toThrow()
-    expect((await reload(user.id)).failCount).toBe(2)
-
-    await attempt(PASSWORD)
-    expect((await reload(user.id)).failCount).toBe(0)
-  })
-})
-
-describe('상태 분기', () => {
-  it('삭제된 계정은 비밀번호를 보기도 전에 거절한다', async () => {
-    const user = await seedUser({ status: 'deleted' })
-
-    await expect(attempt(PASSWORD)).rejects.toThrow()
-    /* 셈이 오르지 않는다 — 비밀번호 대조 앞에서 끊긴다. */
-    expect((await reload(user.id)).failCount).toBe(0)
-  })
-
-  it('미활성 계정은 비밀번호를 **맞춘 뒤에** 거절한다', async () => {
-    /* 순서가 뜻을 만든다: 틀리면 「비밀번호가 틀렸다」, 맞히면 「활성화되지 않았다」.
-       즉 미활성 계정에 대해 비밀번호 맞음/틀림이 응답으로 갈린다. */
-    const user = await seedUser({ status: 'inactive' })
-
-    await expect(attempt(WRONG)).rejects.toMatchObject({ errorCode: CODES.PASSWORD_NOT_MATCHED })
-    await expect(attempt(PASSWORD)).rejects.toMatchObject({ errorCode: CODES.USER_NOT_ACTIVATED })
-  })
-
-  it('없는 계정과 틀린 비밀번호가 다른 오류 코드로 갈린다', async () => {
-    await seedUser()
-
-    await expect(attempt(PASSWORD, 'nobody')).rejects.toMatchObject({ errorCode: CODES.USER_NOT_FOUND })
-    await expect(attempt(WRONG)).rejects.toMatchObject({ errorCode: CODES.PASSWORD_NOT_MATCHED })
-  })
-})
-
-describe('실패 응답에 실려 나가는 것', () => {
-  it('인증되지 않은 실패가 email 과 남은 시도 횟수를 함께 싣는다', async () => {
-    /* `detail` 이 화면까지 가는 경로가 있다. 아무 자격 없이 세 가지를 알 수 있다 —
-       그 계정이 있다는 것, 그 계정의 email, 그리고 잠기기까지 몇 번 남았는지. */
-    await seedUser()
-
-    await expect(attempt(WRONG)).rejects.toMatchObject({
-      detail: { username: 'kim', email: 'kim@example.com', failCount: 1 }
-    })
-  })
-})
-
-describe('잠금 해제 메일', () => {
-  it('잠기면 해제 토큰이 만들어진다', async () => {
-    /*
-     * ⚠ **부르는 쪽이 `await` 하지 않는다** — `signin.ts:40,58` 이 `sendUnlockUserEmail(...)` 을
-     * 띄워 놓고 곧바로 던진다. 그래서 시험이 바로 읽으면 **0건이 나온다.** 그 0건은 제품의
-     * 사실이 아니라 아직 도착하지 않은 쓰기다(처음에 그것을 「메일이 안 간다」로 읽었다).
-     *
-     * 여기서는 그 성질 자체를 고정한다: 즉시 읽으면 없고, 기다리면 있다. 언젠가 그 호출에
-     * `await` 가 붙으면 앞의 기대가 깨져서 알려 줄 것이다.
-     *
-     * 메일 발송 자체는 이 하네스로 확인하지 않는다 — `sendEmail` 이 `config.get('email')` 을
-     * 읽는데 시험 환경에는 그 설정이 없다(`emailInfo.sender` 에서 던진다). 발송은 운영 설정의
-     * 일이고, 실제로 도착하고 있음을 사용자가 확인했다.
-     */
-    const user = await seedUser()
-
-    for (let i = 0; i < 5; i++) {
-      await expect(attempt(WRONG)).rejects.toThrow()
-    }
-
-    expect((await reload(user.id)).status).toBe('locked')
-
-    /* 던진 직후에는 아직 없다 — 부르는 쪽이 기다리지 않기 때문이다. */
-    expect(await getRepository(VerificationToken).find()).toHaveLength(0)
-
-    await new Promise(resolve => setTimeout(resolve, 300))
-
-    const tokens = await getRepository(VerificationToken).find()
-    expect(tokens).toHaveLength(1)
-    expect(tokens[0].type).toBe('unlock')
-    expect(tokens[0].userId).toBe(user.id)
-  })
-})

package/tests/signup-duplicate-db.test.ts

@@ -1,68 +0,0 @@
-/**
- * Signing up refuses a username already taken, and a username that is another account's email.
- *
- * The email lookup was assigned to `user` instead of `duplicated`, so an email clash was never refused and a second
- * account with the same address was made. And a username clash on the profile was named an email clash: the two
- * codes shared one value.
- */
-
-import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
-import { loadCompiled } from './compiled'
-
-const { User } = loadCompiled('service/user/user')
-const { signup } = loadCompiled('controllers/signup')
-const ERROR_CODES = loadCompiled('constants/error-code')
-
-const PASSWORD = 'N3w!Passw0rd'
-
-let here: any
-
-function signUp(username: string) {
-  return signup({ name: 'Lee', username, email: username, password: PASSWORD, domain: here, context: { lng: 'en' } })
-}
-
-beforeAll(async () => {
-  await openAuthDatabase()
-})
-
-afterAll(async () => {
-  await closeAuthDatabase()
-})
-
-beforeEach(async () => {
-  await resetAuthDatabase()
-  here = await getRepository(Domain).save({ name: 'Plant A', subdomain: 'plant-a' })
-  const salt = User.generateSalt()
-  await getRepository(User).save({
-    username: 'kim',
-    email: 'kim@example.com',
-    name: 'Kim',
-    salt,
-    password: User.encode(PASSWORD, salt),
-    status: 'activated',
-    domains: [here]
-  })
-})
-
-describe('signing up', () => {
-  it('★ refuses a username that is another account email, in any case', async () => {
-    await expect(signUp('KIM@example.com')).rejects.toMatchObject({ errorCode: ERROR_CODES.USER_DUPLICATED })
-    expect(await getRepository(User).countBy({ name: 'Lee' })).toBe(0)
-  })
-
-  it('refuses a username already taken', async () => {
-    await expect(signUp('kim')).rejects.toMatchObject({ errorCode: ERROR_CODES.USER_DUPLICATED })
-  })
-
-  it('makes an account for a username nobody has', async () => {
-    await signUp('lee@example.com')
-    expect(await getRepository(User).countBy({ username: 'lee@example.com' })).toBe(1)
-  })
-})
-
-describe('a username clash', () => {
-  it('★ is named a username clash, not an email clash', () => {
-    expect(ERROR_CODES.USERNAME_ALREADY_EXISTS).toBe('username already exists')
-    expect(ERROR_CODES.USERNAME_ALREADY_EXISTS).not.toBe(ERROR_CODES.EMAIL_ALREADY_EXISTS)
-  })
-})

package/tests/token-issuance.test.ts

@@ -1,244 +0,0 @@
-/**
- * 토큰 발급 시험 — **우리 토큰이 무엇을 말하는가.**
- *
- * 사람·애플리케이션·어플라이언스 세 종류의 주체가 모두 JWT 로 들어온다. 저장소의 시험 316개
- * 중 발급을 부르는 것이 없었다. 여기서 고정하는 것은 「무엇이 실려 있나」와 「무엇이 실려
- * 있지 않나」다. **없는 것 쪽이 더 중요하다** (`docs/design/auth-rebuild.md` §4):
- *
- *  · `jti` 가 없다  → 발급한 토큰을 **가리킬 수 없다** = 폐기 수단이 없다.
- *                     로그아웃은 쿠키만 지우고, 복사된 토큰은 만료까지 살아 있다.
- *  · `kid` 가 없다  → 두 키를 동시에 신뢰할 수 없다 = 서명 키를 **교체할 수 없다**.
- *  · 사람 토큰에 도메인이 없다 → 도메인은 `x-things-factory-domain` 헤더가 정한다.
- *
- * 폐기·회전을 넣을 때 이 시험들이 먼저 깨져야 한다. 「`jti` 가 없다」가 깨지는 것이 곧
- * 대장이 생겼다는 증거다.
- */
-
-import jwt from 'jsonwebtoken'
-
-import { loadCompiled } from './compiled'
-
-const { User } = loadCompiled('service/user/user')
-const { Appliance } = loadCompiled('service/appliance/appliance')
-const { Application } = loadCompiled('service/application/application')
-const { SECRET } = loadCompiled('utils/get-secret')
-
-const DAY = 24 * 60 * 60
-const YEAR = 365.25 * DAY /* jsonwebtoken 의 `ms` 는 '1y' 를 365.25일로 읽는다 */
-
-const DOMAIN = { id: 'domain-1', subdomain: 'plant-a' }
-const APPLIANCE = { id: 'appliance-1', name: 'gate-scanner' }
-
-function decode(token: string) {
-  return jwt.decode(token, { complete: true }) as any
-}
-
-function lifetime(payload: any) {
-  return payload.exp - payload.iat
-}
-
-function personToken(overrides: any = {}) {
-  const user = new User()
-  Object.assign(user, { id: 'user-1', username: 'kim', email: 'kim@example.com', ...overrides })
-  return user.sign()
-}
-
-describe('사람 토큰 (User.sign)', () => {
-  it('실려 있는 것은 username · email 과 표준 클레임뿐이다', async () => {
-    const { payload } = decode(await personToken())
-
-    expect(Object.keys(payload).sort()).toEqual(['email', 'exp', 'iat', 'iss', 'sub', 'username'])
-    expect(payload).toMatchObject({
-      username: 'kim',
-      email: 'kim@example.com',
-      iss: 'hatiolab.com',
-      sub: 'user'
-    })
-  })
-
-  it('username 이 없으면 email 을 username 자리에 넣는다', async () => {
-    const { payload } = decode(await personToken({ username: undefined }))
-
-    expect(payload.username).toBe('kim@example.com')
-  })
-
-  it('사용자 id 를 싣지 않는다 — 토큰은 username 으로 사람을 가리킨다', async () => {
-    const { payload } = decode(await personToken())
-
-    expect(payload.id).toBeUndefined()
-  })
-
-  it('기본 수명은 7일이다', async () => {
-    const { payload } = decode(await personToken())
-
-    expect(lifetime(payload)).toBe(7 * DAY)
-  })
-
-  it('넘긴 도메인은 버려진다 — 토큰에 도메인이 없다', async () => {
-    /* `signin` 은 `user.sign({ subdomain: domain?.subdomain })` 로 부르는데(signin.ts:95)
-       `sign` 은 `expiresIn` 만 꺼내 쓴다(user.ts:186). 넘긴 값이 조용히 사라진다. */
-    const user = new User()
-    Object.assign(user, { id: 'user-1', username: 'kim', email: 'kim@example.com' })
-
-    const { payload } = decode(await user.sign({ subdomain: 'plant-a' }))
-
-    expect(payload.subdomain).toBeUndefined()
-    expect(payload.domain).toBeUndefined()
-  })
-})
-
-describe('어플라이언스 토큰 (Appliance.generateAccessToken)', () => {
-  it('주체 종류와 어플라이언스 id, 도메인을 싣는다', () => {
-    const { payload } = decode(Appliance.generateAccessToken(DOMAIN, { id: 'appuser-1' }, APPLIANCE))
-
-    expect(payload).toMatchObject({
-      id: 'appuser-1',
-      userType: 'appliance',
-      appliance: { id: 'appliance-1' },
-      status: 'activated',
-      domain: { subdomain: 'plant-a' },
-      sub: 'access-token'
-    })
-  })
-
-  it('기본 수명이 1년이다', () => {
-    /* 설정 `applianceJwtExpiresIn` 이 없을 때의 값(appliance.ts:131).
-       이 토큰은 DB 에 평문으로도 남는다(appliance-mutation.ts:64,70). */
-    const { payload } = decode(Appliance.generateAccessToken(DOMAIN, { id: 'appuser-1' }, APPLIANCE))
-
-    expect(lifetime(payload)).toBe(YEAR)
-  })
-})
-
-describe('애플리케이션 토큰 (Application)', () => {
-  const SCOPES = ['reader', 'approver']
-
-  /* 서명이 받는 것은 이름을 가진 객체다. 맨 문자열을 받던 시절에는 같은 자리에 appSecret 을
-     넣어도 아무 표시가 없었다 — `Application.sign` 의 주석. */
-  const CLIENT = { appKey: 'APPKEY' }
-
-  it('access token 은 30일, refresh token 은 1년이다', () => {
-    const access = decode(Application.generateAccessToken(DOMAIN, { id: 'appuser-1' }, CLIENT, SCOPES))
-    const refresh = decode(Application.generateRefreshToken(DOMAIN, { id: 'appuser-1' }, CLIENT, SCOPES))
-
-    expect(lifetime(access.payload)).toBe(30 * DAY)
-    expect(lifetime(refresh.payload)).toBe(YEAR)
-    expect(access.payload.sub).toBe('access-token')
-    expect(refresh.payload.sub).toBe('refresh-token')
-  })
-
-  it('appKey 와 scope 를 싣는다 — scope 는 그 도메인의 역할 이름이다', () => {
-    /* `oauth2-server.ts:131` 이 `roles: scopes` 로 저장하고 `:240` 이 `name: In(scopes)` 로
-       역할을 찾는다. 즉 scope 어휘가 따로 없고 역할 이름이 곧 scope 다 — 역할 이름을 바꾸면
-       이미 발급된 토큰의 scope 가 조용히 뜻을 잃는다. */
-    const { payload } = decode(Application.generateAccessToken(DOMAIN, { id: 'appuser-1' }, CLIENT, SCOPES))
-
-    expect(payload).toMatchObject({
-      userType: 'application',
-      application: { appKey: 'APPKEY' },
-      scope: SCOPES
-    })
-  })
-
-  it('auth code 는 1분 살고 왕복한다', () => {
-    const code = Application.generateAuthCode('kim@example.com', 'APPKEY', 'plant-a', ['reader'], 'state-1')
-    const { payload } = decode(code)
-
-    expect(lifetime(payload)).toBe(60)
-    expect(Application.verifyAuthCode(code)).toMatchObject({
-      email: 'kim@example.com',
-      appKey: 'APPKEY',
-      subdomain: 'plant-a',
-      scopes: ['reader'],
-      state: 'state-1'
-    })
-  })
-
-  it('appKey 와 appSecret 은 16바이트 hex 다', () => {
-    expect(Application.generateAppKey()).toMatch(/^[0-9a-f]{32}$/)
-    expect(Application.generateAppSecret()).toMatch(/^[0-9a-f]{32}$/)
-    expect(Application.generateAppKey()).not.toBe(Application.generateAppKey())
-  })
-})
-
-describe('`iat` 은 초로 절삭된다 — 밀리초 시각과 견주면 새 토큰이 옛것으로 보인다', () => {
-  /*
-   * 폐기를 「무효 목록 없이」 하려는 설계가 반드시 밟는 자리다. 사람 행에는
-   * `passwordUpdatedAt`(밀리초를 가진 `Date`)이 있고, 토큰에는 `iat`(초)이 있다. 그래서
-   * `decoded.iat * 1000 < user.passwordUpdatedAt` 로 「그 시각 앞에 발급된 토큰을 끊는다」를
-   * 만들면, **비밀번호를 바꾼 그 사람의 새 토큰까지 끊긴다** — `change-pwd.ts` 가 같은 초에
-   * 칸을 쓰고(:81) 토큰을 발급하기(:99) 때문이다.
-   *
-   * 대장(발급 기록)을 두면 안 생기는 문제이므로, 이 시험은 고칠 대상이 아니라
-   * **설계가 이 사실을 알고 있어야 한다는 표시**다.
-   */
-  /*
-   * ⚠ 이 시험은 **시계에 기대고 있었고 6번에 1번쯤 빨갛게 났다** (2026-09-10).
-   *
-   * 30번을 7ms 간격으로 돌면서 「전부 옛것으로 보인다」를 단정했는데, 그 단정이 틀리는 순간이
-   * 둘 있었다. 둘 다 결함이 아니라 **관측이 성립하지 않은 회차**다.
-   *
-   *   밀리초가 정확히 000     절삭이 아무것도 안 깎는다 — 그 한 순간만 비교가 우연히 안전하다
-   *   두 줄 사이에 초가 넘어감   `passwordUpdatedAt` 과 토큰이 **다른 초**다 — 전제가 「같은 초」다
-   *
-   * 그래서 회차를 세는 대신 **관측이 성립한 회차만** 보고, 그런 회차가 하나도 없으면 조용히
-   * 초록이 되지 않게 따로 단정한다. 시계를 목으로 바꾸지 않는 이유는 재는 대상이 **발급기가
-   * 실제로 넣는 `iat`** 이기 때문이다.
-   */
-  it('같은 초에 찍은 밀리초 시각보다 새 토큰의 `iat` 이 앞선다', async () => {
-    const ROUNDS = 30
-    let observed = 0
-    let looksOlder = 0
-
-    for (let round = 0; round < ROUNDS; round++) {
-      /* change-pwd.ts 의 순서: 먼저 `passwordUpdatedAt` 을 쓰고, 그 다음 발급한다. */
-      const passwordUpdatedAt = new Date()
-      const { payload } = decode(await personToken())
-
-      const sameSecond = Math.floor(passwordUpdatedAt.getTime() / 1000) === payload.iat
-      const truncates = passwordUpdatedAt.getMilliseconds() !== 0
-
-      if (sameSecond && truncates) {
-        observed++
-        if (payload.iat * 1000 < passwordUpdatedAt.getTime()) looksOlder++
-      }
-
-      await new Promise(resolve => setTimeout(resolve, 7))
-    }
-
-    /* 성립한 회차가 없으면 위 단정이 「0 === 0」으로 통과한다 — 그것은 초록이 아니다. */
-    expect(observed).toBeGreaterThan(0)
-    expect(looksOlder).toBe(observed)
-  })
-})
-
-describe('세 종류의 토큰이 공유하는 것 — 그리고 없는 것', () => {
-  /** 사람·어플라이언스·애플리케이션·auth code 를 한 자리에 모아 같은 질문을 던진다. */
-  async function everyToken(): Promise<[string, string][]> {
-    return [
-      ['사람', await personToken()],
-      ['어플라이언스', Appliance.generateAccessToken(DOMAIN, { id: 'appuser-1' }, APPLIANCE)],
-      ['애플리케이션', Application.generateAccessToken(DOMAIN, { id: 'appuser-1' }, 'APPKEY', ['reader'])],
-      ['auth code', Application.generateAuthCode('kim@example.com', 'APPKEY', 'plant-a', ['reader'], 's')]
-    ]
-  }
-
-  it('어느 토큰에도 `jti` 가 없다 — 발급한 것을 가리킬 수 없으니 폐기할 수 없다', async () => {
-    for (const [kind, token] of await everyToken()) {
-      expect({ kind, jti: decode(token).payload.jti }).toEqual({ kind, jti: undefined })
-    }
-  })
-
-  it('어느 토큰에도 `kid` 가 없다 — 서명 키를 교체할 수 없다', async () => {
-    for (const [kind, token] of await everyToken()) {
-      expect({ kind, kid: decode(token).header.kid }).toEqual({ kind, kid: undefined })
-    }
-  })
-
-  it('모든 토큰이 같은 대칭키로 HS256 서명된다 — 검증하는 곳은 서명도 할 수 있다', async () => {
-    for (const [kind, token] of await everyToken()) {
-      expect({ kind, alg: decode(token).header.alg }).toEqual({ kind, alg: 'HS256' })
-      expect(() => jwt.verify(token, SECRET)).not.toThrow()
-    }
-  })
-})

package/tests/user-roles-field-db.test.ts

@@ -1,134 +0,0 @@
-/**
- * `User.roles` — 사용자 목록이 한 사람마다 드는 역할 필드.
- *
- * `userRoles` · `myRoles` 와 같은 결함(`role-query.ts` 의 ③)을 갖고 있던 세 번째 자리다.
- * 사용자를 `relations: ['roles']` 로 읽어 **가진 역할 전부**를 돌려줬다. 도메인 A 와 B 에
- * 함께 속한 사람을 A 의 `users { items { roles { name } } }` 로 읽으면 B 의 역할 이름이 나왔다.
- *
- * 범위는 이 도메인이 부여할 수 있는 것이다 — 내 도메인, 부모 1단, 파트너가 이 도메인에 grant 한
- * 역할. 셋째는 사용자 상세가 체크 상태를 이 필드로 채우기 때문에 빠지면 안 된다: 빠지면 저장할
- * 때 파트너 역할이 떼어진다.
- */
-
-import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
-import { loadCompiled } from './compiled'
-
-const { Role } = loadCompiled('service/role/role')
-const { GrantedRole } = loadCompiled('service/granted-role/granted-role')
-const { User } = loadCompiled('service/user/user')
-const { UserQuery } = loadCompiled('service/user/user-query')
-
-const query = new UserQuery()
-
-let parent: any
-let child: any
-let stranger: any
-
-/** `parentId` 는 `@RelationId` 라 저장소로 읽은 도메인에만 실린다. */
-async function loadDomain(id: string) {
-  return await getRepository(Domain).findOneBy({ id })
-}
-
-/** 필드 리졸버 본문을 직접 부른다 — 목록 질의가 `context.state.domain` 을 채운 상태다. */
-async function rolesOf(user: any, domain: any) {
-  const roles = await query.roles(user, { state: { domain } } as any)
-  return roles.map((role: any) => role.name).sort()
-}
-
-async function makeUser(domains: any[], roles: any[]) {
-  const tag = Math.random().toString(36).slice(2, 8)
-  return await getRepository(User).save({
-    username: `u-${tag}`,
-    email: `u-${tag}@example.com`,
-    name: 'Kim',
-    salt: User.generateSalt(),
-    status: 'activated',
-    domains,
-    roles
-  })
-}
-
-beforeAll(async () => {
-  await openAuthDatabase()
-})
-
-afterAll(async () => {
-  await closeAuthDatabase()
-})
-
-beforeEach(async () => {
-  await resetAuthDatabase()
-
-  const domainRepository = getRepository(Domain)
-
-  const savedParent = await domainRepository.save({ name: 'HQ', subdomain: 'hq' })
-  const savedChild = await domainRepository.save({ name: 'Plant A', subdomain: 'plant-a', parent: savedParent })
-  const savedStranger = await domainRepository.save({ name: 'Other', subdomain: 'other' })
-
-  parent = await loadDomain(savedParent.id)
-  child = await loadDomain(savedChild.id)
-  stranger = await loadDomain(savedStranger.id)
-})
-
-describe('두 도메인에 속한 사람', () => {
-  it('A 에서 읽으면 A 의 역할만 나온다 — B 의 역할 이름이 새지 않는다', async () => {
-    const mine = await getRepository(Role).save({ name: 'operator', domain: child })
-    const theirs = await getRepository(Role).save({ name: 'auditor', domain: stranger })
-    const user = await makeUser([child, stranger], [mine, theirs])
-
-    expect(await rolesOf(user, child)).toEqual(['operator'])
-  })
-
-  it('B 에서 읽으면 B 의 역할만 나온다', async () => {
-    const mine = await getRepository(Role).save({ name: 'operator', domain: child })
-    const theirs = await getRepository(Role).save({ name: 'auditor', domain: stranger })
-    const user = await makeUser([child, stranger], [mine, theirs])
-
-    expect(await rolesOf(user, stranger)).toEqual(['auditor'])
-  })
-})
-
-describe('상속 범위', () => {
-  it('부모 도메인의 역할은 나온다 — 자식 도메인에서 부여할 수 있는 범위다', async () => {
-    const shared = await getRepository(Role).save({ name: 'shared', domain: parent })
-    const local = await getRepository(Role).save({ name: 'local', domain: child })
-    const user = await makeUser([child], [shared, local])
-
-    expect(await rolesOf(user, child)).toEqual(['local', 'shared'])
-  })
-
-  it('부모에서 읽으면 자식 도메인의 역할은 나오지 않는다 — 상속은 위로 한 단이다', async () => {
-    const shared = await getRepository(Role).save({ name: 'shared', domain: parent })
-    const local = await getRepository(Role).save({ name: 'local', domain: child })
-    const user = await makeUser([parent, child], [shared, local])
-
-    expect(await rolesOf(user, parent)).toEqual(['shared'])
-  })
-})
-
-describe('파트너가 grant 한 역할', () => {
-  it('이 도메인에 grant 된 파트너 역할은 나온다 — 빠지면 사용자 상세가 저장할 때 뗀다', async () => {
-    const partnerRole = await getRepository(Role).save({ name: 'partner-viewer', domain: stranger })
-    await getRepository(GrantedRole).save({ role: partnerRole, domain: child })
-    const user = await makeUser([child], [partnerRole])
-
-    expect(await rolesOf(user, child)).toEqual(['partner-viewer'])
-  })
-
-  it('다른 도메인에 grant 된 것은 나오지 않는다 — grant 는 받은 도메인에서만 보인다', async () => {
-    const partnerRole = await getRepository(Role).save({ name: 'partner-viewer', domain: stranger })
-    await getRepository(GrantedRole).save({ role: partnerRole, domain: child })
-    const user = await makeUser([child, parent], [partnerRole])
-
-    expect(await rolesOf(user, parent)).toEqual([])
-  })
-})
-
-describe('역할이 없는 사람', () => {
-  it('빈 목록을 준다', async () => {
-    await getRepository(Role).save({ name: 'operator', domain: child })
-    const user = await makeUser([child], [])
-
-    expect(await rolesOf(user, child)).toEqual([])
-  })
-})