@hile/micro 2.0.8 → 2.1.1

package/dist/registry.d.ts

@@ -20,8 +20,14 @@ export declare class Registry extends Server {
     private readonly configs;
     private readonly fallbacks;
     private readonly topics;
+    private topicRevision;
     constructor(props?: MicroServerProps);
-    watchEnvFile(): import("node:fs").FSWatcher | undefined;
+    private cleanupTopicIfUnused;
+    private clearTopicData;
+    private rememberPublisherPayload;
+    private setTopicData;
+    private restoreTopicDataFromRemainingPublishers;
+    watchEnvFile(): import("node:fs").FSWatcher;
     listen(port?: number): Promise<() => Promise<void>>;
     private registerFindApplication;
     private registerDeclare;
@@ -29,5 +35,6 @@ export declare class Registry extends Server {
     private registerSubscribe;
     private registerUnsubscribe;
     private registerReceiveTopicUpdate;
+    private notifySubscribers;
     private publish;
 }

package/dist/registry.js

@@ -39,6 +39,40 @@ export function parseConfigFilename(filename) {
         return null;
     return filename.slice(0, -'.config.yaml'.length);
 }
+function createTopicEntry(data, hasData = false, retained = false) {
+    return {
+        publishers: new Set(),
+        publisherPayloads: new Map(),
+        subscribers: new Set(),
+        data,
+        hasData,
+        signature: hasData ? stableSignature(data) : undefined,
+        retained,
+    };
+}
+function stableSignature(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    const type = typeof value;
+    if (type === 'string')
+        return `string:${JSON.stringify(value)}`;
+    if (type === 'number')
+        return `number:${String(value)}`;
+    if (type === 'boolean')
+        return `boolean:${String(value)}`;
+    if (type === 'bigint')
+        return `bigint:${String(value)}`;
+    if (Array.isArray(value)) {
+        return `array:[${value.map(stableSignature).join(',')}]`;
+    }
+    if (type === 'object') {
+        const keys = Object.keys(value).sort();
+        return `object:{${keys.map(key => `${JSON.stringify(key)}:${stableSignature(value[key])}`).join(',')}}`;
+    }
+    return `${type}:${String(value)}`;
+}
 export class Registry extends Server {
     namespaces = new Map();
     workspace;
@@ -46,6 +80,7 @@ export class Registry extends Server {
     configs = new Map();
     fallbacks = new Set();
     topics = new Map();
+    topicRevision = 0;
     constructor(props = {}) {
         const workspace = resolve(homedir(), '.registry');
         if (!existsSync(workspace)) {
@@ -64,16 +99,19 @@ export class Registry extends Server {
         });
         this.events.on('disconnect', (client, extras) => {
             const key = client.host + ':' + client.port;
-            // 清理 topic 中的关联（不删除 topic，保留 data 供后续 subscriber 使用）
-            for (const [, { publishers, subscribers }] of this.topics) {
-                if (publishers.has(key)) {
-                    publishers.delete(key);
+            // 清理 topic 中的关联
+            for (const [topic, entry] of [...this.topics]) {
+                if (entry.publishers.has(key)) {
+                    entry.publishers.delete(key);
+                    entry.publisherPayloads.delete(key);
+                    this.restoreTopicDataFromRemainingPublishers(topic, entry);
                     this.logger.debug('[delete publisher] %s', key);
                 }
-                if (subscribers.has(key)) {
-                    subscribers.delete(key);
+                if (entry.subscribers.has(key)) {
+                    entry.subscribers.delete(key);
                     this.logger.debug('[delete subscriber] %s', key);
                 }
+                this.cleanupTopicIfUnused(topic, entry);
             }
             // 清理 namespace 中的关联
             const namespace = extras.join('/');
@@ -96,10 +134,67 @@ export class Registry extends Server {
         this.registerUnsubscribe();
         this.registerReceiveTopicUpdate();
     }
+    cleanupTopicIfUnused(topic, entry = this.topics.get(topic)) {
+        if (!entry)
+            return;
+        if (entry.retained)
+            return;
+        if (entry.publishers.size === 0 && entry.subscribers.size === 0) {
+            this.topics.delete(topic);
+            this.logger.debug('[delete topic] %s', topic);
+        }
+    }
+    clearTopicData(entry) {
+        if (entry.retained)
+            return;
+        entry.data = undefined;
+        entry.hasData = false;
+        entry.signature = undefined;
+    }
+    rememberPublisherPayload(entry, key, payload, revision) {
+        const nextRevision = Number.isFinite(revision) && revision > 0 ? revision : ++this.topicRevision;
+        this.topicRevision = Math.max(this.topicRevision, nextRevision);
+        entry.publisherPayloads.set(key, {
+            data: payload,
+            signature: stableSignature(payload),
+            revision: nextRevision,
+        });
+        return nextRevision;
+    }
+    setTopicData(entry, payload) {
+        const signature = stableSignature(payload);
+        const changed = !entry.hasData || entry.signature !== signature;
+        entry.data = payload;
+        entry.hasData = true;
+        entry.signature = signature;
+        return changed;
+    }
+    restoreTopicDataFromRemainingPublishers(topic, entry) {
+        if (entry.retained)
+            return;
+        let latest;
+        for (const payload of entry.publisherPayloads.values()) {
+            if (!latest || payload.revision > latest.revision) {
+                latest = payload;
+            }
+        }
+        if (!latest) {
+            this.clearTopicData(entry);
+            return;
+        }
+        const changed = !entry.hasData || entry.signature !== latest.signature;
+        entry.data = latest.data;
+        entry.hasData = true;
+        entry.signature = latest.signature;
+        if (changed) {
+            this.notifySubscribers(topic, latest.data, entry);
+        }
+    }
     watchEnvFile() {
         const configFile = resolve(this.workspace, 'configs');
-        if (!existsSync(configFile))
-            return;
+        if (!existsSync(configFile)) {
+            mkdirSync(configFile, { recursive: true });
+        }
         const configFiles = readdirSync(configFile).filter(filename => filename.endsWith(this.configFileSuffix));
         for (const filename of configFiles) {
             try {
@@ -112,8 +207,12 @@ export class Registry extends Server {
                 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.topics.set(_key, createTopicEntry(config[key], true, true));
+                    }
+                    else {
+                        this.topics.get(_key).retained = true;
                     }
+                    this.publish(_key, config[key]);
                 }
             }
             catch { }
@@ -138,7 +237,10 @@ export class Registry extends Server {
                 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.topics.set(_key, createTopicEntry(config[key], true, true));
+                    }
+                    else {
+                        this.topics.get(_key).retained = true;
                     }
                     this.publish(_key, config[key]);
                 }
@@ -156,10 +258,6 @@ export class Registry extends Server {
         return async () => {
             if (watcher)
                 watcher.close();
-            for (const fallback of this.fallbacks) {
-                fallback();
-            }
-            this.fallbacks.clear();
             await teardown();
         };
     }
@@ -183,15 +281,14 @@ export class Registry extends Server {
         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 });
+                this.topics.set(data.topic, createTopicEntry());
             }
             const entry = this.topics.get(data.topic);
             const publishers = entry.publishers;
-            entry.data = data.payload;
             publishers.add(key);
-            this.publish(data.topic, data.payload);
+            const revision = this.publish(data.topic, data.payload, key, data.revision);
             this.logger.debug('[declare] %s/%s', key, data.topic);
-            return Date.now();
+            return revision;
         }));
     }
     registerUndeclare() {
@@ -201,15 +298,13 @@ export class Registry extends Server {
                 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);
+                entry.publisherPayloads.delete(key);
+                this.restoreTopicDataFromRemainingPublishers(data.topic, entry);
                 this.logger.debug('[undeclare] %s/%s', key, data.topic);
-                if (publishers.size === 0 && subscribers.size === 0) {
-                    this.topics.delete(data.topic);
-                    this.logger.debug('[delete topic] %s', data.topic);
-                }
+                this.cleanupTopicIfUnused(data.topic, entry);
             }
             return i - publishers.size;
         }));
@@ -218,13 +313,13 @@ export class Registry extends Server {
         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 });
+                this.topics.set(data.topic, createTopicEntry());
             }
             const entry = this.topics.get(data.topic);
             const subscribers = entry.subscribers;
             subscribers.add(key);
             this.logger.debug('[subscribe] %s/%s', key, data.topic);
-            return entry.data;
+            return { hasData: entry.hasData, payload: entry.data };
         }));
     }
     registerUnsubscribe() {
@@ -239,31 +334,46 @@ export class Registry extends Server {
                 subscribers.delete(key);
             }
             this.logger.debug('[unsubscribe] %s/%s', key, data.topic);
+            this.cleanupTopicIfUnused(data.topic, entry);
             return i - subscribers.size;
         }));
     }
     registerReceiveTopicUpdate() {
-        this.fallbacks.add(this.register('/-/topic/update', async ({ data }) => {
+        this.fallbacks.add(this.register('/-/topic/update', async ({ data, client }) => {
             // 转发
-            this.publish(data.topic, data.payload);
-            return Date.now();
+            const key = client ? `${client.host}:${client.port}` : undefined;
+            const entry = this.topics.get(data.topic);
+            if (key && entry?.publishers.has(key)) {
+                return this.publish(data.topic, data.payload, key) ?? Date.now();
+            }
+            return this.publish(data.topic, data.payload) ?? 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()) {
+    notifySubscribers(topic, payload, entry) {
+        for (const key of entry.subscribers.values()) {
             try {
                 if (this.clients.has(key)) {
                     this.clients.get(key).push(`/-/topic/update`, { topic, payload });
                 }
             }
             catch {
-                // 推送失败，disconnect 事件中会清理                                                             
+                // 推送失败，disconnect 事件中会清理
             }
         }
     }
+    publish(topic, payload, publisherKey, revision) {
+        if (!this.topics.has(topic))
+            return;
+        const entry = this.topics.get(topic);
+        if (publisherKey) {
+            const nextRevision = this.rememberPublisherPayload(entry, publisherKey, payload, revision);
+            this.restoreTopicDataFromRemainingPublishers(topic, entry);
+            return nextRevision;
+        }
+        const changed = this.setTopicData(entry, payload);
+        if (!changed)
+            return;
+        this.notifySubscribers(topic, payload, entry);
+        return ++this.topicRevision;
+    }
 }

package/dist/server.d.ts

@@ -22,6 +22,7 @@ export declare class Server extends MessageLoader {
     port?: number;
     readonly logger: Logger | Console;
     readonly clients: Map<string, Client>;
+    private readonly clientExtras;
     private readonly announceHost;
     readonly events: EventEmitter<any>;
     get host(): string;

package/dist/server.js

@@ -11,6 +11,7 @@ export class Server extends MessageLoader {
     port;
     logger;
     clients = new Map();
+    clientExtras = new Map();
     announceHost;
     events = new EventEmitter();
     get host() {
@@ -58,18 +59,23 @@ export class Server extends MessageLoader {
         const key = `${host}:${port}`;
         const previous = this.clients.get(key);
         if (previous) {
+            const previousExtras = this.clientExtras.get(key) ?? [];
             this.clients.delete(key);
+            this.clientExtras.delete(key);
             previous.dispose();
+            this.events.emit('disconnect', previous, previousExtras);
         }
         const client = new Client({ server: this, ws, host, port });
         ws.on('close', () => {
             if (this.clients.get(key) === client) {
                 this.clients.delete(key);
+                this.clientExtras.delete(key);
                 client.dispose();
                 this.events.emit('disconnect', client, extras);
             }
         });
         this.clients.set(key, client);
+        this.clientExtras.set(key, extras);
         this.events.emit('connect', client, extras);
         return client;
     }
@@ -149,11 +155,16 @@ export class Server extends MessageLoader {
                     });
                 });
             }
-            const toDispose = [...this.clients.values()];
-            for (const client of toDispose) {
+            const toDispose = [...this.clients.entries()];
+            for (const [key, client] of toDispose) {
+                const extras = this.clientExtras.get(key) ?? [];
+                this.clients.delete(key);
+                this.clientExtras.delete(key);
                 client.dispose();
+                this.events.emit('disconnect', client, extras);
             }
             this.clients.clear();
+            this.clientExtras.clear();
             this.wss = undefined;
             this.port = undefined;
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hile/micro",
-  "version": "2.0.8",
+  "version": "2.1.1",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -23,12 +23,12 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@hile/logger": "^2.0.3",
-    "@hile/message-loader": "^2.0.2",
-    "@hile/message-ws": "^2.0.4",
+    "@hile/logger": "^2.1.1",
+    "@hile/message-loader": "^2.1.1",
+    "@hile/message-ws": "^2.1.1",
     "internal-ip": "^9.0.0",
     "ws": "^8.21.0",
     "yaml": "^2.9.0"
   },
-  "gitHead": "a7615000fcb87e6bc0e573af760c814ec935bab2"
+  "gitHead": "7903ae989bd001d1ed1437cb90c9e828a1909061"
 }