@toa.io/core 1.0.0-alpha.284 → 1.0.0-alpha.287

package/test/query.test.js

@@ -1,7 +1,7 @@
-import { describe, it, beforeEach, mock } from 'node:test'
+import { describe, it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { Query } from '../src/query.js'
+import { Query } from '../source/query.js'
 import * as fixtures from './query.fixtures.js'
 
 beforeEach(() => {
@@ -54,10 +54,62 @@ describe('criteria', () => {
     assert.deepStrictEqual(query.criteria, fixtures.samples.extended.parsed.criteria)
   })
 
+  it('should refuse a value the property cannot hold', () => {
+    const strict = new Query({
+      volume: { type: 'number' },
+      count: { type: 'integer' },
+      booked: { type: 'boolean' }
+    })
+
+    const refused = [
+      ['volume>abc', /takes a number/],
+      ['volume==1.5kg', /takes a number/],
+      ['count==1.5', /takes an integer/],
+      ['count==12kg', /takes an integer/],
+      ['booked==yes', /takes a boolean/],
+      ['booked==TRUE', /takes a boolean/],
+      ['volume=in=(1,two)', /'two' is not one/]
+    ]
+
+    for (const [criteria, message] of refused)
+      assert.throws(
+        () => strict.parse({ criteria }),
+        (error) => message.test(error.message),
+        criteria
+      )
+  })
+
+  it('should read a value the property can hold', () => {
+    const strict = new Query({
+      volume: { type: 'number' },
+      count: { type: 'integer' },
+      booked: { type: 'boolean' },
+      title: { type: 'string' }
+    })
+
+    const read = [
+      ['volume>1.5', 1.5],
+      ['volume>-1.5', -1.5],
+      ['count==12', 12],
+      ['booked==false', false],
+      ['title==12kg', '12kg']
+    ]
+
+    for (const [criteria, value] of read)
+      assert.deepStrictEqual(
+        strict.parse({ criteria }).criteria.right.value,
+        value,
+        criteria
+      )
+  })
+
   it('should throw on unknown properties', () => {
     const instance = new Query(fixtures.samples.simple.properties)
 
-    assert.throws(() => instance.parse({ criteria: 'lastname==Johnson' }), (error) => /not defined/.test(error.message))
+    assert.throws(
+      () => instance.parse({ criteria: 'lastname==Johnson' }),
+      (error) => /not defined/.test(error.message)
+    )
   })
 
   it('should parse id', () => {
@@ -91,13 +143,20 @@ describe('options', () => {
       const sort = ['a', 'b:desc', 'c']
       const query = instance.parse({ sort })
 
-      assert.deepStrictEqual(query.options.sort, [['a', 'asc'], ['b', 'desc'], ['c', 'asc']])
+      assert.deepStrictEqual(query.options.sort, [
+        ['a', 'asc'],
+        ['b', 'desc'],
+        ['c', 'asc']
+      ])
     })
 
     it('should throw on unknown properties', () => {
       const sort = ['d:asc']
 
-      assert.throws(() => instance.parse({ sort }), (error) => /not defined/.test(error.message))
+      assert.throws(
+        () => instance.parse({ sort }),
+        (error) => /not defined/.test(error.message)
+      )
     })
   })
 
@@ -105,12 +164,15 @@ describe('options', () => {
     it('should throw on unknown properties', () => {
       const projection = ['a', 'b', 'c', 'd']
 
-      assert.throws(() => instance.parse({ projection }), (error) => /not defined/.test(error.message))
+      assert.throws(
+        () => instance.parse({ projection }),
+        (error) => /not defined/.test(error.message)
+      )
     })
   })
 })
 
-function resetCalls (target = [assert, fixtures], seen = new Set()) {
+function resetCalls(target = [assert, fixtures], seen = new Set()) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/test/receiver.fixtures.js

@@ -8,13 +8,13 @@ export const definition = /** @type {toa.norm.component.Receiver} */ {
   adaptive: false
 }
 
-export const local = /** @type {toa.core.Component} */ {
+export const local = /** @type {import('@toa.io/core').Component} */ {
   locator: { id: 'default.dummy' },
   invoke: mock.fn()
 }
 
 // noinspection JSCheckFunctionSignatures
-export const bridge = /** @type {toa.core.bridges.Event} */ {
+export const bridge = /** @type {import('@toa.io/core/types').bridges.Event} */ {
   condition: mock.fn(async (payload) => !(payload.reject === true)),
   request: mock.fn(async () => ({ input: generate() }))
 }

package/test/receiver.test.js

@@ -6,19 +6,20 @@ import clone from 'clone-deep'
 import { generate } from 'randomstring'
 import { merge } from '@toa.io/generic'
 
-import { Connector } from '../src/connector.js'
+import { Connector } from '../source/connector.js'
 
 // the fixtures are not connectors, so a dependency is recorded rather than linked
 const depends = mock.method(Connector.prototype, 'depends', () => undefined)
 
-const dependencies = (instance) => depends.mock.calls
-  .filter((call) => call.this === instance)
-  .map((call) => call.arguments[0])
+const dependencies = (instance) =>
+  depends.mock.calls
+    .filter((call) => call.this === instance)
+    .map((call) => call.arguments[0])
 
-import { Receiver } from '../src/receiver.js'
+import { Receiver } from '../source/receiver.js'
 import * as fixtures from './receiver.fixtures.js'
 
-/** @type {toa.core.Receiver} */
+/** @type {import('@toa.io/core/types').Receiver} */
 let receiver
 
 /** @type {toa.norm.component.Receiver} */
@@ -42,29 +43,38 @@ it('should apply', async () => {
 
   await receiver.receive({ payload })
 
-  assert.ok(fixtures.local.invoke.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], definition.operation) && isDeepStrictEqual(call.arguments[1], { input: payload })))
+  assert.ok(
+    fixtures.local.invoke.mock.calls.some(
+      (call) =>
+        call.arguments.length === 2 &&
+        isDeepStrictEqual(call.arguments[0], definition.operation) &&
+        isDeepStrictEqual(call.arguments[1], { input: payload })
+    )
+  )
 })
 
 for (const [adaptive] of [[false], [true]])
-   it(`should pass UI extensions (adaptive: ${adaptive})`, async () => {
-  resetCalls()
+  it(`should pass UI extensions (adaptive: ${adaptive})`, async () => {
+    resetCalls()
 
-  definition.adaptive = adaptive
-  receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
+    definition.adaptive = adaptive
+    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
 
-  const payload = { foo: generate() }
-  const extension = { [generate()]: generate() }
-  const message = { payload, ...extension }
+    const payload = { foo: generate() }
+    const extension = { [generate()]: generate() }
+    const message = { payload, ...extension }
 
-  await receiver.receive(message)
+    await receiver.receive(message)
 
-  const request = adaptive ? await fixtures.bridge.request.mock.calls[0].result : { input: payload }
-  const expected = merge(clone(request), extension)
+    const request = adaptive
+      ? await fixtures.bridge.request.mock.calls[0].result
+      : { input: payload }
+    const expected = merge(clone(request), extension)
 
-  const argument = fixtures.local.invoke.mock.calls[0].arguments[1]
+    const argument = fixtures.local.invoke.mock.calls[0].arguments[1]
 
-  assert.deepStrictEqual(argument, expected)
-})
+    assert.deepStrictEqual(argument, expected)
+  })
 
 describe('conditioned', () => {
   beforeEach(() => {
@@ -76,8 +86,20 @@ describe('conditioned', () => {
     const payload = { foo: 'bar' }
     await receiver.receive({ payload })
 
-    assert.ok(fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], payload)))
-    assert.ok(fixtures.local.invoke.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], definition.operation) && isDeepStrictEqual(call.arguments[1], { input: payload })))
+    assert.ok(
+      fixtures.bridge.condition.mock.calls.some(
+        (call) =>
+          call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], payload)
+      )
+    )
+    assert.ok(
+      fixtures.local.invoke.mock.calls.some(
+        (call) =>
+          call.arguments.length === 2 &&
+          isDeepStrictEqual(call.arguments[0], definition.operation) &&
+          isDeepStrictEqual(call.arguments[1], { input: payload })
+      )
+    )
   })
 
   it('should not apply if condition is false', async () => {
@@ -100,14 +122,18 @@ describe('adaptive', () => {
 
     const request = await fixtures.bridge.request.mock.calls[0].result
 
-    assert.ok(fixtures.local.invoke.mock.calls.some((call) =>
-      call.arguments.length === 2 &&
-      isDeepStrictEqual(call.arguments[0], definition.operation) &&
-      isDeepStrictEqual(call.arguments[1], request)))
+    assert.ok(
+      fixtures.local.invoke.mock.calls.some(
+        (call) =>
+          call.arguments.length === 2 &&
+          isDeepStrictEqual(call.arguments[0], definition.operation) &&
+          isDeepStrictEqual(call.arguments[1], request)
+      )
+    )
   })
 })
 
-function resetCalls (target = [assert, clone, fixtures], seen = new Set()) {
+function resetCalls(target = [assert, clone, fixtures], seen = new Set()) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/test/reflection.test.js

@@ -2,18 +2,18 @@ import { it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 
 import { generate } from 'randomstring'
-import { Reflection, Connector } from '../src/index.js'
+import { Reflection, Connector } from '../source/index.js'
 
 it('should export', () => {
   assert.notStrictEqual(Reflection, undefined)
 })
 
-/** @type {toa.core.Reflection<string>} */
+/** @type {import('@toa.io/core').Reflection<string>} */
 let reflection
 
 const value = generate()
 
-/** @type {toa.core.reflection.Source<string>} */
+/** @type {import('@toa.io/core').ReflectionSource<string>} */
 const source = async () => value
 
 beforeEach(() => {

package/test/state.fixtures.js

@@ -5,7 +5,7 @@ import { generate } from 'randomstring'
 export const storage = {
   name: 'dummy',
   get: mock.fn(() => ({ id: generate() })),
-  find: mock.fn(() => ([{ id: generate() }])),
+  find: mock.fn(() => [{ id: generate() }]),
   add: mock.fn(() => true),
   set: mock.fn(() => true),
   store: mock.fn(() => true),
@@ -27,7 +27,8 @@ export const entity = {
 }
 
 export const initial = {
-  initial: true, ...entity
+  initial: true,
+  ...entity
 }
 
 export const unchanged = {
@@ -37,6 +38,12 @@ export const unchanged = {
 
 // a legacy outbox: no storage capability, so `publish` emits inline
 export const outbox = {
-  row: mock.fn((event) => ({ id: generate(), lane: 0, published: false, pending: 0, event })),
+  row: mock.fn((event) => ({
+    id: generate(),
+    lane: 0,
+    published: false,
+    pending: 0,
+    event
+  })),
   publish: mock.fn()
 }

package/test/state.test.js

@@ -1,8 +1,8 @@
-import { describe, it, beforeEach, mock } from 'node:test'
+import { describe, it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 import { isDeepStrictEqual } from 'node:util'
 
-import { State } from '../src/state.js'
+import { State } from '../source/state.js'
 import * as fixtures from './state.fixtures.js'
 
 let state
@@ -16,34 +16,84 @@ beforeEach(() => {
 it('should provide object', async () => {
   const entity = await state.object(fixtures.query)
 
-  assert.ok(fixtures.storage.get.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.query)))
+  assert.ok(
+    fixtures.storage.get.mock.calls.some(
+      (call) =>
+        call.arguments.length === 1 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.query)
+    )
+  )
   assert.deepStrictEqual(entity, fixtures.factory.object.mock.calls[0].result)
-  assert.ok(fixtures.factory.object.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.storage.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], true)))
+  assert.ok(
+    fixtures.factory.object.mock.calls.some(
+      (call) =>
+        call.arguments.length === 2 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.storage.get.mock.calls[0].result) &&
+        isDeepStrictEqual(call.arguments[1], true)
+    )
+  )
 })
 
 it('should provide read-only object', async () => {
   await state.object(fixtures.query, false)
 
-  assert.ok(fixtures.factory.object.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.storage.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], false)))
+  assert.ok(
+    fixtures.factory.object.mock.calls.some(
+      (call) =>
+        call.arguments.length === 2 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.storage.get.mock.calls[0].result) &&
+        isDeepStrictEqual(call.arguments[1], false)
+    )
+  )
 })
 
 it('should provide read-only objects', async () => {
   await state.objects(fixtures.query, false)
 
-  assert.ok(fixtures.factory.objects.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], fixtures.storage.find.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], undefined) && isDeepStrictEqual(call.arguments[2], false)))
+  assert.ok(
+    fixtures.factory.objects.mock.calls.some(
+      (call) =>
+        call.arguments.length === 3 &&
+        isDeepStrictEqual(
+          call.arguments[0],
+          fixtures.storage.find.mock.calls[0].result
+        ) &&
+        isDeepStrictEqual(call.arguments[1], undefined) &&
+        isDeepStrictEqual(call.arguments[2], false)
+    )
+  )
 })
 
 it('should store entity', async () => {
   await state.commit(fixtures.initial)
 
-  assert.ok(fixtures.storage.store.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.initial.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], fixtures.outbox.row.mock.calls[0].result)))
+  assert.ok(
+    fixtures.storage.store.mock.calls.some(
+      (call) =>
+        call.arguments.length === 2 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.initial.get.mock.calls[0].result) &&
+        isDeepStrictEqual(call.arguments[1], fixtures.outbox.row.mock.calls[0].result)
+    )
+  )
 })
 
 it('should publish the row', async () => {
   await state.commit(fixtures.entity)
 
-  assert.ok(fixtures.outbox.row.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.entity.event.mock.calls[0].result)))
-  assert.ok(fixtures.outbox.publish.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.outbox.row.mock.calls[0].result)))
+  assert.ok(
+    fixtures.outbox.row.mock.calls.some(
+      (call) =>
+        call.arguments.length === 1 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.entity.event.mock.calls[0].result)
+    )
+  )
+  assert.ok(
+    fixtures.outbox.publish.mock.calls.some(
+      (call) =>
+        call.arguments.length === 1 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.outbox.row.mock.calls[0].result)
+    )
+  )
 })
 
 it('should not publish if the write did not happen', async () => {
@@ -62,7 +112,6 @@ it('should build the row before the write', async () => {
     return true
   })
 
-  
   await state.commit(fixtures.entity)
 })
 
@@ -72,9 +121,23 @@ describe('assignment', () => {
   it('should pass the row to upsert and publish it', async () => {
     const result = await state.apply(changeset, { foo: 1 })
 
-    assert.ok(fixtures.storage.upsert.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], changeset.query) && isDeepStrictEqual(call.arguments[1], { foo: 1 }) && isDeepStrictEqual(call.arguments[2], fixtures.outbox.row.mock.calls[0].result)))
-
-    assert.ok(fixtures.outbox.publish.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.outbox.row.mock.calls[0].result)))
+    assert.ok(
+      fixtures.storage.upsert.mock.calls.some(
+        (call) =>
+          call.arguments.length === 3 &&
+          isDeepStrictEqual(call.arguments[0], changeset.query) &&
+          isDeepStrictEqual(call.arguments[1], { foo: 1 }) &&
+          isDeepStrictEqual(call.arguments[2], fixtures.outbox.row.mock.calls[0].result)
+      )
+    )
+
+    assert.ok(
+      fixtures.outbox.publish.mock.calls.some(
+        (call) =>
+          call.arguments.length === 1 &&
+          isDeepStrictEqual(call.arguments[0], fixtures.outbox.row.mock.calls[0].result)
+      )
+    )
     assert.deepStrictEqual(result, fixtures.storage.upsert.mock.calls[0].result)
   })
 
@@ -88,7 +151,7 @@ describe('assignment', () => {
   })
 })
 
-function resetCalls (target = [assert, fixtures], seen = new Set()) {
+function resetCalls(target = [assert, fixtures], seen = new Set()) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/test/transmission.test.js

@@ -2,16 +2,17 @@ import { it, beforeEach, mock } from 'node:test'
 import assert from 'node:assert/strict'
 import { isDeepStrictEqual } from 'node:util'
 
-import { Connector } from '../src/connector.js'
+import { Connector } from '../source/connector.js'
 
 // the fixtures are not connectors, so a dependency is recorded rather than linked
 const depends = mock.method(Connector.prototype, 'depends', () => undefined)
 
-const dependencies = (instance) => depends.mock.calls
-  .filter((call) => call.this === instance)
-  .map((call) => call.arguments[0])
-import { Transmission } from '../src/transmission.js'
-import { codes } from '../src/exceptions.js'
+const dependencies = (instance) =>
+  depends.mock.calls
+    .filter((call) => call.this === instance)
+    .map((call) => call.arguments[0])
+import { Transmission } from '../source/transmission.js'
+import { codes } from '../source/exceptions.js'
 import * as fixtures from './transmission.fixtures.js'
 
 let transmission
@@ -27,14 +28,21 @@ beforeEach(() => {
 
 it('should be instance of Connector depending on bindings', () => {
   assert.ok(transmission instanceof Connector)
-  assert.ok(dependencies(transmission).some((one) => isDeepStrictEqual(one, fixtures.bindings)))
+  assert.ok(
+    dependencies(transmission).some((one) => isDeepStrictEqual(one, fixtures.bindings))
+  )
 })
 
 it('should pass arguments and return value', async () => {
   const request = { foo: 'bar' }
   const result = await transmission.request(request)
 
-  assert.ok(fixtures.bindings[0].request.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], request)))
+  assert.ok(
+    fixtures.bindings[0].request.mock.calls.some(
+      (call) =>
+        call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], request)
+    )
+  )
   assert.strictEqual(result, await fixtures.bindings[0].request.mock.calls[0].result)
 })
 
@@ -47,13 +55,18 @@ it('should pick bindings sequentially', async () => {
 })
 
 it('should throw exception if none succeeded', async () => {
-  await assert.rejects(transmission.request({ pick: 5 }), (error) => { assert.partialDeepStrictEqual(error, { code: codes.Transmission }); return true })
+  await assert.rejects(transmission.request({ pick: 5 }), (error) => {
+    assert.partialDeepStrictEqual(error, { code: codes.Transmission })
+    return true
+  })
 
-  fixtures.bindings.forEach((binding) =>
-    assert.ok(binding.request.mock.callCount() > 0))
+  fixtures.bindings.forEach((binding) => assert.ok(binding.request.mock.callCount() > 0))
 })
 
-function resetCalls (target = [assert, depends, dependencies, fixtures], seen = new Set()) {
+function resetCalls(
+  target = [assert, depends, dependencies, fixtures],
+  seen = new Set()
+) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/transpiled/assignment.d.ts

@@ -0,0 +1,6 @@
+import { Operation } from './operation.js';
+import type { Store } from './operation.js';
+export declare class Assignment extends Operation {
+    protected acquire(store: Store): Promise<void>;
+    protected commit(store: Store): Promise<void>;
+}

package/transpiled/assignment.js

@@ -0,0 +1,20 @@
+import { Operation } from './operation.js';
+export class Assignment extends Operation {
+    async acquire(store) {
+        const changeset = this.scope.changeset(store.request.query);
+        store.scope = changeset;
+        store.state = changeset.get();
+    }
+    async commit(store) {
+        const { scope, state, reply, request } = store;
+        if (reply.error !== undefined)
+            return;
+        const changeset = scope;
+        changeset.set(state);
+        const output = await this.scope.apply(changeset, request.input);
+        // assignment returns new state by default
+        if (store.reply.output === undefined)
+            store.reply.output = output;
+    }
+}
+//# sourceMappingURL=assignment.js.map

package/transpiled/assignment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignment.js","sourceRoot":"","sources":["../source/assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAI1C,MAAM,OAAO,UAAW,SAAQ,SAAS;IACpB,KAAK,CAAC,OAAO,CAAC,KAAY;QAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAY,CAAC,CAAA;QAElE,KAAK,CAAC,KAAK,GAAG,SAAS,CAAA;QACvB,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC,GAAG,EAAE,CAAA;IAC/B,CAAC;IAEkB,KAAK,CAAC,MAAM,CAAC,KAAY;QAC1C,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,KAAK,CAAA;QAE9C,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;YAAE,OAAM;QAErC,MAAM,SAAS,GAAG,KAAkB,CAAA;QAEpC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAEpB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC,CAAA;QAE/D,0CAA0C;QAC1C,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,SAAS;YAAE,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,CAAA;IACnE,CAAC;CACF"}

package/transpiled/call.d.ts

@@ -0,0 +1,10 @@
+import { Connector } from './connector.js';
+import type { Transmission } from './transmission.js';
+import type { Request as Contract } from './contract/request.js';
+import type { Request, Source } from './types/request.js';
+export declare class Call extends Connector {
+    #private;
+    constructor(transmitter: Transmission, contract: Contract, source?: Source);
+    invoke(request?: Request): Promise<any>;
+    explain(): any;
+}

package/transpiled/call.js

@@ -0,0 +1,52 @@
+import { Readable } from 'node:stream';
+import { current, encode } from 'openspan';
+import { Connector } from './connector.js';
+export class Call extends Connector {
+    #transmitter;
+    #contract;
+    #source;
+    constructor(transmitter, contract, source) {
+        super();
+        this.#transmitter = transmitter;
+        this.#contract = contract;
+        this.#source = source;
+        this.depends(transmitter);
+    }
+    async invoke(request = {}) {
+        // the caller may have attributed the call itself, as the node bridge does
+        if (this.#source !== undefined)
+            request.source ??= this.#source;
+        this.#contract.fit(request);
+        // an operation that takes no input still has to send an explicit null
+        request.input ??= null;
+        // avoid validation on the recipient's side
+        request.authentic = true;
+        const context = current();
+        if (context !== undefined)
+            request.telemetry = encode(context);
+        const reply = await this.#transmitter.request(request);
+        if (reply === null)
+            return null;
+        else if (reply instanceof Readable)
+            return reply;
+        else {
+            if (reply.exception !== undefined)
+                throw reply.exception;
+            if (reply.error !== undefined)
+                return new RemoteError(reply.error);
+            else
+                return reply.output;
+        }
+    }
+    explain() {
+        return this.#contract.discovery;
+    }
+}
+// the remote error as a value: every property it carries, and nothing else enumerable
+class RemoteError extends Error {
+    constructor(error) {
+        super();
+        Object.assign(this, error);
+    }
+}
+//# sourceMappingURL=call.js.map

package/transpiled/call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.js","sourceRoot":"","sources":["../source/call.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAK1C,MAAM,OAAO,IAAK,SAAQ,SAAS;IACxB,YAAY,CAAc;IAC1B,SAAS,CAAU;IACnB,OAAO,CAAoB;IAEpC,YAAmB,WAAyB,EAAE,QAAkB,EAAE,MAAe;QAC/E,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,YAAY,GAAG,WAAW,CAAA;QAC/B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAA;QACzB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QAErB,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3B,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,OAAO,GAAY,EAAE;QACvC,0EAA0E;QAC1E,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS;YAAE,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,OAAO,CAAA;QAE/D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAE3B,sEAAsE;QACtE,OAAO,CAAC,KAAK,KAAK,IAAI,CAAA;QAEtB,2CAA2C;QAC3C,OAAO,CAAC,SAAS,GAAG,IAAI,CAAA;QAExB,MAAM,OAAO,GAAG,OAAO,EAAE,CAAA;QAEzB,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAAA;QAE9D,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAEtD,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,IAAI,CAAA;aAC1B,IAAI,KAAK,YAAY,QAAQ;YAAE,OAAO,KAAK,CAAA;aAC3C,CAAC;YACJ,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;gBAAE,MAAM,KAAK,CAAC,SAAS,CAAA;YAExD,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;gBAAE,OAAO,IAAI,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;;gBAC7D,OAAO,KAAK,CAAC,MAAM,CAAA;QAC1B,CAAC;IACH,CAAC;IAEM,OAAO;QACZ,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAA;IACjC,CAAC;CACF;AAED,sFAAsF;AACtF,MAAM,WAAY,SAAQ,KAAK;IAC7B,YAAmB,KAAa;QAC9B,KAAK,EAAE,CAAA;QAEP,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAC5B,CAAC;CACF"}

package/transpiled/cascade.d.ts

@@ -0,0 +1,7 @@
+import { Connector } from './connector.js';
+import type { Algorithm } from './types/bridges.js';
+export declare class Cascade extends Connector {
+    #private;
+    constructor(bridges: Algorithm[], preflight?: Connector);
+    run(...args: [any, any?]): Promise<any>;
+}

package/transpiled/cascade.js

@@ -0,0 +1,28 @@
+import { Connector } from './connector.js';
+export class Cascade extends Connector {
+    #last;
+    constructor(bridges, preflight) {
+        super();
+        // this.#bridges = bridges
+        this.#last = bridges[bridges.length - 1];
+        if (preflight === undefined)
+            this.depends(bridges);
+        else
+            this.depends(bridges).depends(preflight);
+    }
+    async run(...args) {
+        // const reply = {}
+        //
+        // for (const bridge of this.#bridges) {
+        //   const partial = await bridge.execute(...args)
+        //
+        //   if (partial.error) return { error: partial.error }
+        //
+        //   merge(reply, partial)
+        // }
+        //
+        // return reply
+        return this.#last.execute(...args);
+    }
+}
+//# sourceMappingURL=cascade.js.map