edilkamin 1.4.0 → 1.4.1

package/.github/workflows/publish.yml

@@ -2,8 +2,7 @@ name: Publish
 
 on:
   push:
-    tags:
-      - "*"
+  pull_request:
 
 jobs:
   build:
@@ -17,6 +16,8 @@ jobs:
           registry-url: "https://registry.npmjs.org"
       - run: yarn install
       - run: yarn build
+      - run: npm publish --dry-run
       - run: npm publish
+        if: startsWith(github.ref, 'refs/tags/')
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}

package/.github/workflows/tests.yml

@@ -19,4 +19,11 @@ jobs:
       - run: yarn install
       - run: yarn lint
       - run: yarn build
-      - run: npm publish --dry-run
+      - run: yarn test
+      - uses: codecov/codecov-action@v5
+        with:
+          files: ./coverage/lcov.info
+          token: ${{ secrets.CODECOV_TOKEN }}
+          fail_ci_if_error: true
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

package/README.md

@@ -2,6 +2,7 @@
 
 [![Tests](https://github.com/AndreMiras/edilkamin.js/workflows/Tests/badge.svg)](https://github.com/AndreMiras/edilkamin.js/actions/workflows/tests.yml)
 [![CLI Tests](https://github.com/AndreMiras/edilkamin.js/actions/workflows/cli-tests.yml/badge.svg)](https://github.com/AndreMiras/edilkamin.js/actions/workflows/cli-tests.yml)
+[![codecov](https://codecov.io/gh/AndreMiras/edilkamin.js/graph/badge.svg?token=YG3LKXNZWU)](https://app.codecov.io/gh/AndreMiras/edilkamin.js/tree/main)
 [![Documentation](https://github.com/AndreMiras/edilkamin.js/workflows/Documentation/badge.svg)](https://github.com/AndreMiras/edilkamin.js/actions/workflows/documentation.yml)
 [![npm version](https://badge.fury.io/js/edilkamin.svg)](https://badge.fury.io/js/edilkamin)
 

package/dist/esm/cli.js

@@ -8,10 +8,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { signIn, configure } from "./library";
 import { Command } from "commander";
 import readline from "readline";
 import { version } from "../package.json";
+import { configure, signIn } from "./library";
 const promptPassword = () => {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -61,10 +61,11 @@ const createProgram = () => {
         .description("Retrieve device info for a specific MAC address")
         .requiredOption("-m, --mac <macAddress>", "MAC address of the device")).action((options) => __awaiter(void 0, void 0, void 0, function* () {
         const { username, password, mac } = options;
+        const normalizedMac = mac.replace(/:/g, "");
         const pwd = password || (yield promptPassword());
         const jwtToken = yield signIn(username, pwd);
         const api = configure(); // Use the default API configuration
-        const deviceInfo = yield api.deviceInfo(jwtToken, mac);
+        const deviceInfo = yield api.deviceInfo(jwtToken, normalizedMac);
         console.log("Device Info:", deviceInfo.data);
     }));
     return program;

package/dist/esm/index.d.ts

@@ -1,4 +1,4 @@
 export { API_URL } from "./constants";
+export { configure, signIn } from "./library";
 export { CommandsType, DeviceInfoType, StatusType, TemperaturesType, UserParametersType, } from "./types";
-export { signIn, configure } from "./library";
 export declare const deviceInfo: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<import("./types").DeviceInfoType, any>>, setPower: (jwtToken: string, macAddress: string, value: number) => Promise<import("axios").AxiosResponse<any, any>>, setPowerOff: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any>>, setPowerOn: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any>>;

package/dist/esm/index.js

@@ -1,4 +1,4 @@
 import { configure } from "./library";
 export { API_URL } from "./constants";
-export { signIn, configure } from "./library";
+export { configure, signIn } from "./library";
 export const { deviceInfo, setPower, setPowerOff, setPowerOn } = configure();

package/dist/esm/library.d.ts

@@ -1,7 +1,21 @@
+import * as amplifyAuth from "aws-amplify/auth";
 import { DeviceInfoType } from "./types";
 /**
- * Sign in to return the JWT token.
+ * Generates headers with a JWT token for authenticated requests.
+ * @param {string} jwtToken - The JWT token for authorization.
+ * @returns {object} - The headers object with the Authorization field.
  */
+declare const headers: (jwtToken: string) => {
+    Authorization: string;
+};
+/**
+ * Creates an authentication service with sign-in functionality.
+ * @param {typeof amplifyAuth} auth - The authentication module to use.
+ * @returns {object} - An object containing authentication-related methods.
+ */
+declare const createAuthService: (auth: typeof amplifyAuth) => {
+    signIn: (username: string, password: string) => Promise<string>;
+};
 declare const signIn: (username: string, password: string) => Promise<string>;
 declare const configure: (baseURL?: string) => {
     deviceInfo: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<DeviceInfoType, any>>;
@@ -9,4 +23,4 @@ declare const configure: (baseURL?: string) => {
     setPowerOff: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any>>;
     setPowerOn: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any>>;
 };
-export { signIn, configure };
+export { configure, createAuthService, headers, signIn };

package/dist/esm/library.js

@@ -17,28 +17,54 @@ const amplifyconfiguration = {
     aws_user_pools_id: "eu-central-1_BYmQ2VBlo",
     aws_user_pools_web_client_id: "7sc1qltkqobo3ddqsk4542dg2h",
 };
-Amplify.configure(amplifyconfiguration);
+/**
+ * Generates headers with a JWT token for authenticated requests.
+ * @param {string} jwtToken - The JWT token for authorization.
+ * @returns {object} - The headers object with the Authorization field.
+ */
 const headers = (jwtToken) => ({ Authorization: `Bearer ${jwtToken}` });
 /**
- * Sign in to return the JWT token.
+ * Configures Amplify if not already configured.
+ * Ensures the configuration is only applied once.
  */
-const signIn = (username, password) => __awaiter(void 0, void 0, void 0, function* () {
-    // in case the user is already signed in, refs:
-    // https://github.com/aws-amplify/amplify-js/issues/13813
-    yield amplifyAuth.signOut();
-    const { isSignedIn } = yield amplifyAuth.signIn({
-        username,
-        password,
+const configureAmplify = () => {
+    const currentConfig = Amplify.getConfig();
+    if (Object.keys(currentConfig).length !== 0)
+        return;
+    Amplify.configure(amplifyconfiguration);
+};
+/**
+ * Creates an authentication service with sign-in functionality.
+ * @param {typeof amplifyAuth} auth - The authentication module to use.
+ * @returns {object} - An object containing authentication-related methods.
+ */
+const createAuthService = (auth) => {
+    /**
+     * Signs in a user with the provided credentials.
+     * @param {string} username - The username of the user.
+     * @param {string} password - The password of the user.
+     * @returns {Promise<string>} - The JWT token of the signed-in user.
+     * @throws {Error} - If sign-in fails or no tokens are retrieved.
+     */
+    const signIn = (username, password) => __awaiter(void 0, void 0, void 0, function* () {
+        configureAmplify();
+        yield auth.signOut(); // Ensure the user is signed out first
+        const { isSignedIn } = yield auth.signIn({ username, password });
+        assert.ok(isSignedIn, "Sign-in failed");
+        const { tokens } = yield auth.fetchAuthSession();
+        assert.ok(tokens, "No tokens found");
+        return tokens.accessToken.toString();
     });
-    assert.ok(isSignedIn);
-    const { tokens } = yield amplifyAuth.fetchAuthSession();
-    assert.ok(tokens);
-    return tokens.accessToken.toString();
-});
+    return { signIn };
+};
+// Create the default auth service using amplifyAuth
+const { signIn } = createAuthService(amplifyAuth);
 const deviceInfo = (axiosInstance) => (jwtToken, macAddress) => axiosInstance.get(`device/${macAddress}/info`, {
     headers: headers(jwtToken),
 });
-const mqttCommand = (axiosInstance) => (jwtToken, macAddress, payload) => axiosInstance.put("mqtt/command", Object.assign({ mac_address: macAddress }, payload), { headers: headers(jwtToken) });
+const mqttCommand = (axiosInstance) => 
+// eslint-disable-next-line  @typescript-eslint/no-explicit-any
+(jwtToken, macAddress, payload) => axiosInstance.put("mqtt/command", Object.assign({ mac_address: macAddress }, payload), { headers: headers(jwtToken) });
 const setPower = (axiosInstance) => (jwtToken, macAddress, value) => mqttCommand(axiosInstance)(jwtToken, macAddress, { name: "power", value });
 const setPowerOn = (axiosInstance) => (jwtToken, macAddress) => setPower(axiosInstance)(jwtToken, macAddress, 1);
 const setPowerOff = (axiosInstance) => (jwtToken, macAddress) => setPower(axiosInstance)(jwtToken, macAddress, 0);
@@ -55,4 +81,4 @@ const configure = (baseURL = API_URL) => {
         setPowerOn: setPowerOnInstance,
     };
 };
-export { signIn, configure };
+export { configure, createAuthService, headers, signIn };

package/dist/esm/library.test.js

@@ -8,26 +8,99 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { strict as assert } from "assert";
-import sinon from "sinon";
 import axios from "axios";
-import { configure } from "../src/library";
+import sinon from "sinon";
+import { configure, createAuthService } from "../src/library";
+import { API_URL } from "./constants";
 describe("library", () => {
     let axiosStub;
     beforeEach(() => {
         axiosStub = sinon.stub(axios, "create").returns({
             get: sinon.stub(),
             put: sinon.stub(),
+            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
         });
     });
     afterEach(() => {
         sinon.restore();
     });
+    describe("signIn", () => {
+        it("should sign in and return the JWT token", () => __awaiter(void 0, void 0, void 0, function* () {
+            const expectedUsername = "testuser";
+            const expectedPassword = "testpassword";
+            const expectedToken = "mockJwtToken";
+            const signIn = sinon.stub().resolves({ isSignedIn: true });
+            const signOut = sinon.stub();
+            const fetchAuthSession = sinon.stub().resolves({
+                tokens: {
+                    accessToken: { toString: () => expectedToken },
+                },
+            });
+            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);
+            assert.deepEqual(authStub.signOut.args, [[]]);
+            assert.deepEqual(signIn.args, [
+                [{ username: expectedUsername, password: expectedPassword }],
+            ]);
+            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";
+            const expectedToken = "mockJwtToken";
+            const signIn = sinon.stub().resolves({ isSignedIn: false });
+            const signOut = sinon.stub();
+            const fetchAuthSession = sinon.stub().resolves({
+                tokens: {
+                    accessToken: { toString: () => expectedToken },
+                },
+            });
+            const authStub = {
+                signIn,
+                signOut,
+                fetchAuthSession,
+            };
+            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+            const authService = createAuthService(authStub);
+            yield assert.rejects(() => __awaiter(void 0, void 0, void 0, function* () { return authService.signIn(expectedUsername, expectedPassword); }), {
+                name: "AssertionError",
+                message: "Sign-in failed",
+            });
+        }));
+    });
     describe("configure", () => {
         it("should create API methods with the correct baseURL", () => {
             const baseURL = "https://example.com/api";
             const api = configure(baseURL);
-            assert.ok(axiosStub.calledOnce);
-            assert.deepEqual(axiosStub.firstCall.args[0], { baseURL });
+            assert.deepEqual(axiosStub.args, [
+                [
+                    {
+                        baseURL,
+                    },
+                ],
+            ]);
+            assert.deepEqual(Object.keys(api), [
+                "deviceInfo",
+                "setPower",
+                "setPowerOff",
+                "setPowerOn",
+            ]);
+        });
+        it("should create API methods with the default baseURL", () => {
+            const api = configure();
+            assert.deepEqual(axiosStub.args, [
+                [
+                    {
+                        baseURL: API_URL,
+                    },
+                ],
+            ]);
             assert.deepEqual(Object.keys(api), [
                 "deviceInfo",
                 "setPower",
@@ -38,39 +111,58 @@ describe("library", () => {
     });
     describe("API Methods", () => {
         it("should call axios for deviceInfo", () => __awaiter(void 0, void 0, void 0, function* () {
+            const expectedDevice = { id: "123", name: "Mock Device" };
+            const expectedToken = "mockToken";
             const mockAxios = {
-                get: sinon
-                    .stub()
-                    .resolves({ data: { id: "123", name: "Mock Device" } }),
+                get: sinon.stub().resolves({ data: expectedDevice }),
             };
             axiosStub.returns(mockAxios);
             const api = configure("https://example.com/api");
-            const result = yield api.deviceInfo("mockToken", "mockMacAddress");
-            assert.ok(mockAxios.get.calledOnce);
-            assert.equal(mockAxios.get.firstCall.args[0], "device/mockMacAddress/info");
-            assert.deepEqual(mockAxios.get.firstCall.args[1], {
-                headers: { Authorization: "Bearer mockToken" },
-            });
-            assert.deepEqual(result.data, { id: "123", name: "Mock Device" });
-        }));
-        it("should call axios for setPowerOn", () => __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 api.setPowerOn("mockToken", "mockMacAddress");
-            assert.ok(mockAxios.put.calledOnce);
-            assert.equal(mockAxios.put.firstCall.args[0], "mqtt/command");
-            assert.deepEqual(mockAxios.put.firstCall.args[1], {
-                mac_address: "mockMacAddress",
-                name: "power",
-                value: 1,
-            });
-            assert.deepEqual(mockAxios.put.firstCall.args[2], {
-                headers: { Authorization: "Bearer mockToken" },
-            });
-            assert.equal(result.status, 200);
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(mockAxios.get.args, [
+                [
+                    "device/mockMacAddress/info",
+                    { headers: { Authorization: `Bearer ${expectedToken}` } },
+                ],
+            ]);
+            assert.deepEqual(result.data, expectedDevice);
         }));
+        // Tests for setPowerOn and setPowerOff
+        [
+            {
+                method: "setPowerOn",
+                call: (api) => api.setPowerOn("mockToken", "mockMacAddress"),
+                expectedValue: 1,
+            },
+            {
+                method: "setPowerOff",
+                call: (api) => api.setPowerOff("mockToken", "mockMacAddress"),
+                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");
+                // 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);
+            }));
+        });
     });
 });

package/eslint.config.mjs

@@ -0,0 +1,35 @@
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import simpleImportSort from "eslint-plugin-simple-import-sort";
+import globals from "globals";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+});
+
+export default [
+  ...compat.extends(
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended"
+  ),
+  {
+    plugins: {
+      "@typescript-eslint": typescriptEslint,
+      "simple-import-sort": simpleImportSort,
+    },
+    rules: {
+      // Sorting imports and exports
+      "simple-import-sort/imports": "error",
+      "simple-import-sort/exports": "error",
+    },
+  },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edilkamin",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -8,10 +8,14 @@
   "scripts": {
     "cli": "ts-node src/cli.ts",
     "cli:debug": "node --inspect --require ts-node/register/transpile-only src/cli.ts",
-    "test": "mocha --require ts-node/register src/*.test.ts",
-    "test:debug": "mocha --require ts-node/register/transpile-only --inspect src/*.test.ts",
-    "lint": "prettier --check src docs .github *.md *.json",
-    "format": "prettier --write src docs .github *.md *.json",
+    "test": "nyc mocha --require ts-node/register src/*.test.ts",
+    "test:debug": "nyc mocha --require ts-node/register/transpile-only --inspect src/*.test.ts",
+    "lint:prettier": "prettier --check src docs .github *.json *.md *.mjs",
+    "format:prettier": "prettier --write src docs .github *.json *.md *.mjs",
+    "lint:eslint": "eslint src",
+    "format:eslint": "eslint --fix src",
+    "lint": "yarn lint:prettier && yarn lint:eslint",
+    "format": "yarn format:prettier && yarn format:eslint",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:esm": "tsc -p tsconfig.esm.json",
     "build": "npm run build:cjs && npm run build:esm"
@@ -29,15 +33,31 @@
   "bin": {
     "edilkamin": "dist/cjs/cli.js"
   },
+  "nyc": {
+    "reporter": [
+      "html",
+      "lcov",
+      "text"
+    ]
+  },
   "dependencies": {
     "aws-amplify": "^6.10.0",
     "axios": "^0.26.0"
   },
   "devDependencies": {
     "@aws-amplify/cli": "^7.6.21",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.16.0",
     "@types/mocha": "^10.0.10",
     "@types/sinon": "^17.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.17.0",
+    "@typescript-eslint/parser": "^8.17.0",
+    "eslint": "^9.16.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
     "mocha": "^10.8.2",
+    "nyc": "^17.1.0",
     "prettier": "^2.5.1",
     "sinon": "^19.0.2",
     "ts-node": "^10.9.1",

package/src/cli.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { signIn, configure } from "./library";
 import { Command } from "commander";
 import readline from "readline";
+
 import { version } from "../package.json";
+import { configure, signIn } from "./library";
 
 const promptPassword = (): Promise<string> => {
   const rl = readline.createInterface({
@@ -59,10 +60,11 @@ const createProgram = (): Command => {
       .requiredOption("-m, --mac <macAddress>", "MAC address of the device")
   ).action(async (options) => {
     const { username, password, mac } = options;
+    const normalizedMac = mac.replace(/:/g, "");
     const pwd = password || (await promptPassword());
     const jwtToken = await signIn(username, pwd);
     const api = configure(); // Use the default API configuration
-    const deviceInfo = await api.deviceInfo(jwtToken, mac);
+    const deviceInfo = await api.deviceInfo(jwtToken, normalizedMac);
     console.log("Device Info:", deviceInfo.data);
   });
   return program;

package/src/index.ts

@@ -1,7 +1,7 @@
 import { configure } from "./library";
 
 export { API_URL } from "./constants";
-
+export { configure, signIn } from "./library";
 export {
   CommandsType,
   DeviceInfoType,
@@ -10,6 +10,4 @@ export {
   UserParametersType,
 } from "./types";
 
-export { signIn, configure } from "./library";
-
 export const { deviceInfo, setPower, setPowerOff, setPowerOn } = configure();

package/src/library.test.ts

@@ -1,7 +1,9 @@
 import { strict as assert } from "assert";
-import sinon from "sinon";
 import axios from "axios";
-import { configure } from "../src/library";
+import sinon from "sinon";
+
+import { configure, createAuthService } from "../src/library";
+import { API_URL } from "./constants";
 
 describe("library", () => {
   let axiosStub: sinon.SinonStub;
@@ -10,6 +12,7 @@ describe("library", () => {
     axiosStub = sinon.stub(axios, "create").returns({
       get: sinon.stub(),
       put: sinon.stub(),
+      // eslint-disable-next-line  @typescript-eslint/no-explicit-any
     } as any);
   });
 
@@ -17,12 +20,91 @@ describe("library", () => {
     sinon.restore();
   });
 
+  describe("signIn", () => {
+    it("should sign in and return the JWT token", async () => {
+      const expectedUsername = "testuser";
+      const expectedPassword = "testpassword";
+      const expectedToken = "mockJwtToken";
+      const signIn = sinon.stub().resolves({ isSignedIn: true });
+      const signOut = sinon.stub();
+      const fetchAuthSession = sinon.stub().resolves({
+        tokens: {
+          accessToken: { toString: () => expectedToken },
+        },
+      });
+      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
+      );
+      assert.deepEqual(authStub.signOut.args, [[]]);
+      assert.deepEqual(signIn.args, [
+        [{ username: expectedUsername, password: expectedPassword }],
+      ]);
+      assert.equal(token, expectedToken);
+    });
+
+    it("should throw an error if sign-in fails", async () => {
+      const expectedUsername = "testuser";
+      const expectedPassword = "testpassword";
+      const expectedToken = "mockJwtToken";
+      const signIn = sinon.stub().resolves({ isSignedIn: false });
+      const signOut = sinon.stub();
+      const fetchAuthSession = sinon.stub().resolves({
+        tokens: {
+          accessToken: { toString: () => expectedToken },
+        },
+      });
+      const authStub = {
+        signIn,
+        signOut,
+        fetchAuthSession,
+      };
+      // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+      const authService = createAuthService(authStub as any);
+      await assert.rejects(
+        async () => authService.signIn(expectedUsername, expectedPassword),
+        {
+          name: "AssertionError",
+          message: "Sign-in failed",
+        }
+      );
+    });
+  });
+
   describe("configure", () => {
     it("should create API methods with the correct baseURL", () => {
       const baseURL = "https://example.com/api";
       const api = configure(baseURL);
-      assert.ok(axiosStub.calledOnce);
-      assert.deepEqual(axiosStub.firstCall.args[0], { baseURL });
+      assert.deepEqual(axiosStub.args, [
+        [
+          {
+            baseURL,
+          },
+        ],
+      ]);
+      assert.deepEqual(Object.keys(api), [
+        "deviceInfo",
+        "setPower",
+        "setPowerOff",
+        "setPowerOn",
+      ]);
+    });
+    it("should create API methods with the default baseURL", () => {
+      const api = configure();
+      assert.deepEqual(axiosStub.args, [
+        [
+          {
+            baseURL: API_URL,
+          },
+        ],
+      ]);
       assert.deepEqual(Object.keys(api), [
         "deviceInfo",
         "setPower",
@@ -34,43 +116,62 @@ describe("library", () => {
 
   describe("API Methods", () => {
     it("should call axios for deviceInfo", async () => {
+      const expectedDevice = { id: "123", name: "Mock Device" };
+      const expectedToken = "mockToken";
       const mockAxios = {
-        get: sinon
-          .stub()
-          .resolves({ data: { id: "123", name: "Mock Device" } }),
+        get: sinon.stub().resolves({ data: expectedDevice }),
       };
-      axiosStub.returns(mockAxios as any);
+      axiosStub.returns(mockAxios);
       const api = configure("https://example.com/api");
-      const result = await api.deviceInfo("mockToken", "mockMacAddress");
-      assert.ok(mockAxios.get.calledOnce);
-      assert.equal(
-        mockAxios.get.firstCall.args[0],
-        "device/mockMacAddress/info"
-      );
-      assert.deepEqual(mockAxios.get.firstCall.args[1], {
-        headers: { Authorization: "Bearer mockToken" },
-      });
-      assert.deepEqual(result.data, { id: "123", name: "Mock Device" });
+      const result = await api.deviceInfo(expectedToken, "mockMacAddress");
+      assert.deepEqual(mockAxios.get.args, [
+        [
+          "device/mockMacAddress/info",
+          { headers: { Authorization: `Bearer ${expectedToken}` } },
+        ],
+      ]);
+      assert.deepEqual(result.data, expectedDevice);
     });
 
-    it("should call axios for setPowerOn", async () => {
-      const mockAxios = {
-        put: sinon.stub().resolves({ status: 200 }),
-      };
-      axiosStub.returns(mockAxios as any);
-      const api = configure("https://example.com/api");
-      const result = await api.setPowerOn("mockToken", "mockMacAddress");
-      assert.ok(mockAxios.put.calledOnce);
-      assert.equal(mockAxios.put.firstCall.args[0], "mqtt/command");
-      assert.deepEqual(mockAxios.put.firstCall.args[1], {
-        mac_address: "mockMacAddress",
-        name: "power",
-        value: 1,
-      });
-      assert.deepEqual(mockAxios.put.firstCall.args[2], {
-        headers: { Authorization: "Bearer mockToken" },
+    // Tests for setPowerOn and setPowerOff
+    [
+      {
+        method: "setPowerOn",
+        call: (api: ReturnType<typeof configure>) =>
+          api.setPowerOn("mockToken", "mockMacAddress"),
+        expectedValue: 1,
+      },
+      {
+        method: "setPowerOff",
+        call: (api: ReturnType<typeof configure>) =>
+          api.setPowerOff("mockToken", "mockMacAddress"),
+        expectedValue: 0,
+      },
+    ].forEach(({ method, call, expectedValue }) => {
+      it(`should call axios for ${method}`, async () => {
+        const mockAxios = {
+          put: sinon.stub().resolves({ status: 200 }),
+        };
+        axiosStub.returns(mockAxios);
+        const api = configure("https://example.com/api");
+
+        // Invoke the method using the mapped call function
+        const result = await 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);
       });
-      assert.equal(result.status, 200);
     });
   });
 });

package/src/library.ts

@@ -2,35 +2,64 @@ import { strict as assert } from "assert";
 import { Amplify } from "aws-amplify";
 import * as amplifyAuth from "aws-amplify/auth";
 import axios, { AxiosInstance } from "axios";
-import { DeviceInfoType } from "./types";
+
 import { API_URL } from "./constants";
+import { DeviceInfoType } from "./types";
 
 const amplifyconfiguration = {
   aws_project_region: "eu-central-1",
   aws_user_pools_id: "eu-central-1_BYmQ2VBlo",
   aws_user_pools_web_client_id: "7sc1qltkqobo3ddqsk4542dg2h",
 };
-Amplify.configure(amplifyconfiguration);
 
+/**
+ * Generates headers with a JWT token for authenticated requests.
+ * @param {string} jwtToken - The JWT token for authorization.
+ * @returns {object} - The headers object with the Authorization field.
+ */
 const headers = (jwtToken: string) => ({ Authorization: `Bearer ${jwtToken}` });
 
 /**
- * Sign in to return the JWT token.
+ * Configures Amplify if not already configured.
+ * Ensures the configuration is only applied once.
  */
-const signIn = async (username: string, password: string): Promise<string> => {
-  // in case the user is already signed in, refs:
-  // https://github.com/aws-amplify/amplify-js/issues/13813
-  await amplifyAuth.signOut();
-  const { isSignedIn } = await amplifyAuth.signIn({
-    username,
-    password,
-  });
-  assert.ok(isSignedIn);
-  const { tokens } = await amplifyAuth.fetchAuthSession();
-  assert.ok(tokens);
-  return tokens.accessToken.toString();
+const configureAmplify = () => {
+  const currentConfig = Amplify.getConfig();
+  if (Object.keys(currentConfig).length !== 0) return;
+  Amplify.configure(amplifyconfiguration);
 };
 
+/**
+ * Creates an authentication service with sign-in functionality.
+ * @param {typeof amplifyAuth} auth - The authentication module to use.
+ * @returns {object} - An object containing authentication-related methods.
+ */
+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.
+   * @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
+  ): Promise<string> => {
+    configureAmplify();
+    await auth.signOut(); // Ensure the user is signed out first
+    const { isSignedIn } = await auth.signIn({ username, password });
+    assert.ok(isSignedIn, "Sign-in failed");
+    const { tokens } = await auth.fetchAuthSession();
+    assert.ok(tokens, "No tokens found");
+    return tokens.accessToken.toString();
+  };
+  return { signIn };
+};
+
+// Create the default auth service using amplifyAuth
+const { signIn } = createAuthService(amplifyAuth);
+
 const deviceInfo =
   (axiosInstance: AxiosInstance) => (jwtToken: string, macAddress: string) =>
     axiosInstance.get<DeviceInfoType>(`device/${macAddress}/info`, {
@@ -39,6 +68,7 @@ const deviceInfo =
 
 const mqttCommand =
   (axiosInstance: AxiosInstance) =>
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
   (jwtToken: string, macAddress: string, payload: any) =>
     axiosInstance.put(
       "mqtt/command",
@@ -72,4 +102,4 @@ const configure = (baseURL: string = API_URL) => {
   };
 };
 
-export { signIn, configure };
+export { configure, createAuthService, headers, signIn };