@voxgig/build 4.4.0 → 4.12.0

package/tm/web/backend/test/unit/srv/api/api.setup.ts.frag

@@ -0,0 +1,162 @@
+import Seneca from 'seneca'
+
+import Model from '../../../../model/model.json'
+
+const Expose = require('../../../../dist/srv/api/expose.js')
+
+
+// Seneca with the REST API service loaded from compiled dist/srv.
+//
+// The generic entity service is NOT loaded: it is stood in for with MOCK
+// MESSAGES (see mockEnt below), so these tests exercise the API layer -
+// exposure rules, generated-shape validation, op routing, result shaping -
+// in isolation, with no store and no access control in the way.
+async function makeSeneca(mock?: (seneca: any) => void) {
+  const seneca = Seneca({ legacy: false, timeout: 2222, debug: { undead: true } })
+  seneca.context.model = Model
+  seneca.context.env = 'test'
+
+  seneca.test()
+
+  seneca
+    .use('promisify')
+    .use('reload')
+    .use('../../../../dist/srv/api/api-srv')
+
+  if (mock) {
+    mock(seneca)
+  }
+
+  return seneca.ready()
+}
+
+
+// Stand-in for the generic entity service: records the calls it receives
+// and answers from a simple in-test store.
+function mockEnt(store: Record<string, any[]> = {}) {
+  const calls: any[] = []
+
+  const install = (seneca: any) => {
+    seneca.message('aim:ent,cmd:list', async function (msg: any) {
+      calls.push({ cmd: 'list', ent: msg.ent, q: msg.q })
+      const list = (store[msg.ent] || []).filter((item: any) =>
+        Object.keys(msg.q || {}).every((k) => item[k] === msg.q[k]))
+      return { ok: true, list }
+    })
+
+    seneca.message('aim:ent,cmd:load', async function (msg: any) {
+      calls.push({ cmd: 'load', ent: msg.ent, id: msg.id })
+      const item = (store[msg.ent] || []).find((i: any) => i.id === msg.id)
+      return { ok: true, item: item || null }
+    })
+
+    seneca.message('aim:ent,cmd:save', async function (msg: any) {
+      calls.push({ cmd: 'save', ent: msg.ent, item: msg.item })
+      const item = Object.assign({ id: msg.item.id || 'new01' }, msg.item)
+      store[msg.ent] = (store[msg.ent] || []).filter((i: any) => i.id !== item.id)
+      store[msg.ent].push(item)
+      return { ok: true, item }
+    })
+
+    seneca.message('aim:ent,cmd:remove', async function (msg: any) {
+      calls.push({ cmd: 'remove', ent: msg.ent, id: msg.id })
+      store[msg.ent] = (store[msg.ent] || []).filter((i: any) => i.id !== msg.id)
+      return { ok: true, id: msg.id }
+    })
+  }
+
+  return { install, calls, store }
+}
+
+
+// Post an API message AS a given user (the router resolves the principal
+// from the API key and passes it the same way).
+function as(seneca: any, user: any, msg: any) {
+  return seneca.post(Object.assign({}, msg, {
+    custom$: { principal: { user } },
+  }))
+}
+
+
+// ---- model-driven test subject -----------------------------------------
+//
+// These tests must hold for ANY model, so the entity under test and the
+// payloads are derived from the model rather than hard-coded.
+
+// Fields the server owns: never client-writable.
+const MANAGED = ['id', 'owner_id', 't_c', 't_m']
+
+const SAMPLE: Record<string, any> = {
+  String: 'test-value',
+  Number: 42,
+  Boolean: true,
+}
+
+// The wrong type to send for a given kind (to trip validation).
+const WRONG: Record<string, any> = {
+  String: 123,
+  Number: 'not-a-number',
+  Boolean: 'not-a-boolean',
+}
+
+
+// Pick an entity the API exposes, with everything a test needs to build
+// valid and invalid payloads for it. Returns null for a model with no
+// exposed entities (a brand new project).
+function pickEntity() {
+  const canons: string[] = Expose.exposedCanons(Model)
+  if (0 === canons.length) {
+    return null
+  }
+
+  const canon = canons[0]
+  const [zone, name] = canon.split('/')
+  const fields = ((Model as any).main.ent[zone][name] || {}).field || {}
+
+  const writable = Object.keys(fields).filter((f) => !MANAGED.includes(f))
+  const required = writable.filter((f) => {
+    const valid = null == fields[f].valid ? '' : String(fields[f].valid)
+    return !/Skip/.test(valid)
+  })
+
+  const kindOf = (f: string) =>
+    ['String', 'Number', 'Boolean'].includes(fields[f].kind) ? fields[f].kind : 'String'
+
+  // A minimal valid payload: every required field, nothing else.
+  const valid = () => required.reduce((a: any, f: string) =>
+    (a[f] = SAMPLE[kindOf(f)], a), {} as any)
+
+  // A payload with one field of the wrong type, when the entity has a
+  // field whose kind can be violated unambiguously.
+  const typed = writable.find((f) => 'Number' === kindOf(f) || 'Boolean' === kindOf(f))
+  const wrongType = () => {
+    if (null == typed) {
+      return null
+    }
+    return Object.assign(valid(), { [typed]: WRONG[kindOf(typed)] })
+  }
+
+  // A VALID value for a field that differs from what valid() sets, so a
+  // partial update is observable.
+  const patchValue = (f: string) => {
+    const kind = kindOf(f)
+    return 'String' === kind ? 'changed-value'
+      : 'Number' === kind ? 99
+        : false
+  }
+
+  return {
+    canon, zone, name, fields, writable, required,
+    valid, wrongType, kindOf, patchValue,
+  }
+}
+
+
+export {
+  makeSeneca,
+  mockEnt,
+  as,
+  pickEntity,
+  Model,
+}
+

package/tm/web/backend/test/unit/srv/api/api.test.ts.frag

@@ -0,0 +1,225 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+
+import { makeSeneca, mockEnt, as, pickEntity } from './api.setup'
+
+
+const ALICE = { id: 'u01', email: 'alice@ex.com' }
+
+// The entity under test comes from the model, so this suite holds for any
+// entity graph (see pickEntity).
+const ENT = pickEntity()
+
+
+describe('api service', () => {
+
+  test('get-info', async () => {
+    const seneca = await makeSeneca()
+    const out = await seneca.post('aim:api,get:info')
+    assert.strictEqual(out.ok, true)
+    assert.strictEqual(out.srv, 'api')
+    await seneca.close()
+  })
+
+
+  test('unknown entities, the sys zone and unknown ops are rejected', async () => {
+    const ent = mockEnt()
+    const seneca = await makeSeneca(ent.install)
+
+    for (const canon of ['nope/nope', 'sys/user', 'sys/apikey']) {
+      const out = await as(seneca, ALICE,
+        { aim: 'api', on: 'ent', op: 'list', ent: canon })
+      assert.strictEqual(out.ok, false, canon)
+      assert.strictEqual(out.why, 'unknown-entity', canon)
+    }
+
+    if (ENT) {
+      const badop = await as(seneca, ALICE,
+        { aim: 'api', on: 'ent', op: 'wat', ent: ENT.canon })
+      assert.strictEqual(badop.ok, false)
+      assert.strictEqual(badop.why, 'unknown-op')
+    }
+
+    // Nothing reached the entity service.
+    assert.strictEqual(ent.calls.length, 0)
+    await seneca.close()
+  })
+
+
+  test('list delegates to the entity service, query included', async (t) => {
+    if (!ENT) {
+      return t.skip('model exposes no entities')
+    }
+    const field = ENT.required[0] || ENT.writable[0]
+    const rows = [
+      Object.assign({ id: 'e01' }, ENT.valid()),
+      Object.assign({ id: 'e02' }, ENT.valid(), field ? { [field]: 'other' } : {}),
+    ]
+    const ent = mockEnt({ [ENT.canon]: rows })
+    const seneca = await makeSeneca(ent.install)
+
+    const all = await as(seneca, ALICE,
+      { aim: 'api', on: 'ent', op: 'list', ent: ENT.canon })
+    assert.strictEqual(all.ok, true)
+    assert.strictEqual(all.items.length, 2)
+    assert.deepStrictEqual(ent.calls[0], { cmd: 'list', ent: ENT.canon, q: {} })
+
+    if (field) {
+      const some = await as(seneca, ALICE, {
+        aim: 'api', on: 'ent', op: 'list', ent: ENT.canon,
+        q: { [field]: 'other' },
+      })
+      assert.strictEqual(some.items.length, 1)
+      assert.strictEqual(some.items[0].id, 'e02')
+    }
+
+    await seneca.close()
+  })
+
+
+  test('load returns the entity, or not-found', async (t) => {
+    if (!ENT) {
+      return t.skip('model exposes no entities')
+    }
+    const ent = mockEnt({ [ENT.canon]: [Object.assign({ id: 'e01' }, ENT.valid())] })
+    const seneca = await makeSeneca(ent.install)
+
+    const got = await as(seneca, ALICE,
+      { aim: 'api', on: 'ent', op: 'load', ent: ENT.canon, id: 'e01' })
+    assert.strictEqual(got.ok, true)
+    assert.strictEqual(got.item.id, 'e01')
+
+    const missing = await as(seneca, ALICE,
+      { aim: 'api', on: 'ent', op: 'load', ent: ENT.canon, id: 'nope' })
+    assert.strictEqual(missing.ok, false)
+    assert.strictEqual(missing.why, 'not-found')
+
+    await seneca.close()
+  })
+
+
+  test('create validates against the generated shape', async (t) => {
+    if (!ENT) {
+      return t.skip('model exposes no entities')
+    }
+    const ent = mockEnt()
+    const seneca = await makeSeneca(ent.install)
+
+    const made = await as(seneca, ALICE, {
+      aim: 'api', on: 'ent', op: 'create', ent: ENT.canon, data: ENT.valid(),
+    })
+    assert.strictEqual(made.ok, true)
+    assert.ok(made.item.id)
+
+    // The shapes are closed: unknown properties are rejected (strict JSON).
+    const extra = await as(seneca, ALICE, {
+      aim: 'api', on: 'ent', op: 'create', ent: ENT.canon,
+      data: Object.assign(ENT.valid(), { definitely_not_a_field: 1 }),
+    })
+    assert.strictEqual(extra.ok, false)
+    assert.strictEqual(extra.why, 'invalid-data')
+    assert.ok(extra.details.some((d: any) => 'closed' === d.what))
+
+    // Server-managed fields are not client-writable either.
+    const managed = await as(seneca, ALICE, {
+      aim: 'api', on: 'ent', op: 'create', ent: ENT.canon,
+      data: Object.assign(ENT.valid(), { owner_id: 'someone-else' }),
+    })
+    assert.strictEqual(managed.ok, false)
+    assert.strictEqual(managed.why, 'invalid-data')
+
+    // A required field left out.
+    if (0 < ENT.required.length) {
+      const bare = await as(seneca, ALICE,
+        { aim: 'api', on: 'ent', op: 'create', ent: ENT.canon, data: {} })
+      assert.strictEqual(bare.ok, false)
+      assert.strictEqual(bare.why, 'invalid-data')
+      assert.ok(bare.details.some((d: any) => 'required' === d.what))
+    }
+
+    // A field of the wrong type.
+    const wrong = ENT.wrongType()
+    if (wrong) {
+      const out = await as(seneca, ALICE,
+        { aim: 'api', on: 'ent', op: 'create', ent: ENT.canon, data: wrong })
+      assert.strictEqual(out.ok, false)
+      assert.strictEqual(out.why, 'invalid-data')
+      assert.ok(out.details.some((d: any) => 'type' === d.what))
+    }
+
+    await seneca.close()
+  })
+
+
+  test('update merges onto the existing entity', async (t) => {
+    if (!ENT) {
+      return t.skip('model exposes no entities')
+    }
+    const field = ENT.writable[0]
+    if (null == field) {
+      return t.skip('entity has no writable fields')
+    }
+
+    const existing = Object.assign({ id: 'e01' }, ENT.valid())
+    const ent = mockEnt({ [ENT.canon]: [existing] })
+    const seneca = await makeSeneca(ent.install)
+
+    const patch = { [field]: ENT.patchValue(field) }
+    const out = await as(seneca, ALICE, {
+      aim: 'api', on: 'ent', op: 'update', ent: ENT.canon, id: 'e01', data: patch,
+    })
+    assert.strictEqual(out.ok, true)
+    assert.strictEqual(out.item.id, 'e01')
+    assert.strictEqual(out.item[field], patch[field])
+
+    // Fields not named in a partial update survive it.
+    for (const other of ENT.required.filter((f: string) => f !== field)) {
+      assert.strictEqual(out.item[other], existing[other], other)
+    }
+
+    const missing = await as(seneca, ALICE, {
+      aim: 'api', on: 'ent', op: 'update', ent: ENT.canon, id: 'nope', data: patch,
+    })
+    assert.strictEqual(missing.ok, false)
+    assert.strictEqual(missing.why, 'not-found')
+
+    await seneca.close()
+  })
+
+
+  test('remove deletes an existing entity only', async (t) => {
+    if (!ENT) {
+      return t.skip('model exposes no entities')
+    }
+    const ent = mockEnt({ [ENT.canon]: [Object.assign({ id: 'e01' }, ENT.valid())] })
+    const seneca = await makeSeneca(ent.install)
+
+    const gone = await as(seneca, ALICE,
+      { aim: 'api', on: 'ent', op: 'remove', ent: ENT.canon, id: 'e01' })
+    assert.strictEqual(gone.ok, true)
+
+    const again = await as(seneca, ALICE,
+      { aim: 'api', on: 'ent', op: 'remove', ent: ENT.canon, id: 'e01' })
+    assert.strictEqual(again.ok, false)
+    assert.strictEqual(again.why, 'not-found')
+
+    await seneca.close()
+  })
+
+
+  test('a failure from the entity service is passed through', async (t) => {
+    if (!ENT) {
+      return t.skip('model exposes no entities')
+    }
+    const seneca = await makeSeneca((s: any) => {
+      s.message('aim:ent,cmd:list', async () => ({ ok: false, why: 'forbidden' }))
+    })
+
+    const out = await as(seneca, ALICE,
+      { aim: 'api', on: 'ent', op: 'list', ent: ENT.canon })
+    assert.strictEqual(out.ok, false)
+    assert.strictEqual(out.why, 'forbidden')
+    await seneca.close()
+  })
+})
+

package/tm/web/backend/test/unit/srv/auth/apikey.test.ts.frag

@@ -0,0 +1,152 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+
+import Crypto from 'node:crypto'
+
+import { makeSeneca, as } from './auth.setup'
+
+
+// API access keys: the raw key is shown once, only its hash is stored,
+// revocation is immediate, and the gateway wrappers act on the SIGNED-IN
+// user rather than a caller-supplied id.
+describe('api keys', () => {
+
+  test('create returns the key once and stores only its hash', async () => {
+    const seneca = await makeSeneca()
+
+    const made = await seneca.post('aim:auth,create:apikey',
+      { user_id: 'u01', name: 'ci' })
+    assert.strictEqual(made.ok, true)
+    assert.ok(made.key.startsWith('vk_'))
+    assert.strictEqual(made.item.name, 'ci')
+    assert.strictEqual(made.item.revoked, false)
+    // The public view never carries the hash.
+    assert.strictEqual((made.item as any).hash, undefined)
+    assert.strictEqual(made.item.prefix, made.key.slice(0, 8))
+
+    // What is stored is the sha-256 of the key, not the key.
+    const stored = await seneca.entity('sys/apikey').load$(made.item.id)
+    const hash = Crypto.createHash('sha256').update(made.key).digest('hex')
+    assert.strictEqual(stored.hash, hash)
+    assert.ok(!JSON.stringify(stored.data$(false)).includes(made.key))
+
+    await seneca.close()
+  })
+
+
+  test('create rejects missing arguments', async () => {
+    const seneca = await makeSeneca()
+
+    const nouser = await seneca.post('aim:auth,create:apikey', { name: 'x' })
+    assert.strictEqual(nouser.ok, false)
+    assert.strictEqual(nouser.why, 'invalid-args')
+
+    const noname = await seneca.post('aim:auth,create:apikey',
+      { user_id: 'u01', name: '  ' })
+    assert.strictEqual(noname.ok, false)
+    assert.strictEqual(noname.why, 'invalid-args')
+
+    await seneca.close()
+  })
+
+
+  test('list returns only that user keys, without hashes', async () => {
+    const seneca = await makeSeneca()
+
+    await seneca.post('aim:auth,create:apikey', { user_id: 'u01', name: 'a' })
+    await seneca.post('aim:auth,create:apikey', { user_id: 'u01', name: 'b' })
+    await seneca.post('aim:auth,create:apikey', { user_id: 'u02', name: 'other' })
+
+    const mine = await seneca.post('aim:auth,list:apikey', { user_id: 'u01' })
+    assert.strictEqual(mine.ok, true)
+    assert.strictEqual(mine.items.length, 2)
+    assert.deepStrictEqual(mine.items.map((k: any) => k.name).sort(), ['a', 'b'])
+    assert.ok(mine.items.every((k: any) => undefined === k.hash))
+
+    const bad = await seneca.post('aim:auth,list:apikey', {})
+    assert.strictEqual(bad.ok, false)
+    assert.strictEqual(bad.why, 'invalid-args')
+
+    await seneca.close()
+  })
+
+
+  test('revoke marks the key revoked, and only for its owner', async () => {
+    const seneca = await makeSeneca()
+
+    const made = await seneca.post('aim:auth,create:apikey',
+      { user_id: 'u01', name: 'ci' })
+
+    // Another user cannot revoke it.
+    const notmine = await seneca.post('aim:auth,revoke:apikey',
+      { user_id: 'u02', id: made.item.id })
+    assert.strictEqual(notmine.ok, false)
+    assert.strictEqual(notmine.why, 'not-found')
+
+    const gone = await seneca.post('aim:auth,revoke:apikey',
+      { user_id: 'u01', id: made.item.id })
+    assert.strictEqual(gone.ok, true)
+    assert.strictEqual(gone.item.revoked, true)
+
+    // The record is kept (audit trail), flagged revoked.
+    const list = await seneca.post('aim:auth,list:apikey', { user_id: 'u01' })
+    assert.strictEqual(list.items.length, 1)
+    assert.strictEqual(list.items[0].revoked, true)
+
+    const missing = await seneca.post('aim:auth,revoke:apikey',
+      { user_id: 'u01', id: 'nope' })
+    assert.strictEqual(missing.ok, false)
+    assert.strictEqual(missing.why, 'not-found')
+
+    const bad = await seneca.post('aim:auth,revoke:apikey', { user_id: 'u01' })
+    assert.strictEqual(bad.ok, false)
+    assert.strictEqual(bad.why, 'invalid-args')
+
+    await seneca.close()
+  })
+
+
+  test('the gateway wrappers use the signed-in user', async () => {
+    const seneca = await makeSeneca()
+
+    // Unauthenticated calls are refused.
+    for (const msg of [
+      { aim: 'web', on: 'auth', create: 'apikey', name: 'x' },
+      { aim: 'web', on: 'auth', list: 'apikey' },
+      { aim: 'web', on: 'auth', revoke: 'apikey', id: 'x' },
+    ]) {
+      const out = await seneca.post(msg)
+      assert.strictEqual(out.ok, false)
+      assert.strictEqual(out.why, 'not-authenticated')
+    }
+
+    const made = await as(seneca, { id: 'u01' },
+      { aim: 'web', on: 'auth', create: 'apikey', name: 'from-web' })
+    assert.strictEqual(made.ok, true)
+
+    // The key belongs to the signed-in user, not anyone named in the msg.
+    const stored = await seneca.entity('sys/apikey').load$(made.item.id)
+    assert.strictEqual(stored.user_id, 'u01')
+
+    const mine = await as(seneca, { id: 'u01' },
+      { aim: 'web', on: 'auth', list: 'apikey' })
+    assert.strictEqual(mine.items.length, 1)
+
+    // Another user sees none of them, and cannot revoke.
+    const others = await as(seneca, { id: 'u02' },
+      { aim: 'web', on: 'auth', list: 'apikey' })
+    assert.strictEqual(others.items.length, 0)
+
+    const denied = await as(seneca, { id: 'u02' },
+      { aim: 'web', on: 'auth', revoke: 'apikey', id: made.item.id })
+    assert.strictEqual(denied.ok, false)
+
+    const revoked = await as(seneca, { id: 'u01' },
+      { aim: 'web', on: 'auth', revoke: 'apikey', id: made.item.id })
+    assert.strictEqual(revoked.ok, true)
+    assert.strictEqual(revoked.item.revoked, true)
+
+    await seneca.close()
+  })
+})
+

package/tm/web/backend/test/unit/srv/auth/auth.setup.ts.frag

@@ -0,0 +1,40 @@
+
+import Seneca from 'seneca'
+
+import Model from '../../../../model/model.json'
+
+// The shared plugin setup (loads @seneca/user etc.) from compiled output.
+const { basic } = require('../../../../dist/env/shared/basic.js')
+
+
+// Seneca with @seneca/user + the auth service (from compiled dist/srv).
+async function makeSeneca() {
+  const seneca = Seneca({ legacy: false, timeout: 2222, debug: { undead: true } })
+  seneca.context.model = Model
+  seneca.context.env = 'test'
+
+  seneca.test()
+  basic(seneca)
+
+  seneca
+    .use('reload')
+    .use('../../../../dist/srv/auth/auth-srv')
+
+  return seneca.ready()
+}
+
+
+// Post a gateway message AS a signed-in user (principal in meta.custom).
+function as(seneca: any, user: any, msg: any) {
+  return seneca.post(Object.assign({}, msg, {
+    custom$: { principal: { user } },
+  }))
+}
+
+
+export {
+  makeSeneca,
+  as,
+  Model,
+}
+