@zucker-framework/things 1.0.0

package/dist/index.mjs

@@ -0,0 +1,415 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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
+import { Injectable } 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");
+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([
+  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
+import { Injectable as Injectable2 } 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");
+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([
+  Injectable2(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof TimeSeriesService === "undefined" ? Object : TimeSeriesService
+  ])
+], DefaultThingsDataService);
+
+// src/things.module.ts
+import { Module } from "@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([
+  Module({
+    providers: [
+      InMemoryThingManager
+    ],
+    exports: [
+      InMemoryThingManager
+    ]
+  })
+], ThingsModule);
+export {
+  DefaultThingsDataService,
+  EventLevel,
+  InMemoryThingManager,
+  PropertyAccessMode,
+  ThingState,
+  ThingsModule,
+  convertValue,
+  createEventMessage,
+  createMessageId,
+  createMetadata,
+  createReportPropertyMessage,
+  mergeMetadata
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@zucker-framework/things",
+  "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/event": "1.0.0",
+    "@zucker-framework/timeseries": "1.0.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/core": "^12.0.0",
+    "rxjs": "^7.0.0"
+  },
+  "license": "Apache-2.0",
+  "author": "Lind",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lind-pro/zucker-framework.git",
+    "directory": "packages/things"
+  },
+  "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/"
+  }
+}