@hivedev/hivesdk 1.0.3 → 1.0.7

package/hive-server.js

@@ -0,0 +1,337 @@
+// Server/Utility/SendMail.js
+import nodemailer from "nodemailer";
+async function sendMail(sender, receiver, subject, html) {
+  const transporter = nodemailer.createTransport({
+    host: "smtp.gmail.com",
+    port: 587,
+    secure: false,
+    auth: {
+      user: "fatbeluuga@gmail.com",
+      pass: process.env.SMTP_PASSWORD
+    }
+  });
+  const mailOptions = {
+    from: sender,
+    to: receiver,
+    subject,
+    html
+  };
+  try {
+    const info = await transporter.sendMail(mailOptions);
+    console.log("Email sent:", info.response);
+  } catch (error) {
+    console.error("Error:", error);
+  }
+}
+
+// Server/Utility/DecryptFileWithPassword.js
+import { promises as fs } from "fs";
+
+// Server/Utility/DecryptDataWithPassword.js
+import crypto from "crypto";
+async function decryptDataWithPassword(data, password) {
+  const iv = data.subarray(0, 16);
+  const encrypted = data.subarray(16);
+  const key = crypto.scryptSync(password, "salt", 32);
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+  return decrypted.toString("utf8");
+}
+
+// Server/Utility/DecryptFileWithPassword.js
+async function decryptFileWithPassword(fullPath, password) {
+  const payload = await fs.readFile(fullPath);
+  try {
+    return await decryptDataWithPassword(payload, password);
+  } catch (e) {
+    return null;
+  }
+}
+
+// Server/Utility/GetAppdataDirectory.js
+import path from "path";
+import fs2 from "fs";
+
+// Common/Constants.js
+var _serviceName = null;
+var serviceNameSet = false;
+var serviceName = new Proxy(
+  {},
+  {
+    get() {
+      if (!_serviceName) {
+        throw new Error("Service name not set. Call setServiceName() first.");
+      }
+      return _serviceName;
+    }
+  }
+);
+function setServiceName(name) {
+  if (typeof name !== "string") {
+    throw new Error("Service name must be a string.");
+  }
+  _serviceName = name;
+  serviceNameSet = true;
+}
+
+// Server/Utility/GetAppdataDirectory.js
+function getAppDataDirectory() {
+  const baseDir = process.env.APPDATA || (process.platform === "darwin" ? path.join(process.env.HOME, "Library", "Application Support") : path.join(process.env.HOME, ".config"));
+  const hiveDir = path.join(baseDir, serviceName);
+  fs2.mkdirSync(hiveDir, { recursive: true });
+  return hiveDir.replace(/\\/g, "/");
+}
+
+// Database/DatabaseConnector.js
+import { MongoClient } from "mongodb";
+var DatabaseConnector = class _DatabaseConnector {
+  static #databaseUrl = "mongodb://127.0.0.1:27017";
+  static #databaseName = "untitled";
+  static #username = "";
+  static #password = "";
+  static #mongoClient = null;
+  static #bConfigured = false;
+  static databaseObject = null;
+  /**
+   * Connects to the MongoDB database.
+   * If the database configuration is not set, it will call loadConfiguration() to load the configuration.
+   * If the database configuration is still not set after calling loadConfiguration(), it will return false.
+   * If the MongoClient object is not set, it will create a new MongoClient object with the database URL and credentials.
+   * It will then try to connect to the database using the MongoClient object.
+   * If the connection is successful, it will set the databaseObject to the database object returned by the MongoClient.
+   * If the connection fails, it will log an error message and return false.
+   * @returns {boolean} True if the connection is successful, false otherwise.
+   */
+  static async connect() {
+    if (!_DatabaseConnector.#bConfigured) {
+      await loadConfiguration();
+      if (!_DatabaseConnector.#bConfigured) {
+        console.log("Database configuration is not set! Please provide database credentials first.");
+        return false;
+      }
+    }
+    if (!_DatabaseConnector.#mongoClient) {
+      _DatabaseConnector.#mongoClient = new MongoClient(
+        _DatabaseConnector.#databaseUrl,
+        {
+          auth: { username: _DatabaseConnector.#username, password: _DatabaseConnector.#password }
+        }
+      );
+    }
+    try {
+      await _DatabaseConnector.#mongoClient.connect();
+      _DatabaseConnector.databaseObject = _DatabaseConnector.#mongoClient.db(_DatabaseConnector.#databaseName);
+      return true;
+    } catch (exception) {
+      console.log("Error connecting to database");
+    }
+    return false;
+  }
+  /**
+   * Disconnects from the MongoDB database.
+   * If the MongoClient object is not set, it does nothing.
+   * If the MongoClient object is set, it closes the connection to the database.
+   * It then sets the MongoClient object and the database object to null.
+   * Finally, it logs a message to the console indicating that the disconnection was successful.
+   */
+  static async disconnect() {
+    if (_DatabaseConnector.#mongoClient) {
+      await _DatabaseConnector.#mongoClient.close();
+    }
+    _DatabaseConnector.#mongoClient = null;
+    _DatabaseConnector.databaseObject = null;
+    console.log("Disconnected from database");
+  }
+  /**
+   * Sets the database credentials for the DatabaseConnector
+   * @param {Object} obj - contains the database host, username, password, and name
+   * @param {string} obj.host - The host of the database
+   * @param {string} obj.username - The username of the database
+   * @param {string} obj.password - The password of the database
+   * @param {string} obj.name - The name of the database
+   * @throws {Error} - If any of the database credentials are not set
+   */
+  static setCredentials({ host, username, password, name }) {
+    if (host) _DatabaseConnector.#databaseUrl = "mongodb://" + host + ":27017";
+    else throw new Error("Database host not set!");
+    if (username) _DatabaseConnector.#username = username;
+    else throw new Error("Database username not set!");
+    if (password) _DatabaseConnector.#password = password;
+    else throw new Error("Database password not set!");
+    if (name) _DatabaseConnector.#databaseName = name;
+    else throw new Error("Database name not set!");
+    _DatabaseConnector.#bConfigured = true;
+  }
+};
+var DatabaseConnector_default = DatabaseConnector;
+
+// Server/Utility/LoadConfiguration.js
+import path2 from "path";
+import fs3 from "fs";
+async function loadConfiguration() {
+  let firebaseAdminCredentials = "";
+  let databaseCredentials = "";
+  let permissions = "";
+  let smtpCredentials = "";
+  const firebaseAdminCredentialsPath = path2.join(getAppDataDirectory(), "firebase_admin_credentials.dat");
+  const databaseCredentialsPath = path2.join(getAppDataDirectory(), "database_credentials.dat");
+  const permissionsPath = path2.join(getAppDataDirectory(), "permissions.dat");
+  const smtpCredentialsPath = path2.join(getAppDataDirectory(), "smtp_credentials.dat");
+  if (fs3.existsSync(firebaseAdminCredentialsPath)) {
+    firebaseAdminCredentials = await decryptFileWithPassword(path2.join(getAppDataDirectory(), "firebase_admin_credentials.dat"), process.env.SERVER_PASSWORD);
+  }
+  if (fs3.existsSync(databaseCredentialsPath)) {
+    databaseCredentials = await decryptFileWithPassword(path2.join(getAppDataDirectory(), "database_credentials.dat"), process.env.SERVER_PASSWORD);
+  }
+  if (fs3.existsSync(permissionsPath)) {
+    permissions = await decryptFileWithPassword(path2.join(getAppDataDirectory(), "permissions.dat"), process.env.SERVER_PASSWORD);
+  }
+  if (fs3.existsSync(smtpCredentialsPath)) {
+    smtpCredentials = await decryptFileWithPassword(path2.join(getAppDataDirectory(), "smtp_credentials.dat"), process.env.SERVER_PASSWORD);
+  }
+  process.env.FIREBASE_ADMIN_CREDENTIALS = firebaseAdminCredentials;
+  process.env.DATABASE_CREDENTIALS = databaseCredentials;
+  process.env.PERMISSIONS = permissions;
+  process.env.SMTP_CREDENTIALS = smtpCredentials;
+  try {
+    const smtpCredentialsObject = JSON.parse(smtpCredentials);
+    process.env.SMTP_PASSWORD = smtpCredentialsObject.password || "";
+  } catch (e) {
+    console.error(e);
+  }
+  if (databaseCredentials) {
+    databaseCredentials = JSON.parse(databaseCredentials);
+    const hivePortalDatabaseCredentials = databaseCredentials[serviceName];
+    DatabaseConnector_default.setCredentials(
+      {
+        host: hivePortalDatabaseCredentials.host || "127.0.0.1",
+        username: hivePortalDatabaseCredentials.username || "",
+        password: hivePortalDatabaseCredentials.password || "",
+        name: hivePortalDatabaseCredentials.name || "hive"
+      }
+    );
+  }
+}
+
+// Server/Utility/EncryptFileWithPassword.js
+import { promises as fs4 } from "fs";
+import path3 from "path";
+
+// Server/Utility/EncryptDataWithPassword.js
+import crypto2 from "crypto";
+async function encryptDataWithPassword(data, password) {
+  const key = crypto2.scryptSync(password, "salt", 32);
+  const iv = crypto2.randomBytes(16);
+  const cipher = crypto2.createCipheriv("aes-256-cbc", key, iv);
+  const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
+  return Buffer.concat([iv, encrypted]);
+}
+
+// Server/Utility/EncryptFileWithPassword.js
+async function encryptAndStoreFile(data, fullPath, password) {
+  const payload = await encryptDataWithPassword(data, password);
+  const dir = path3.dirname(fullPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(fullPath, payload);
+}
+
+// Server/Utility/ExtractConfigurationForService.js
+function extractConfigurationForService() {
+  const firebaseAdminCredentials = process.env.FIREBASE_ADMIN_CREDENTIALS ? JSON.parse(process.env.FIREBASE_ADMIN_CREDENTIALS) : null;
+  const databaseCredentials = process.env.DATABASE_CREDENTIALS ? JSON.parse(process.env.databaseCredentials) : null;
+  const permissions = process.env.PERMISSIONS ? JSON.parse(process.env.PERMISSIONS) : null;
+  const smtpCredentials = process.env.SMTP_CREDENTIALS ? JSON.parse(process.env.SMTP_CREDENTIALS) : null;
+  const databaseCredentialsForService = databaseCredentials[serviceName] ? databaseCredentials[serviceName] : null;
+  return { firebaseAdminCredentials, databaseCredentials: databaseCredentialsForService, permissions, smtpCredentials };
+}
+
+// Server/Utility/GetHostIp.js
+import os from "os";
+function getHostIp() {
+  const interfaces = os.networkInterfaces();
+  for (const devName in interfaces) {
+    const iface = interfaces[devName];
+    for (let i = 0; i < iface.length; i++) {
+      const alias = iface[i];
+      if (alias.family === "IPv4" && alias.address !== "127.0.0.1" && !alias.internal) {
+        return alias.address;
+      }
+    }
+  }
+}
+
+// Server/Utility/PromptPassword.js
+import readline from "readline";
+async function promptPassword(promptText = "Enter password: ") {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface(
+      {
+        input: process.stdin,
+        output: process.stdout
+      }
+    );
+    rl.question(promptText, (answer) => {
+      rl.close();
+      process.stdout.write("\n");
+      resolve(answer);
+    });
+    rl._writeToOutput = () => {
+    };
+  });
+}
+
+// Server/Utility/SetupPassword.js
+import fs5 from "fs";
+import path4 from "path";
+
+// Common/Utility/GetSha512Hash.js
+import { createHash } from "crypto";
+function getSha512Hash(text) {
+  return createHash("sha512").update(text).digest("hex");
+}
+
+// Server/Utility/SetupPassword.js
+async function setupPassword() {
+  const appDataDirectory = getAppDataDirectory();
+  const passwordFilePath = path4.join(appDataDirectory, "password.dat");
+  let correctPassword = null;
+  if (!fs5.existsSync(passwordFilePath)) {
+    while (true) {
+      const password = await promptPassword("Create a password: ");
+      const confirm = await promptPassword("Confirm password: ");
+      if (password === confirm) {
+        correctPassword = password;
+        const hashedPassword = getSha512Hash(password);
+        await encryptAndStoreFile(hashedPassword, passwordFilePath, password);
+        break;
+      }
+      console.log("Passwords do not match! Try again!");
+    }
+  } else {
+    while (true) {
+      const password = await promptPassword("Enter your password: ");
+      const storedPasswordHash = await decryptFileWithPassword(passwordFilePath, password);
+      if (storedPasswordHash !== getSha512Hash(password)) {
+        console.log("Incorrect password! Please try again.");
+      } else {
+        correctPassword = password;
+        break;
+      }
+    }
+  }
+  process.env.SERVER_PASSWORD = correctPassword;
+  return correctPassword;
+}
+export {
+  decryptFileWithPassword,
+  encryptAndStoreFile,
+  extractConfigurationForService,
+  getAppDataDirectory,
+  getHostIp,
+  loadConfiguration,
+  promptPassword,
+  sendMail,
+  serviceName,
+  setServiceName,
+  setupPassword
+};

package/package.json

@@ -1,28 +1,24 @@
 {
   "name": "@hivedev/hivesdk",
   "type": "module",
-  "version": "1.0.3",
+  "version": "1.0.7",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
-  "scripts": 
-  {
+  "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "npm run build:esm && npm run build:cjs",
-    "buildserver:esm": "esbuild server.js --bundle --format=esm --external:nodemailer --outfile=dist/server/index.js",
-    "buildserver:cjs": "esbuild server.js --bundle --format=cjs --outfile=dist/server/index.cjs",
+    "buildserver:esm": "node build-server.js",
+    "buildserver:cjs": "esbuild server.js --bundle --format=cjs --outfile=hive-server.cjs",
     "buildclient:esm": "esbuild index.js --bundle --format=esm --outfile=dist/index.js"
   },
-  "exports": 
-  {
-      "./client": 
-      {
-        "import": "./dist/client.js"
-      },
-      "./server": 
-      {
-        "import": "./dist/server/index.js",
-        "require": "./dist/server/index.cjs"
-      }
+  "exports": {
+    "./client": {
+      "import": "./dist/client.js"
+    },
+    "./server": {
+      "import": "./dist/server/index.js",
+      "require": "./dist/server/index.cjs"
+    }
   },
   "keywords": [],
   "author": "Sourav K",
@@ -36,6 +32,7 @@
     "esbuild": "^0.25.10"
   },
   "dependencies": {
+    "mongodb": "^6.20.0",
     "nodemailer": "^7.0.6"
   }
 }

package/Client/Utility/DisableAllButtons.js

@@ -1,4 +0,0 @@
-export function disableAllbuttons()
-{
-    document.querySelectorAll("button").forEach(button => button.disabled = true);
-}

package/Client/Utility/GenerateUUID.js

@@ -1,23 +0,0 @@
-export function generateUUID()
-{
-    let d = new Date().getTime();
-    let d2 = (performance && performance.now && (performance.now() * 1000)) || 0;
-
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c)
-    {
-        let r = Math.random() * 16;
-
-        if (d > 0)
-        {
-            r = (d + r) % 16 | 0;
-            d = Math.floor(d / 16);
-        }
-        else
-        {
-            r = (d2 + r) % 16 | 0;
-            d2 = Math.floor(d2 / 16);
-        }
-
-        return (c === "x" ? r : (r & 0x3 | 0x8)).toString(16);
-    });
-}

package/Client/Utility/GetDeviceId.js

@@ -1,21 +0,0 @@
-import { sha256 } from "../../Common/Utility/Sha256.js";
-import { generateUUID } from "./GenerateUUID.js";
-
-export async function getDeviceId()
-{
-    let uuid = localStorage.getItem("deviceId");
-
-    if (!uuid)
-    {
-        uuid = generateUUID();
-        localStorage.setItem("deviceId", uuid);
-    }
-
-    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const language = navigator.language;
-    const userAgent = navigator.userAgent;
-
-    const rawId = `${uuid}|${timezone}|${language}|${userAgent}`;
-
-    return sha256(rawId);
-}

package/Client/Utility/IsInApp.js

@@ -1,4 +0,0 @@
-export function isInApp()
-{
-    return window.self !== window.top;
-}

package/Client/Utility/SetupAppUsage.js

@@ -1,65 +0,0 @@
-import { appWebViewInteractions } from "../../Common/Enumerations/AppWebViewInteractions.js";
-import { isInApp } from "./IsInApp.js";
-
-export function setupAppUsage()
-{
-    document.cookie = "usesCookies=true; path=/";
-
-    if(isInApp())
-    {
-        window.fallbackOpen = window.open;
-        
-        window.open = (url, name, features)=>
-        {
-            const iframe = document.createElement("iframe");
-            iframe.src = url;
-            iframe.style.position = "fixed";
-            iframe.style.display = "block";
-            iframe.style.height = "100vh";
-            iframe.style.width = "100vw";
-            iframe.style.top = "0px";
-            iframe.style.left = "0px";
-            iframe.style.border = "none";
-            iframe.style.zIndex = "10000"
-            document.body.appendChild(iframe);
-
-            return {
-                close: ()=>
-                {
-                    iframe.remove();
-                }
-                
-            }
-        }
-
-        document.querySelectorAll("img").forEach(img => 
-        {
-            if(img.getAttribute("src") && !img.src.startsWith("http")) 
-            {
-                img.src = new URL(img.getAttribute("src"), window.location.origin).href;
-            }
-        });
-
-        window.addEventListener("message", (event)=>
-        {
-            try
-            {
-               
-                const messageObject = typeof event.data === 'string' ? JSON.parse(event.data) : event.data;
-                
-                switch(messageObject.interaction)
-                {
-                    case appWebViewInteractions.BACK_PRESSED:
-                    {
-                        window.history.back();
-                    }
-                }
-                
-            }
-            catch(error)
-            {
-                return;
-            }
-        });
-    }
-}

package/Common/Utility/GetDirectoryName.js

@@ -1,8 +0,0 @@
-import { fileURLToPath } from 'url';
-import path from 'path';
-
-export function getDirectoryName(metaUrl)
-{
-    const __filename = fileURLToPath(metaUrl);
-    return path.dirname(__filename).replace(/\\/g, "/");
-}

package/server.js

@@ -1,3 +0,0 @@
-import { sendMail } from "./Server/Utility/SendMail.js";
-
-export { sendMail };