@voxgig/build 4.4.0 → 4.11.0

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,
+}
+

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

@@ -0,0 +1,189 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+
+import { makeSeneca, as } from './auth.setup'
+
+
+// Sign-in / sign-out / session load, and the gateway wrappers that turn
+// them into cookie operations for the SPA.
+describe('auth session', () => {
+
+  async function withUser() {
+    const seneca = await makeSeneca()
+    const reg = await seneca.post('sys:user,register:user',
+      { name: 'Alice', email: 'alice@ex.com', password: 'alice-pass-01' })
+    assert.strictEqual(reg.ok, true)
+    return { seneca, user: reg.user }
+  }
+
+
+  test('signin succeeds with the right password and fails otherwise', async () => {
+    const { seneca } = await withUser()
+
+    const ok = await seneca.post('aim:auth,signin:user',
+      { email: 'alice@ex.com', password: 'alice-pass-01' })
+    assert.strictEqual(ok.ok, true)
+    assert.strictEqual(ok.user.email, 'alice@ex.com')
+
+    // aim:auth messages are gateway-reachable, so the result must never
+    // carry credentials: @seneca/user answers with the whole entity
+    // (password hash + salt) and its `fields` option does not stop it.
+    assert.strictEqual(ok.user.pass, undefined)
+    assert.strictEqual(ok.user.salt, undefined)
+    assert.deepStrictEqual(Object.keys(ok.user).sort(),
+      ['email', 'handle', 'id', 'name'])
+
+    const bad = await seneca.post('aim:auth,signin:user',
+      { email: 'alice@ex.com', password: 'wrong' })
+    assert.strictEqual(bad.ok, false)
+
+    await seneca.close()
+  })
+
+
+  test('the gateway wrapper returns a cookie token on success', async () => {
+    const { seneca } = await withUser()
+
+    const out = await seneca.post(
+      { aim: 'web', on: 'auth', signin: 'user', email: 'alice@ex.com', password: 'alice-pass-01' })
+    assert.strictEqual(out.ok, true)
+    // gateway-auth (express_cookie) sets the cookie from this field.
+    assert.ok(out.gateway$.auth.token)
+    assert.strictEqual(out.user.email, 'alice@ex.com')
+    assert.strictEqual(out.user.pass, undefined)
+
+    const bad = await seneca.post(
+      { aim: 'web', on: 'auth', signin: 'user', email: 'alice@ex.com', password: 'wrong' })
+    assert.strictEqual(bad.ok, false)
+    assert.strictEqual(bad.gateway$, undefined)
+    assert.ok(bad.why)
+
+    await seneca.close()
+  })
+
+
+  test('signout revokes the login server-side', async () => {
+    const { seneca, user } = await withUser()
+
+    const login = await seneca.post('aim:auth,signin:user',
+      { email: 'alice@ex.com', password: 'alice-pass-01' })
+    const token = login.login.token
+    assert.ok(token)
+
+    const before = await seneca.entity('sys/login').list$({ token })
+    assert.strictEqual(before[0].active, true)
+
+    const out = await seneca.post('aim:auth,signout:user',
+      { user_id: user.id, token })
+    assert.strictEqual(out.ok, true)
+
+    // The session must really be revoked: a token alone does not do it
+    // (@seneca/user answers no-user-query and leaves the row active), so
+    // the user id has to travel with it.
+    const after = await seneca.entity('sys/login').list$({ token })
+    assert.strictEqual(after[0].active, false)
+
+    await seneca.close()
+  })
+
+
+  test('the signout wrapper revokes the session and clears the cookie', async () => {
+    const { seneca, user } = await withUser()
+
+    const login = await seneca.post('aim:auth,signin:user',
+      { email: 'alice@ex.com', password: 'alice-pass-01' })
+    const token = login.login.token
+
+    // The gateway principal carries both the user and the login token.
+    const out = await seneca.post({
+      aim: 'web', on: 'auth', signout: 'user',
+      custom$: { principal: { user, token } },
+    })
+    assert.strictEqual(out.ok, true)
+    // Tells gateway-auth to clear the cookie.
+    assert.strictEqual(out.gateway$.auth.remove, true)
+
+    const after = await seneca.entity('sys/login').list$({ token })
+    assert.strictEqual(after[0].active, false)
+
+    // Signing out with no principal at all is still a clean no-op.
+    const anon = await seneca.post({ aim: 'web', on: 'auth', signout: 'user' })
+    assert.strictEqual(anon.ok, true)
+
+    await seneca.close()
+  })
+
+
+  test('load:auth reports the signed-in user, or nobody', async () => {
+    const { seneca, user } = await withUser()
+
+    const anon = await seneca.post({ aim: 'web', on: 'auth', load: 'auth' })
+    assert.strictEqual(anon.ok, true)
+    assert.strictEqual(anon.user, undefined)
+
+    const signed = await as(seneca, user, { aim: 'web', on: 'auth', load: 'auth' })
+    assert.strictEqual(signed.ok, true)
+    assert.strictEqual(signed.user.email, 'alice@ex.com')
+    assert.strictEqual(signed.user.pass, undefined)
+
+    // The service message behind it must not leak credentials either.
+    const direct = await seneca.post('aim:auth,load:auth', { user_id: user.id })
+    assert.strictEqual(direct.ok, true)
+    assert.strictEqual(direct.state, 'signedin')
+    assert.strictEqual(direct.user.pass, undefined)
+    assert.strictEqual(direct.user.salt, undefined)
+
+    const gone = await seneca.post('aim:auth,load:auth', { user_id: 'nope' })
+    assert.strictEqual(gone.ok, false)
+    assert.strictEqual(gone.state, 'signedout')
+
+    await seneca.close()
+  })
+
+
+  test('update:user changes the profile of the signed-in user only', async () => {
+    const { seneca, user } = await withUser()
+
+    const out = await as(seneca, user,
+      { aim: 'web', on: 'auth', update: 'user', data: { name: 'Alicia' } })
+    assert.strictEqual(out.ok, true)
+
+    const check = await seneca.post('sys:user,get:user', { email: 'alice@ex.com' })
+    assert.strictEqual(check.user.name, 'Alicia')
+
+    const anon = await seneca.post(
+      { aim: 'web', on: 'auth', update: 'user', data: { name: 'Mallory' } })
+    assert.strictEqual(anon.ok, false)
+    assert.strictEqual(anon.why, 'not-authenticated')
+
+    await seneca.close()
+  })
+
+
+  test('remind:pass never reveals whether the account exists', async () => {
+    const { seneca } = await withUser()
+
+    const known = await seneca.post(
+      { aim: 'web', on: 'auth', remind: 'pass', email: 'alice@ex.com' })
+    const unknown = await seneca.post(
+      { aim: 'web', on: 'auth', remind: 'pass', email: 'nobody@ex.com' })
+
+    // Same answer either way (no user enumeration), and nothing is sent.
+    assert.strictEqual(known.ok, true)
+    assert.strictEqual(unknown.ok, true)
+    assert.strictEqual(known.user, undefined)
+    assert.strictEqual(unknown.user, undefined)
+
+    await seneca.close()
+  })
+
+
+  test('get:info reports the service', async () => {
+    const seneca = await makeSeneca()
+    const out = await seneca.post('aim:auth,get:info')
+    assert.strictEqual(out.ok, true)
+    assert.strictEqual(out.srv, 'auth')
+    await seneca.close()
+  })
+})
+

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

@@ -0,0 +1,53 @@
+
+import Seneca from 'seneca'
+
+import { entity } from '@voxgig/util'
+
+import Model from '../../../../model/model.json'
+
+const { base } = require('../../../../dist/env/shared/basic')
+
+
+// Build a Seneca instance with the generic entity service loaded from the
+// compiled dist/srv. In-memory entity store, no external deps.
+//
+// @seneca/owner is loaded with the SAME options as the running app (from
+// `base`): access control is enforced in the entity layer, so a test
+// harness without it would exercise a system that cannot deny anything.
+async function makeSeneca() {
+  const seneca = Seneca({ legacy: false, timeout: 2222, debug: { undead: true } })
+  seneca.context.model = Model
+  seneca.context.env = 'test'
+
+  return seneca
+    .test()
+    .use('promisify')
+    .use('entity', {
+      strict: true,
+      ent: entity(Model),
+    })
+    .use('entity-util', {
+      when: { active: true },
+    })
+    .use('owner', base.options.owner)
+    .use('reload')
+    .use('../../../../dist/srv/ent/ent-srv')
+    .ready()
+}
+
+
+// Post a message AS a given user, injecting the gateway-style principal into
+// meta.custom (mirrors what @seneca/gateway-auth attaches from the cookie).
+function as(seneca: any, user: any, msg: any) {
+  return seneca.post(Object.assign({}, msg, {
+    custom$: { principal: { user } },
+  }))
+}
+
+
+export {
+  makeSeneca,
+  as,
+  Model,
+}
+