@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/entity-delta.test.ts

@@ -1,352 +0,0 @@
-/*
- * 호스트 방출 매핑(buildEntityDeltas) 단위 검증 — 씬 컴포넌트가 소비하는 data(tag) payload 계약.
- *
- * 지키는 것(2026-08-01 재편):
- *  ① **레퍼런스가 아는 것은 전부 나간다** — 필드를 손으로 골라 담지 않는다. 화이트리스트였을 때
- *     노드 parentId·작업 전량·물품 전량이 오류 없이 빠졌다. 계약에 속성이 생기면 자동으로 도달해야 한다.
- *  ② **표식은 도메인 낱말을 훔치지 않는다** — 엔티티 종류 표식은 `entity`, `kind` 는 도메인 것
- *     (무버 cutter · 작업 putaway · 오더 workorder).
- *  ③ **알리지 않고 자르지 않는다** — 물품 집약이 상한에 걸리면 total·truncated 로 밝힌다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { buildEntityDeltas, ITEMS_AGGREGATE_LIMIT, itemsTag, ordersTag, personsTag, tasksTag, energyTag } from '../shared/entity-delta.ts'
-
-const byTag = (arr: any[], tag: string) => arr.find(x => x.tag === tag)
-
-test('노드: 계약의 속성이 전부 나간다 — parentId(소속 구역)를 포함해', () => {
-  const d = buildEntityDeltas({
-    locations: [{ id: 'bin-1', occupancy: 3, capacity: 10, status: 'idle', type: 'storage', parentId: 'zone-a' }]
-  }, 't1')
-  assert.deepEqual(byTag(d, 'bin-1').data, {
-    entity: 'location',
-    occupancy: 3,
-    capacity: 10,
-    status: 'idle',
-    type: 'storage',
-    parentId: 'zone-a'
-  })
-})
-
-test('표식은 entity, kind 는 도메인 것 — 무버 종류가 표식에 덮이지 않는다', () => {
-  const d = buildEntityDeltas({
-    equipment: [{ id: 'cutter-1', kind: 'cutter', location: 'cut', status: 'down', held: true }]
-  }, 't1')
-  const m = byTag(d, 'cutter-1').data
-  assert.equal(m.entity, 'equipment', '표식')
-  assert.equal(m.kind, 'cutter', '도메인 속성 — 예전엔 표식에 덮여 사라졌다')
-  assert.equal(m.status, 'down')
-  assert.equal(m.held, true)
-})
-
-test('무버: OEE 는 정수 퍼센트로 정형화하고 원시 누적은 빼낸다(churn 억제)', () => {
-  const d = buildEntityDeltas({
-    equipment: [
-      {
-        id: 'cutter-1',
-        kind: 'cutter',
-        status: 'down',
-        oee: { overall: 0.8234, availability: 0.9, performance: 0.95, quality: 0.96, goodCount: 12, nonconformingCount: 3, idleMs: 99999 }
-      }
-    ]
-  }, 't1')
-  assert.deepEqual(byTag(d, 'cutter-1').data.oee, {
-    overall: 82,
-    availability: 90,
-    performance: 95,
-    quality: 96,
-    good: 12,
-    scrap: 3
-  })
-})
-
-test('무버: oee 미측정이면 실리지 않는다', () => {
-  const d = buildEntityDeltas({ equipment: [{ id: 'fk-1', kind: 'forklift', status: 'idle' }] }, 't1')
-  assert.equal(byTag(d, 'fk-1').data.oee, undefined)
-})
-
-test('작업: 개별 + 집약으로 나간다 — 예전엔 아예 방출되지 않았다', () => {
-  const d = buildEntityDeltas({
-    tasks: [
-      { id: 't1', kind: 'putaway', status: 'in-progress', fromNode: 'dock', toNode: 'rack-1', resourceRef: 'fk-1', orderId: 'o1', progress: 0.4 },
-      { id: 't2', kind: 'pick', status: 'created' }
-    ]
-  }, 't1')
-  assert.deepEqual(byTag(d, 't1').data, {
-    entity: 'task',
-    kind: 'putaway',
-    status: 'in-progress',
-    fromNode: 'dock',
-    toNode: 'rack-1',
-    resourceRef: 'fk-1',
-    orderId: 'o1',
-    progress: 0.4
-  })
-  const agg = byTag(d, tasksTag('t1')).data
-  assert.equal(agg.entity, 'tasks')
-  assert.equal(agg.tasks.length, 2)
-  assert.equal(agg.tasks[0].id, 't1', '집약에는 식별자가 있다')
-  assert.equal(agg.tasks[0].resourceRef, 'fk-1', '집약도 속성을 다 담는다')
-})
-
-test('물품: 개별(태그=epc) + 집약으로 나간다 — 수량·소속 팔레트·만료까지', () => {
-  const d = buildEntityDeltas({
-    items: [{ epc: 'urn:epc:id:sgtin:1.1.1', gtin: 'g1', location: 'rack-1', disposition: 'sellable', parent: 'sscc-1', qty: 40, expiry: 1234 }]
-  }, 't1')
-  assert.deepEqual(byTag(d, 'urn:epc:id:sgtin:1.1.1').data, {
-    entity: 'item',
-    gtin: 'g1',
-    location: 'rack-1',
-    disposition: 'sellable',
-    parent: 'sscc-1',
-    qty: 40,
-    expiry: 1234
-  })
-  const agg = byTag(d, itemsTag('t1')).data
-  assert.equal(agg.entity, 'items')
-  assert.equal(agg.items[0].epc, 'urn:epc:id:sgtin:1.1.1')
-  assert.equal(agg.items[0].qty, 40)
-  assert.equal(agg.total, 1)
-  assert.equal(agg.truncated, undefined, '상한 안이면 truncated 없음')
-})
-
-test('물품 집약: 상한을 넘으면 잘린 사실을 밝힌다 — 들어온 것이 없는 절단 금지', () => {
-  const items = Array.from({ length: ITEMS_AGGREGATE_LIMIT + 7 }, (_, i) => ({ epc: `e${i}`, location: 'rack-1' }))
-  const d = buildEntityDeltas({ items }, 't1')
-  const agg = byTag(d, itemsTag('t1')).data
-  assert.equal(agg.items.length, ITEMS_AGGREGATE_LIMIT)
-  assert.equal(agg.total, ITEMS_AGGREGATE_LIMIT + 7)
-  assert.equal(agg.truncated, 7)
-  /* 개별 물품은 상한과 무관하게 전부 태그별로 나간다(시그니처 dedup 이 변한 것만 재브로드캐스팅한다). */
-  assert.equal(d.filter(x => x.data?.entity === 'item').length, ITEMS_AGGREGATE_LIMIT + 7)
-})
-
-test('오더: 개별 + 집약, 도메인 kind 유지', () => {
-  const d = buildEntityDeltas({
-    orders: [
-      { id: 'o1', kind: 'workorder', status: 'picking', progress: 0.5, held: false },
-      { id: 'o2', kind: 'outbound', status: 'created', progress: 0, held: true }
-    ]
-  }, 't1')
-  assert.equal(byTag(d, 'o1').data.kind, 'workorder')
-  const agg = byTag(d, ordersTag('t1')).data
-  assert.equal(agg.entity, 'orders')
-  assert.equal(agg.orders.length, 2)
-  assert.equal(agg.orders[1].held, true, '집약에 held 반영')
-})
-
-test('계약에 새 속성이 생기면 손대지 않아도 도달한다 — 화이트리스트 재발 방지', () => {
-  /* 이 테스트가 실패하면 누군가 필드를 손으로 골라 담기 시작한 것이다. */
-  const d = buildEntityDeltas({ locations: [{ id: 'n1', occupancy: 0, temperatureC: -18, hazmatClass: '3' }] }, 't1')
-  const n = byTag(d, 'n1').data
-  assert.equal(n.temperatureC, -18, '알지 못하는 새 속성도 통과해야 한다')
-  assert.equal(n.hazmatClass, '3')
-})
-
-test('undefined 값은 싣지 않는다 — 키 유무가 시그니처를 흔들지 않게', () => {
-  const d = buildEntityDeltas({ equipment: [{ id: 'fk-1', kind: 'forklift', location: undefined, status: 'idle' }] }, 't1')
-  assert.equal('location' in byTag(d, 'fk-1').data, false)
-})
-
-test('빈 상태 — 집약 태그 셋은 항상 방출(빈 배열)', () => {
-  const d = buildEntityDeltas({}, 't1')
-  assert.deepEqual(byTag(d, ordersTag('t1')).data.orders, [])
-  assert.deepEqual(byTag(d, tasksTag('t1')).data.tasks, [])
-  assert.deepEqual(byTag(d, itemsTag('t1')).data.items, [])
-  assert.equal(byTag(d, itemsTag('t1')).data.total, 0)
-})
-
-/* ── 사람 ────────────────────────────────────────────────────────────────
- *
- * 인원은 설비와 별개 엔티티다(고장·설비효율이 아니라 등급·교대로 산다). 같은 통과 규칙을 쓰되
- * 자기 태그로 나가고, 집약 태그도 따로 둔다 — 인원을 한눈에 보는 소비처가 있기 때문이다.
- */
-test('사람이 개별 태그로 나간다 — 등급·교대가 그대로', () => {
-  const deltas = buildEntityDeltas({
-    persons: [{ id: 'w1', personnelClass: 'welder-op', status: 'busy', taskId: 't1', offShift: undefined }]
-  }, 't1')
-  const one = deltas.find(d => d.tag === 'w1')!
-  assert.equal(one.data.entity, 'person')
-  assert.equal(one.data.personnelClass, 'welder-op')
-  assert.equal(one.data.status, 'busy')
-  assert.equal(one.data.taskId, 't1')
-})
-
-test('사람 집약 태그가 항상 나간다 — 선언하지 않은 트윈은 빈 배열(없음과 모름을 구별)', () => {
-  const withNone = buildEntityDeltas({}, 't1')
-  const agg = withNone.find(d => d.tag === personsTag('t1'))!
-  assert.deepEqual(agg.data.persons, [])
-  const withTwo = buildEntityDeltas({ persons: [{ id: 'w1' }, { id: 'w2' }] }, 't1')
-  assert.equal(withTwo.find(d => d.tag === personsTag('t1'))!.data.persons.length, 2)
-})
-
-/*
- * ── 에너지 (EMS 6단계) ──────────────────────────────────────────────────────
- *
- * 계측은 `state.energy` 에 산다 — 자원 축이 아니다. 이 매핑이 없으면 보드에 놓은 계량기가 값을
- * 받지 못하고 **영원히 빈 모습**이 된다(컴포넌트는 있는데 데이터가 없는, 눈에 안 보이는 결함).
- */
-test('계량 지점의 마지막 관측이 그 설비 태그로 나간다', () => {
-  const deltas = buildEntityDeltas(
-    {
-      locations: [],
-      equipment: [],
-      energy: {
-        points: [
-          { id: 'meter-incoming', kW: 1200.5, kWh: 98_000, powerFactor: 0.95, atMs: Date.parse('2026-08-14T09:01:00.000Z'), samplesInWindow: 3 },
-          { id: 'meter-quiet', samplesInWindow: 0 }
-        ],
-        closed: [],
-        closedTotal: 0
-      }
-    },
-    'ems-1'
-  )
-  const m = deltas.find(d => d.tag === 'meter-incoming')!
-  assert.equal(m.data.entity, 'meter')
-  assert.equal(m.data.kW, 1200.5)
-  assert.equal(m.data.measuredAt, '2026-08-14T09:01:00.000Z', '시각을 함께 낸다 — 화면이 계측 끊김을 스스로 안다')
-
-  /* 값이 없는 지점: 키를 넣지 않는다(0 으로 만들면 「전기를 안 썼다」가 된다). */
-  const q = deltas.find(d => d.tag === 'meter-quiet')!
-  assert.equal('kW' in q.data, false)
-  assert.equal(q.data.samplesInWindow, 0, '받은 표본 수는 사실이다')
-})
-
-test('수요 구간·피크·계약은 집약 태그로 나간다 — 개체의 사실이 아니다', () => {
-  const deltas = buildEntityDeltas(
-    {
-      locations: [],
-      equipment: [],
-      energy: {
-        points: [],
-        contractKW: 4000,
-        open: { startMs: 1, endMs: 2, samples: 1, maxKW: 4200 },
-        peakSince: { kW: 4200, windowStartMs: 1 },
-        closed: Array.from({ length: 20 }, (_, i) => ({ startMs: i, endMs: i + 1, samples: 1, maxKW: 100 + i })),
-        closedTotal: 137
-      }
-    },
-    'ems-1'
-  )
-  const agg = deltas.find(d => d.tag === energyTag('ems-1'))!
-  assert.ok(agg, '집약 태그가 있어야 한다')
-  assert.equal(agg.data.contractKW, 4000)
-  assert.equal(agg.data.peakSince.kW, 4200)
-  /* 하루치를 매 브로드캐스팅에 실으면 채널이 그것으로 찬다 — 최근 것만 내고 전체 수를 함께 낸다. */
-  assert.equal(agg.data.recent.length, 8)
-  assert.equal(agg.data.closedTotal, 137, '자른 사실을 알리지 않고 두지 않는다')
-})
-
-test('에너지가 없는 트윈은 에너지 태그를 내지 않는다 — 없는 것을 만들지 않는다', () => {
-  const deltas = buildEntityDeltas({ locations: [], equipment: [] }, 'wms-1')
-  assert.equal(deltas.some(d => d.tag === energyTag('wms-1')), false)
-  assert.equal(deltas.some(d => d.data?.entity === 'meter'), false)
-})
-
-test('자리에도 에너지가 실린다 — 능력이 「잰다」고 말하는데 값이 없던 자리', () => {
-  const deltas = buildEntityDeltas(
-    {
-      locations: [
-        { id: 'incoming-1', type: 'incoming' },
-        { id: 'feeder-a', type: 'feeder' },
-        { id: 'feeder-b', type: 'feeder' }
-      ],
-      equipment: [
-        { id: 'm-main', kind: 'meter', homeLocation: 'incoming-1' },
-        { id: 'm-a1', kind: 'meter', homeLocation: 'feeder-a' },
-        { id: 'm-a2', kind: 'meter', homeLocation: 'feeder-a' }
-      ],
-      energy: {
-        points: [
-          { id: 'm-main', kW: 3800, kWh: 1000, atMs: Date.parse('2026-08-14T09:00:00.000Z'), samplesInWindow: 3 },
-          { id: 'm-a1', kW: 1000, atMs: Date.parse('2026-08-14T09:01:00.000Z'), samplesInWindow: 2 },
-          { id: 'm-a2', kW: 600, atMs: Date.parse('2026-08-14T09:02:00.000Z'), samplesInWindow: 1 }
-        ],
-        closed: [],
-        closedTotal: 0
-      }
-    },
-    'ems-1'
-  )
-
-  const incoming = deltas.find(d => d.tag === 'incoming-1')!.data
-  assert.equal(incoming.entity, 'location', '자리 payload 를 덮지 않고 합친다')
-  assert.equal(incoming.kW, 3800)
-  assert.deepEqual(incoming.meters, ['m-main'], '어느 계량기에서 온 수인지 되짚을 수 있어야 한다')
-
-  /* 자리에 계량기가 둘이면 그 자리의 수는 둘의 합이고, 나이는 **가장 최근**이다. */
-  const a = deltas.find(d => d.tag === 'feeder-a')!.data
-  assert.equal(a.kW, 1600)
-  assert.equal(a.samplesInWindow, 3)
-  assert.equal(a.measuredAt, '2026-08-14T09:02:00.000Z')
-  assert.deepEqual(a.meters, ['m-a1', 'm-a2'])
-
-  /* 계량기가 없는 자리는 예전 그대로 — 에너지 키를 만들지 않는다(0 은 「안 썼다」가 된다). */
-  const b = deltas.find(d => d.tag === 'feeder-b')!.data
-  assert.equal('kW' in b, false)
-  assert.equal('meters' in b, false)
-})
-
-test('자리를 모르는 계량기는 자리에 실리지 않는다 — 설비 태그로만 나간다', () => {
-  const deltas = buildEntityDeltas(
-    {
-      locations: [{ id: 'incoming-1', type: 'incoming' }],
-      equipment: [],
-      energy: { points: [{ id: 'm-orphan', kW: 500, samplesInWindow: 1 }], closed: [], closedTotal: 0 }
-    },
-    'ems-1'
-  )
-  assert.equal('kW' in deltas.find(d => d.tag === 'incoming-1')!.data, false)
-  assert.equal(deltas.find(d => d.tag === 'm-orphan')!.data.kW, 500, '설비 태그로는 나간다')
-})
-
-/*
- * ── 능력 넷의 값이 컴포넌트까지 간다 (2026-08-15) ───────────────────────────
- * 보드에 놓인 컴포넌트는 `data(tag)` 로만 값을 받는다. 커널이 값을 들고 있어도 이 페이로드에 실리지
- * 않으면 화면은 영원히 「—」다 — 실제로 그 부류를 두 번 겪었다(스냅샷 투영이 필드를 빠뜨렸고,
- * 값의 시각을 버렸다).
- *
- * 그래서 **설비 태그의 payload** 를 직접 못 박는다: 값과 그 값의 나이가 함께 실려야 한다.
- */
-test('발전·저장·감축·개폐 값과 그 나이가 설비 태그로 나간다', () => {
-  const deltas = buildEntityDeltas(
-    {
-      locations: [{ id: 'incoming-1', type: 'incoming' }],
-      equipment: [
-        { id: 'pv-1', kind: 'pv-array', homeLocation: 'incoming-1', status: 'idle', generatedKW: 210, exportKW: 40, measuredAt: '2026-08-15T09:00:00.000Z' },
-        { id: 'ess-1', kind: 'battery', homeLocation: 'incoming-1', status: 'idle', soc: 62, chargeKW: 0, dischargeKW: 85, measuredAt: '2026-08-15T09:00:00.000Z' },
-        { id: 'load-1', kind: 'curtailable-load', homeLocation: 'incoming-1', status: 'busy', curtailable: true, minKW: 30, measuredAt: '2026-08-15T09:00:00.000Z' },
-        { id: 'cb-1', kind: 'breaker', homeLocation: 'incoming-1', status: 'idle', position: 'closed', measuredAt: '2026-08-15T09:00:00.000Z' }
-      ]
-    },
-    'ems-1'
-  )
-  const by = Object.fromEntries(deltas.map(d => [d.tag, d.data as any]))
-
-  assert.equal(by['pv-1'].generatedKW, 210)
-  assert.equal(by['pv-1'].exportKW, 40)
-  assert.equal(by['ess-1'].soc, 62)
-  assert.equal(by['ess-1'].dischargeKW, 85)
-  assert.equal(by['load-1'].curtailable, true)
-  assert.equal(by['load-1'].minKW, 30)
-  assert.equal(by['cb-1'].position, 'closed')
-  /* 나이가 없으면 화면이 멈춘 값을 지금 값처럼 그린다 — 네 컴포넌트가 모두 이 키를 읽는다. */
-  for (const id of ['pv-1', 'ess-1', 'load-1', 'cb-1']) {
-    assert.equal(by[id].measuredAt, '2026-08-15T09:00:00.000Z', `${id}: 값의 나이가 함께 가야 한다`)
-  }
-})
-
-test('값이 없는 설비에는 그 키를 만들지 않는다 — 0 으로 그리면 「안 쓴다」가 된다', () => {
-  const deltas = buildEntityDeltas(
-    {
-      locations: [{ id: 'incoming-1', type: 'incoming' }],
-      equipment: [{ id: 'pv-2', kind: 'pv-array', homeLocation: 'incoming-1', status: 'idle' }]
-    },
-    'ems-1'
-  )
-  const pv = deltas.find(d => d.tag === 'pv-2')!.data as any
-  assert.equal('generatedKW' in pv, false)
-  assert.equal('measuredAt' in pv, false)
-})

package/test/equipment-identity-reaches.test.ts

@@ -1,57 +0,0 @@
-/*
- * **선언한 설비 정체성이 투영까지 닿는가** — 선언에서 화면까지 걸어 본다.
- *
- * ── 무엇이 있었나 (2026-08-30) ────────────────────────────────────────────
- * 투영이 `m.gs1Id` 를 읽고 있었는데 **선언에 그런 필드가 없었다.** 그래서 그 칸은 일곱 대 모두 영원히
- * 비어 있었다. 오류는 나지 않았다 — `?? null` 이 늘 `null` 을 냈을 뿐이다.
- *
- * 값은 한 칸 옆에 있었다. 커넥터가 인버터의 하드웨어 식별자를 속성으로 이미 보내고 있었고
- * (`properties.deviceId = ES100000007d8d061d-1`), 정체성 칸도 있었는데 **그 사이에 길이 없었다.**
- *
- * 이 저장소에서 가장 자주 나는 결함 부류다. 그래서 필드를 여는 것으로 끝내지 않고 **선언 → 투영**을
- * 실제로 걸어 본다. 필드만 있고 길이 없으면 여기서 빨갛게 난다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-
-import type { TwinModelDef } from '@operato/ops-contract'
-
-const here = dirname(fileURLToPath(import.meta.url))
-const src = (p: string) => readFileSync(join(here, '..', 'server', p), 'utf-8')
-
-test('★ 선언에 정체성 자리가 있다', () => {
-  /* 타입이 받아들이면 선언에 자리가 있는 것이다 — 없으면 이 파일이 컴파일되지 않는다. */
-  const model: TwinModelDef = {
-    locations: [{ id: 'incoming', type: 'incoming' }],
-    equipment: [{ id: '001', kind: 'pv-array', homeLocation: 'incoming', identity: 'ES100000007d8d061d-1' }]
-  } as any
-  assert.equal((model.equipment?.[0] as any).identity, 'ES100000007d8d061d-1')
-})
-
-test('★ 투영이 그 자리를 읽는다 — 선언에 없는 이름을 읽으면 칸이 영원히 빈다', () => {
-  const projection = src('service/twin-model/project-structure.ts')
-  assert.match(
-    projection,
-    /identity:\s*\(m as any\)\.identity/,
-    '설비 투영이 선언의 identity 를 읽어야 한다. 다른 이름을 읽으면 그 칸은 늘 null 이다.'
-  )
-  assert.doesNotMatch(
-    projection,
-    /gs1Id:\s*m\.gs1Id/,
-    '설비 선언에 gs1Id 는 없다 — 읽으면 늘 null 이 된다(2026-08-30 실측: 일곱 대 모두 비어 있었다)'
-  )
-})
-
-test('★ 저장 자리의 이름이 선언과 같다 — 두 벌이면 한쪽만 고쳐진다', () => {
-  const entity = src('service/twin-model/twin-equipment.ts')
-  assert.match(entity, /identity\?: string/, '설비 행에 identity 칸이 있어야 한다')
-  assert.doesNotMatch(entity, /gs1Id\?: string/, '설비에서는 gs1Id 를 쓰지 않는다 — 정체성이 GS1 키가 아닌 것이 정상이다')
-})
-
-test('자리(location)의 gs1Id 는 그대로 둔다 — 그쪽은 실제로 SGLN 이 온다', () => {
-  const entity = src('service/twin-model/twin-location.ts')
-  assert.match(entity, /gs1Id\?: string/, '자리는 GS1 키를 받는다 — 설비와 같은 이유로 지우면 안 된다')
-})

package/test/event-subjects.test.ts

@@ -1,148 +0,0 @@
-/*
- * ★ 사건 하나가 무엇을 가리키는지 뽑는다 — 360 이력이 64초인 원인을 없애는 첫 조각.
- *
- * ── 왜 이 모양인가 (2026-08-27 실측) ────────────────────────────────────────
- * 「이 품목의 이력」 조회가 64초다. 저장된 식별자에 품목과 로트가 한 문자열로 붙어 있어서, 품목만으로는
- * 찾을 방법이 없다.
- *
- *   https://seunghwa.net/class/product-M0000618-lot-L2604100071
- *
- * 문자열을 자르는 규칙을 여기에 넣지 않는다 — 어느 부호가 로트를 가리키는지 연결된 시스템마다 다르고,
- * chef 의 `-lot-` 을 굳히면 이 파일이 그 시스템 위에 서게 된다. 대신 대상마다 한 줄을 적고, 품목이
- * 무엇인지는 그 트윈의 선언과 견주어 부르는 쪽이 답한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { subjectsOf, SUBJECT_KINDS } from '../server/service/twin-subject/event-subjects.js'
-
-const objectEvent = (over: any = {}) => ({
-  eventType: 'epcis.ObjectEvent',
-  eventTime: '2026-08-27T05:00:00.000Z',
-  data: {
-    epcList: ['https://seunghwa.net/class/product-M0000438-lot-L2403090386'],
-    bizLocation: { id: 'M2R0001' },
-    action: 'OBSERVE',
-    ...over
-  }
-})
-
-const find = (subjects: any[], kind: string) => subjects.filter(s => s.kind === kind).map(s => s.id)
-
-test('★ 품목과 로트를 두 줄로 적는다 — 문자열을 자르지 않고도 품목으로 찾을 수 있다', () => {
-  const subjects = subjectsOf(objectEvent(), {
-    /* 선언과 견주어 품목을 찾는 일은 부르는 쪽이 한다 — 그 트윈의 선언을 아는 것이 그쪽이다. */
-    itemOf: epc => (epc.includes('product-M0000438') ? 'M0000438' : null)
-  })
-  assert.deepEqual(find(subjects, 'lot'), ['https://seunghwa.net/class/product-M0000438-lot-L2403090386'])
-  assert.deepEqual(find(subjects, 'item'), ['M0000438'])
-})
-
-test('★ 품목을 찾지 못하면 품목 줄을 만들지 않는다 — 짐작으로 이으면 남의 이력에 섞인다', () => {
-  const subjects = subjectsOf(objectEvent(), { itemOf: () => null })
-  assert.equal(find(subjects, 'lot').length, 1, '개체는 그대로 적는다')
-  assert.deepEqual(find(subjects, 'item'), [], '품목은 비운다')
-})
-
-test('★ 찾은 값이 개체 식별자와 같으면 품목이 아니다 — itemRefOf 는 URI 를 그대로 돌려준다', () => {
-  /*
-   * `itemRefOf` 는 SGTIN 이 아닌 모양에서 문자열을 그대로 낸다(자르는 판단을 하지 않으므로). 그 값을
-   * 품목으로 적으면 로트와 같은 줄이 두 종류로 생기고, 품목 이력이 로트 이력과 같아진다.
-   */
-  const epc = 'https://seunghwa.net/class/product-M0000438-lot-L2403090386'
-  const subjects = subjectsOf(objectEvent(), { itemOf: () => epc })
-  assert.deepEqual(find(subjects, 'item'), [])
-})
-
-test('★ 한 사건이 여러 대상을 가리킨다 — 자리·설비·오더·작업', () => {
-  const subjects = subjectsOf({
-    eventType: 'task.status',
-    eventTime: '2026-08-27T05:00:00.000Z',
-    data: { taskId: 'tk-1', moverId: 'mixer-1', toNode: 'M2R0001', orderId: 'ORD-9' }
-  })
-  assert.deepEqual(find(subjects, 'task'), ['tk-1'])
-  assert.deepEqual(find(subjects, 'equipment'), ['mixer-1'])
-  assert.deepEqual(find(subjects, 'order'), ['ORD-9'])
-  assert.ok(find(subjects, 'location').length <= 1, '자리는 한 줄이다')
-})
-
-test('★ 가리키는 것이 없으면 빈 배열이다 — 없는 대상을 만들지 않는다', () => {
-  const subjects = subjectsOf({ eventType: 'energy.demand.window', data: { maxKW: 3 } })
-  assert.deepEqual(subjects, [])
-})
-
-test('★ 작업이 오간 두 자리를 다 적는다 — 승격 컬럼은 둘 중 하나만 담을 수 있어 비워 둔다', () => {
-  /*
-   * `locationOf` 는 EPCIS 자리만 읽는다. 작업이 A→B 로 갈 때 컬럼 하나에 둘을 넣을 수 없으므로
-   * 아무것도 넣지 않는다. 이 표는 자리마다 줄이 하나라서 둘을 함께 담는다.
-   */
-  const subjects = subjectsOf({
-    eventType: 'task.status',
-    data: { taskId: 'tk-1', fromNode: 'M2R0001', toNode: 'M2R0002' }
-  })
-  assert.deepEqual(find(subjects, 'location'), ['M2R0001', 'M2R0002'])
-})
-
-test('★ 같은 대상을 두 번 적지 않는다 — 출발지와 도착지가 같을 수 있다', () => {
-  const subjects = subjectsOf({
-    eventType: 'task.status',
-    data: { taskId: 'tk-1', fromNode: 'M2R0001', toNode: 'M2R0001' }
-  })
-  assert.deepEqual(find(subjects, 'location'), ['M2R0001'])
-})
-
-test('종류 목록이 닫혀 있다 — 열어 두면 넣는 쪽마다 다른 이름을 쓴다', () => {
-  /* `transaction` 은 2026-09-05 에 늘었다 — 거래가 오더 칸에 섞여 들어오던 것을 갈랐다. */
-  assert.deepEqual([...SUBJECT_KINDS], ['item', 'lot', 'order', 'location', 'equipment', 'task', 'transaction'])
-})
-
-test('너무 긴 식별자는 적지 않는다 — 자르면 그 줄이 다른 대상을 가리킨다', () => {
-  const long = 'x'.repeat(300)
-  const subjects = subjectsOf({ eventType: 'task.status', data: { taskId: long } })
-  assert.deepEqual(find(subjects, 'task'), [], '알리지 않고 자르지 않고 아예 만들지 않는다')
-})
-
-test('빈 값과 공백은 대상이 아니다 — 결측을 대상으로 만들지 않는다', () => {
-  const subjects = subjectsOf({ eventType: 'task.status', data: { taskId: '   ', moverId: '' } })
-  assert.deepEqual(subjects, [])
-})
-
-test('★ 클래스로 온 사건은 품목 줄만 만든다 — 개체가 없는 사건이다', () => {
-  /*
-   * 실측한 chef 의 사건이다. 무게로 담는 현장이라 개체 목록이 비어 있고 수량 목록에 클래스가 있다.
-   * 그것을 로트로 적으면 뜻이 틀린다 — 개체가 아니라 품목이다.
-   */
-  const subjects = subjectsOf({
-    eventType: 'epcis.ObjectEvent',
-    data: {
-      epcList: [],
-      quantityList: [{ epcClass: 'https://seunghwa.net/class/product-M0000879', quantity: 11797.6, uom: 'KGM' }],
-      bizLocation: { id: 'P2F0001' }
-    }
-  })
-  assert.deepEqual(find(subjects, 'lot'), [], '개체 줄을 만들지 않는다')
-  assert.deepEqual(find(subjects, 'item'), ['https://seunghwa.net/class/product-M0000879'])
-  assert.deepEqual(find(subjects, 'location'), ['P2F0001'])
-})
-
-test('★ 클래스도 선언과 견주어 품목 코드로 줄인다 — 선언이 답하면 그것을 쓴다', () => {
-  const subjects = subjectsOf(
-    {
-      eventType: 'epcis.ObjectEvent',
-      data: { epcList: [], quantityList: [{ epcClass: 'https://seunghwa.net/class/product-M0000879' }] }
-    },
-    { itemOf: epc => (epc.includes('M0000879') ? 'M0000879' : null) }
-  )
-  assert.deepEqual(find(subjects, 'item'), ['M0000879'])
-})
-
-test('개체와 클래스가 함께 오면 둘 다 적는다 — 한 사건이 둘을 가리킬 수 있다', () => {
-  const subjects = subjectsOf({
-    eventType: 'epcis.ObjectEvent',
-    data: {
-      epcList: ['https://seunghwa.net/class/product-M0000438-lot-L1'],
-      quantityList: [{ epcClass: 'https://seunghwa.net/class/product-M0000879' }]
-    }
-  })
-  assert.deepEqual(find(subjects, 'lot'), ['https://seunghwa.net/class/product-M0000438-lot-L1'])
-  assert.deepEqual(find(subjects, 'item'), ['https://seunghwa.net/class/product-M0000879'])
-})

package/test/event-time-column.test.ts

@@ -1,67 +0,0 @@
-/*
- * eventTime 이 **날짜 컬럼**이라는 사실을 지킨다.
- *
- * ── 왜 있나 (2026-08-08) ────────────────────────────────────────────────────
- * 예전에는 문자열 컬럼이었고, "UTC ISO 만 들어오니 사전식 비교가 맞는다" 는 전제 위에서 정렬·범위
- * 질의가 돌았다. 그 전제는 컬럼 어디에도 적혀 있지 않았다.
- *
- * 날짜 컬럼으로 바꾸면서 **들어온 것이 없는 함정**이 하나 드러났다: sqlite 는 datetime 을 공백 구분 형식
- * (`2026-08-07 11:00:00.000`)으로 저장하는데, 화면은 ISO 문자열(`…T11:00:00.000Z`)을 보낸다.
- * 문자열 그대로 비교하면 사전식으로 어긋나 **오류 없이 0건**이 나온다 — 원장 시간창이 알리지 않고
- * 비어 버리고, 사용자는 "그 시간에 아무 일도 없었다" 로 읽는다.
- *
- * 그래서 두 가지를 못 박는다: 저장 형식이 실제로 그렇다는 것과, 경계에서 날짜로 옮기면 걸린다는 것.
- * 이 검사가 깨지면 typeorm/드라이버의 거동이 바뀐 것이므로 변환 지점을 다시 봐야 한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-
-const req = createRequire(import.meta.url)
-const { DataSource, EntitySchema, Between } = req('typeorm')
-
-const Ev = new EntitySchema({
-  name: 'ev',
-  tableName: 'ev',
-  columns: {
-    id: { primary: true, type: 'int', generated: true },
-    eventTime: { type: 'datetime', nullable: true }
-  }
-})
-
-async function seeded() {
-  const ds = new DataSource({ type: 'sqlite', database: ':memory:', entities: [Ev], synchronize: true })
-  await ds.initialize()
-  const repo = ds.getRepository('ev')
-  await repo.save([
-    { eventTime: new Date('2026-08-07T11:00:00.000Z') },
-    { eventTime: new Date('2026-08-07T13:00:00.000Z') }
-  ])
-  return { ds, repo }
-}
-
-test('sqlite 는 datetime 을 공백 구분 형식으로 저장한다 — ISO 문자열과 사전식으로 어긋난다', async () => {
-  const { ds } = await seeded()
-  const raw = await ds.query('select eventTime from ev order by id')
-  assert.match(raw[0].eventTime, /^\d{4}-\d{2}-\d{2} /, '공백 구분이 아니면 이 검사의 전제가 바뀐 것이다')
-  assert.ok(!String(raw[0].eventTime).includes('T'), 'T 가 들어가면 ISO 와 같은 형식이므로 함정이 사라진 것이다')
-  await ds.destroy()
-})
-
-test('ISO 문자열을 그대로 넘기면 **알리지 않고 0건** — 오류가 아니라 빈 결과라 더 위험하다', async () => {
-  const { ds, repo } = await seeded()
-  const rows = await repo.find({
-    where: { eventTime: Between('2026-08-07T10:00:00.000Z', '2026-08-07T12:00:00.000Z') }
-  })
-  assert.equal(rows.length, 0, '이 검사가 깨졌다면 드라이버가 문자열을 받아 주게 된 것 — 변환 지점을 재검토할 것')
-  await ds.destroy()
-})
-
-test('경계에서 날짜로 옮기면 제대로 걸린다 — 질의 전에 반드시 변환한다', async () => {
-  const { ds, repo } = await seeded()
-  const rows = await repo.find({
-    where: { eventTime: Between(new Date('2026-08-07T10:00:00.000Z'), new Date('2026-08-07T12:00:00.000Z')) }
-  })
-  assert.equal(rows.length, 1)
-  await ds.destroy()
-})