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

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',

package/source/directives/auth/split.ts

@@ -1,5 +1,5 @@
-import * as http from '../../HTTP'
-import { type Scheme } from './types'
+import * as http from '../../HTTP/index.js'
+import { type Scheme } from './types.js'
 
 export function split (authorization: string): [Scheme, string] {
   const space = authorization.indexOf(' ')

package/source/directives/auth/types.ts

@@ -1,8 +1,8 @@
 import { type Component } from '@toa.io/core'
 import { type Maybe } from '@toa.io/types'
-import { type Parameter } from '../../RTD'
-import type * as http from '../../HTTP'
-import type * as io from '../../io'
+import { type Parameter } from '../../RTD/index.js'
+import type * as http from '../../HTTP/index.js'
+import type * as io from '../../io.js'
 
 export interface Directive {
   priority?: number

package/source/directives/cache/Cache.ts

@@ -1,9 +1,9 @@
-import { Control } from './Control'
-import { Exact } from './Exact'
-import type { Output } from '../../io'
-import type { AuthenticatedContext, Directive } from './types'
-import type { DirectiveFamily } from '../../RTD'
-import type * as http from '../../HTTP'
+import { Control } from './Control.js'
+import { Exact } from './Exact.js'
+import type { Output } from '../../io.js'
+import type { AuthenticatedContext, Directive } from './types.js'
+import type { DirectiveFamily } from '../../RTD/index.js'
+import type * as http from '../../HTTP/index.js'
 
 export class Cache implements DirectiveFamily<Directive> {
   public readonly name: string = 'cache'

package/source/directives/cache/Control.ts

@@ -1,5 +1,5 @@
 import { match } from 'matchacho'
-import type { AuthenticatedContext, Directive } from './types'
+import type { AuthenticatedContext, Directive } from './types.js'
 
 export class Control implements Directive {
   protected readonly value: string

package/source/directives/cache/Exact.ts

@@ -1,4 +1,4 @@
-import { Control } from './Control'
+import { Control } from './Control.js'
 
 export class Exact extends Control {
   protected override resolve (): string {

package/source/directives/cache/index.ts

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

package/source/directives/cache/types.ts

@@ -1,4 +1,4 @@
-import type { Input } from '../../io'
+import type { Input } from '../../io.js'
 
 export interface Directive {
   set: (input: Input, headers: Headers) => void

package/source/directives/cors/CORS.ts

@@ -1,5 +1,5 @@
-import type { Input, Output } from '../../io'
-import type { Interceptor } from '../../Interception'
+import type { Input, Output } from '../../io.js'
+import type { Interceptor } from '../../Interception.js'
 
 /** What is allowed before any directive asks for more. */
 const REQUEST_HEADERS = [

package/source/directives/cors/index.ts

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

package/source/directives/dev/Development.ts

@@ -1,10 +1,10 @@
-import { Stub } from './Stub'
-import { Throw } from './Throw'
-import { Sleep } from './Sleep'
-import { Faulty } from './Faulty'
-import { type Directive } from './types'
-import type { Input, Output } from '../../io'
-import type { DirectiveFamily } from '../../RTD'
+import { Stub } from './Stub.js'
+import { Throw } from './Throw.js'
+import { Sleep } from './Sleep.js'
+import { Faulty } from './Faulty.js'
+import { type Directive } from './types.js'
+import type { Input, Output } from '../../io.js'
+import type { DirectiveFamily } from '../../RTD/index.js'
 
 export class Development implements DirectiveFamily<Directive> {
   public readonly name: string = 'dev'

package/source/directives/dev/Faulty.ts

@@ -1,8 +1,8 @@
 import assert from 'node:assert'
-import { ServiceUnavailable } from '../../HTTP'
-import { cors } from '../cors'
-import type { Output } from '../../io'
-import type { Directive } from './types'
+import { ServiceUnavailable } from '../../HTTP/index.js'
+import { cors } from '../cors/index.js'
+import type { Output } from '../../io.js'
+import type { Directive } from './types.js'
 
 export class Faulty implements Directive {
   private static readonly warned = false

package/source/directives/dev/Sleep.ts

@@ -1,10 +1,10 @@
 import assert from 'node:assert'
 import { setTimeout } from 'node:timers/promises'
 import { console } from 'openspan'
-import { cors } from '../cors'
-import { BadRequest } from '../../HTTP'
-import type { Directive } from './types'
-import type { Input, Output } from '../../io'
+import { cors } from '../cors/index.js'
+import { BadRequest } from '../../HTTP/index.js'
+import type { Directive } from './types.js'
+import type { Input, Output } from '../../io.js'
 
 export class Sleep implements Directive {
   private static warned = false
@@ -48,7 +48,7 @@ export class Sleep implements Directive {
         throw new Error()
 
       return pair
-    } catch (error) {
+    } catch {
       throw new BadRequest('Invalid sleep duration value')
     }
   }

package/source/directives/dev/Stub.ts

@@ -1,5 +1,5 @@
-import type { Output } from '../../io'
-import type { Directive } from './types'
+import type { Output } from '../../io.js'
+import type { Directive } from './types.js'
 
 export class Stub implements Directive {
   private readonly value: unknown

package/source/directives/dev/Throw.ts

@@ -1,5 +1,5 @@
-import type { Output } from '../../io'
-import type { Directive } from './types'
+import type { Output } from '../../io.js'
+import type { Directive } from './types.js'
 
 export class Throw implements Directive {
   private readonly message: string

package/source/directives/dev/index.ts

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

package/source/directives/dev/types.ts

@@ -1,4 +1,4 @@
-import type { Input, Output } from '../../io'
+import type { Input, Output } from '../../io.js'
 
 export interface Directive {
   apply: (input: Input) => Promise<Output> | Output

package/source/directives/flow/Compose.ts

@@ -2,9 +2,9 @@ import { once } from 'node:events'
 import * as assert from 'node:assert'
 import { Readable } from 'node:stream'
 import { console } from 'openspan'
-import type { Directive } from './types'
-import type { Input as Context } from '../../io'
-import type { OutgoingMessage } from '../../HTTP'
+import type { Directive } from './types.js'
+import type { Input as Context } from '../../io.js'
+import type { OutgoingMessage } from '../../HTTP/index.js'
 
 export class Compose implements Directive {
   private readonly expressions: Expression[]

package/source/directives/flow/Fetch.ts

@@ -1,15 +1,15 @@
 import { Readable } from 'node:stream'
 import assert from 'node:assert'
 import { match } from 'matchacho'
-import { NotFound } from '../../HTTP'
-import type { Directive } from './types'
+import { NotFound } from '../../HTTP/index.js'
+import type { Directive } from './types.js'
 import type { ReadableStream } from 'node:stream/web'
-import type { Remotes } from '../../Remotes'
+import type { Remotes } from '../../Remotes.js'
 import type { Maybe } from '@toa.io/types'
 import type { Component } from '@toa.io/core'
-import type { Output } from '../../io'
-import type { Input } from '../octets/types'
-import type { Parameter } from '../../RTD'
+import type { Output } from '../../io.js'
+import type { Input } from '../octets/types.js'
+import type { Parameter } from '../../RTD/index.js'
 
 export class Fetch implements Directive {
   private readonly connecting: Promise<Component>

package/source/directives/flow/Flow.ts

@@ -1,9 +1,9 @@
-import { Fetch } from './Fetch'
-import { Compose } from './Compose'
-import type { Directive } from './types'
-import type { Input, Output } from '../../io'
-import type { DirectiveFamily, Parameter } from '../../RTD'
-import type { Remotes } from '../../Remotes'
+import { Fetch } from './Fetch.js'
+import { Compose } from './Compose.js'
+import type { Directive } from './types.js'
+import type { Input, Output } from '../../io.js'
+import type { DirectiveFamily, Parameter } from '../../RTD/index.js'
+import type { Remotes } from '../../Remotes.js'
 
 export class Flow implements DirectiveFamily<Directive> {
   public readonly name: string = 'flow'

package/source/directives/flow/index.ts

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

package/source/directives/flow/types.ts

@@ -1,5 +1,5 @@
-import type { Input as Context, Input, Output } from '../../io'
-import type { Parameter } from '../../RTD'
+import type { Input as Context, Input, Output } from '../../io.js'
+import type { Parameter } from '../../RTD/index.js'
 
 export interface Directive {
   apply?: (input: Input, parameters: Parameter[]) => Promise<Output>

package/source/directives/index.ts

@@ -1,14 +1,14 @@
-import { authorization } from './auth'
-import { cache } from './cache'
-import { cors } from './cors'
-import { dev } from './dev'
-import { octets } from './octets'
-import { io } from './io'
-import { map } from './map'
-import { req } from './require'
-import { flow } from './flow'
-import type { DirectiveFamily } from '../RTD'
-import type { Interceptor } from '../Interception'
+import { authorization } from './auth/index.js'
+import { cache } from './cache/index.js'
+import { cors } from './cors/index.js'
+import { dev } from './dev/index.js'
+import { octets } from './octets/index.js'
+import { io } from './io/index.js'
+import { map } from './map/index.js'
+import { req } from './require/index.js'
+import { flow } from './flow/index.js'
+import type { DirectiveFamily } from '../RTD/index.js'
+import type { Interceptor } from '../Interception.js'
 
 export const families: DirectiveFamily[] = [authorization, io, cache, map, req, flow, octets, dev]
 export const interceptors: Interceptor[] = [cors]

package/source/directives/io/Directive.ts

@@ -1,7 +1,7 @@
-import type { Sync } from './lib/throttle'
-import type { Parameter } from '../../RTD'
-import type { Input as Context } from '../../io'
-import type * as http from '../../HTTP'
+import type { Sync } from './lib/throttle/index.js'
+import type { Parameter } from '../../RTD/index.js'
+import type { Input as Context } from '../../io.js'
+import type * as http from '../../HTTP/index.js'
 
 export interface Directive {
   preflight: (context: Context, parameters: Parameter[]) => void

package/source/directives/io/IO.ts

@@ -1,11 +1,11 @@
-import { Output } from './Output'
-import { Input } from './Input'
-import { Throttle } from './Throttle'
-import { Sync } from './lib/throttle'
-import type * as http from '../../HTTP'
-import type { Parameter, DirectiveFamily } from '../../RTD'
-import type { Remotes } from '../../Remotes'
-import type { Constructor, Directive } from './Directive'
+import { Output } from './Output.js'
+import { Input } from './Input.js'
+import { Throttle } from './Throttle.js'
+import { Sync } from './lib/throttle/index.js'
+import type * as http from '../../HTTP/index.js'
+import type { Parameter, DirectiveFamily } from '../../RTD/index.js'
+import type { Remotes } from '../../Remotes.js'
+import type { Constructor, Directive } from './Directive.js'
 
 export class IO implements DirectiveFamily<Directive> {
   public readonly name = 'io'

package/source/directives/io/Input.ts

@@ -1,8 +1,8 @@
-import { BadRequest } from '../../HTTP'
-import * as schemas from './schemas'
-import type { Message } from './Message'
-import type { Directive } from './Directive'
-import type { Input as Context } from '../../io'
+import { BadRequest } from '../../HTTP/index.js'
+import * as schemas from './schemas.js'
+import type { Message } from './Message.js'
+import type { Directive } from './Directive.js'
+import type { Input as Context } from '../../io.js'
 
 export class Input implements Directive {
   private readonly allowed: Set<string>

package/source/directives/io/Output.ts

@@ -1,10 +1,10 @@
 import { Stream } from 'node:stream'
 import { console } from 'openspan'
-import * as schemas from './schemas'
-import type { Message } from './Message'
-import type { Directive } from './Directive'
-import type { Input as Context } from '../../io'
-import type { OutgoingMessage } from '../../HTTP'
+import * as schemas from './schemas.js'
+import type { Message } from './Message.js'
+import type { Directive } from './Directive.js'
+import type { Input as Context } from '../../io.js'
+import type { OutgoingMessage } from '../../HTTP/index.js'
 
 export class Output implements Directive {
   private readonly disabled: boolean = false

package/source/directives/io/Throttle.ts

@@ -1,9 +1,9 @@
-import { TooManyRequests } from '../../HTTP'
-import * as schemas from './schemas'
-import { parse, Quotas, type Declaration, type Sync } from './lib/throttle'
-import type * as http from '../../HTTP'
-import type { Parameter } from '../../RTD'
-import type { Directive } from './Directive'
+import { TooManyRequests } from '../../HTTP/index.js'
+import * as schemas from './schemas.js'
+import { parse, Quotas, type Declaration, type Sync } from './lib/throttle/index.js'
+import type * as http from '../../HTTP/index.js'
+import type { Parameter } from '../../RTD/index.js'
+import type { Directive } from './Directive.js'
 
 export class Throttle implements Directive {
   private readonly quotas: Quotas

package/source/directives/io/index.ts

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