@internetderdinge/api 1.224.2 → 1.229.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@internetderdinge/api",
-  "version": "1.224.2",
+  "version": "1.229.0",
   "description": "Shared OpenIoT API modules",
   "main": "src/index.ts",
   "type": "module",
@@ -9,6 +9,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "deploy:version": "node ./scripts/release-version.mjs",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
@@ -23,9 +24,6 @@
     "@aws-sdk/util-endpoints": "^3.216.0",
     "@sentry/node": "^10.25.0",
     "@sentry/profiling-node": "^10.25.0",
-    "@wirewire/fhir": "^1.212.0",
-    "@wirewire/fhir-helpers": "^1.212.0",
-    "@wirewire/helpers": "^1.223.0",
     "agenda": "^5.0.0",
     "agendash": "^4.0.0",
     "auth0": "^4.23.1",
@@ -81,6 +79,7 @@
     "request": "^2.81.0",
     "rrule": "^2.7.1",
     "sharp": "^0.33.5",
+    "semver": "^7.7.1",
     "stripe": "^12.6.0",
     "swagger-ui-express": "^5.0.1",
     "ts-node": "^10.9.2",

package/scripts/release-version.mjs

@@ -0,0 +1,145 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import semver from "semver";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..");
+
+const args = process.argv.slice(2);
+const shouldPublish = args.includes("--publish");
+const versionInput = args.find((value) => !value.startsWith("-")) ?? "patch";
+
+const readJson = (filePath) => {
+  const raw = fs.readFileSync(filePath, "utf8");
+  return JSON.parse(raw);
+};
+
+const writeJson = (filePath, data) => {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`);
+};
+
+const resolveNextVersion = (current, input) => {
+  const cleanedCurrent = semver.valid(semver.clean(current));
+  if (!cleanedCurrent) {
+    throw new Error(`Unsupported version format: ${current}`);
+  }
+
+  const exact = semver.valid(input);
+  if (exact) {
+    return exact;
+  }
+
+  if (input === "major" || input === "minor" || input === "patch") {
+    const bumped = semver.inc(cleanedCurrent, input);
+    if (!bumped) {
+      throw new Error(`Failed to bump version: ${current}`);
+    }
+    return bumped;
+  }
+
+  throw new Error(
+    `Unknown version input: ${input}. Use major/minor/patch or a semver like 1.2.3.`,
+  );
+};
+
+const resolveMemoMonoRoot = () => {
+  if (process.env.MEMO_MONO_PATH) {
+    return path.resolve(process.env.MEMO_MONO_PATH);
+  }
+
+  return path.resolve(repoRoot, "../../memo/memo-mono");
+};
+
+const updateDependencyVersion = (
+  packageJsonPath,
+  dependencyName,
+  newVersion,
+  expectedVersion,
+) => {
+  const packageJson = readJson(packageJsonPath);
+  const dependencies = packageJson.dependencies ?? {};
+
+  if (!dependencies[dependencyName]) {
+    throw new Error(
+      `Missing dependency ${dependencyName} in ${packageJsonPath}`,
+    );
+  }
+
+  const currentRange = dependencies[dependencyName];
+  const currentDependencyMin = semver.minVersion(currentRange);
+  if (!currentDependencyMin) {
+    throw new Error(
+      `Unsupported dependency version for ${dependencyName} in ${packageJsonPath}: ${currentRange}`,
+    );
+  }
+  const currentDependencyVersion = currentDependencyMin.version;
+
+  if (expectedVersion && currentDependencyVersion !== expectedVersion) {
+    throw new Error(
+      `${path.basename(path.dirname(packageJsonPath))} dependency is ${currentRange} (expected ${expectedVersion}). Update it before bumping.`,
+    );
+  }
+
+  const prefix = currentRange.startsWith("^")
+    ? "^"
+    : currentRange.startsWith("~")
+      ? "~"
+      : "";
+
+  dependencies[dependencyName] = `${prefix}${newVersion}`;
+  packageJson.dependencies = dependencies;
+  writeJson(packageJsonPath, packageJson);
+
+  return { previous: currentRange, next: dependencies[dependencyName] };
+};
+
+const apiPackagePath = path.join(repoRoot, "package.json");
+const apiPackage = readJson(apiPackagePath);
+const currentVersion = apiPackage.version;
+const cleanedCurrent = semver.valid(semver.clean(currentVersion));
+if (!cleanedCurrent) {
+  throw new Error(`Unsupported version format: ${currentVersion}`);
+}
+
+const nextVersion = resolveNextVersion(currentVersion, versionInput);
+
+const memoMonoRoot = resolveMemoMonoRoot();
+const memoApiPath = path.join(memoMonoRoot, "packages/memo-api/package.json");
+const paperlessApiPath = path.join(
+  memoMonoRoot,
+  "packages/paperlesspaper-api/package.json",
+);
+
+if (!fs.existsSync(memoApiPath) || !fs.existsSync(paperlessApiPath)) {
+  throw new Error(
+    `Could not find memo-mono package.json files. Set MEMO_MONO_PATH to the repo root.`,
+  );
+}
+
+const memoUpdate = updateDependencyVersion(
+  memoApiPath,
+  "@internetderdinge/api",
+  nextVersion,
+  cleanedCurrent,
+);
+const paperlessUpdate = updateDependencyVersion(
+  paperlessApiPath,
+  "@internetderdinge/api",
+  nextVersion,
+  cleanedCurrent,
+);
+
+apiPackage.version = nextVersion;
+writeJson(apiPackagePath, apiPackage);
+
+console.log(`Updated @internetderdinge/api to ${nextVersion}`);
+console.log(`memo-api: ${memoUpdate.previous} -> ${memoUpdate.next}`);
+console.log(
+  `paperlesspaper-api: ${paperlessUpdate.previous} -> ${paperlessUpdate.next}`,
+);
+
+if (shouldPublish) {
+  execSync("npm publish", { cwd: repoRoot, stdio: "inherit" });
+}

package/src/devices/devices.service.ts

@@ -5,7 +5,7 @@ import iotDevicesService from "../iotdevice/iotdevice.service.js";
 
 import { promisify } from "util";
 import { getSignedFileUrl } from "../files/upload.service";
-import { deviceByDeviceName, deviceKindHasFeature } from "@wirewire/helpers";
+import { deviceByDeviceName, deviceKindHasFeature } from "../utils/deviceUtils";
 
 import type { DeviceDocument, DeviceInput } from "./devices.model.js";
 import type { ApiErrorType } from "../utils/ApiError.js";

package/src/i18n/i18n.ts

@@ -5,7 +5,7 @@ import { existsSync, readdirSync } from "fs";
 import i18next from "i18next";
 import Backend, { setLocalesFolder } from "./saveMissingLocalJsonBackend";
 
-import config from "@wirewire/openiot-api/src/config/config";
+import config from "../config/config";
 
 // Fix for __dirname in ES modules
 const __filename = fileURLToPath(import.meta.url);

package/src/iotdevice/iotdevice.service.ts

@@ -1,7 +1,7 @@
 import httpStatus from "http-status";
 import axios from "axios";
 import AWS from "aws-sdk";
-import { deviceKindHasFeature } from "@wirewire/helpers";
+import { deviceKindHasFeature } from "../utils/deviceUtils";
 import ApiError from "../utils/ApiError";
 import { getAuth0Token } from "../accounts/auth0.service";
 import {

package/src/utils/deviceUtils.ts

@@ -0,0 +1,109 @@
+import { readFileSync } from "fs";
+import path from "path";
+
+export type DeviceListEntry = {
+  id: string;
+  features: string[];
+  deviceNameDetection?: string;
+  [key: string]: any;
+};
+
+export interface InitDeviceListOptions {
+  list?: DeviceListEntry[];
+  listPath?: string;
+}
+
+let deviceList: DeviceListEntry[] | null = null;
+
+const parseDeviceList = (value: unknown): DeviceListEntry[] => {
+  if (!Array.isArray(value)) {
+    throw new Error("Device list must be an array.");
+  }
+  return value as DeviceListEntry[];
+};
+
+const loadDeviceListFromFile = (listPath: string): DeviceListEntry[] => {
+  const absolutePath = path.resolve(listPath);
+  const raw = readFileSync(absolutePath, "utf8");
+  const parsed = JSON.parse(raw) as unknown;
+  return parseDeviceList(parsed);
+};
+
+export const initDeviceList = (
+  options: InitDeviceListOptions = {},
+): DeviceListEntry[] => {
+  if (options.list) {
+    deviceList = options.list;
+    return deviceList;
+  }
+  if (options.listPath) {
+    deviceList = loadDeviceListFromFile(options.listPath);
+    return deviceList;
+  }
+  throw new Error("initDeviceList requires list or listPath.");
+};
+
+const ensureDeviceList = (): DeviceListEntry[] => {
+  if (!deviceList) {
+    throw new Error(
+      "deviceList is not initialized. Call initDeviceList(...) before using device utilities.",
+    );
+  }
+  return deviceList;
+};
+
+export { deviceList as default };
+
+export function deviceByKind(device): any {
+  const list = ensureDeviceList();
+  const result = list.find((e) => e.id === device);
+  return result;
+}
+
+export function deviceByDeviceName(deviceName): any {
+  if (!deviceName) return false;
+  const list = ensureDeviceList();
+  const result = list.find((e) => {
+    if (!e.deviceNameDetection) return false;
+
+    return deviceName.startsWith(e.deviceNameDetection);
+  });
+  if (!result) return false;
+  return result;
+}
+
+/**
+ * Returns true if the device kind has the given feature
+ */
+export function deviceKindHasFeature(
+  feature:
+    | "analog"
+    | "wifi"
+    | "epaper"
+    | "nbiot"
+    | "nouser"
+    | "battery-offline"
+    | "code7"
+    | "sensor"
+    | "payment"
+    | "anabox-smart"
+    | "intakes1"
+    | "intakes3"
+    | "intakes4"
+    | "intakes5"
+    | "intakes7"
+    | "stationaer"
+    | "tray-colors"
+    | "nuechtern-bedarf"
+    | "week-colors"
+    | "day-colors"
+    | "alt-device"
+    | "battery-level",
+  kind?: DeviceListEntry["id"],
+): boolean {
+  if (!kind) return false;
+  const list = ensureDeviceList();
+  const result = list.find((e) => e.id === kind);
+  if (!result) return false;
+  return result.features.includes(feature);
+}