@zucker-framework/network 1.0.0

package/dist/index.mjs

@@ -0,0 +1,327 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/network-type.ts
+function networkType(id, name) {
+  return {
+    id,
+    name: name ?? id
+  };
+}
+__name(networkType, "networkType");
+var NetworkTypes = {
+  TCP_CLIENT: networkType("TCP_CLIENT", "TCP Client"),
+  TCP_SERVER: networkType("TCP_SERVER", "TCP Server"),
+  HTTP_CLIENT: networkType("HTTP_CLIENT", "HTTP Client"),
+  HTTP_SERVER: networkType("HTTP_SERVER", "HTTP Server"),
+  MQTT_CLIENT: networkType("MQTT_CLIENT", "MQTT Client"),
+  MQTT_SERVER: networkType("MQTT_SERVER", "MQTT Server"),
+  WEB_SOCKET_CLIENT: networkType("WEB_SOCKET_CLIENT", "WebSocket Client"),
+  WEB_SOCKET_SERVER: networkType("WEB_SOCKET_SERVER", "WebSocket Server"),
+  UDP: networkType("UDP", "UDP")
+};
+var NetworkTypeRegistry = class NetworkTypeRegistry2 {
+  static {
+    __name(this, "NetworkTypeRegistry");
+  }
+  types = /* @__PURE__ */ new Map();
+  constructor() {
+    for (const t of Object.values(NetworkTypes)) {
+      this.types.set(t.id.toUpperCase(), t);
+    }
+  }
+  /** 注册网络类型 — 对齐 jetlinks NetworkTypes.register() */
+  register(type) {
+    this.types.set(type.id.toUpperCase(), type);
+  }
+  /** 批量注册 */
+  registerAll(types) {
+    for (const t of types) {
+      this.register(t);
+    }
+  }
+  /** 根据 ID 查找网络类型 — 对齐 jetlinks NetworkTypes.lookup() */
+  lookup(id) {
+    return this.types.get(id.toUpperCase());
+  }
+  /** 获取所有已注册的网络类型 — 对齐 jetlinks NetworkTypes.get() */
+  getAll() {
+    return Array.from(this.types.values());
+  }
+};
+var networkTypeRegistry = new NetworkTypeRegistry();
+
+// src/transport.ts
+function createTransport(protocol, schema) {
+  return {
+    protocol,
+    schema
+  };
+}
+__name(createTransport, "createTransport");
+var Transports = {
+  TCP: createTransport("TCP", "tcp"),
+  UDP: createTransport("UDP", "udp"),
+  HTTP: createTransport("TCP", "http"),
+  HTTPS: createTransport("TCP", "https"),
+  MQTT: createTransport("TCP", "mqtt"),
+  MQTTS: createTransport("TCP", "mqtts"),
+  WS: createTransport("TCP", "ws"),
+  WSS: createTransport("TCP", "wss")
+};
+
+// src/network-manager.ts
+import { Injectable, Logger } from "@nestjs/common";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+var DefaultNetworkManager = class _DefaultNetworkManager {
+  static {
+    __name(this, "DefaultNetworkManager");
+  }
+  configManager;
+  logger = new Logger(_DefaultNetworkManager.name);
+  /** type-id -> Provider */
+  providers = /* @__PURE__ */ new Map();
+  /** type-id -> (network-id -> Network) */
+  store = /* @__PURE__ */ new Map();
+  checkTimer;
+  constructor(configManager) {
+    this.configManager = configManager;
+    this.checkTimer = setInterval(() => {
+      this.checkNetworks().catch((err) => this.logger.error("Network health-check failed", err));
+    }, 1e4);
+  }
+  /* ------------------------------------------------------------------ */
+  /*  Provider 注册                                                      */
+  /* ------------------------------------------------------------------ */
+  registerProvider(provider) {
+    this.providers.set(provider.type.id, provider);
+    this.logger.log(`NetworkProvider registered: ${provider.type.id}`);
+  }
+  /* ------------------------------------------------------------------ */
+  /*  INetworkManager 实现                                               */
+  /* ------------------------------------------------------------------ */
+  async getNetwork(type, id) {
+    const networkMap = this.getNetworkStore(type.id);
+    let network = networkMap.get(id);
+    if (network) return network;
+    network = await this.createFromConfig(type, id);
+    networkMap.set(id, network);
+    return network;
+  }
+  getNetworks() {
+    const result = [];
+    for (const map of this.store.values()) {
+      for (const n of map.values()) {
+        result.push(n);
+      }
+    }
+    return result;
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+  getProvider(typeId) {
+    return this.providers.get(typeId);
+  }
+  async reload(type, id) {
+    const provider = this.requireProvider(type.id);
+    const props = await this.configManager.getConfig(type, id);
+    if (!props || !props.enabled) return;
+    const config = await provider.createConfig(props);
+    const networkMap = this.getNetworkStore(type.id);
+    const existing = networkMap.get(id);
+    const network = existing ? await provider.reload(existing, config) : await provider.createNetwork(config);
+    networkMap.set(id, network);
+  }
+  async shutdown(type, id) {
+    const network = this.getNetworkStore(type.id).get(id);
+    if (network) {
+      await network.shutdown();
+    }
+  }
+  async destroy(type, id) {
+    const networkMap = this.getNetworkStore(type.id);
+    const network = networkMap.get(id);
+    if (network) {
+      networkMap.delete(id);
+      await network.shutdown();
+    }
+  }
+  /* ------------------------------------------------------------------ */
+  /*  生命周期                                                           */
+  /* ------------------------------------------------------------------ */
+  async onModuleDestroy() {
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = void 0;
+    }
+    const shutdowns = [];
+    for (const map of this.store.values()) {
+      for (const network of map.values()) {
+        shutdowns.push(Promise.resolve(network.shutdown()).catch((err) => this.logger.error(`Failed to shutdown network ${network.id}`, err)));
+      }
+    }
+    await Promise.all(shutdowns);
+    this.store.clear();
+  }
+  /* ------------------------------------------------------------------ */
+  /*  内部方法                                                           */
+  /* ------------------------------------------------------------------ */
+  getNetworkStore(typeId) {
+    let map = this.store.get(typeId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.store.set(typeId, map);
+    }
+    return map;
+  }
+  requireProvider(typeId) {
+    const provider = this.providers.get(typeId);
+    if (!provider) {
+      throw new Error(`Unsupported network type: ${typeId}`);
+    }
+    return provider;
+  }
+  async createFromConfig(type, id) {
+    const provider = this.requireProvider(type.id);
+    const props = await this.configManager.getConfig(type, id);
+    if (!props || !props.enabled) {
+      throw new Error(`Network config not found or disabled: ${type.id}/${id}`);
+    }
+    const config = await provider.createConfig(props);
+    return provider.createNetwork(config);
+  }
+  /**
+  * 定期检查网络组件存活状态 — 与 jetlinks checkNetwork() 逻辑对齐。
+  */
+  async checkNetworks() {
+    for (const [typeId, networkMap] of this.store) {
+      const provider = this.providers.get(typeId);
+      if (!provider) continue;
+      for (const [id, network] of networkMap) {
+        if (network.isAlive() || !network.isAutoReload()) continue;
+        try {
+          const props = await this.configManager.getConfig(network.type, id);
+          if (!props || !props.enabled) continue;
+          const config = await provider.createConfig(props);
+          const reloaded = await provider.reload(network, config);
+          networkMap.set(id, reloaded);
+          this.logger.log(`Reloaded network: ${typeId}/${id}`);
+        } catch (err) {
+          this.logger.warn(`Failed to reload network ${typeId}/${id}`, err);
+        }
+      }
+    }
+  }
+};
+DefaultNetworkManager = _ts_decorate([
+  Injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof NetworkConfigManager === "undefined" ? Object : NetworkConfigManager
+  ])
+], DefaultNetworkManager);
+
+// src/codec.ts
+var JsonCodec = class {
+  static {
+    __name(this, "JsonCodec");
+  }
+  id;
+  transport;
+  constructor(id, transport) {
+    this.id = id;
+    this.transport = transport;
+  }
+  encode(message) {
+    return Buffer.from(JSON.stringify(message));
+  }
+  decode(payload) {
+    return JSON.parse(payload.toString("utf-8"));
+  }
+};
+
+// src/network.module.ts
+import { Module } from "@nestjs/common";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var NETWORK_MANAGER = /* @__PURE__ */ Symbol("NETWORK_MANAGER");
+var NETWORK_CONFIG_MANAGER = /* @__PURE__ */ Symbol("NETWORK_CONFIG_MANAGER");
+var ZuckerNetworkModule = class _ZuckerNetworkModule {
+  static {
+    __name(this, "ZuckerNetworkModule");
+  }
+  static forRoot(options) {
+    const configManagerProvider = typeof options.configManager === "function" ? {
+      provide: NETWORK_CONFIG_MANAGER,
+      useClass: options.configManager
+    } : options.configManager;
+    const networkManagerProvider = {
+      provide: NETWORK_MANAGER,
+      useFactory: /* @__PURE__ */ __name((configManager) => {
+        return new DefaultNetworkManager(configManager);
+      }, "useFactory"),
+      inject: [
+        NETWORK_CONFIG_MANAGER
+      ]
+    };
+    return {
+      module: _ZuckerNetworkModule,
+      global: true,
+      providers: [
+        configManagerProvider,
+        networkManagerProvider
+      ],
+      exports: [
+        NETWORK_MANAGER,
+        NETWORK_CONFIG_MANAGER
+      ]
+    };
+  }
+};
+ZuckerNetworkModule = _ts_decorate2([
+  Module({})
+], ZuckerNetworkModule);
+export {
+  DefaultNetworkManager,
+  JsonCodec,
+  NETWORK_CONFIG_MANAGER,
+  NETWORK_MANAGER,
+  NetworkTypes,
+  Transports,
+  ZuckerNetworkModule,
+  createTransport,
+  networkType,
+  networkTypeRegistry
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@zucker-framework/network",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE",
+    "THIRD_PARTY_NOTICES"
+  ],
+  "dependencies": {
+    "@zucker-framework/core": "1.0.0",
+    "@zucker-framework/provider": "1.0.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/core": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.43"
+  },
+  "license": "Apache-2.0",
+  "author": "Lind",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lind-pro/zucker-framework.git",
+    "directory": "packages/network"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "clean": "rm -rf dist",
+    "lint": "eslint src/"
+  }
+}