erlc-api 2.3.4 → 3.1.0

package/src/functions/server/getCommandLogs.js

@@ -1,28 +1,53 @@
-const { BASEURL } = require("../../constants.js");
-
-module.exports = (serverToken) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const fetch = await import("node-fetch");
-        const { config } = await import("../../erlc.js");
-  
-        const res = await fetch.default(`${BASEURL}/server/commandlogs`, {
-          headers: {
-            "Authorization": config?.globalToken,
-            "Server-Key": serverToken,
-          },
-        });
-        const data = await res.json().catch((err) => {
-          return reject(err);
-        });
-  
-        if (!res.ok) {
-          return reject(data);
-        }
-  
-        resolve(data);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
+const { BASEURL } = require("../../constants.js");
+const { processError } = require("../../utils/errorHandler.js");
+
+/**
+ * Retrieves command logs from a server
+ * @param {string} serverToken - The server API key
+ * @returns {Promise<Array>} Promise that resolves to array of command logs
+ */
+module.exports = (serverToken) => {
+  return new Promise(async (resolve, reject) => {
+    // Input validation
+    if (!serverToken || typeof serverToken !== "string") {
+      return reject(new Error("Server token is required and must be a string"));
+    }
+
+    try {
+      const fetch = await import("node-fetch");
+      const { config } = await import("../../erlc.js");
+
+      // Check if global token is configured
+      if (!config?.globalToken) {
+        const error = await processError(
+          new Error(
+            "Global token not configured. Please initialize the client first."
+          )
+        );
+        return reject(error);
+      }
+
+      const res = await fetch.default(`${BASEURL}/server/commandlogs`, {
+        headers: {
+          Authorization: config.globalToken,
+          "Server-Key": serverToken,
+        },
+        timeout: 10000, // 10 second timeout
+      });
+
+      if (!res.ok) {
+        const errorData = await res
+          .json()
+          .catch(() => ({ error: "Unknown API error" }));
+        const error = await processError(res, errorData);
+        return reject(error);
+      }
+
+      const data = await res.json();
+      resolve(Array.isArray(data) ? data : []);
+    } catch (error) {
+      const processedError = await processError(error);
+      reject(processedError);
+    }
+  });
+};

package/src/functions/server/getJoinLogs.js

@@ -1,28 +1,53 @@
-const { BASEURL } = require("../../constants.js");
-
-module.exports = (serverToken) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const fetch = await import("node-fetch");
-        const { config } = await import("../../erlc.js");
-  
-        const res = await fetch.default(`${BASEURL}/server/joinlogs`, {
-          headers: {
-            "Authorization": config?.globalToken,
-            "Server-Key": serverToken,
-          },
-        });
-        const data = await res.json().catch((err) => {
-          return reject(err);
-        });
-  
-        if (!res.ok) {
-          return reject(data);
-        }
-  
-        resolve(data);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
+const { BASEURL } = require("../../constants.js");
+const { processError } = require("../../utils/errorHandler.js");
+
+/**
+ * Retrieves join/leave logs from a server
+ * @param {string} serverToken - The server API key
+ * @returns {Promise<Array>} Promise that resolves to array of join logs
+ */
+module.exports = (serverToken) => {
+  return new Promise(async (resolve, reject) => {
+    // Input validation
+    if (!serverToken || typeof serverToken !== "string") {
+      return reject(new Error("Server token is required and must be a string"));
+    }
+
+    try {
+      const fetch = await import("node-fetch");
+      const { config } = await import("../../erlc.js");
+
+      // Check if global token is configured
+      if (!config?.globalToken) {
+        const error = await processError(
+          new Error(
+            "Global token not configured. Please initialize the client first."
+          )
+        );
+        return reject(error);
+      }
+
+      const res = await fetch.default(`${BASEURL}/server/joinlogs`, {
+        headers: {
+          Authorization: config.globalToken,
+          "Server-Key": serverToken,
+        },
+        timeout: 10000, // 10 second timeout
+      });
+
+      if (!res.ok) {
+        const errorData = await res
+          .json()
+          .catch(() => ({ error: "Unknown API error" }));
+        const error = await processError(res, errorData);
+        return reject(error);
+      }
+
+      const data = await res.json();
+      resolve(Array.isArray(data) ? data : []);
+    } catch (error) {
+      const processedError = await processError(error);
+      reject(processedError);
+    }
+  });
+};

package/src/functions/server/getKillLogs.js

@@ -1,28 +1,53 @@
-const { BASEURL } = require("../../constants.js");
-
-module.exports = (serverToken) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const fetch = await import("node-fetch");
-        const { config } = await import("../../erlc.js");
-  
-        const res = await fetch.default(`${BASEURL}/server/killlogs`, {
-          headers: {
-            "Authorization": config?.globalToken,
-            "Server-Key": serverToken,
-          },
-        });
-        const data = await res.json().catch((err) => {
-          return reject(err);
-        });
-  
-        if (!res.ok) {
-          return reject(data);
-        }
-  
-        resolve(data);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
+const { BASEURL } = require("../../constants.js");
+const { processError } = require("../../utils/errorHandler.js");
+
+/**
+ * Retrieves kill logs from a server
+ * @param {string} serverToken - The server API key
+ * @returns {Promise<Array>} Promise that resolves to array of kill logs
+ */
+module.exports = (serverToken) => {
+  return new Promise(async (resolve, reject) => {
+    // Input validation
+    if (!serverToken || typeof serverToken !== "string") {
+      return reject(new Error("Server token is required and must be a string"));
+    }
+
+    try {
+      const fetch = await import("node-fetch");
+      const { config } = await import("../../erlc.js");
+
+      // Check if global token is configured
+      if (!config?.globalToken) {
+        const error = await processError(
+          new Error(
+            "Global token not configured. Please initialize the client first."
+          )
+        );
+        return reject(error);
+      }
+
+      const res = await fetch.default(`${BASEURL}/server/killlogs`, {
+        headers: {
+          Authorization: config.globalToken,
+          "Server-Key": serverToken,
+        },
+        timeout: 10000, // 10 second timeout
+      });
+
+      if (!res.ok) {
+        const errorData = await res
+          .json()
+          .catch(() => ({ error: "Unknown API error" }));
+        const error = await processError(res, errorData);
+        return reject(error);
+      }
+
+      const data = await res.json();
+      resolve(Array.isArray(data) ? data : []);
+    } catch (error) {
+      const processedError = await processError(error);
+      reject(processedError);
+    }
+  });
+};

package/src/functions/server/getModcallLogs.js

@@ -1,28 +1,53 @@
-const { BASEURL } = require("../../constants.js");
-
-module.exports = (serverToken) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const fetch = await import("node-fetch");
-        const { config } = await import("../../erlc.js");
-  
-        const res = await fetch.default(`${BASEURL}/server/modcalls`, {
-          headers: {
-            "Authorization": config?.globalToken,
-            "Server-Key": serverToken,
-          },
-        });
-        const data = await res.json().catch((err) => {
-          return reject(err);
-        });
-  
-        if (!res.ok) {
-          return reject(data);
-        }
-  
-        resolve(data);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
+const { BASEURL } = require("../../constants.js");
+const { processError } = require("../../utils/errorHandler.js");
+
+/**
+ * Retrieves moderator call logs from a server
+ * @param {string} serverToken - The server API key
+ * @returns {Promise<Array>} Promise that resolves to array of modcall logs
+ */
+module.exports = (serverToken) => {
+  return new Promise(async (resolve, reject) => {
+    // Input validation
+    if (!serverToken || typeof serverToken !== "string") {
+      return reject(new Error("Server token is required and must be a string"));
+    }
+
+    try {
+      const fetch = await import("node-fetch");
+      const { config } = await import("../../erlc.js");
+
+      // Check if global token is configured
+      if (!config?.globalToken) {
+        const error = await processError(
+          new Error(
+            "Global token not configured. Please initialize the client first."
+          )
+        );
+        return reject(error);
+      }
+
+      const res = await fetch.default(`${BASEURL}/server/modcalls`, {
+        headers: {
+          Authorization: config.globalToken,
+          "Server-Key": serverToken,
+        },
+        timeout: 10000, // 10 second timeout
+      });
+
+      if (!res.ok) {
+        const errorData = await res
+          .json()
+          .catch(() => ({ error: "Unknown API error" }));
+        const error = await processError(res, errorData);
+        return reject(error);
+      }
+
+      const data = await res.json();
+      resolve(Array.isArray(data) ? data : []);
+    } catch (error) {
+      const processedError = await processError(error);
+      reject(processedError);
+    }
+  });
+};

package/src/functions/server/getPlayers.js

@@ -1,28 +1,53 @@
-const { BASEURL } = require("../../constants.js");
-
-module.exports = (serverToken) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const fetch = await import("node-fetch");
-        const { config } = await import("../../erlc.js");
-  
-        const res = await fetch.default(`${BASEURL}/server/players`, {
-          headers: {
-            "Authorization": config?.globalToken,
-            "Server-Key": serverToken,
-          },
-        });
-        const data = await res.json().catch((err) => {
-          return reject(err);
-        });
-  
-        if (!res.ok) {
-          return reject(data);
-        }
-  
-        resolve(data);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
+const { BASEURL } = require("../../constants.js");
+const { processError } = require("../../utils/errorHandler.js");
+
+/**
+ * Retrieves current players from a server
+ * @param {string} serverToken - The server API key
+ * @returns {Promise<Array>} Promise that resolves to array of current players
+ */
+module.exports = (serverToken) => {
+  return new Promise(async (resolve, reject) => {
+    // Input validation
+    if (!serverToken || typeof serverToken !== "string") {
+      return reject(new Error("Server token is required and must be a string"));
+    }
+
+    try {
+      const fetch = await import("node-fetch");
+      const { config } = await import("../../erlc.js");
+
+      // Check if global token is configured
+      if (!config?.globalToken) {
+        const error = await processError(
+          new Error(
+            "Global token not configured. Please initialize the client first."
+          )
+        );
+        return reject(error);
+      }
+
+      const res = await fetch.default(`${BASEURL}/server/players`, {
+        headers: {
+          Authorization: config.globalToken,
+          "Server-Key": serverToken,
+        },
+        timeout: 10000, // 10 second timeout
+      });
+
+      if (!res.ok) {
+        const errorData = await res
+          .json()
+          .catch(() => ({ error: "Unknown API error" }));
+        const error = await processError(res, errorData);
+        return reject(error);
+      }
+
+      const data = await res.json();
+      resolve(Array.isArray(data) ? data : []);
+    } catch (error) {
+      const processedError = await processError(error);
+      reject(processedError);
+    }
+  });
+};

package/src/functions/server/getQueue.js

@@ -1,28 +1,53 @@
-const { BASEURL } = require("../../constants.js");
-
-module.exports = (serverToken) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const fetch = await import("node-fetch");
-        const { config } = await import("../../erlc.js");
-  
-        const res = await fetch.default(`${BASEURL}/server/queue`, {
-          headers: {
-            "Authorization": config?.globalToken,
-            "Server-Key": serverToken,
-          },
-        });
-        const data = await res.json().catch((err) => {
-          return reject(err);
-        });
-  
-        if (!res.ok) {
-          return reject(data);
-        }
-  
-        resolve(data);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
+const { BASEURL } = require("../../constants.js");
+const { processError } = require("../../utils/errorHandler.js");
+
+/**
+ * Retrieves server queue information
+ * @param {string} serverToken - The server API key
+ * @returns {Promise<Array>} Promise that resolves to array of queued player IDs
+ */
+module.exports = (serverToken) => {
+  return new Promise(async (resolve, reject) => {
+    // Input validation
+    if (!serverToken || typeof serverToken !== "string") {
+      return reject(new Error("Server token is required and must be a string"));
+    }
+
+    try {
+      const fetch = await import("node-fetch");
+      const { config } = await import("../../erlc.js");
+
+      // Check if global token is configured
+      if (!config?.globalToken) {
+        const error = await processError(
+          new Error(
+            "Global token not configured. Please initialize the client first."
+          )
+        );
+        return reject(error);
+      }
+
+      const res = await fetch.default(`${BASEURL}/server/queue`, {
+        headers: {
+          Authorization: config.globalToken,
+          "Server-Key": serverToken,
+        },
+        timeout: 10000, // 10 second timeout
+      });
+
+      if (!res.ok) {
+        const errorData = await res
+          .json()
+          .catch(() => ({ error: "Unknown API error" }));
+        const error = await processError(res, errorData);
+        return reject(error);
+      }
+
+      const data = await res.json();
+      resolve(Array.isArray(data) ? data : []);
+    } catch (error) {
+      const processedError = await processError(error);
+      reject(processedError);
+    }
+  });
+};

package/src/functions/server/getServer.js

@@ -1,52 +1,105 @@
-const { BASEURL , Vanity} = require("../../constants.js");
-module.exports = (serverToken) => {
-  return new Promise(async (resolve, reject) => {
-    try {
-      const fetch = await import("node-fetch");
-      const { config } = await import("../../erlc.js");
-
-      const res = await fetch.default(`${BASEURL}/server`, {
-        headers: {
-          "Authorization": config?.globalToken,
-          "Server-Key": serverToken,
-        },
-      });
-
-      const data = await res.json().catch((err) => {
-        return reject(err);
-      });
-
-      if (!res.ok) {
-        return reject(data);
-      }
-      const getUsername = async (userId) => {
-        const response = await fetch.default(`https://users.roblox.com/v1/users/${userId}`);
-        const userData = await response.json();
-        if (!response.ok) {
-          throw new Error(`Error fetching username for ID: ${userId}`);
-        }
-        return userData.name;
-      };
-      try {
-        const ownerUsername = await getUsername(data.OwnerId);
-        const coOwnerUsernames = await Promise.all(data.CoOwnerIds.map(getUsername));
-        const VanityURL = `${Vanity}${data.JoinKey}`
-   
-
-        data.OwnerUsername = ownerUsername;
-        data.CoOwnerUsernames = coOwnerUsernames;
-        data.VanityURL = VanityURL
-
-        delete data.OwnerId;
-        delete data.CoOwnerIds;
-
-        resolve(data);
-      } catch (error) {
-        reject(error);
-      }
-
-    } catch (error) {
-      reject(error);
-    }
-  });
-};
+const { BASEURL, Vanity } = require("../../constants.js");
+const { processError } = require("../../utils/errorHandler.js");
+
+module.exports = (serverToken) => {
+  return new Promise(async (resolve, reject) => {
+    // Input validation
+    if (!serverToken || typeof serverToken !== "string") {
+      return reject(new Error("Server token is required and must be a string"));
+    }
+
+    try {
+      const fetch = await import("node-fetch");
+      const { config } = await import("../../erlc.js");
+
+      // Check if global token is configured
+      if (!config?.globalToken) {
+        return reject(
+          new Error(
+            "Global token not configured. Please initialize the client first."
+          )
+        );
+      }
+
+      const res = await fetch.default(`${BASEURL}/server`, {
+        headers: {
+          Authorization: config?.globalToken,
+          "Server-Key": serverToken,
+        },
+        timeout: 10000, // 10 second timeout
+      });
+
+      if (!res.ok) {
+        const errorData = await res
+          .json()
+          .catch(() => ({ error: "Unknown API error" }));
+        const error = await processError(res, errorData);
+        return reject(error);
+      }
+
+      const data = await res.json();
+
+      const getUsername = async (userId) => {
+        try {
+          const response = await fetch.default(
+            `https://users.roblox.com/v1/users/${userId}`
+          );
+          const userData = await response.json();
+          if (!response.ok) {
+            console.warn(`Warning: Could not fetch username for ID: ${userId}`);
+            return `User:${userId}`; // Fallback format
+          }
+          return userData.name;
+        } catch (error) {
+          console.warn(
+            `Warning: Error fetching username for ID: ${userId}`,
+            error
+          );
+          return `User:${userId}`; // Fallback format
+        }
+      };
+
+      try {
+        // Get owner username
+        const ownerUsername = await getUsername(data.OwnerId);
+
+        // Get co-owner usernames (handle empty array case)
+        const coOwnerUsernames =
+          data.CoOwnerIds && data.CoOwnerIds.length > 0
+            ? await Promise.all(data.CoOwnerIds.map(getUsername))
+            : [];
+
+        // Create vanity URL
+        const vanityURL = `${Vanity}${data.JoinKey}`;
+
+        // Add the new properties to the response
+        const enhancedData = {
+          ...data,
+          OwnerUsername: ownerUsername,
+          CoOwnerUsernames: coOwnerUsernames,
+          VanityURL: vanityURL,
+        };
+
+        // Remove the original ID properties as they're now converted to usernames
+        delete enhancedData.OwnerId;
+        delete enhancedData.CoOwnerIds;
+
+        resolve(enhancedData);
+      } catch (error) {
+        // If username fetching fails, still return the original data with IDs
+        console.warn(
+          "Warning: Could not fetch usernames, returning data with IDs:",
+          error
+        );
+        const fallbackData = {
+          ...data,
+          VanityURL: `${Vanity}${data.JoinKey}`,
+        };
+        resolve(fallbackData);
+      }
+    } catch (error) {
+      const processedError = await processError(error);
+      reject(processedError);
+    }
+  });
+};