@zucker-framework/things 1.0.0

package/dist/index.js

@@ -0,0 +1,451 @@
+"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, {
+  DefaultThingsDataService: () => DefaultThingsDataService,
+  EventLevel: () => EventLevel,
+  InMemoryThingManager: () => InMemoryThingManager,
+  PropertyAccessMode: () => PropertyAccessMode,
+  ThingState: () => ThingState,
+  ThingsModule: () => ThingsModule,
+  convertValue: () => convertValue,
+  createEventMessage: () => createEventMessage,
+  createMessageId: () => createMessageId,
+  createMetadata: () => createMetadata,
+  createReportPropertyMessage: () => createReportPropertyMessage,
+  mergeMetadata: () => mergeMetadata
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/data-type.ts
+function convertValue(type, raw) {
+  if (raw === null || raw === void 0) return raw;
+  switch (type.id) {
+    case "int":
+    case "long": {
+      const n = Number(raw);
+      return isNaN(n) ? raw : Math.trunc(n);
+    }
+    case "float":
+    case "double": {
+      const n = Number(raw);
+      if (isNaN(n)) return raw;
+      if (type.scale !== void 0) {
+        return parseFloat(n.toFixed(type.scale));
+      }
+      return n;
+    }
+    case "boolean": {
+      if (typeof raw === "boolean") return raw;
+      const tv = type.trueValue ?? "true";
+      const fv = type.falseValue ?? "false";
+      if (String(raw) === tv) return true;
+      if (String(raw) === fv) return false;
+      return Boolean(raw);
+    }
+    case "string":
+    case "password":
+      return String(raw);
+    case "date": {
+      if (raw instanceof Date) return raw.getTime();
+      const n = Number(raw);
+      return isNaN(n) ? new Date(String(raw)).getTime() : n;
+    }
+    case "enum": {
+      const match = type.elements.find((e) => e.value === raw || String(e.value) === String(raw));
+      return match ? match.value : raw;
+    }
+    default:
+      return raw;
+  }
+}
+__name(convertValue, "convertValue");
+
+// src/metadata.ts
+var PropertyAccessMode = /* @__PURE__ */ (function(PropertyAccessMode2) {
+  PropertyAccessMode2["READ"] = "r";
+  PropertyAccessMode2["WRITE"] = "w";
+  PropertyAccessMode2["READ_WRITE"] = "rw";
+  return PropertyAccessMode2;
+})({});
+var EventLevel = /* @__PURE__ */ (function(EventLevel2) {
+  EventLevel2["OTHER"] = "other";
+  EventLevel2["WARN"] = "warn";
+  EventLevel2["ERROR"] = "error";
+  return EventLevel2;
+})({});
+function mergeMetadata(base, patch) {
+  const mergeList = /* @__PURE__ */ __name((a, b = []) => {
+    const map = new Map(a.map((i) => [
+      i.id,
+      i
+    ]));
+    for (const item of b) {
+      map.set(item.id, item);
+    }
+    return Array.from(map.values());
+  }, "mergeList");
+  return {
+    properties: mergeList(base.properties, patch.properties),
+    functions: mergeList(base.functions, patch.functions),
+    events: mergeList(base.events, patch.events),
+    tags: mergeList(base.tags ?? [], patch.tags)
+  };
+}
+__name(mergeMetadata, "mergeMetadata");
+function createMetadata(partial = {}) {
+  return {
+    properties: partial.properties ?? [],
+    functions: partial.functions ?? [],
+    events: partial.events ?? [],
+    tags: partial.tags ?? []
+  };
+}
+__name(createMetadata, "createMetadata");
+
+// src/thing.ts
+var ThingState = /* @__PURE__ */ (function(ThingState2) {
+  ThingState2["INACTIVE"] = "notActive";
+  ThingState2["OFFLINE"] = "offline";
+  ThingState2["ONLINE"] = "online";
+  return ThingState2;
+})({});
+
+// src/thing-manager.ts
+var import_common = require("@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");
+var InMemoryThingManager = class {
+  static {
+    __name(this, "InMemoryThingManager");
+  }
+  types = /* @__PURE__ */ new Map();
+  things = /* @__PURE__ */ new Map();
+  async getThingType(typeId) {
+    return this.types.get(typeId);
+  }
+  async registerThingType(type) {
+    this.types.set(type.id, type);
+  }
+  async getThing(thingId) {
+    return this.things.get(thingId);
+  }
+  async registerThing(thing) {
+    const existing = this.things.get(thing.id);
+    this.things.set(thing.id, {
+      ...existing,
+      ...thing,
+      state: existing?.state ?? ThingState.INACTIVE
+    });
+  }
+  async unregisterThing(thingId) {
+    this.things.delete(thingId);
+  }
+  async updateState(thingId, state, timestamp) {
+    const thing = this.things.get(thingId);
+    if (!thing) return;
+    const update = {
+      state
+    };
+    if (state === ThingState.ONLINE) {
+      update.onlineTime = timestamp ?? Date.now();
+    } else if (state === ThingState.OFFLINE) {
+      update.offlineTime = timestamp ?? Date.now();
+    }
+    this.things.set(thingId, {
+      ...thing,
+      ...update
+    });
+  }
+  async getEffectiveMetadata(thingId) {
+    const thing = this.things.get(thingId);
+    if (!thing) return void 0;
+    const type = this.types.get(thing.thingTypeId);
+    if (!type) return void 0;
+    if (!thing.metadataPatch) {
+      return type.metadata;
+    }
+    return mergeMetadata(type.metadata, thing.metadataPatch);
+  }
+  /** 获取指定类型的所有实例 */
+  getThingsByType(typeId) {
+    return Array.from(this.things.values()).filter((t) => t.thingTypeId === typeId);
+  }
+  /** 获取所有在线实例数量 */
+  countOnline() {
+    return Array.from(this.things.values()).filter((t) => t.state === ThingState.ONLINE).length;
+  }
+};
+InMemoryThingManager = _ts_decorate([
+  (0, import_common.Injectable)()
+], InMemoryThingManager);
+
+// src/message.ts
+function createMessageId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+__name(createMessageId, "createMessageId");
+function createReportPropertyMessage(thingId, thingType, properties, extra) {
+  return {
+    messageType: "ReportProperty",
+    messageId: createMessageId(),
+    thingId,
+    thingType,
+    timestamp: Date.now(),
+    properties,
+    ...extra
+  };
+}
+__name(createReportPropertyMessage, "createReportPropertyMessage");
+function createEventMessage(thingId, thingType, event, data) {
+  return {
+    messageType: "Event",
+    messageId: createMessageId(),
+    thingId,
+    thingType,
+    timestamp: Date.now(),
+    event,
+    data
+  };
+}
+__name(createEventMessage, "createEventMessage");
+
+// src/property-log.ts
+var import_common2 = require("@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");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+var DefaultThingsDataService = class {
+  static {
+    __name(this, "DefaultThingsDataService");
+  }
+  tsService;
+  constructor(tsService) {
+    this.tsService = tsService;
+  }
+  propertyMetric(thingType) {
+    return `thing_property_${thingType}`;
+  }
+  eventMetric(thingType, eventId) {
+    return `thing_event_${thingType}_${eventId}`;
+  }
+  async saveProperties(message) {
+    const metric = this.propertyMetric(message.thingType);
+    const points = Object.entries(message.properties).map(([key, value]) => ({
+      timestamp: message.propertySourceTimes?.[key] ?? message.timestamp,
+      tags: {
+        thingId: message.thingId,
+        thingType: message.thingType,
+        property: key
+      },
+      values: {
+        value: typeof value === "object" ? JSON.stringify(value) : value,
+        state: message.propertyStates?.[key] ?? "success"
+      }
+    }));
+    for (const point of points) {
+      const propMetric = `thing_property_${message.thingType}_${point.tags["property"]}`;
+      await this.tsService.save({
+        ...point,
+        tags: {
+          thingId: point.tags["thingId"],
+          thingType: point.tags["thingType"]
+        }
+      });
+      void propMetric;
+    }
+    if (points.length > 0) {
+      await this.tsService.saveBatch(points.map((p) => ({
+        ...p,
+        tags: {
+          ...p.tags
+        },
+        values: {
+          ...p.values,
+          metric
+        }
+      })));
+    }
+  }
+  async saveEvent(message) {
+    const metric = this.eventMetric(message.thingType, message.event);
+    const data = {
+      timestamp: message.timestamp,
+      tags: {
+        thingId: message.thingId,
+        thingType: message.thingType,
+        event: message.event
+      },
+      values: {
+        data: typeof message.data === "object" ? JSON.stringify(message.data) : message.data,
+        metric
+      }
+    };
+    await this.tsService.save(data);
+  }
+  async queryPropertyLogs(query) {
+    const tsQuery = {
+      metric: this.propertyMetric(query.thingType),
+      from: query.from,
+      to: query.to,
+      tags: {
+        thingId: query.thingId,
+        property: query.id
+      },
+      limit: query.limit,
+      order: query.order
+    };
+    const results = await this.tsService.query(tsQuery);
+    return results.map((r) => ({
+      property: String(r.tags["property"] ?? query.id),
+      value: r.values["value"],
+      thingId: String(r.tags["thingId"]),
+      thingType: String(r.tags["thingType"] ?? query.thingType),
+      timestamp: r.timestamp,
+      state: r.values["state"]
+    }));
+  }
+  async queryEventLogs(query) {
+    const tsQuery = {
+      metric: this.eventMetric(query.thingType, query.id),
+      from: query.from,
+      to: query.to,
+      tags: {
+        thingId: query.thingId
+      },
+      limit: query.limit,
+      order: query.order
+    };
+    const results = await this.tsService.query(tsQuery);
+    return results.map((r) => {
+      let data = r.values["data"];
+      if (typeof data === "string") {
+        try {
+          data = JSON.parse(data);
+        } catch {
+        }
+      }
+      return {
+        event: String(r.tags["event"] ?? query.id),
+        data,
+        thingId: String(r.tags["thingId"]),
+        thingType: String(r.tags["thingType"] ?? query.thingType),
+        timestamp: r.timestamp
+      };
+    });
+  }
+  async aggregateProperties(thingId, thingType, property, aggQuery) {
+    const query = {
+      ...aggQuery,
+      metric: this.propertyMetric(thingType),
+      tags: {
+        ...aggQuery.tags,
+        thingId,
+        property
+      }
+    };
+    return this.tsService.aggregate(query);
+  }
+};
+DefaultThingsDataService = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof TimeSeriesService === "undefined" ? Object : TimeSeriesService
+  ])
+], DefaultThingsDataService);
+
+// src/things.module.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");
+var ThingsModule = class {
+  static {
+    __name(this, "ThingsModule");
+  }
+};
+ThingsModule = _ts_decorate3([
+  (0, import_common3.Module)({
+    providers: [
+      InMemoryThingManager
+    ],
+    exports: [
+      InMemoryThingManager
+    ]
+  })
+], ThingsModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultThingsDataService,
+  EventLevel,
+  InMemoryThingManager,
+  PropertyAccessMode,
+  ThingState,
+  ThingsModule,
+  convertValue,
+  createEventMessage,
+  createMessageId,
+  createMetadata,
+  createReportPropertyMessage,
+  mergeMetadata
+});