@hile/micro 1.0.10 → 2.0.0

package/dist/application.d.ts

@@ -36,6 +36,8 @@ export declare class Application extends Server {
     private readonly namespaces;
     private static readonly CB_COOLDOWN_MS;
     private readonly circuitBreakers;
+    private readonly fallbacks;
+    private readonly topics;
     constructor(props: ApplicationProps);
     listen(port?: number): Promise<() => Promise<void>>;
     private scheduleRegistryRetry;
@@ -45,7 +47,20 @@ export declare class Application extends Server {
     private getActiveExcludes;
     private findFromRegistry;
     get(namespace: string, exclude?: string[]): Promise<Client>;
-    call<T = any>(namespace: string, url: string, data: any, timeout?: number, retries?: number): Promise<T>;
-    getEnvVariables<T extends Record<string, Record<string, any>>, const Requests extends readonly EnvRequest<T>[] = readonly EnvRequest<T>[]>(...data: Requests): Promise<GetEnvVariablesResult<T, Requests>>;
+    call<T = any>(namespace: string, url: string, data: any, options?: {
+        timeout?: number;
+        retries?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    stream(namespace: string, url: string, data: any, options?: {
+        signal?: AbortSignal;
+        retries?: number;
+    }): Promise<import('stream').Readable>;
+    publish<T = any>(topic: string, data: T): Promise<{
+        update: (payload: T) => Promise</*elided*/ any>;
+        unpublish: () => Promise</*elided*/ any>;
+    }>;
+    /** 对同一 topic 重复 subscribe 是幂等的：第二次调用只返回 unsubscribe 函数，不会注册第二个 callback */
+    subscribe<T = any>(topic: string, callback: (data: T) => any, isReconnect?: boolean): Promise<() => Promise<void>>;
 }
 export {};

package/dist/application.js

@@ -47,6 +47,8 @@ export class Application extends Server {
     namespaces = new Map();
     static CB_COOLDOWN_MS = 30_000;
     circuitBreakers = new Map();
+    fallbacks = new Set();
+    topics = new Map();
     constructor(props) {
         const { namespace, registry, registryLookupTimeoutMs = 10_000, requestTimeoutMs = 30_000, ...microAndLoader } = props;
         super(namespace, microAndLoader);
@@ -54,11 +56,15 @@ export class Application extends Server {
         this._registry_address = registry;
         this._registryLookupTimeoutMs = registryLookupTimeoutMs;
         this._requestTimeoutMs = requestTimeoutMs;
-        this.register('/-/health', async () => ({
+        this.fallbacks.add(this.register('/-/health', async () => ({
             status: 'ok',
             registry: !!this.registry,
             uptime: process.uptime(),
             namespaces: [...this.namespaces.keys()],
+        })));
+        this.fallbacks.add(this.register('/-/topic/update', async ({ data }) => {
+            this.events.emit('topic:' + data.topic, data.payload);
+            return Date.now();
         }));
     }
     async listen(port = 0) {
@@ -76,7 +82,13 @@ export class Application extends Server {
             }
             throw err;
         }
+        // 这里不清理 topics 由业务方自己清理
+        // 这里也不清理 declare 和 undeclare 由业务方自己清理
         return async () => {
+            for (const fallback of this.fallbacks) {
+                fallback();
+            }
+            this.fallbacks.clear();
             this.stopped = true;
             if (this.reconnectTimeout) {
                 clearTimeout(this.reconnectTimeout);
@@ -124,6 +136,10 @@ export class Application extends Server {
                 });
             });
             this.registry = registry;
+            // 重新订阅所有 topic
+            for (const [topic, callback] of this.topics) {
+                await this.subscribe(topic, callback, true);
+            }
         })().finally(() => {
             this.registryReconnectPromise = undefined;
         });
@@ -166,8 +182,8 @@ export class Application extends Server {
     async findFromRegistry(namespace, exclude) {
         if (!this.registry)
             throw new Error('Registry not found');
-        const { response } = this.registry.request('/-/find', { namespace, exclude });
-        return await withTimeout(response(), this._registryLookupTimeoutMs, 'Registry /-/find');
+        const promise = this.registry.request('/-/find', { namespace, exclude });
+        return await withTimeout(promise, this._registryLookupTimeoutMs, 'Registry /-/find');
     }
     get(namespace, exclude) {
         if (!this.namespaces.has(namespace)) {
@@ -238,7 +254,8 @@ export class Application extends Server {
             }
         });
     }
-    async call(namespace, url, data, timeout, retries = 1) {
+    async call(namespace, url, data, options) {
+        const { timeout = this._requestTimeoutMs, retries = 1, signal } = options || {};
         const exclude = this.getActiveExcludes(namespace);
         let client;
         try {
@@ -249,28 +266,87 @@ export class Application extends Server {
             client = await this.get(namespace);
         }
         try {
-            const { response } = client.request(url, data, timeout ?? this._requestTimeoutMs);
-            const result = await response();
+            const result = await client.request(url, data, {
+                timeout: timeout ?? this._requestTimeoutMs,
+                signal,
+            });
             this.recordSuccess(namespace, client.host, client.port);
             return result;
         }
         catch (err) {
             this.recordFailure(namespace, client.host, client.port);
             if (retries > 0) {
-                return this.call(namespace, url, data, timeout, retries - 1);
+                return this.call(namespace, url, data, { timeout, retries: retries - 1, signal });
             }
             throw err;
         }
     }
-    async getEnvVariables(...data) {
+    async stream(namespace, url, data, options) {
+        const { signal, retries = 1 } = options || {};
+        const exclude = this.getActiveExcludes(namespace);
+        let client;
+        try {
+            client = await this.get(namespace, exclude);
+        }
+        catch {
+            this.circuitBreakers.delete(namespace);
+            client = await this.get(namespace);
+        }
+        try {
+            const readable = client.stream(url, data, { signal });
+            this.recordSuccess(namespace, client.host, client.port);
+            return readable;
+        }
+        catch (err) {
+            this.recordFailure(namespace, client.host, client.port);
+            if (retries > 0) {
+                return this.stream(namespace, url, data, { signal, retries: retries - 1 });
+            }
+            throw err;
+        }
+    }
+    async publish(topic, data) {
         if (!this.registry)
             throw new Error('Registry not found');
-        const { response } = this.registry.request('/-/env/variables', data);
-        const configs = await response();
-        const out = {};
-        for (const { namespace, value } of configs) {
-            out[namespace] = value;
+        await this.registry.request('/-/declare', { topic, payload: data });
+        const ref = {
+            update: async (payload) => {
+                if (!this.registry)
+                    throw new Error('Registry not found');
+                await this.registry.request('/-/topic/update', { topic, payload });
+                return ref;
+            },
+            unpublish: async () => {
+                if (!this.registry)
+                    throw new Error('Registry not found');
+                await this.registry.request('/-/undeclare', { topic });
+                return ref;
+            }
+        };
+        return ref;
+    }
+    /** 对同一 topic 重复 subscribe 是幂等的：第二次调用只返回 unsubscribe 函数，不会注册第二个 callback */
+    async subscribe(topic, callback, isReconnect = false) {
+        if (!this.registry)
+            throw new Error('Registry not found');
+        const fallback = async () => {
+            if (!this.registry)
+                throw new Error('Registry not found');
+            await this.registry.request('/-/unsubscribe', { topic });
+            if (this.topics.has(topic)) {
+                const _callback = this.topics.get(topic);
+                this.events.off('topic:' + topic, _callback);
+                this.topics.delete(topic);
+            }
+        };
+        if (this.topics.has(topic) && !isReconnect)
+            return fallback;
+        const payload = await this.registry.request('/-/subscribe', { topic });
+        if (!isReconnect) {
+            this.events.on('topic:' + topic, callback);
+            this.topics.set(topic, callback);
+            callback(payload);
         }
-        return out;
+        return fallback;
     }
 }

package/dist/client.d.ts

@@ -24,10 +24,16 @@ export declare class Client extends MessageWs {
         url: string;
         data: any;
     }): Promise<any>;
-    request(url: string, data: any, timeout?: number): {
-        abort: () => void;
-        response: <U = any>() => Promise<U>;
-    };
-    push(url: string, data: any, timeout?: number): void;
+    request<T = any>(url: string, data: any, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    push(url: string, data: any, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): void;
+    stream(url: string, data: any, options?: {
+        signal?: AbortSignal;
+    }): import("node:stream").Readable;
     dispose(): void;
 }

package/dist/client.js

@@ -52,15 +52,20 @@ export class Client extends MessageWs {
             client: this,
         });
     }
-    request(url, data, timeout) {
+    request(url, data, options) {
         if (!this._online)
             throw new Error('Client is not online');
-        return this._send({ url, data }, timeout);
+        return this._send({ url, data }, options);
     }
-    push(url, data, timeout) {
+    push(url, data, options) {
         if (!this._online)
             throw new Error('Client is not online');
-        return this._push({ url, data }, timeout);
+        return this._push({ url, data }, options);
+    }
+    stream(url, data, options) {
+        if (!this._online)
+            throw new Error('Client is not online');
+        return this._stream({ url, data }, options);
     }
     dispose() {
         if (this.heartbeatTimer)

package/dist/registry.d.ts

@@ -15,15 +15,19 @@ export declare function namespaceToConfigFile(ns: string): string;
 export declare function parseConfigFilename(filename: string): string | null;
 export declare class Registry extends Server {
     private readonly namespaces;
-    private unregisterFind?;
     private readonly workspace;
     private readonly configFileSuffix;
     private readonly configs;
+    private readonly fallbacks;
+    private readonly topics;
     constructor(props?: MicroServerProps);
     watchEnvFile(): import("node:fs").FSWatcher | undefined;
     listen(port?: number): Promise<() => Promise<void>>;
-    /** 幂等：重复调用会先注销上一条 `/-/find` 再注册，避免叠多条路由 */
-    onFind(): void;
-    private mountFindHandler;
-    private registerEnvVariables;
+    private registerFindApplication;
+    private registerDeclare;
+    private registerUndeclare;
+    private registerSubscribe;
+    private registerUnsubscribe;
+    private registerReceiveTopicUpdate;
+    private publish;
 }

package/dist/registry.js

@@ -41,10 +41,11 @@ export function parseConfigFilename(filename) {
 }
 export class Registry extends Server {
     namespaces = new Map();
-    unregisterFind;
     workspace;
     configFileSuffix = '.config.yaml';
     configs = new Map();
+    fallbacks = new Set();
+    topics = new Map();
     constructor(props = {}) {
         const workspace = resolve(homedir(), '.registry');
         if (!existsSync(workspace)) {
@@ -62,6 +63,17 @@ export class Registry extends Server {
         });
         this.events.on('disconnect', (client, extras) => {
             const key = client.host + ':' + client.port;
+            // 清理 topic 中的关联
+            for (const [topic, { publishers, subscribers }] of this.topics) {
+                if (publishers.has(key))
+                    publishers.delete(key);
+                if (subscribers.has(key))
+                    subscribers.delete(key);
+                if (publishers.size === 0 && subscribers.size === 0) {
+                    this.topics.delete(topic);
+                }
+            }
+            // 清理 namespace 中的关联
             const namespace = extras.join('/');
             if (this.namespaces.has(namespace)) {
                 const keys = this.namespaces.get(namespace);
@@ -73,8 +85,12 @@ export class Registry extends Server {
                 }
             }
         });
-        this.mountFindHandler();
-        this.registerEnvVariables();
+        this.registerFindApplication();
+        this.registerDeclare();
+        this.registerUndeclare();
+        this.registerSubscribe();
+        this.registerUnsubscribe();
+        this.registerReceiveTopicUpdate();
     }
     watchEnvFile() {
         const configFile = resolve(this.workspace, 'configs');
@@ -86,7 +102,15 @@ export class Registry extends Server {
                 const config = YAML.parse(readFileSync(resolve(configFile, filename), 'utf8'));
                 if (typeof config !== 'object' || config === null)
                     continue;
-                this.configs.set(parseConfigFilename(filename), config);
+                const namespace = parseConfigFilename(filename);
+                this.configs.set(namespace, config);
+                const keys = Object.keys(config);
+                for (const key of keys) {
+                    const _key = `registry:${namespace}/${key}`;
+                    if (!this.topics.has(_key)) {
+                        this.topics.set(_key, { publishers: new Set(), subscribers: new Set(), data: config[key] });
+                    }
+                }
             }
             catch { }
         }
@@ -94,16 +118,26 @@ export class Registry extends Server {
             if (!filename?.endsWith(this.configFileSuffix))
                 return;
             const fullPath = resolve(configFile, filename);
-            // 文件被删除（或重命名）：移除对应配置
             if (!existsSync(fullPath)) {
-                this.configs.delete(parseConfigFilename(filename));
+                const namespace = parseConfigFilename(filename);
+                this.configs.delete(namespace);
                 return;
             }
             try {
                 const config = YAML.parse(readFileSync(fullPath, 'utf8'));
                 if (typeof config !== 'object' || config === null)
                     return;
-                this.configs.set(parseConfigFilename(filename), config);
+                const namespace = parseConfigFilename(filename);
+                this.configs.set(namespace, config);
+                const keys = Object.keys(config);
+                // 只加不减
+                for (const key of keys) {
+                    const _key = `registry:${namespace}/${key}`;
+                    if (!this.topics.has(_key)) {
+                        this.topics.set(_key, { publishers: new Set(), subscribers: new Set(), data: config[key] });
+                    }
+                    this.publish(_key, config[key]);
+                }
             }
             catch { /* vim 替换文件时的中间态读错误，忽略 */ }
         });
@@ -118,19 +152,15 @@ export class Registry extends Server {
         return async () => {
             if (watcher)
                 watcher.close();
+            for (const fallback of this.fallbacks) {
+                fallback();
+            }
+            this.fallbacks.clear();
             await teardown();
         };
     }
-    /** 幂等：重复调用会先注销上一条 `/-/find` 再注册，避免叠多条路由 */
-    onFind() {
-        this.mountFindHandler();
-    }
-    mountFindHandler() {
-        if (this.unregisterFind) {
-            this.unregisterFind();
-            this.unregisterFind = undefined;
-        }
-        this.unregisterFind = this.register('/-/find', async ({ data }) => {
+    registerFindApplication() {
+        this.fallbacks.add(this.register('/-/find', async ({ data }) => {
             const namespace = data.namespace;
             let keys = this.namespaces.get(namespace);
             if (!keys)
@@ -143,23 +173,92 @@ export class Registry extends Server {
                 keys = new Set(filtered);
             }
             return selectRandomRegistryAddress(keys);
-        });
+        }));
+    }
+    registerDeclare() {
+        this.fallbacks.add(this.register('/-/declare', async ({ data, client }) => {
+            const key = `${client.host}:${client.port}`;
+            if (!this.topics.has(data.topic)) {
+                this.topics.set(data.topic, { publishers: new Set(), subscribers: new Set(), data: data.payload });
+            }
+            const entry = this.topics.get(data.topic);
+            const publishers = entry.publishers;
+            entry.data = data.payload;
+            publishers.add(key);
+            this.publish(data.topic, data.payload);
+            return Date.now();
+        }));
+    }
+    registerUndeclare() {
+        this.fallbacks.add(this.register('/-/undeclare', async ({ data, client }) => {
+            const key = `${client.host}:${client.port}`;
+            if (!this.topics.has(data.topic))
+                return 0;
+            const entry = this.topics.get(data.topic);
+            const publishers = entry.publishers;
+            const subscribers = entry.subscribers;
+            const i = publishers.size;
+            if (publishers.has(key)) {
+                publishers.delete(key);
+                if (publishers.size === 0 && subscribers.size === 0) {
+                    this.topics.delete(data.topic);
+                }
+            }
+            return i - publishers.size;
+        }));
+    }
+    registerSubscribe() {
+        this.fallbacks.add(this.register('/-/subscribe', async ({ data, client }) => {
+            const key = `${client.host}:${client.port}`;
+            if (!this.topics.has(data.topic)) {
+                this.topics.set(data.topic, { publishers: new Set(), subscribers: new Set(), data: undefined });
+            }
+            const entry = this.topics.get(data.topic);
+            const subscribers = entry.subscribers;
+            subscribers.add(key);
+            return entry.data;
+        }));
     }
-    registerEnvVariables() {
-        this.register('/-/env/variables', async ({ data }) => {
-            return data.map(({ namespace, fields }) => {
-                if (!this.configs.has(namespace)) {
-                    return { namespace, value: null };
+    registerUnsubscribe() {
+        this.fallbacks.add(this.register('/-/unsubscribe', async ({ data, client }) => {
+            const key = `${client.host}:${client.port}`;
+            if (!this.topics.has(data.topic))
+                return 0;
+            const entry = this.topics.get(data.topic);
+            const subscribers = entry.subscribers;
+            const publishers = entry.publishers;
+            const i = subscribers.size;
+            if (subscribers.has(key)) {
+                subscribers.delete(key);
+                if (subscribers.size === 0 && publishers.size === 0) {
+                    this.topics.delete(data.topic);
                 }
-                if (!fields?.length)
-                    return { namespace, value: this.configs.get(namespace) };
-                const config = this.configs.get(namespace);
-                const value = {};
-                for (const field of fields) {
-                    value[field] = config[field];
+            }
+            return i - subscribers.size;
+        }));
+    }
+    registerReceiveTopicUpdate() {
+        this.fallbacks.add(this.register('/-/topic/update', async ({ data }) => {
+            // 转发
+            this.publish(data.topic, data.payload);
+            return Date.now();
+        }));
+    }
+    publish(topic, payload) {
+        if (!this.topics.has(topic))
+            return;
+        const entry = this.topics.get(topic);
+        const subscribers = entry.subscribers;
+        entry.data = payload;
+        for (const key of subscribers.values()) {
+            try {
+                if (this.clients.has(key)) {
+                    this.clients.get(key).push(`/-/topic/update`, { topic, payload });
                 }
-                return { namespace, value };
-            });
-        });
+            }
+            catch {
+                // 推送失败，disconnect 事件中会清理                                                             
+            }
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hile/micro",
-  "version": "1.0.10",
+  "version": "2.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -24,10 +24,10 @@
   },
   "dependencies": {
     "@hile/message-loader": "^1.0.9",
-    "@hile/message-ws": "^1.0.6",
+    "@hile/message-ws": "^2.0.0",
     "internal-ip": "^9.0.0",
     "ws": "^8.19.0",
     "yaml": "^2.9.0"
   },
-  "gitHead": "be31521d206109a1ed6e915ec231a849870b538c"
+  "gitHead": "d28b20bc22ee08c45cbf4596672705cb96e8e461"
 }