@olane/o-node 0.7.12-alpha.3 → 0.7.12-alpha.30

package/dist/test/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/test/search-resolver.spec.js

@@ -515,6 +515,85 @@ describe('oSearchResolver', () => {
             }
         });
     });
+    describe('Address duplication bug fix', () => {
+        it('should NOT duplicate path segments when registry returns full hierarchical address', async () => {
+            // This test verifies the fix for the bug where o://services/embeddings-text
+            // was being resolved to o://leader/services/embeddings-text/services/embeddings-text
+            const address = new oNodeAddress('o://services/embeddings-text');
+            mockNode.use = async () => createResponse({
+                data: [
+                    {
+                        address: 'o://leader/services/embeddings-text',
+                        staticAddress: 'o://embeddings-text',
+                        transports: [
+                            {
+                                value: '/ip4/127.0.0.1/tcp/6001',
+                                type: TransportType.LIBP2P,
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = await resolver.resolve({
+                address,
+                targetAddress: address,
+                node: mockNode,
+                request: createRouterRequest(),
+            });
+            // Should be o://leader/services/embeddings-text, NOT o://leader/services/embeddings-text/embeddings-text
+            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text');
+        });
+        it('should NOT duplicate when calling via static address', async () => {
+            const address = new oNodeAddress('o://embeddings-text');
+            mockNode.use = async () => createResponse({
+                data: [
+                    {
+                        address: 'o://leader/services/embeddings-text',
+                        staticAddress: 'o://embeddings-text',
+                        transports: [
+                            {
+                                value: '/ip4/127.0.0.1/tcp/6001',
+                                type: TransportType.LIBP2P,
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = await resolver.resolve({
+                address,
+                targetAddress: address,
+                node: mockNode,
+                request: createRouterRequest(),
+            });
+            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text');
+        });
+        it('should still append legitimate extra params beyond the service name', async () => {
+            // If someone calls o://embeddings-text/custom/path, we should preserve /custom/path
+            const address = new oNodeAddress('o://embeddings-text/custom/path');
+            mockNode.use = async () => createResponse({
+                data: [
+                    {
+                        address: 'o://leader/services/embeddings-text',
+                        staticAddress: 'o://embeddings-text',
+                        transports: [
+                            {
+                                value: '/ip4/127.0.0.1/tcp/6001',
+                                type: TransportType.LIBP2P,
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = await resolver.resolve({
+                address,
+                targetAddress: address,
+                node: mockNode,
+                request: createRouterRequest(),
+            });
+            // Should append the extra /custom/path
+            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text/custom/path');
+        });
+    });
     describe('Edge cases', () => {
         it('should handle address with long nested paths', async () => {
             const address = new oNodeAddress('o://leader/a/b/c/d/e/f');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.12-alpha.3",
+  "version": "0.7.12-alpha.30",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -54,12 +54,12 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "^0.7.12-alpha.3",
-    "@olane/o-core": "0.7.12-alpha.3",
-    "@olane/o-protocol": "^0.7.12-alpha.3",
-    "@olane/o-tool": "0.7.12-alpha.3",
+    "@olane/o-config": "0.7.12-alpha.30",
+    "@olane/o-core": "0.7.12-alpha.30",
+    "@olane/o-protocol": "0.7.12-alpha.30",
+    "@olane/o-tool": "0.7.12-alpha.30",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "5c05e5f248001abc38f34c77bd97c9a325231503"
+  "gitHead": "066e6bda19e79a744779a797664481476b0ea655"
 }

package/dist/src/router/resolvers/o-node.child-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"o-node.child-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.child-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,kBAAmB,SAAQ,gBAAgB;IAC1C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY;IAIpD,IAAI,mBAAmB,IAAI,aAAa,EAAE,CAEzC;IAEK,OAAO,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA4D1E"}

package/dist/src/router/resolvers/o-node.child-resolver.js

@@ -1,58 +0,0 @@
-import { oAddressResolver, TransportType, } from '@olane/o-core';
-export class oNodeChildResolver extends oAddressResolver {
-    constructor(address) {
-        super(address);
-        this.address = address;
-    }
-    get supportedTransports() {
-        return [TransportType.LIBP2P];
-    }
-    async resolve(routeRequest) {
-        const { address, node, request } = routeRequest;
-        if (!node) {
-            return {
-                nextHopAddress: address,
-                targetAddress: address,
-                requestOverride: request,
-            };
-        }
-        // if we are the same address, return the address
-        if (address.toStaticAddress().equals(node.address.toStaticAddress())) {
-            return {
-                nextHopAddress: node.address,
-                targetAddress: node.address,
-                requestOverride: request,
-            };
-        }
-        // get the next node & check for child address existence
-        const remainingPath = address.protocol.replace(node.address.protocol + '/', '');
-        // ensure this is going down in the hierarchy
-        if (remainingPath === address.protocol && node.isLeader === false) {
-            return {
-                nextHopAddress: node.address,
-                targetAddress: address,
-                requestOverride: request,
-            };
-        }
-        // static resolver
-        this.logger.debug(`[${node?.address}]: Next node: ${address.toString()}`);
-        const childAddress = node?.hierarchyManager.getChild(address);
-        this.logger.debug(`[${node?.address}]: Children: ${node?.hierarchyManager.children.map((c) => c.toString()).join(', ')}`);
-        this.logger.debug(`[${node?.address}]: Resolving address: ${address.toString()} and child address: ${childAddress?.toString()}`);
-        this.logger.debug('Child transports: ' +
-            childAddress?.transports.map((t) => t.toString()).join(', '));
-        // get the child address from hierarchy (which includes transports)
-        if (childAddress) {
-            return {
-                nextHopAddress: childAddress,
-                targetAddress: address,
-                requestOverride: request,
-            };
-        }
-        return {
-            nextHopAddress: address,
-            targetAddress: address,
-            requestOverride: request,
-        };
-    }
-}