erlc-api 1.3.0

package/.gitattributes

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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 0Adexus0
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# ER:LC API Wrapper
+
+A lightweight API Wrapper with 100% coverage of the ER:LC API. Fixed Error and Improvements
+
+## Getting Started
+
+First you need to install the package.
+
+`npm i erlc`
+
+### Setting Up
+
+Setting up is super simple:
+
+```js
+// index.js
+
+const erlc = require("erlc");
+const client = new erlc.Client({
+  globalToken: "", // Here you enter your global token provided for the API
+});
+client.config(); // Registers your client
+```
+
+Now you can start using API Methods - here are a few examples:
+
+```js
+// api.js
+
+const erlc = require("erlc");
+
+const getServerFunc = async () => {
+  const serverId = ""; // The server ApiKey you wish to target
+  const server = await erlc.getServer(serverId).catch(console.log); // Gets the server, logs any errors
+
+  console.log(server); // Logs the server object
+};
+
+getServerFunc();
+```
+
+### [PRC API Docs](https://apidocs.policeroleplay.community/reference/api-reference)
+
+### Credits
+
+Library Re-Development - [Egologics](https://twitter.com/0Adexus0)
+API Development - [Police Roleplay Community](https://twitter.com/PRC_Roblox)

package/index.js

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

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "erlc-api",
+  "version": "1.3.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"
+  ],
+  "author": "egologics",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.3.2"
+  },
+  "dependencies": {
+    "node-fetch": "^3.3.2"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Exodo0/ERLC-API.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Exodo0/ERLC-API/issues"
+  },
+  "homepage": "https://github.com/Exodo0/ERLC-API#readme"
+}

package/src/classes/client.js

@@ -0,0 +1,38 @@
+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,13 @@
+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.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);
+    }
+}

package/src/functions/server/getBans.js

@@ -0,0 +1,28 @@
+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/bans`, {
+        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);
+    }
+  });
+};

package/src/functions/server/getCommandLogs.js

@@ -0,0 +1,28 @@
+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);
+    }
+  });
+};

package/src/functions/server/getJoinLogs.js

@@ -0,0 +1,28 @@
+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);
+    }
+  });
+};

package/src/functions/server/getKillLogs.js

@@ -0,0 +1,28 @@
+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);
+    }
+  });
+};

package/src/functions/server/getModcallLogs.js

@@ -0,0 +1,28 @@
+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);
+    }
+  });
+};

package/src/functions/server/getPlayers.js

@@ -0,0 +1,28 @@
+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);
+    }
+  });
+};

package/src/functions/server/getQueue.js

@@ -0,0 +1,28 @@
+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);
+    }
+  });
+};

package/src/functions/server/getServer.js

@@ -0,0 +1,54 @@
+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);
+    }
+  });
+};

package/src/functions/server/runCommand.js

@@ -0,0 +1,28 @@
+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}` });
+      console.log(params);
+      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) {
+        return reject(data);
+      }
+
+      resolve(true);
+    } catch (error) {
+      reject(error);
+    }
+  });
+};

package/src/types/custom.d.ts

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

package/src/types/index.d.ts

@@ -0,0 +1,74 @@
+declare module 'erlc' {
+    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
+
+    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 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 runCommand(serverToken: string, command: string): Promise<boolean>;
+
+    export class Client {
+        constructor(options: ClientConfig)
+        config(): ClientConfig;
+    }
+}