edilkamin 1.7.2 → 1.7.3

package/dist/esm/library.test.js

@@ -8,7 +8,6 @@ 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";
@@ -24,15 +23,20 @@ const createGzippedBuffer = (data) => {
         data: Array.from(compressed),
     };
 };
+/**
+ * Helper to create a mock Response object for fetch.
+ */
+const mockResponse = (data, status = 200) => ({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status >= 200 && status < 300 ? "OK" : "Error",
+    json: () => Promise.resolve(data),
+});
 describe("library", () => {
-    let axiosStub;
+    let fetchStub;
     const expectedToken = "mockJwtToken";
     beforeEach(() => {
-        axiosStub = sinon.stub(axios, "create").returns({
-            get: sinon.stub(),
-            put: sinon.stub(),
-            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-        });
+        fetchStub = sinon.stub(globalThis, "fetch");
     });
     afterEach(() => {
         sinon.restore();
@@ -182,29 +186,25 @@ describe("library", () => {
             "getTargetTemperature",
             "setTargetTemperature",
         ];
-        it("should create API methods with the correct baseURL", () => {
-            const baseURL = "https://example.com/api";
+        it("should create API methods with the correct baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
+            const baseURL = "https://example.com/api/";
+            fetchStub.resolves(mockResponse({ test: "data" }));
             const api = configure(baseURL);
-            assert.deepEqual(axiosStub.args, [
-                [
-                    {
-                        baseURL,
-                    },
-                ],
-            ]);
             assert.deepEqual(Object.keys(api), expectedApi);
-        });
-        it("should create API methods with the default baseURL", () => {
+            // Verify baseURL is used when making a request
+            yield api.deviceInfo(expectedToken, "mockMac");
+            assert.ok(fetchStub.calledOnce);
+            assert.ok(fetchStub.firstCall.args[0].startsWith(baseURL));
+        }));
+        it("should create API methods with the default baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse({ test: "data" }));
             const api = configure();
-            assert.deepEqual(axiosStub.args, [
-                [
-                    {
-                        baseURL: API_URL,
-                    },
-                ],
-            ]);
             assert.deepEqual(Object.keys(api), expectedApi);
-        });
+            // Verify default baseURL is used when making a request
+            yield api.deviceInfo(expectedToken, "mockMac");
+            assert.ok(fetchStub.calledOnce);
+            assert.ok(fetchStub.firstCall.args[0].startsWith(API_URL));
+        }));
     });
     describe("API Methods", () => {
         const mockDeviceInfo = {
@@ -222,19 +222,16 @@ describe("library", () => {
                 },
             },
         };
-        it("should call axios for deviceInfo", () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockAxios = {
-                get: sinon.stub().resolves({ data: mockDeviceInfo }),
-            };
-            axiosStub.returns(mockAxios);
-            const api = configure("https://example.com/api");
+        it("should call fetch for deviceInfo", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfo));
+            const api = configure("https://example.com/api/");
             const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
-            assert.deepEqual(mockAxios.get.args, [
-                [
-                    "device/mockMacAddress/info",
-                    { headers: { Authorization: `Bearer ${expectedToken}` } },
-                ],
-            ]);
+            assert.ok(fetchStub.calledOnce);
+            assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/mockMacAddress/info");
+            assert.deepEqual(fetchStub.firstCall.args[1], {
+                method: "GET",
+                headers: { Authorization: `Bearer ${expectedToken}` },
+            });
             assert.deepEqual(result, mockDeviceInfo);
         }));
         // Tests for setPowerOn and setPowerOff
@@ -250,28 +247,25 @@ describe("library", () => {
                 expectedValue: 0,
             },
         ].forEach(({ method, call, expectedValue }) => {
-            it(`should call axios for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
-                const mockAxios = {
-                    put: sinon.stub().resolves({ status: 200 }),
-                };
-                axiosStub.returns(mockAxios);
-                const api = configure("https://example.com/api");
+            it(`should call fetch for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = configure("https://example.com/api/");
                 // Invoke the method using the mapped call function
-                const result = yield call(api);
-                assert.deepEqual(mockAxios.put.args, [
-                    [
-                        "mqtt/command",
-                        {
-                            mac_address: "mockMacAddress",
-                            name: "power",
-                            value: expectedValue,
-                        },
-                        {
-                            headers: { Authorization: "Bearer mockToken" },
-                        },
-                    ],
-                ]);
-                assert.equal(result.status, 200);
+                yield call(api);
+                assert.ok(fetchStub.calledOnce);
+                assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/mqtt/command");
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: "Bearer mockToken",
+                    },
+                    body: JSON.stringify({
+                        mac_address: "mockMacAddress",
+                        name: "power",
+                        value: expectedValue,
+                    }),
+                });
             }));
         });
         const getterTests = [
@@ -292,19 +286,16 @@ describe("library", () => {
             },
         ];
         getterTests.forEach(({ method, call, expectedResult }) => {
-            it(`should call axios and return the correct value for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
-                const mockAxios = {
-                    get: sinon.stub().resolves({ data: mockDeviceInfo }),
-                };
-                axiosStub.returns(mockAxios);
-                const api = configure("https://example.com/api");
+            it(`should call fetch and return the correct value for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse(mockDeviceInfo));
+                const api = configure("https://example.com/api/");
                 const result = yield call(api, expectedToken, "mockMacAddress");
-                assert.deepEqual(mockAxios.get.args, [
-                    [
-                        "device/mockMacAddress/info",
-                        { headers: { Authorization: `Bearer ${expectedToken}` } },
-                    ],
-                ]);
+                assert.ok(fetchStub.calledOnce);
+                assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/mockMacAddress/info");
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "GET",
+                    headers: { Authorization: `Bearer ${expectedToken}` },
+                });
                 assert.equal(result, expectedResult);
             }));
         });
@@ -320,119 +311,100 @@ describe("library", () => {
             },
         ];
         setterTests.forEach(({ method, call, payload }) => {
-            it(`should call axios and send the correct payload for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
-                const mockAxios = {
-                    put: sinon.stub().resolves({ status: 200 }),
-                };
-                axiosStub.returns(mockAxios);
-                const api = configure("https://example.com/api");
-                const result = yield call(api, expectedToken, "mockMacAddress", payload.value);
-                assert.deepEqual(mockAxios.put.args, [
-                    [
-                        "mqtt/command",
-                        Object.assign({ mac_address: "mockMacAddress" }, payload),
-                        {
-                            headers: { Authorization: `Bearer ${expectedToken}` },
-                        },
-                    ],
-                ]);
-                assert.equal(result.status, 200);
+            it(`should call fetch and send the correct payload for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = configure("https://example.com/api/");
+                yield call(api, expectedToken, "mockMacAddress", payload.value);
+                assert.ok(fetchStub.calledOnce);
+                assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/mqtt/command");
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, payload)),
+                });
             }));
         });
     });
     describe("registerDevice", () => {
         it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            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);
+            assert.ok(fetchStub.calledOnce);
+            assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/device");
+            assert.deepEqual(fetchStub.firstCall.args[1], {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${expectedToken}`,
+                },
+                body: JSON.stringify({
+                    macAddress: "AABBCCDDEEFF",
+                    deviceName: "Test Stove",
+                    deviceRoom: "Living Room",
+                    serialNumber: "EDK123",
+                }),
+            });
+            assert.deepEqual(result, mockResponseData);
         }));
         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");
+            fetchStub.resolves(mockResponse({}));
+            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");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert.equal(body.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");
+            fetchStub.resolves(mockResponse({}));
+            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, "");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert.equal(body.deviceName, "");
+            assert.equal(body.deviceRoom, "");
         }));
     });
     describe("editDevice", () => {
         it("should call PUT /device/{mac} with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            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);
+            assert.ok(fetchStub.calledOnce);
+            assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/AABBCCDDEEFF");
+            assert.deepEqual(fetchStub.firstCall.args[1], {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${expectedToken}`,
+                },
+                body: JSON.stringify({
+                    deviceName: "Updated Name",
+                    deviceRoom: "Basement",
+                }),
+            });
+            assert.deepEqual(result, mockResponseData);
         }));
         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");
+            fetchStub.resolves(mockResponse({}));
+            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, "");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert.equal(body.deviceName, "");
+            assert.equal(body.deviceRoom, "");
         }));
     });
     describe("deviceInfo with compressed responses", () => {
@@ -441,7 +413,7 @@ describe("library", () => {
                 commands: { power: true },
                 temperatures: { enviroment: 19, board: 25 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 status: createGzippedBuffer(statusData),
                 nvm: {
                     user_parameters: {
@@ -449,11 +421,8 @@ describe("library", () => {
                     },
                 },
             };
-            const mockAxios = {
-                get: sinon.stub().resolves({ data: mockResponse }),
-            };
-            axiosStub.returns(mockAxios);
-            const api = configure("https://example.com/api");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
             assert.deepEqual(result.status, statusData);
         }));
@@ -467,18 +436,15 @@ describe("library", () => {
                     is_sound_active: true,
                 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
             assert.deepEqual(result.nvm, nvmData);
         }));
@@ -496,15 +462,12 @@ describe("library", () => {
                     is_sound_active: false,
                 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 status: createGzippedBuffer(statusData),
                 nvm: createGzippedBuffer(nvmData),
             };
-            const mockAxios = {
-                get: sinon.stub().resolves({ data: mockResponse }),
-            };
-            axiosStub.returns(mockAxios);
-            const api = configure("https://example.com/api");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
             assert.deepEqual(result.status, statusData);
             assert.deepEqual(result.nvm, nvmData);
@@ -514,15 +477,12 @@ describe("library", () => {
                 commands: { power: true },
                 temperatures: { enviroment: 19 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.getPower(expectedToken, "mockMacAddress");
             assert.equal(result, true);
         }));
@@ -531,15 +491,12 @@ describe("library", () => {
                 commands: { power: true },
                 temperatures: { enviroment: 19, board: 25 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.getEnvironmentTemperature(expectedToken, "mockMacAddress");
             assert.equal(result, 19);
         }));
@@ -549,17 +506,37 @@ describe("library", () => {
                     enviroment_1_temperature: 22,
                 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
             assert.equal(result, 22);
         }));
     });
+    describe("Error Handling", () => {
+        const errorTests = [
+            { status: 400, statusText: "Bad Request" },
+            { status: 401, statusText: "Unauthorized" },
+            { status: 404, statusText: "Not Found" },
+            { status: 500, statusText: "Internal Server Error" },
+        ];
+        errorTests.forEach(({ status, statusText }) => {
+            it(`should throw error when fetch returns ${status}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const errorResponse = {
+                    ok: false,
+                    status,
+                    statusText,
+                    json: () => Promise.resolve({ error: statusText }),
+                };
+                fetchStub.resolves(errorResponse);
+                const api = configure("https://example.com/api/");
+                yield assert.rejects(() => __awaiter(void 0, void 0, void 0, function* () { return api.deviceInfo(expectedToken, "mockMac"); }), {
+                    message: `HTTP ${status}: ${statusText}`,
+                });
+            }));
+        });
+    });
 });

package/package.json

@@ -1,10 +1,22 @@
 {
   "name": "edilkamin",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "description": "",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
   "scripts": {
     "cli": "ts-node src/cli.ts",
     "cli:debug": "node --inspect --require ts-node/register/transpile-only src/cli.ts",
@@ -42,7 +54,6 @@
   },
   "dependencies": {
     "aws-amplify": "^6.10.0",
-    "axios": "^1.13.2",
     "pako": "^2.1.0"
   },
   "devDependencies": {
@@ -54,6 +65,7 @@
     "@types/sinon": "^17.0.3",
     "@typescript-eslint/eslint-plugin": "^8.17.0",
     "@typescript-eslint/parser": "^8.17.0",
+    "esbuild": "^0.27.1",
     "eslint": "^9.16.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.2.1",

package/src/browser-bundle.test.ts

@@ -0,0 +1,21 @@
+import { strict as assert } from "assert";
+import * as esbuild from "esbuild";
+
+describe("browser-bundle", () => {
+  it("should bundle for browser without Node.js built-ins", async () => {
+    // This test verifies that the library can be bundled for browser environments
+    // without requiring Node.js built-in modules (fs, os, path).
+    // If this test fails, it means Node.js-only code has leaked into the main exports.
+    const result = await esbuild.build({
+      entryPoints: ["dist/esm/index.js"],
+      platform: "browser",
+      bundle: true,
+      write: false,
+      // External dependencies that are expected (real deps + assert which is used for validation)
+      external: ["aws-amplify", "aws-amplify/*", "pako", "assert"],
+      logLevel: "silent",
+    });
+    // If we get here without error, the bundle succeeded
+    assert.ok(result.outputFiles.length > 0, "Bundle should produce output");
+  });
+});

package/src/configureAmplify.test.ts

@@ -0,0 +1,47 @@
+import { strict as assert } from "assert";
+import sinon from "sinon";
+
+import { configureAmplify } from "../src/library";
+
+/**
+ * This test file specifically tests the configureAmplify function with custom storage.
+ * It tests line 61 in library.ts:
+ * cognitoUserPoolsTokenProvider.setKeyValueStorage(storage)
+ *
+ * IMPORTANT: This file is named to run BEFORE library.test.ts (alphabetically)
+ * to ensure amplifyConfigured is still false when these tests run.
+ */
+
+describe("configureAmplify", () => {
+  it("should configure Amplify with custom storage", () => {
+    const mockStorage = {
+      setItem: sinon.stub().resolves(),
+      getItem: sinon.stub().resolves(null),
+      removeItem: sinon.stub().resolves(),
+      clear: sinon.stub().resolves(),
+    };
+
+    // Call configureAmplify with custom storage
+    // This is the first call in the test suite, so amplifyConfigured is false
+    // This should trigger line 61 in library.ts
+    configureAmplify(mockStorage);
+
+    // The test passes if no error is thrown
+    // Coverage confirms line 61 is executed
+    assert.ok(true, "configureAmplify with storage completed without error");
+  });
+
+  it("should only configure Amplify once (idempotent)", () => {
+    // Call configureAmplify multiple times without storage
+    configureAmplify();
+    configureAmplify();
+    configureAmplify();
+
+    // Should not throw or have any side effects
+    // The function returns early if already configured (line 58)
+    assert.ok(
+      true,
+      "Multiple calls to configureAmplify completed without error",
+    );
+  });
+});

package/src/index.ts

@@ -8,7 +8,6 @@ export {
   serialNumberFromHex,
   serialNumberToHex,
 } from "./serial-utils";
-export { clearSession } from "./token-storage";
 export {
   BufferEncodedType,
   CommandsType,