@olane/o-node 0.7.51 → 0.7.52

package/dist/test/helpers/stream-pool-test-helpers.js

@@ -1,229 +1,262 @@
-import { oNodeConnectionStream } from '../../src/connection/o-node-connection-stream.js';
-/**
- * Create a mock stream for testing
- */
-export function createMockStream(id = 'test-stream', options = {}) {
-    const stream = {
-        id,
-        status: options.status || 'open',
-        writeStatus: options.writeStatus || 'writable',
-        readStatus: options.readStatus || 'readable',
-        remoteReadStatus: options.remoteReadStatus || 'readable',
-        protocol: '/test/1.0.0',
-        direction: 'outbound',
-        timeline: { open: Date.now() },
-        source: [],
-        sink: async () => { },
-        close: async () => { },
-        closeRead: async () => { },
-        closeWrite: async () => { },
-        abort: async () => { },
-        reset: () => {
-            stream.status = 'reset';
-        },
-    };
-    return stream;
-}
-/**
- * Create a mock P2P connection for testing
- */
-export function createMockP2PConnection(id = 'test-connection', status = 'open') {
-    const streams = [];
-    return {
-        id,
-        status,
-        remotePeer: { toString: () => 'test-peer' },
-        streams: () => streams,
-        newStream: async (protocols) => {
-            const stream = createMockStream(`stream-${streams.length}`, {
-                status: 'open',
-            });
-            stream.protocol = protocols[0];
-            streams.push(stream);
-            return stream;
-        },
-        close: async () => {
-            status = 'closed';
-        },
-    };
-}
-/**
- * Create a mock StreamHandler for testing
- */
-export function createMockStreamHandler() {
-    const handler = {
-        handleIncomingStreamCalls: [],
-        handleOutgoingStreamCalls: [],
-        shouldFailIncoming: false,
-        shouldFailOutgoing: false,
-        incomingStreamPromise: null,
-        incomingStreamResolve: null,
-        handleIncomingStream: async (stream, connection, requestHandler) => {
-            handler.handleIncomingStreamCalls.push({
-                stream,
-                connection,
-                requestHandler,
-            });
-            if (handler.shouldFailIncoming) {
-                throw new Error('Mock incoming stream handler failure');
-            }
-            // Create a promise that can be externally resolved to simulate stream closure
-            return new Promise((resolve) => {
-                handler.incomingStreamResolve = resolve;
-            });
-        },
-        handleOutgoingStream: async (stream, emitter, config, requestHandler, requestId) => {
-            handler.handleOutgoingStreamCalls.push({
-                stream,
-                emitter,
-                config,
-                requestHandler,
-                requestId,
-            });
-            if (handler.shouldFailOutgoing) {
-                throw new Error('Mock outgoing stream handler failure');
-            }
-            return { result: { success: true, data: {} } };
-        },
-        // Helper to simulate stream closure/failure
-        simulateStreamClosure: () => {
-            if (handler.incomingStreamResolve) {
-                handler.incomingStreamResolve();
-                handler.incomingStreamResolve = null;
-            }
-        },
-        // Helper to simulate stream error
-        simulateStreamError: () => {
-            if (handler.incomingStreamResolve) {
-                // Reject the promise by throwing after a small delay
-                setTimeout(() => {
-                    throw new Error('Stream closed');
-                }, 10);
-            }
-        },
-    };
-    return handler;
-}
-/**
- * Create a mock oNodeConnectionStream
- */
-export function createMockConnectionStream(p2pStream, streamType = 'general') {
-    const mockP2PStream = p2pStream || createMockStream();
-    return new oNodeConnectionStream(mockP2PStream, {
-        direction: 'outbound',
-        reusePolicy: 'reuse',
-        remoteAddress: { toString: () => 'o://test' },
-        streamType,
-    });
-}
-/**
- * Factory for creating StreamPoolManager test config
- */
-export function createStreamPoolManagerConfig(overrides = {}) {
-    const mockP2PConnection = createMockP2PConnection();
-    const mockStreamHandler = createMockStreamHandler();
-    let streamCounter = 0;
-    const defaultConfig = {
-        poolSize: 10,
-        readerStreamIndex: 0,
-        streamHandler: mockStreamHandler,
-        p2pConnection: mockP2PConnection,
-        requestHandler: async (request, stream) => {
-            return { success: true, data: {} };
-        },
-        createStream: async () => {
-            const p2pStream = createMockStream(`stream-${streamCounter++}`);
-            return createMockConnectionStream(p2pStream, 'general');
-        },
-    };
-    return {
-        ...defaultConfig,
-        ...overrides,
-    };
-}
-/**
- * Event capture helper for testing event emissions
- */
-export class EventCapture {
-    constructor(emitter) {
-        this.emitter = emitter;
-        this.events = [];
-    }
-    /**
-     * Start capturing events
-     */
-    start(eventNames) {
-        for (const eventName of eventNames) {
-            this.emitter.on(eventName, (data) => {
-                this.events.push({
-                    type: eventName,
-                    data,
-                    timestamp: Date.now(),
-                });
-            });
-        }
-    }
-    /**
-     * Get all captured events
-     */
-    getEvents() {
-        return this.events;
-    }
-    /**
-     * Get events of specific type
-     */
-    getEventsByType(type) {
-        return this.events.filter((e) => e.type === type).map((e) => e.data);
-    }
-    /**
-     * Check if event was emitted
-     */
-    hasEvent(type) {
-        return this.events.some((e) => e.type === type);
-    }
-    /**
-     * Get count of specific event type
-     */
-    getEventCount(type) {
-        return this.events.filter((e) => e.type === type).length;
-    }
-    /**
-     * Wait for specific event
-     */
-    async waitForEvent(type, timeoutMs = 5000) {
-        const startTime = Date.now();
-        while (Date.now() - startTime < timeoutMs) {
-            const event = this.events.find((e) => e.type === type);
-            if (event) {
-                return event.data;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 10));
-        }
-        throw new Error(`Timeout waiting for event: ${type}`);
-    }
-    /**
-     * Clear captured events
-     */
-    clear() {
-        this.events = [];
-    }
-}
-/**
- * Helper to make a stream invalid
- */
-export function makeStreamInvalid(stream) {
-    stream.p2pStream.status = 'closed';
-    stream.p2pStream.writeStatus = 'closed';
-}
-/**
- * Helper to wait for condition with timeout
- */
-export async function waitFor(condition, timeoutMs = 5000, intervalMs = 10) {
-    const startTime = Date.now();
-    while (!condition()) {
-        if (Date.now() - startTime > timeoutMs) {
-            throw new Error('Timeout waiting for condition');
-        }
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-}
+"use strict";
+// import type { Connection } from '@libp2p/interface';
+// import type { Stream } from '@olane/o-config';
+// import { oRequest } from '@olane/o-core';
+// import { StreamHandler } from '../../src/connection/stream-handler.js';
+// import { oNodeConnectionStream } from '../../src/connection/o-node-connection-stream.js';
+// import { StreamPoolManagerConfig } from '../../src/index.js';
+// /**
+//  * Create a mock stream for testing
+//  */
+// export function createMockStream(
+//   id: string = 'test-stream',
+//   options: {
+//     status?: 'open' | 'closed' | 'reset';
+//     writeStatus?: 'writable' | 'writing' | 'closed';
+//     readStatus?: 'readable' | 'reading' | 'closed';
+//     remoteReadStatus?: 'readable' | 'reading' | 'closed';
+//   } = {},
+// ): any {
+//   const stream = {
+//     id,
+//     status: options.status || 'open',
+//     writeStatus: options.writeStatus || 'writable',
+//     readStatus: options.readStatus || 'readable',
+//     remoteReadStatus: options.remoteReadStatus || 'readable',
+//     protocol: '/test/1.0.0',
+//     direction: 'outbound',
+//     timeline: { open: Date.now() },
+//     source: [],
+//     sink: async () => {},
+//     close: async () => {},
+//     closeRead: async () => {},
+//     closeWrite: async () => {},
+//     abort: async () => {},
+//     reset: () => {
+//       stream.status = 'reset';
+//     },
+//   };
+//   return stream;
+// }
+// /**
+//  * Create a mock P2P connection for testing
+//  */
+// export function createMockP2PConnection(
+//   id: string = 'test-connection',
+//   status: 'open' | 'closed' = 'open',
+// ): any {
+//   const streams: any[] = [];
+//   return {
+//     id,
+//     status,
+//     remotePeer: { toString: () => 'test-peer' },
+//     streams: () => streams,
+//     newStream: async (protocols: string[]) => {
+//       const stream = createMockStream(`stream-${streams.length}`, {
+//         status: 'open',
+//       });
+//       stream.protocol = protocols[0];
+//       streams.push(stream);
+//       return stream;
+//     },
+//     close: async () => {
+//       status = 'closed';
+//     },
+//   };
+// }
+// /**
+//  * Create a mock StreamHandler for testing
+//  */
+// export function createMockStreamHandler(): any {
+//   const handler = {
+//     handleIncomingStreamCalls: [] as any[],
+//     handleOutgoingStreamCalls: [] as any[],
+//     shouldFailIncoming: false,
+//     shouldFailOutgoing: false,
+//     incomingStreamPromise: null as Promise<void> | null,
+//     incomingStreamResolve: null as (() => void) | null,
+//     handleIncomingStream: async (
+//       stream: Stream,
+//       connection: Connection,
+//       requestHandler: (request: oRequest, stream: Stream) => Promise<any>,
+//     ): Promise<void> => {
+//       handler.handleIncomingStreamCalls.push({
+//         stream,
+//         connection,
+//         requestHandler,
+//       });
+//       if (handler.shouldFailIncoming) {
+//         throw new Error('Mock incoming stream handler failure');
+//       }
+//       // Create a promise that can be externally resolved to simulate stream closure
+//       return new Promise((resolve) => {
+//         handler.incomingStreamResolve = resolve;
+//       });
+//     },
+//     handleOutgoingStream: async (
+//       stream: Stream,
+//       emitter: any,
+//       config: any,
+//       requestHandler?: any,
+//       requestId?: string | number,
+//     ): Promise<any> => {
+//       handler.handleOutgoingStreamCalls.push({
+//         stream,
+//         emitter,
+//         config,
+//         requestHandler,
+//         requestId,
+//       });
+//       if (handler.shouldFailOutgoing) {
+//         throw new Error('Mock outgoing stream handler failure');
+//       }
+//       return { result: { success: true, data: {} } };
+//     },
+//     // Helper to simulate stream closure/failure
+//     simulateStreamClosure: () => {
+//       if (handler.incomingStreamResolve) {
+//         handler.incomingStreamResolve();
+//         handler.incomingStreamResolve = null;
+//       }
+//     },
+//     // Helper to simulate stream error
+//     simulateStreamError: () => {
+//       if (handler.incomingStreamResolve) {
+//         // Reject the promise by throwing after a small delay
+//         setTimeout(() => {
+//           throw new Error('Stream closed');
+//         }, 10);
+//       }
+//     },
+//   };
+//   return handler;
+// }
+// /**
+//  * Create a mock oNodeConnectionStream
+//  */
+// export function createMockConnectionStream(
+//   p2pStream?: any,
+//   streamType: 'dedicated-reader' | 'request-response' | 'general' = 'general',
+// ): oNodeConnectionStream {
+//   const mockP2PStream = p2pStream || createMockStream();
+//   return new oNodeConnectionStream(mockP2PStream, {
+//     direction: 'outbound',
+//     reusePolicy: 'reuse',
+//     remoteAddress: { toString: () => 'o://test' } as any,
+//     streamType,
+//   });
+// }
+// /**
+//  * Factory for creating StreamPoolManager test config
+//  */
+// export function createStreamPoolManagerConfig(
+//   overrides: Partial<StreamPoolManagerConfig> = {},
+// ): StreamPoolManagerConfig {
+//   const mockP2PConnection = createMockP2PConnection();
+//   const mockStreamHandler = createMockStreamHandler();
+//   let streamCounter = 0;
+//   const defaultConfig: StreamPoolManagerConfig = {
+//     readerStreamIndex: 0,
+//     streamHandler: mockStreamHandler,
+//     p2pConnection: mockP2PConnection,
+//     requestHandler: async (request: oRequest, stream: Stream) => {
+//       return { success: true, data: {} };
+//     },
+//     createStream: async () => {
+//       const p2pStream = createMockStream(`stream-${streamCounter++}`);
+//       return createMockConnectionStream(p2pStream, 'general');
+//     },
+//   };
+//   return {
+//     ...defaultConfig,
+//     ...overrides,
+//   };
+// }
+// /**
+//  * Event capture helper for testing event emissions
+//  */
+// export class EventCapture {
+//   private events: Array<{ type: string; data: any; timestamp: number }> = [];
+//   constructor(private emitter: any) {}
+//   /**
+//    * Start capturing events
+//    */
+//   start(eventNames: string[]): void {
+//     for (const eventName of eventNames) {
+//       this.emitter.on(eventName, (data: any) => {
+//         this.events.push({
+//           type: eventName,
+//           data,
+//           timestamp: Date.now(),
+//         });
+//       });
+//     }
+//   }
+//   /**
+//    * Get all captured events
+//    */
+//   getEvents(): Array<{ type: string; data: any; timestamp: number }> {
+//     return this.events;
+//   }
+//   /**
+//    * Get events of specific type
+//    */
+//   getEventsByType(type: string): any[] {
+//     return this.events.filter((e) => e.type === type).map((e) => e.data);
+//   }
+//   /**
+//    * Check if event was emitted
+//    */
+//   hasEvent(type: string): boolean {
+//     return this.events.some((e) => e.type === type);
+//   }
+//   /**
+//    * Get count of specific event type
+//    */
+//   getEventCount(type: string): number {
+//     return this.events.filter((e) => e.type === type).length;
+//   }
+//   /**
+//    * Wait for specific event
+//    */
+//   async waitForEvent(type: string, timeoutMs: number = 5000): Promise<any> {
+//     const startTime = Date.now();
+//     while (Date.now() - startTime < timeoutMs) {
+//       const event = this.events.find((e) => e.type === type);
+//       if (event) {
+//         return event.data;
+//       }
+//       await new Promise((resolve) => setTimeout(resolve, 10));
+//     }
+//     throw new Error(`Timeout waiting for event: ${type}`);
+//   }
+//   /**
+//    * Clear captured events
+//    */
+//   clear(): void {
+//     this.events = [];
+//   }
+// }
+// /**
+//  * Helper to make a stream invalid
+//  */
+// export function makeStreamInvalid(stream: any): void {
+//   stream.p2pStream.status = 'closed';
+//   stream.p2pStream.writeStatus = 'closed';
+// }
+// /**
+//  * Helper to wait for condition with timeout
+//  */
+// export async function waitFor(
+//   condition: () => boolean,
+//   timeoutMs: number = 5000,
+//   intervalMs: number = 10,
+// ): Promise<void> {
+//   const startTime = Date.now();
+//   while (!condition()) {
+//     if (Date.now() - startTime > timeoutMs) {
+//       throw new Error('Timeout waiting for condition');
+//     }
+//     await new Promise((resolve) => setTimeout(resolve, intervalMs));
+//   }
+// }

package/dist/test/parent-child-registration.spec.js

@@ -13,6 +13,7 @@ describe('Parent-Child Registration', () => {
     });
     describe('Basic Registration', () => {
         it('should register child with parent during startup', async () => {
+            console.log('Starting Basic Registration Test');
             builder = new NetworkBuilder();
             const leader = await builder.addNode('o://leader');
             await builder.startNode('o://leader');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.51",
+  "version": "0.7.52",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -40,7 +40,7 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
-    "@olane/o-test": "0.7.51",
+    "@olane/o-test": "0.7.52",
     "@tsconfig/node20": "^20.1.6",
     "@types/jest": "^30.0.0",
     "@types/json5": "^2.2.0",
@@ -60,13 +60,13 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.51",
-    "@olane/o-core": "0.7.51",
-    "@olane/o-protocol": "0.7.51",
-    "@olane/o-tool": "0.7.51",
+    "@olane/o-config": "0.7.52",
+    "@olane/o-core": "0.7.52",
+    "@olane/o-protocol": "0.7.52",
+    "@olane/o-tool": "0.7.52",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0",
     "json5": "^2.2.3"
   },
-  "gitHead": "f770a110369cb9791d9e9208c7a084feecbb9b2c"
+  "gitHead": "706ee0d5b546e96b6c05270b39035ee7e08dadbd"
 }

package/dist/src/connection/interfaces/o-node-connection-stream.config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"o-node-connection-stream.config.d.ts","sourceRoot":"","sources":["../../../../src/connection/interfaces/o-node-connection-stream.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,kBAAkB,GAAG,kBAAkB,GAAG,SAAS,CAAC;AAE7E,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,SAAS,GAAG,UAAU,CAAC;IAClC,WAAW,EAAE,iBAAiB,CAAC;IAC/B,aAAa,EAAE,QAAQ,CAAC;IACxB,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB"}

package/dist/src/connection/interfaces/stream-pool-manager.config.d.ts

@@ -1,41 +0,0 @@
-import type { Connection } from '@libp2p/interface';
-import { oRequest } from '@olane/o-core';
-import type { Stream } from '@olane/o-config';
-import type { oNodeConnectionStream } from '../o-node-connection-stream.js';
-import type { StreamHandler } from '../stream-handler.js';
-export interface StreamPoolManagerConfig {
-    /**
-     * Pool size (total number of streams to maintain)
-     * Default: 10 (1 dedicated reader + 9 request-response)
-     */
-    poolSize?: number;
-    /**
-     * Index of the dedicated reader stream in the pool
-     * Default: 0
-     */
-    readerStreamIndex?: number;
-    /**
-     * Stream handler for managing stream communication
-     */
-    streamHandler: StreamHandler;
-    /**
-     * P2P connection for creating streams
-     */
-    p2pConnection: Connection;
-    /**
-     * Request handler for incoming requests on the dedicated reader
-     */
-    requestHandler?: (request: oRequest, stream: Stream) => Promise<any>;
-    /**
-     * Function to create a new stream
-     */
-    createStream: () => Promise<oNodeConnectionStream>;
-}
-export interface StreamPoolStats {
-    totalStreams: number;
-    healthyStreams: number;
-    readerStreamHealth: 'healthy' | 'unhealthy' | 'not-initialized';
-    requestResponseStreams: number;
-    failureCount: number;
-}
-//# sourceMappingURL=stream-pool-manager.config.d.ts.map

package/dist/src/connection/interfaces/stream-pool-manager.config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-pool-manager.config.d.ts","sourceRoot":"","sources":["../../../../src/connection/interfaces/stream-pool-manager.config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,aAAa,EAAE,aAAa,CAAC;IAE7B;;OAEG;IACH,aAAa,EAAE,UAAU,CAAC;IAE1B;;OAEG;IACH,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAErE;;OAEG;IACH,YAAY,EAAE,MAAM,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,SAAS,GAAG,WAAW,GAAG,iBAAiB,CAAC;IAChE,sBAAsB,EAAE,MAAM,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;CACtB"}

package/dist/src/connection/o-node-connection-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"o-node-connection-stream.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAuB,OAAO,EAAiB,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,iDAAiD,CAAC;AAE9F;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,OAAO;aAI9B,SAAS,EAAE,MAAM;aACjB,MAAM,EAAE,2BAA2B;IAJrD,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAGhB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,2BAA2B;IAOrD,QAAQ;IA6BR;;;;;;;OAOG;IACH,IAAI,OAAO,IAAI,OAAO,CAMrB;IAED;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAgB7B"}