erlc-api 2.3.4 → 3.0.0

package/src/functions/server/getServer.js

@@ -1,52 +1,78 @@
-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");
+
+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) => {
+        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) {
+      reject(error);
+    }
+  });
 };

package/src/functions/server/getStaff.js

@@ -0,0 +1,54 @@
+const { BASEURL } = require("../../constants.js");
+
+/**
+ * Retrieves server staff information
+ * @param {string} serverToken - The server API key
+ * @returns {Promise<Object>} Promise that resolves to server staff object
+ */
+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/staff`, {
+        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 = new Error(`API Error: ${res.status} - ${errorData.error || res.statusText}`);
+        error.status = res.status;
+        error.data = errorData;
+        return reject(error);
+      }
+
+      const data = await res.json();
+      resolve(data || { CoOwners: [], Admins: {}, Mods: {} });
+
+    } catch (error) {
+      // Handle different types of errors
+      if (error.code === 'ENOTFOUND') {
+        reject(new Error('Network error: Unable to connect to ER:LC API'));
+      } else if (error.name === 'AbortError') {
+        reject(new Error('Request timeout: API took too long to respond'));
+      } else {
+        reject(error);
+      }
+    }
+  });
+};

package/src/functions/server/getVehicles.js

@@ -1,28 +1,54 @@
-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/vehicles`, {
-        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");
+
+/**
+ * Retrieves server vehicles information
+ * @param {string} serverToken - The server API key
+ * @returns {Promise<Array>} Promise that resolves to array of vehicles
+ */
+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/vehicles`, {
+        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 = new Error(`API Error: ${res.status} - ${errorData.error || res.statusText}`);
+        error.status = res.status;
+        error.data = errorData;
+        return reject(error);
+      }
+
+      const data = await res.json();
+      resolve(Array.isArray(data) ? data : []);
+
+    } catch (error) {
+      // Handle different types of errors
+      if (error.code === 'ENOTFOUND') {
+        reject(new Error('Network error: Unable to connect to ER:LC API'));
+      } else if (error.name === 'AbortError') {
+        reject(new Error('Request timeout: API took too long to respond'));
+      } else {
+        reject(error);
+      }
+    }
+  });
+};

package/src/functions/server/runCommand.js

@@ -1,29 +1,70 @@
-const { BASEURL } = require("../../constants.js");
-
-module.exports = (serverToken, command) => {
-  return new Promise(async (resolve, reject) => {
-    try {
-      const fetch = await import("node-fetch");
-      const { config } = await import("../../erlc.js");
-      const params = JSON.stringify({ command: `${command}` });
-      const res = await fetch.default(`${BASEURL}/server/command`, {
-        headers: {
-          Authorization: config?.globalToken,
-          "Server-Key": serverToken,
-          "Content-Type": "application/json",
-        },
-        method: "POST",
-        body: params,
-      });
-
-      if (!res.ok) {
-        const errorData = await res.json(); 
-        return reject(errorData); 
-      }
-
-      resolve(true);
-    } catch (error) {
-      reject(error);
-    }
-  });
-};
+const { BASEURL } = require("../../constants.js");
+
+/**
+ * Executes a command on the server
+ * @param {string} serverToken - The server API key
+ * @param {string} command - The command to execute
+ * @returns {Promise<boolean>} Promise that resolves to true if command was executed successfully
+ */
+module.exports = (serverToken, command) => {
+  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'));
+    }
+
+    if (!command || typeof command !== 'string') {
+      return reject(new Error('Command is required and must be a string'));
+    }
+
+    if (command.trim().length === 0) {
+      return reject(new Error('Command cannot be empty'));
+    }
+
+    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 requestBody = JSON.stringify({ command: command.trim() });
+
+      const res = await fetch.default(`${BASEURL}/server/command`, {
+        method: "POST",
+        headers: {
+          "Authorization": config.globalToken,
+          "Server-Key": serverToken,
+          "Content-Type": "application/json",
+        },
+        body: requestBody,
+        timeout: 15000, // 15 second timeout for commands
+      });
+
+      if (!res.ok) {
+        const errorData = await res.json().catch(() => ({ error: 'Unknown API error' }));
+        const error = new Error(`Command execution failed: ${res.status} - ${errorData.error || res.statusText}`);
+        error.status = res.status;
+        error.data = errorData;
+        return reject(error);
+      }
+
+      // Command executed successfully
+      resolve(true);
+
+    } catch (error) {
+      // Handle different types of errors
+      if (error.code === 'ENOTFOUND') {
+        reject(new Error('Network error: Unable to connect to ER:LC API'));
+      } else if (error.name === 'AbortError') {
+        reject(new Error('Request timeout: Command took too long to execute'));
+      } else if (error.message.includes('JSON')) {
+        reject(new Error('Invalid command format'));
+      } else {
+        reject(error);
+      }
+    }
+  });
+};

package/src/types/custom.d.ts

@@ -1,5 +1,5 @@
-declare module 'NodeModule' {
-    interface NodeModule {
-      type?: string;
-    }
+declare module 'NodeModule' {
+    interface NodeModule {
+      type?: string;
+    }
   }

package/src/types/index.d.ts

@@ -1,91 +1,98 @@
-declare module "erlc-api" {
-  export interface ClientConfig {
-    globalToken: string; // The ER:LC global API token
-  }
-
-  export const BASEURL = "https://api.policeroleplay.community/v1";
-
-  type PlayerId = string;
-  type PlayerName = string;
-  type TextureName = string;
-  type CarName = string;
-
-  export type ErlcPlayer = `${PlayerName}:${PlayerId}`; // Playername:UserID
-  export type ErlcPlayerPermission =
-    | "Normal"
-    | "Server Administrator"
-    | "Server Owner"
-    | "Server Moderator";
-
-  export interface ServerStatus {
-    Name: string; // The server name
-    OwnerId: number; // The roblox id of the server owner
-    CoOwnerIds: number[]; // The roblox ids of the server co owners
-    CurrentPlayers: number; // The amount of people currently in-game
-    MaxPlayers: number; // The amount of people who can join the server including server owner
-    JoinKey: string; // The code used to join the private server
-    AccVerifiedReq: "Disabled" | "Email" | "Phone/ID"; // The level of verification roblox accounts need to join the private server
-    TeamBalance: boolean; // If team balance is enabled or not
-  }
-
-  export interface ServerPlayer {
-    Player: ErlcPlayer;
-    Permission: ErlcPlayerPermission;
-  }
-
-  export interface JoinLog {
-    Join: boolean; // True is join and False is leave
-    Timestamp: number; // Timestamp in seconds
-    Player: ErlcPlayer;
-  }
-
-  export interface KillLog {
-    Killed: ErlcPlayer;
-    Timestamp: number; // Timestamp in seconds
-    Killer: ErlcPlayer;
-  }
-
-  export interface CommandLog {
-    Player: ErlcPlayer;
-    Timestamp: number; // Timestamp in seconds
-    Command: string;
-  }
-
-  export interface ModcallLog {
-    Caller: ErlcPlayer;
-    Moderator?: ErlcPlayer; // If call is unanswered property is undefined
-    Timestamp: number; // Timestamp in seconds
-  }
-
-  export type ServerBan = Record<PlayerId, PlayerName>;
-
-  export interface VehiclesLog {
-    Texture: string | null;
-    Name: string;
-    Owner: ErlcPlayer;
-  }
-
-  export interface VSMCommandBody {
-    command: string; // ":h Hey everyone!"
-  }
-
-
-  export function getBans(serverToken: string): Promise<ServerBan>;
-  export function getCommandLogs(serverToken: string): Promise<CommandLog[]>;
-  export function getJoinLogs(serverToken: string): Promise<JoinLog[]>;
-  export function getKillLogs(serverToken: string): Promise<KillLog[]>;
-  export function getModcallLogs(serverToken: string): Promise<ModcallLog[]>;
-  export function getPlayers(serverToken: string): Promise<ServerPlayer[]>;
-  export function getQueue(serverToken: string): Promise<number[]>;
-  export function getServer(serverToken: string): Promise<ServerStatus>;
-  export function getVehicles(serverToken: string): Promise<VehiclesLog[]>;
-  export function runCommand(
-    serverToken: string,
-    command: string
-  ): Promise<boolean>;
-
-  export class Client {
-    constructor(options: ClientConfig);
-    config(): ClientConfig;
-  }
-}
+declare module "erlc-api" {
+  export interface ClientConfig {
+    globalToken: string; // The ER:LC global API token
+  }
+
+  export const BASEURL = "https://api.policeroleplay.community/v1";
+
+  type PlayerId = string;
+  type PlayerName = string;
+  type TextureName = string;
+  type CarName = string;
+
+  export type ErlcPlayer = `${PlayerName}:${PlayerId}`; // Playername:UserID
+  export type ErlcPlayerPermission =
+    | "Normal"
+    | "Server Administrator"
+    | "Server Owner"
+    | "Server Moderator";
+
+  export interface ServerStatus {
+    Name: string; // The server name
+    OwnerUsername: string; // The username of the server owner
+    CoOwnerUsernames: string[]; // The usernames of the server co owners
+    CurrentPlayers: number; // The amount of people currently in-game
+    MaxPlayers: number; // The amount of people who can join the server including server owner
+    JoinKey: string; // The code used to join the private server
+    AccVerifiedReq: "Disabled" | "Email" | "Phone/ID"; // The level of verification roblox accounts need to join the private server
+    TeamBalance: boolean; // If team balance is enabled or not
+    VanityURL: string; // The vanity URL to join the server
+  }
+
+  export interface ServerPlayer {
+    Player: ErlcPlayer;
+    Permission: ErlcPlayerPermission;
+  }
+
+  export interface JoinLog {
+    Join: boolean; // True is join and False is leave
+    Timestamp: number; // Timestamp in seconds
+    Player: ErlcPlayer;
+  }
+
+  export interface KillLog {
+    Killed: ErlcPlayer;
+    Timestamp: number; // Timestamp in seconds
+    Killer: ErlcPlayer;
+  }
+
+  export interface CommandLog {
+    Player: ErlcPlayer;
+    Timestamp: number; // Timestamp in seconds
+    Command: string;
+  }
+
+  export interface ModcallLog {
+    Caller: ErlcPlayer;
+    Moderator?: ErlcPlayer; // If call is unanswered property is undefined
+    Timestamp: number; // Timestamp in seconds
+  }
+
+  export type ServerBan = Record<PlayerId, PlayerName>;
+
+  export interface VehiclesLog {
+    Texture: string | null;
+    Name: string;
+    Owner: ErlcPlayer;
+  }
+
+  export interface ServerStaff {
+    CoOwners: number[];
+    Admins: Record<string, string>;
+    Mods: Record<string, string>;
+  }
+
+  export interface VSMCommandBody {
+    command: string; // ":h Hey everyone!"
+  }
+
+  export function getBans(serverToken: string): Promise<ServerBan>;
+  export function getCommandLogs(serverToken: string): Promise<CommandLog[]>;
+  export function getJoinLogs(serverToken: string): Promise<JoinLog[]>;
+  export function getKillLogs(serverToken: string): Promise<KillLog[]>;
+  export function getModcallLogs(serverToken: string): Promise<ModcallLog[]>;
+  export function getPlayers(serverToken: string): Promise<ServerPlayer[]>;
+  export function getQueue(serverToken: string): Promise<number[]>;
+  export function getServer(serverToken: string): Promise<ServerStatus>;
+  export function getStaff(serverToken: string): Promise<ServerStaff>;
+  export function getVehicles(serverToken: string): Promise<VehiclesLog[]>;
+  export function runCommand(
+    serverToken: string,
+    command: string
+  ): Promise<boolean>;
+
+  export class Client {
+    constructor(options: ClientConfig);
+    config(): ClientConfig;
+  }
+}