@toa.io/core 1.0.0-alpha.29 → 1.0.0-alpha.291

package/test/state.test.js

@@ -1,46 +1,162 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { State } = require('../src/state')
-const fixtures = require('./state.fixtures')
+import { State } from '../source/state.js'
+import * as fixtures from './state.fixtures.js'
 
 let state
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 
-  state = new State(fixtures.storage, fixtures.factory, fixtures.emitter)
+  state = new State(fixtures.storage, fixtures.factory, fixtures.outbox)
 })
 
 it('should provide object', async () => {
   const entity = await state.object(fixtures.query)
 
-  expect(fixtures.storage.get).toHaveBeenCalledWith(fixtures.query)
-  expect(entity).toStrictEqual(fixtures.factory.object.mock.results[0].value)
-  expect(fixtures.factory.object).toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value)
+  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)
+    )
+  )
 })
 
-it('should provide objects', async () => {
-  const set = await state.objects(fixtures.query)
+it('should provide read-only object', async () => {
+  await state.object(fixtures.query, false)
 
-  expect(fixtures.storage.find).toHaveBeenCalledWith(fixtures.query)
-  expect(set).toStrictEqual(fixtures.factory.objects.mock.results[0].value)
-  expect(fixtures.factory.objects).toHaveBeenCalledWith(fixtures.storage.find.mock.results[0].value)
+  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)
+    )
+  )
 })
 
 it('should store entity', async () => {
   await state.commit(fixtures.initial)
 
-  expect(fixtures.storage.store).toHaveBeenCalledWith(fixtures.initial.get.mock.results[0].value)
+  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 emit', async () => {
+it('should publish the row', async () => {
   await state.commit(fixtures.entity)
 
-  expect(fixtures.emitter.emit).toHaveBeenCalledWith(fixtures.entity.event.mock.results[0].value)
+  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 emit if state has not been changed', async () => {
-  await state.commit(fixtures.unchanged)
+it('should not publish if the write did not happen', async () => {
+  fixtures.storage.store.mock.mockImplementationOnce(() => false)
 
-  expect(fixtures.emitter.emit).not.toHaveBeenCalled()
+  await state.commit(fixtures.entity)
+
+  assert.strictEqual(fixtures.outbox.publish.mock.callCount(), 0)
 })
+
+it('should build the row before the write', async () => {
+  // the storage commits the row in the same transaction, so it must already exist
+  fixtures.storage.store.mock.mockImplementationOnce((_, row) => {
+    assert.notStrictEqual(row, undefined)
+
+    return true
+  })
+
+  await state.commit(fixtures.entity)
+})
+
+describe('assignment', () => {
+  const changeset = { query: 'q', export: () => ({ foo: 1 }) }
+
+  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.deepStrictEqual(result, fixtures.storage.upsert.mock.calls[0].result)
+  })
+
+  it('should fill the state a storage without the outbox left alone', async () => {
+    await state.apply(changeset, { foo: 1 })
+
+    const row = fixtures.outbox.row.mock.calls[0].result
+
+    assert.deepStrictEqual(row.event.state, fixtures.storage.upsert.mock.calls[0].result)
+    assert.deepStrictEqual(row.event.input, { foo: 1 })
+  })
+})
+
+function resetCalls(target = [assert, fixtures], 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/test/transmission.fixtures.js

@@ -1,15 +1,13 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
 const binding = (index) => ({
-  request: jest.fn(async (request) => {
+  request: mock.fn(async (request) => {
     if (request?.pick !== undefined && request.pick !== index) return false
 
     return { output: generate() }
   })
 })
 
-const bindings = [0, 1, 2, 3, 4].map(binding)
-
-exports.bindings = bindings
+export const bindings = [0, 1, 2, 3, 4].map(binding)

package/test/transmission.test.js

@@ -1,16 +1,25 @@
-'use strict'
+import { it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-jest.mock('../src/connector')
+import { Connector } from '../source/connector.js'
 
-const { Connector } = require('../src/connector')
-const { Transmission } = require('../src/transmission')
-const { codes } = require('../src/exceptions')
-const fixtures = require('./transmission.fixtures')
+// 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 '../source/transmission.js'
+import { codes } from '../source/exceptions.js'
+import * as fixtures from './transmission.fixtures.js'
 
 let transmission
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  depends.mock.resetCalls()
 })
 
 beforeEach(() => {
@@ -18,29 +27,51 @@ beforeEach(() => {
 })
 
 it('should be instance of Connector depending on bindings', () => {
-  expect(transmission).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bindings)
+  assert.ok(transmission instanceof Connector)
+  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)
 
-  expect(fixtures.bindings[0].request).toHaveBeenCalledWith(request)
-  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
+  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)
 })
 
 it('should pick bindings sequentially', async () => {
   let result = await transmission.request()
-  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
+  assert.strictEqual(result, await fixtures.bindings[0].request.mock.calls[0].result)
 
   result = await transmission.request({ pick: 1 })
-  expect(result).toBe(await fixtures.bindings[1].request.mock.results[0]?.value)
+  assert.strictEqual(result, await fixtures.bindings[1].request.mock.calls[0]?.result)
 })
 
 it('should throw exception if none succeeded', async () => {
-  await expect(transmission.request({ pick: 5 })).rejects.toMatchObject({ code: codes.Transmission })
+  await assert.rejects(transmission.request({ pick: 5 }), (error) => {
+    assert.partialDeepStrictEqual(error, { code: codes.Transmission })
+    return true
+  })
 
-  fixtures.bindings.forEach((binding) =>
-    expect(binding.request).toHaveBeenCalled())
+  fixtures.bindings.forEach((binding) => assert.ok(binding.request.mock.callCount() > 0))
 })
+
+function resetCalls(
+  target = [assert, depends, dependencies, fixtures],
+  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/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

package/transpiled/cascade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade.js","sourceRoot":"","sources":["../source/cascade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG1C,MAAM,OAAO,OAAQ,SAAQ,SAAS;IAC3B,KAAK,CAAW;IAEzB,YAAmB,OAAoB,EAAE,SAAqB;QAC5D,KAAK,EAAE,CAAA;QAEP,0BAA0B;QAC1B,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAExC,IAAI,SAAS,KAAK,SAAS;YAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;;YAC7C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;IAC/C,CAAC;IAEM,KAAK,CAAC,GAAG,CAAC,GAAG,IAAiB;QACnC,mBAAmB;QACnB,EAAE;QACF,wCAAwC;QACxC,kDAAkD;QAClD,EAAE;QACF,uDAAuD;QACvD,EAAE;QACF,0BAA0B;QAC1B,IAAI;QACJ,EAAE;QACF,eAAe;QAEf,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;IACpC,CAAC;CACF"}

package/transpiled/component.d.ts

@@ -0,0 +1,15 @@
+import { Connector } from './connector.js';
+import type { Locator } from './locator.js';
+import type { Request } from './types/request.js';
+/** What a component holds one of per endpoint: an operation, or the call that stands for it. */
+export interface Invocable extends Connector {
+    invoke: (request: Request) => Promise<any>;
+}
+export declare class Component<O extends Invocable = Invocable> extends Connector {
+    #private;
+    readonly locator: Locator;
+    protected readonly operations: Record<string, O>;
+    protected kind: 'server' | 'client';
+    constructor(locator: Locator, operations: Record<string, O>);
+    invoke<T = any>(endpoint: string, request?: Request): Promise<T>;
+}

package/transpiled/component.js

@@ -0,0 +1,61 @@
+import assert from 'node:assert';
+import { console, current, decode, run } from 'openspan';
+import { Connector } from './connector.js';
+export class Component extends Connector {
+    locator;
+    operations;
+    kind = 'server';
+    /** span options per endpoint */
+    #spans = {};
+    constructor(locator, operations) {
+        super();
+        this.locator = locator;
+        this.operations = operations;
+        Object.values(operations).forEach((operation) => this.depends(operation));
+    }
+    async invoke(endpoint, request) {
+        if (!(endpoint in this.operations))
+            // `assert.fail`, not `assert.ok`: the message is built only when it is needed
+            assert.fail(`Endpoint '${endpoint}' is not provided by '${this.locator.id}'`);
+        // if the request carries no telemetry, the trace starts here
+        const remote = request?.telemetry === undefined ? null : decode(request.telemetry);
+        const task = async () => this.#process(endpoint, request);
+        if (remote === null)
+            return task();
+        else
+            return run(remote, task);
+    }
+    async #process(endpoint, request) {
+        return console.span(this.#span(endpoint), async () => {
+            const reply = await this.operations[endpoint].invoke(request);
+            if (reply?.exception !== undefined) {
+                const span = current();
+                if (span !== undefined)
+                    span.status = 'error';
+                console.error('Failed to execute operation', {
+                    endpoint: `${this.locator.id}.${endpoint}`,
+                    exception: reply.exception
+                });
+            }
+            return reply;
+        });
+    }
+    /**
+     * The span of an endpoint never changes, so it is built once. Not in the constructor:
+     * `kind` is a field of the subclass, and those are assigned after this one is built.
+     *
+     */
+    #span(endpoint) {
+        let options = this.#spans[endpoint];
+        if (options === undefined) {
+            options = { name: `${this.locator.id}.${endpoint}`, kind: this.kind };
+            // the server span is emitted by the component itself, while the client span
+            // belongs to the calling service and inherits it from the context
+            if (this.kind === 'server')
+                options.service = this.locator.id;
+            this.#spans[endpoint] = options;
+        }
+        return options;
+    }
+}
+//# sourceMappingURL=component.js.map

package/transpiled/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","sourceRoot":"","sources":["../source/component.ts"],"names":[],"mappings":"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"}

package/transpiled/composition.d.ts

@@ -0,0 +1,6 @@
+import { Connector } from './connector.js';
+export declare class Composition extends Connector {
+    constructor(expositions: Connector[], producers: Connector[], receivers: Connector[], tenants: Connector[]);
+    protected open(): Promise<void>;
+    protected dispose(): Promise<void>;
+}

package/transpiled/composition.js

@@ -0,0 +1,23 @@
+import { console } from 'openspan';
+import { Connector } from './connector.js';
+export class Composition extends Connector {
+    // eslint-disable-next-line max-params
+    constructor(expositions, producers, receivers, tenants) {
+        super();
+        if (expositions.length > 0)
+            this.depends(expositions);
+        if (producers.length > 0)
+            this.depends(producers);
+        if (receivers.length > 0)
+            this.depends(receivers);
+        if (tenants.length > 0)
+            this.depends(tenants);
+    }
+    async open() {
+        console.info('Composition complete');
+    }
+    async dispose() {
+        console.info('Composition shutdown complete');
+    }
+}
+//# sourceMappingURL=composition.js.map

package/transpiled/composition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.js","sourceRoot":"","sources":["../source/composition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,MAAM,OAAO,WAAY,SAAQ,SAAS;IACxC,sCAAsC;IACtC,YACE,WAAwB,EACxB,SAAsB,EACtB,SAAsB,EACtB,OAAoB;QAEpB,KAAK,EAAE,CAAA;QAEP,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;QACrD,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;QACjD,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;QACjD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IAC/C,CAAC;IAEkB,KAAK,CAAC,IAAI;QAC3B,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAA;IACtC,CAAC;IAEkB,KAAK,CAAC,OAAO;QAC9B,OAAO,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAA;IAC/C,CAAC;CACF"}

package/transpiled/connector.d.ts

@@ -0,0 +1,47 @@
+/** Abstract connections hierarchy */
+export declare class Connector {
+    #private;
+    readonly id: string;
+    connected: boolean;
+    constructor();
+    /**
+     * Creates a dependency and backlink with another Connector or a set of Connectors
+     *
+     * See .connect() and .disconnect()
+     *
+     */
+    depends(connector: Connector | Connector[]): Connector;
+    /**
+     * Creates a backlink to another Connector
+     *
+     * See .connect() and .disconnect()
+     *
+     */
+    link(connector: Connector): void;
+    /**
+     * Connects dependants then self
+     *
+     * In case of exception disconnects with current connection interruption
+     *
+     * Method is idempotent
+     *
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnects self then dependants
+     *
+     * Does nothing if there are connected linked Connectors
+     *
+     * Method is idempotent
+     *
+     */
+    disconnect(interrupt?: boolean): Promise<void>;
+    reconnect(): Promise<void>;
+    debug(node?: Record<string, any>): Record<string, any>;
+    /** Called on connection */
+    protected open(): Promise<void> | void;
+    /** Called on disconnection */
+    protected close(): Promise<void> | void;
+    /** Called after self and dependants disconnection is complete */
+    protected dispose(): Promise<void> | void;
+}