@olane/o-node 0.7.12-alpha.4 → 0.7.12-alpha.41

package/dist/o-core/src/core/lib/o-hierarchy.manager.js

@@ -0,0 +1,58 @@
+import { oObject } from '../o-object.js';
+export class oHierarchyManager extends oObject {
+    constructor(config) {
+        super();
+        this.leaders = [];
+        this.children = [];
+        this.parents = []; // multiple parents allow for more flexibility with address construction
+        this.leaders = config.leaders || [];
+        this.children = config.children || [];
+        this.parents = config.parents || [];
+    }
+    clear() {
+        this.leaders = [];
+        this.children = [];
+        this.parents = [];
+    }
+    deduplicate(addresses) {
+        const added = {};
+        return addresses.filter((a) => {
+            if (added[a.toString()]) {
+                return false;
+            }
+            added[a.toString()] = true;
+            return true;
+        });
+    }
+    addChild(address) {
+        // remove child if it exists
+        this.removeChild(address);
+        // deduplicate
+        this.children = this.deduplicate([...this.children, address]);
+    }
+    getChild(address) {
+        return this.children.find((a) => a.toStaticAddress().toString() === address.toStaticAddress().toString());
+    }
+    removeChild(address) {
+        this.children = this.deduplicate([
+            ...this.children.filter((a) => a.toString() !== address.toString()),
+        ]);
+    }
+    addParent(address) {
+        this.parents = this.deduplicate([...this.parents, address]);
+    }
+    removeParent(address) {
+        this.parents = this.deduplicate([
+            ...this.parents.filter((a) => a.toString() !== address.toString()),
+        ]);
+    }
+    getChildren() {
+        return this.children;
+    }
+    getParents() {
+        return this.parents;
+    }
+    getLeaders() {
+        return this.leaders;
+    }
+}

package/dist/o-core/src/core/lib/o-metrics.d.ts

@@ -0,0 +1,5 @@
+export declare class oMetrics {
+    successCount: number;
+    errorCount: number;
+}
+//# sourceMappingURL=o-metrics.d.ts.map

package/dist/o-core/src/core/lib/o-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-metrics.d.ts","sourceRoot":"","sources":["../../../../../../o-core/src/core/lib/o-metrics.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAQ;IACZ,YAAY,EAAE,MAAM,CAAK;IACzB,UAAU,EAAE,MAAM,CAAK;CAC/B"}

package/dist/o-core/src/core/lib/o-metrics.js

@@ -0,0 +1,6 @@
+export class oMetrics {
+    constructor() {
+        this.successCount = 0;
+        this.errorCount = 0;
+    }
+}

package/dist/o-core/src/core/lib/o-notification.manager.d.ts

@@ -0,0 +1,58 @@
+import { oObject } from '../o-object.js';
+import { oNotificationEvent } from './events/o-notification-event.js';
+import { EventFilter, NotificationHandler, Subscription } from './interfaces/notification-types.js';
+/**
+ * Abstract notification manager - transport agnostic
+ * NO dependencies on libp2p, HTTP, or any specific transport
+ *
+ * Subclasses implement setupListeners() to wire up transport-specific events
+ */
+export declare abstract class oNotificationManager extends oObject {
+    private eventTarget;
+    private subscriptions;
+    constructor();
+    /**
+     * Subscribe to a notification event
+     *
+     * @param eventType - The event type to subscribe to (e.g., "node:connected", "child:joined")
+     * @param handler - The handler function to call when event is emitted
+     * @param filter - Optional filter to apply to events
+     * @returns Subscription handle
+     */
+    on(eventType: string, handler: NotificationHandler, filter?: EventFilter): Subscription;
+    /**
+     * Unsubscribe from a notification event
+     */
+    off(subscription: Subscription): void;
+    /**
+     * Emit a notification event
+     */
+    emit(event: oNotificationEvent): void;
+    /**
+     * Check if an event matches a filter
+     */
+    protected matchesFilter(event: oNotificationEvent, filter: EventFilter): boolean;
+    /**
+     * Get all active subscriptions for an event type
+     */
+    getSubscriptions(eventType?: string): Subscription[];
+    /**
+     * Get count of active subscriptions
+     */
+    getSubscriptionCount(eventType?: string): number;
+    /**
+     * Subclasses must implement this to wire up transport-specific listeners
+     * This is where libp2p/HTTP/WebSocket events get connected
+     */
+    protected abstract setupListeners(): void | Promise<void>;
+    /**
+     * Initialize the notification manager
+     * Calls setupListeners() to wire up transport events
+     */
+    initialize(): Promise<void>;
+    /**
+     * Cleanup all subscriptions
+     */
+    teardown(): Promise<void>;
+}
+//# sourceMappingURL=o-notification.manager.d.ts.map

package/dist/o-core/src/core/lib/o-notification.manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-notification.manager.d.ts","sourceRoot":"","sources":["../../../../../../o-core/src/core/lib/o-notification.manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,YAAY,EACb,MAAM,oCAAoC,CAAC;AAG5C;;;;;GAKG;AACH,8BAAsB,oBAAqB,SAAQ,OAAO;IACxD,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,aAAa,CAAiC;;IAQtD;;;;;;;OAOG;IACH,EAAE,CACA,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,mBAAmB,EAC5B,MAAM,CAAC,EAAE,WAAW,GACnB,YAAY;IAoDf;;OAEG;IACH,GAAG,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;IA6BrC;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAUrC;;OAEG;IACH,SAAS,CAAC,aAAa,CACrB,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,WAAW,GAClB,OAAO;IAyBV;;OAEG;IACH,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE;IAcpD;;OAEG;IACH,oBAAoB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAIhD;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEzD;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}

package/dist/o-core/src/core/lib/o-notification.manager.js

@@ -0,0 +1,159 @@
+import { v4 as uuidv4 } from 'uuid';
+import { oObject } from '../o-object.js';
+import { EventFilters } from './utils/event-filters.js';
+/**
+ * Abstract notification manager - transport agnostic
+ * NO dependencies on libp2p, HTTP, or any specific transport
+ *
+ * Subclasses implement setupListeners() to wire up transport-specific events
+ */
+export class oNotificationManager extends oObject {
+    constructor() {
+        super();
+        this.eventTarget = new EventTarget();
+        this.subscriptions = new Map();
+    }
+    /**
+     * Subscribe to a notification event
+     *
+     * @param eventType - The event type to subscribe to (e.g., "node:connected", "child:joined")
+     * @param handler - The handler function to call when event is emitted
+     * @param filter - Optional filter to apply to events
+     * @returns Subscription handle
+     */
+    on(eventType, handler, filter) {
+        const subscriptionId = uuidv4();
+        const subscription = {
+            id: subscriptionId,
+            eventType,
+            handler,
+            filter,
+            unsubscribe: () => {
+                this.off(subscription);
+            },
+        };
+        // Add to subscriptions map
+        if (!this.subscriptions.has(eventType)) {
+            this.subscriptions.set(eventType, new Set());
+        }
+        this.subscriptions.get(eventType).add(subscription);
+        // Add DOM event listener
+        const wrappedHandler = async (event) => {
+            if (!(event instanceof CustomEvent)) {
+                return;
+            }
+            const notificationEvent = event.detail;
+            // Apply filter if provided
+            if (filter && !this.matchesFilter(notificationEvent, filter)) {
+                return;
+            }
+            try {
+                await handler(notificationEvent);
+            }
+            catch (error) {
+                this.logger.error(`Error in notification handler for ${eventType}:`, error);
+            }
+        };
+        // Store wrapped handler for later removal
+        subscription._wrappedHandler = wrappedHandler;
+        this.eventTarget.addEventListener(eventType, wrappedHandler);
+        this.logger.debug(`Subscribed to ${eventType} with ID ${subscriptionId}`);
+        return subscription;
+    }
+    /**
+     * Unsubscribe from a notification event
+     */
+    off(subscription) {
+        const subscriptionsForType = this.subscriptions.get(subscription.eventType);
+        if (!subscriptionsForType) {
+            return;
+        }
+        // Remove from subscriptions set
+        subscriptionsForType.delete(subscription);
+        // Remove DOM event listener
+        const wrappedHandler = subscription._wrappedHandler;
+        if (wrappedHandler) {
+            this.eventTarget.removeEventListener(subscription.eventType, wrappedHandler);
+        }
+        // Clean up empty sets
+        if (subscriptionsForType.size === 0) {
+            this.subscriptions.delete(subscription.eventType);
+        }
+        this.logger.verbose(`Unsubscribed from ${subscription.eventType} with ID ${subscription.id}`);
+    }
+    /**
+     * Emit a notification event
+     */
+    emit(event) {
+        this.logger.verbose(`Emitting event: ${event.type}`, event.toJSON());
+        const customEvent = new CustomEvent(event.type, {
+            detail: event,
+        });
+        this.eventTarget.dispatchEvent(customEvent);
+    }
+    /**
+     * Check if an event matches a filter
+     */
+    matchesFilter(event, filter) {
+        // Check event type filter
+        if (filter.eventTypes && !filter.eventTypes.includes(event.type)) {
+            return false;
+        }
+        // Check address pattern filter
+        if (filter.addressPattern) {
+            const eventAddress = EventFilters.getEventAddress(event);
+            if (!eventAddress ||
+                !EventFilters.addressMatches(eventAddress, filter.addressPattern)) {
+                return false;
+            }
+        }
+        // Check custom filter
+        if (filter.customFilter && !filter.customFilter(event)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get all active subscriptions for an event type
+     */
+    getSubscriptions(eventType) {
+        if (eventType) {
+            const subs = this.subscriptions.get(eventType);
+            return subs ? Array.from(subs) : [];
+        }
+        // Return all subscriptions
+        const allSubs = [];
+        for (const subs of this.subscriptions.values()) {
+            allSubs.push(...Array.from(subs));
+        }
+        return allSubs;
+    }
+    /**
+     * Get count of active subscriptions
+     */
+    getSubscriptionCount(eventType) {
+        return this.getSubscriptions(eventType).length;
+    }
+    /**
+     * Initialize the notification manager
+     * Calls setupListeners() to wire up transport events
+     */
+    async initialize() {
+        this.logger.debug('Initializing notification manager...');
+        await this.setupListeners();
+        this.logger.debug('Notification manager initialized');
+    }
+    /**
+     * Cleanup all subscriptions
+     */
+    async teardown() {
+        this.logger.debug('Tearing down notification manager...');
+        // Unsubscribe all
+        const allSubs = this.getSubscriptions();
+        for (const sub of allSubs) {
+            this.off(sub);
+        }
+        this.subscriptions.clear();
+        this.logger.debug('Notification manager torn down');
+    }
+}

package/dist/o-core/src/core/lib/o-request.manager.d.ts

@@ -0,0 +1,10 @@
+import { oRequest } from '../../connection/o-request.js';
+export declare class oRequestManager {
+    private requests;
+    constructor();
+    addRequest(request: oRequest): void;
+    removeRequest(request: oRequest): void;
+    getRequest(id: string): oRequest | undefined;
+    get activeRequests(): oRequest[];
+}
+//# sourceMappingURL=o-request.manager.d.ts.map

package/dist/o-core/src/core/lib/o-request.manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-request.manager.d.ts","sourceRoot":"","sources":["../../../../../../o-core/src/core/lib/o-request.manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAkB;;IAGlC,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAInC,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAItC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAI5C,IAAI,cAAc,IAAI,QAAQ,EAAE,CAE/B;CACF"}

package/dist/o-core/src/core/lib/o-request.manager.js

@@ -0,0 +1,18 @@
+import { RequestState } from '../../connection/interfaces/request-state.enum.js';
+export class oRequestManager {
+    constructor() {
+        this.requests = [];
+    }
+    addRequest(request) {
+        this.requests.push(request);
+    }
+    removeRequest(request) {
+        this.requests = this.requests.filter((r) => r !== request);
+    }
+    getRequest(id) {
+        return this.requests.find((r) => r.id === id);
+    }
+    get activeRequests() {
+        return this.requests.filter((r) => r.state === RequestState.PENDING);
+    }
+}

package/dist/o-core/src/core/lib/utils/event-filters.d.ts

@@ -0,0 +1,38 @@
+import { oAddress } from '../../../router/o-address.js';
+import { oNotificationEvent } from '../events/o-notification-event.js';
+/**
+ * Utility functions for filtering notification events
+ */
+export declare class EventFilters {
+    /**
+     * Check if an address matches a pattern
+     * Supports:
+     *   - Regex patterns: any string starting with '/' or containing regex special chars
+     *   - Wildcards: * for single segment, ** for multiple segments
+     *
+     * Examples:
+     *   Wildcards:
+     *     - "o://leader/*" matches "o://leader/child1" but not "o://leader/child1/grandchild"
+     *     - "o://leader/**" matches "o://leader/child1" and "o://leader/child1/grandchild"
+     *     - "o://leader/tools/*" matches "o://leader/tools/calculator"
+     *
+     *   Regex (use standard regex patterns with / delimiters):
+     *     - /^o:\/\/leader\/.*\/ matches any path starting with o://leader/
+     *     - /tool-\d+/ matches paths with tool-1, tool-99, etc.
+     *     - /o:\/\/leader\/(analytics|reporting)\// matches analytics or reporting paths
+     */
+    static addressMatches(address: oAddress, pattern: string): boolean;
+    /**
+     * Filter events to only include direct children of a parent address
+     */
+    static childrenOnly(event: oNotificationEvent, parentAddress: oAddress): boolean;
+    /**
+     * Filter events to only include descendants (children, grandchildren, etc.) of an ancestor address
+     */
+    static descendantsOnly(event: oNotificationEvent, ancestorAddress: oAddress): boolean;
+    /**
+     * Get the address from an event based on its type
+     */
+    static getEventAddress(event: oNotificationEvent): oAddress | null;
+}
+//# sourceMappingURL=event-filters.d.ts.map

package/dist/o-core/src/core/lib/utils/event-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-filters.d.ts","sourceRoot":"","sources":["../../../../../../../o-core/src/core/lib/utils/event-filters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAUvE;;GAEG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAiElE;;OAEG;IACH,MAAM,CAAC,YAAY,CACjB,KAAK,EAAE,kBAAkB,EACzB,aAAa,EAAE,QAAQ,GACtB,OAAO;IAiCV;;OAEG;IACH,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,kBAAkB,EACzB,eAAe,EAAE,QAAQ,GACxB,OAAO;IAgDV;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,kBAAkB,GAAG,QAAQ,GAAG,IAAI;CAcnE"}

package/dist/o-core/src/core/lib/utils/event-filters.js

@@ -0,0 +1,159 @@
+import { ChildJoinedEvent, ChildLeftEvent, } from '../events/hierarchy-events.js';
+import { NodeConnectedEvent, NodeDisconnectedEvent, } from '../events/node-events.js';
+/**
+ * Utility functions for filtering notification events
+ */
+export class EventFilters {
+    /**
+     * Check if an address matches a pattern
+     * Supports:
+     *   - Regex patterns: any string starting with '/' or containing regex special chars
+     *   - Wildcards: * for single segment, ** for multiple segments
+     *
+     * Examples:
+     *   Wildcards:
+     *     - "o://leader/*" matches "o://leader/child1" but not "o://leader/child1/grandchild"
+     *     - "o://leader/**" matches "o://leader/child1" and "o://leader/child1/grandchild"
+     *     - "o://leader/tools/*" matches "o://leader/tools/calculator"
+     *
+     *   Regex (use standard regex patterns with / delimiters):
+     *     - /^o:\/\/leader\/.*\/ matches any path starting with o://leader/
+     *     - /tool-\d+/ matches paths with tool-1, tool-99, etc.
+     *     - /o:\/\/leader\/(analytics|reporting)\// matches analytics or reporting paths
+     */
+    static addressMatches(address, pattern) {
+        const addressStr = address.toString();
+        // Check if pattern is a regex (starts with / or contains regex special chars like ^, $, [], (), |)
+        const isRegex = pattern.startsWith('/') || /[\^\$\[\]\(\)\|]/.test(pattern);
+        if (isRegex) {
+            try {
+                // Extract regex pattern and flags if format is /pattern/flags
+                let regexPattern = pattern;
+                let flags = '';
+                if (pattern.startsWith('/')) {
+                    const lastSlash = pattern.lastIndexOf('/');
+                    if (lastSlash > 0) {
+                        regexPattern = pattern.slice(1, lastSlash);
+                        flags = pattern.slice(lastSlash + 1);
+                    }
+                }
+                const regex = new RegExp(regexPattern, flags);
+                return regex.test(addressStr);
+            }
+            catch (e) {
+                // If regex compilation fails, fall back to exact match
+                console.warn(`Invalid regex pattern: ${pattern}`, e);
+                return addressStr === pattern;
+            }
+        }
+        // Handle wildcard patterns (backward compatibility)
+        const addressPaths = address.paths;
+        const patternPaths = pattern.replace('o://', '').split('/').filter(Boolean);
+        // Handle exact match
+        if (addressStr === pattern) {
+            return true;
+        }
+        // Handle wildcard patterns
+        for (let i = 0; i < patternPaths.length; i++) {
+            const patternSegment = patternPaths[i];
+            // ** matches rest of path
+            if (patternSegment === '**') {
+                return true;
+            }
+            // * matches single segment
+            if (patternSegment === '*') {
+                if (i >= addressPaths.length) {
+                    return false;
+                }
+                continue;
+            }
+            // Exact segment match
+            if (addressPaths[i] !== patternSegment) {
+                return false;
+            }
+        }
+        // Pattern must match full address length (unless ended with **)
+        return addressPaths.length === patternPaths.length;
+    }
+    /**
+     * Filter events to only include direct children of a parent address
+     */
+    static childrenOnly(event, parentAddress) {
+        // Check if event is a hierarchy event
+        if (event instanceof ChildJoinedEvent || event instanceof ChildLeftEvent) {
+            return event.parentAddress.toString() === parentAddress.toString();
+        }
+        // For node events, check if the node is a direct child
+        if (event instanceof NodeConnectedEvent ||
+            event instanceof NodeDisconnectedEvent) {
+            const nodeAddr = event.nodeAddress;
+            const parentPaths = parentAddress.paths;
+            const nodePaths = nodeAddr.paths;
+            // Direct child has exactly one more path segment
+            if (nodePaths.length !== parentPaths.length + 1) {
+                return false;
+            }
+            // Check all parent segments match
+            for (let i = 0; i < parentPaths.length; i++) {
+                if (parentPaths[i] !== nodePaths[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Filter events to only include descendants (children, grandchildren, etc.) of an ancestor address
+     */
+    static descendantsOnly(event, ancestorAddress) {
+        // Check if event is a hierarchy event
+        if (event instanceof ChildJoinedEvent || event instanceof ChildLeftEvent) {
+            // Check if parent is a descendant of or equal to ancestor
+            const parentPaths = event.parentAddress.paths;
+            const ancestorPaths = ancestorAddress.paths;
+            if (parentPaths.length < ancestorPaths.length) {
+                return false;
+            }
+            // Check all ancestor segments match
+            for (let i = 0; i < ancestorPaths.length; i++) {
+                if (ancestorPaths[i] !== parentPaths[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // For node events, check if the node is a descendant
+        if (event instanceof NodeConnectedEvent ||
+            event instanceof NodeDisconnectedEvent) {
+            const nodeAddr = event.nodeAddress;
+            const nodePaths = nodeAddr.paths;
+            const ancestorPaths = ancestorAddress.paths;
+            // Descendant must have more path segments
+            if (nodePaths.length <= ancestorPaths.length) {
+                return false;
+            }
+            // Check all ancestor segments match
+            for (let i = 0; i < ancestorPaths.length; i++) {
+                if (ancestorPaths[i] !== nodePaths[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get the address from an event based on its type
+     */
+    static getEventAddress(event) {
+        if (event instanceof NodeConnectedEvent ||
+            event instanceof NodeDisconnectedEvent) {
+            return event.nodeAddress;
+        }
+        if (event instanceof ChildJoinedEvent || event instanceof ChildLeftEvent) {
+            return event.childAddress;
+        }
+        return null;
+    }
+}