@things-factory/shell 10.0.0-zeta.8 → 10.0.3

package/tests/env-var-tenant-isolation.test.ts

@@ -0,0 +1,118 @@
+/**
+ * 테넌트 격리 회귀 테스트 — 일괄 갱신이 다른 도메인의 행을 건드리지 못한다.
+ *
+ * `updateMultipleX` 계열은 스캐폴딩이 찍어낸 형태라 여러 패키지에 같은 코드가 복제돼 있었고,
+ * 클라이언트가 준 id 로 도메인 조건 없이 행을 집어 저장했다. 즉 자기 테넌트에서 해당 권한만
+ * 있으면 UUID 를 아는 다른 테넌트의 행을 조용히 수정할 수 있었다.
+ *
+ * 여기서는 `EnvVar`(테넌트별 환경변수 — 값이 가장 민감한 축) 로 그 형태를 잠근다.
+ * 리졸버를 직접 호출한다 — `@Directive` 는 GraphQL 스키마 계층이라 직접 호출에 개입하지 않고,
+ * 트랜잭션은 `context.state.tx` 로 주입한다.
+ */
+
+import { DataSource } from 'typeorm'
+
+import { Domain, EnvVar, NamingStrategy, entities as shellEntities } from '@things-factory/shell'
+
+/* 리졸버는 패키지 공개 표면이 아니라 dist-server 에서 직접 가져온다 (빌드 후 실행할 것). */
+import { EnvVarMutation } from '../dist-server/service/env-var/env-var-mutation.js'
+
+let dataSource: DataSource
+
+const mutation = new EnvVarMutation()
+
+function contextFor(domain: Domain) {
+  return { state: { domain, user: null, tx: dataSource.manager } } as any
+}
+
+async function createDomain(name: string): Promise<Domain> {
+  return await dataSource.getRepository(Domain).save({ name, subdomain: name } as any)
+}
+
+async function createEnvVar(domain: Domain, name: string, value: string): Promise<EnvVar> {
+  return await dataSource.getRepository(EnvVar).save({ domain, name, value } as any)
+}
+
+beforeAll(async () => {
+  dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new NamingStrategy(),
+    entities: [...shellEntities],
+    logging: false
+  })
+
+  await dataSource.initialize()
+})
+
+afterAll(async () => {
+  await dataSource?.destroy()
+})
+
+beforeEach(async () => {
+  await dataSource.query(`DELETE FROM "${dataSource.getMetadata(EnvVar).tableName}"`)
+  await dataSource.query(`DELETE FROM "${dataSource.getMetadata(Domain).tableName}"`)
+})
+
+describe('updateMultipleEnvVars 테넌트 격리', () => {
+  it('다른 도메인의 행은 갱신하지 못하고 실패한다', async () => {
+    const victim = await createDomain('victim')
+    const attacker = await createDomain('attacker')
+    const secret = await createEnvVar(victim, 'API_ENDPOINT', 'https://victim.example.com')
+
+    await expect(
+      mutation.updateMultipleEnvVars(
+        [{ cuFlag: 'M', id: secret.id, value: 'https://attacker.example.com' } as any],
+        contextFor(attacker)
+      )
+    ).rejects.toThrow(secret.id)
+
+    /* 피해 도메인의 값이 그대로여야 한다 */
+    const kept = await dataSource.getRepository(EnvVar).findOneBy({ id: secret.id })
+    expect(kept.value).toBe('https://victim.example.com')
+  })
+
+  it('없는 id 는 조용히 새 행을 만들지 않고 실패한다', async () => {
+    const domain = await createDomain('acme')
+
+    await expect(
+      mutation.updateMultipleEnvVars(
+        [{ cuFlag: 'M', id: '00000000-0000-0000-0000-000000000000', value: 'x' } as any],
+        contextFor(domain)
+      )
+    ).rejects.toThrow()
+
+    expect(await dataSource.getRepository(EnvVar).count()).toBe(0)
+  })
+
+  it('자기 도메인의 행은 정상적으로 갱신한다', async () => {
+    const domain = await createDomain('acme')
+    const envVar = await createEnvVar(domain, 'API_ENDPOINT', 'https://old.example.com')
+
+    const results = await mutation.updateMultipleEnvVars(
+      [{ cuFlag: 'M', id: envVar.id, value: 'https://new.example.com' } as any],
+      contextFor(domain)
+    )
+
+    expect(results).toHaveLength(1)
+    const updated = await dataSource.getRepository(EnvVar).findOneBy({ id: envVar.id })
+    expect(updated.value).toBe('https://new.example.com')
+  })
+
+  it('생성은 현재 도메인으로 귀속된다', async () => {
+    const domain = await createDomain('acme')
+
+    await mutation.updateMultipleEnvVars(
+      [{ cuFlag: '+', name: 'NEW_VAR', value: 'v' } as any],
+      contextFor(domain)
+    )
+
+    const created = await dataSource.getRepository(EnvVar).findOne({
+      where: { name: 'NEW_VAR' },
+      relations: ['domain']
+    })
+    expect(created.domain.id).toBe(domain.id)
+  })
+})

package/tests/get-query-builder-features.test.ts

@@ -0,0 +1,229 @@
+import 'reflect-metadata'
+import { Column, DataSource, Entity, ManyToOne, PrimaryColumn, Repository } from 'typeorm'
+
+import { getQueryBuilderFromListParams } from '../server/utils/get-query-builder-from-list-params.js'
+import { InheritedValueType, ListParam } from '../server/service/common-types/list-param.js'
+import { Domain } from '../server/service/domain/domain.js'
+
+/**
+ * getQueryBuilderFromListParams 종합 회귀 테스트 (SQLite 실행).
+ *
+ * 121개 소비처가 의존하는 핵심 유틸의 동작을 실제 DB 실행으로 고정한다:
+ * 필터 · 검색(search/searchables) · 페이지네이션 · 정렬 · 도메인 상속(None/Include/Only) ·
+ * 관계(filtersMap+join) · 엣지(미지의 컬럼).
+ */
+
+@Entity()
+class Category {
+  @PrimaryColumn({ type: 'integer' })
+  id!: number
+
+  @Column({ type: 'text', nullable: true })
+  name!: string | null
+}
+
+@Entity()
+class Item {
+  @PrimaryColumn({ type: 'integer' })
+  id!: number
+
+  @Column({ type: 'text', nullable: true })
+  name!: string | null
+
+  @Column({ type: 'integer', nullable: true })
+  qty!: number | null
+
+  /* 멀티테넌트 도메인 컬럼(문자열 tenant id 저장) */
+  @Column({ type: 'text', nullable: true })
+  domain!: string | null
+
+  @ManyToOne(() => Category, { nullable: true })
+  category!: Category | null
+}
+
+/* 도메인 상속 테스트용 stub (빌더는 domain.id / domain.parentId 만 참조) */
+const DOMAIN_A = { id: 'A', parentId: 'ROOT' } as unknown as Domain
+
+let dataSource: DataSource
+let repository: Repository<Item>
+
+beforeAll(async () => {
+  dataSource = new DataSource({
+    type: 'better-sqlite3',
+    database: ':memory:',
+    synchronize: true,
+    entities: [Item, Category]
+  })
+  await dataSource.initialize()
+
+  const catRepo = dataSource.getRepository(Category)
+  const books = await catRepo.save({ id: 1, name: 'books' })
+  const toys = await catRepo.save({ id: 2, name: 'toys' })
+
+  repository = dataSource.getRepository(Item)
+  await repository.save([
+    { id: 1, name: 'Apple', qty: 10, domain: 'A', category: books },
+    { id: 2, name: 'apricot', qty: 0, domain: 'A', category: toys },
+    { id: 3, name: 'Banana', qty: 5, domain: 'B', category: books },
+    { id: 4, name: 'cherry', qty: null, domain: 'ROOT', category: null },
+    { id: 5, name: 'Date', qty: 20, domain: 'A', category: toys }
+  ])
+})
+
+afterAll(async () => {
+  await dataSource?.destroy()
+})
+
+type Opts = Parameters<typeof getQueryBuilderFromListParams>[0]
+
+async function ids(opts: Omit<Opts, 'repository'>): Promise<number[]> {
+  const qb = getQueryBuilderFromListParams<Item>({ repository, ...(opts as any) })
+  const rows = (await qb.getMany()) as Item[]
+  return rows.map(r => r.id).sort((a, b) => a - b)
+}
+
+const P = (filters: any[] = [], extra: any = {}) => ({ filters, ...extra } as unknown as ListParam)
+
+describe('컬럼 필터 연산자', () => {
+  it('eq / noteq', async () => {
+    expect(await ids({ params: P([{ name: 'name', operator: 'eq', value: 'Apple' }]) })).toEqual([1])
+    expect(await ids({ params: P([{ name: 'qty', operator: 'noteq', value: 0 }]) })).toEqual([1, 3, 5]) // null 은 != 0 에 안 걸림
+  })
+
+  it('in / notin', async () => {
+    expect(await ids({ params: P([{ name: 'qty', operator: 'in', value: [0, 5] }]) })).toEqual([2, 3])
+  })
+
+  it('between', async () => {
+    expect(await ids({ params: P([{ name: 'qty', operator: 'between', value: [5, 20] }]) })).toEqual([1, 3, 5])
+  })
+
+  it('lt / gte', async () => {
+    expect(await ids({ params: P([{ name: 'qty', operator: 'lt', value: 10 }]) })).toEqual([2, 3])
+    expect(await ids({ params: P([{ name: 'qty', operator: 'gte', value: 10 }]) })).toEqual([1, 5])
+  })
+
+  it('is_null / is_not_null', async () => {
+    expect(await ids({ params: P([{ name: 'qty', operator: 'is_null', value: null }]) })).toEqual([4])
+    expect(await ids({ params: P([{ name: 'qty', operator: 'is_not_null', value: null }]) })).toEqual([1, 2, 3, 5])
+  })
+})
+
+describe('검색 (search / searchables)', () => {
+  it('search 는 대소문자 무시 부분일치 (LOWER LIKE %v%)', async () => {
+    expect(
+      await ids({ params: P([{ name: 'name', operator: 'search', value: 'AP' }]), searchables: ['name'] })
+    ).toEqual([1, 2]) // Apple, apricot
+  })
+
+  it('LIKE 는 searchables 미지정 시 무시됨(무거운 스캔 방지) → 전체 반환', async () => {
+    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    expect(await ids({ params: P([{ name: 'name', operator: 'like', value: 'a' }]) })).toEqual([1, 2, 3, 4, 5])
+    warn.mockRestore()
+  })
+})
+
+describe('페이지네이션', () => {
+  it('page/limit 로 분할 (id 정렬 기준)', async () => {
+    const sortings = [{ name: 'id', desc: false }]
+    expect(await ids({ params: P([], { pagination: { page: 1, limit: 2 }, sortings }) })).toEqual([1, 2])
+    expect(await ids({ params: P([], { pagination: { page: 2, limit: 2 }, sortings }) })).toEqual([3, 4])
+  })
+
+  it('limit 만 지정 시 take 만 적용', async () => {
+    const rows = await ids({ params: P([], { pagination: { limit: 3 }, sortings: [{ name: 'id' }] }) })
+    expect(rows.length).toBe(3)
+  })
+})
+
+describe('정렬', () => {
+  it('desc 정렬', async () => {
+    const qb = getQueryBuilderFromListParams({ repository, params: P([], { sortings: [{ name: 'id', desc: true }] }) })
+    const rows = await qb.getMany()
+    expect(rows.map(r => r.id)).toEqual([5, 4, 3, 2, 1])
+  })
+})
+
+describe('도메인 상속 (None / Include / Only / 없음)', () => {
+  it('None: 해당 도메인만', async () => {
+    expect(await ids({ params: P([]), domain: DOMAIN_A })).toEqual([1, 2, 5])
+  })
+  it('Include: 도메인 + 부모', async () => {
+    expect(await ids({ params: P([], { inherited: InheritedValueType.Include }), domain: DOMAIN_A })).toEqual([
+      1, 2, 4, 5
+    ])
+  })
+  it('Only: 부모만', async () => {
+    expect(await ids({ params: P([], { inherited: InheritedValueType.Only }), domain: DOMAIN_A })).toEqual([4])
+  })
+  it('domain 미전달 시 도메인 필터 없음', async () => {
+    expect(await ids({ params: P([]) })).toEqual([1, 2, 3, 4, 5])
+  })
+})
+
+describe('관계 (filtersMap + join)', () => {
+  const filtersMap = { cat: { columnName: 'name', relationColumn: 'category' } }
+
+  it('관계 컬럼으로 필터(innerJoin)', async () => {
+    expect(
+      await ids({ params: P([{ name: 'cat', operator: 'eq', value: 'books' }]), filtersMap })
+    ).toEqual([1, 3])
+  })
+
+  it('관계 컬럼으로 정렬(leftJoin) — 크래시 없이 전체 반환', async () => {
+    const qb = getQueryBuilderFromListParams({
+      repository,
+      params: P([], { sortings: [{ name: 'cat', desc: false }] }),
+      filtersMap
+    })
+    const rows = await qb.getMany()
+    expect(rows.length).toBe(5) // category 없는 항목(4)도 leftJoin 이라 포함
+  })
+})
+
+describe('검색 모드 (searchMode)', () => {
+  const searchables = ['name']
+  // 이름: Apple(1) apricot(2) Banana(3) cherry(4) Date(5) — 'a' 포함: 1,2,3,5 / 'a' 접두: 1,2
+  it('기본은 contains (어디든 포함) — 하위호환', async () => {
+    expect(await ids({ params: P([{ name: 'name', operator: 'search', value: 'a' }]), searchables })).toEqual([
+      1, 2, 3, 5
+    ])
+  })
+  it('startsWith — 접두 일치', async () => {
+    expect(
+      await ids({ params: P([{ name: 'name', operator: 'search', value: 'a' }]), searchables, searchMode: 'startsWith' })
+    ).toEqual([1, 2])
+  })
+  it('exact — 정확 일치(대소문자 무시)', async () => {
+    expect(
+      await ids({ params: P([{ name: 'name', operator: 'search', value: 'apple' }]), searchables, searchMode: 'exact' })
+    ).toEqual([1])
+    expect(
+      await ids({ params: P([{ name: 'name', operator: 'search', value: 'a' }]), searchables, searchMode: 'exact' })
+    ).toEqual([])
+  })
+})
+
+describe('엣지 — 명확한 오류 가이드', () => {
+  it('미지의 컬럼 → 엔티티·컬럼을 안내하는 명확한 오류', () => {
+    expect(() =>
+      getQueryBuilderFromListParams({ repository, params: P([{ name: 'nope', operator: 'eq', value: 'x' }]) })
+    ).toThrow(/unknown filter column "nope" on entity "Item"/)
+  })
+
+  it('미지의 연산자 → 명확한 오류', () => {
+    expect(() =>
+      getQueryBuilderFromListParams({ repository, params: P([{ name: 'name', operator: 'bogus', value: 'x' }]) })
+    ).toThrow(/unsupported filter operator "bogus"/)
+  })
+
+  it('미지의 관계(정렬 relationColumn) → 명확한 오류', () => {
+    expect(() =>
+      getQueryBuilderFromListParams({
+        repository,
+        params: P([], { sortings: [{ name: 'x', desc: false }] }),
+        filtersMap: { x: { columnName: 'name', relationColumn: 'nosuch' } }
+      })
+    ).toThrow(/relation "nosuch" not found on entity "Item"/)
+  })
+})

package/tests/list-param-operators.test.ts

@@ -0,0 +1,87 @@
+import 'reflect-metadata'
+import { Column, DataSource, Entity, PrimaryColumn, Repository } from 'typeorm'
+
+import { getQueryBuilderFromListParams } from '../server/utils/get-query-builder-from-list-params.js'
+import { ListParam } from '../server/service/common-types/list-param.js'
+
+/**
+ * 목록 필터 연산자의 SQL 이식성 회귀 테스트.
+ *
+ * 배경: 과거 boolean 연산자가 `IS TRUE/FALSE`(MSSQL/Oracle 미지원), 그리고
+ *      `IS PRESENT/BLANK/EMPTY NUMERIC ID`(어떤 DB 에서도 무효) 를 raw SQL 로 방출했다.
+ *      파라미터 바인딩 기반의 이식성 SQL 로 교체한 뒤, SQLite 에서 실제 실행 결과를 고정한다.
+ */
+
+@Entity()
+class Widget {
+  @PrimaryColumn({ type: 'integer' })
+  id!: number
+
+  @Column({ type: 'boolean', nullable: true })
+  flag!: boolean | null
+
+  @Column({ type: 'text', nullable: true })
+  title!: string | null
+
+  @Column({ type: 'integer', nullable: true })
+  refId!: number | null
+}
+
+let dataSource: DataSource
+let repository: Repository<Widget>
+
+beforeAll(async () => {
+  dataSource = new DataSource({
+    type: 'better-sqlite3',
+    database: ':memory:',
+    synchronize: true,
+    entities: [Widget]
+  })
+  await dataSource.initialize()
+  repository = dataSource.getRepository(Widget)
+
+  await repository.save([
+    { id: 1, flag: true, title: 'a', refId: 10 },
+    { id: 2, flag: false, title: '', refId: null },
+    { id: 3, flag: null, title: null, refId: 0 }
+  ])
+})
+
+afterAll(async () => {
+  await dataSource?.destroy()
+})
+
+/** 단일 필터로 조회한 결과 id 목록(정렬) */
+async function idsFor(name: string, operator: string): Promise<number[]> {
+  const params = { filters: [{ name, operator, value: null }] } as unknown as ListParam
+  const qb = getQueryBuilderFromListParams({ repository, params })
+  const rows = await qb.getMany()
+  return rows.map(r => r.id).sort((a, b) => a - b)
+}
+
+describe('list-param filter operators — SQLite 실행 결과 (이식성 SQL)', () => {
+  it('is_true / is_false (boolean 파라미터 바인딩)', async () => {
+    expect(await idsFor('flag', 'is_true')).toEqual([1])
+    expect(await idsFor('flag', 'is_false')).toEqual([2])
+  })
+
+  it('is_not_true / is_not_false (NULL 포함 의미 보존)', async () => {
+    // NOT TRUE = false 또는 NULL, NOT FALSE = true 또는 NULL
+    expect(await idsFor('flag', 'is_not_true')).toEqual([2, 3])
+    expect(await idsFor('flag', 'is_not_false')).toEqual([1, 3])
+  })
+
+  it('is_present / is_blank (값 있음 / 없음)', async () => {
+    expect(await idsFor('title', 'is_present')).toEqual([1, 2]) // IS NOT NULL ('' 은 not null)
+    expect(await idsFor('title', 'is_blank')).toEqual([3]) // IS NULL
+  })
+
+  it('is_empty_num_id (NULL 또는 0)', async () => {
+    expect(await idsFor('refId', 'is_empty_num_id')).toEqual([2, 3])
+  })
+
+  it('is_null / is_not_null (기존 연산자 회귀 확인)', async () => {
+    expect(await idsFor('flag', 'is_null')).toEqual([3])
+    expect(await idsFor('flag', 'is_not_null')).toEqual([1, 2])
+  })
+})

package/tests/manifest-contract.test.ts

@@ -0,0 +1,38 @@
+import type { ThingsFactoryClientConfig, ThingsFactoryServerModule } from '@things-factory/env'
+
+/**
+ * 모듈 매니페스트 계약 파일럿 (P1 4단계).
+ *
+ * 실제 모듈이 취하는 형태(클라이언트 config / 서버 export)가 매니페스트 타입을 만족하는지
+ * 컴파일 타임(ts-jest)에 고정한다. 형태가 계약과 어긋나면 이 스위트가 컴파일에 실패한다.
+ *
+ * 참고: things-factory.config.js 는 babel(preset-typescript)로 컴파일되어 타입이 검사되지 않으므로
+ *       (satisfies 도 그냥 제거됨), 계약 검증은 이처럼 tsc/ts-jest 가 타입 체크하는 지점에서 한다.
+ *       모듈이 자발적으로 계약을 채택하려면 tsc 로 검사되는 코드(서버 export 등)에서 satisfies 를 쓰거나
+ *       이와 같은 타입 어서션을 두면 된다.
+ */
+
+// 클라이언트 매니페스트 — shell 의 실제 things-factory.config 형태
+const clientConfig = {
+  bootstrap: () => {},
+  route: (page: string) => page,
+  routes: [{ tagname: 'page-404', page: 'page404' }]
+} satisfies ThingsFactoryClientConfig
+
+// 서버 모듈 — 대표적인 named export 형태(schema/entities/migrations/initMiddlewares)
+const serverModule = {
+  schema: { resolverClasses: [class SampleResolver {}], typeDefs: {}, resolvers: {}, directives: {} },
+  entities: [class SampleEntity {}],
+  migrations: [],
+  subscribers: [],
+  initMiddlewares: (_app: unknown) => {}
+} satisfies ThingsFactoryServerModule
+
+describe('모듈 매니페스트 계약 (P1)', () => {
+  it('클라이언트/서버 형태가 매니페스트 타입을 만족한다 (컴파일 타임 검증)', () => {
+    expect(clientConfig.routes.length).toBe(1)
+    expect(clientConfig.routes[0].tagname).toBe('page-404')
+    expect(Array.isArray(serverModule.entities)).toBe(true)
+    expect(typeof serverModule.initMiddlewares).toBe('function')
+  })
+})

package/client/store.ts

@@ -1,15 +0,0 @@
-import { configureStore } from '@reduxjs/toolkit'
-
-import app from './reducers/app.js'
-import route from './reducers/route.js'
-
-export const store = configureStore({
-  // set false due to causing severe conflicts with redux-devtools.
-  // devTools: false // process.env['NODE-ENV'] !== 'production'
-  devTools: process.env['NODE-ENV'] !== 'production'
-})
-
-store.addReducers({
-  app,
-  route
-})