@olane/o-node 0.7.12-alpha.21 → 0.7.12-alpha.23

package/dist/o-node/src/utils/leader-request-wrapper.test.js

@@ -0,0 +1,246 @@
+"use strict";
+// import { expect } from 'chai';
+// import { LeaderRequestWrapper } from './leader-request-wrapper.js';
+// import { oAddress } from '@olane/o-core';
+// import { CircuitState } from './circuit-breaker.js';
+// describe('LeaderRequestWrapper with Circuit Breaker', () => {
+//   let wrapper: LeaderRequestWrapper;
+//   const leaderAddress = new oAddress('o://leader');
+//   const registryAddress = new oAddress('o://registry');
+//   const regularAddress = new oAddress('o://some-service');
+//   beforeEach(() => {
+//     wrapper = new LeaderRequestWrapper({
+//       enabled: true,
+//       maxAttempts: 5,
+//       baseDelayMs: 10,
+//       maxDelayMs: 100,
+//       timeoutMs: 1000,
+//       circuitBreaker: {
+//         enabled: true,
+//         failureThreshold: 3,
+//         openTimeoutMs: 500,
+//         halfOpenMaxAttempts: 1,
+//       },
+//     });
+//   });
+//   describe('Circuit Breaker Integration', () => {
+//     it('should execute request successfully and record success', async () => {
+//       const mockRequest = vi.fn().mockResolvedValue('success');
+//       const result = await wrapper.execute(mockRequest, leaderAddress);
+//       expect(result).toBe('success');
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalSuccesses).toBe(1);
+//       expect(stats.leader.state).toBe(CircuitState.CLOSED);
+//     });
+//     it('should record failures in circuit breaker', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBeGreaterThan(0);
+//       expect(stats.leader.consecutiveFailures).toBeGreaterThan(0);
+//     });
+//     it('should open circuit after threshold failures', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // Attempt request multiple times to trigger circuit breaker
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.state).toBe(CircuitState.OPEN);
+//     });
+//     it('should fast-fail when circuit is open', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // First request to open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Reset mock to verify it's not called
+//       mockRequest.mockClear();
+//       // Second request should fast-fail
+//       await expect(wrapper.execute(mockRequest, leaderAddress)).rejects.toThrow(
+//         /Circuit breaker is OPEN/,
+//       );
+//       // Request function should not have been called
+//       expect(mockRequest).not.toHaveBeenCalled();
+//     });
+//     it('should stop retrying when circuit opens mid-retry', async () => {
+//       let callCount = 0;
+//       const mockRequest = vi.fn().mockImplementation(() => {
+//         callCount++;
+//         throw new Error('Service down');
+//       });
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Should have stopped retrying after circuit opened
+//       expect(callCount).toBeLessThan(5); // Less than maxAttempts
+//       expect(callCount).toBeGreaterThanOrEqual(3); // At least threshold attempts
+//     });
+//     it('should track separate circuits for leader and registry', async () => {
+//       const failingRequest = vi
+//         .fn()
+//         .mockRejectedValue(new Error('Service down'));
+//       // Fail leader requests
+//       await expect(
+//         wrapper.execute(failingRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.state).toBe(CircuitState.OPEN);
+//       expect(stats.registry.state).toBe(CircuitState.CLOSED);
+//     });
+//     it('should allow recovery after timeout in HALF_OPEN state', async () => {
+//       const mockRequest = vi
+//         .fn()
+//         .mockRejectedValueOnce(new Error('Service down'))
+//         .mockResolvedValue('recovered');
+//       // Open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.OPEN,
+//       );
+//       // Wait for circuit to attempt recovery
+//       await new Promise((resolve) => setTimeout(resolve, 600));
+//       // Should succeed and close circuit
+//       const result = await wrapper.execute(mockRequest, leaderAddress);
+//       expect(result).toBe('recovered');
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//     });
+//   });
+//   describe('Non-Leader Addresses', () => {
+//     it('should not use circuit breaker for non-leader addresses', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       await expect(
+//         wrapper.execute(mockRequest, regularAddress),
+//       ).rejects.toThrow('Service down');
+//       // Should execute directly without retry
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//       // Should not affect circuit breaker stats
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBe(0);
+//       expect(stats.registry.totalFailures).toBe(0);
+//     });
+//     it('should execute successful requests directly', async () => {
+//       const mockRequest = vi.fn().mockResolvedValue('success');
+//       const result = await wrapper.execute(mockRequest, regularAddress);
+//       expect(result).toBe('success');
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//     });
+//   });
+//   describe('Timeout Handling', () => {
+//     it('should timeout long-running requests', async () => {
+//       const longRequest = vi.fn().mockImplementation(
+//         () =>
+//           new Promise((resolve) => {
+//             setTimeout(() => resolve('too-late'), 2000);
+//           }),
+//       );
+//       await expect(wrapper.execute(longRequest, leaderAddress)).rejects.toThrow(
+//         /timeout/,
+//       );
+//     });
+//     it('should record timeout as failure in circuit breaker', async () => {
+//       const longRequest = vi.fn().mockImplementation(
+//         () =>
+//           new Promise((resolve) => {
+//             setTimeout(() => resolve('too-late'), 2000);
+//           }),
+//       );
+//       await expect(
+//         wrapper.execute(longRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBeGreaterThan(0);
+//     });
+//   });
+//   describe('Configuration', () => {
+//     it('should bypass retry when disabled', async () => {
+//       const disabledWrapper = new LeaderRequestWrapper({
+//         enabled: false,
+//         maxAttempts: 5,
+//         baseDelayMs: 10,
+//         maxDelayMs: 100,
+//         timeoutMs: 1000,
+//       });
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Fail'));
+//       await expect(
+//         disabledWrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow('Fail');
+//       // Should only call once (no retry)
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//     });
+//     it('should allow circuit breaker to be disabled', async () => {
+//       const noBreakerWrapper = new LeaderRequestWrapper({
+//         enabled: true,
+//         maxAttempts: 3,
+//         baseDelayMs: 10,
+//         maxDelayMs: 100,
+//         timeoutMs: 1000,
+//         circuitBreaker: {
+//           enabled: false,
+//           failureThreshold: 3,
+//           openTimeoutMs: 500,
+//           halfOpenMaxAttempts: 1,
+//         },
+//       });
+//       let callCount = 0;
+//       const mockRequest = vi.fn().mockImplementation(() => {
+//         callCount++;
+//         throw new Error('Fail');
+//       });
+//       await expect(
+//         noBreakerWrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Should retry all attempts even with failures
+//       expect(callCount).toBe(3);
+//     });
+//   });
+//   describe('Manual Reset', () => {
+//     it('should reset circuit breakers manually', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // Open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.OPEN,
+//       );
+//       // Reset
+//       wrapper.resetCircuitBreakers();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//       expect(wrapper.getCircuitBreakerStats().registry.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//     });
+//   });
+//   describe('Registry Address', () => {
+//     it('should use separate circuit breaker for registry', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Registry down'));
+//       await expect(
+//         wrapper.execute(mockRequest, registryAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.registry.totalFailures).toBeGreaterThan(0);
+//       expect(stats.registry.state).toBe(CircuitState.OPEN);
+//       expect(stats.leader.state).toBe(CircuitState.CLOSED);
+//     });
+//   });
+//   describe('Statistics', () => {
+//     it('should provide circuit breaker statistics', () => {
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats).toHaveProperty('leader');
+//       expect(stats).toHaveProperty('registry');
+//       expect(stats.leader).toHaveProperty('state');
+//       expect(stats.leader).toHaveProperty('consecutiveFailures');
+//       expect(stats.registry).toHaveProperty('state');
+//     });
+//   });
+// });

package/dist/o-node/src/utils/network.utils.d.ts

@@ -0,0 +1,20 @@
+import { Libp2p, Multiaddr } from '@olane/o-config';
+import { oObject } from '@olane/o-core';
+import { CID } from 'multiformats';
+import { oNodeAddress } from '../router/o-node.address.js';
+export declare class NetworkUtils extends oObject {
+    static findProviders(p2pNode: Libp2p, cid: CID): Promise<{
+        transports: Multiaddr[];
+        staticAddress: string;
+        absoluteAddress: string;
+    }>;
+    static findNode(p2pNode: Libp2p, address: oNodeAddress): Promise<{
+        transports: Multiaddr[];
+        staticAddress: string;
+        absoluteAddress: string;
+    }>;
+    static advertiseValueToNetwork(value: CID, p2pNode: Libp2p): Promise<void>;
+    static dhtProvide(value: CID, p2pNode: Libp2p): Promise<void>;
+    static advertiseToNetwork(address: oNodeAddress, staticAddress: oNodeAddress, p2pNode: Libp2p): Promise<void>;
+}
+//# sourceMappingURL=network.utils.d.ts.map

package/dist/o-node/src/utils/network.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/network.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,qBAAa,YAAa,SAAQ,OAAO;WACnB,aAAa,CAC/B,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,GAAG,GACP,OAAO,CAAC;QACT,UAAU,EAAE,SAAS,EAAE,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;WA2BkB,QAAQ,CAC1B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC;QACT,UAAU,EAAE,SAAS,EAAE,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;WAiBkB,uBAAuB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;WAgBnD,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;WAYtC,kBAAkB,CACpC,OAAO,EAAE,YAAY,EACrB,aAAa,EAAE,YAAY,EAC3B,OAAO,EAAE,MAAM;CAoClB"}

package/dist/o-node/src/utils/network.utils.js

@@ -0,0 +1,74 @@
+import { oObject } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+export class NetworkUtils extends oObject {
+    static async findProviders(p2pNode, cid) {
+        let peer = null;
+        let multiaddrs = [];
+        for await (const event of p2pNode.services.dht.findProviders(cid)) {
+            // Look for events that contain actual provider information
+            if (event.name === 'PEER_RESPONSE') {
+                if (event.providers?.length === 0) {
+                    NetworkUtils.log('No providers found');
+                    break;
+                }
+                peer = event.providers[0].id;
+                multiaddrs = event.providers[0].multiaddrs;
+                break;
+            }
+            if (event.name === 'PATH_ENDED' || event.name === 'QUERY_ERROR') {
+                break;
+            }
+        }
+        return {
+            transports: multiaddrs,
+            staticAddress: '',
+            absoluteAddress: '',
+        };
+    }
+    static async findNode(p2pNode, address) {
+        const cid = await address.toCID();
+        return await Promise.race([
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Content routing provide timeout')), 5000)),
+            this.findProviders(p2pNode, cid),
+        ]);
+    }
+    static async advertiseValueToNetwork(value, p2pNode) {
+        NetworkUtils.log('Advertising value to network: ', value.toString());
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Advertise Content routing provide timeout')), 5000));
+        await Promise.race([
+            NetworkUtils.dhtProvide(value, p2pNode),
+            timeoutPromise,
+        ]);
+        NetworkUtils.log('Advertise complete!');
+    }
+    static async dhtProvide(value, p2pNode) {
+        for await (const event of p2pNode.services.dht.provide(value)) {
+            if (event.name === 'PATH_ENDED' ||
+                event.name === 'QUERY_ERROR' ||
+                event.name === 'PEER_RESPONSE') {
+                break;
+            }
+        }
+    }
+    static async advertiseToNetwork(address, staticAddress, p2pNode) {
+        NetworkUtils.log('Advertising to network our static and absolute addresses...');
+        // advertise the absolute address to the network with timeout
+        const add = new oNodeAddress(address.toString());
+        const absoluteAddressCid = await add.toCID();
+        // Add timeout to prevent hanging
+        NetworkUtils.advertiseValueToNetwork(absoluteAddressCid, p2pNode)
+            .then((d) => {
+            NetworkUtils.log(`${address.toString()} - Successfully advertised absolute address`);
+        })
+            .catch((error) => {
+            NetworkUtils.log(`${address.toString()} - Failed to advertise absolute address (this is normal for isolated nodes):`, error.message);
+        });
+        // advertise the static address to the network with timeout
+        const staticAdd = new oNodeAddress(staticAddress.toString());
+        const staticAddressCid = await staticAdd.toCID();
+        // Add timeout to prevent hanging
+        NetworkUtils.advertiseValueToNetwork(staticAddressCid, p2pNode).catch((error) => {
+            NetworkUtils.log('Failed to advertise absolute address (this is normal for isolated nodes):', error.message);
+        });
+    }
+}

package/dist/o-node/test/o-node.spec.d.ts

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

package/dist/o-node/test/o-node.spec.d.ts.map

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

package/dist/o-node/test/o-node.spec.js

@@ -0,0 +1,20 @@
+import { NodeState } from '@olane/o-core';
+import { expect } from 'chai';
+import { oNode } from '../src/index.js';
+import { oNodeAddress } from '../src/router/o-node.address.js';
+describe('in-process @memory', () => {
+    it('should be able to start a single node with no leader', async () => {
+        const node = new oNode({
+            address: new oNodeAddress('o://test'),
+            leader: null,
+            parent: null,
+        });
+        await node.start();
+        expect(node.state).to.equal(NodeState.RUNNING);
+        const transports = node.transports;
+        // expect(transports.length).to.equal(1);
+        // expect(transports[0].toString()).to.contain('/memory');
+        await node.stop();
+        expect(node.state).to.equal(NodeState.STOPPED);
+    });
+});

package/dist/o-node/test/search-resolver.spec.d.ts

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

package/dist/o-node/test/search-resolver.spec.d.ts.map

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