@olane/o-client-limited 0.7.51 → 0.7.53

package/dist/test/bidirectional-communication.spec.js

@@ -0,0 +1,265 @@
+import { expect } from 'chai';
+import { TestEnvironment, createConnectionSpy, } from '@olane/o-node/test/helpers';
+import { oNodeAddress } from '@olane/o-node';
+import { LimitedTestTool, ReceiverTestTool } from './helpers/index.js';
+describe('Bidirectional Communication', () => {
+    const env = new TestEnvironment();
+    let caller;
+    let receiver;
+    afterEach(async () => {
+        await env.cleanup();
+    });
+    describe('Caller → Receiver', () => {
+        it('should send request and receive response', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const response = await caller.use(new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'hello-receiver' },
+            });
+            expect(response.result.success).to.be.true;
+            expect(response.result.data.message).to.equal('hello-receiver');
+            expect(receiver.receivedRequests).to.have.lengthOf(1);
+        });
+        it('should handle multiple sequential requests', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            for (let i = 0; i < 5; i++) {
+                const response = await caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: `request-${i}` },
+                });
+                expect(response.result.success).to.be.true;
+                expect(response.result.data.message).to.equal(`request-${i}`);
+            }
+            expect(receiver.receivedRequests).to.have.lengthOf(5);
+        });
+    });
+    describe('Receiver → Caller', () => {
+        it('should send request via reader stream and receive response', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // First: Caller establishes connection (creates reader stream)
+            const initialResponse = await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'initial' },
+            });
+            expect(initialResponse.result.success).to.be.true;
+            // Set up event listeners on both sides
+            const callerConn = caller.getFirstConnection();
+            const receiverConn = receiver.getFirstConnection();
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            // if (callerConn) {
+            //   caller.setupEventListeners(callerConn);
+            // }
+            // if (receiverConn) {
+            //   receiver.setupStreamListeners(receiverConn);
+            // }
+            // // Wait for receiver to identify reader stream
+            // await env.waitFor(() => receiver.identifiedStreams.length > 0, 5000, 100);
+            // expect(receiver.identifiedStreams).to.have.lengthOf(1);
+            // expect(receiver.identifiedStreams[0].role).to.equal('reader');
+            // Now: Receiver calls back to caller
+            const callerAddr = new oNodeAddress(caller.address.toString(), caller.address.libp2pTransports);
+            const response = await receiver.use(callerAddr, {
+                method: 'echo',
+                params: { message: 'hello-caller' },
+            });
+            console.log('Response from caller:', response);
+            expect(response.result.success).to.be.true;
+            expect(response.result.data.message).to.equal('hello-caller');
+            expect(caller.callCount).to.equal(1); // Only the reverse call
+        });
+        it('should handle request via tool method that calls caller', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Establish connection
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'initial' },
+            });
+            // Set up event listeners
+            // const callerConn = caller.getFirstConnection();
+            // const receiverConn = receiver.getFirstConnection();
+            // if (callerConn) {
+            //   caller.setupEventListeners(callerConn);
+            // }
+            // if (receiverConn) {
+            //   receiver.setupStreamListeners(receiverConn);
+            // }
+            // // Wait for reader stream identification
+            // await env.waitFor(() => receiver.identifiedStreams.length > 0, 5000, 100);
+            // Caller calls receiver method that will call back to caller
+            const callerAddr = new oNodeAddress(caller.address.toString(), caller.address.libp2pTransports);
+            const response = await receiver.use(receiverAddr, {
+                method: 'call_caller',
+                params: { callerAddress: callerAddr },
+            });
+            expect(response.result.success).to.be.true;
+            expect(response.result.data.callerResponse.data.message).to.equal('from-receiver');
+        });
+    });
+    describe('Concurrent Bidirectional', () => {
+        it('should handle multiple concurrent bidirectional requests', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            const callerAddr = new oNodeAddress(caller.address.toString(), caller.address.libp2pTransports);
+            // Establish connection
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'initial' },
+            });
+            // Set up event listeners
+            // const callerConn = caller.getFirstConnection();
+            // const receiverConn = receiver.getFirstConnection();
+            // if (callerConn) {
+            //   caller.setupEventListeners(callerConn);
+            // }
+            // if (receiverConn) {
+            //   receiver.setupStreamListeners(receiverConn);
+            // }
+            // // Wait for reader stream identification
+            // await env.waitFor(() => receiver.identifiedStreams.length > 0, 5000, 100);
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            console.log('Starting concurrent bidirectional requests');
+            // Concurrent bidirectional requests
+            const promises = [];
+            // Caller → Receiver
+            // for (let i = 0; i < 5; i++) {
+            //   promises.push(
+            //     caller.use(receiverAddr, {
+            //       method: 'echo',
+            //       params: { message: `c2r-${i}` },
+            //     }),
+            //   );
+            // }
+            // Receiver → Caller
+            for (let i = 0; i < 5; i++) {
+                promises.push(receiver.use(callerAddr, {
+                    method: 'echo',
+                    params: { message: `r2c-${i}` },
+                }));
+            }
+            const responses = await Promise.all(promises);
+            responses.forEach((response) => {
+                expect(response.result.success).to.be.true;
+            });
+            // Verify request counts
+            expect(caller.callCount).to.equal(5); // 5 from receiver
+            expect(receiver.receivedRequests).to.have.lengthOf(6); // 5 from caller + 1 initial
+        });
+    });
+    describe('Stream Reuse Verification', () => {
+        it('should reuse outbound streams for multiple requests', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            const spy = createConnectionSpy(caller);
+            spy.start();
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            // Multiple requests should use same stream
+            for (let i = 0; i < 10; i++) {
+                await caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: `test-${i}` },
+                });
+            }
+            const stats = spy.getConnectionStats();
+            // Should have created connection
+            expect(stats.length).to.be.greaterThan(0);
+            // Should have limited number of streams (reader + outbound, reused)
+            const streamCount = stats.reduce((sum, conn) => sum + (conn.streams?.length || 0), 0);
+            // With reuse, stream count should be much less than request count
+            expect(streamCount).to.be.lessThan(10);
+            expect(receiver.receivedRequests).to.have.lengthOf(10);
+            spy.stop();
+        });
+        it('should maintain single connection across many requests', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            const spy = createConnectionSpy(caller);
+            spy.start();
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            // Make multiple requests
+            for (let i = 0; i < 20; i++) {
+                await caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: `request-${i}` },
+                });
+            }
+            // Should only have 1 connection
+            const summary = spy.getSummary();
+            expect(summary.currentConnections).to.equal(1);
+            expect(receiver.receivedRequests).to.have.lengthOf(20);
+            spy.stop();
+        });
+    });
+    describe('Reader Stream Identification', () => {
+        it('should create and identify reader stream', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Make initial connection
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            // Set up event listeners
+            const callerConn = caller.getFirstConnection();
+            const receiverConn = receiver.getFirstConnection();
+            if (callerConn) {
+                caller.setupEventListeners(callerConn);
+            }
+            if (receiverConn) {
+                receiver.setupStreamListeners(receiverConn);
+            }
+            // Wait a bit for events to propagate
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            // Verify reader stream was created on caller side
+            const readerEvents = caller.getReaderEvents();
+            expect(readerEvents.length).to.be.greaterThan(0);
+            const readerStarted = readerEvents.find((e) => e.type === 'reader-started');
+            expect(readerStarted).to.exist;
+            // Verify receiver identified the reader stream
+            expect(receiver.identifiedStreams.length).to.be.greaterThan(0);
+            expect(receiver.identifiedStreams[0].role).to.equal('reader');
+        });
+    });
+});

package/dist/test/helpers/index.d.ts

@@ -1,4 +1,3 @@
-export { MockStream, createMockStream, createMockStreams, } from './mock-stream.js';
-export { MockP2PConnection, createMockP2PConnection, } from './mock-p2p-connection.js';
-export { MockStreamHandler, createMockStreamHandler, } from './mock-stream-handler.js';
+export { LimitedTestTool } from './limited-test-tool.js';
+export { ReceiverTestTool } from './receiver-test-tool.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/test/helpers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../test/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../test/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/test/helpers/index.js

@@ -1,3 +1,2 @@
-export { MockStream, createMockStream, createMockStreams, } from './mock-stream.js';
-export { MockP2PConnection, createMockP2PConnection, } from './mock-p2p-connection.js';
-export { MockStreamHandler, createMockStreamHandler, } from './mock-stream-handler.js';
+export { LimitedTestTool } from './limited-test-tool.js';
+export { ReceiverTestTool } from './receiver-test-tool.js';

package/dist/test/helpers/limited-test-tool.d.ts

@@ -0,0 +1,41 @@
+import type { oRequest } from '@olane/o-core';
+import { oLimitedTool } from '../../src/o-limited.tool.js';
+/**
+ * Test tool that uses limited connections
+ * Tracks events and call counts for verification
+ */
+export declare class LimitedTestTool extends oLimitedTool {
+    callCount: number;
+    streamManagerEvents: Array<{
+        type: string;
+        data: any;
+    }>;
+    private eventListenersSetup;
+    initialize(): Promise<void>;
+    /**
+     * Set up event listeners for stream manager events
+     * Call this after first connection is established
+     */
+    setupEventListeners(connection: any): void;
+    /**
+     * Simple echo method
+     */
+    _tool_echo(request: oRequest): Promise<any>;
+    /**
+     * Method that calls back to the requester
+     * Used to test bidirectional communication
+     */
+    _tool_reverse_echo(request: oRequest): Promise<any>;
+    /**
+     * Get all reader-related events
+     */
+    getReaderEvents(): Array<{
+        type: string;
+        data: any;
+    }>;
+    /**
+     * Get the first connection (for accessing stream manager)
+     */
+    getFirstConnection(): any;
+}
+//# sourceMappingURL=limited-test-tool.d.ts.map

package/dist/test/helpers/limited-test-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limited-test-tool.d.ts","sourceRoot":"","sources":["../../../test/helpers/limited-test-tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;IACxC,SAAS,SAAK;IACd,mBAAmB,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,CAAC,CAAM;IACpE,OAAO,CAAC,mBAAmB,CAAS;IAE9B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC;;;OAGG;IACH,mBAAmB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAiD1C;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAUjD;;;OAGG;IACG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAczD;;OAEG;IACH,eAAe,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,CAAC;IAIrD;;OAEG;IACH,kBAAkB,IAAI,GAAG;CAO1B"}

package/dist/test/helpers/limited-test-tool.js

@@ -0,0 +1,98 @@
+import { oLimitedConnectionManager } from '../../src/connection/o-limited-connection-manager.js';
+import { StreamManagerEvent } from '@olane/o-node';
+import { oLimitedTool } from '../../src/o-limited.tool.js';
+/**
+ * Test tool that uses limited connections
+ * Tracks events and call counts for verification
+ */
+export class LimitedTestTool extends oLimitedTool {
+    constructor() {
+        super(...arguments);
+        this.callCount = 0;
+        this.streamManagerEvents = [];
+        this.eventListenersSetup = false;
+    }
+    async initialize() {
+        await super.initialize();
+        // Use limited connection manager
+        this.connectionManager = new oLimitedConnectionManager({
+            p2pNode: this.p2pNode,
+            runOnLimitedConnection: true,
+        });
+    }
+    /**
+     * Set up event listeners for stream manager events
+     * Call this after first connection is established
+     */
+    setupEventListeners(connection) {
+        if (this.eventListenersSetup || !connection?.streamManager) {
+            return;
+        }
+        this.eventListenersSetup = true;
+        // Listen to all stream manager events
+        connection.streamManager.on(StreamManagerEvent.ReaderStarted, (data) => {
+            this.streamManagerEvents.push({
+                type: 'reader-started',
+                data,
+            });
+        });
+        connection.streamManager.on(StreamManagerEvent.ReaderFailed, (data) => {
+            this.streamManagerEvents.push({
+                type: 'reader-failed',
+                data,
+            });
+        });
+        connection.streamManager.on(StreamManagerEvent.ReaderRecovered, (data) => {
+            this.streamManagerEvents.push({
+                type: 'reader-recovered',
+                data,
+            });
+        });
+        connection.streamManager.on(StreamManagerEvent.StreamIdentified, (data) => {
+            this.streamManagerEvents.push({
+                type: 'stream-identified',
+                data,
+            });
+        });
+    }
+    /**
+     * Simple echo method
+     */
+    async _tool_echo(request) {
+        this.callCount++;
+        return {
+            message: request.params.message,
+            nodeAddress: this.address.toString(),
+            callCount: this.callCount,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Method that calls back to the requester
+     * Used to test bidirectional communication
+     */
+    async _tool_reverse_echo(request) {
+        const callerAddress = request.params.callerAddress;
+        const response = await this.use(callerAddress, {
+            method: 'echo',
+            params: { message: 'reverse-response' },
+        });
+        return {
+            original: request.params.message,
+            reversed: response.result,
+        };
+    }
+    /**
+     * Get all reader-related events
+     */
+    getReaderEvents() {
+        return this.streamManagerEvents.filter((e) => e.type.includes('reader'));
+    }
+    /**
+     * Get the first connection (for accessing stream manager)
+     */
+    getFirstConnection() {
+        const firstEntry = Array.from(this.connectionManager?.cachedConnections?.values() || []);
+        return firstEntry?.[0];
+    }
+}

package/dist/test/helpers/receiver-test-tool.d.ts

@@ -0,0 +1,34 @@
+import { oNodeTool } from '@olane/o-node';
+import type { oRequest } from '@olane/o-core';
+/**
+ * Standard receiver tool (uses base connection manager)
+ * Tracks received requests and identified streams
+ */
+export declare class ReceiverTestTool extends oNodeTool {
+    receivedRequests: oRequest[];
+    identifiedStreams: Array<{
+        streamId: string;
+        role: string;
+    }>;
+    private eventListenersSetup;
+    constructor(config: any);
+    /**
+     * Set up event listeners for stream identification
+     * Call this after tool is started
+     */
+    setupStreamListeners(connection: any): void;
+    /**
+     * Simple echo method
+     */
+    _tool_echo(request: oRequest): Promise<any>;
+    /**
+     * Method that calls back to the caller
+     * Tests receiver → caller communication
+     */
+    _tool_call_caller(request: oRequest): Promise<any>;
+    /**
+     * Get the first connection (for accessing stream manager)
+     */
+    getFirstConnection(): any;
+}
+//# sourceMappingURL=receiver-test-tool.d.ts.map

package/dist/test/helpers/receiver-test-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receiver-test-tool.d.ts","sourceRoot":"","sources":["../../../test/helpers/receiver-test-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI9C;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IACtC,gBAAgB,EAAE,QAAQ,EAAE,CAAM;IAClC,iBAAiB,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAM;IACzE,OAAO,CAAC,mBAAmB,CAAS;gBAExB,MAAM,EAAE,GAAG;IAIvB;;;OAGG;IACH,oBAAoB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAmB3C;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAUjD;;;OAGG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAiBxD;;OAEG;IACH,kBAAkB,IAAI,GAAG;CAM1B"}

package/dist/test/helpers/receiver-test-tool.js

@@ -0,0 +1,67 @@
+import { oNodeTool } from '@olane/o-node';
+import { StreamManagerEvent } from '@olane/o-node';
+/**
+ * Standard receiver tool (uses base connection manager)
+ * Tracks received requests and identified streams
+ */
+export class ReceiverTestTool extends oNodeTool {
+    constructor(config) {
+        super(config);
+        this.receivedRequests = [];
+        this.identifiedStreams = [];
+        this.eventListenersSetup = false;
+    }
+    /**
+     * Set up event listeners for stream identification
+     * Call this after tool is started
+     */
+    setupStreamListeners(connection) {
+        if (this.eventListenersSetup || !connection?.streamManager) {
+            return;
+        }
+        this.eventListenersSetup = true;
+        // Listen for stream identification events
+        connection.streamManager.on(StreamManagerEvent.StreamIdentified, (data) => {
+            this.identifiedStreams.push({
+                streamId: data.streamId,
+                role: data.role,
+            });
+        });
+    }
+    /**
+     * Simple echo method
+     */
+    async _tool_echo(request) {
+        this.receivedRequests.push(request);
+        return {
+            message: request.params.message,
+            nodeAddress: this.address.toString(),
+            requestCount: this.receivedRequests.length,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Method that calls back to the caller
+     * Tests receiver → caller communication
+     */
+    async _tool_call_caller(request) {
+        this.receivedRequests.push(request);
+        const callerAddress = request.params.callerAddress;
+        // Call back to the caller
+        const response = await this.use(callerAddress, {
+            method: 'echo',
+            params: { message: 'from-receiver' },
+        });
+        return {
+            callerResponse: response.result,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Get the first connection (for accessing stream manager)
+     */
+    getFirstConnection() {
+        const firstEntry = Array.from(this.connectionManager?.cachedConnections?.values() || []);
+        return firstEntry?.[0];
+    }
+}

package/dist/test/limited-connection-lifecycle.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=limited-connection-lifecycle.spec.d.ts.map

package/dist/test/limited-connection-lifecycle.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limited-connection-lifecycle.spec.d.ts","sourceRoot":"","sources":["../../test/limited-connection-lifecycle.spec.ts"],"names":[],"mappings":""}