edilkamin 1.6.0 → 1.6.2

package/src/library.test.ts

@@ -1,10 +1,25 @@
 import { strict as assert } from "assert";
 import axios from "axios";
+import pako from "pako";
 import sinon from "sinon";
 
 import { configure, createAuthService } from "../src/library";
 import { API_URL } from "./constants";
 
+/**
+ * Helper to create a gzip-compressed Buffer object for testing.
+ */
+const createGzippedBuffer = (
+  data: unknown
+): { type: "Buffer"; data: number[] } => {
+  const json = JSON.stringify(data);
+  const compressed = pako.gzip(json);
+  return {
+    type: "Buffer",
+    data: Array.from(compressed),
+  };
+};
+
 describe("library", () => {
   let axiosStub: sinon.SinonStub;
   const expectedToken = "mockJwtToken";
@@ -22,7 +37,7 @@ describe("library", () => {
   });
 
   describe("signIn", () => {
-    it("should sign in and return the JWT token", async () => {
+    it("should sign in and return the ID token by default", async () => {
       const expectedUsername = "testuser";
       const expectedPassword = "testpassword";
       const signIn = sinon.stub().resolves({ isSignedIn: true });
@@ -30,6 +45,7 @@ describe("library", () => {
       const fetchAuthSession = sinon.stub().resolves({
         tokens: {
           idToken: { toString: () => expectedToken },
+          accessToken: { toString: () => "accessToken" },
         },
       });
       const authStub = {
@@ -50,6 +66,32 @@ describe("library", () => {
       assert.equal(token, expectedToken);
     });
 
+    it("should sign in and return the access token in legacy mode", async () => {
+      const expectedUsername = "testuser";
+      const expectedPassword = "testpassword";
+      const signIn = sinon.stub().resolves({ isSignedIn: true });
+      const signOut = sinon.stub();
+      const fetchAuthSession = sinon.stub().resolves({
+        tokens: {
+          accessToken: { toString: () => expectedToken },
+          idToken: { toString: () => "idToken" },
+        },
+      });
+      const authStub = {
+        signIn,
+        signOut,
+        fetchAuthSession,
+      };
+      // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+      const authService = createAuthService(authStub as any);
+      const token = await authService.signIn(
+        expectedUsername,
+        expectedPassword,
+        true // legacy mode
+      );
+      assert.equal(token, expectedToken);
+    });
+
     it("should throw an error if sign-in fails", async () => {
       const expectedUsername = "testuser";
       const expectedPassword = "testpassword";
@@ -80,6 +122,8 @@ describe("library", () => {
   describe("configure", () => {
     const expectedApi = [
       "deviceInfo",
+      "registerDevice",
+      "editDevice",
       "setPower",
       "setPowerOff",
       "setPowerOn",
@@ -273,4 +317,282 @@ describe("library", () => {
       });
     });
   });
+
+  describe("registerDevice", () => {
+    it("should call POST /device with correct payload", async () => {
+      const mockResponse = {
+        macAddress: "AABBCCDDEEFF",
+        deviceName: "Test Stove",
+        deviceRoom: "Living Room",
+        serialNumber: "EDK123",
+      };
+      const mockAxios = {
+        post: sinon.stub().resolves({ data: mockResponse }),
+        get: sinon.stub(),
+        put: sinon.stub(),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      const result = await api.registerDevice(
+        expectedToken,
+        "AA:BB:CC:DD:EE:FF",
+        "EDK123",
+        "Test Stove",
+        "Living Room"
+      );
+
+      assert.deepEqual(mockAxios.post.args, [
+        [
+          "device",
+          {
+            macAddress: "AABBCCDDEEFF",
+            deviceName: "Test Stove",
+            deviceRoom: "Living Room",
+            serialNumber: "EDK123",
+          },
+          { headers: { Authorization: `Bearer ${expectedToken}` } },
+        ],
+      ]);
+      assert.deepEqual(result, mockResponse);
+    });
+
+    it("should normalize MAC address by removing colons", async () => {
+      const mockAxios = {
+        post: sinon.stub().resolves({ data: {} }),
+        get: sinon.stub(),
+        put: sinon.stub(),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      await api.registerDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "EDK123");
+
+      assert.equal(mockAxios.post.args[0][1].macAddress, "AABBCCDDEEFF");
+    });
+
+    it("should use empty strings as defaults for name and room", async () => {
+      const mockAxios = {
+        post: sinon.stub().resolves({ data: {} }),
+        get: sinon.stub(),
+        put: sinon.stub(),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      await api.registerDevice(expectedToken, "AABBCCDDEEFF", "EDK123");
+
+      assert.equal(mockAxios.post.args[0][1].deviceName, "");
+      assert.equal(mockAxios.post.args[0][1].deviceRoom, "");
+    });
+  });
+
+  describe("editDevice", () => {
+    it("should call PUT /device/{mac} with correct payload", async () => {
+      const mockResponse = {
+        macAddress: "AABBCCDDEEFF",
+        deviceName: "Updated Name",
+        deviceRoom: "Basement",
+        serialNumber: "EDK123",
+      };
+      const mockAxios = {
+        put: sinon.stub().resolves({ data: mockResponse }),
+        get: sinon.stub(),
+        post: sinon.stub(),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      const result = await api.editDevice(
+        expectedToken,
+        "AA:BB:CC:DD:EE:FF",
+        "Updated Name",
+        "Basement"
+      );
+
+      assert.deepEqual(mockAxios.put.args, [
+        [
+          "device/AABBCCDDEEFF",
+          {
+            deviceName: "Updated Name",
+            deviceRoom: "Basement",
+          },
+          { headers: { Authorization: `Bearer ${expectedToken}` } },
+        ],
+      ]);
+      assert.deepEqual(result, mockResponse);
+    });
+
+    it("should use empty strings as defaults for name and room", async () => {
+      const mockAxios = {
+        put: sinon.stub().resolves({ data: {} }),
+        get: sinon.stub(),
+        post: sinon.stub(),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      await api.editDevice(expectedToken, "AABBCCDDEEFF");
+
+      assert.equal(mockAxios.put.args[0][1].deviceName, "");
+      assert.equal(mockAxios.put.args[0][1].deviceRoom, "");
+    });
+  });
+
+  describe("deviceInfo with compressed responses", () => {
+    it("should decompress Buffer-encoded status field", async () => {
+      const statusData = {
+        commands: { power: true },
+        temperatures: { enviroment: 19, board: 25 },
+      };
+      const mockResponse = {
+        status: createGzippedBuffer(statusData),
+        nvm: {
+          user_parameters: {
+            enviroment_1_temperature: 22,
+          },
+        },
+      };
+
+      const mockAxios = {
+        get: sinon.stub().resolves({ data: mockResponse }),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      const result = await api.deviceInfo(expectedToken, "mockMacAddress");
+
+      assert.deepEqual(result.status, statusData);
+    });
+
+    it("should decompress Buffer-encoded nvm field", async () => {
+      const nvmData = {
+        user_parameters: {
+          enviroment_1_temperature: 22,
+          enviroment_2_temperature: 0,
+          enviroment_3_temperature: 0,
+          is_auto: false,
+          is_sound_active: true,
+        },
+      };
+      const mockResponse = {
+        status: {
+          commands: { power: true },
+          temperatures: { enviroment: 19 },
+        },
+        nvm: createGzippedBuffer(nvmData),
+      };
+
+      const mockAxios = {
+        get: sinon.stub().resolves({ data: mockResponse }),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      const result = await api.deviceInfo(expectedToken, "mockMacAddress");
+
+      assert.deepEqual(result.nvm, nvmData);
+    });
+
+    it("should handle fully compressed response (status and nvm)", async () => {
+      const statusData = {
+        commands: { power: false },
+        temperatures: { enviroment: 21, board: 30 },
+      };
+      const nvmData = {
+        user_parameters: {
+          enviroment_1_temperature: 20,
+          enviroment_2_temperature: 0,
+          enviroment_3_temperature: 0,
+          is_auto: true,
+          is_sound_active: false,
+        },
+      };
+      const mockResponse = {
+        status: createGzippedBuffer(statusData),
+        nvm: createGzippedBuffer(nvmData),
+      };
+
+      const mockAxios = {
+        get: sinon.stub().resolves({ data: mockResponse }),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      const result = await api.deviceInfo(expectedToken, "mockMacAddress");
+
+      assert.deepEqual(result.status, statusData);
+      assert.deepEqual(result.nvm, nvmData);
+    });
+
+    it("should work with getPower on compressed response", async () => {
+      const statusData = {
+        commands: { power: true },
+        temperatures: { enviroment: 19 },
+      };
+      const mockResponse = {
+        status: createGzippedBuffer(statusData),
+        nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+      };
+
+      const mockAxios = {
+        get: sinon.stub().resolves({ data: mockResponse }),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      const result = await api.getPower(expectedToken, "mockMacAddress");
+
+      assert.equal(result, true);
+    });
+
+    it("should work with getEnvironmentTemperature on compressed response", async () => {
+      const statusData = {
+        commands: { power: true },
+        temperatures: { enviroment: 19, board: 25 },
+      };
+      const mockResponse = {
+        status: createGzippedBuffer(statusData),
+        nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+      };
+
+      const mockAxios = {
+        get: sinon.stub().resolves({ data: mockResponse }),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      const result = await api.getEnvironmentTemperature(
+        expectedToken,
+        "mockMacAddress"
+      );
+
+      assert.equal(result, 19);
+    });
+
+    it("should work with getTargetTemperature on compressed response", async () => {
+      const nvmData = {
+        user_parameters: {
+          enviroment_1_temperature: 22,
+        },
+      };
+      const mockResponse = {
+        status: { commands: { power: true }, temperatures: { enviroment: 19 } },
+        nvm: createGzippedBuffer(nvmData),
+      };
+
+      const mockAxios = {
+        get: sinon.stub().resolves({ data: mockResponse }),
+      };
+      axiosStub.returns(mockAxios);
+      const api = configure("https://example.com/api");
+
+      const result = await api.getTargetTemperature(
+        expectedToken,
+        "mockMacAddress"
+      );
+
+      assert.equal(result, 22);
+    });
+  });
 });

package/src/library.ts

@@ -3,8 +3,15 @@ import { Amplify } from "aws-amplify";
 import * as amplifyAuth from "aws-amplify/auth";
 import axios, { AxiosInstance } from "axios";
 
+import { processResponse } from "./buffer-utils";
 import { API_URL } from "./constants";
-import { DeviceInfoType } from "./types";
+import {
+  DeviceAssociationBody,
+  DeviceAssociationResponse,
+  DeviceInfoRawType,
+  DeviceInfoType,
+  EditDeviceAssociationBody,
+} from "./types";
 
 const amplifyconfiguration = {
   aws_project_region: "eu-central-1",
@@ -19,14 +26,16 @@ const amplifyconfiguration = {
  */
 const headers = (jwtToken: string) => ({ Authorization: `Bearer ${jwtToken}` });
 
+let amplifyConfigured = false;
+
 /**
  * Configures Amplify if not already configured.
- * Ensures the configuration is only applied once.
+ * Uses a local flag to avoid calling getConfig() which prints a warning.
  */
 const configureAmplify = () => {
-  const currentConfig = Amplify.getConfig();
-  if (Object.keys(currentConfig).length !== 0) return;
+  if (amplifyConfigured) return;
   Amplify.configure(amplifyconfiguration);
+  amplifyConfigured = true;
 };
 
 /**
@@ -39,12 +48,14 @@ const createAuthService = (auth: typeof amplifyAuth) => {
    * Signs in a user with the provided credentials.
    * @param {string} username - The username of the user.
    * @param {string} password - The password of the user.
+   * @param {boolean} [legacy=false] - If true, returns accessToken for legacy API.
    * @returns {Promise<string>} - The JWT token of the signed-in user.
    * @throws {Error} - If sign-in fails or no tokens are retrieved.
    */
   const signIn = async (
     username: string,
-    password: string
+    password: string,
+    legacy: boolean = false
   ): Promise<string> => {
     configureAmplify();
     await auth.signOut(); // Ensure the user is signed out first
@@ -52,6 +63,10 @@ const createAuthService = (auth: typeof amplifyAuth) => {
     assert.ok(isSignedIn, "Sign-in failed");
     const { tokens } = await auth.fetchAuthSession();
     assert.ok(tokens, "No tokens found");
+    if (legacy) {
+      assert.ok(tokens.accessToken, "No access token found");
+      return tokens.accessToken.toString();
+    }
     assert.ok(tokens.idToken, "No ID token found");
     return tokens.idToken.toString();
   };
@@ -65,19 +80,21 @@ const deviceInfo =
   (axiosInstance: AxiosInstance) =>
   /**
    * Retrieves information about a device by its MAC address.
+   * Automatically decompresses any gzip-compressed Buffer fields in the response.
    *
    * @param {string} jwtToken - The JWT token for authentication.
    * @param {string} macAddress - The MAC address of the device.
    * @returns {Promise<DeviceInfoType>} - A promise that resolves to the device info.
    */
-  async (jwtToken: string, macAddress: string) => {
-    const response = await axiosInstance.get<DeviceInfoType>(
+  async (jwtToken: string, macAddress: string): Promise<DeviceInfoType> => {
+    const response = await axiosInstance.get<DeviceInfoRawType>(
       `device/${macAddress}/info`,
       {
         headers: headers(jwtToken),
       }
     );
-    return response.data;
+    // Process response to decompress any gzipped Buffer fields
+    return processResponse(response.data) as DeviceInfoType;
   };
 
 const mqttCommand =
@@ -193,6 +210,70 @@ const setTargetTemperature =
       value: temperature,
     });
 
+const registerDevice =
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Registers a device with the user's account.
+   * This must be called before other device operations will work on the new API.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device (colons optional).
+   * @param {string} serialNumber - The device serial number.
+   * @param {string} deviceName - User-friendly name for the device (default: empty string).
+   * @param {string} deviceRoom - Room name for the device (default: empty string).
+   * @returns {Promise<DeviceAssociationResponse>} - A promise that resolves to the registration response.
+   */
+  async (
+    jwtToken: string,
+    macAddress: string,
+    serialNumber: string,
+    deviceName: string = "",
+    deviceRoom: string = ""
+  ): Promise<DeviceAssociationResponse> => {
+    const body: DeviceAssociationBody = {
+      macAddress: macAddress.replace(/:/g, ""),
+      deviceName,
+      deviceRoom,
+      serialNumber,
+    };
+    const response = await axiosInstance.post<DeviceAssociationResponse>(
+      "device",
+      body,
+      { headers: headers(jwtToken) }
+    );
+    return response.data;
+  };
+
+const editDevice =
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Updates a device's name and room.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device (colons optional).
+   * @param {string} deviceName - New name for the device (default: empty string).
+   * @param {string} deviceRoom - New room for the device (default: empty string).
+   * @returns {Promise<DeviceAssociationResponse>} - A promise that resolves to the update response.
+   */
+  async (
+    jwtToken: string,
+    macAddress: string,
+    deviceName: string = "",
+    deviceRoom: string = ""
+  ): Promise<DeviceAssociationResponse> => {
+    const normalizedMac = macAddress.replace(/:/g, "");
+    const body: EditDeviceAssociationBody = {
+      deviceName,
+      deviceRoom,
+    };
+    const response = await axiosInstance.put<DeviceAssociationResponse>(
+      `device/${normalizedMac}`,
+      body,
+      { headers: headers(jwtToken) }
+    );
+    return response.data;
+  };
+
 /**
  * Configures the library for API interactions.
  * Initializes API methods with a specified base URL.
@@ -207,6 +288,8 @@ const setTargetTemperature =
 const configure = (baseURL: string = API_URL) => {
   const axiosInstance = axios.create({ baseURL });
   const deviceInfoInstance = deviceInfo(axiosInstance);
+  const registerDeviceInstance = registerDevice(axiosInstance);
+  const editDeviceInstance = editDevice(axiosInstance);
   const setPowerInstance = setPower(axiosInstance);
   const setPowerOffInstance = setPowerOff(axiosInstance);
   const setPowerOnInstance = setPowerOn(axiosInstance);
@@ -217,6 +300,8 @@ const configure = (baseURL: string = API_URL) => {
   const setTargetTemperatureInstance = setTargetTemperature(axiosInstance);
   return {
     deviceInfo: deviceInfoInstance,
+    registerDevice: registerDeviceInstance,
+    editDevice: editDeviceInstance,
     setPower: setPowerInstance,
     setPowerOff: setPowerOffInstance,
     setPowerOn: setPowerOnInstance,

package/src/serial-utils.test.ts

@@ -0,0 +1,64 @@
+import { strict as assert } from "assert";
+
+import {
+  serialNumberDisplay,
+  serialNumberFromHex,
+  serialNumberToHex,
+} from "./serial-utils";
+
+describe("serial-utils", () => {
+  describe("serialNumberToHex", () => {
+    it("should convert ASCII string to hex", () => {
+      assert.equal(serialNumberToHex("EDK123"), "45444b313233");
+    });
+
+    it("should handle empty string", () => {
+      assert.equal(serialNumberToHex(""), "");
+    });
+
+    it("should convert string with non-printable chars", () => {
+      const input = "EDK\x00123";
+      const hex = serialNumberToHex(input);
+      assert.equal(hex, "45444b00313233");
+    });
+  });
+
+  describe("serialNumberFromHex", () => {
+    it("should convert hex back to ASCII string", () => {
+      assert.equal(serialNumberFromHex("45444b313233"), "EDK123");
+    });
+
+    it("should handle empty string", () => {
+      assert.equal(serialNumberFromHex(""), "");
+    });
+
+    it("should round-trip with toHex", () => {
+      const original = "EDK\x00123\x1F";
+      const hex = serialNumberToHex(original);
+      const restored = serialNumberFromHex(hex);
+      assert.equal(restored, original);
+    });
+  });
+
+  describe("serialNumberDisplay", () => {
+    it("should remove non-printable characters", () => {
+      assert.equal(serialNumberDisplay("EDK\x00123\x1F"), "EDK123");
+    });
+
+    it("should collapse whitespace", () => {
+      assert.equal(serialNumberDisplay("EDK  123"), "EDK 123");
+    });
+
+    it("should trim leading and trailing whitespace", () => {
+      assert.equal(serialNumberDisplay("  EDK123  "), "EDK123");
+    });
+
+    it("should handle empty string", () => {
+      assert.equal(serialNumberDisplay(""), "");
+    });
+
+    it("should preserve normal serial numbers", () => {
+      assert.equal(serialNumberDisplay("EDK12345678"), "EDK12345678");
+    });
+  });
+});

package/src/serial-utils.ts

@@ -0,0 +1,50 @@
+/**
+ * Converts a raw serial number string to hex-encoded format.
+ * This is useful when serial numbers contain non-printable characters.
+ *
+ * @param serial - The raw serial number string
+ * @returns Hex-encoded string representation
+ *
+ * @example
+ * serialNumberToHex("EDK123") // returns "45444b313233"
+ */
+const serialNumberToHex = (serial: string): string => {
+  return Buffer.from(serial, "utf-8").toString("hex");
+};
+
+/**
+ * Converts a hex-encoded serial number back to raw string format.
+ *
+ * @param hex - The hex-encoded serial number
+ * @returns Raw serial number string
+ *
+ * @example
+ * serialNumberFromHex("45444b313233") // returns "EDK123"
+ */
+const serialNumberFromHex = (hex: string): string => {
+  return Buffer.from(hex, "hex").toString("utf-8");
+};
+
+/**
+ * Produces a display-friendly version of a serial number by removing
+ * non-printable characters and collapsing whitespace.
+ *
+ * @param serial - The raw serial number string
+ * @returns Display-friendly serial number
+ *
+ * @example
+ * serialNumberDisplay("EDK\x00123\x1F") // returns "EDK123"
+ */
+const serialNumberDisplay = (serial: string): string => {
+  // Remove non-printable characters (ASCII 0-31, 127)
+  // Keep printable ASCII (32-126) and extended characters
+  return (
+    serial
+      // eslint-disable-next-line no-control-regex
+      .replace(/[\x00-\x1F\x7F]/g, "")
+      .replace(/\s+/g, " ")
+      .trim()
+  );
+};
+
+export { serialNumberDisplay, serialNumberFromHex, serialNumberToHex };