@zucker-framework/gateway 1.0.0

package/dist/index.js

@@ -0,0 +1,443 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbstractDeviceGateway: () => AbstractDeviceGateway,
+  GatewayManager: () => GatewayManager,
+  GatewayModule: () => GatewayModule,
+  GatewayState: () => GatewayState,
+  HttpDeviceGateway: () => HttpDeviceGateway,
+  ProtocolRegistry: () => ProtocolRegistry,
+  SessionState: () => SessionState
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/device-session.ts
+var SessionState = /* @__PURE__ */ (function(SessionState2) {
+  SessionState2["CONNECTED"] = "connected";
+  SessionState2["CLOSED"] = "closed";
+  SessionState2["IDLE"] = "idle";
+  return SessionState2;
+})({});
+
+// src/codec.ts
+var ProtocolRegistry = class {
+  static {
+    __name(this, "ProtocolRegistry");
+  }
+  protocols = /* @__PURE__ */ new Map();
+  register(protocol) {
+    this.protocols.set(protocol.id, protocol);
+  }
+  unregister(id) {
+    this.protocols.delete(id);
+  }
+  get(id) {
+    return this.protocols.get(id);
+  }
+  getAll() {
+    return Array.from(this.protocols.values());
+  }
+};
+
+// src/device-gateway.ts
+var import_common = require("@nestjs/common");
+var import_things = require("@zucker-framework/things");
+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 GatewayState = /* @__PURE__ */ (function(GatewayState2) {
+  GatewayState2["STARTING"] = "starting";
+  GatewayState2["RUNNING"] = "running";
+  GatewayState2["PAUSED"] = "paused";
+  GatewayState2["STOPPED"] = "stopped";
+  return GatewayState2;
+})({});
+var AbstractDeviceGateway = class {
+  static {
+    __name(this, "AbstractDeviceGateway");
+  }
+  config;
+  protocol;
+  thingManager;
+  dataService;
+  logger;
+  sessions = /* @__PURE__ */ new Map();
+  state = "stopped";
+  constructor(config, protocol, thingManager, dataService) {
+    this.config = config;
+    this.protocol = protocol;
+    this.thingManager = thingManager;
+    this.dataService = dataService;
+    this.logger = new import_common.Logger(this.constructor.name);
+  }
+  getSessionCount() {
+    return this.sessions.size;
+  }
+  getSession(thingId) {
+    return this.sessions.get(thingId);
+  }
+  async sendDownstream(thingId, payload) {
+    const session = this.sessions.get(thingId);
+    if (!session || !session.isAlive()) {
+      throw new Error(`No active session for thing: ${thingId}`);
+    }
+    await session.send(payload);
+  }
+  /**
+  * 处理设备连接 — 注册会话并触发上线
+  */
+  async onSessionConnected(session) {
+    this.sessions.set(session.thingId, session);
+    await this.thingManager.updateState(session.thingId, import_things.ThingState.ONLINE);
+    this.logger.log(`Device connected: ${session.thingId} (session: ${session.sessionId})`);
+  }
+  /**
+  * 处理设备断开 — 移除会话并触发离线
+  */
+  async onSessionClosed(session) {
+    this.sessions.delete(session.thingId);
+    session.state = SessionState.CLOSED;
+    await this.thingManager.updateState(session.thingId, import_things.ThingState.OFFLINE);
+    this.logger.log(`Device disconnected: ${session.thingId}`);
+  }
+  /**
+  * 处理上行原始消息 — 解码后路由到对应处理器
+  * 对应 jetlinks AbstractDeviceGateway.doMessage()
+  */
+  async handleIncoming(context) {
+    const codec = this.protocol.getCodec(this.config.transport);
+    if (!codec) {
+      this.logger.warn(`No codec for transport: ${this.config.transport}`);
+      return;
+    }
+    let messages;
+    try {
+      messages = await codec.decode(context);
+    } catch (err) {
+      this.logger.error(`Decode error for device ${context.session.thingId}:`, err);
+      return;
+    }
+    for (const msg of messages) {
+      await this.routeMessage(msg);
+    }
+  }
+  /**
+  * 将解码后的消息路由到业务处理 — 对应 jetlinks DeviceMessageBus.publish()
+  */
+  async routeMessage(message) {
+    try {
+      switch (message.messageType) {
+        case "Online":
+          await this.thingManager.updateState(message.thingId, import_things.ThingState.ONLINE, message.timestamp);
+          break;
+        case "Offline":
+          await this.thingManager.updateState(message.thingId, import_things.ThingState.OFFLINE, message.timestamp);
+          break;
+        case "Register":
+          break;
+        case "ReportProperty":
+          await this.dataService.saveProperties(message);
+          break;
+        case "Event":
+          await this.dataService.saveEvent(message);
+          break;
+        case "FunctionReply":
+        case "ReadPropertyReply":
+          break;
+        default:
+          break;
+      }
+    } catch (err) {
+      this.logger.error(`Failed to route message ${message.messageType} from ${message.thingId}:`, err);
+    }
+  }
+  /**
+  * 关闭所有会话
+  */
+  async closeAllSessions() {
+    const closing = Array.from(this.sessions.values()).map((s) => s.close().catch(() => {
+    }));
+    await Promise.all(closing);
+    this.sessions.clear();
+  }
+};
+AbstractDeviceGateway = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DeviceGatewayConfig === "undefined" ? Object : DeviceGatewayConfig,
+    typeof ProtocolSupport === "undefined" ? Object : ProtocolSupport,
+    typeof ThingManager === "undefined" ? Object : ThingManager,
+    typeof ThingsDataService === "undefined" ? Object : ThingsDataService
+  ])
+], AbstractDeviceGateway);
+
+// src/http-gateway.ts
+var import_common2 = require("@nestjs/common");
+var import_network = require("@zucker-framework/network");
+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");
+function _ts_metadata2(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata2, "_ts_metadata");
+var HttpDeviceSession = class HttpDeviceSession2 {
+  static {
+    __name(this, "HttpDeviceSession");
+  }
+  sessionId;
+  thingId;
+  gatewayId;
+  transport = import_network.Transports.HTTP;
+  connectTime = Date.now();
+  lastPingTime = Date.now();
+  state = SessionState.CONNECTED;
+  sendFn;
+  constructor(thingId, gatewayId, sendFn) {
+    this.sessionId = `http-${thingId}-${Date.now()}`;
+    this.thingId = thingId;
+    this.gatewayId = gatewayId;
+    this.sendFn = sendFn;
+  }
+  async send(payload) {
+    await this.sendFn(payload);
+  }
+  async close() {
+    this.state = SessionState.CLOSED;
+  }
+  ping() {
+    this.lastPingTime = Date.now();
+  }
+  isAlive() {
+    return this.state === SessionState.CONNECTED;
+  }
+};
+var HttpDeviceGateway = class extends AbstractDeviceGateway {
+  static {
+    __name(this, "HttpDeviceGateway");
+  }
+  constructor(config, protocol, thingManager, dataService) {
+    super(config, protocol, thingManager, dataService);
+  }
+  async start() {
+    this.state = GatewayState.RUNNING;
+    this.logger.log(`HTTP gateway started: ${this.config.id}`);
+  }
+  async pause() {
+    this.state = GatewayState.PAUSED;
+  }
+  async shutdown() {
+    await this.closeAllSessions();
+    this.state = GatewayState.STOPPED;
+    this.logger.log(`HTTP gateway stopped: ${this.config.id}`);
+  }
+  /**
+  * 处理来自设备的 HTTP 请求
+  * 由 NestJS Controller 调用
+  *
+  * @param thingId 设备 ID（从路径参数或认证信息中提取）
+  * @param body 请求体
+  */
+  async handleRequest(thingId, body) {
+    if (this.state !== GatewayState.RUNNING) {
+      throw new Error(`Gateway ${this.config.id} is not running`);
+    }
+    const session = new HttpDeviceSession(thingId, this.config.id, async () => {
+    });
+    await this.onSessionConnected(session);
+    try {
+      await this.handleIncoming({
+        payload: body,
+        session
+      });
+    } finally {
+      await this.onSessionClosed(session);
+    }
+  }
+};
+HttpDeviceGateway = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof DeviceGatewayConfig === "undefined" ? Object : DeviceGatewayConfig,
+    typeof ProtocolSupport === "undefined" ? Object : ProtocolSupport,
+    typeof ThingManager === "undefined" ? Object : ThingManager,
+    typeof ThingsDataService === "undefined" ? Object : ThingsDataService
+  ])
+], HttpDeviceGateway);
+
+// src/gateway-manager.ts
+var import_common3 = require("@nestjs/common");
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+function _ts_metadata3(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata3, "_ts_metadata");
+var GatewayManager = class _GatewayManager {
+  static {
+    __name(this, "GatewayManager");
+  }
+  protocolRegistry;
+  logger = new import_common3.Logger(_GatewayManager.name);
+  gateways = /* @__PURE__ */ new Map();
+  constructor(protocolRegistry) {
+    this.protocolRegistry = protocolRegistry;
+  }
+  register(gateway) {
+    if (this.gateways.has(gateway.config.id)) {
+      throw new Error(`Gateway already registered: ${gateway.config.id}`);
+    }
+    this.gateways.set(gateway.config.id, gateway);
+    this.logger.log(`Gateway registered: ${gateway.config.id} (${gateway.config.name})`);
+  }
+  unregister(gatewayId) {
+    this.gateways.delete(gatewayId);
+  }
+  get(gatewayId) {
+    return this.gateways.get(gatewayId);
+  }
+  getAll() {
+    return Array.from(this.gateways.values());
+  }
+  /** 启动所有已注册的网关 */
+  async startAll() {
+    const results = await Promise.allSettled(Array.from(this.gateways.values()).map((g) => g.start()));
+    for (const [i, result] of results.entries()) {
+      const gateway = Array.from(this.gateways.values())[i];
+      if (result.status === "rejected") {
+        this.logger.error(`Failed to start gateway ${gateway?.config.id}:`, result.reason);
+      }
+    }
+  }
+  /** 停止所有网关 */
+  async shutdownAll() {
+    await Promise.allSettled(Array.from(this.gateways.values()).map((g) => g.shutdown()));
+  }
+  /** 汇总统计 */
+  getSummary() {
+    const all = Array.from(this.gateways.values());
+    return {
+      total: all.length,
+      running: all.filter((g) => g.state === GatewayState.RUNNING).length,
+      stopped: all.filter((g) => g.state === GatewayState.STOPPED).length,
+      totalSessions: all.reduce((sum, g) => sum + g.getSessionCount(), 0)
+    };
+  }
+};
+GatewayManager = _ts_decorate3([
+  (0, import_common3.Injectable)(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ProtocolRegistry === "undefined" ? Object : ProtocolRegistry
+  ])
+], GatewayManager);
+
+// src/gateway.module.ts
+var import_common4 = require("@nestjs/common");
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+var GatewayModule = class {
+  static {
+    __name(this, "GatewayModule");
+  }
+};
+GatewayModule = _ts_decorate4([
+  (0, import_common4.Module)({
+    providers: [
+      ProtocolRegistry,
+      GatewayManager
+    ],
+    exports: [
+      ProtocolRegistry,
+      GatewayManager
+    ]
+  })
+], GatewayModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractDeviceGateway,
+  GatewayManager,
+  GatewayModule,
+  GatewayState,
+  HttpDeviceGateway,
+  ProtocolRegistry,
+  SessionState
+});