edilkamin 1.6.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();
@@ -81,8 +85,7 @@ describe("library", () => {
             };
             // eslint-disable-next-line  @typescript-eslint/no-explicit-any
             const authService = createAuthService(authStub);
-            const token = yield authService.signIn(expectedUsername, expectedPassword, true // legacy mode
-            );
+            const token = yield authService.signIn(expectedUsername, expectedPassword, true);
             assert.equal(token, expectedToken);
         }));
         it("should throw an error if sign-in fails", () => __awaiter(void 0, void 0, void 0, function* () {
@@ -108,6 +111,68 @@ describe("library", () => {
             });
         }));
     });
+    describe("getSession", () => {
+        it("should return idToken by default", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon.stub().resolves({ isSignedIn: true }),
+                signOut: sinon.stub().resolves(),
+                fetchAuthSession: sinon.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = createAuthService(mockAuth);
+            yield signIn("user", "pass");
+            const token = yield getSession();
+            assert.equal(token, "mock-id-token");
+        }));
+        it("should return accessToken when legacy=true", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon.stub().resolves({ isSignedIn: true }),
+                signOut: sinon.stub().resolves(),
+                fetchAuthSession: sinon.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = createAuthService(mockAuth);
+            yield signIn("user", "pass");
+            const token = yield getSession(false, true);
+            assert.equal(token, "mock-access-token");
+        }));
+        it("should throw error when no session exists", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon.stub().resolves({ isSignedIn: true }),
+                signOut: sinon.stub().resolves(),
+                fetchAuthSession: sinon.stub().resolves({ tokens: null }),
+            };
+            const { getSession } = createAuthService(mockAuth);
+            yield assert.rejects(() => __awaiter(void 0, void 0, void 0, function* () { return getSession(); }), {
+                name: "AssertionError",
+                message: "No session found - please sign in first",
+            });
+        }));
+        it("should pass forceRefresh to fetchAuthSession", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon.stub().resolves({ isSignedIn: true }),
+                signOut: sinon.stub().resolves(),
+                fetchAuthSession: sinon.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = createAuthService(mockAuth);
+            yield signIn("user", "pass");
+            yield getSession(true);
+            assert.ok(mockAuth.fetchAuthSession.calledWith({ forceRefresh: true }));
+        }));
+    });
     describe("configure", () => {
         const expectedApi = [
             "deviceInfo",
@@ -121,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 = {
@@ -161,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
@@ -189,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 = [
@@ -231,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);
             }));
         });
@@ -259,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", () => {
@@ -380,7 +413,7 @@ describe("library", () => {
                 commands: { power: true },
                 temperatures: { enviroment: 19, board: 25 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 status: createGzippedBuffer(statusData),
                 nvm: {
                     user_parameters: {
@@ -388,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);
         }));
@@ -406,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);
         }));
@@ -435,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);
@@ -453,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);
         }));
@@ -470,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);
         }));
@@ -488,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/dist/esm/token-storage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Custom storage adapter for AWS Amplify that persists to file system.
+ * Used for CLI to maintain sessions between invocations.
+ */
+export declare const createFileStorage: () => {
+    setItem: (key: string, value: string) => Promise<void>;
+    getItem: (key: string) => Promise<string | null>;
+    removeItem: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+};
+/**
+ * Clears all stored session data.
+ */
+export declare const clearSession: () => Promise<void>;