erlc-v2 1.1.0 → 1.1.2

package/src/Client.js

@@ -1,480 +1,475 @@
-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";
-const BLOCKED_COMMANDS = new Set([
-  ":view",
-  ":to",
-  ":tocar",
-  ":toatv",
-  ":logs",
-  ":mods",
-  ":admins",
-  "helpers",
-  ":helpers",
-  ":administrators",
-  ":moderators",
-  ":killlogs",
-  ":kl",
-  ":cmds",
-  ":commands",
-]);
-const EVENT_ALIASES = {
-  onReady: "ready",
-  onJoin: "playerJoin",
-  onLeave: "playerLeave",
-  onKill: "kill",
-  onVehicleSpawn: "vehicleSpawn",
-  onVehicleDespawn: "vehicleDespawn",
-  onQueueUpdate: "queueUpdate",
-  onStaffUpdate: "staffUpdate",
-  onModCall: "modCall",
-  onEmergencyCall: "emergencyCall",
-  onCommandLog: "commandLog",
+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.erlc.gg";
+const BLOCKED_COMMANDS = new Set([
+  ":view",
+  ":to",
+  ":tocar",
+  ":toatv",
+  ":logs",
+  ":mods",
+  ":admins",
+  "helpers",
+  ":helpers",
+  ":administrators",
+  ":moderators",
+  ":killlogs",
+  ":kl",
+  ":cmds",
+  ":commands",
+]);
+const EVENT_ALIASES = {
+  onReady: "ready",
+  onJoin: "playerJoin",
+  onLeave: "playerLeave",
+  onKill: "kill",
+  onVehicleSpawn: "vehicleSpawn",
+  onVehicleDespawn: "vehicleDespawn",
+  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",
 };
-
-function resolveEventName(eventName) {
-  if (typeof eventName !== "string") return eventName;
-  return EVENT_ALIASES[eventName] || eventName;
-}
-
-function getCommandKeyword(command) {
-  const raw = String(command ?? "").trim();
-  if (!raw) return "";
-  return raw.split(/\s+/)[0].toLowerCase();
-}
-
-function isPromiseLike(value) {
-  return (
-    value !== null &&
-    typeof value === "object" &&
-    typeof value.then === "function"
-  );
-}
-
-class Client extends EventEmitter {
-  constructor(options = {}) {
-    super();
-
-    this.options = mergeOptions(DEFAULT_OPTIONS, options);
-    if (!this.options.serverKey || typeof this.options.serverKey !== "string") {
-      throw new ERLCError("Client requires a valid serverKey");
-    }
-
-    this.logger = createLogger(this.options.logging, this.options.logger);
-    this.cache = new Cache(this.options.cache, this.logger);
-
-    this.state = {
-      disconnected: false,
-      destroyed: false,
-      disconnectReason: null,
-      disconnectError: null,
-    };
-    this.commandQueue = Promise.resolve();
-
-    this.requestManager = new RequestManager({
-      baseURL: BASE_URL,
-      serverKey: this.options.serverKey,
-      globalKey: this.options.globalKey,
-      cache: this.cache,
-      rateLimit: this.options.rateLimit,
-      logger: this.logger,
-      onDisconnect: (reason, error) => this._handleDisconnect(reason, error),
-    });
-
-    this.server = {
-      fetch: (flags = {}, requestOptions = {}) =>
-        this._fetchServer(flags, requestOptions),
-    };
-
-    this.players = {
-      list: (requestOptions = {}) =>
-        this.server
-          .fetch({ players: true }, requestOptions)
-          .then((d) => d.players),
-    };
-
-    this.map = {
-      render: (options = {}, requestOptions = {}) =>
-        this._renderMap(options, requestOptions),
-      renderUser: (userId, options = {}, requestOptions = {}) =>
-        this._renderMap({ ...options, userId }, requestOptions),
-    };
-
-    this.staff = {
-      list: (requestOptions = {}) =>
-        this.server.fetch({ staff: true }, requestOptions).then((d) => d.staff),
-    };
-
-    this.logs = {
-      kills: (requestOptions = {}) =>
-        this.server
-          .fetch({ killLogs: true }, requestOptions)
-          .then((d) => d.killLogs),
-      joins: (requestOptions = {}) =>
-        this.server
-          .fetch({ joinLogs: true }, requestOptions)
-          .then((d) => d.joinLogs),
-      commands: (requestOptions = {}) =>
-        this.server
-          .fetch({ commandLogs: true }, requestOptions)
-          .then((d) => d.commandLogs),
-      modCalls: (requestOptions = {}) =>
-        this.server
-          .fetch({ modCalls: true }, requestOptions)
-          .then((d) => d.modCalls),
-      emergencyCalls: (requestOptions = {}) =>
-        this.server
-          .fetch({ emergencyCalls: true }, requestOptions)
-          .then((d) => d.emergencyCalls),
-    };
-
-    this.commands = {
-      execute: (command, requestOptions = {}) =>
-        this._executeCommand(command, requestOptions),
-    };
-
-    this.vehicles = {
-      list: (requestOptions = {}) =>
-        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 = {
-      get: (requestOptions = {}) =>
-        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) {
-    return super.on(resolveEventName(eventName), listener);
-  }
-
-  once(eventName, listener) {
-    return super.once(resolveEventName(eventName), listener);
-  }
-
-  addListener(eventName, listener) {
-    return super.addListener(resolveEventName(eventName), listener);
-  }
-
-  prependListener(eventName, listener) {
-    return super.prependListener(resolveEventName(eventName), listener);
-  }
-
-  prependOnceListener(eventName, listener) {
-    return super.prependOnceListener(resolveEventName(eventName), listener);
-  }
-
-  off(eventName, listener) {
-    return super.off(resolveEventName(eventName), listener);
-  }
-
-  removeListener(eventName, listener) {
-    return super.removeListener(resolveEventName(eventName), listener);
-  }
-
-  onReady(listener) {
-    return this.on("ready", listener);
-  }
-
-  onJoin(listener) {
-    return this.on("playerJoin", listener);
-  }
-
-  onLeave(listener) {
-    return this.on("playerLeave", listener);
-  }
-
-  onKill(listener) {
-    return this.on("kill", listener);
-  }
-
-  onVehicleSpawn(listener) {
-    return this.on("vehicleSpawn", listener);
-  }
-
-  onVehicleDespawn(listener) {
-    return this.on("vehicleDespawn", listener);
-  }
-
-  onQueueUpdate(listener) {
-    return this.on("queueUpdate", listener);
-  }
-
-  onStaffUpdate(listener) {
-    return this.on("staffUpdate", listener);
-  }
-
-  onModCall(listener) {
-    return this.on("modCall", listener);
-  }
-
-  onCommandLog(listener) {
-    return this.on("commandLog", listener);
-  }
-
-  onEmergencyCall(listener) {
-    return this.on("emergencyCall", listener);
-  }
-
-  onLogCommand(listener) {
-    return this.on("logCommand", listener);
-  }
-
-  onServerUpdate(listener) {
-    return this.on("serverUpdate", listener);
-  }
-
-  onApiRequest(listener) {
-    return this.on("apiRequest", listener);
-  }
-
+
+function resolveEventName(eventName) {
+  if (typeof eventName !== "string") return eventName;
+  return EVENT_ALIASES[eventName] || eventName;
+}
+
+function getCommandKeyword(command) {
+  const raw = String(command ?? "").trim();
+  if (!raw) return "";
+  return raw.split(/\s+/)[0].toLowerCase();
+}
+
+function isPromiseLike(value) {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    typeof value.then === "function"
+  );
+}
+
+class Client extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    this.options = mergeOptions(DEFAULT_OPTIONS, options);
+    if (!this.options.serverKey || typeof this.options.serverKey !== "string") {
+      throw new ERLCError("Client requires a valid serverKey");
+    }
+
+    this.logger = createLogger(this.options.logging, this.options.logger);
+    this.cache = new Cache(this.options.cache, this.logger);
+
+    this.state = {
+      disconnected: false,
+      destroyed: false,
+      disconnectReason: null,
+      disconnectError: null,
+    };
+    this.commandQueue = Promise.resolve();
+
+    this.requestManager = new RequestManager({
+      baseURL: BASE_URL,
+      serverKey: this.options.serverKey,
+      globalKey: this.options.globalKey,
+      cache: this.cache,
+      rateLimit: this.options.rateLimit,
+      logger: this.logger,
+      onDisconnect: (reason, error) => this._handleDisconnect(reason, error),
+    });
+
+    this.server = {
+      fetch: (flags = {}, requestOptions = {}) =>
+        this._fetchServer(flags, requestOptions),
+    };
+
+    this.players = {
+      list: (requestOptions = {}) =>
+        this.server
+          .fetch({ players: true }, requestOptions)
+          .then((d) => d.players),
+    };
+
+    this.map = {
+      render: (options = {}, requestOptions = {}) =>
+        this._renderMap(options, requestOptions),
+      renderUser: (userId, options = {}, requestOptions = {}) =>
+        this._renderMap({ ...options, userId }, requestOptions),
+    };
+
+    this.staff = {
+      list: (requestOptions = {}) =>
+        this.server.fetch({ staff: true }, requestOptions).then((d) => d.staff),
+    };
+
+    this.logs = {
+      kills: (requestOptions = {}) =>
+        this.server
+          .fetch({ killLogs: true }, requestOptions)
+          .then((d) => d.killLogs),
+      joins: (requestOptions = {}) =>
+        this.server
+          .fetch({ joinLogs: true }, requestOptions)
+          .then((d) => d.joinLogs),
+      commands: (requestOptions = {}) =>
+        this.server
+          .fetch({ commandLogs: true }, requestOptions)
+          .then((d) => d.commandLogs),
+      modCalls: (requestOptions = {}) =>
+        this.server
+          .fetch({ modCalls: true }, requestOptions)
+          .then((d) => d.modCalls),
+      emergencyCalls: (requestOptions = {}) =>
+        this.server
+          .fetch({ emergencyCalls: true }, requestOptions)
+          .then((d) => d.emergencyCalls),
+    };
+
+    this.commands = {
+      execute: (command, requestOptions = {}) =>
+        this._executeCommand(command, requestOptions),
+    };
+
+    this.vehicles = {
+      list: (requestOptions = {}) =>
+        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 = {
+      get: (requestOptions = {}) =>
+        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) {
+    return super.on(resolveEventName(eventName), listener);
+  }
+
+  once(eventName, listener) {
+    return super.once(resolveEventName(eventName), listener);
+  }
+
+  addListener(eventName, listener) {
+    return super.addListener(resolveEventName(eventName), listener);
+  }
+
+  prependListener(eventName, listener) {
+    return super.prependListener(resolveEventName(eventName), listener);
+  }
+
+  prependOnceListener(eventName, listener) {
+    return super.prependOnceListener(resolveEventName(eventName), listener);
+  }
+
+  off(eventName, listener) {
+    return super.off(resolveEventName(eventName), listener);
+  }
+
+  removeListener(eventName, listener) {
+    return super.removeListener(resolveEventName(eventName), listener);
+  }
+
+  onReady(listener) {
+    return this.on("ready", listener);
+  }
+
+  onJoin(listener) {
+    return this.on("playerJoin", listener);
+  }
+
+  onLeave(listener) {
+    return this.on("playerLeave", listener);
+  }
+
+  onKill(listener) {
+    return this.on("kill", listener);
+  }
+
+  onVehicleSpawn(listener) {
+    return this.on("vehicleSpawn", listener);
+  }
+
+  onVehicleDespawn(listener) {
+    return this.on("vehicleDespawn", listener);
+  }
+
+  onQueueUpdate(listener) {
+    return this.on("queueUpdate", listener);
+  }
+
+  onStaffUpdate(listener) {
+    return this.on("staffUpdate", listener);
+  }
+
+  onModCall(listener) {
+    return this.on("modCall", listener);
+  }
+
+  onCommandLog(listener) {
+    return this.on("commandLog", listener);
+  }
+
+  onEmergencyCall(listener) {
+    return this.on("emergencyCall", listener);
+  }
+
+  onLogCommand(listener) {
+    return this.on("logCommand", listener);
+  }
+
+  onServerUpdate(listener) {
+    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);
-  }
-
-  onDisconnect(listener) {
-    return this.on("disconnect", listener);
-  }
-
-  _handleDisconnect(reason, error) {
-    if (this.state.disconnected) return;
-    this.state.disconnected = true;
-    this.state.disconnectReason = reason;
-    this.state.disconnectError = error;
-
-    this.logger.warn({
-      msg: "client_disconnected",
-      reason,
-      error: error?.message,
-    });
-
-    this.poller.stop();
-    this.emit("disconnect", { reason, error });
-  }
-
-  _buildQueryFlags(flags) {
-    const query = {};
-    if (!flags || typeof flags !== "object") return query;
-
-    for (const [key, apiKey] of Object.entries(QUERY_FLAG_MAP)) {
-      if (flags[key] === true) {
-        query[apiKey] = true;
-      }
-    }
-
-    for (const apiKey of Object.values(QUERY_FLAG_MAP)) {
-      if (flags[apiKey] === true) {
-        query[apiKey] = true;
-      }
-    }
-
-    return query;
-  }
-
-  async _fetchServer(flags = {}, requestOptions = {}) {
-    if (this.state.disconnected && this.state.disconnectError) {
-      throw this.state.disconnectError;
-    }
-    if (this.state.destroyed) {
-      throw new ERLCError("Client has been destroyed");
-    }
-
-    const query = this._buildQueryFlags(flags);
-    const response = await this.requestManager.request({
-      method: "GET",
-      path: "/v2/server",
-      query,
-      useCache: requestOptions.bypassCache !== true,
-      cacheTtlMs: requestOptions.cacheTtlMs,
-      dedupe: requestOptions.dedupe !== false,
-    });
-
-    const normalized = normalizeServerResponse(response.data);
-    normalized.meta = {
-      status: response.status,
-      endpoint: response.endpoint,
-      bucket: response.bucket,
-      rateLimit: response.rateLimit,
-    };
-    return normalized;
-  }
-
-  async _executeCommand(command, requestOptions = {}) {
-    if (this.state.disconnected && this.state.disconnectError) {
-      throw this.state.disconnectError;
-    }
-    if (this.state.destroyed) {
-      throw new ERLCError("Client has been destroyed");
-    }
-    if (typeof command !== "string" || !command.trim()) {
-      throw new ERLCError("Command must be a non-empty string");
-    }
-
-    const normalizedCommand = command.trim();
-    const keyword = getCommandKeyword(normalizedCommand);
-    if (BLOCKED_COMMANDS.has(keyword)) {
-      throw new ERLCError(`Command "${keyword}" is blocked by client policy`);
-    }
-
-    return this._queueCommand(async () => {
-      if (this.state.disconnected && this.state.disconnectError) {
-        throw this.state.disconnectError;
-      }
-      if (this.state.destroyed) {
-        throw new ERLCError("Client has been destroyed");
-      }
-
-      const response = await this.requestManager.request({
-        method: "POST",
-        path: "/v2/server/command",
-        body: { command: normalizedCommand },
-        useCache: false,
-        dedupe: requestOptions.dedupe === true,
-      });
-
-      return {
-        ok: response.status >= 200 && response.status < 300,
-        status: response.status,
-        endpoint: response.endpoint,
-        bucket: response.bucket,
-        rateLimit: response.rateLimit,
-        message: response.data?.message ?? null,
-        commandId:
-          response.data?.commandId ??
-          response.data?.CommandId ??
-          null,
-      };
-    });
-  }
-
-  async _renderMap(options = {}, requestOptions = {}) {
-    if (this.state.disconnected && this.state.disconnectError) {
-      throw this.state.disconnectError;
-    }
-    if (this.state.destroyed) {
-      throw new ERLCError("Client has been destroyed");
-    }
-
-    return renderPlayerMap(this, options, requestOptions);
-  }
-
-  _queueCommand(task) {
-    const run = this.commandQueue.then(task, task);
-    this.commandQueue = run.catch(() => {});
-    return run;
-  }
-
-  destroy() {
-    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"),
-    );
-    const clearResult = this.cache.clear();
-    const maybeLog = (promiseLike, msg) => {
-      if (!isPromiseLike(promiseLike)) return;
-      promiseLike.catch((error) => {
-        this.logger.warn({
-          msg,
-          error: error?.message || String(error),
-        });
-      });
-    };
-
-    if (isPromiseLike(clearResult)) {
-      maybeLog(
-        clearResult
-          .catch((error) => {
-            this.logger.warn({
-              msg: "cache_clear_failed",
-              error: error?.message || String(error),
-            });
-          })
-          .finally(() => this.cache.destroy?.()),
-        "cache_destroy_failed",
-      );
-      return;
-    }
-
-    const destroyResult = this.cache.destroy?.();
-    maybeLog(destroyResult, "cache_destroy_failed");
-  }
-}
-
-module.exports = Client;
+
+  onError(listener) {
+    return this.on("error", listener);
+  }
+
+  onDisconnect(listener) {
+    return this.on("disconnect", listener);
+  }
+
+  _handleDisconnect(reason, error) {
+    if (this.state.disconnected) return;
+    this.state.disconnected = true;
+    this.state.disconnectReason = reason;
+    this.state.disconnectError = error;
+
+    this.logger.warn({
+      msg: "client_disconnected",
+      reason,
+      error: error?.message,
+    });
+
+    this.poller.stop();
+    this.emit("disconnect", { reason, error });
+  }
+
+  _buildQueryFlags(flags) {
+    const query = {};
+    if (!flags || typeof flags !== "object") return query;
+
+    for (const [key, apiKey] of Object.entries(QUERY_FLAG_MAP)) {
+      if (flags[key] === true) {
+        query[apiKey] = true;
+      }
+    }
+
+    for (const apiKey of Object.values(QUERY_FLAG_MAP)) {
+      if (flags[apiKey] === true) {
+        query[apiKey] = true;
+      }
+    }
+
+    return query;
+  }
+
+  async _fetchServer(flags = {}, requestOptions = {}) {
+    if (this.state.disconnected && this.state.disconnectError) {
+      throw this.state.disconnectError;
+    }
+    if (this.state.destroyed) {
+      throw new ERLCError("Client has been destroyed");
+    }
+
+    const query = this._buildQueryFlags(flags);
+    const response = await this.requestManager.request({
+      method: "GET",
+      path: "/v2/server",
+      query,
+      useCache: requestOptions.bypassCache !== true,
+      cacheTtlMs: requestOptions.cacheTtlMs,
+      dedupe: requestOptions.dedupe !== false,
+    });
+
+    const normalized = normalizeServerResponse(response.data);
+    normalized.meta = {
+      status: response.status,
+      endpoint: response.endpoint,
+      bucket: response.bucket,
+      rateLimit: response.rateLimit,
+    };
+    return normalized;
+  }
+
+  async _executeCommand(command, requestOptions = {}) {
+    if (this.state.disconnected && this.state.disconnectError) {
+      throw this.state.disconnectError;
+    }
+    if (this.state.destroyed) {
+      throw new ERLCError("Client has been destroyed");
+    }
+    if (typeof command !== "string" || !command.trim()) {
+      throw new ERLCError("Command must be a non-empty string");
+    }
+
+    const normalizedCommand = command.trim();
+    const keyword = getCommandKeyword(normalizedCommand);
+    if (BLOCKED_COMMANDS.has(keyword)) {
+      throw new ERLCError(`Command "${keyword}" is blocked by client policy`);
+    }
+
+    return this._queueCommand(async () => {
+      if (this.state.disconnected && this.state.disconnectError) {
+        throw this.state.disconnectError;
+      }
+      if (this.state.destroyed) {
+        throw new ERLCError("Client has been destroyed");
+      }
+
+      const response = await this.requestManager.request({
+        method: "POST",
+        path: "/v2/server/command",
+        body: { command: normalizedCommand },
+        useCache: false,
+        dedupe: requestOptions.dedupe === true,
+      });
+
+      return {
+        ok: response.status >= 200 && response.status < 300,
+        status: response.status,
+        endpoint: response.endpoint,
+        bucket: response.bucket,
+        rateLimit: response.rateLimit,
+        message: response.data?.message ?? null,
+        commandId:
+          response.data?.commandId ??
+          response.data?.CommandId ??
+          null,
+      };
+    });
+  }
+
+  async _renderMap(options = {}, requestOptions = {}) {
+    if (this.state.disconnected && this.state.disconnectError) {
+      throw this.state.disconnectError;
+    }
+    if (this.state.destroyed) {
+      throw new ERLCError("Client has been destroyed");
+    }
+
+    return renderPlayerMap(this, options, requestOptions);
+  }
+
+  _queueCommand(task) {
+    const run = this.commandQueue.then(task, task);
+    this.commandQueue = run.catch(() => {});
+    return run;
+  }
+
+  destroy() {
+    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"),
+    );
+    const clearResult = this.cache.clear();
+    const maybeLog = (promiseLike, msg) => {
+      if (!isPromiseLike(promiseLike)) return;
+      promiseLike.catch((error) => {
+        this.logger.warn({
+          msg,
+          error: error?.message || String(error),
+        });
+      });
+    };
+
+    if (isPromiseLike(clearResult)) {
+      maybeLog(
+        clearResult
+          .catch((error) => {
+            this.logger.warn({
+              msg: "cache_clear_failed",
+              error: error?.message || String(error),
+            });
+          })
+          .finally(() => this.cache.destroy?.()),
+        "cache_destroy_failed",
+      );
+      return;
+    }
+
+    const destroyResult = this.cache.destroy?.();
+    maybeLog(destroyResult, "cache_destroy_failed");
+  }
+}
+
+module.exports = Client;