edilkamin 1.4.0 → 1.5.0

package/dist/esm/library.test.js

@@ -8,69 +8,238 @@ 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;
+    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
         });
     });
     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 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 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", () => {
+        const expectedApi = [
+            "deviceInfo",
+            "setPower",
+            "setPowerOff",
+            "setPowerOn",
+            "getPower",
+            "getEnvironmentTemperature",
+            "getTargetTemperature",
+            "setTargetTemperature",
+        ];
         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(Object.keys(api), [
-                "deviceInfo",
-                "setPower",
-                "setPowerOff",
-                "setPowerOn",
+            assert.deepEqual(axiosStub.args, [
+                [
+                    {
+                        baseURL,
+                    },
+                ],
+            ]);
+            assert.deepEqual(Object.keys(api), expectedApi);
+        });
+        it("should create API methods with the default baseURL", () => {
+            const api = configure();
+            assert.deepEqual(axiosStub.args, [
+                [
+                    {
+                        baseURL: API_URL,
+                    },
+                ],
             ]);
+            assert.deepEqual(Object.keys(api), expectedApi);
         });
     });
     describe("API Methods", () => {
+        const mockDeviceInfo = {
+            status: {
+                commands: {
+                    power: true,
+                },
+                temperatures: {
+                    enviroment: 19,
+                },
+            },
+            nvm: {
+                user_parameters: {
+                    enviroment_1_temperature: 22,
+                },
+            },
+        };
         it("should call axios for deviceInfo", () => __awaiter(void 0, void 0, void 0, function* () {
             const mockAxios = {
-                get: sinon
-                    .stub()
-                    .resolves({ data: { id: "123", name: "Mock Device" } }),
+                get: sinon.stub().resolves({ data: mockDeviceInfo }),
             };
             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, mockDeviceInfo);
         }));
+        // 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);
+            }));
+        });
+        const getterTests = [
+            {
+                method: "getPower",
+                call: (api, token, mac) => api.getPower(token, mac),
+                expectedResult: true,
+            },
+            {
+                method: "getEnvironmentTemperature",
+                call: (api, token, mac) => api.getEnvironmentTemperature(token, mac),
+                expectedResult: 19,
+            },
+            {
+                method: "getTargetTemperature",
+                call: (api, token, mac) => api.getTargetTemperature(token, mac),
+                expectedResult: 22,
+            },
+        ];
+        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");
+                const result = yield call(api, expectedToken, "mockMacAddress");
+                assert.deepEqual(mockAxios.get.args, [
+                    [
+                        "device/mockMacAddress/info",
+                        { headers: { Authorization: `Bearer ${expectedToken}` } },
+                    ],
+                ]);
+                assert.equal(result, expectedResult);
+            }));
+        });
+        // Setter tests
+        const setterTests = [
+            {
+                method: "setTargetTemperature",
+                call: (api, token, mac, value) => api.setTargetTemperature(token, mac, value),
+                payload: {
+                    name: "enviroment_1_temperature",
+                    value: 20,
+                },
+            },
+        ];
+        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);
+            }));
+        });
     });
 });

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.5.0",
   "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({
@@ -31,11 +32,78 @@ const promptPassword = (): Promise<string> => {
  * @param command The command to which options should be added.
  * @returns The command with options added.
  */
-const addCommonOptions = (command: Command): Command =>
+const addAuthOptions = (command: Command): Command =>
   command
     .requiredOption("-u, --username <username>", "Username")
     .option("-p, --password <password>", "Password");
 
+/**
+ * Adds MAC address option to a command.
+ * @param command The command to which the MAC address option should be added.
+ * @returns The command with the MAC address option added.
+ */
+const addMacOption = (command: Command): Command =>
+  command.requiredOption("-m, --mac <macAddress>", "MAC address of the device");
+
+/**
+ * Handles common authentication and API initialization logic.
+ * @param options The options passed from the CLI command.
+ * @returns An object containing the normalized MAC, JWT token, and configured API instance.
+ */
+const initializeCommand = async (options: {
+  username: string;
+  password?: string;
+  mac: string;
+}): Promise<{
+  normalizedMac: string;
+  jwtToken: string;
+  api: ReturnType<typeof configure>;
+}> => {
+  const { username, password, mac } = options;
+  const normalizedMac = mac.replace(/:/g, "");
+  const pwd = password || (await promptPassword());
+  const jwtToken = await signIn(username, pwd);
+  const api = configure();
+  return { normalizedMac, jwtToken, api };
+};
+
+/**
+ * Executes a getter command by handling common steps (authentication, API initialization).
+ * @param options The options passed from the CLI command.
+ * @param getter A function to call on the configured API object.
+ */
+const executeGetter = async (
+  options: { username: string; password?: string; mac: string },
+  getter: (
+    api: ReturnType<typeof configure>,
+    jwtToken: string,
+    mac: string
+  ) => Promise<unknown>
+): Promise<void> => {
+  const { normalizedMac, jwtToken, api } = await initializeCommand(options);
+  const result = await getter(api, jwtToken, normalizedMac);
+  console.log(result);
+};
+
+/**
+ * Executes a setter command by handling common steps (authentication, API initialization).
+ * @param options The options passed from the CLI command.
+ * @param setter A function to call on the configured API object.
+ */
+const executeSetter = async (
+  options: { username: string; password?: string; mac: string; value: number },
+  setter: (
+    api: ReturnType<typeof configure>,
+    jwtToken: string,
+    mac: string,
+    value: number
+  ) => Promise<unknown>
+): Promise<void> => {
+  const { normalizedMac, jwtToken, api } = await initializeCommand(options);
+  const result = await setter(api, jwtToken, normalizedMac, options.value);
+  console.log(result);
+};
+
 const createProgram = (): Command => {
   const program = new Command();
   program
@@ -43,7 +111,7 @@ const createProgram = (): Command => {
     .description("CLI tool for interacting with the Edilkamin API")
     .version(version);
   // Command: signIn
-  addCommonOptions(
+  addAuthOptions(
     program.command("signIn").description("Sign in and retrieve a JWT token")
   ).action(async (options) => {
     const { username, password } = options;
@@ -51,20 +119,79 @@ const createProgram = (): Command => {
     const jwtToken = await signIn(username, pwd);
     console.log("JWT Token:", jwtToken);
   });
-  // Command: deviceInfo
-  addCommonOptions(
-    program
-      .command("deviceInfo")
-      .description("Retrieve device info for a specific MAC address")
-      .requiredOption("-m, --mac <macAddress>", "MAC address of the device")
-  ).action(async (options) => {
-    const { username, password, mac } = options;
-    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);
-    console.log("Device Info:", deviceInfo.data);
+  // Generic getter commands
+  [
+    {
+      commandName: "deviceInfo",
+      description: "Retrieve device info for a specific MAC address",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string
+      ) => api.deviceInfo(jwtToken, mac),
+    },
+    {
+      commandName: "getPower",
+      description: "Retrieve device power status",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string
+      ) => api.getPower(jwtToken, mac),
+    },
+    {
+      commandName: "getEnvironmentTemperature",
+      description: "Retrieve environment temperature",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string
+      ) => api.getEnvironmentTemperature(jwtToken, mac),
+    },
+    {
+      commandName: "getTargetTemperature",
+      description: "Retrieve target temperature",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string
+      ) => api.getTargetTemperature(jwtToken, mac),
+    },
+  ].forEach(({ commandName, description, getter }) => {
+    addMacOption(
+      addAuthOptions(program.command(commandName).description(description))
+    ).action((options) => executeGetter(options, getter));
   });
+  // Generic setter commands
+  [
+    {
+      commandName: "setPower",
+      description: "Set the power state of the device (1 for ON, 0 for OFF)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number
+      ) => api.setPower(jwtToken, mac, value),
+    },
+    {
+      commandName: "setTargetTemperature",
+      description: "Set the target temperature (degree celsius) for a device",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number
+      ) => api.setTargetTemperature(jwtToken, mac, value),
+    },
+  ].forEach(({ commandName, description, setter }) => {
+    addMacOption(
+      addAuthOptions(
+        program.command(commandName).description(description)
+      ).requiredOption("-v, --value <number>", "Value to set", parseFloat)
+    ).action((options) => executeSetter(options, setter));
+  });
+
   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,13 @@ export {
   UserParametersType,
 } from "./types";
 
-export { signIn, configure } from "./library";
-
-export const { deviceInfo, setPower, setPowerOff, setPowerOn } = configure();
+export const {
+  deviceInfo,
+  setPower,
+  setPowerOff,
+  setPowerOn,
+  getPower,
+  getEnvironmentTemperature,
+  getTargetTemperature,
+  setTargetTemperature,
+} = configure();