@toa.io/extensions.exposition 1.0.0-alpha.274 → 1.0.0-alpha.277

package/source/RTD/syntax/parse.test.ts

@@ -1,4 +1,7 @@
-import { parse } from './parse'
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { parse } from './parse.js'
 
 describe('routes', () => {
   it('should parse route', async () => {
@@ -9,9 +12,9 @@ describe('routes', () => {
 
     const node = parse(declaration)
 
-    expect(node.routes).toHaveLength(2)
-    expect(node.routes[0].path).toBe('/')
-    expect(node.routes[1].path).toBe('/foo')
+    assert.strictEqual(node.routes.length, 2)
+    assert.strictEqual(node.routes[0].path, '/')
+    assert.strictEqual(node.routes[1].path, '/foo')
   })
 
   it('should parse nested routes', async () => {
@@ -25,9 +28,9 @@ describe('routes', () => {
     const node = parse(declaration)
     const root = node.routes[0].node
 
-    expect(root.routes).toHaveLength(2)
-    expect(root.routes[0].path).toBe('/foo')
-    expect(root.routes[1].path).toBe('/bar')
+    assert.strictEqual(root.routes.length, 2)
+    assert.strictEqual(root.routes[0].path, '/foo')
+    assert.strictEqual(root.routes[1].path, '/bar')
   })
 })
 
@@ -44,9 +47,9 @@ describe('methods', () => {
     const node = parse(declaration)
     const root = node.routes[0].node
 
-    expect(root.methods).toHaveLength(1)
-    expect(root.methods[0].verb).toBe('GET')
-    expect(root.methods[0].mapping).toMatchObject({ endpoint: 'observe' })
+    assert.strictEqual(root.methods.length, 1)
+    assert.strictEqual(root.methods[0].verb, 'GET')
+    assert.partialDeepStrictEqual(root.methods[0].mapping, { endpoint: 'observe' })
   })
 
   it('should parse endpoint shortcut', async () => {
@@ -59,9 +62,9 @@ describe('methods', () => {
     const node = parse(declaration)
     const root = node.routes[0].node
 
-    expect(root.methods).toHaveLength(1)
-    expect(root.methods[0].verb).toBe('GET')
-    expect(root.methods[0].mapping).toMatchObject({ endpoint: 'observe' })
+    assert.strictEqual(root.methods.length, 1)
+    assert.strictEqual(root.methods[0].verb, 'GET')
+    assert.partialDeepStrictEqual(root.methods[0].mapping, { endpoint: 'observe' })
   })
 
   it('should parse fq endpoint', async () => {
@@ -74,10 +77,10 @@ describe('methods', () => {
     const node = parse(declaration)
     const root = node.routes[0].node
 
-    expect(root.methods).toHaveLength(1)
-    expect(root.methods[0].verb).toBe('GET')
+    assert.strictEqual(root.methods.length, 1)
+    assert.strictEqual(root.methods[0].verb, 'GET')
 
-    expect(root.methods[0].mapping).toMatchObject({
+    assert.partialDeepStrictEqual(root.methods[0].mapping, {
       namespace: 'dummies',
       component: 'dummy',
       endpoint: 'observe'
@@ -94,10 +97,10 @@ describe('methods', () => {
     const node = parse(declaration)
     const root = node.routes[0].node
 
-    expect(root.methods).toHaveLength(1)
-    expect(root.methods[0].verb).toBe('GET')
+    assert.strictEqual(root.methods.length, 1)
+    assert.strictEqual(root.methods[0].verb, 'GET')
 
-    expect(root.methods[0].mapping).toMatchObject({
+    assert.partialDeepStrictEqual(root.methods[0].mapping, {
       namespace: 'default',
       component: 'dummy',
       endpoint: 'observe'
@@ -117,8 +120,7 @@ describe('methods', () => {
     const node = parse(declaration)
     const root = node.routes[0].node
 
-    expect(root.methods[0].directives)
-      .toStrictEqual([{ family: 'auth', name: 'incept', value: 'id' }])
+    assert.deepStrictEqual(root.methods[0].directives, [{ family: 'auth', name: 'incept', value: 'id' }])
   })
 })
 
@@ -137,10 +139,10 @@ describe('directives', () => {
     const node = parse(declaration, shortcuts)
     const root = node.routes[0].node
 
-    expect(root.directives).toHaveLength(1)
-    expect(root.directives[0].family).toBe('dev')
-    expect(root.directives[0].name).toBe('foo')
-    expect(root.directives[0].value).toBe('baz')
+    assert.strictEqual(root.directives.length, 1)
+    assert.strictEqual(root.directives[0].family, 'dev')
+    assert.strictEqual(root.directives[0].name, 'foo')
+    assert.strictEqual(root.directives[0].value, 'baz')
   })
 })
 
@@ -148,7 +150,7 @@ describe('validation', () => {
   it('should throw on unknown key', async () => {
     const declaration = { hello: 'world' }
 
-    expect(() => parse(declaration)).toThrow('RTD parse error: unknown key \'hello\'')
+    assert.throws(() => parse(declaration), (error: any) => /RTD parse error: unknown key 'hello'/.test(error.message))
   })
 
   it('should throw on invalid mapping', async () => {
@@ -161,7 +163,7 @@ describe('validation', () => {
       }
     }
 
-    expect(() => parse(declaration)).toThrow('/methods/0/mapping')
+    assert.throws(() => parse(declaration), (error: any) => /\/methods\/0\/mapping/.test(error.message))
   })
 })
 
@@ -181,7 +183,7 @@ it('should expand ranges', async () => {
   const node = parse(declaration)
   const query = node.routes[0].node.methods[0].mapping?.query
 
-  expect(query).toMatchObject({
+  assert.partialDeepStrictEqual(query, {
     omit: { value: 3, range: [3, 3] },
     limit: { value: 2, range: [2, 2] }
   })

package/source/RTD/syntax/parse.ts

@@ -1,4 +1,4 @@
-import * as schemas from '../../schemas'
+import * as schemas from '../../schemas.js'
 import {
   verbs,
   type Node,
@@ -7,7 +7,7 @@ import {
   type Mapping,
   type Directive,
   type Range
-} from './types'
+} from './types.js'
 
 export function parse (input: object, shortcuts?: Shortcuts): Node {
   const node = parseNode(input, shortcuts)

package/source/Remotes.test.ts

@@ -1,19 +1,23 @@
+import { it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
+
 import { generate } from 'randomstring'
 import { Connector } from '@toa.io/core'
-import { Remotes } from './Remotes'
-import type { Bootloader } from './Factory'
+import { Remotes } from './Remotes.js'
+import type { Bootloader } from './Factory.js'
 import type { Locator, Source } from '@toa.io/core'
 
-jest.mock('@toa.io/boot', () => ({
+mock.module('@toa.io/boot', { namedExports: ({
   remote: async (locator: Locator, source?: Source) => await boot.remote(locator, source)
-}))
+}) })
 
 const boot = {
-  remote: jest.fn(async (..._) => ({
-    connect: jest.fn(() => undefined),
-    link: jest.fn(() => undefined)
+  remote: mock.fn(async () => ({
+    connect: mock.fn(() => undefined),
+    link: mock.fn(() => undefined)
   }))
-} as unknown as jest.MockedObjectDeep<Bootloader>
+} as unknown as Bootloader
 
 const namespace = generate()
 const name = generate()
@@ -27,24 +31,33 @@ beforeEach(() => {
 it('should create remote', async () => {
   const remote = await remotes.discover(namespace, name)
 
-  expect(boot.remote).toHaveBeenCalledWith(expect.objectContaining({ namespace, name }),
-    expect.anything())
+  assert.ok(boot.remote.mock.calls.some((call: any) => call.arguments.length === 2 && isPartial(call.arguments[0], { namespace, name }) && call.arguments[1] !== null && call.arguments[1] !== undefined))
 
-  expect(remote).toStrictEqual(await boot.remote.mock.results[0].value)
+  assert.deepStrictEqual(remote, await boot.remote.mock.calls[0].result)
 })
 
 it('should be instance of Connector', async () => {
-  expect(remotes).toBeInstanceOf(Connector)
+  assert.ok(remotes instanceof Connector)
 })
 
 it('should depend on created remotes', async () => {
   const remote = await remotes.discover(namespace, name)
 
-  expect(remote.link).toHaveBeenCalledWith(remotes)
+  assert.ok(remote.link.mock.calls.some((call: any) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], remotes)))
 })
 
 it('should attribute calls to the gateway', async () => {
   await remotes.discover(namespace, name)
 
-  expect(boot.remote).toHaveBeenCalledWith(expect.anything(), { service: 'exposition' })
+  assert.ok(boot.remote.mock.calls.some((call: any) => call.arguments.length === 2 && call.arguments[0] !== null && call.arguments[0] !== undefined && isDeepStrictEqual(call.arguments[1], { service: 'exposition' })))
 })
+
+function isPartial (actual, expected) {
+  try {
+    assert.partialDeepStrictEqual(actual, expected)
+
+    return true
+  } catch {
+    return false
+  }
+}

package/source/Remotes.ts

@@ -1,5 +1,5 @@
 import { Locator, Connector, type Remote, type Source } from '@toa.io/core'
-import { type Bootloader } from './Factory'
+import { type Bootloader } from './Factory.js'
 
 export class Remotes extends Connector {
   private readonly boot: Bootloader

package/source/Tenant.ts

@@ -1,9 +1,9 @@
 import { setTimeout } from 'node:timers/promises'
 import { Connector } from '@toa.io/core'
-import { BRANCH_TTL } from './const'
+import { BRANCH_TTL } from './const.js'
 import type { bindings } from '@toa.io/core'
-import type { Label } from './discovery'
-import type { Branch } from './Branch'
+import type { Label } from './discovery.js'
+import type { Branch } from './Branch.js'
 
 export class Tenant extends Connector {
   private readonly broadcast: Broadcast

package/source/deployment.ts

@@ -1,11 +1,12 @@
+import { readFileSync } from 'node:fs'
 import assert from 'node:assert'
 import { type Dependency, type Service } from '@toa.io/operations'
-import { type Annotation } from './Annotation'
-import * as schemas from './schemas'
-import { shortcuts } from './Directive'
-import { components } from './Composition'
-import { parse } from './RTD/syntax'
-import { DELAY, PORT } from './HTTP'
+import { type Annotation } from './Annotation.js'
+import * as schemas from './schemas.js'
+import { shortcuts } from './Directive.js'
+import { components } from './Composition.js'
+import { parse } from './RTD/syntax/index.js'
+import { DELAY, PORT, PROBE } from './HTTP/index.js'
 
 export function deployment (_: unknown, annotation?: Annotation): Dependency {
   assert.ok(annotation !== undefined, 'Exposition context annotation is required')
@@ -17,14 +18,14 @@ export function deployment (_: unknown, annotation?: Annotation): Dependency {
     group: 'exposition',
     name: 'gateway',
     port: PORT,
-    version: require('../package.json').version,
+    version: JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version,
     variables: [],
     components: labels,
     resources: annotation.resources,
     ingress: { path: '/', hosts: [] },
     probe: {
       path: '/.ready',
-      port: PORT,
+      port: PROBE,
       delay: DELAY
     }
   }
@@ -49,17 +50,25 @@ export function deployment (_: unknown, annotation?: Annotation): Dependency {
   if (annotation.annotations !== undefined)
     service.ingress!.annotations = annotation.annotations
 
+  if (annotation.service?.annotations !== undefined)
+    service.annotations = annotation.service.annotations
+
   const properties: Properties = { authorities }
 
   if (debug === true)
     properties.debug = true
 
+  if (annotation.protocol !== undefined)
+    properties.protocol = annotation.protocol
+
   service.variables!.push({
     name: 'TOA_EXPOSITION_PROPERTIES',
     value: JSON.stringify(properties)
   })
 
-  // Nested identity composition shares this process; gateway already exposes /.ready.
+  // The identity composition nested in this process connects before route discovery settles,
+  // so telemetry's probe — which tracks that composition — would report ready too early.
+  // The gateway answers for itself, on the same port telemetry would have used.
   service.variables!.push({
     name: 'TOA_TELEMETRY_READY',
     value: JSON.stringify(false)
@@ -68,4 +77,4 @@ export function deployment (_: unknown, annotation?: Annotation): Dependency {
   return { services: [service] }
 }
 
-type Properties = Pick<Annotation, 'authorities' | 'debug'>
+type Properties = Pick<Annotation, 'authorities' | 'debug' | 'protocol'>

package/source/directives/auth/Anonymous.ts

@@ -1,4 +1,4 @@
-import { type Directive, type Context } from './types'
+import { type Directive, type Context } from './types.js'
 
 export class Anonymous implements Directive {
   private readonly allow: boolean

package/source/directives/auth/Anyone.ts

@@ -1,4 +1,4 @@
-import { type Directive, type Context } from './types'
+import { type Directive, type Context } from './types.js'
 
 export class Anyone implements Directive {
   private readonly allow: boolean

package/source/directives/auth/Assert.ts

@@ -1,8 +1,8 @@
 import assert from 'node:assert'
 import { newid } from '@toa.io/generic'
-import * as http from '../../HTTP'
-import { Incept } from './Incept'
-import type { Context, Directive, Identity } from './types'
+import * as http from '../../HTTP/index.js'
+import { Incept } from './Incept.js'
+import type { Context, Directive, Identity } from './types.js'
 
 export class Assert implements Directive {
   private readonly disabled: boolean

package/source/directives/auth/Authorization.ts

@@ -2,25 +2,25 @@ import assert from 'node:assert'
 import { match } from 'matchacho'
 import { console } from 'openspan'
 import { Minimatch } from 'minimatch'
-import * as http from '../../HTTP'
-import { Anonymous } from './Anonymous'
-import { Id } from './Id'
-import { Role } from './Role'
-import { Rule } from './Rule'
-import { Incept } from './Incept'
-import { Assert } from './Assert'
-import { Echo } from './Echo'
-import { Scheme } from './Scheme'
-import { Delegate } from './Delegate'
-import { Federation } from './Federation'
-import { Anyone } from './Anyone'
-import { Input, type Declaration } from './Input'
-import { split } from './split'
-import { PRIMARY, PROVIDERS } from './schemes'
-import type { Output } from '../../io'
+import * as http from '../../HTTP/index.js'
+import { Anonymous } from './Anonymous.js'
+import { Id } from './Id.js'
+import { Role } from './Role.js'
+import { Rule } from './Rule.js'
+import { Incept } from './Incept.js'
+import { Assert } from './Assert.js'
+import { Echo } from './Echo.js'
+import { Scheme } from './Scheme.js'
+import { Delegate } from './Delegate.js'
+import { Federation } from './Federation.js'
+import { Anyone } from './Anyone.js'
+import { Input, type Declaration } from './Input.js'
+import { split } from './split.js'
+import { PRIMARY, PROVIDERS } from './schemes.js'
+import type { Output } from '../../io.js'
 import type { Component } from '@toa.io/core'
-import type { Remotes } from '../../Remotes'
-import type { Parameter, DirectiveFamily } from '../../RTD'
+import type { Remotes } from '../../Remotes.js'
+import type { Parameter, DirectiveFamily } from '../../RTD/index.js'
 import type {
   AuthenticationResult,
   Ban,
@@ -31,7 +31,7 @@ import type {
   Context,
   Remote,
   Schemes
-} from './types'
+} from './types.js'
 
 export class Authorization implements DirectiveFamily<Directive, Extension> {
   public readonly depends: string[] = ['Vary']

package/source/directives/auth/Delegate.ts

@@ -1,6 +1,6 @@
-import { BadRequest } from '../../HTTP'
-import { Role } from './Role'
-import type { Context, Directive, Identity } from './types'
+import { BadRequest } from '../../HTTP/index.js'
+import { Role } from './Role.js'
+import type { Context, Directive, Identity } from './types.js'
 import type { Component } from '@toa.io/core'
 
 export class Delegate implements Directive {

package/source/directives/auth/Echo.ts

@@ -1,6 +1,6 @@
-import { create } from './create'
-import type { OutgoingMessage } from '../../HTTP'
-import type { Directive, Identity, Context } from './types'
+import { create } from './create.js'
+import type { OutgoingMessage } from '../../HTTP/index.js'
+import type { Directive, Identity, Context } from './types.js'
 
 export class Echo implements Directive {
   public authorize (identity: Identity | null, context: Context): boolean {

package/source/directives/auth/Federation.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert'
-import type { Directive, Identity, Context } from './types'
-import type { Parameter } from '../../RTD'
+import type { Directive, Identity, Context } from './types.js'
+import type { Parameter } from '../../RTD/index.js'
 
 export class Federation implements Directive {
   private readonly matchers: Array<[keyof Claims, Matcher]>

package/source/directives/auth/Id.ts

@@ -1,5 +1,5 @@
-import { type Parameter } from '../../RTD'
-import { type Directive, type Identity } from './types'
+import { type Parameter } from '../../RTD/index.js'
+import { type Directive, type Identity } from './types.js'
 
 export class Id implements Directive {
   private readonly parameter: string

package/source/directives/auth/Incept.ts

@@ -1,13 +1,13 @@
 import assert from 'node:assert'
 import { console } from 'openspan'
-import * as http from '../../HTTP'
-import { split } from './split'
-import { create } from './create'
-import { PROVIDERS, INCEPTION } from './schemes'
-import { Role } from './Role'
+import * as http from '../../HTTP/index.js'
+import { split } from './split.js'
+import { create } from './create.js'
+import { PROVIDERS, INCEPTION } from './schemes.js'
+import { Role } from './Role.js'
 import type { Component } from '@toa.io/core'
 import type { Maybe } from '@toa.io/types'
-import type { Directive, Discovery, Identity, Context, Schemes, Ban } from './types'
+import type { Directive, Discovery, Identity, Context, Schemes, Ban } from './types.js'
 
 export class Incept implements Directive {
   private static readonly schemes: Schemes = {} as unknown as Schemes

package/source/directives/auth/Input.ts

@@ -1,6 +1,6 @@
-import { Forbidden } from '../../HTTP'
-import type { Parameter } from '../../RTD'
-import type { Context, Directive, Identity, Create } from './types'
+import { Forbidden } from '../../HTTP/index.js'
+import type { Parameter } from '../../RTD/index.js'
+import type { Context, Directive, Identity, Create } from './types.js'
 
 export class Input implements Directive {
   public priority = 0

package/source/directives/auth/Role.test.ts

@@ -1,17 +1,21 @@
+import { it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
+
 import { type Component } from '@toa.io/core'
 import { generate } from 'randomstring'
-import { Role } from './Role'
-import { type Identity } from './types'
-import type { Parameter } from '../../RTD'
+import { Role } from './Role.js'
+import { type Identity } from './types.js'
+import type { Parameter } from '../../RTD/index.js'
 
 const remote = {
-  invoke: jest.fn()
-} as unknown as jest.MockedObject<Component>
+  invoke: mock.fn()
+} as unknown as Component
 
 const discovery = Promise.resolve(remote)
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 })
 
 it('should return false if not matched', async () => {
@@ -24,43 +28,42 @@ it('should return false if not matched', async () => {
     refresh: false
   }
 
-  remote.invoke.mockResolvedValueOnce(['guest'])
+  remote.invoke.mock.mockImplementationOnce(async () => ['guest'])
 
   const result = await directive.authorize(identity, undefined, [])
 
-  expect(result).toBe(false)
+  assert.strictEqual(result, false)
 
-  expect(remote.invoke)
-    .toHaveBeenCalledWith('list', {
+  assert.ok(remote.invoke.mock.calls.some((call: any) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], 'list') && isDeepStrictEqual(call.arguments[1], {
       query: {
         criteria: `identity==${identity.id}`,
         limit: 1024
       }
-    })
+    })))
 })
 
 it('should return true on exact match', async () => {
   const result = await match(['admin', 'user'], ['user'])
 
-  expect(result).toBe(true)
+  assert.strictEqual(result, true)
 })
 
 it('should return true on scope match', async () => {
   const result = await match(['system:identity:roles'], ['system'])
 
-  expect(result).toBe(true)
+  assert.strictEqual(result, true)
 })
 
 it('should return false on scope mismatch', async () => {
   const result = await match(['system:identity'], ['system:identity:roles'])
 
-  expect(result).toBe(false)
+  assert.strictEqual(result, false)
 })
 
 it('should return false on non-scope substring match', async () => {
   const result = await match(['system:identity'], ['system:iden'])
 
-  expect(result).toBe(false)
+  assert.strictEqual(result, false)
 })
 
 it('should return true on match with parameters', async () => {
@@ -70,7 +73,7 @@ it('should return true on match with parameters', async () => {
       value: '29e54ae1'
     }])
 
-  expect(result).toBe(true)
+  assert.strictEqual(result, true)
 })
 
 it('should return true on match with parameters', async () => {
@@ -80,7 +83,7 @@ it('should return true on match with parameters', async () => {
       value: '29e54ae1'
     }])
 
-  expect(result).toBe(true)
+  assert.strictEqual(result, true)
 })
 
 it('should return false on mismatch with parameters', async () => {
@@ -90,7 +93,7 @@ it('should return false on mismatch with parameters', async () => {
       value: '88584c9b'
     }])
 
-  expect(result).toBe(false)
+  assert.strictEqual(result, false)
 })
 
 async function match (expected: string[], actual: string[], parameters: Parameter[] = []): Promise<boolean> {
@@ -102,7 +105,17 @@ async function match (expected: string[], actual: string[], parameters: Paramete
     refresh: false
   }
 
-  remote.invoke.mockResolvedValueOnce(actual)
+  remote.invoke.mock.mockImplementationOnce(async () => actual)
 
   return await directive.authorize(identity, undefined, parameters)
 }
+
+function resetCalls (target = [remote, discovery], seen = new Set()) {
+  if (target === null || typeof target !== 'object' || seen.has(target)) return
+
+  seen.add(target)
+
+  for (const value of Object.values(target))
+    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
+    else resetCalls(value, seen)
+}

package/source/directives/auth/Role.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert'
 import { type Component, type Query } from '@toa.io/core'
-import { type Directive, type Identity } from './types'
-import type { Parameter } from '../../RTD'
+import { type Directive, type Identity } from './types.js'
+import type { Parameter } from '../../RTD/index.js'
 
 export class Role implements Directive {
   public static remote: Component | null = null

package/source/directives/auth/Rule.ts

@@ -1,5 +1,5 @@
-import { type Parameter } from '../../RTD'
-import type { Context, Directive, Identity, Create } from './types'
+import { type Parameter } from '../../RTD/index.js'
+import type { Context, Directive, Identity, Create } from './types.js'
 
 export class Rule implements Directive {
   private readonly directives: Directive[] = []

package/source/directives/auth/Scheme.ts

@@ -1,6 +1,6 @@
-import * as http from '../../HTTP'
-import { type Directive, type Identity, type Context } from './types'
-import { split } from './split'
+import * as http from '../../HTTP/index.js'
+import { type Directive, type Identity, type Context } from './types.js'
+import { split } from './split.js'
 
 export class Scheme implements Directive {
   private readonly scheme: string

package/source/directives/auth/create.ts

@@ -1,5 +1,5 @@
 import { newid } from '@toa.io/generic'
-import type { Identity } from './types'
+import type { Identity } from './types.js'
 
 export function create (credentials?: string): Identity {
   return {

package/source/directives/auth/index.ts

@@ -1,3 +1,3 @@
-import { Authorization } from './Authorization'
+import { Authorization } from './Authorization.js'
 
 export const authorization = new Authorization()

package/source/directives/auth/schemes.ts

@@ -1,4 +1,4 @@
-import type { Remote, Scheme } from './types'
+import type { Remote, Scheme } from './types.js'
 
 export const PROVIDERS: Record<Scheme, Remote> = {
   basic: 'basic',