@hivedev/hivesdk 1.0.3 → 1.0.7

package/Common/Constants.js

@@ -1,6 +1,36 @@
-export let serviceName = `UnknownService${Date.now()}`;
+let _serviceName = null;
+let serviceNameSet = false;
 
+
+export const serviceName = new Proxy({}, 
+{
+    get()
+    {
+        if (!_serviceName)
+        {
+            throw new Error("Service name not set. Call setServiceName() first.");
+        }
+
+        return _serviceName;
+    }
+});
+
+
+/**
+ * Sets the service name for the current instance of the SDK.
+ * This is necessary before any other functions can be called.
+ * @param {string} name - The name of the service.
+ * @throws {Error} - If the service name is not a string.
+ */
 export function setServiceName(name) 
 {
-    serviceName = name;
-}
+    if (typeof name !== "string")
+    {
+        throw new Error("Service name must be a string.");
+    }
+    
+    _serviceName = name;
+    serviceNameSet = true;
+}
+
+

package/Common/Utility/ConvertEnumerationKeyToTitleCase.js

@@ -1,3 +1,8 @@
+/**
+ * Converts an enumeration key (e.g. SOME_ENUM_KEY) to title case (e.g. Some Enum Key)
+ * @param {string} input - The enumeration key to convert
+ * @returns {string} - The converted title case string
+ */
 export function convertEnumerationKeyToTitleCase(input)
 {
   return input

package/Common/Utility/Delay.js

@@ -1,3 +1,8 @@
+/**
+ * Returns a promise that resolves after the specified number of milliseconds.
+ * @param {number} ms The number of milliseconds to wait.
+ * @returns {Promise} A promise that resolves after the specified time.
+ */
 export function delay(ms) 
 {
     return new Promise(resolve => setTimeout(resolve, ms));

package/Common/Utility/ExtractIpFromUrl.js

@@ -1,11 +1,16 @@
 import { URL } from "url";
 import dns from "dns/promises";
 
-export async function extractIpFromUrl(httpUrl)
+/**
+ * Extracts the IP address from the given URL.
+ * If the hostname is a valid IP address, it is returned directly.
+ * Otherwise, a DNS lookup is performed to resolve the hostname to an IP address.
+ * @param {string} url - The URL to extract the IP address from.
+ * @returns {Promise<string>} A promise that resolves with the extracted IP address.
+ */
+export async function extractIpFromUrl(url)
 {
-    console.log("URL IS" + httpUrl);
-    console.log(httpUrl);
-    const parsed = new URL(httpUrl);
+    const parsed = new URL(url);
     const hostname = parsed.hostname;  
 
     if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) 

package/Common/Utility/GenerateRandomId.js

@@ -1,3 +1,9 @@
+/**
+ * Generates a random id of a given length.
+ * The id is a string of alphanumeric characters.
+ * @param {number} length The length of the id to generate.
+ * @returns {string} A random id of the given length.
+ */
 export function generateRandomId(length)
 {
     const characters = `abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`;

package/Common/Utility/GetSha512Hash.js

@@ -1,5 +1,10 @@
 import { createHash } from 'crypto';
 
+/**
+ * Returns the SHA-512 hash of the given text as a hexadecimal string.
+ * @param {string} text - The text to hash.
+ * @returns {string} The SHA-512 hash of the given text as a hexadecimal string.
+ */
 export function getSha512Hash(text) 
 {
     return createHash('sha512').update(text).digest('hex');

package/Common/Utility/NormalizeIp.js

@@ -1,3 +1,12 @@
+/**
+ * Normalizes an IP address.
+ * If the IP address is an IPv6 address in the form "::ffff:<IPv4 address>",
+ * it is converted to the corresponding IPv4 address.
+ * If the IP address is "::1", it is converted to "127.0.0.1".
+ * Otherwise, the IP address is returned unchanged.
+ * @param {string} ip - The IP address to normalize.
+ * @returns {string} The normalized IP address.
+ */
 export function normalizeIp(ip)
 {
     if (ip.startsWith("::ffff:")) 

package/Common/Utility/Sha256.js

@@ -1,4 +1,13 @@
-// Pure JS SHA-256 (no dependencies)
+
+
+/**
+ * Generates a SHA-256 hash of the given ASCII string.
+ * @param {string} ascii The string to hash.
+ * @returns {string} The SHA-256 hash of the given string.
+ * @example
+ * const hash = sha256("password");
+ * console.log(hash); // Output: 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8
+ */
 export function sha256(ascii)
 {
     function rightRotate(value, amount)

package/Database/DatabaseConnector.js

@@ -0,0 +1,109 @@
+import { MongoClient } from "mongodb";
+import { loadConfiguration } from "../Server/Utility/LoadConfiguration.js";
+
+
+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;
+    }
+
+}
+
+export default DatabaseConnector;

package/Server/Classes/HiveServerGlobals.js

@@ -0,0 +1,20 @@
+class HiveServerGlobals
+{
+    static #serviceUrls = {};
+
+    static getServiceUrls(serviceName)
+    {
+        if(!serviceName)
+        {
+            return this.#serviceUrls;
+        }
+        else
+        {
+            return this.#serviceUrls[serviceName] || {};
+        }
+    }
+
+    
+}
+
+export default HiveServerGlobals;

package/Server/InitServer.js

@@ -0,0 +1,16 @@
+import { setupPassword } from "./Utility/SetupPassword.js";
+
+let bInitialized = false;
+
+export async function initServer() 
+{
+    if(bInitialized)
+    {
+        console.warn("Server already initialized! Skipping...");
+        return;
+    }
+
+    await setupPassword();
+    
+    bInitialized = true;
+}

package/Server/Utility/DecryptDataWithPassword.js

@@ -1,5 +1,11 @@
 import crypto from "crypto";
 
+/**
+ * Decrypt data encrypted with the given password.
+ * @param {Buffer} data - The encrypted data.
+ * @param {string} password - The password used for encryption.
+ * @returns {string} The decrypted data as a UTF-8 string.
+ */
 export async function decryptDataWithPassword(data, password)
 {
     const iv = data.subarray(0, 16);

package/Server/Utility/DecryptFileWithPassword.js

@@ -2,6 +2,12 @@ import { promises as fs } from "fs";
 import crypto from "crypto";
 import { decryptDataWithPassword } from "./DecryptDataWithPassword.js";
 
+/**
+ * Decrypt a file encrypted with the given password.
+ * @param {string} fullPath - The full path to the file to decrypt.
+ * @param {string} password - The password to use for decryption.
+ * @returns {Promise<string|null>} The decrypted file contents, or null on failure.
+ */
 export async function decryptFileWithPassword(fullPath, password)
 {
     const payload = await fs.readFile(fullPath);

package/Server/Utility/EncryptFileWithPassword.js

@@ -2,6 +2,13 @@ import { promises as fs } from "fs";
 import path from "path";
 import { encryptDataWithPassword } from "./EncryptDataWithPassword.js";
 
+/**
+ * Encrypt the given data with the given password and store it in the given file.
+ * @param {string|Buffer} data - The data to encrypt.
+ * @param {string} fullPath - The full path to the file to store the encrypted data in.
+ * @param {string} password - The password to use for encryption.
+ * @returns {Promise<void>} - A promise that resolves when the file has been encrypted and stored.
+ */
 export async function encryptAndStoreFile(data, fullPath, password)
 {  
     const payload = await encryptDataWithPassword(data, password);

package/Server/Utility/ExtractConfigurationForService.js

@@ -1,9 +1,21 @@
-export function extractConfigurationForService(serviceName)
+import { serviceName } from "../../Common/Constants.js";
+
+/**
+ * Extract the configuration for the given service name from the environment variables.
+ * This function expects the environment variables FIREBASE_ADMIN_CREDENTIALS, DATABASE_CREDENTIALS, PERMISSIONS, and SMTP_CREDENTIALS to be set.
+ * If any of the environment variables are not set, the corresponding configuration will be set to null.
+ * @returns {Object} An object containing the extracted configuration for the given service name.
+ * @property {Object|null} firebaseAdminCredentials - The Firebase admin credentials for the given service name.
+ * @property {Object|null} databaseCredentials - The database credentials for the given service name.
+ * @property {Object|null} permissions - The permissions for the given service name.
+ * @property {Object|null} smtpCredentials - The SMTP credentials for the given service name.
+ */
+export function extractConfigurationForService()
 {
-    const firebaseAdminCredentials = process.env.firebaseAdminCredentials? JSON.parse(process.env.firebaseAdminCredentials): null;
-    const databaseCredentials = process.env.databaseCredentials? JSON.parse(process.env.databaseCredentials): null;
-    const permissions = process.env.permissions? JSON.parse(process.env.permissions): null;
-    const smtpCredentials = process.env.smtpCredentials? JSON.parse(process.env.smtpCredentials): null;
+    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: firebaseAdminCredentials, databaseCredentials: databaseCredentialsForService, permissions: permissions, smtpCredentials: smtpCredentials };

package/Server/Utility/FindService.js

@@ -0,0 +1,84 @@
+import dgram from "dgram";
+
+const TARGET_PORT = 49153;
+const RESPONSE_TIMEOUT = 3000;
+
+export async function findService(serviceName)
+{
+    const targetIp = process.env.HIVE_PORTAL_LAN_IP;
+    if (!targetIp) return { name: serviceName, urls: { local: "http://127.0.0.1:49152", remote: "" } };
+
+    const request = { serviceName };
+    const message = Buffer.from(JSON.stringify(request));
+    const socket = dgram.createSocket("udp4");
+
+    return await new Promise((resolve, reject) =>
+    {
+        let resolved = false;
+
+        socket.on("message", (msg, rinfo) =>
+        {
+            if (resolved) return;
+            try
+            {
+                const parsed = JSON.parse(msg.toString());
+                
+                if (parsed.name === serviceName && parsed.urls)
+                {
+                    resolved = true;
+                    clearTimeout(timer);
+                    socket.close();
+                    resolve(parsed);
+                }
+            }
+            catch
+            {
+                // ignore malformed responses
+            }
+        });
+
+        socket.once("error", (err) =>
+        {
+            if (resolved) return;
+            resolved = true;
+            clearTimeout(timer);
+            socket.close();
+            resolve(null);
+        });
+
+        socket.bind(() =>
+        {
+            try
+            {
+                socket.send(message, TARGET_PORT, targetIp, (err) =>
+                {
+                    if (err && !resolved)
+                    {
+                        resolved = true;
+                        clearTimeout(timer);
+                        socket.close();
+                        resolve(null);
+                    }
+                });
+            }
+            catch
+            {
+                if (!resolved)
+                {
+                    resolved = true;
+                    clearTimeout(timer);
+                    socket.close();
+                    resolve(null);
+                }
+            }
+        });
+
+        const timer = setTimeout(() =>
+        {
+            if (resolved) return;
+            resolved = true;
+            socket.close();
+            resolve(null);
+        }, RESPONSE_TIMEOUT);
+    });
+}

package/Server/Utility/GetAppdataDirectory.js

@@ -1,5 +1,6 @@
 import path from "path";
 import fs from "fs";
+import { serviceName } from "../../Common/Constants.js";
 
 export function getAppDataDirectory()
 {
@@ -8,7 +9,7 @@ export function getAppDataDirectory()
             ? path.join(process.env.HOME, "Library", "Application Support")
             : path.join(process.env.HOME, ".config"));
 
-    const hiveDir = path.join(baseDir, "Hive");
+    const hiveDir = path.join(baseDir, serviceName);
 
     fs.mkdirSync(hiveDir, { recursive: true });
 

package/Server/Utility/IsRequestOriginatingFromService.js

@@ -1,55 +1,54 @@
-import url from "url";
-import { normalizeIp } from "../../Common/Utility/NormalizeIp.js";
-import DatabaseQueryEngine from "../../Database/DatabaseQueryEngine.js";
-import { extractIpFromUrl } from "../../Common/Utility/ExtractIpFromUrl.js";
-
-export async function isRequestOriginatingFromService(request)
-{
-    const serviceUrls = await DatabaseQueryEngine.getServiceUrls(null);
-
-    if (!serviceUrls || serviceUrls.length === 0)
-    {
-        return false;
-    }
-
-    const ip = request.ip || request.connection.remoteAddress || request.socket.remoteAddress;
-
-    const normalizedIp = normalizeIp(ip);
-
-    for (const service of serviceUrls)
-    {
-        for (const key of ["local", "remote"])
-        {
-            console.log(service);
-            console.log(key);
-            console.log(service.urls[key]);
-
-            try
-            {
-                const serviceUrl = await extractIpFromUrl(service.urls[key]);
-            }
-            catch(err)
-            {
-                console.log("ERROR");
-                continue;
-            }
+// import { normalizeIp } from "../../Common/Utility/NormalizeIp.js";
+// import DatabaseQueryEngine from "../../Database/DatabaseQueryEngine.js";
+// import { extractIpFromUrl } from "../../Common/Utility/ExtractIpFromUrl.js";
+
+// export async function isRequestOriginatingFromService(request)
+// {
+//     const serviceUrls = await DatabaseQueryEngine.getServiceUrls(null);
+
+//     if (!serviceUrls || serviceUrls.length === 0)
+//     {
+//         return false;
+//     }
+
+//     const ip = request.ip || request.connection.remoteAddress || request.socket.remoteAddress;
+
+//     const normalizedIp = normalizeIp(ip);
+
+//     for (const service of serviceUrls)
+//     {
+//         for (const key of ["local", "remote"])
+//         {
+//             console.log(service);
+//             console.log(key);
+//             console.log(service.urls[key]);
+
+//             try
+//             {
+//                 const serviceUrl = await extractIpFromUrl(service.urls[key]);
+//             }
+//             catch(err)
+//             {
+//                 console.log("ERROR");
+//                 continue;
+//             }
             
-            const serviceUrl = await extractIpFromUrl(service.urls[key]);
-            if (!serviceUrl) continue;
+//             const serviceUrl = await extractIpFromUrl(service.urls[key]);
+//             if (!serviceUrl) continue;
 
-            const normalizedServiceUrl = normalizeIp(serviceUrl);
+//             const normalizedServiceUrl = normalizeIp(serviceUrl);
 
-            console.log(normalizedIp);
-            console.log(normalizedServiceUrl);
+//             console.log(normalizedIp);
+//             console.log(normalizedServiceUrl);
 
-            console.log("____")
+//             console.log("____")
 
-            if (normalizedIp === normalizedServiceUrl)
-            {
-                return true;
-            }
-        }
-    }
+//             if (normalizedIp === normalizedServiceUrl)
+//             {
+//                 return true;
+//             }
+//         }
+//     }
 
-    return false;
-}
+//     return false;
+// }

package/Server/Utility/LoadConfiguration.js

@@ -1,6 +1,7 @@
 import { decryptFileWithPassword } from "./DecryptFileWithPassword.js";
-import { getHiveAppDataDirectory } from "./GetHiveAppdataDirectory.js";
+import { getAppDataDirectory } from "./GetAppdataDirectory.js";
 import DatabaseConnector from "../../Database/DatabaseConnector.js";
+import { serviceName } from "../../Common/Constants.js";
 
 import path from "path";
 import fs from "fs";
@@ -12,41 +13,53 @@ export async function loadConfiguration()
     let permissions = "";
     let smtpCredentials = "";
 
-    const firebaseAdminCredentialsPath = path.join(getHiveAppDataDirectory(), "firebase_admin_credentials.dat");
-    const databaseCredentialsPath = path.join(getHiveAppDataDirectory(), "database_credentials.dat");
-    const permissionsPath = path.join(getHiveAppDataDirectory(), "permissions.dat");
-    const smtpCredentialsPath = path.join(getHiveAppDataDirectory(), "smtp_credentials.dat");
+    const firebaseAdminCredentialsPath = path.join(getAppDataDirectory(), "firebase_admin_credentials.dat");
+    const databaseCredentialsPath = path.join(getAppDataDirectory(), "database_credentials.dat");
+    const permissionsPath = path.join(getAppDataDirectory(), "permissions.dat");
+    const smtpCredentialsPath = path.join(getAppDataDirectory(), "smtp_credentials.dat");
 
     if(fs.existsSync(firebaseAdminCredentialsPath))
     {
-        firebaseAdminCredentials = await decryptFileWithPassword(path.join(getHiveAppDataDirectory(), "firebase_admin_credentials.dat"), process.env.serverPassword);
+        firebaseAdminCredentials = await decryptFileWithPassword(path.join(getAppDataDirectory(), "firebase_admin_credentials.dat"), process.env.SERVER_PASSWORD);
     }
 
     if(fs.existsSync(databaseCredentialsPath))
     {
-        databaseCredentials = await decryptFileWithPassword(path.join(getHiveAppDataDirectory(), "database_credentials.dat"), process.env.serverPassword);
+        databaseCredentials = await decryptFileWithPassword(path.join(getAppDataDirectory(), "database_credentials.dat"), process.env.SERVER_PASSWORD);
     }
 
     if(fs.existsSync(permissionsPath))
     {
-        permissions = await decryptFileWithPassword(path.join(getHiveAppDataDirectory(), "permissions.dat"), process.env.serverPassword);
+        permissions = await decryptFileWithPassword(path.join(getAppDataDirectory(), "permissions.dat"), process.env.SERVER_PASSWORD);
     }
 
     if(fs.existsSync(smtpCredentialsPath))
     {
-        smtpCredentials = await decryptFileWithPassword(path.join(getHiveAppDataDirectory(), "smtp_credentials.dat"), process.env.serverPassword);
+        smtpCredentials = await decryptFileWithPassword(path.join(getAppDataDirectory(), "smtp_credentials.dat"), process.env.SERVER_PASSWORD);
     }
 
-    process.env.firebaseAdminCredentials = firebaseAdminCredentials;
-    process.env.databaseCredentials = databaseCredentials;
-    process.env.permissions = permissions;
-    process.env.smtpCredentials = smtpCredentials;
+    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["HivePortal"];
+        const hivePortalDatabaseCredentials = databaseCredentials[serviceName];
         DatabaseConnector.setCredentials
         (
             {