erlc-api 2.3.3 → 3.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -1,134 +1,428 @@
-# ERLC API
+# 🚔 ER:LC API Wrapper
 
-A modern TypeScript/JavaScript API wrapper for ER:LC (Emergency Response: Liberty County) with full browser support.
+[![npm version](https://badge.fury.io/js/erlc-api.svg)](https://badge.fury.io/js/erlc-api)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Features
+A comprehensive, lightweight, and fully-typed API wrapper for Emergency Response: Liberty County (ER:LC) with 100% API coverage, robust error handling, and TypeScript support.
 
-- 🚀 Full TypeScript support
-- 🌐 Browser compatible
-- ⚡ Promise-based API
-- 🛡️ Comprehensive error handling
-- 📘 Type definitions included
-- 🔄 CommonJS and ES Module support
+## ✨ Features
 
-## Installation
+- 🎯 **100% API Coverage** - All ER:LC API endpoints supported
+- 🛡️ **Robust Error Handling** - Comprehensive error catching and meaningful error messages
+- 📝 **Full TypeScript Support** - Complete type definitions for all methods and responses
+- ⚡ **Optimized Performance** - Efficient request handling with timeout management
+- 🔒 **Secure** - Built-in validation and secure token handling
+- 📚 **Well Documented** - Extensive documentation and examples
+- 🚀 **Easy to Use** - Simple, intuitive API design
+
+## 📦 Installation
 
 ```bash
 npm install erlc-api
 ```
 
-## Usage
+```bash
+bun add erlc-api
+```
+
+## 🚀 Quick Start
 
-### TypeScript/ES Modules
+### Basic Setup
+
+```javascript
+const erlc = require("erlc-api");
+
+// Initialize the client with your global token
+const client = new erlc.Client({
+  globalToken: "your-global-token-here", // Get this from ER:LC developers
+});
+
+// Register your client
+client.config();
+```
+
+### TypeScript Setup
 
 ```typescript
-import { Client } from 'erlc-api';
+import erlc from "erlc-api";
 
-const client = new Client({
-  globalToken: 'your-global-token',
+const client = new erlc.Client({
+  globalToken: "your-global-token-here",
 });
 
-// Get server information
-const serverInfo = await client.getServer('server-token');
-console.log(serverInfo);
+client.config();
+```
+
+## 📖 API Methods
+
+### 🖥️ Server Information
+
+#### Get Server Details
 
-// Get players
-const players = await client.getPlayers('server-token');
-console.log(players);
+```javascript
+const getServerInfo = async () => {
+  try {
+    const serverToken = "your-server-api-key"; // From Server Settings
+    const server = await erlc.getServer(serverToken);
 
-//Run Command
-const Command = await client.runCommand('server-token', ':h Hello');
-console.log(Command);
+    console.log(server);
+    /*
+    Expected Response:
+    {
+      Name: "Your Server Name",
+      OwnerUsername: "ServerOwner",
+      CoOwnerUsernames: ["CoOwner1", "CoOwner2"],
+      CurrentPlayers: 25,
+      MaxPlayers: 40,
+      JoinKey: "ABC123",
+      AccVerifiedReq: "Disabled", // "Email" | "Phone/ID"
+      TeamBalance: true,
+      VanityURL: "https://policeroleplay.community/join?code=ABC123"
+    }
+    */
+  } catch (error) {
+    console.error("Error fetching server info:", error.message);
+  }
+};
 ```
 
-### CommonJS
+#### Get Current Players
 
 ```javascript
-const { Client } = require('erlc-api');
+const getCurrentPlayers = async () => {
+  try {
+    const players = await erlc.getPlayers(serverToken);
+
+    console.log(players);
+    /*
+    Expected Response:
+    [
+      {
+        Player: "PlayerName:123456789",
+        Permission: "Server Owner", // "Member" | "Moderator" | "Server Administrator"
+        Team: "Police" // "Civilian" | "Fire" | "Sheriff"
+      }
+    ]
+    */
+  } catch (error) {
+    console.error("Error fetching players:", error.message);
+  }
+};
+```
 
-const client = new Client({
-  globalToken: 'your-global-token',
-});
+#### Get Server Queue
 
-// Using async/await
-async function getServerInfo() {
+```javascript
+const getServerQueue = async () => {
   try {
-    const server = await client.getServer('server-token');
-    console.log(server);
+    const queue = await erlc.getQueue(serverToken);
+    console.log(`Players in queue: ${queue.length}`);
+  } catch (error) {
+    console.error("Error fetching queue:", error.message);
+  }
+};
+```
+
+### 👥 Staff Management
+
+#### Get Staff Information
+
+```javascript
+const getStaffInfo = async () => {
+  try {
+    const staff = await erlc.getStaff(serverToken);
+
+    console.log(staff);
+    /*
+    Expected Response:
+    {
+      CoOwners: [123456789, 987654321],
+      Admins: { "123456789": "AdminName" },
+      Mods: { "987654321": "ModName" }
+    }
+    */
   } catch (error) {
-    console.error('Error:', error.message);
+    console.error("Error fetching staff:", error.message);
   }
-}
+};
 ```
 
-### Browser
+### 📊 Server Logs
 
-```html
-<script src="node_modules/erlc-api/dist/browser/erlc.min.js"></script>
-<script>
-  const client = new ERLC.Client({
-    globalToken: 'your-global-token',
-  });
+#### Get Join/Leave Logs
 
-  client
-    .getServer('server-token')
-    .then((server) => console.log(server))
-    .catch((error) => console.error(error));
-</script>
+```javascript
+const getJoinLogs = async () => {
+  try {
+    const logs = await erlc.getJoinLogs(serverToken);
+
+    logs.forEach((log) => {
+      const action = log.Join ? "joined" : "left";
+      console.log(
+        `${log.Player} ${action} at ${new Date(log.Timestamp * 1000)}`
+      );
+    });
+  } catch (error) {
+    console.error("Error fetching join logs:", error.message);
+  }
+};
+```
+
+#### Get Kill Logs
+
+```javascript
+const getKillLogs = async () => {
+  try {
+    const kills = await erlc.getKillLogs(serverToken);
+
+    kills.forEach((kill) => {
+      console.log(
+        `${kill.Killer} killed ${kill.Killed} at ${new Date(
+          kill.Timestamp * 1000
+        )}`
+      );
+    });
+  } catch (error) {
+    console.error("Error fetching kill logs:", error.message);
+  }
+};
 ```
 
-## API Methods
+#### Get Command Logs
 
-- `getServer(serverToken)` - Get server information
-- `getPlayers(serverToken)` - Get list of players
-- `getJoinLogs(serverToken)` - Get join/leave logs
-- `getKillLogs(serverToken)` - Get kill logs
-- `getCommandLogs(serverToken)` - Get command logs
-- `getModcallLogs(serverToken)` - Get modcall logs
-- `getBans(serverToken)` - Get server bans
-- `getVehicles(serverToken)` - Get vehicle information
-- `getQueue(serverToken)` - Get queue information
-- `runCommand(serverToken, command)` - Run a server command
+```javascript
+const getCommandLogs = async () => {
+  try {
+    const commands = await erlc.getCommandLogs(serverToken);
 
-## Error Handling
+    commands.forEach((cmd) => {
+      console.log(`${cmd.Player} executed: ${cmd.Command}`);
+    });
+  } catch (error) {
+    console.error("Error fetching command logs:", error.message);
+  }
+};
+```
 
-The library includes custom error classes for better error handling:
+#### Get Moderator Call Logs
 
-```typescript
-import { AuthenticationError, ValidationError, NetworkError } from 'erlc-api';
-
-try {
-  await client.getServer('server-token');
-} catch (error) {
-  if (error instanceof AuthenticationError) {
-    console.error('Authentication failed');
-  } else if (error instanceof ValidationError) {
-    console.error('Invalid input');
-  } else if (error instanceof NetworkError) {
-    console.error('Network error occurred');
+```javascript
+const getModCalls = async () => {
+  try {
+    const modcalls = await erlc.getModcallLogs(serverToken);
+
+    modcalls.forEach((call) => {
+      const status = call.Moderator
+        ? `answered by ${call.Moderator}`
+        : "unanswered";
+      console.log(`${call.Caller} made a modcall - ${status}`);
+    });
+  } catch (error) {
+    console.error("Error fetching modcall logs:", error.message);
   }
-}
+};
 ```
 
-## Development
+### 🚗 Vehicle Management
 
-```bash
-# Install dependencies
-npm install
+#### Get Server Vehicles
+
+```javascript
+const getVehicles = async () => {
+  try {
+    const vehicles = await erlc.getVehicles(serverToken);
+
+    vehicles.forEach((vehicle) => {
+      console.log(
+        `${vehicle.Name} owned by ${vehicle.Owner} - Texture: ${
+          vehicle.Texture || "Default"
+        }`
+      );
+    });
+  } catch (error) {
+    console.error("Error fetching vehicles:", error.message);
+  }
+};
+```
+
+### 🔨 Server Management
+
+#### Execute Server Commands
+
+```javascript
+const executeCommand = async () => {
+  try {
+    const success = await erlc.runCommand(
+      serverToken,
+      ":h Welcome to our server!"
+    );
+
+    if (success) {
+      console.log("Command executed successfully!");
+    }
+  } catch (error) {
+    console.error("Error executing command:", error.message);
+  }
+};
+```
+
+#### Get Server Bans
+
+```javascript
+const getBannedPlayers = async () => {
+  try {
+    const bans = await erlc.getBans(serverToken);
+
+    Object.entries(bans).forEach(([playerId, playerName]) => {
+      console.log(`${playerName} (${playerId}) is banned`);
+    });
+  } catch (error) {
+    console.error("Error fetching bans:", error.message);
+  }
+};
+```
+
+## 🛠️ Advanced Usage
+
+### Error Handling Best Practices
+
+```javascript
+const handleApiCall = async () => {
+  try {
+    const result = await erlc.getServer(serverToken);
+    return result;
+  } catch (error) {
+    // Handle specific error types
+    if (error.status === 401) {
+      console.error("Authentication failed - check your tokens");
+    } else if (error.status === 404) {
+      console.error("Server not found - check your server token");
+    } else if (error.message.includes("Network error")) {
+      console.error("Connection issue - check your internet connection");
+    } else if (error.message.includes("timeout")) {
+      console.error("Request timed out - try again later");
+    } else {
+      console.error("Unexpected error:", error.message);
+    }
+
+    throw error; // Re-throw if needed
+  }
+};
+```
+
+### Batch Operations
+
+```javascript
+const getServerOverview = async (serverToken) => {
+  try {
+    // Execute multiple API calls concurrently
+    const [serverInfo, players, staff, vehicles] = await Promise.all([
+      erlc.getServer(serverToken),
+      erlc.getPlayers(serverToken),
+      erlc.getStaff(serverToken),
+      erlc.getVehicles(serverToken),
+    ]);
+
+    return {
+      server: serverInfo,
+      playerCount: players.length,
+      staffCount:
+        Object.keys(staff.Admins).length + Object.keys(staff.Mods).length,
+      vehicleCount: vehicles.length,
+    };
+  } catch (error) {
+    console.error("Error getting server overview:", error.message);
+    throw error;
+  }
+};
+```
+
+## 🔑 Authentication
+
+### Getting Your Tokens
+
+1. **Global Token**: Contact ER:LC developers through their [Discord](https://discord.gg/prc) to request increased API limits
+2. **Server Token**: Found in your server settings within ER:LC
+
+### Token Security
+
+```javascript
+// ❌ Don't hardcode tokens
+const client = new erlc.Client({
+  globalToken: "your-token-here",
+});
+
+// ✅ Use environment variables
+const client = new erlc.Client({
+  globalToken: process.env.ERLC_GLOBAL_TOKEN,
+});
+```
+
+## 📝 TypeScript Support
+
+The package includes comprehensive TypeScript definitions:
 
-# Run tests
-npm test
+```typescript
+import erlc, { ServerStatus, ServerPlayer, JoinLog } from "erlc-api";
 
-# Build
-npm run build
+const client = new erlc.Client({
+  globalToken: process.env.ERLC_GLOBAL_TOKEN!,
+});
 
-# Lint
-npm run lint
+client.config();
 
-# Format code
-npm run format
+// Fully typed responses
+const server: ServerStatus = await erlc.getServer(serverToken);
+const players: ServerPlayer[] = await erlc.getPlayers(serverToken);
+const joinLogs: JoinLog[] = await erlc.getJoinLogs(serverToken);
 ```
 
-## License
+## ⚡ Performance Tips
+
+1. **Use Promise.all()** for concurrent requests when fetching multiple endpoints
+2. **Implement caching** for frequently accessed data that doesn't change often
+3. **Handle rate limits** by implementing retry logic with exponential backoff
+4. **Use timeouts** - all methods have built-in 10-15 second timeouts
+
+## 🐛 Error Types
+
+The wrapper provides detailed error information:
+
+- **Network Errors**: Connection issues, DNS resolution failures
+- **Authentication Errors**: Invalid tokens, insufficient permissions
+- **API Errors**: Server-side errors with status codes and messages
+- **Validation Errors**: Invalid input parameters
+- **Timeout Errors**: Requests that take too long to complete
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🔗 Links
+
+- **Discord Bot**: [Invite to your server](https://discord.com/oauth2/authorize?client_id=1014990793280323624)
+- **API Documentation**: [PRC API Docs](https://apidocs.policeroleplay.community/reference/api-reference)
+- **Discord Support**: [Join PRC Discord](https://discord.gg/prc)
+- **Custom Liveries**: [Browse Collection](https://github.com/Exodo0/ERLC-API/tree/main/Custom%20Liveries)
+
+## 👨‍💻 Credits
+
+- **Library Development**: [Egologics](https://twitter.com/0Adexus0)
+- **NPM Package**: [ERLC-API](https://www.npmjs.com/package/erlc-api)
+- **API Development**: [Police Roleplay Community](https://twitter.com/PRC_Roblox)
+- **Community Support**: [PRC Discord Community](https://discord.gg/prc)
+
+---
 
-MIT License - see LICENSE file for details.
+<div align="center">
+  <p>Made with ❤️ for the ER:LC community</p>
+  <p>
+    <a href="https://github.com/Exodo0/ERLC-API">⭐ Star us on GitHub</a> •
+    <a href="https://discord.gg/prc">💬 Join our Discord</a> •
+    <a href="https://twitter.com/0Adexus0">🐦 Follow on Twitter</a>
+  </p>
+</div>

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./src/erlc')

package/package.json

@@ -1,38 +1,30 @@
 {
   "name": "erlc-api",
-  "version": "2.3.3",
-  "description": "A modern API wrapper for ER:LC with TypeScript and browser support",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/types/index.d.ts",
-  "browser": "dist/browser/erlc.min.js",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "npm run clean && npm run build:all",
-    "build:all": "npm run build:esm && npm run build:cjs && npm run build:browser && npm run build:types",
-    "build:esm": "tsc -p tsconfig.esm.json",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:browser": "webpack --config webpack.config.js",
-    "build:types": "tsc -p tsconfig.types.json",
-    "clean": "rimraf dist",
-    "test": "jest",
-    "lint": "eslint src --ext .ts",
-    "format": "prettier --write \"src/**/*.ts\"",
-    "docs": "typedoc"
-  },
+  "version": "3.0.0",
+  "description": "An ER:LC API wrapper for JS/TS",
+  "main": "index.js",
+  "types": "src/types/index.d.ts",
   "keywords": [
     "erlc",
     "roblox",
     "prc",
     "erlc-api",
-    "liberty-county",
-    "typescript",
-    "browser"
+    "liberty-county"
   ],
   "author": "egologics",
   "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.3.2"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "node-fetch": "^3.3.2",
+    "ora": "^8.2.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Exodo0/ERLC-API.git"
@@ -40,25 +32,5 @@
   "bugs": {
     "url": "https://github.com/Exodo0/ERLC-API/issues"
   },
-  "homepage": "https://github.com/Exodo0/ERLC-API#readme",
-  "devDependencies": {
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.1",
-    "@typescript-eslint/eslint-plugin": "^8.23.0",
-    "@typescript-eslint/parser": "^8.23.0",
-    "eslint": "^9.19.0",
-    "jest": "^29.7.0",
-    "prettier": "^3.4.2",
-    "rimraf": "^6.0.1",
-    "ts-jest": "^29.2.5",
-    "ts-loader": "^9.5.2",
-    "typedoc": "^0.27.6",
-    "typescript": "^5.7.3",
-    "webpack": "^5.97.1",
-    "webpack-cli": "^6.0.1"
-  },
-  "dependencies": {
-    "axios": "^1.7.9",
-    "erlc-api": "file:"
-  }
+  "homepage": "https://github.com/Exodo0/ERLC-API#readme"
 }

package/src/classes/client.js

@@ -0,0 +1,36 @@
+const erlc = require('../erlc.js')
+const assert = require('../functions/assert.js')
+
+/**
+ * @typedef {Object} ClientConfig
+ * @property {string} globalToken - Your ER:LC global API token
+ */
+
+/**
+ * Creates an authorised ER:LC client for requests
+ * @class
+ * @param {ClientConfig} options - Client Options
+ */
+
+class Client {
+
+    /**
+     * @constructor
+     * @param {ClientConfig} options - Client Options
+     */
+    constructor(options) {
+        assert(typeof options === 'object', `Syntax error: object expected for "options", received ${typeof options}`);
+        this.options = { ...options };
+      }
+    
+     /**
+     * Updates and returns the client configurationg
+     * @returns {ClientConfig} The client configuration.
+     */
+    config() {
+        erlc.config = this.options
+        return erlc.config
+    }
+}
+
+module.exports = Client

package/src/constants.js

@@ -0,0 +1,2 @@
+exports.Vanity = "https://policeroleplay.community/join?code="
+exports.BASEURL = "https://api.policeroleplay.community/v1"

package/src/erlc.js

@@ -0,0 +1,15 @@
+exports.config = {};
+
+exports.getBans = require("./functions/server/getBans.js");
+exports.getCommandLogs = require("./functions/server/getCommandLogs.js");
+exports.getJoinLogs = require("./functions/server/getJoinLogs.js");
+exports.getKillLogs = require("./functions/server/getKillLogs.js");
+exports.getModcallLogs = require("./functions/server/getModcallLogs.js");
+exports.getPlayers = require("./functions/server/getPlayers.js");
+exports.getServer = require("./functions/server/getServer.js");
+exports.getQueue = require("./functions/server/getQueue.js");
+exports.runCommand = require("./functions/server/runCommand.js");
+exports.getVehicles = require("./functions/server/getVehicles.js");
+exports.getStaff = require("./functions/server/getStaff.js");
+
+exports.Client = require("./classes/client.js");

package/src/functions/assert.js

@@ -0,0 +1,5 @@
+module.exports = function(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}