@spider-mesh/core 2.0.41 → 2.0.43

package/build/src/SpiderMesh.js

@@ -1,110 +1,98 @@
-import { BehaviorSubject, catchError, EMPTY, filter, finalize, from, lastValueFrom, map, mergeAll, mergeMap, NEVER, Observable, of, retry, Subject, take, tap, throwError, timeout, timer } from "rxjs";
+import { BehaviorSubject, catchError, EMPTY, finalize, firstValueFrom, from, lastValueFrom, map, mergeMap, Observable, of, retry, share, Subject, Subscription, switchMap, take, tap, throwError, timeout, timer } from "rxjs";
 import { listBeforeMicroserviceOnlineMethods } from "./decorators/BeforeMicroserviceOnline.js";
 import { LOCAL_SERVICES$ } from "./decorators/Microservice.js";
 import { SPIDERMESH_NAMESPACE, SPIDERMESH_NODE_HOSTNAME } from "../const.js";
 const isSubscribable = (value) => {
     return !!value && typeof value === 'object' && typeof value.subscribe === 'function';
 };
+const isNamedTransporter = (value) => {
+    return !!value && typeof value === 'object';
+};
 export class SpiderMesh {
-    options;
-    node_id = `${Date.now().toString(36).toUpperCase()}`;
+    registry;
+    node_id = `${Date.now().toString(36).toUpperCase()}|${Math.random().toString(36).slice(10).toUpperCase()}`;
     namespace = SPIDERMESH_NAMESPACE;
-    #rpcs = new Map();
-    #pubsubs = new BehaviorSubject(new Map());
-    #discovers = new Map();
-    #metadata$ = new BehaviorSubject({
+    #transporters = {
+        rpcs: new Map(),
+        pubsubs: new Map(),
+        discoveries: new Map()
+    };
+    #localServices = new Map();
+    #me$ = new BehaviorSubject({
         host: SPIDERMESH_NODE_HOSTNAME,
         namespace: SPIDERMESH_NAMESPACE,
         node_id: this.node_id,
+        topics: [],
         services: {},
         transporters: {},
         nodes: {},
         version: 0,
     });
-    #nodes$ = new BehaviorSubject({
-        nodes: new Map(),
-        last_updated_node_id: ''
-    });
-    #local_services = new Map();
     #rpc = {
-        indexes: new Map(),
         pending: new Map(),
         running: new Map()
     };
-    constructor(options) {
-        this.options = options;
-        if (!options)
-            throw new Error(`Missing options for SpiderMesh, please using like that new SpiderMeshOptions({ ... options})`);
-        setTimeout(() => {
-            LOCAL_SERVICES$.pipe(mergeMap(async (service) => {
-                const list = listBeforeMicroserviceOnlineMethods(service.instance);
-                for (const method of list) {
-                    await service.instance[method]();
+    constructor(registry) {
+        this.registry = registry;
+        LOCAL_SERVICES$.pipe(mergeMap(async (service) => {
+            const list = listBeforeMicroserviceOnlineMethods(service.instance);
+            for (const method of list) {
+                await service.instance[method]();
+            }
+            this.#localServices.set(service.name, service.instance);
+            this.#refresh({
+                services: {
+                    [service.name]: service.metadata
                 }
-                this.#local_services.set(service.name, service.instance);
-                const metadata = {
-                    ...this.#metadata$.value,
-                    services: {
-                        ...this.#metadata$.value.services,
-                        [service.name]: service.metadata
-                    },
-                    version: this.#metadata$.value.version + 1
-                };
-                this.#metadata$.next(metadata);
-            }, 1), catchError(e => EMPTY)).subscribe();
-            this.#linkTransporters();
-        }, 0);
+            });
+        }, 1), catchError(() => EMPTY)).subscribe();
     }
-    static asProvider(options) {
-        return {
-            provide: this,
-            useFactory: async () => new this(options)
-        };
+    registerTransporter(meshTransporter, name) {
+        const resolvedName = name
+            || (isNamedTransporter(meshTransporter) ? meshTransporter.constructor?.name : undefined)
+            || 'AnonymousTransporter';
+        const subscription = new Subscription();
+        if (this.registry && typeof meshTransporter.linkRegistry === 'function') {
+            meshTransporter.linkRegistry(this.registry);
+        }
+        if (this.#isRpcTransporter(meshTransporter)) {
+            subscription.add(this.#linkRpcTransporter(resolvedName, meshTransporter).subscribe());
+        }
+        if (this.#isPubsubTransporter(meshTransporter)) {
+            subscription.add(this.#linkPubsubTransporter(resolvedName, meshTransporter).subscribe());
+        }
+        if (this.#isDiscoveryTransporter(meshTransporter)) {
+            subscription.add(this.#linkDiscoveryTransporter(resolvedName, meshTransporter).subscribe());
+        }
+        return subscription;
     }
     listRpcNodes(service) {
-        return [...this.#nodes$.value.nodes.values()].filter(node => {
-            return !!node.rpc && node.services[service] != undefined;
-        });
+        if (!this.registry)
+            return [];
+        return this.registry.listPeers(service).filter(node => !!node.transporters.rpc);
     }
     watchService(service) {
-        return this.#nodes$.pipe(filter((e, i) => {
-            if (i == 0 || !e.last_updated_node_id)
-                return true;
-            if (e.last_updated_node_id.startsWith('offline:')) {
-                return e.last_updated_node_id.split(':')[1].includes(service);
-            }
-            const node = e.nodes.get(e.last_updated_node_id);
-            return node ? node.services[service] != undefined : false;
-        }), map(e => [...e.nodes.values()].filter(node => node.services[service] != undefined)));
+        if (!this.registry)
+            return EMPTY;
+        return this.registry.watch(service).pipe(map(() => this.listRpcNodes(service)));
     }
-    #selectRpcTarget(filters = {}) {
+    #selectRpcTransport(filters = {}) {
         if (!filters.service)
-            return null;
-        if (filters.node_id) {
-            const node = this.#nodes$.value.nodes.get(filters.node_id);
-            if (!node)
-                return null;
-            if (!node.services[filters.service])
-                return null;
-            if (!node.rpc)
-                return null;
-            const transporter = this.#rpcs.get(node.rpc);
-            if (!transporter)
-                return null;
-            return { node, transporter };
+            return undefined;
+        if (filters.transporter) {
+            const name = typeof filters.transporter === 'string' ? filters.transporter : filters.transporter.name;
+            if (!name)
+                return;
+            return this.#transporters.rpcs.get(name);
         }
-        const nodes = this.listRpcNodes(filters.service).map(node => {
-            const transporter = node.rpc && this.#rpcs.get(node.rpc);
-            if (transporter) {
-                return { node, transporter };
-            }
-            return null;
-        }).filter(Boolean).map(node => node);
-        if (nodes.length === 0)
-            return null;
-        const index = this.#rpc.indexes.get(filters.service) || 0;
-        this.#rpc.indexes.set(filters.service, (index + 1) % nodes.length);
-        return nodes[index % nodes.length];
+        if (!this.registry) {
+            return this.#transporters.rpcs.values().next().value;
+        }
+        const name = this.registry.getRpcTransporterName(filters.service);
+        if (!name)
+            return;
+        const transporter = this.#transporters.rpcs.get(name);
+        return transporter;
     }
     #normalizeRpcError(error) {
         if (error && typeof error === 'object') {
@@ -115,24 +103,6 @@ export class SpiderMesh {
         }
         return { message: typeof error === 'string' ? error : 'Unknown RPC error' };
     }
-    #sendRpcPacket(transporter, node, packet) {
-        return transporter.send(packet, node);
-    }
-    #resolveRpcNode(node_id) {
-        const known = this.#nodes$.value.nodes.get(node_id);
-        if (known) {
-            return known;
-        }
-        return {
-            node_id,
-            namespace: this.namespace,
-            host: '',
-            version: 0,
-            services: {},
-            nodes: {},
-            transporters: {}
-        };
-    }
     #completePendingRpc(request_id) {
         this.#rpc.pending.delete(request_id);
     }
@@ -140,7 +110,10 @@ export class SpiderMesh {
         this.#rpc.running.delete(request_id);
     }
     callRemoteService(options) {
-        return this.#nodes$.pipe(map(() => this.#selectRpcTarget(options)), filter(Boolean), take(1), mergeMap(target => {
+        return of(1).pipe(switchMap(() => this.registry ? firstValueFrom(this.registry.watch(options.service)) : of(1)), take(1), mergeMap(() => {
+            const transporter = this.#selectRpcTransport(options);
+            if (!transporter)
+                throw { code: 'MICROSERVICE_OFFLINE', message: `No transporter available for service ${options.service}` };
             return new Observable(subscriber => {
                 const request_id = `${this.node_id}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
                 const pending = {
@@ -159,29 +132,20 @@ export class SpiderMesh {
                         subscriber.complete();
                     }
                 });
-                this.#sendRpcPacket(target.transporter, target.node, {
+                transporter.send({
                     kind: 'request',
                     request_id,
-                    source_node_id: this.node_id,
-                    target_node_id: target.node.node_id,
+                    sender_node_id: this.node_id,
                     service: options.service,
                     method: options.method,
                     args: options.args
-                }).catch(error => {
+                }, options.node_id).catch((error) => {
                     pending.finished = true;
                     pending.stream.error(this.#normalizeRpcError(error));
                     this.#completePendingRpc(request_id);
                 });
                 return () => {
                     subscription.unsubscribe();
-                    if (!pending.finished && this.#rpc.pending.has(request_id)) {
-                        void this.#sendRpcPacket(target.transporter, target.node, {
-                            kind: 'cancel',
-                            request_id,
-                            source_node_id: this.node_id,
-                            target_node_id: target.node.node_id,
-                        }).catch(() => undefined);
-                    }
                     this.#completePendingRpc(request_id);
                 };
             });
@@ -203,83 +167,75 @@ export class SpiderMesh {
         }));
     }
     #linkRpcTransporter(name, transporter) {
-        if (this.#rpcs.has(name))
-            return EMPTY;
-        this.#rpcs.set(name, transporter);
+        this.#transporters.rpcs.set(name, transporter);
+        this.#ensureLocalTransporterPresence(name);
         const initialEndpoints = transporter.metadata;
         if (initialEndpoints) {
-            this.#metadata$.next({
-                ...this.#metadata$.value,
+            this.#refresh({
                 transporters: {
-                    ...this.#metadata$.value.transporters,
                     [name]: initialEndpoints
-                },
-                version: this.#metadata$.value.version + 1
+                }
             });
         }
         return transporter.pipe(map(({ rpc, offline, endpoints }) => {
             if (rpc) {
-                const packet = rpc.packet;
-                if (packet?.kind === 'request') {
-                    if (packet.target_node_id === this.node_id) {
-                        const reply = async (response) => {
-                            await this.#sendRpcPacket(transporter, this.#resolveRpcNode(rpc.node_id), {
-                                kind: 'response',
-                                request_id: packet.request_id,
-                                source_node_id: this.node_id,
-                                target_node_id: rpc.node_id,
-                                ...response
+                const packet = rpc;
+                if (packet.kind == 'request') {
+                    const reply = async (response) => {
+                        await transporter.send({
+                            kind: 'response',
+                            request_id: packet.request_id,
+                            ...response
+                        }, packet.sender_node_id);
+                    };
+                    const handleResponse = (response) => {
+                        if (isSubscribable(response)) {
+                            let queue = Promise.resolve();
+                            const running = response.subscribe({
+                                next: data => {
+                                    queue = queue.then(() => reply({ data }));
+                                },
+                                error: error => {
+                                    queue = queue.then(() => reply({
+                                        error: this.#normalizeRpcError(error),
+                                        completed: true
+                                    })).finally(() => this.#completeRunningRpc(packet.request_id));
+                                },
+                                complete: () => {
+                                    queue = queue.then(() => reply({ completed: true })).finally(() => this.#completeRunningRpc(packet.request_id));
+                                }
                             });
-                        };
-                        const handleResponse = (response) => {
-                            if (isSubscribable(response)) {
-                                let queue = Promise.resolve();
-                                const running = response.subscribe({
-                                    next: data => {
-                                        queue = queue.then(() => reply({ data }));
-                                    },
-                                    error: error => {
-                                        queue = queue.then(() => reply({
-                                            error: this.#normalizeRpcError(error),
-                                            completed: true
-                                        })).finally(() => this.#completeRunningRpc(packet.request_id));
-                                    },
-                                    complete: () => {
-                                        queue = queue.then(() => reply({ completed: true })).finally(() => this.#completeRunningRpc(packet.request_id));
-                                    }
-                                });
-                                this.#rpc.running.set(packet.request_id, running);
-                                return;
-                            }
-                            void reply({ data: response, completed: true });
-                        };
-                        const service = this.#local_services.get(packet.service);
-                        if (!service || typeof service[packet.method] !== 'function') {
+                            this.#rpc.running.set(packet.request_id, running);
+                            return;
+                        }
+                        void reply({ data: response, completed: true });
+                    };
+                    const service = this.#localServices.get(packet.service);
+                    if (!service || typeof service[packet.method] !== 'function') {
+                        void reply({
+                            error: {
+                                code: 'MICROSERVICE_NOT_FOUND',
+                                message: `Service ${packet.service}.${packet.method} not found`
+                            },
+                            completed: true
+                        });
+                    }
+                    else {
+                        try {
+                            const response = service[packet.method].apply(service, packet.args);
+                            Promise.resolve(response)
+                                .then(handleResponse)
+                                .catch(error => reply({
+                                error: this.#normalizeRpcError(error),
+                                completed: true
+                            }));
+                        }
+                        catch (error) {
                             void reply({
-                                error: {
-                                    code: 'MICROSERVICE_NOT_FOUND',
-                                    message: `Service ${packet.service}.${packet.method} not found`
-                                },
+                                error: this.#normalizeRpcError(error),
                                 completed: true
                             });
                         }
-                        else {
-                            try {
-                                const response = service[packet.method].apply(service, packet.args);
-                                Promise.resolve(response)
-                                    .then(handleResponse)
-                                    .catch(error => reply({
-                                    error: this.#normalizeRpcError(error),
-                                    completed: true
-                                }));
-                            }
-                            catch (error) {
-                                void reply({
-                                    error: this.#normalizeRpcError(error),
-                                    completed: true
-                                });
-                            }
-                        }
                     }
                 }
                 if (packet?.kind === 'response') {
@@ -301,49 +257,40 @@ export class SpiderMesh {
                     }
                 }
                 if (packet?.kind === 'cancel') {
-                    if (packet.target_node_id === this.node_id) {
-                        const stream = this.#rpc.running.get(packet.request_id);
-                        if (stream) {
-                            stream.unsubscribe();
-                            this.#completeRunningRpc(packet.request_id);
-                        }
+                    const stream = this.#rpc.running.get(packet.request_id);
+                    if (stream) {
+                        stream.unsubscribe();
+                        this.#completeRunningRpc(packet.request_id);
                     }
                 }
             }
             if (offline) {
-                const nodes = this.#nodes$.value.nodes;
-                const node = nodes.get(offline);
-                if (node) {
-                    nodes.delete(offline);
-                    this.#nodes$.next({ nodes, last_updated_node_id: `offline:${Object.keys(node.services).join(',')}` });
-                }
+                this.registry?.removePeer(offline);
             }
             if (endpoints) {
-                this.#metadata$.next({
-                    ...this.#metadata$.value,
+                this.#refresh({
                     transporters: {
-                        ...this.#metadata$.value.transporters,
                         [name]: endpoints
-                    },
-                    version: this.#metadata$.value.version + 1
+                    }
                 });
             }
-        }), finalize(() => {
-            this.#rpcs.delete(name);
-        }));
+        }), finalize(() => undefined));
     }
     #linkPubsubTransporter(name, transporter) {
-        const transporters = this.#pubsubs.getValue();
-        transporters.set(name, transporter);
-        this.#pubsubs.next(transporters);
-        return NEVER.pipe(finalize(() => {
-            transporters.delete(name);
-            this.#pubsubs.next(transporters);
-        }));
+        this.#transporters.pubsubs.set(name, transporter);
+        this.#ensureLocalTransporterPresence(name);
+        return transporter.pipe(tap(({ endpoints }) => {
+            this.#refresh({
+                transporters: {
+                    [name]: endpoints
+                }
+            });
+        }), finalize(() => undefined));
     }
     #linkDiscoveryTransporter(name, transporter) {
-        this.#discovers.set(name, transporter);
-        const announce = this.#metadata$.subscribe(metadata => {
+        this.#transporters.discoveries.set(name, transporter);
+        this.#ensureLocalTransporterPresence(name);
+        const announce = this.#me$.subscribe(metadata => {
             void transporter.broadcast({
                 hi: true,
                 node: metadata,
@@ -353,52 +300,93 @@ export class SpiderMesh {
         return transporter.pipe(tap(({ discovered: node }) => {
             if (!node || typeof node !== 'object' || !('node_id' in node) || !('services' in node))
                 return;
-            const nodes = this.#nodes$.value.nodes;
-            const rpc = Object.keys(node.transporters || {}).find(key => this.#rpcs.has(key));
-            nodes.set(node.node_id, {
-                ...nodes.get(node.node_id) || {},
+            const rpcTransporterName = this.#resolveDiscoveredRpcTransporterName(node);
+            const peer = this.registry?.upsertPeer(rpcTransporterName ? {
                 ...node,
-                rpc
-            });
-            this.#nodes$.next({
-                nodes,
-                last_updated_node_id: node.node_id
-            });
+                transporters: {
+                    ...(node.transporters || {}),
+                    rpc: rpcTransporterName
+                }
+            } : node);
+            if (!this.registry || !peer)
+                return;
         }), finalize(() => {
             announce.unsubscribe();
-            this.#discovers.delete(name);
         }));
     }
-    #linkTransporters() {
-        return from(this.options.transporters).pipe(mergeMap(entry => {
-            const transporter = typeof entry === 'function' ? new entry() : entry;
-            const name = typeof entry === 'function'
-                ? entry.name
-                : transporter.constructor?.name || 'AnonymousTransporter';
-            const links = [];
-            if ('send' in transporter) {
-                links.push(this.#linkRpcTransporter(name, transporter));
-            }
-            if ('publish' in transporter) {
-                links.push(this.#linkPubsubTransporter(name, transporter));
+    #isRpcTransporter(transporter) {
+        return 'send' in transporter;
+    }
+    #isPubsubTransporter(transporter) {
+        return 'publish' in transporter;
+    }
+    #isDiscoveryTransporter(transporter) {
+        return 'broadcast' in transporter;
+    }
+    #refresh(patch) {
+        const current = this.#me$.value;
+        this.#me$.next({
+            ...current,
+            ...patch,
+            version: current.version + 1,
+            topics: patch.topics || current.topics,
+            services: {
+                ...current.services,
+                ...(patch.services || {})
+            },
+            nodes: {
+                ...current.nodes,
+                ...(patch.nodes || {})
+            },
+            transporters: {
+                ...current.transporters,
+                ...(patch.transporters || {})
             }
-            if ('broadcast' in transporter) {
-                links.push(this.#linkDiscoveryTransporter(name, transporter));
+        });
+    }
+    #ensureLocalTransporterPresence(name) {
+        if (Object.hasOwn(this.#me$.value.transporters, name))
+            return;
+        this.#refresh({
+            transporters: {
+                [name]: true
             }
-            if (links.length === 0)
-                return EMPTY;
-            if (links.length === 1)
-                return links[0];
-            return from(links).pipe(mergeAll());
-        })).subscribe();
+        });
+    }
+    #resolveDiscoveredRpcTransporterName(node) {
+        for (const [name] of this.#transporters.rpcs.entries()) {
+            if (node.transporters && Object.hasOwn(node.transporters, name))
+                return name;
+        }
+        return null;
+    }
+    #registerTopic(topic) {
+        if (this.#me$.value.topics.includes(topic))
+            return;
+        this.#refresh({
+            topics: [...this.#me$.value.topics, topic]
+        });
+    }
+    #unregisterTopic(topic) {
+        if (!this.#me$.value.topics.includes(topic))
+            return;
+        this.#refresh({
+            topics: this.#me$.value.topics.filter(item => item !== topic)
+        });
     }
     linkEvent(factory) {
         const topic = factory.name;
+        const listen$ = new Observable(subscriber => {
+            this.#registerTopic(topic);
+            const subscription = from(this.#transporters.pubsubs.values()).pipe(mergeMap(t => t.listen(topic))).subscribe(subscriber);
+            return () => {
+                subscription.unsubscribe();
+                this.#unregisterTopic(topic);
+            };
+        }).pipe(share());
         return {
-            publish: (data) => lastValueFrom(from(this.#pubsubs.getValue().values()).pipe(mergeMap(t => t.publish(topic, data))), { defaultValue: undefined }),
-            listen: () => {
-                return this.#pubsubs.pipe(map(list => [...list.values()]), mergeAll(), mergeMap(t => t.listen(topic)));
-            }
+            publish: (data) => lastValueFrom(from(this.#transporters.pubsubs.values()).pipe(mergeMap(t => t.publish(topic, data))), { defaultValue: undefined }),
+            listen: () => listen$
         };
     }
 }