@things-factory/webhook 10.1.29 → 10.1.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/webhook",
-  "version": "10.1.29",
+  "version": "10.1.33",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -29,11 +29,11 @@
   "dependencies": {
     "@operato/graphql": "^10.0.0",
     "@operato/i18n": "^10.0.0",
-    "@operato/ops-contract": "^0.9.28",
-    "@things-factory/auth-base": "^10.1.29",
+    "@operato/ops-contract": "^0.9.30",
+    "@things-factory/auth-base": "^10.1.33",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/shell": "^10.1.29",
-    "@things-factory/task-lease": "^10.1.29"
+    "@things-factory/shell": "^10.1.33",
+    "@things-factory/task-lease": "^10.1.33"
   },
-  "gitHead": "e6bf9dec003fe5e794746aaeb5852b3b50478232"
+  "gitHead": "7fb7b6587846b5ff6ee7a4983652d9561b4d6b2c"
 }

package/tests/outbox-append.test.ts

@@ -0,0 +1,106 @@
+/**
+ * The back row of the outbox: the order of the two writes, and what is refused before either.
+ *
+ * The number and the row have to commit together. A caller that passed the default manager burned 200
+ * numbers at one site before anybody noticed, so the manager is now asked for in the type as well as
+ * checked - and the check is what these tests can reach.
+ */
+
+import { appendOutbox, openTransaction, type NewOutboxRow } from '../server/service/outbox/append.js'
+
+const inTransaction = { queryRunner: { isTransactionActive: true } }
+
+function store() {
+  const inserted: NewOutboxRow<any>[][] = []
+  const allocated: number[] = []
+  let last = 100
+
+  return {
+    inserted,
+    allocated,
+    async allocate(count: number) {
+      allocated.push(count)
+      last += count
+
+      return last - count + 1
+    },
+    async insert(rows: readonly NewOutboxRow<any>[]) {
+      inserted.push([...rows])
+
+      return rows.map((row, index) => ({ ...row, id: `r${index}` }))
+    }
+  }
+}
+
+const tx = () => openTransaction(inTransaction as any)
+
+describe('appendOutbox', () => {
+  it('will not take a manager that is not in a transaction - the number would commit alone', () => {
+    expect(() => openTransaction({} as any)).toThrow(/transaction/)
+    expect(() => openTransaction({ queryRunner: {} } as any)).toThrow(/transaction/)
+  })
+
+  it('numbers a batch in one run, in the order given', async () => {
+    const one = store()
+
+    await appendOutbox(tx(), one, [{ record: { a: 1 } }, { record: { a: 2 } }, { record: { a: 3 } }])
+
+    expect(one.allocated).toEqual([3])
+    expect(one.inserted[0].map(row => row.seq)).toEqual([101, 102, 103])
+  })
+
+  it('takes no number at all for an empty batch', async () => {
+    const one = store()
+
+    expect(await appendOutbox(tx(), one, [])).toEqual([])
+    expect(one.allocated).toEqual([])
+    expect(one.inserted).toEqual([])
+  })
+
+  it('gives every row an id the receiver can dedupe on, and keeps one the caller named', async () => {
+    const one = store()
+
+    await appendOutbox(tx(), one, [{ record: { a: 1 } }, { record: { a: 2 }, eventId: 'urn:uuid:mine' }])
+
+    const [first, second] = one.inserted[0]
+
+    expect(first.eventId).toMatch(/^urn:uuid:/)
+    expect(second.eventId).toBe('urn:uuid:mine')
+    expect(first.eventId).not.toBe(second.eventId)
+  })
+
+  it('stamps one record time for the batch, and keeps each event time', async () => {
+    const one = store()
+    const happened = new Date('2026-09-01T00:00:00.000Z')
+
+    await appendOutbox(tx(), one, [{ record: { a: 1 }, eventTime: happened }, { record: { a: 2 } }])
+
+    const [first, second] = one.inserted[0]
+
+    expect(first.eventTime).toBe(happened)
+    expect(second.eventTime).toEqual(second.recordTime)
+    expect(first.recordTime).toEqual(second.recordTime)
+  })
+
+  describe('what is refused before anything is written', () => {
+    it('an empty payload - it would be delivered as a fact', async () => {
+      const one = store()
+
+      await expect(appendOutbox(tx(), one, [{ record: undefined as any }])).rejects.toThrow(/record is required/)
+      expect(one.allocated).toEqual([])
+    })
+
+    it('★ a record the product says has a broken identity, and no number is taken', async () => {
+      const one = store()
+      const check = (record: any) => (record.epc ? [] : ['epc is missing'])
+
+      await expect(appendOutbox(tx(), one, [{ record: { epc: 'x' } }, { record: {} }], { check })).rejects.toThrow(
+        /identity is not valid - epc is missing/
+      )
+
+      /* The whole batch is refused before the counter moves - a rolled-back raise is a burned number. */
+      expect(one.allocated).toEqual([])
+      expect(one.inserted).toEqual([])
+    })
+  })
+})

package/tests/outbox-pump-gate.test.ts

@@ -0,0 +1,65 @@
+/**
+ * Whether this installation can sign, and whose key a domain gets.
+ *
+ * This is the judgement that decides whether anything is delivered at all, so it takes the
+ * environment as an argument - read from the process it would be out of a test's reach, and the way
+ * it fails is silence: rows pile up and nothing errors.
+ *
+ * Moved from operato-plant with the names lifted out (ADR-0078 decision 2 ②, decision 5 as amended):
+ * the module owns the shape of a per-domain variable, the product owns the stems.
+ */
+
+import { domainSecretName, outboxCanSign, outboxSecretFor } from '../server/service/outbox/pump-gate.js'
+
+const names = { common: 'MES_OUTBOX_SECRET', domainPrefix: 'MES_OUTBOX_SECRET__' }
+
+describe('a domain becomes a variable name', () => {
+  it('upper case, and anything else becomes an underscore', () => {
+    expect(domainSecretName('MES_OUTBOX_SECRET__', 'miratek-gunsan')).toBe('MES_OUTBOX_SECRET__MIRATEK_GUNSAN')
+    expect(domainSecretName('MES_OUTBOX_SECRET__', 'miratek.gunsan')).toBe('MES_OUTBOX_SECRET__MIRATEK_GUNSAN')
+  })
+})
+
+describe('can this installation sign', () => {
+  it('no - nothing named holds a value', () => {
+    expect(outboxCanSign({}, names)).toBe(false)
+    expect(outboxCanSign({ SOMETHING_ELSE: 'x' }, names)).toBe(false)
+  })
+
+  it('★ no - a key that is only whitespace signs, so it does not count as a key', () => {
+    expect(outboxCanSign({ MES_OUTBOX_SECRET: '   ' }, names)).toBe(false)
+    expect(outboxCanSign({ MES_OUTBOX_SECRET__MIRATEK_GUNSAN: '\t' }, names)).toBe(false)
+  })
+
+  it('yes - the common key, a domain key, or one declared in configuration', () => {
+    expect(outboxCanSign({ MES_OUTBOX_SECRET: 'k' }, names)).toBe(true)
+    expect(outboxCanSign({ MES_OUTBOX_SECRET__MIRATEK_GUNSAN: 'k' }, names)).toBe(true)
+    expect(outboxCanSign({}, names, 'k')).toBe(true)
+  })
+
+  it('★ counts only the names this product declared - another product\'s keys are not ours', () => {
+    const warehouse = { WMS_OUTBOX_SECRET: 'k', WMS_OUTBOX_SECRET__MIRATEK_GUNSAN: 'k' }
+
+    expect(outboxCanSign(warehouse, names)).toBe(false)
+    expect(outboxCanSign(warehouse, { common: 'WMS_OUTBOX_SECRET', domainPrefix: 'WMS_OUTBOX_SECRET__' })).toBe(true)
+  })
+})
+
+describe('whose key this domain signs with', () => {
+  it('★ its own comes before the common one', () => {
+    const env = { MES_OUTBOX_SECRET: 'common', MES_OUTBOX_SECRET__MIRATEK_GUNSAN: 'mine' }
+
+    expect(outboxSecretFor(env, names, 'miratek-gunsan')).toBe('mine')
+    expect(outboxSecretFor(env, names, 'somewhere-else')).toBe('common')
+  })
+
+  it('★ absent is undefined, never an empty string - an empty key signs', () => {
+    expect(outboxSecretFor({}, names, 'miratek-gunsan')).toBeUndefined()
+    expect(outboxSecretFor({ MES_OUTBOX_SECRET: '  ' }, names, 'miratek-gunsan')).toBeUndefined()
+  })
+
+  it('a key declared in configuration is the last resort', () => {
+    expect(outboxSecretFor({}, names, 'miratek-gunsan', 'declared')).toBe('declared')
+    expect(outboxSecretFor({ MES_OUTBOX_SECRET: 'common' }, names, 'miratek-gunsan', 'declared')).toBe('common')
+  })
+})