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

package/source/Branch.ts

@@ -1,5 +1,5 @@
-import type * as RTD from './RTD/syntax'
-import type { Node } from './RTD'
+import type * as RTD from './RTD/syntax/index.js'
+import type { Node } from './RTD/index.js'
 
 export interface Branch {
   namespace: string

package/source/Composition.ts

@@ -1,7 +1,7 @@
 import { readdirSync, type Dirent } from 'node:fs'
 import { resolve } from 'node:path'
 import { Connector } from '@toa.io/core'
-import { type Bootloader } from './Factory'
+import { type Bootloader } from './Factory.js'
 
 export class Composition extends Connector {
   private readonly boot: Bootloader
@@ -48,4 +48,4 @@ interface Components {
   paths: string[]
 }
 
-const ROOT = resolve(__dirname, '../components/')
+const ROOT = resolve(import.meta.dirname, '../components/')

package/source/Context.ts

@@ -1,4 +1,4 @@
-import type * as RTD from './RTD'
+import type * as RTD from './RTD/index.js'
 
 // the trunk is built from the context annotation and belongs to no branch,
 // thus its endpoints must be fully qualified and are not versioned

package/source/Directive.test.ts

@@ -1,49 +1,54 @@
-import assert from 'node:assert'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
 import { generate } from 'randomstring'
-import { DirectivesFactory } from './Directive'
-import type { syntax, DirectiveFamily } from './RTD'
-import type { Remotes } from './Remotes'
-import type { Context } from './HTTP'
+import { DirectivesFactory } from './Directive.js'
+import type { syntax, DirectiveFamily } from './RTD/index.js'
+import type { Remotes } from './Remotes.js'
+import type { Context } from './HTTP/index.js'
+
+const sequence: string[] = []
 
-const families: Array<jest.MockedObjectDeep<DirectiveFamily>> = [
+const families: Array<DirectiveFamily> = [
   {
     name: 'foo',
     mandatory: true,
-    create: jest.fn((_0: any, _1: any, _2: any) => generate() as any),
-    arrange: jest.fn(),
-    preflight: jest.fn(),
-    settle: jest.fn(),
-    dispose: jest.fn()
+    create: mock.fn((_0: any, _1: any, _2: any) => generate() as any),
+    arrange: mock.fn(),
+    preflight: mock.fn(() => { sequence.push('foo'); return null }),
+    settle: mock.fn(),
+    dispose: mock.fn()
   },
   {
     name: 'qux',
     mandatory: true,
-    create: jest.fn((_0: any, _1: any, _2: any) => generate() as any),
-    arrange: jest.fn(),
-    preflight: jest.fn(),
-    settle: jest.fn(),
-    dispose: jest.fn()
+    create: mock.fn((_0: any, _1: any, _2: any) => generate() as any),
+    arrange: mock.fn(),
+    preflight: mock.fn(() => { sequence.push('qux'); return null }),
+    settle: mock.fn(),
+    dispose: mock.fn()
   },
   {
     name: 'bar',
     mandatory: false,
-    create: jest.fn((_0: string, _1: any, _2: any) => generate() as any),
-    arrange: jest.fn(),
-    preflight: jest.fn(),
-    settle: jest.fn(),
-    dispose: jest.fn()
+    create: mock.fn((_0: string, _1: any, _2: any) => generate() as any),
+    arrange: mock.fn(),
+    preflight: mock.fn(() => { sequence.push('bar'); return null }),
+    settle: mock.fn(),
+    dispose: mock.fn()
   }
 ]
 
 let factory: DirectivesFactory
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  sequence.length = 0
 
   for (const family of families) {
     assert.ok(family.preflight !== undefined)
 
-    family.preflight.mockImplementation(() => null)
+    family.preflight.mock.mockImplementation(() => { sequence.push(family.name); return null })
   }
 
   factory = new DirectivesFactory(families, {} as unknown as Remotes)
@@ -68,8 +73,8 @@ it('should create directive', async () => {
   for (const declaration of declarations) {
     const family = families.find(({ name }) => name === declaration.family)!
 
-    expect(family.create.mock.calls[0][0]).toBe(declaration.name)
-    expect(family.create.mock.calls[0][1]).toBe(declaration.value)
+    assert.strictEqual(family.create.mock.calls[0].arguments[0], declaration.name)
+    assert.strictEqual(family.create.mock.calls[0].arguments[1], declaration.value)
   }
 })
 
@@ -78,7 +83,7 @@ it('should pass the route to the families', async () => {
 
   factory.create([{ family: 'foo', name: generate(), value: generate() }], route)
 
-  expect(families[0].create.mock.calls[0][3]).toBe(route)
+  assert.strictEqual(families[0].create.mock.calls[0].arguments[3], route)
 })
 
 it('should throw error if directive family is not found', async () => {
@@ -88,8 +93,8 @@ it('should throw error if directive family is not found', async () => {
     value: generate()
   }
 
-  expect(() => factory.create([declaration]))
-    .toThrow(`Directive family '${declaration.family}' is not found`)
+  assert.throws(() => factory.create([declaration]),
+    (error: Error) => error.message.includes(`Directive family '${declaration.family}' is not found`))
 })
 
 it('should apply directive', async () => {
@@ -101,14 +106,14 @@ it('should apply directive', async () => {
 
   const directives = factory.create([declaration])
   const request = generate() as unknown as Context
-  const directive = families[0].create.mock.results[0].value
+  const directive = families[0].create.mock.calls[0].result
 
   await directives.preflight(request, [])
 
   assert.ok(families[0].preflight !== undefined)
 
-  expect(families[0].preflight.mock.calls[0][0]).toStrictEqual([directive])
-  expect(families[0].preflight.mock.calls[0][1]).toEqual(request)
+  assert.deepStrictEqual(families[0].preflight.mock.calls[0].arguments[0], [directive])
+  assert.deepStrictEqual(families[0].preflight.mock.calls[0].arguments[1], request)
 })
 
 it('should apply mandatory families', async () => {
@@ -117,16 +122,13 @@ it('should apply mandatory families', async () => {
 
   await directives.preflight(request, [])
 
-  expect(families[0].preflight).toHaveBeenCalled()
+  assert.ok(families[0].preflight.mock.callCount() > 0)
 })
 
 describe('order', () => {
+  // the order the families actually ran, as each preflight recorded it
   function order (): string[] {
-    return families
-      .filter(({ preflight }) => preflight!.mock.calls.length > 0)
-      .sort((a, b) => a.preflight!.mock.invocationCallOrder[0] -
-        b.preflight!.mock.invocationCallOrder[0])
-      .map(({ name }) => name)
+    return sequence
   }
 
   it('should run mandatory families in their own order, whatever a manifest says', async () => {
@@ -138,7 +140,7 @@ describe('order', () => {
 
     await directives.preflight(generate() as unknown as Context, [])
 
-    expect(order()).toStrictEqual(['foo', 'qux'])
+    assert.deepStrictEqual(order(), ['foo', 'qux'])
   })
 
   it('should run a mandatory family before a declared one it is not declared with',
@@ -151,7 +153,7 @@ describe('order', () => {
 
       await directives.preflight(generate() as unknown as Context, [])
 
-      expect(order()).toStrictEqual(['foo', 'qux'])
+      assert.deepStrictEqual(order(), ['foo', 'qux'])
     })
 
   it('should run mandatory families before the rest', async () => {
@@ -162,6 +164,16 @@ describe('order', () => {
 
     await directives.preflight(generate() as unknown as Context, [])
 
-    expect(order()).toStrictEqual(['foo', 'qux', 'bar'])
+    assert.deepStrictEqual(order(), ['foo', 'qux', 'bar'])
   })
 })
+
+function resetCalls (target = [families], 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/Directive.ts

@@ -1,8 +1,8 @@
 import { console, type SpanOptions } from 'openspan'
-import type { Context, OutgoingMessage } from './HTTP'
-import type { Remotes } from './Remotes'
-import type { Output } from './io'
-import type * as RTD from './RTD'
+import type { Context, OutgoingMessage } from './HTTP/index.js'
+import type { Remotes } from './Remotes.js'
+import type { Output } from './io.js'
+import type * as RTD from './RTD/index.js'
 
 export class Directives implements RTD.Directives {
   private readonly sets: RTD.DirectiveSet[]

package/source/Endpoint.ts

@@ -1,12 +1,12 @@
 import { Readable } from 'node:stream'
 import { console } from 'openspan'
-import { Mapping } from './Mapping'
-import * as http from './HTTP'
-import type { Introspection, Schema } from './Introspection'
+import { Mapping } from './Mapping.js'
+import * as http from './HTTP/index.js'
+import type { Introspection, Schema } from './Introspection.js'
 import type { Remote } from '@toa.io/core'
-import type { Remotes } from './Remotes'
-import type { Context } from './Context'
-import type * as RTD from './RTD'
+import type { Remotes } from './Remotes.js'
+import type { Context } from './Context.js'
+import type * as RTD from './RTD/index.js'
 
 export class Endpoint implements RTD.Endpoint {
   private readonly endpoint: string

package/source/Factory.ts

@@ -1,20 +1,20 @@
 import assert from 'node:assert'
 import { createHash } from 'node:crypto'
 import { console, traces, type LevelName, type TracesOptions } from 'openspan'
-import { Tenant } from './Tenant'
-import { Gateway } from './Gateway'
-import { Remotes } from './Remotes'
-import { Tree } from './RTD'
-import { EndpointsFactory } from './Endpoint'
-import { families, interceptors } from './directives'
-import { DirectivesFactory } from './Directive'
-import { Composition } from './Composition'
-import * as root from './root'
-import { Interception } from './Interception'
-import * as http from './HTTP'
-import type { Branch } from './Branch'
-import type { syntax } from './RTD'
-import type { Broadcast } from './Gateway'
+import { Tenant } from './Tenant.js'
+import { Gateway } from './Gateway.js'
+import { Remotes } from './Remotes.js'
+import { Tree } from './RTD/index.js'
+import { EndpointsFactory } from './Endpoint.js'
+import { families, interceptors } from './directives/index.js'
+import { DirectivesFactory } from './Directive.js'
+import { Composition } from './Composition.js'
+import * as root from './root.js'
+import { Interception } from './Interception.js'
+import * as http from './HTTP/index.js'
+import type { Branch } from './Branch.js'
+import type { syntax } from './RTD/index.js'
+import type { Broadcast } from './Gateway.js'
 import type { Connector, Locator, extensions } from '@toa.io/core'
 
 export class Factory implements extensions.Factory {
@@ -24,8 +24,8 @@ export class Factory implements extensions.Factory {
     this.boot = boot
   }
 
-  public tenant (locator: Locator, node: syntax.Node): Connector {
-    const broadcast: Broadcast = this.boot.bindings.broadcast(CHANNEL, locator.id)
+  public async tenant (locator: Locator, node: syntax.Node): Promise<Connector> {
+    const broadcast: Broadcast = await this.boot.bindings.broadcast(CHANNEL, locator.id)
     const hash = createHash('sha256').update(JSON.stringify(node)).digest('hex')
 
     // no timestamp: the tenant stamps each announcement with its own start time
@@ -40,14 +40,14 @@ export class Factory implements extensions.Factory {
     return new Tenant(broadcast, branch)
   }
 
-  public service (): Connector | null {
+  public async service (): Promise<Connector | null> {
     assert.ok(process.env.TOA_EXPOSITION_PROPERTIES,
       'TOA_EXPOSITION_PROPERTIES is undefined')
 
     configureLogs()
 
     const options = JSON.parse(process.env.TOA_EXPOSITION_PROPERTIES) as http.Options
-    const broadcast: Broadcast = this.boot.bindings.broadcast(CHANNEL)
+    const broadcast: Broadcast = await this.boot.bindings.broadcast(CHANNEL)
     const server = http.Server.create({ ...options })
     const remotes = new Remotes(this.boot)
     const node = root.resolve()

package/source/Gateway.ts

@@ -2,13 +2,13 @@ import assert from 'node:assert'
 import { setTimeout } from 'node:timers/promises'
 import { console } from 'openspan'
 import { type bindings, Connector } from '@toa.io/core'
-import * as http from './HTTP'
-import { rethrow } from './exceptions'
-import { decide } from './Branch'
-import type { Interception } from './Interception'
-import type { Method, Node, Parameter, Tree, Match } from './RTD'
-import type { Label } from './discovery'
-import type { Branch, Exposed } from './Branch'
+import * as http from './HTTP/index.js'
+import { rethrow } from './exceptions.js'
+import { decide } from './Branch.js'
+import type { Interception } from './Interception.js'
+import type { Method, Node, Parameter, Tree, Match } from './RTD/index.js'
+import type { Label } from './discovery.js'
+import type { Branch, Exposed } from './Branch.js'
 
 export class Gateway extends Connector {
   private readonly broadcast: Broadcast

package/source/HTTP/Context.ts

@@ -2,11 +2,11 @@ import crypto from 'node:crypto'
 import { buffer } from 'node:stream/consumers'
 import Negotiator from 'negotiator'
 import { console } from 'openspan'
-import { Timing } from './Timing'
-import { type Format, formats, types } from './formats'
-import { read } from './messages'
-import type { OutgoingMessage } from './messages'
-import type { IncomingMessage } from './types'
+import { Timing } from './Timing.js'
+import { type Format, formats, types } from './formats/index.js'
+import { read } from './messages.js'
+import type { OutgoingMessage } from './messages.js'
+import type { IncomingMessage } from './types.js'
 
 export class Context {
   public readonly id: string

package/source/HTTP/Server.ts

@@ -7,11 +7,11 @@ import { once } from 'node:events'
 import { setTimeout } from 'node:timers/promises'
 import { console, current, decide, decode, run, type SpanContext } from 'openspan'
 import { Connector } from '@toa.io/core'
-import { type OutgoingMessage, write } from './messages'
-import { ClientError, Exception } from './exceptions'
-import { Context } from './Context'
-import { PROBE, Probe } from './Probe'
-import type { IncomingMessage, Protocol, ServerResponse } from './types'
+import { type OutgoingMessage, write } from './messages.js'
+import { ClientError, Exception } from './exceptions.js'
+import { Context } from './Context.js'
+import { PROBE, Probe } from './Probe.js'
+import type { IncomingMessage, Protocol, ServerResponse } from './types.js'
 
 export class Server extends Connector {
   private readonly server: http.Server | http2.Http2Server
@@ -261,7 +261,7 @@ export class Server extends Connector {
         if (!response.writableEnded)
           try {
             response.writeHead(500).end()
-          } catch (e) {
+          } catch {
             // Nothing more we can do
           }
       }

package/source/HTTP/Timing.ts

@@ -1,5 +1,5 @@
 import { performance } from 'node:perf_hooks'
-import type { ServerResponse } from './types'
+import type { ServerResponse } from './types.js'
 
 export class Timing {
   private readonly start = performance.now()

package/source/HTTP/formats/index.ts

@@ -1,7 +1,7 @@
-import * as json from './json'
-import * as yaml from './yaml'
-import * as msgpack from './msgpack'
-import * as text from './text'
+import * as json from './json.js'
+import * as yaml from './yaml.js'
+import * as msgpack from './msgpack.js'
+import * as text from './text.js'
 
 export const formats: Record<string, Format> = {
   [json.type]: json,

package/source/HTTP/formats/yaml.test.ts

@@ -1,4 +1,7 @@
-import { encode } from './yaml'
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { encode } from './yaml.js'
 
 it('encodes error values as their public properties', () => {
   const value = new (class InvalidUsernameError extends Error {
@@ -6,12 +9,11 @@ it('encodes error values as their public properties', () => {
     public override readonly message = 'Username is not meeting the requirements'
   })()
 
-  expect(encode(value).toString())
-    .toBe('code: INVALID_USERNAME\nmessage: Username is not meeting the requirements\n')
+  assert.strictEqual(encode(value).toString(), 'code: INVALID_USERNAME\nmessage: Username is not meeting the requirements\n')
 })
 
 it('writes a value the way its toJSON says', () => {
   const secret = { unwrap: () => 's3cret', toJSON: () => '<REDACTED>' }
 
-  expect(encode({ a: 1, b: secret }).toString()).toBe('a: 1\nb: <REDACTED>\n')
+  assert.strictEqual(encode({ a: 1, b: secret }).toString(), 'a: 1\nb: <REDACTED>\n')
 })

package/source/HTTP/formats/yaml.ts

@@ -1,4 +1,4 @@
-import * as yaml from 'js-yaml'
+import { yaml } from '@toa.io/generic'
 
 export const type = 'application/yaml'
 export const multipart = 'multipart/yaml'

package/source/HTTP/index.ts

@@ -1,6 +1,6 @@
-export * from './Server'
-export * from './messages'
-export * from './exceptions'
-export * from './Context'
-export * from './types'
-export * from './Probe'
+export * from './Server.js'
+export * from './messages.js'
+export * from './exceptions.js'
+export * from './Context.js'
+export * from './types.js'
+export * from './Probe.js'

package/source/HTTP/messages.test.ts

@@ -1,16 +1,19 @@
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
 import { PassThrough, Readable } from 'node:stream'
 import * as streamConsumers from 'node:stream/consumers'
 import { generate } from 'randomstring'
 import * as msgpack from 'msgpackr'
-import { multipart, read, type OutgoingMessage } from './messages'
-import { BadRequest, UnsupportedMediaType } from './exceptions'
-import { formats } from './formats'
-import { Timing } from './Timing'
+import { multipart, read, type OutgoingMessage } from './messages.js'
+import { BadRequest, UnsupportedMediaType } from './exceptions.js'
+import { formats } from './formats/index.js'
+import { Timing } from './Timing.js'
 import type * as http from 'node:http'
-import type { Context } from './Context'
+import type { Context } from './Context.js'
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 })
 
 describe('read', () => {
@@ -22,7 +25,7 @@ describe('read', () => {
     const context = createContext(path, headers, json)
     const output = await read(context)
 
-    expect(output).toStrictEqual(input)
+    assert.deepStrictEqual(output, input)
   })
 
   it('should parse application/yaml', async () => {
@@ -32,7 +35,7 @@ describe('read', () => {
     const request = createContext(path, headers, yaml)
     const value = await read(request)
 
-    expect(value).toStrictEqual({ foo: 1 })
+    assert.deepStrictEqual(value, { foo: 1 })
   })
 
   it('should parse application/mskpack', async () => {
@@ -43,7 +46,7 @@ describe('read', () => {
     const request = createContext(path, headers, msg)
     const output = await read(request)
 
-    expect(output).toStrictEqual(input)
+    assert.deepStrictEqual(output, input)
   })
 
   it('should parse text/plain', async () => {
@@ -53,7 +56,7 @@ describe('read', () => {
     const request = createContext(path, headers, input)
     const output = await read(request)
 
-    expect(output).toStrictEqual(input)
+    assert.deepStrictEqual(output, input)
   })
 
   it('should parse application/json with charset parameter', async () => {
@@ -64,7 +67,7 @@ describe('read', () => {
     const context = createContext(path, headers, json)
     const output = await read(context)
 
-    expect(output).toStrictEqual(input)
+    assert.deepStrictEqual(output, input)
   })
 
   it('should throw on unsupported request media type', async () => {
@@ -72,7 +75,7 @@ describe('read', () => {
     const headers = { 'content-type': 'wtf/' + generate() }
     const request = createContext(path, headers)
 
-    await expect(read(request)).rejects.toThrow(UnsupportedMediaType)
+    await assert.rejects(read(request), UnsupportedMediaType)
   })
 
   it('should throw on malformed content', async () => {
@@ -81,7 +84,7 @@ describe('read', () => {
     const headers = { 'content-type': 'application/json' }
     const request = createContext(path, headers, text)
 
-    await expect(read(request)).rejects.toThrow(BadRequest)
+    await assert.rejects(read(request), BadRequest)
   })
 
   it('should output correct mulitpart format', async () => {
@@ -102,7 +105,7 @@ describe('read', () => {
 
     const result = await streamConsumers.text(framed)
 
-    expect(result).toBe([
+    assert.strictEqual(result, [
       '--cut',
       '',
       'ACK',
@@ -123,7 +126,7 @@ describe('read', () => {
 })
 
 export function createContext (url: string, headers: Record<string, string> = {}, content: string | Buffer = ''):
-jest.MockedObject<Context> {
+Context {
   const data = Buffer.isBuffer(content) ? content : Buffer.from(content)
   const stream = Readable.from(data)
   let consumed = false
@@ -145,5 +148,15 @@ jest.MockedObject<Context> {
     }
   }
 
-  return mock as unknown as jest.MockedObject<Context>
+  return mock as unknown as Context
+}
+
+function resetCalls (target = [], 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/HTTP/messages.ts

@@ -1,14 +1,15 @@
+import { readFileSync } from 'node:fs'
 import { Readable } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
 import { createHash } from 'node:crypto'
 import * as contentType from 'content-type'
 import { console } from 'openspan'
-import { type Format, formats } from './formats'
-import { BadRequest, NotAcceptable, UnsupportedMediaType } from './exceptions'
-import type { Context } from './Context'
-import type { ServerResponse } from './types'
+import { type Format, formats } from './formats/index.js'
+import { BadRequest, NotAcceptable, UnsupportedMediaType } from './exceptions.js'
+import type { Context } from './Context.js'
+import type { ServerResponse } from './types.js'
 
-const server = `Exposition/${require('../../package.json').version}` +
+const server = `Exposition/${JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version}` +
   ((process.env.TOA_CONTEXT === undefined ? '' : ` ${process.env.TOA_CONTEXT}`) +
     (process.env.TOA_ENV === undefined ? '' : `/${process.env.TOA_ENV}`))
 

package/source/Interception.ts

@@ -1,4 +1,4 @@
-import type { Input, Output } from './io'
+import type { Input, Output } from './io.js'
 
 export class Interception implements Interceptor {
   private readonly interceptors: Interceptor[]

package/source/Mapping.ts

@@ -1,9 +1,9 @@
-import { type Parameter } from './RTD'
-import { Query } from './Query'
-import type { Introspection, Schema } from './Introspection'
-import type { QueryString } from './Query'
-import type * as http from './HTTP'
-import type * as syntax from './RTD/syntax'
+import { type Parameter } from './RTD/index.js'
+import { Query } from './Query.js'
+import type { Introspection, Schema } from './Introspection.js'
+import type { QueryString } from './Query.js'
+import type * as http from './HTTP/index.js'
+import type * as syntax from './RTD/syntax/index.js'
 import type * as core from '@toa.io/core'
 
 export abstract class Mapping {

package/source/Query.test.ts

@@ -1,5 +1,8 @@
-import { Query } from './Query'
-import { type Parameter, type syntax } from './RTD'
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Query } from './Query.js'
+import { type Parameter, type syntax } from './RTD/index.js'
 
 it('should combine request criteria', async () => {
   const query: syntax.Query = {
@@ -16,7 +19,7 @@ it('should combine request criteria', async () => {
   const instance = new Query(query)
   const result = instance.fit({ criteria: 'qux==4' }, parameters)
 
-  expect(result.query!.criteria).toStrictEqual('(bar==2;baz==3);(foo==1);(qux==4)')
+  assert.deepStrictEqual(result.query!.criteria, '(bar==2;baz==3);(foo==1);(qux==4)')
 })
 
 it('should set id parameter as query.id', async () => {
@@ -32,6 +35,6 @@ it('should set id parameter as query.id', async () => {
   const instance = new Query(query)
   const result = instance.fit({}, parameters)
 
-  expect(result.query!.criteria).toBeUndefined()
-  expect(result.query!.id).toStrictEqual(id)
+  assert.strictEqual(result.query!.criteria, undefined)
+  assert.deepStrictEqual(result.query!.id, id)
 })