@olane/o-node 0.7.12-alpha.42 → 0.7.12-alpha.44

package/dist/o-node/src/router/o-node.routing-policy.js

@@ -1,57 +0,0 @@
-import { oAddress, oRoutingPolicy } from '@olane/o-core';
-import { oNodeAddress } from './o-node.address.js';
-/**
- * Routing policy implementation for oNode that handles internal/external routing decisions
- * and leader-based routing strategies.
- */
-export class oNodeRoutingPolicy extends oRoutingPolicy {
-    /**
-     * Determines if an address is internal to the current node's hierarchy.
-     * An address is considered internal if:
-     * 1. It doesn't have leader references, OR
-     * 2. Its leader references match our known leaders
-     *
-     * @param address The address to check
-     * @param node The current node context
-     * @returns True if the address is internal to this hierarchy
-     */
-    isInternalAddress(address, node) {
-        const nodeAddress = address;
-        // if we are trying to connect to a parent, it's internal
-        if (node.hierarchyManager.parents.some((p) => p.equals(address))) {
-            return true;
-        }
-        if (nodeAddress.paths.indexOf(oAddress.leader().paths) !== -1 && // if the address has a leader
-            nodeAddress.libp2pTransports?.length > 0) {
-            // transports are provided, let's see if they match our known leaders
-            const isLeaderRef = nodeAddress.toString() === oAddress.leader().toString();
-            const isOurLeaderRef = node.address.equals(nodeAddress) ||
-                node.hierarchyManager.leaders.some((l) => l.equals(nodeAddress));
-            return isLeaderRef || isOurLeaderRef;
-        }
-        return true;
-    }
-    /**
-     * Determines the routing strategy for external addresses.
-     * External addresses are routed to the leader of the external OS using
-     * the address's libp2p transports.
-     *
-     * @param address The address to evaluate
-     * @param node The current node context
-     * @returns RouteResponse if external routing is needed, null if internal
-     */
-    getExternalRoutingStrategy(address, node) {
-        const nodeAddress = address;
-        const isInternal = this.isInternalAddress(address, node);
-        if (!isInternal) {
-            // external address, so we need to route
-            this.logger.debug('Address is external, routing...', nodeAddress);
-            // route to leader of external OS
-            return {
-                nextHopAddress: new oNodeAddress(oAddress.leader().toString(), nodeAddress.libp2pTransports),
-                targetAddress: nodeAddress,
-            };
-        }
-        return null;
-    }
-}

package/dist/o-node/src/router/o-node.transport.d.ts

@@ -1,11 +0,0 @@
-import { Multiaddr } from '@olane/o-config';
-import { oTransport, TransportType } from '@olane/o-core';
-export declare class oNodeTransport extends oTransport {
-    readonly type: TransportType;
-    value: Multiaddr | string;
-    constructor(value: Multiaddr | string);
-    toMultiaddr(): Multiaddr;
-    toString(): string;
-    toPeerId(): string;
-}
-//# sourceMappingURL=o-node.transport.d.ts.map

package/dist/o-node/src/router/o-node.transport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"o-node.transport.d.ts","sourceRoot":"","sources":["../../../../src/router/o-node.transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE1D,qBAAa,cAAe,SAAQ,UAAU;IAC5C,SAAgB,IAAI,EAAE,aAAa,CAAwB;IACpD,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC;gBAErB,KAAK,EAAE,SAAS,GAAG,MAAM;IAKrC,WAAW,IAAI,SAAS;IAIxB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/o-node/src/router/o-node.transport.js

@@ -1,18 +0,0 @@
-import { multiaddr } from '@olane/o-config';
-import { oTransport, TransportType } from '@olane/o-core';
-export class oNodeTransport extends oTransport {
-    constructor(value) {
-        super(value);
-        this.type = TransportType.LIBP2P;
-        this.value = value;
-    }
-    toMultiaddr() {
-        return multiaddr(this.toString());
-    }
-    toString() {
-        return this.value.toString();
-    }
-    toPeerId() {
-        return this.value.toString().split('/p2p/')[1];
-    }
-}

package/dist/o-node/src/router/resolvers/index.d.ts

@@ -1,4 +0,0 @@
-export * from './o-node.search-resolver.js';
-export * from './o-node.resolver.js';
-export * from './o-node.leader-resolver-fallback.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sCAAsC,CAAC"}

package/dist/o-node/src/router/resolvers/index.js

@@ -1,3 +0,0 @@
-export * from './o-node.search-resolver.js';
-export * from './o-node.resolver.js';
-export * from './o-node.leader-resolver-fallback.js';

package/dist/o-node/src/router/resolvers/o-node.leader-resolver-fallback.d.ts

@@ -1,8 +0,0 @@
-import { oAddress, oAddressResolver, oTransport, ResolveRequest, RouteResponse } from '@olane/o-core';
-export declare class oLeaderResolverFallback extends oAddressResolver {
-    protected readonly address: oAddress;
-    constructor(address: oAddress);
-    get customTransports(): oTransport[];
-    resolve(request: ResolveRequest): Promise<RouteResponse>;
-}
-//# sourceMappingURL=o-node.leader-resolver-fallback.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"o-node.leader-resolver-fallback.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/o-node.leader-resolver-fallback.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAEhB,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AAIvB,qBAAa,uBAAwB,SAAQ,gBAAgB;IAC/C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAEK,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA4B/D"}

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

@@ -1,35 +0,0 @@
-import { oAddressResolver, oCustomTransport, } from '@olane/o-core';
-export class oLeaderResolverFallback extends oAddressResolver {
-    constructor(address) {
-        super(address);
-        this.address = address;
-    }
-    get customTransports() {
-        return [new oCustomTransport('/fallback/leader')];
-    }
-    async resolve(request) {
-        const { address, node, request: resolveRequest, targetAddress } = request;
-        // check to see if something odd was attempted where the leader transports were applied to a different address
-        if (node.leader &&
-            address.transports.some((t) => node.leader?.transports.includes(t))) {
-            return {
-                nextHopAddress: node.leader,
-                targetAddress: targetAddress,
-                requestOverride: resolveRequest,
-            };
-        }
-        // if already has transports, return the address
-        if (address.transports.length > 0) {
-            return {
-                nextHopAddress: address,
-                targetAddress: targetAddress,
-                requestOverride: resolveRequest,
-            };
-        }
-        return {
-            nextHopAddress: node.leader,
-            targetAddress: targetAddress,
-            requestOverride: resolveRequest,
-        };
-    }
-}

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

@@ -1,11 +0,0 @@
-import { oAddressResolver, TransportType } from '@olane/o-core';
-import { oNodeAddress } from '../o-node.address.js';
-import { oNodeRouterResponse } from '../interfaces/o-node-router.response.js';
-import { ResolveRequest } from '@olane/o-core';
-export declare class oNodeResolver extends oAddressResolver {
-    protected readonly address: oNodeAddress;
-    constructor(address: oNodeAddress);
-    get supportedTransports(): TransportType[];
-    resolve(routeRequest: ResolveRequest): Promise<oNodeRouterResponse>;
-}
-//# sourceMappingURL=o-node.resolver.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"o-node.resolver.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/o-node.resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAId,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,aAAc,SAAQ,gBAAgB;IACrC,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;CA8C1E"}

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

@@ -1,45 +0,0 @@
-import { oAddressResolver, oAddress, TransportType, oError, oErrorCodes, } from '@olane/o-core';
-import { oNodeAddress } from '../o-node.address.js';
-export class oNodeResolver extends oAddressResolver {
-    constructor(address) {
-        super(address);
-        this.address = address;
-    }
-    get supportedTransports() {
-        return [TransportType.LIBP2P];
-    }
-    async resolve(routeRequest) {
-        const { address, node, request, targetAddress } = routeRequest;
-        // get the next node & check for child address existence
-        const remainingPath = targetAddress.paths.replace(node.address.paths + '/', '');
-        // ensure this is going down in the hierarchy
-        if (remainingPath === targetAddress.paths && node.isLeader === false) {
-            return {
-                nextHopAddress: address,
-                targetAddress: targetAddress,
-                requestOverride: request,
-            };
-        }
-        // next term resolver
-        const parts = remainingPath.split('/');
-        const nextNode = new oNodeAddress(`o://${parts.shift()}`);
-        const childAddress = node?.hierarchyManager.getChild(nextNode);
-        // get the child address from hierarchy (which includes transports)
-        if (childAddress) {
-            return {
-                nextHopAddress: childAddress,
-                targetAddress: targetAddress,
-                requestOverride: request,
-            };
-        }
-        // no child address, and we have already been to the leader, fail
-        if (address.toString().indexOf(oAddress.leader().toString()) > -1) {
-            throw new oError(oErrorCodes.NOT_FOUND, targetAddress.toString() + ' node not found.');
-        }
-        return {
-            nextHopAddress: address,
-            targetAddress: targetAddress,
-            requestOverride: request,
-        };
-    }
-}

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

@@ -1,170 +0,0 @@
-import { oAddress, oAddressResolver, oCore, oTransport, ResolveRequest, RouteResponse } from '@olane/o-core';
-import { oNodeTransport } from '../o-node.transport.js';
-/**
- * Address resolver that searches a registry to find transports for addresses.
- *
- * This resolver queries a registry service to find the transport information
- * for addresses that don't already have transports configured. It's designed
- * to be extensible through subclassing via protected template methods.
- *
- * @example Basic usage
- * ```typescript
- * const resolver = new oSearchResolver(nodeAddress);
- * router.addResolver(resolver);
- * ```
- *
- * @example Creating a custom search resolver
- * ```typescript
- * class CustomSearchResolver extends oSearchResolver {
- *   // Search a different registry
- *   protected getRegistryAddress(): oAddress {
- *     return new oAddress('o://my-custom-registry');
- *   }
- *
- *   // Use round-robin selection instead of first result
- *   private currentIndex = 0;
- *   protected selectResult(results: any[]): any | null {
- *     if (results.length === 0) return null;
- *     const result = results[this.currentIndex % results.length];
- *     this.currentIndex++;
- *     return result;
- *   }
- *
- *   // Add custom filtering logic
- *   protected filterSearchResults(results: any[], node: oCore): any[] {
- *     return super.filterSearchResults(results, node).filter(
- *       result => result.status === 'active'
- *     );
- *   }
- *
- *   // Implement custom routing logic with transport setup
- *   protected determineNextHop(
- *     node: oCore,
- *     resolvedTargetAddress: oAddress,
- *     searchResult: any
- *   ): oAddress {
- *     // Always route directly to target, bypassing hierarchy
- *     const targetTransports = this.mapTransports(searchResult);
- *     resolvedTargetAddress.setTransports(targetTransports);
- *     return resolvedTargetAddress;
- *   }
- * }
- * ```
- *
- * ## Extension Points
- *
- * The following protected methods can be overridden to customize behavior:
- *
- * - `getRegistryAddress()` - Change which registry to search
- * - `getSearchMethod()` - Change the registry method to call
- * - `buildSearchParams()` - Customize search parameters
- * - `filterSearchResults()` - Add custom filtering logic
- * - `selectResult()` - Implement custom result selection (e.g., load balancing)
- * - `mapTransports()` - Customize how transports are mapped from results
- * - `determineNextHop()` - Implement custom routing logic to determine the next hop address
- * - `resolveNextHopTransports()` - Customize transport resolution for the next hop
- */
-export declare class oSearchResolver extends oAddressResolver {
-    protected readonly address: oAddress;
-    constructor(address: oAddress);
-    get customTransports(): oTransport[];
-    /**
-     * Returns the address of the registry to search.
-     * Override this method to search a different registry.
-     * @returns The registry address to query
-     */
-    protected getRegistryAddress(): oAddress;
-    /**
-     * Returns the method name to call on the registry.
-     * Override this method to use a different search method.
-     * @returns The method name to call
-     */
-    protected getSearchMethod(): string;
-    /**
-     * Builds the search parameters for the registry query.
-     * Override this method to customize search parameters.
-     * @param address - The address being resolved
-     * @returns Parameters to pass to the registry search method
-     */
-    protected buildSearchParams(address: oAddress): any;
-    /**
-     * Filters the search results from the registry.
-     * Override this method to apply custom filtering logic.
-     * @param results - Raw results from the registry
-     * @param node - The current node context
-     * @returns Filtered array of results
-     */
-    protected filterSearchResults(results: any[], node: oCore): any[];
-    /**
-     * Selects which result to use from the filtered results.
-     * Override this method to implement custom selection logic (e.g., load balancing).
-     * @param results - Filtered search results
-     * @returns The selected result, or null if no suitable result
-     */
-    protected selectResult(results: any[]): any | null;
-    /**
-     * Maps the transport data from the search result to oNodeTransport instances.
-     * Override this method to customize transport mapping.
-     * @param result - The selected search result
-     * @returns Array of oNodeTransport instances
-     */
-    protected mapTransports(result: any): oNodeTransport[];
-    /**
-     * Resolves the transports for the next hop address.
-     * This handles the logic of determining which transports to use based on
-     * whether the next hop is the leader, a known child, or a new target.
-     *
-     * Override this method to customize transport resolution logic.
-     *
-     * @param nextHop - The next hop address
-     * @param targetTransports - The transports from the registry search result
-     * @param node - The current node context
-     * @returns Array of transports to use for the next hop
-     */
-    protected resolveNextHopTransports(nextHop: oAddress, targetTransports: oNodeTransport[], node: oCore): oNodeTransport[];
-    /**
-     * Determines the next hop address for routing to the target and sets up its transports.
-     *
-     * This method implements the complete routing logic including:
-     * 1. Determining the next address in the path (using `oAddress.next()`)
-     * 2. Mapping transports from the search result
-     * 3. Resolving and setting transports on the next hop address
-     * 4. Setting transports on the target address
-     *
-     * The default implementation:
-     * - Uses `oAddress.next()` for standard hierarchy-based routing
-     * - Maps transports from the registry search result
-     * - Resolves next hop transports based on leader/hierarchy
-     * - Configures both next hop and target with appropriate transports
-     *
-     * Override this method to implement custom routing logic, such as:
-     * - Direct peer-to-peer routing
-     * - Custom hierarchy traversal
-     * - Alternative transport selection strategies
-     * - Bypass leader for certain routes
-     *
-     * @param node - The current node context
-     * @param resolvedTargetAddress - The resolved target address to route to
-     * @param searchResult - The raw search result from the registry containing transport data
-     * @returns The next hop address with transports configured
-     *
-     * @example Custom direct routing
-     * ```typescript
-     * class DirectSearchResolver extends oSearchResolver {
-     *   protected determineNextHop(
-     *     node: oCore,
-     *     resolvedTargetAddress: oAddress,
-     *     searchResult: any
-     *   ): oAddress {
-     *     // Always route directly to the target, bypassing hierarchy
-     *     const targetTransports = this.mapTransports(searchResult);
-     *     resolvedTargetAddress.setTransports(targetTransports);
-     *     return resolvedTargetAddress;
-     *   }
-     * }
-     * ```
-     */
-    protected determineNextHop(node: oCore, resolvedTargetAddress: oAddress, searchResult: any): oAddress;
-    resolve(request: ResolveRequest): Promise<RouteResponse>;
-}
-//# sourceMappingURL=o-node.search-resolver.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAeL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAsG/D"}