edilkamin 1.6.1 → 1.6.2

package/dist/esm/library.test.js

@@ -9,9 +9,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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) => {
+    const json = JSON.stringify(data);
+    const compressed = pako.gzip(json);
+    return {
+        type: "Buffer",
+        data: Array.from(compressed),
+    };
+};
 describe("library", () => {
     let axiosStub;
     const expectedToken = "mockJwtToken";
@@ -26,7 +38,7 @@ describe("library", () => {
         sinon.restore();
     });
     describe("signIn", () => {
-        it("should sign in and return the JWT token", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("should sign in and return the ID token by default", () => __awaiter(void 0, void 0, void 0, function* () {
             const expectedUsername = "testuser";
             const expectedPassword = "testpassword";
             const signIn = sinon.stub().resolves({ isSignedIn: true });
@@ -34,6 +46,7 @@ describe("library", () => {
             const fetchAuthSession = sinon.stub().resolves({
                 tokens: {
                     idToken: { toString: () => expectedToken },
+                    accessToken: { toString: () => "accessToken" },
                 },
             });
             const authStub = {
@@ -50,6 +63,28 @@ describe("library", () => {
             ]);
             assert.equal(token, expectedToken);
         }));
+        it("should sign in and return the access token in legacy mode", () => __awaiter(void 0, void 0, void 0, function* () {
+            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);
+            const token = yield authService.signIn(expectedUsername, expectedPassword, true // legacy mode
+            );
+            assert.equal(token, expectedToken);
+        }));
         it("should throw an error if sign-in fails", () => __awaiter(void 0, void 0, void 0, function* () {
             const expectedUsername = "testuser";
             const expectedPassword = "testpassword";
@@ -76,6 +111,8 @@ describe("library", () => {
     describe("configure", () => {
         const expectedApi = [
             "deviceInfo",
+            "registerDevice",
+            "editDevice",
             "setPower",
             "setPowerOff",
             "setPowerOn",
@@ -242,4 +279,226 @@ describe("library", () => {
             }));
         });
     });
+    describe("registerDevice", () => {
+        it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
+            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 = yield 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", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                post: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                put: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield 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", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                post: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                put: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield 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", () => __awaiter(void 0, void 0, void 0, function* () {
+            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 = yield 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", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                put: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                post: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield 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", () => __awaiter(void 0, void 0, void 0, function* () {
+            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 = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.status, statusData);
+        }));
+        it("should decompress Buffer-encoded nvm field", () => __awaiter(void 0, void 0, void 0, function* () {
+            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 = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.nvm, nvmData);
+        }));
+        it("should handle fully compressed response (status and nvm)", () => __awaiter(void 0, void 0, void 0, function* () {
+            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 = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.status, statusData);
+            assert.deepEqual(result.nvm, nvmData);
+        }));
+        it("should work with getPower on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            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 = yield api.getPower(expectedToken, "mockMacAddress");
+            assert.equal(result, true);
+        }));
+        it("should work with getEnvironmentTemperature on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            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 = yield api.getEnvironmentTemperature(expectedToken, "mockMacAddress");
+            assert.equal(result, 19);
+        }));
+        it("should work with getTargetTemperature on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            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 = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
+            assert.equal(result, 22);
+        }));
+    });
 });

package/dist/esm/serial-utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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"
+ */
+declare const serialNumberToHex: (serial: string) => string;
+/**
+ * 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"
+ */
+declare const serialNumberFromHex: (hex: string) => string;
+/**
+ * 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"
+ */
+declare const serialNumberDisplay: (serial: string) => string;
+export { serialNumberDisplay, serialNumberFromHex, serialNumberToHex };

package/dist/esm/serial-utils.js

@@ -0,0 +1,45 @@
+/**
+ * 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) => {
+    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) => {
+    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) => {
+    // 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 };

package/dist/esm/serial-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/serial-utils.test.js

@@ -0,0 +1,48 @@
+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/dist/esm/types.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Represents a Node.js Buffer object serialized to JSON.
+ * This format is used by the Edilkamin API for gzip-compressed fields.
+ */
+interface BufferEncodedType {
+    type: "Buffer";
+    data: number[];
+}
 interface CommandsType {
     power: boolean;
 }
@@ -22,4 +30,44 @@ interface DeviceInfoType {
         user_parameters: UserParametersType;
     };
 }
-export type { CommandsType, DeviceInfoType, StatusType, TemperaturesType, UserParametersType, };
+/**
+ * Raw device info response that may contain Buffer-encoded compressed fields.
+ * Used internally before processing; external callers receive DeviceInfoType.
+ */
+interface DeviceInfoRawType {
+    status: StatusType | BufferEncodedType;
+    nvm: {
+        user_parameters: UserParametersType;
+    } | BufferEncodedType;
+    component_info?: BufferEncodedType | Record<string, unknown>;
+}
+/**
+ * Request body for registering a device with a user account.
+ * All fields are required by the API.
+ */
+interface DeviceAssociationBody {
+    macAddress: string;
+    deviceName: string;
+    deviceRoom: string;
+    serialNumber: string;
+}
+/**
+ * Request body for editing a device's name and room.
+ * MAC address is specified in the URL path, not the body.
+ * Serial number cannot be changed after registration.
+ */
+interface EditDeviceAssociationBody {
+    deviceName: string;
+    deviceRoom: string;
+}
+/**
+ * Response from device registration endpoint.
+ * Structure based on Android app behavior - may need adjustment after testing.
+ */
+interface DeviceAssociationResponse {
+    macAddress: string;
+    deviceName: string;
+    deviceRoom: string;
+    serialNumber: string;
+}
+export type { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, EditDeviceAssociationBody, StatusType, TemperaturesType, UserParametersType, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edilkamin",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -42,13 +42,15 @@
   },
   "dependencies": {
     "aws-amplify": "^6.10.0",
-    "axios": "^1.13.2"
+    "axios": "^1.13.2",
+    "pako": "^2.1.0"
   },
   "devDependencies": {
     "@aws-amplify/cli": "^7.6.21",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.16.0",
     "@types/mocha": "^10.0.10",
+    "@types/pako": "^2.0.4",
     "@types/sinon": "^17.0.3",
     "@typescript-eslint/eslint-plugin": "^8.17.0",
     "@typescript-eslint/parser": "^8.17.0",