@spider-mesh/core 1.0.152 → 2.0.1

package/build/src/SpiderMesh.js

@@ -1,345 +1,237 @@
-import { DeepProxy } from './decorators/DeepProxy.js';
-import { RPCOptionsList } from './RPCOptions.js';
-import { listEventSubscribers } from './decorators/ListenEvent.js';
-import { BehaviorSubject, Observable, ReplaySubject, Subject, bufferTime, catchError, debounceTime, filter, firstValueFrom, from, groupBy, map, merge, mergeAll, mergeMap, of, pipe, retry, scan, share, tap, timeout, toArray } from 'rxjs';
-import { sleep } from './helpers/sleep.js';
-import { NAMEPSACE } from './const.js';
-import { $services } from './decorators/Microservice.js';
-import { randomUUID } from './helpers/randomUUID.js';
-import axios from 'axios';
-const $public_ip = new Promise(async (resolve) => {
-    try {
-        const { data } = await axios.get('https://api.ipify.org?format=json');
-        resolve(data.ip);
-    }
-    catch (error) {
-        resolve(undefined);
-    }
-});
+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 {
-    metadata;
-    static $transporters = new ReplaySubject();
-    #node_id = randomUUID();
-    #requests = new Map;
-    #local_services = new Map();
-    #remote_services = new Map;
-    #linked_nodes = new Map();
-    $nodes_monitor = new Subject();
-    #$isolated = new BehaviorSubject(false);
-    #transporters = new Map();
-    constructor(metadata = {}) {
-        this.metadata = metadata;
-        merge(SpiderMesh.$transporters.pipe(mergeMap(async (transporter) => {
-            await this.#link_transporter(transporter);
-            return transporter;
-        }), map(t => t.transporter_id)), $services.pipe(tap(({ instance, metadata }) => {
-            const prototype = Object.getPrototypeOf(instance);
-            const name = prototype.constructor.name;
-            this.#local_services.set(name, { instance, metadata });
-        }), map(() => undefined))).pipe(debounceTime(2000), mergeMap(async (transporter_id) => {
-            await this.#self_introduce(transporter_id);
-        }, 1)).subscribe();
+    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 = 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 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();
     }
-    #caculate_rpc_node_id(service_name, options = {}) {
-        const current = this.#remote_services.get(service_name);
-        if (!current || current.nodes.length == 0)
-            return;
-        if (options.$node_id) {
-            if (current.nodes.some(node => node.node_id == options.$node_id))
-                return options.$node_id;
-            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 option_ip = options.$ip;
-        const nodes = option_ip ? (current
-            .nodes
-            .filter(node => node.public_ip == option_ip)) : current.nodes;
-        if (nodes.length == 0)
-            return;
-        current.last_call_index = (current.last_call_index + 1) % nodes.length;
-        return nodes[current.last_call_index].node_id;
-    }
-    rpc(service, method, args, options = {}) {
-        const rpc_node_id = this.#caculate_rpc_node_id(service, options);
-        if (!rpc_node_id) {
-            const e = new Error(`SERVICE_NOT_RUNNING:${service}`, {
-                cause: {
-                    service,
-                    method,
-                    args,
-                    options
+        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 Object.assign(new Observable(o => o.error(e)), {
-                then: async (success, error) => {
-                    error(e);
-                },
-                async catch() {
-                    return {};
-                },
-                async finally() {
-                    return {};
-                },
-                [Symbol.toStringTag]: ''
-            });
-        }
-        if (options.$forgot) {
-            this.publish({
-                topic: rpc_node_id,
-                payload: [{
-                        request: {
-                            args,
-                            method,
-                            request_id: '#',
-                            service
-                        }
-                    }],
-                node_id: rpc_node_id
-            });
-            return;
-        }
-        const $ = new Observable($response => {
-            const request_id = randomUUID();
-            this.#requests.set(request_id, { $response, rpc_node_id });
-            this.publish({
-                topic: rpc_node_id,
-                payload: [{
-                        request: {
-                            args,
-                            method,
-                            request_id,
-                            service
-                        }
-                    }],
-                node_id: rpc_node_id
-            });
-            return () => {
-                this.#requests.delete(request_id);
-            };
-        }).pipe(retry({ count: options.$retry || 0, delay: options.$retry_delay || 1000 }), options.$timeout ? timeout(options.$timeout) : tap(), catchError(err => {
-            if (options.$fallback) {
-                return of(options.$fallback);
+                return { node, transporter };
             }
-            throw err;
-        }), share());
-        $.subscribe({ error: () => { }, next: () => { } });
-        return Object.assign($, {
-            then: async (success, error) => {
-                try {
-                    const value = await firstValueFrom($);
-                    success(options.$safe_mode ? [null, value] : value);
-                }
-                catch (e) {
-                    options.$safe_mode ? success([e, null]) : error(e);
-                }
-            },
-            async catch() {
-                return {};
-            },
-            async finally() {
-                return {};
-            },
-            [Symbol.toStringTag]: ''
-        });
+        }).filter(Boolean).map(e => e);
+        return nodes[state.index++ % nodes.length];
     }
-    async $metadata() {
-        const services = [...this.#local_services.entries()].reduce((p, [service_id, { metadata }]) => ({
-            ...p,
-            [service_id]: metadata
-        }), {});
-        const isolated_nodes = [
-            ...new Set([...this.#linked_nodes.values()]
-                .filter(node => node.isolated)
-                .map(node => node.local_transporter_id))
-        ];
-        const metadata = {
-            metadata: this.metadata,
-            node_id: this.#node_id,
-            node_version: process.version,
-            last_online: Date.now(),
-            online: true,
-            services,
-            namespace: NAMEPSACE,
-            linked: [...this.#linked_nodes.keys()],
-            isolated_nodes,
-            isolated: this.#$isolated.value,
-            public_ip: await $public_ip
-        };
-        return metadata;
-    }
-    async #self_introduce(local_transporter_id, node_id) {
-        const list = local_transporter_id ? [this.#transporters.get(local_transporter_id)] : [...this.#transporters.values()];
-        for (const target of list) {
+    callRemoteService(options) {
+        return of(0).pipe(mergeMap(async () => {
+            await this.waitServiceOnline(options.service);
+            const target = this.#selectRpcTarget(options);
             if (!target)
-                continue;
-            const me = {
-                ...await this.$metadata(),
-                local_transporter_id: target.transporter.transporter_id,
-                remote_transporter_id: '#OVERWRITE'
-            };
-            await this.publish({ payload: [me], topic: '#join', node_id }, target.transporter);
-        }
-    }
-    async $update_isolate_mode(active) {
-        this.#$isolated.next(active);
-        const me = await this.#self_introduce();
-        return me;
-    }
-    #get_rpc_target(msg) {
-        if (msg.service == 'SpiderMesh') {
-            if (!msg.method.startsWith('$'))
-                throw `SPIDER_MESH_METHOD_NOT_ALLOW`;
-            return this;
-        }
-        const service = this.#local_services.get(msg.service)?.instance;
-        if (!service)
-            throw 'RPC_SERVICE_NOT_FOUND';
-        if (typeof service[msg.method] != 'function')
-            throw 'RPC_METHOD_NOT_FOUND';
-        return service;
+                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;
+            }
+        }), 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;
+            }
+            throw e;
+        }));
     }
-    async #node_event_handler(transporter, { payload: event, metadata: { smnid } }) {
-        if (event.request) {
-            const response = (data) => {
-                const error = data.error ? (data.error instanceof Error ? {
-                    cause: data.error.cause,
-                    message: data.error.message,
-                    name: data.error.name,
-                    stack: data.error.stack
-                } : data.error) : undefined;
-                const payload = [{
-                        response: {
-                            request_id: event.request.request_id,
-                            ...data,
-                            error
-                        },
-                    }];
-                this.publish({
-                    payload,
-                    topic: smnid,
-                    node_id: smnid
-                }, transporter);
-            };
-            try {
-                const instance = this.#get_rpc_target(event.request);
-                try {
-                    const value = await instance?.[event.request.method]?.(...event.request.args || []);
-                    if (event.request.request_id == '#')
-                        return;
-                    if (value instanceof Observable) {
-                        value.subscribe({
-                            complete: () => response({ completed: true }),
-                            error: error => response({ error }),
-                            next: value => response({ data: { value } })
-                        });
-                        return;
+    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);
                     }
-                    else {
-                        response({ completed: true, data: { value } });
+                    catch (err) {
+                        rpc.callback(throwError(() => err));
                     }
                 }
-                catch (error) {
-                    if (event.request.request_id == '#')
-                        return;
-                    response({ error: error });
+                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);
+                        }
+                    }
                 }
-            }
-            catch (error) {
-                if (event.request.request_id == '#')
-                    return;
-                response({ error: error });
-            }
+                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();
         }
-        if (event.response) {
-            const request = this.#requests.get(event.response.request_id);
-            if (!request)
-                return;
-            if (event.response.data) {
-                request.$response.next(event.response.data.value);
-            }
-            if (event.response.completed) {
-                request.$response.complete();
-            }
-            if (event.response.error) {
-                request.$response.error(event.response.error);
-            }
+        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();
         }
-    }
-    async #link_transporter(transporter) {
-        this.#transporters.set(transporter.transporter_id, {
-            transporter,
-            nodes: new Map()
-        });
-        this.listen(this.#node_id, transporter).pipe(tap(msg => this.#node_event_handler(transporter, msg))).subscribe();
-        this.listen('#join', transporter).pipe(filter(node => node.metadata.smnid != this.#node_id), groupBy(node => node.metadata.smnid), mergeMap(grouped => grouped.pipe(debounceTime(500), map(({ payload, sti }) => ({
-            ...payload,
-            local_transporter_id: transporter.transporter_id,
-            remote_transporter_id: sti,
-        })), filter(node => node.node_id != this.#node_id), mergeMap(node => this.#on_node_discovered(node), 1)))).subscribe();
-        transporter.$nodes_status.pipe(tap(node => !node.online && this.#on_node_offline(transporter.transporter_id, node.remote_transporter_id)), groupBy(node => node.remote_transporter_id), mergeMap(grouped => grouped.pipe(scan((prev, current) => {
-            if (!prev || (prev.online != current.online))
-                return current;
-            return undefined;
-        }, undefined), filter(Boolean), map(node => node), filter(node => node.online), tap(node => this.#self_introduce(transporter.transporter_id))))).subscribe();
-        $services.subscribe(({ instance }) => {
-            const prototype = Object.getPrototypeOf(instance);
-            const name = prototype.constructor.name;
-            this.listen(name, transporter).subscribe(evt => this.#node_event_handler(transporter, evt));
-            const event_subscribers = listEventSubscribers(prototype);
-            for (const { event, method, buffer_ms } of event_subscribers) {
-                this.listen(event, transporter).pipe(filter(() => !this.#$isolated.value), buffer_ms ? pipe(bufferTime(buffer_ms), filter(l => l.length > 0)) : pipe(map(item => [item]))).subscribe(e => instance[method]?.(e, this));
-            }
-        });
-    }
-    async #on_node_discovered(node) {
-        if (node.node_id == this.#node_id)
-            return;
-        const saved_node = this.#linked_nodes.get(node.node_id);
-        if (saved_node && saved_node.last_online > node.last_online)
-            return;
-        const peer_updated = node.linked.includes(this.#node_id);
-        const new_node = {
-            ...node,
-            online: true
-        };
-        this.#linked_nodes.set(node.node_id, new_node);
-        this.#transporters.get(node.local_transporter_id)?.nodes.set(node.remote_transporter_id, node.node_id);
-        if (!peer_updated && !this.#$isolated.value)
-            await this.#self_introduce(node.local_transporter_id, node.node_id);
-        for (const service_id of Object.keys(node.services)) {
-            if (!this.#remote_services.has(service_id)) {
-                this.#remote_services.set(service_id, {
-                    last_call_index: -1,
-                    nodes: []
+        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 $service = this.#remote_services.get(service_id);
-            const index = $service.nodes.findIndex(n => n.node_id == new_node.node_id);
-            index >= 0 ? ($service.nodes[index] = new_node) : $service.nodes.push(new_node);
+                const last_updated_node_id = node.node_id;
+                this.#nodes.next({
+                    nodes,
+                    last_updated_node_id
+                });
+            }), finalize(() => this.#discovers.delete(transporter_name))).subscribe();
         }
-        this.$nodes_monitor.next(node);
     }
-    #on_node_offline(local_transporter_id, remote_transporter_id) {
-        const node_id = this.#transporters.get(local_transporter_id)?.nodes?.get(remote_transporter_id);
-        if (!node_id)
-            return;
-        const node = this.#linked_nodes.get(node_id);
-        if (!node)
-            return;
-        for (const service of this.#remote_services.values()) {
-            service.nodes = service.nodes.filter(node => node.remote_transporter_id != remote_transporter_id);
-        }
-        for (const [rid, { $response, rpc_node_id }] of this.#requests) {
-            if (rpc_node_id == node_id) {
-                $response.error('OFFLINE');
-                this.#requests.delete(rid);
-            }
-        }
-        node && this.$nodes_monitor.next({ ...node, online: false });
-        this.#linked_nodes.delete(node_id);
+    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',
@@ -361,114 +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);
-            }
-        }
-        wait_service_online && await this.#wait_service_online(service_name);
-        return new Proxy({}, {
-            get: (_, method) => {
-                if (method == '$wait_service_online') {
-                    return (fn) => this.#wait_service_online(service_name, fn);
+        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_services.get(service_name)?.nodes.filter(node => !node.isolated).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_services.get(service_name)?.nodes.filter(node => !node.isolated) || [];
-                    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.node_id });
-                                return { node, data };
+                                s(await firstValueFrom(response));
                             }
-                            catch (error) {
-                                return { node, error };
+                            catch (e) {
+                                r(e);
                             }
-                        })).subscribe(o);
-                        return o;
-                    };
-                }
-                if (actions.has(method) || method.startsWith('$')) {
-                    return new DeepProxy(method => RPCOptionsList.has(method), (method, options) => ((...args) => this.rpc(service_name, method, args, options))).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({
-            payload: [data],
-            topic: event_factory.name
-        }));
+    linkEvent(factory) {
+        const topic = factory.name;
         return {
-            publish: async (data) => $.next(data),
-            listen: () => this.listen(event_factory)
-        };
-    }
-    async #wait_service_online(service_name = 'all', fn = nodes => nodes.length > 0) {
-        while (true) {
-            await sleep(1000);
-            if (service_name == 'all') {
-                const ok = await firstValueFrom(from(this.#remote_services.values()).pipe(mergeMap(async (e) => await fn(e.nodes)), toArray(), map(list => list.every(ok => ok))));
-                if (ok)
-                    return;
-            }
-            else {
-                const nodes = this.#remote_services.get(service_name)?.nodes || [];
-                if (await fn(nodes))
-                    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({ payload, topic, node_id, local_transporter_id }, transporter) {
-        const event = typeof topic == 'string' ? topic : topic.name;
-        const e = {
-            event,
-            metadata: { smnid: this.#node_id },
-            payload
         };
-        if (transporter) {
-            return transporter.publish(e);
-        }
-        if (node_id) {
-            const node = this.#linked_nodes.get(node_id);
-            if (!node)
-                return;
-            const target = this.#transporters.get(node.local_transporter_id);
-            if (!target)
-                return;
-            return target.transporter.publish({
-                ...e,
-                rti: node.remote_transporter_id
-            });
-        }
-        if (local_transporter_id) {
-            const target = this.#transporters.get(local_transporter_id);
-            return target && target.transporter.publish(e);
-        }
-        for (const { transporter } of this.#transporters.values()) {
-            transporter.publish(e);
-        }
     }
-    listen(topic, transporter) {
-        const topic_name = typeof topic == 'string' ? topic : topic.name;
-        const source = transporter ? of(transporter) : SpiderMesh.$transporters;
-        return source.pipe(mergeMap(transporter => transporter.listen(topic_name).pipe(map(msg => msg.payload.map(data => ({
-            ...msg,
-            payload: data,
-            node_id: msg.metadata.smnid
-        }))), 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