@hivedev/hivesdk 1.0.33 → 1.0.35

package/hive-server.js

@@ -30,7 +30,7 @@ var require_dist = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.parse = parse2;
-    exports.serialize = serialize2;
+    exports.serialize = serialize4;
     var cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
     var cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
     var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
@@ -88,7 +88,7 @@ var require_dist = __commonJS({
       }
       return min;
     }
-    function serialize2(name, val, options) {
+    function serialize4(name, val, options) {
       const enc = options?.encode || encodeURIComponent;
       if (!cookieNameRegExp.test(name)) {
         throw new TypeError(`argument name is invalid: ${name}`);
@@ -374,47 +374,64 @@ var DatabaseConnector_default = DatabaseConnector;
 import path2 from "path";
 import fs3 from "fs";
 async function loadConfiguration() {
-  let firebaseAdminCredentials = "";
-  let databaseCredentials = "";
-  let permissions = "";
-  let smtpCredentials = "";
+  let firebaseAdminCredentials = null;
+  let databaseCredentials = null;
+  let permissions = null;
+  let smtpCredentials = null;
   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);
+    firebaseAdminCredentials = await decryptFileWithPassword(firebaseAdminCredentialsPath, process.env.SERVER_PASSWORD);
   }
   if (fs3.existsSync(databaseCredentialsPath)) {
-    databaseCredentials = await decryptFileWithPassword(path2.join(getAppDataDirectory(), "database_credentials.dat"), process.env.SERVER_PASSWORD);
+    databaseCredentials = await decryptFileWithPassword(databaseCredentialsPath, process.env.SERVER_PASSWORD);
   }
   if (fs3.existsSync(permissionsPath)) {
-    permissions = await decryptFileWithPassword(path2.join(getAppDataDirectory(), "permissions.dat"), process.env.SERVER_PASSWORD);
+    permissions = await decryptFileWithPassword(permissionsPath, process.env.SERVER_PASSWORD);
   }
   if (fs3.existsSync(smtpCredentialsPath)) {
-    smtpCredentials = await decryptFileWithPassword(path2.join(getAppDataDirectory(), "smtp_credentials.dat"), process.env.SERVER_PASSWORD);
+    smtpCredentials = await decryptFileWithPassword(smtpCredentialsPath, 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 (firebaseAdminCredentials) {
+    process.env.FIREBASE_ADMIN_CREDENTIALS = firebaseAdminCredentials;
   }
   if (databaseCredentials) {
-    databaseCredentials = JSON.parse(databaseCredentials);
-    const hivePortalDatabaseCredentials = databaseCredentials[HiveServerGlobals_default.getServiceName()];
-    DatabaseConnector_default.setCredentials(
-      {
-        host: hivePortalDatabaseCredentials.host || "127.0.0.1",
-        username: hivePortalDatabaseCredentials.username || "",
-        password: hivePortalDatabaseCredentials.password || "",
-        name: hivePortalDatabaseCredentials.name || "hive"
+    process.env.DATABASE_CREDENTIALS = databaseCredentials;
+  }
+  if (permissions) {
+    process.env.PERMISSIONS = permissions;
+  }
+  if (smtpCredentials) {
+    process.env.SMTP_CREDENTIALS = smtpCredentials;
+    try {
+      const smtpCredentialsObject = JSON.parse(smtpCredentials);
+      process.env.SMTP_PASSWORD = smtpCredentialsObject.password || "";
+    } catch (error) {
+      console.error("loadConfiguration: Failed to parse SMTP credentials.", error);
+    }
+  }
+  if (databaseCredentials) {
+    try {
+      const parsedDatabaseCredentials = JSON.parse(databaseCredentials);
+      const serviceName = HiveServerGlobals_default.getServiceName();
+      const serviceCredentials = parsedDatabaseCredentials[serviceName];
+      if (!serviceCredentials) {
+        console.error(`loadConfiguration: No database credentials found for service "${serviceName}".`);
+        return;
       }
-    );
+      DatabaseConnector_default.setCredentials(
+        {
+          host: serviceCredentials.host || "127.0.0.1",
+          username: serviceCredentials.username || "",
+          password: serviceCredentials.password || "",
+          name: serviceCredentials.name || "hive"
+        }
+      );
+    } catch (error) {
+      console.error("loadConfiguration: Failed to parse database credentials.", error);
+    }
   }
 }
 
@@ -440,10 +457,47 @@ async function encryptAndStoreFile(data, fullPath, password) {
   await fs4.writeFile(fullPath, payload);
 }
 
+// Server/Utility/SaveConfiguration.js
+import path4 from "path";
+async function saveConfiguration(configurationObject) {
+  if (!configurationObject) {
+    console.error("saveConfiguration: No configuration object provided.");
+    return;
+  }
+  if (configurationObject.firebaseAdminCredentials) {
+    await encryptAndStoreFile(
+      JSON.stringify(configurationObject.firebaseAdminCredentials),
+      path4.join(getAppDataDirectory(), "firebase_admin_credentials.dat"),
+      process.env.SERVER_PASSWORD
+    );
+  }
+  if (configurationObject.databaseCredentials) {
+    await encryptAndStoreFile(
+      JSON.stringify(configurationObject.databaseCredentials),
+      path4.join(getAppDataDirectory(), "database_credentials.dat"),
+      process.env.SERVER_PASSWORD
+    );
+  }
+  if (configurationObject.permissions) {
+    await encryptAndStoreFile(
+      JSON.stringify(configurationObject.permissions),
+      path4.join(getAppDataDirectory(), "permissions.dat"),
+      process.env.SERVER_PASSWORD
+    );
+  }
+  if (configurationObject.smtpCredentials) {
+    await encryptAndStoreFile(
+      JSON.stringify(configurationObject.smtpCredentials),
+      path4.join(getAppDataDirectory(), "smtp_credentials.dat"),
+      process.env.SERVER_PASSWORD
+    );
+  }
+}
+
 // 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 databaseCredentials = process.env.DATABASE_CREDENTIALS ? JSON.parse(process.env.DATABASE_CREDENTIALS) : 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[HiveServerGlobals_default.getServiceName()] ? databaseCredentials[HiveServerGlobals_default.getServiceName()] : null;
@@ -487,7 +541,7 @@ async function promptPassword(promptText = "Enter password: ") {
 
 // Server/Utility/SetupPassword.js
 import fs5 from "fs";
-import path4 from "path";
+import path5 from "path";
 
 // Common/Utility/GetSha512Hash.js
 import { createHash } from "crypto";
@@ -498,7 +552,7 @@ function getSha512Hash(text) {
 // Server/Utility/SetupPassword.js
 async function setupPassword() {
   const appDataDirectory = getAppDataDirectory();
-  const passwordFilePath = path4.join(appDataDirectory, "password.dat");
+  const passwordFilePath = path5.join(appDataDirectory, "password.dat");
   let correctPassword = null;
   if (!fs5.existsSync(passwordFilePath)) {
     while (true) {
@@ -626,9 +680,9 @@ function getClientConnectionTypeFromHostname(hostname) {
 }
 
 // Common/Utility/GetHiveUrl.js
-async function getHiveUrl(path6) {
-  while (path6.startsWith("/")) {
-    path6 = path6.substring(1);
+async function getHiveUrl(path7) {
+  while (path7.startsWith("/")) {
+    path7 = path7.substring(1);
   }
   const connectionType = typeof window !== "undefined" ? getClientConnectionTypeFromHostname(window.location.hostname) : clientConnectionTypeFlags.LAN;
   const isLan = connectionType & clientConnectionTypeFlags.LAN ? true : false;
@@ -637,9 +691,9 @@ async function getHiveUrl(path6) {
   const response = await fetch(url, { method: "GET" });
   if (response.ok) {
     const hiveAddress = await response.json();
-    return hiveAddress + "/" + path6;
+    return hiveAddress + "/" + path7;
   }
-  return "http://127.0.0.1:49152/" + path6;
+  return "http://127.0.0.1:49152/" + path7;
 }
 
 // Server/Utility/ParseRequestBody.js
@@ -647,6 +701,7 @@ async function parseRequestBody(request) {
   if (typeof request.body == "object") {
     return request.body;
   }
+  let body = "";
   for await (const chunk of request) {
     body += chunk;
   }
@@ -661,6 +716,7 @@ async function parseRequestBody(request) {
 }
 
 // Server/RequestHandlers/HandleLogin.js
+var import_cookie = __toESM(require_dist(), 1);
 async function handleLogin(request, response) {
   await parseRequestBody(request);
   const userId = request.body.userId;
@@ -682,15 +738,17 @@ async function handleLogin(request, response) {
   } else if (loginResponse.status == 200) {
     const sessionTokenObject = await loginResponse.json();
     const sessionToken = sessionTokenObject.sessionToken;
-    response.cookie(
+    const cookieHeader = (0, import_cookie.serialize)(
       "sessionToken",
       sessionToken,
       {
         httpOnly: true,
         sameSite: "lax",
-        maxAge: 7 * 24 * 60 * 60 * 1e3
+        maxAge: 7 * 24 * 60 * 60,
+        path: "/"
       }
     );
+    response.setHeader("Set-Cookie", cookieHeader);
     if (!request.cookies["usesCookies"]) {
       response.setHeader("x-session-token", sessionToken);
     }
@@ -700,9 +758,12 @@ async function handleLogin(request, response) {
 }
 
 // Server/HandleHiveRequests.js
-import path5, { parse } from "path";
+import path6, { parse } from "path";
 import fs6 from "fs";
 
+// Server/Authentication/IsLoggedIn.js
+var import_cookie2 = __toESM(require_dist(), 1);
+
 // Server/Utility/ParseRequestCookies.js
 async function parseRequestCookies(request) {
   if (typeof request.cookies === "object") {
@@ -727,7 +788,6 @@ async function parseRequestCookies(request) {
 }
 
 // Server/Authentication/IsLoggedIn.js
-var import_cookie = __toESM(require_dist(), 1);
 async function isLoggedIn(request, response, bSendResponse = false) {
   await parseRequestCookies(request);
   const cookies = request.cookies;
@@ -760,7 +820,7 @@ async function isLoggedIn(request, response, bSendResponse = false) {
       const sessionJson = isLoggedInResponseJson.session;
       if (isLoggedInResponseJson.refresh) {
         const newSessionToken = sessionJson.sessionToken;
-        const cookieHeader = (0, import_cookie.serialize)(
+        const cookieHeader = (0, import_cookie2.serialize)(
           "sessionToken",
           newSessionToken,
           {
@@ -816,6 +876,7 @@ async function handleLogout(request, response) {
 }
 
 // Server/Authentication/IsLoggedInWithPermission.js
+var import_cookie3 = __toESM(require_dist(), 1);
 async function isLoggedInWithPermission(request, response, bSendResponse = false) {
   await parseRequestCookies(request);
   await parseRequestBody(request);
@@ -859,15 +920,17 @@ async function isLoggedInWithPermission(request, response, bSendResponse = false
       const sessionJson = isLoggedInResponseJson.session;
       if (isLoggedInResponseJson.refresh) {
         const newSessionToken = sessionJson.sessionToken;
-        response.cookie(
+        const cookieHeader = (0, import_cookie3.serialize)(
           "sessionToken",
           newSessionToken,
           {
             httpOnly: true,
             sameSite: "strict",
-            maxAge: 7 * 24 * 60 * 60 * 1e3
+            maxAge: 7 * 24 * 60 * 60,
+            path: "/"
           }
         );
+        response.setHeader("Set-Cookie", cookieHeader);
       }
     }
     if (bSendResponse) {
@@ -912,6 +975,37 @@ async function saveUserFilter(request, response) {
   response.end("Unauthorized");
 }
 
+// Server/RequestHandlers/PushNotificationToken.js
+async function pushNotificationToken(request, response) {
+  await parseRequestBody(request);
+  const notificationToken = request.body.notificationToken;
+  const sessionToken = request.cookies.sessionToken || request.headers["x-session-token"];
+  const deviceId = request.headers["x-device-id"];
+  const url = await getHiveUrl("/PushNotificationToken");
+  const pushResponse = await fetch(
+    url,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-device-id": deviceId,
+        "x-session-token": sessionToken
+      },
+      body: JSON.stringify({
+        notificationToken,
+        serviceName: process.env.SERVICE_NAME
+      })
+    }
+  );
+  if (pushResponse.ok) {
+    response.statusCode = 200;
+    response.end();
+  } else {
+    response.statusCode = 500;
+    response.end();
+  }
+}
+
 // Server/HandleHiveRequests.js
 async function handleHiveRequests(request, response, next) {
   const { url, method } = request;
@@ -934,8 +1028,11 @@ async function handleHiveRequests(request, response, next) {
     } else if (url === "/SaveUserFilter" && method === "POST") {
       await saveUserFilter(request, response);
       return;
+    } else if (url === "/PushNotificationToken" && method === "POST") {
+      pushNotificationToken(request, response);
+      return;
     } else if (url === "/hive-client.js") {
-      const filePath = path5.join(process.cwd(), "node_modules/@hivedev/hivesdk/hive-client.js");
+      const filePath = path6.join(process.cwd(), "node_modules/@hivedev/hivesdk/hive-client.js");
       const stream = fs6.createReadStream(filePath);
       stream.on("open", () => {
         response.writeHead(200, { "Content-Type": "application/javascript" });
@@ -1016,6 +1113,55 @@ async function findService(serviceName) {
     }, RESPONSE_TIMEOUT);
   });
 }
+
+// Server/Utility/RegisterService.js
+async function registerService() {
+  const serviceName = HiveServerGlobals_default.getServiceName();
+  HiveServerGlobals_default.setServiceUrls(
+    serviceName,
+    {
+      local: `http://${getHostIp()}:${HiveServerGlobals_default.getServicePort()}`,
+      remote: HiveServerGlobals_default.getRemoteUrl() || ""
+    }
+  );
+  const hiveUrl = await getHiveUrl("/RegisterService");
+  console.log("Registering service...");
+  const registrationResponse = await fetch(
+    hiveUrl,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ serviceName, urls: HiveServerGlobals_default.getServiceUrls(serviceName) })
+    }
+  );
+  if (registrationResponse.status != 200) {
+    console.log("Failed to register service.");
+    return;
+  }
+  const configurationUrl = await getHiveUrl("/Configuration");
+  const configurationInterval = setInterval(async () => {
+    const configurationResponse = await fetch(
+      configurationUrl,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ serviceName })
+      }
+    );
+    if (configurationResponse.ok) {
+      clearInterval(configurationInterval);
+      const encryptedConfiguration = await configurationResponse.text();
+      console.log("Configuration received.");
+      const decryptedConfiguration = await decryptDataWithPassword(Buffer.from(encryptedConfiguration, "base64"), process.env.SERVER_PASSWORD);
+      const configurationObject = JSON.parse(decryptedConfiguration);
+      console.log("Saving configuration...");
+      await saveConfiguration(configurationObject);
+      console.log("Service registered.");
+    } else {
+      console.log("Service registration hasn't been approved yet. Please contact administrators!");
+    }
+  }, 2e3);
+}
 export {
   decryptFileWithPassword,
   encryptAndStoreFile,
@@ -1029,6 +1175,8 @@ export {
   isLoggedInWithPermission,
   loadConfiguration,
   promptPassword,
+  registerService,
+  saveConfiguration,
   sendMail,
   setupPassword
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hivedev/hivesdk",
   "type": "module",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "scripts": {