@spider-mesh/core 1.0.9965 → 2.0.2

package/build/src/SpiderMesh.js

@@ -1,297 +1,237 @@
-import { randomUUID } from 'crypto';
-import { get } from 'http';
-import { networkInterfaces } from 'os';
-import { DeepProxy } from './decorators/DeepProxy.js';
-import { RPCOptionsList } from './RPCOptions.js';
-import os from 'os';
-import { listEventSubscribers } from './decorators/ListenEvent.js';
-import { listReadyHookMethods } from './decorators/OnMicroserviceReady.js';
-import { BehaviorSubject, Subject, bufferTime, filter, from, map, mergeAll, mergeMap, throttleTime } from 'rxjs';
-import { readFileSync } from 'fs';
-import { serviceInstanceList } from './decorators/Microservice.js';
-import { sleep } from './helpers/sleep.js';
-import { BuiltinTransporter } from './builtin-transporter/BuiltinTransporter.js';
-import { DEBUG, NAMEPSACE, NODE_ID } from './const.js';
-export class SpiderMeshConfig {
-    namespace;
-    node_id;
-    transporter;
-}
-const PACKAGE_JSON = JSON.parse(readFileSync(`package.json`, 'utf8')) || {};
+import { BehaviorSubject, catchError, EMPTY, filter, finalize, firstValueFrom, from, lastValueFrom, map, mergeAll, mergeMap, of, retry, tap, throwError, timeout, timer } from "rxjs";
+import { listBeforeMicroserviceOnlineMethods } from "./decorators/BeforeMicroserviceOnline.js";
+import { PubsubTransporter } from "./interfaces/PubsubTransporter.js";
+import { RpcTransporter } from "./interfaces/RpcTransporter.js";
+import { MicroserviceException } from "./helpers/MicroserviceException.js";
+import { MicroserviceOfflineException } from "./helpers/MicroserviceOfflineException.js";
+import { services$ } from "./decorators/Microservice.js";
+import { networkInterfaces } from "os";
+import { MicroserviceNotFound } from "./helpers/MicroserviceNotFound.js";
+import { DiscoveryTransporter } from "./interfaces/DiscoveryTransporter.js";
+import { SPIDERMESH_NAMESPACE } from "const.js";
+import { MicroserviceRpcTimeout } from "./helpers/MicroserviceRpcTimeout.js";
 export class SpiderMesh {
-    transporter;
-    #$isolated = new BehaviorSubject(false);
-    #local_rpc_services = new Map();
-    #remote_rpc_services = new Map;
-    #linked_nodes = new Map();
-    #rpc_queue = new Map;
-    #public_ip = new Promise(async (s) => {
-        for (let i = 1; i <= 5; i++) {
-            const ip = await new Promise(s => {
-                get('http://api.ipify.org', (res) => {
-                    res.setEncoding('utf8');
-                    let rawData = '';
-                    res.on('data', (chunk) => { rawData += chunk; });
-                    res.on('end', () => s(rawData));
-                }).on('error', () => s(null));
-            });
-            if (ip && ip != 'Bad Gateway')
-                return s(ip);
-            await new Promise(s => setTimeout(s, 100));
-        }
-        return s(null);
+    node_id = `${Date.now()}`;
+    namespace = SPIDERMESH_NAMESPACE;
+    #rpcs = new Map();
+    #pubsubs = new BehaviorSubject(new Map());
+    #discovers = new Map();
+    #metadata$ = new BehaviorSubject({
+        ips: Object.values(networkInterfaces()).flat(2).filter(a => !a?.internal && !!a?.address).map(a => a?.address),
+        host: '',
+        namespace: SPIDERMESH_NAMESPACE,
+        node_id: this.node_id,
+        services: {},
+        topics: [],
+        transporters: {},
+        nodes: {},
+        version: 0
     });
-    $nodes_monitor = new Subject();
-    #initing;
-    constructor(transporter = new BuiltinTransporter(NODE_ID, NAMEPSACE)) {
-        this.transporter = transporter;
-        DEBUG && console.log(`Node online : ${NODE_ID}`);
-        this.#initing = this.#init();
-    }
-    static add_transporter(transporter) {
-        new this(transporter);
-    }
-    async $metadata(revalidate_on_join) {
-        const ips = Object.values(networkInterfaces()).map(itf => itf?.map(ip => ip.address) || []).flat(2);
-        const services = [...this.#local_rpc_services.entries()].reduce((p, [service_id, { metadata }]) => ({ ...p, [service_id]: metadata }), {});
-        const metadata = {
-            id: this.transporter.node_id,
-            name: PACKAGE_JSON?.name || 'UNKNOWN',
-            version: PACKAGE_JSON?.version || '1.0.0',
-            path: process.cwd(),
-            uptime: process.uptime(),
-            hostname: os.hostname(),
-            plaform: os.platform(),
-            node_version: process.version,
-            public_ip: await this.#public_ip,
-            ip_addresses: ips,
-            last_online: Date.now(),
-            active: true,
-            online: true,
-            services,
-            namespace: this.transporter.namespace,
-            linked: [...this.#linked_nodes.keys()],
-            isolated_nodes: [...new Set([...this.#linked_nodes.values()].filter(node => node.isolate).map(node => node.id))],
-            isolate: this.#$isolated.value,
-            revalidate_on_join
-        };
-        return metadata;
-    }
-    async $update_isolate_mode(active) {
-        this.#$isolated.next(active);
-        const me = await this.$metadata();
-        await this.publish('#join', me);
-        return me;
-    }
-    async #node_event_handler({ data: msg, sender_node_id }) {
-        if (msg.type == 'rpc') {
-            if (msg.service == 'SpiderMesh' && !msg.method.startsWith('$')) {
-                sender_node_id && this.transporter.publish({
-                    data: [{
-                            id: msg.id,
-                            type: 'error',
-                            error: 'NOT_ALLOW'
-                        }],
-                    event: sender_node_id,
-                    node_id: sender_node_id
-                });
-                return;
-            }
-            const instance = msg.service == 'SpiderMesh' ? this : this.#local_rpc_services.get(msg.service)?.instance;
-            if (!instance)
-                return this.transporter.publish({
-                    data: [{
-                            id: msg.id,
-                            type: 'error',
-                            error: 'SERVICE_NOT_FOUND'
-                        }],
-                    event: sender_node_id,
-                    node_id: sender_node_id
-                });
-            if (typeof instance?.[msg.method] != 'function')
-                return this.transporter.publish({
-                    data: [{
-                            id: msg.id,
-                            type: 'error',
-                            error: 'SERVICE_METHOD_NOT_FOUND'
-                        }],
-                    event: sender_node_id,
-                    node_id: sender_node_id
-                });
-            const args = msg.args.map(arg => arg != '__FUNCTION__' ? arg : (...args) => {
-                sender_node_id && this.transporter.publish({
-                    event: sender_node_id,
-                    node_id: sender_node_id,
-                    data: [{ id: msg.id, type: 'callback', args }]
-                });
-            });
-            try {
-                const response = await instance?.[msg.method]?.(...args);
-                sender_node_id && this.transporter.publish({
-                    event: sender_node_id,
-                    node_id: sender_node_id,
-                    data: [{ id: msg.id, type: 'response', response }]
-                });
-            }
-            catch (error) {
-                sender_node_id && this.transporter.publish({
-                    event: sender_node_id,
-                    node_id: sender_node_id,
-                    data: [{ id: msg.id, type: 'error', error: error?.code || error?.message || error || 'UNKNOWN' }]
-                });
+    #nodes = new BehaviorSubject({
+        nodes: new Map(),
+        last_updated_node_id: ''
+    });
+    #services$ = new BehaviorSubject(new Map());
+    constructor() {
+        services$.pipe(filter(list => Object.keys(list).length > 0), mergeMap(async (services) => {
+            for (const v of Object.values(services)) {
+                const metadata = v['$'] || (typeof v.metadata == 'function' ? await v.metadata() : v.metadata);
+                Object.defineProperty(v, '$', { value: metadata });
             }
-            return;
-        }
-        const request = this.#rpc_queue.get(msg.id);
-        if (!request)
-            return;
-        if (msg.type == 'callback') {
-            request.args?.[msg.index]?.();
-            return;
-        }
-        if (msg.type == 'ack') {
-            request.last_ping = Date.now();
-            return;
-        }
-        if (msg.type == 'error') {
-            request.reject(msg.error);
-            this.#rpc_queue.delete(msg.id);
-            return;
-        }
-        if (msg.type == 'response') {
-            request.success(msg.response);
-            this.#rpc_queue.delete(msg.id);
-            return;
-        }
-    }
-    async #init() {
-        await this.transporter.start();
-        this.listen(this.transporter.node_id).subscribe(evt => this.#node_event_handler(evt));
-        this.listen('#join').subscribe(({ data }) => {
-            this.#on_node_discovered(data);
-        });
-        this.transporter.$nodes_status.subscribe(async ({ node_id, online }) => {
-            !online && this.#on_node_offline(node_id);
-            online && this.transporter.publish({
-                event: '#join',
-                data: [await this.$metadata()],
-                node_id
-            });
-        });
-        serviceInstanceList.pipe(filter(i => i.namespace == this.transporter.namespace), mergeMap(async ({ instance, metadata }) => {
-            await this.#active_local_service(instance, metadata);
-            await this.#active_ready_hooks(instance);
-        }), throttleTime(1000), mergeMap(async () => {
-            const me = await this.$metadata();
-            await this.publish('#join', me);
-        })).subscribe();
+            return services;
+        }), tap(services => {
+            const metadata = {
+                ...this.#metadata$.value,
+                services: Object.entries(services).reduce((p, [name, v]) => {
+                    return {
+                        ...p,
+                        [name]: v['$']
+                    };
+                }, {}),
+                version: this.#metadata$.value.version + 1
+            };
+            this.#metadata$.next(metadata);
+        }), catchError(e => EMPTY)).subscribe();
     }
-    async #on_node_discovered(node) {
-        if (node.id == this.transporter.node_id)
-            return;
-        if (this.#$isolated.value)
-            return;
-        const peer_updated = node.linked.includes(this.transporter.node_id);
-        DEBUG && console.log(`[${new Date().toLocaleString()}:${new Date().getMilliseconds()}] New node `, node, { peer_updated });
-        const new_node = {
-            ...node,
-            online: true
-        };
-        this.#linked_nodes.set(node.id, new_node);
-        (!peer_updated || node.revalidate_on_join) && await this.transporter.publish({
-            event: '#join',
-            data: [await this.$metadata(!peer_updated)],
-            node_id: node.id
-        });
-        peer_updated && Object.values(node.services).forEach(({ instance: service }) => {
-            const $service = this.#remote_rpc_services.get(service);
-            if (!$service) {
-                this.#remote_rpc_services.set(service, {
-                    last_call_index: -1,
-                    nodes: [node]
-                });
-                return;
+    #selectRpcTarget(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 };
+        }
+        const state = this.#services$.value.get(filters.service);
+        if (!state || state.nodes.length == 0)
+            return null;
+        const nodes = state.nodes.map(id => {
+            const node = this.#nodes.value.nodes.get(id);
+            const transporter = node && node.rpc && this.#rpcs.get(node.rpc);
+            if (node && transporter) {
+                if (filters.ip) {
+                    if (!node.ips.includes(filters.ip))
+                        return null;
+                }
+                return { node, transporter };
             }
-            if ($service.nodes) {
-                const index = $service.nodes.findIndex(n => n.id == new_node.id);
-                index >= 0 ? ($service.nodes[index] = new_node) : $service.nodes.push(new_node);
+        }).filter(Boolean).map(e => e);
+        return nodes[state.index++ % nodes.length];
+    }
+    callRemoteService(options) {
+        return of(0).pipe(mergeMap(async () => {
+            await this.waitServiceOnline(options.service);
+            const target = this.#selectRpcTarget(options);
+            if (!target)
+                throw new MicroserviceOfflineException();
+            const force = !!options.node_id || !!options.ip;
+            return target.transporter.rpc(options, target.node, force);
+        }), mergeMap($ => $), retry({
+            delay: (e, count) => {
+                if (e instanceof MicroserviceOfflineException || e.message == MicroserviceOfflineException.code) {
+                    if (options.retry && count < options.retry)
+                        return timer(1000);
+                }
+                throw e;
             }
-            else {
-                $service.nodes = [new_node];
+        }), options.timeout ? timeout({
+            each: options.timeout,
+            with: () => throwError(() => new MicroserviceRpcTimeout())
+        }) : tap(), catchError(e => {
+            if (options.fallback != undefined)
+                return of(options.fallback);
+            if (e.code) {
+                const error = new MicroserviceException(e);
+                error.stack = e.stack;
+                throw error;
             }
-        });
-        this.$nodes_monitor.next(node);
+            throw e;
+        }));
     }
-    async #on_node_offline(id) {
-        DEBUG && console.log(`[${new Date().toLocaleString()}] Node ${id} offline`);
-        for (const service of this.#remote_rpc_services.values()) {
-            service.nodes = service.nodes.filter(node => node.id != id);
-        }
-        for (const [rid, { target_node_id, reject }] of this.#rpc_queue) {
-            if (target_node_id == id) {
-                reject(new Error('SERVICE_OFFLINE'));
-                this.#rpc_queue.delete(rid);
-            }
+    linkTransporter(transporter) {
+        const transporter_name = Object.getPrototypeOf(transporter).constructor.name;
+        if (transporter instanceof RpcTransporter) {
+            const rpc = transporter;
+            if (this.#rpcs.has(transporter_name))
+                return;
+            this.#rpcs.set(transporter_name, rpc);
+            return transporter.link(this.#nodes).pipe(map(e => {
+                const rpc = e.rpc;
+                if (rpc) {
+                    try {
+                        const service = services$.value[rpc.service];
+                        const instance = service?.instance;
+                        if (!instance)
+                            return rpc.callback(throwError(() => new MicroserviceNotFound()));
+                        const response = instance[rpc.method](...rpc.args);
+                        rpc.callback(response);
+                    }
+                    catch (err) {
+                        rpc.callback(throwError(() => err));
+                    }
+                }
+                const online = e.online;
+                if (online) {
+                    const node = this.#nodes.value.nodes.get(online);
+                    if (node) {
+                        node.rpc = transporter_name;
+                        for (const service of Object.keys(node.services || {})) {
+                            const services = this.#services$.value;
+                            const target = services.get(service) || { index: 0, nodes: [] };
+                            services.set(service, {
+                                index: target.index,
+                                nodes: [
+                                    ...target.nodes.filter(id => id != node.node_id),
+                                    node.node_id
+                                ]
+                            });
+                            this.#services$.next(services);
+                        }
+                    }
+                }
+                const offline = e.offline;
+                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: node.node_id });
+                        for (const service of Object.values(node.services)) {
+                            const services = this.#services$.value;
+                            const target = services.get(service) || { index: 0, nodes: [] };
+                            const nodes = target.nodes.filter(id => id != node.node_id);
+                            nodes.length == 0 ? services.delete(service) : services.set(service, { ...target, nodes });
+                            this.#services$.next(services);
+                        }
+                    }
+                }
+                const metadata = e.metadata;
+                if (metadata) {
+                    this.#metadata$.next({
+                        ...this.#metadata$.value,
+                        transporters: {
+                            ...this.#metadata$.value.transporters,
+                            [transporter_name]: metadata
+                        },
+                        version: this.#metadata$.value.version + 1
+                    });
+                }
+            }), finalize(() => {
+                this.#rpcs.delete(transporter_name);
+            })).subscribe();
         }
-        const node = this.#linked_nodes.get(id);
-        node && this.$nodes_monitor.next({ ...node, online: false });
-    }
-    #caculate_rpc_node_id(service_name, options = {}) {
-        const current = this.#remote_rpc_services.get(service_name);
-        if (!current || current.nodes.length == 0)
-            return;
-        if (options.$node_id) {
-            if (current.nodes.some(node => node.id == options.$node_id))
-                return options.$node_id;
-            return;
+        if (transporter instanceof PubsubTransporter) {
+            const transporters = this.#pubsubs.getValue();
+            transporters.set(transporter_name, transporter);
+            this.#pubsubs.next(transporters);
+            return transporter.link(this.#nodes).pipe(map(a => a.metadata), filter(Boolean), tap(metadata => {
+                this.#metadata$.next({
+                    ...this.#metadata$.value,
+                    transporters: {
+                        ...this.#metadata$.value.transporters,
+                        [transporter_name]: metadata
+                    },
+                    version: this.#metadata$.value.version + 1
+                });
+            }), finalize(() => {
+                transporters.delete(transporter_name);
+                this.#pubsubs.next(transporters);
+            })).subscribe();
         }
-        if (options.$ip) {
-            const node = current
-                .nodes
-                .filter(node => node.public_ip == options.$ip || node.ip_addresses.includes(options.$ip))
-                .sort((a, b) => b.last_online - a.last_online)[0];
-            return node ? node.id : null;
+        if (transporter instanceof DiscoveryTransporter) {
+            const discover = transporter;
+            this.#discovers.set(transporter_name, discover);
+            return discover.link(this.#metadata$).pipe(tap(node => {
+                const nodes = this.#nodes.value.nodes;
+                nodes.set(node.node_id, {
+                    ...nodes.get(node.node_id) || {},
+                    ...node
+                });
+                const last_updated_node_id = node.node_id;
+                this.#nodes.next({
+                    nodes,
+                    last_updated_node_id
+                });
+            }), finalize(() => this.#discovers.delete(transporter_name))).subscribe();
         }
-        const index = ++current.last_call_index % current.nodes.length;
-        return current.nodes[index].id;
     }
-    async rpc(service, method, args, options) {
-        await this.#initing;
-        return await new Promise(async (success, r) => {
-            const reject = (err) => (options.$fallback !== undefined) ? success(options.$fallback) : r(err);
-            const rid = randomUUID();
-            options.$timeout && setTimeout(() => {
-                reject(new Error('TIMEOUT'));
-                this.#rpc_queue.delete(rid);
-            }, options.$timeout);
-            !options.$nevermind && this.#rpc_queue.set(rid, {
-                args,
-                last_ping: 0,
-                reject,
-                request_time: Date.now(),
-                success,
-                timeout: options.$timeout,
-                target_node_id: options.$node_id
-            });
-            const retry_count = options.$retry || 1;
-            for (let i = retry_count; i > 0; i--) {
-                try {
-                    const node_id = this.#caculate_rpc_node_id(service, options);
-                    if (!node_id)
-                        return reject(Object.assign(new Error(`SERVICE_NOT_RUNNING:${service}`), { service }));
-                    await this.publish(service, { type: 'rpc', id: rid, args, method, service }, node_id);
-                    return;
-                }
-                catch (e) { }
-                i > 1 && await new Promise(s => setTimeout(s, options.$retry_delay || 1000));
-            }
-            if (options.$fallback)
-                return success(options.$fallback);
-        });
+    waitServiceOnline(service, check = (nodes => nodes.length > 0)) {
+        return firstValueFrom(this.#services$.pipe(map(() => {
+            const targets = this.#services$.value.get(service)?.nodes || [];
+            const nodes = targets.map(id => this.#nodes.value.nodes.get(id)).filter(Boolean);
+            return nodes;
+        }), mergeMap(async (targets) => check(targets)), filter(Boolean)));
     }
-    async link_remote_service(factory, wait_service_online = false) {
-        const service_name = factory.name;
-        const omit_properties = new Set([
+    linkRemoteService(factory) {
+        const service = factory.name;
+        const omitProperties = new Set([
             'caller',
             'callee',
             'arguments',
@@ -313,117 +253,110 @@ export class SpiderMesh {
             'beforeApplicationShutdown',
             'onApplicationShutdown'
         ]);
-        const actions = new Set();
-        for (let f = factory.prototype; f != null; f = Object.getPrototypeOf(f)) {
-            for (const method of Object.getOwnPropertyNames(f).filter(method => !omit_properties.has(method))) {
-                typeof f[method] == 'function' && actions.add(method);
-            }
-        }
-        if (!this.#remote_rpc_services.has(service_name)) {
-            this.#remote_rpc_services.set(service_name, { last_call_index: -1, nodes: [] });
-        }
-        wait_service_online && await this.#wait_service_online(service_name);
-        return new Proxy({}, {
-            get: (_, method) => {
-                if (method == '$wait_service_online') {
-                    return () => this.#wait_service_online(service_name);
+        const listRpcNodes = () => {
+            const targets = this.#services$.value.get(service);
+            if (!targets || targets.nodes.length == 0)
+                return [];
+            return targets.nodes.map(id => {
+                const node = this.#nodes.value.nodes.get(id);
+                if (node && node.rpc)
+                    return node;
+            }).filter(Boolean).map(node => node);
+        };
+        const target = new Proxy({}, {
+            get: (_, $) => {
+                if (omitProperties.has($))
+                    return null;
+                if ($ == 'wait$') {
+                    return (fn) => this.waitServiceOnline(service, fn);
                 }
-                if (method == '$watch')
-                    return () => this.$nodes_monitor.pipe(filter(node => !!node.services[service_name]));
-                if (method == '$list_nodes') {
-                    return (() => this.#remote_rpc_services.get(service_name)?.nodes.filter(node => !node.isolate).filter(node => node.online) || []);
+                if ($ == 'nodes')
+                    return listRpcNodes();
+                if ($ == 'watch$')
+                    return (fn = (nodes => nodes.length > 0)) => {
+                        return this.#services$.pipe(map(services => services.get(service)?.nodes || []), map(targets => targets.map(id => this.#nodes.value.nodes.get(id)).filter(Boolean)));
+                    };
+                if ($.startsWith('__batch__')) {
+                    const method = $.split('__batch__')?.[1];
+                    return (...args) => from(listRpcNodes()).pipe(mergeMap(node => (this.callRemoteService({
+                        service,
+                        args,
+                        method,
+                        node_id: node.node_id,
+                    }).pipe(map(data => ({ node, data })), catchError(e => of({ node, e }))))));
                 }
-                if (method.startsWith('$batch_')) {
-                    const real_method = method.split('$batch_')?.[1];
-                    if (!real_method || !actions.has(real_method))
-                        return null;
-                    const nodes = this.#remote_rpc_services.get(service_name)?.nodes.filter(node => !node.isolate) || [];
-                    return (...args) => {
-                        const o = new Subject();
-                        from(nodes).pipe(mergeMap(async (node) => {
+                if ($ == 'set') {
+                    return (options) => new Proxy({}, {
+                        get: (_, method) => {
+                            return (...args) => {
+                                const response = this.callRemoteService({
+                                    ...options,
+                                    args,
+                                    method,
+                                    service
+                                });
+                                return Object.assign(response, {
+                                    then: async (s, r) => {
+                                        try {
+                                            s(await firstValueFrom(response));
+                                        }
+                                        catch (e) {
+                                            r(e);
+                                        }
+                                    }
+                                });
+                            };
+                        }
+                    });
+                }
+                return (...args) => {
+                    const response = this.callRemoteService({
+                        args,
+                        method: $,
+                        service
+                    });
+                    return Object.assign(response, {
+                        then: async (s, r) => {
                             try {
-                                const data = await this.rpc(service_name, real_method, args, { $node_id: node.id });
-                                return { data, node, error: null };
+                                s(await firstValueFrom(response));
                             }
-                            catch (error) {
-                                return { node, data: null, error };
+                            catch (e) {
+                                r(e);
                             }
-                        })).subscribe(o);
-                        return o;
-                    };
-                }
-                if (actions.has(method) || method.startsWith('$')) {
-                    return new DeepProxy(method => RPCOptionsList.has(method), (method, options) => (async (...args) => {
-                        const safe = options.$safe_mode;
-                        try {
-                            const data = await this.rpc(service_name, method, args, options);
-                            return safe ? [null, data] : data;
                         }
-                        catch (e) {
-                            if (safe)
-                                return [e, null];
-                            throw e;
-                        }
-                    })).nest()[method];
-                }
-                return null;
+                    });
+                };
             }
         });
+        return new Proxy(target, {
+            get(target, p) {
+                if (p == 'then')
+                    return target;
+                return target[p];
+            },
+        });
     }
-    async link_event(event_factory, publish_buffer_ms) {
-        const $ = new Subject();
-        const $$ = publish_buffer_ms ? $.pipe(bufferTime(publish_buffer_ms), filter(l => l.length > 0)) : $;
-        $$.subscribe(data => this.publish(event_factory.name, data));
-        const event_hub = {
-            publish: async (data) => $.next(data),
-            listen: () => this.listen(event_factory.name)
+    linkEvent(factory) {
+        const topic = factory.name;
+        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)));
+            }
         };
-        return event_hub;
     }
-    async #active_local_service(instance, metadata) {
-        const prototype = Object.getPrototypeOf(instance);
-        const name = prototype.constructor.name;
-        this.#local_rpc_services.set(name, { instance, metadata });
-        this.listen(name).subscribe(evt => this.#node_event_handler(evt));
-        const event_subscribers = listEventSubscribers(prototype);
-        for (const { event, method, buffer_ms } of event_subscribers) {
-            const $ = this.listen(event).pipe(filter(() => !this.#$isolated.value));
-            const $$ = buffer_ms ? $.pipe(bufferTime(buffer_ms), filter(l => l.length > 0)) : $;
-            $$.subscribe(e => instance[method]?.(e));
-        }
-    }
-    async #wait_service_online(service_name = 'all') {
-        if (this.#remote_rpc_services.size == 0)
-            return;
-        while (true) {
-            await sleep(500);
-            const nodes = service_name == 'all' ? ([...this.#remote_rpc_services.values()].map(s => s.nodes).flat(2)) : (this.#remote_rpc_services.get(service_name)?.nodes || []);
-            if (nodes.length > 0)
-                break;
-        }
-    }
-    async #active_ready_hooks(instance) {
-        await this.#wait_service_online();
-        for (const { method } of listReadyHookMethods(Object.getPrototypeOf(instance))) {
-            instance[method]?.();
-        }
-    }
-    async publish(topic, payload, node_id) {
-        await this.#initing;
-        const event = typeof topic == 'string' ? topic : topic.name;
-        const data = Array.isArray(payload) ? payload : [payload];
-        this.transporter.publish({ event, data, node_id });
-    }
-    listen(topic) {
-        const topic_name = typeof topic == 'string' ? topic : topic.name;
-        return this.transporter.listen(topic_name).pipe(map(e => {
-            if (!Array.isArray(e.data))
-                return [];
-            return e.data.map(data => ({
-                data,
-                sender_node_id: e.sender_node_id
-            }));
-        }), mergeAll());
+    async exposeLocalService(name, instance) {
+        const hooks = listBeforeMicroserviceOnlineMethods(instance);
+        for (const method of hooks)
+            await instance[method];
+        services$.next({
+            ...services$.value,
+            [name]: {
+                instance,
+                metadata: {},
+                name
+            }
+        });
     }
 }
 //# sourceMappingURL=SpiderMesh.js.map