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

package/source/Query.ts

@@ -1,10 +1,10 @@
 import assert from 'node:assert'
-import * as http from './HTTP'
-import { type Parameter } from './RTD'
-import * as schemas from './schemas'
-import { queryable } from './Mapping'
-import type { Introspection, Schema } from './Introspection'
-import type * as syntax from './RTD/syntax'
+import * as http from './HTTP/index.js'
+import { type Parameter } from './RTD/index.js'
+import * as schemas from './schemas.js'
+import { queryable } from './Mapping.js'
+import type { Introspection, Schema } from './Introspection.js'
+import type * as syntax from './RTD/syntax/index.js'
 import type * as core from '@toa.io/core'
 
 export class Query {

package/source/RTD/Context.ts

@@ -1,6 +1,6 @@
-import { type DirectiveFactory } from './Directives'
-import { type EndpointsFactory } from './Endpoint'
-import type { Directive } from './syntax'
+import { type DirectiveFactory } from './Directives.js'
+import { type EndpointsFactory } from './Endpoint.js'
+import type { Directive } from './syntax/index.js'
 
 export interface Context<TExtension = any> {
   readonly protected: boolean

package/source/RTD/Directives.ts

@@ -1,7 +1,7 @@
-import type { Parameter } from './Match'
-import type * as syntax from './syntax'
-import type { Context, OutgoingMessage } from '../HTTP'
-import type { Output } from '../io'
+import type { Parameter } from './Match.js'
+import type * as syntax from './syntax/index.js'
+import type { Context, OutgoingMessage } from '../HTTP/index.js'
+import type { Output } from '../io.js'
 
 export interface Directives {
   preflight: (context: Context, parameters: Parameter[]) => Promise<Output>

package/source/RTD/Endpoint.ts

@@ -1,7 +1,7 @@
-import { type Context } from './Context'
-import type * as http from '../HTTP'
-import type * as syntax from './syntax'
-import type * as RTD from './index'
+import { type Context } from './Context.js'
+import type * as http from '../HTTP/index.js'
+import type * as syntax from './syntax/index.js'
+import type * as RTD from './index.js'
 
 export interface Endpoint {
   call: (context: http.Context, parameters: RTD.Parameter[]) => Promise<http.OutgoingMessage>

package/source/RTD/Match.ts

@@ -1,4 +1,4 @@
-import { type Node } from './Node'
+import { type Node } from './Node.js'
 
 export interface Match {
   node: Node

package/source/RTD/Method.ts

@@ -1,6 +1,6 @@
-import type { Parameter } from './Match'
-import type { Endpoint } from './Endpoint'
-import type { Directives } from './Directives'
+import type { Parameter } from './Match.js'
+import type { Endpoint } from './Endpoint.js'
+import type { Directives } from './Directives.js'
 
 export class Method {
   public readonly endpoint: Endpoint | null

package/source/RTD/Node.ts

@@ -1,6 +1,6 @@
-import { type Route } from './Route'
-import { type Methods } from './Method'
-import { type Match, type Parameter } from './Match'
+import { type Route } from './Route.js'
+import { type Methods } from './Method.js'
+import { type Match, type Parameter } from './Match.js'
 
 export class Node {
   public intermediate: boolean

package/source/RTD/Route.ts

@@ -1,6 +1,6 @@
-import { type Segment } from './segment'
-import { type Match, type Parameter } from './Match'
-import type { Node } from './Node'
+import { type Segment } from './segment.js'
+import { type Match, type Parameter } from './Match.js'
+import type { Node } from './Node.js'
 
 export class Route {
   public readonly root: boolean

package/source/RTD/Tree.ts

@@ -1,11 +1,11 @@
-import { branchTTL, createNode } from './factory'
-import { fragment } from './segment'
-import type { Node } from './Node'
-import type { Match } from './Match'
-import type { Context } from './Context'
-import type { DirectiveFactory } from './Directives'
-import type { EndpointsFactory } from './Endpoint'
-import type * as syntax from './syntax'
+import { branchTTL, createNode } from './factory.js'
+import { fragment } from './segment.js'
+import type { Node } from './Node.js'
+import type { Match } from './Match.js'
+import type { Context } from './Context.js'
+import type { DirectiveFactory } from './Directives.js'
+import type { EndpointsFactory } from './Endpoint.js'
+import type * as syntax from './syntax/index.js'
 
 export class Tree {
   private readonly root: syntax.Node

package/source/RTD/expiration.test.ts

@@ -1,7 +1,10 @@
-import { Tree } from './Tree'
-import type { EndpointsFactory } from '../Endpoint'
-import type { DirectiveFactory } from './Directives'
-import type * as syntax from './syntax'
+import { it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Tree } from './Tree.js'
+import type { EndpointsFactory } from '../Endpoint.js'
+import type { DirectiveFactory } from './Directives.js'
+import type * as syntax from './syntax/index.js'
 
 const endpoints = {} as unknown as EndpointsFactory
 
@@ -11,7 +14,7 @@ const directives = {
     settle: async () => undefined,
     dispose: () => undefined
   }),
-  dispose: jest.fn()
+  dispose: mock.fn()
 } as unknown as DirectiveFactory
 
 const root: syntax.Node = {
@@ -38,41 +41,41 @@ const pots: syntax.Node = {
 it('should extend expiration without rebuilding the branch', () => {
   process.env.__TESTING_EXPOSITION_BRANCH_TTL = '1000'
 
-  const now = jest.spyOn(Date, 'now').mockReturnValue(10_000)
+  const now = mock.method(Date, 'now', () => 10_000)
   const tree = new Tree(root, endpoints, directives)
   const nodes = tree.merge(pots, { namespace: 'default', component: 'pots' })
   const match = tree.match('/pots/')
 
-  expect(match).not.toBeNull()
+  assert.notStrictEqual(match, null)
 
-  now.mockReturnValue(10_900)
+  now.mock.mockImplementation(() => 10_900)
   tree.refresh(nodes)
 
-  now.mockReturnValue(11_500)
+  now.mock.mockImplementation(() => 11_500)
 
   const refreshed = tree.match('/pots/')
 
-  expect(refreshed).not.toBeNull()
-  expect(refreshed?.node).toBe(match?.node)
+  assert.notStrictEqual(refreshed, null)
+  assert.strictEqual(refreshed?.node, match?.node)
 
-  now.mockRestore()
+  now.mock.restore()
   delete process.env.__TESTING_EXPOSITION_BRANCH_TTL
 })
 
 it('should ignore expired nodes during match', () => {
   process.env.__TESTING_EXPOSITION_BRANCH_TTL = '1000'
 
-  const now = jest.spyOn(Date, 'now').mockReturnValue(10_000)
+  const now = mock.method(Date, 'now', () => 10_000)
   const tree = new Tree(root, endpoints, directives)
 
   tree.merge(pots, { namespace: 'default', component: 'pots' })
 
-  expect(tree.match('/pots/')).not.toBeNull()
+  assert.notStrictEqual(tree.match('/pots/'), null)
 
-  now.mockReturnValue(11_000)
+  now.mock.mockImplementation(() => 11_000)
 
-  expect(tree.match('/pots/')).toBeNull()
+  assert.strictEqual(tree.match('/pots/'), null)
 
-  now.mockRestore()
+  now.mock.restore()
   delete process.env.__TESTING_EXPOSITION_BRANCH_TTL
 })

package/source/RTD/factory.ts

@@ -1,10 +1,10 @@
-import { BRANCH_TTL } from '../const'
-import { Node, type Properties } from './Node'
-import { Route } from './Route'
-import { segment } from './segment'
-import { Method, type Methods } from './Method'
-import type { Context } from './Context'
-import type * as syntax from './syntax'
+import { BRANCH_TTL } from '../const.js'
+import { Node, type Properties } from './Node.js'
+import { Route } from './Route.js'
+import { segment } from './segment.js'
+import { Method, type Methods } from './Method.js'
+import type { Context } from './Context.js'
+import type * as syntax from './syntax/index.js'
 
 export function createNode (node: syntax.Node, context: Context): Node {
   if (node.isolated === true)

package/source/RTD/index.ts

@@ -1,8 +1,8 @@
-export * from './Tree'
-export * from './Node'
-export * from './Match'
-export * from './Method'
-export * from './Context'
-export * from './Endpoint'
-export * from './Directives'
-export * as syntax from './syntax'
+export * from './Tree.js'
+export * from './Node.js'
+export * from './Match.js'
+export * from './Method.js'
+export * from './Context.js'
+export * from './Endpoint.js'
+export * from './Directives.js'
+export * as syntax from './syntax/index.js'

package/source/RTD/segment.test.ts

@@ -1,32 +1,35 @@
-import { segment, fragment } from './segment'
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { segment, fragment } from './segment.js'
 
 it('should return segments', async () => {
   const segments = segment('/foo/bar/')
 
-  expect(segments).toHaveLength(2)
-  expect(segments[0].fragment).toBe('foo')
-  expect(segments[1].fragment).toBe('bar')
+  assert.strictEqual(segments.length, 2)
+  assert.strictEqual(segments[0].fragment, 'foo')
+  assert.strictEqual(segments[1].fragment, 'bar')
 })
 
 it('should parse placeholders', async () => {
   const segments = segment('/foo/:id/')
 
-  expect(segments).toHaveLength(2)
-  expect(segments[0].fragment).toBe('foo')
-  expect(segments[1].fragment).toBeNull()
+  assert.strictEqual(segments.length, 2)
+  assert.strictEqual(segments[0].fragment, 'foo')
+  assert.strictEqual(segments[1].fragment, null)
 
   // helping typescript
   if (segments[1].fragment !== null) throw new Error('?')
 
-  expect(segments[1].placeholder).toBe('id')
+  assert.strictEqual(segments[1].placeholder, 'id')
 })
 
 it('should handle root path', async () => {
-  expect(segment('/')).toStrictEqual([])
+  assert.deepStrictEqual(segment('/'), [])
 })
 
 it('should split', async () => {
   const parts = fragment('/foo/bar/')
 
-  expect(parts).toStrictEqual(['foo', 'bar'])
+  assert.deepStrictEqual(parts, ['foo', 'bar'])
 })

package/source/RTD/syntax/index.ts

@@ -1,2 +1,2 @@
-export * from './parse'
-export * from './types'
+export * from './parse.js'
+export * from './types.js'

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, PROBE } 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,7 +18,7 @@ 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,

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