erlc-v2 1.0.1 → 1.1.0

package/index.d.ts

@@ -49,6 +49,17 @@ export interface PollingOptions {
   bypassCache?: boolean;
 }
 
+export interface ApiServerOptions {
+  enabled?: boolean;
+  host?: string;
+  port?: number;
+  path?: string;
+  webhookPath?: string;
+  publicUrl?: string;
+  token?: string;
+  logRequests?: boolean;
+}
+
 export interface ClientOptions {
   serverKey: string;
   globalKey?: string;
@@ -57,6 +68,7 @@ export interface ClientOptions {
   cache?: CacheOptions;
   rateLimit?: RateLimitOptions;
   polling?: PollingOptions;
+  api?: ApiServerOptions;
 }
 
 export interface ServerFetchFlags {
@@ -67,6 +79,7 @@ export interface ServerFetchFlags {
   killLogs?: boolean;
   commandLogs?: boolean;
   modCalls?: boolean;
+  emergencyCalls?: boolean;
   vehicles?: boolean;
 }
 
@@ -85,6 +98,8 @@ export interface CommandExecuteResult {
   status: number;
   endpoint: string;
   bucket: string;
+  message: string | null;
+  commandId: string | null;
   rateLimit: {
     limit: number;
     remaining: number;
@@ -92,6 +107,102 @@ export interface CommandExecuteResult {
   };
 }
 
+export interface VehicleData {
+  Name?: string;
+  Owner?: string;
+  Plate?: string;
+  Texture?: string | null;
+  ColorHex?: string;
+  ColorName?: string;
+  [key: string]: any;
+}
+
+export interface EmergencyCallData {
+  Team?: string;
+  Caller?: number;
+  Players?: number[];
+  Position?: number[];
+  StartedAt?: number;
+  CallNumber?: number;
+  Description?: string;
+  PositionDescriptor?: string;
+  [key: string]: any;
+}
+
+export interface VehicleSearchFilters {
+  query?: string;
+  search?: string;
+  plate?: string;
+  owner?: string;
+  name?: string;
+  color?: string;
+  colorName?: string;
+  texture?: string;
+  exact?: boolean;
+  limit?: number;
+}
+
+export interface ApiServerInfo {
+  running: boolean;
+  host: string;
+  port: number | null;
+  path: string;
+  webhookPath: string;
+  localUrl: string | null;
+  webhookUrl: string | null;
+  publicUrl: string | null;
+  tokenEnabled: boolean;
+}
+
+export interface WebhookPayload {
+  type: "command" | "emergencyCall" | "verification" | "unknown";
+  body: Record<string, any>;
+  timestamp: string | null;
+  signature: string | null;
+  rawBody: Buffer | null;
+  headers: Record<string, any>;
+  server: string | null;
+  events: Array<{
+    event: string | null;
+    origin: string | null;
+    eventTimestamp: number | null;
+    data: Record<string, any>;
+    command: string | null;
+    argument: string;
+    args: string;
+  }>;
+  entry: {
+    event: string | null;
+    origin: string | null;
+    eventTimestamp: number | null;
+    data: Record<string, any>;
+    command: string | null;
+    argument: string;
+    args: string;
+  } | null;
+  event: string | null;
+  origin: string | null;
+  eventTimestamp: number | null;
+  data: Record<string, any> | null;
+  command: string | null;
+  argument: string;
+  args: string;
+}
+
+export interface ApiRequestPayload {
+  method: string;
+  path: string;
+  query: Record<string, string>;
+  kind: "route" | "webhook";
+  status: number;
+  type: string | null;
+  body: any;
+  note: string;
+  tookMs: number;
+  ip: string | string[] | null;
+  at: string;
+}
+
 export interface MapCoordinateBounds {
   minX: number;
   maxX: number;
@@ -173,7 +284,8 @@ export interface ServerResponse {
   killLogs: any[];
   commandLogs: any[];
   modCalls: any[];
-  vehicles: any[];
+  emergencyCalls: EmergencyCallData[];
+  vehicles: VehicleData[];
   raw: Record<string, any>;
   meta: {
     status: number;
@@ -249,6 +361,9 @@ export class Client extends EventEmitter {
     joins: (requestOptions?: RequestOptions) => Promise<any[]>;
     commands: (requestOptions?: RequestOptions) => Promise<any[]>;
     modCalls: (requestOptions?: RequestOptions) => Promise<any[]>;
+    emergencyCalls: (
+      requestOptions?: RequestOptions,
+    ) => Promise<EmergencyCallData[]>;
   };
   commands: {
     execute: (
@@ -257,11 +372,32 @@ export class Client extends EventEmitter {
     ) => Promise<CommandExecuteResult>;
   };
   vehicles: {
-    list: (requestOptions?: RequestOptions) => Promise<any[]>;
+    list: (requestOptions?: RequestOptions) => Promise<VehicleData[]>;
+    search: (
+      filters?: string | VehicleSearchFilters,
+      requestOptions?: RequestOptions,
+    ) => Promise<VehicleData[]>;
+    findByPlate: (
+      plate: string,
+      requestOptions?: RequestOptions,
+    ) => Promise<VehicleData | null>;
+    findByOwner: (
+      owner: string,
+      requestOptions?: RequestOptions,
+    ) => Promise<VehicleData[]>;
+    findOne: (
+      filters?: string | VehicleSearchFilters,
+      requestOptions?: RequestOptions,
+    ) => Promise<VehicleData | null>;
   };
   queue: {
     get: (requestOptions?: RequestOptions) => Promise<any[]>;
   };
+  api: {
+    start: () => Promise<ApiServerInfo>;
+    stop: () => void;
+    info: () => ApiServerInfo;
+  };
   onReady(listener: (...args: any[]) => void): this;
   onJoin(listener: (...args: any[]) => void): this;
   onLeave(listener: (...args: any[]) => void): this;
@@ -271,9 +407,14 @@ export class Client extends EventEmitter {
   onQueueUpdate(listener: (...args: any[]) => void): this;
   onStaffUpdate(listener: (...args: any[]) => void): this;
   onModCall(listener: (...args: any[]) => void): this;
+  onEmergencyCall(listener: (...args: any[]) => void): this;
   onCommandLog(listener: (...args: any[]) => void): this;
   onLogCommand(listener: (...args: any[]) => void): this;
   onServerUpdate(listener: (...args: any[]) => void): this;
+  onApiRequest(listener: (payload: ApiRequestPayload) => void): this;
+  onWebhook(listener: (payload: WebhookPayload) => void): this;
+  onWebhookCommand(listener: (payload: WebhookPayload) => void): this;
+  onWebhookEmergencyCall(listener: (payload: WebhookPayload) => void): this;
   onError(listener: (...args: any[]) => void): this;
   onDisconnect(listener: (...args: any[]) => void): this;
   destroy(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erlc-v2",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Premium, lightweight JavaScript wrapper for the ER:LC API v2.",
   "main": "index.js",
   "module": "index.mjs",
@@ -23,9 +23,12 @@
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "test:map": "node test-map-render.js"
-  },
+  "scripts": {
+    "test:map": "node test-map-render.js",
+    "dev:api": "node scripts/start-api.js",
+    "test:api": "node scripts/check-api.js",
+    "test:features": "node scripts/test-features.js"
+  },
   "dependencies": {
     "@napi-rs/canvas": "^0.1.74"
   },

package/src/Client.js

@@ -2,11 +2,13 @@ const { EventEmitter } = require("events");
 const Cache = require("./cache/Cache");
 const RequestManager = require("./rest/RequestManager");
 const Poller = require("./events/Poller");
+const LocalApiServer = require("./api/LocalApiServer");
 const { DEFAULT_OPTIONS, QUERY_FLAG_MAP } = require("./util/constants");
 const { mergeOptions } = require("./util/options");
 const { createLogger } = require("./util/logger");
 const { normalizeServerResponse } = require("./util/normalize");
 const { renderPlayerMap } = require("./map/renderPlayerMap");
+const { searchVehicles, findVehicleByPlate } = require("./util/vehicleSearch");
 const { ERLCError } = require("./errors");
 
 const BASE_URL = "https://api.policeroleplay.community";
@@ -37,9 +39,14 @@ const EVENT_ALIASES = {
   onQueueUpdate: "queueUpdate",
   onStaffUpdate: "staffUpdate",
   onModCall: "modCall",
+  onEmergencyCall: "emergencyCall",
   onCommandLog: "commandLog",
   onLogCommand: "logCommand",
   onServerUpdate: "serverUpdate",
+  onApiRequest: "apiRequest",
+  onWebhook: "webhook",
+  onWebhookCommand: "webhookCommand",
+  onWebhookEmergencyCall: "webhookEmergencyCall",
   onError: "error",
   onDisconnect: "disconnect",
 };
@@ -134,6 +141,10 @@ class Client extends EventEmitter {
         this.server
           .fetch({ modCalls: true }, requestOptions)
           .then((d) => d.modCalls),
+      emergencyCalls: (requestOptions = {}) =>
+        this.server
+          .fetch({ emergencyCalls: true }, requestOptions)
+          .then((d) => d.emergencyCalls),
     };
 
     this.commands = {
@@ -146,6 +157,29 @@ class Client extends EventEmitter {
         this.server
           .fetch({ vehicles: true }, requestOptions)
           .then((d) => d.vehicles),
+      search: (filters = {}, requestOptions = {}) =>
+        this.server
+          .fetch({ vehicles: true }, requestOptions)
+          .then((d) => searchVehicles(d.vehicles, filters)),
+      findByPlate: (plate, requestOptions = {}) =>
+        this.server
+          .fetch({ vehicles: true }, requestOptions)
+          .then((d) => findVehicleByPlate(d.vehicles, plate)),
+      findByOwner: (owner, requestOptions = {}) =>
+        this.server
+          .fetch({ vehicles: true }, requestOptions)
+          .then((d) => searchVehicles(d.vehicles, { owner })),
+      findOne: (filters = {}, requestOptions = {}) =>
+        this.server
+          .fetch({ vehicles: true }, requestOptions)
+          .then((d) =>
+            searchVehicles(
+              d.vehicles,
+              typeof filters === "string"
+                ? { query: filters, limit: 1 }
+                : { ...filters, limit: 1 },
+            )[0] ?? null,
+          ),
     };
 
     this.queue = {
@@ -153,10 +187,23 @@ class Client extends EventEmitter {
         this.server.fetch({ queue: true }, requestOptions).then((d) => d.queue),
     };
 
+    this.api = new LocalApiServer(this, this.options.api);
+
     this.poller = new Poller(this, this.options.polling);
     if (this.options.polling?.enabled !== false) {
       this.poller.start();
     }
+    if (this.options.api?.enabled || this.options.api?.port) {
+      this.api.start().catch((error) => {
+        this.logger.error({
+          msg: "local_api_start_failed",
+          error: error?.message || String(error),
+        });
+        if (this.listenerCount("error") > 0) {
+          this.emit("error", error);
+        }
+      });
+    }
   }
 
   on(eventName, listener) {
@@ -227,6 +274,10 @@ class Client extends EventEmitter {
     return this.on("commandLog", listener);
   }
 
+  onEmergencyCall(listener) {
+    return this.on("emergencyCall", listener);
+  }
+
   onLogCommand(listener) {
     return this.on("logCommand", listener);
   }
@@ -235,6 +286,22 @@ class Client extends EventEmitter {
     return this.on("serverUpdate", listener);
   }
 
+  onApiRequest(listener) {
+    return this.on("apiRequest", listener);
+  }
+
+  onWebhook(listener) {
+    return this.on("webhook", listener);
+  }
+
+  onWebhookCommand(listener) {
+    return this.on("webhookCommand", listener);
+  }
+
+  onWebhookEmergencyCall(listener) {
+    return this.on("webhookEmergencyCall", listener);
+  }
+
   onError(listener) {
     return this.on("error", listener);
   }
@@ -333,7 +400,7 @@ class Client extends EventEmitter {
 
       const response = await this.requestManager.request({
         method: "POST",
-        path: "/v1/server/command",
+        path: "/v2/server/command",
         body: { command: normalizedCommand },
         useCache: false,
         dedupe: requestOptions.dedupe === true,
@@ -345,6 +412,11 @@ class Client extends EventEmitter {
         endpoint: response.endpoint,
         bucket: response.bucket,
         rateLimit: response.rateLimit,
+        message: response.data?.message ?? null,
+        commandId:
+          response.data?.commandId ??
+          response.data?.CommandId ??
+          null,
       };
     });
   }
@@ -370,6 +442,7 @@ class Client extends EventEmitter {
     if (this.state.destroyed) return;
     this.state.destroyed = true;
     this.poller.destroy();
+    this.api.stop();
     this.requestManager.destroy(
       this.state.disconnectError || new ERLCError("Client destroyed"),
     );