allow to abort client.http requests via AbortController

Author: endel

package-lock.json

@@ -1,11 +1,11 @@
 {
   "name": "colyseus.js",
-  "version": "0.16.17",
+  "version": "0.16.18",
   "description": "Colyseus Multiplayer SDK for JavaScript/TypeScript",
   "author": "Endel Dreyer",
   "license": "MIT",
   "scripts": {
-    "test": "vitest --dir test",
+    "test": "vitest --dir test --reporter verbose",
     "build": "rollup -c rollup.config.mjs",
     "build-dist-dts": "dts-bundle-generator --config dts-generator.json",
     "build-ci": "tsc && npm run build && npm run build-dist-dts && npm run build-zip-dist",
@@ -60,7 +60,7 @@
   "dependencies": {
     "@colyseus/msgpackr": "^1.11.2",
     "@colyseus/schema": "^3.0.0",
-    "httpie": "^2.0.0-next.13",
+    "@colyseus/httpie": "^2.0.0",
     "tslib": "^2.1.0",
     "ws": "^8.13.0"
   },

package.json

@@ -63,7 +63,7 @@ export default [
             alias({
                 entries: [
                     // httpie: force `fetch` for web environments
-                    { find: 'httpie', replacement: path.resolve('./node_modules/httpie/fetch/index.js') },
+                    { find: '@colyseus/httpie', replacement: path.resolve('./node_modules/@colyseus/httpie/fetch/index.js') },
 
                     // ws: force browser.js version.
                     { find: 'ws', replacement: path.resolve('./node_modules/ws/browser.js') },
@@ -98,7 +98,7 @@ export default [
             alias({
                 entries: [
                     // httpie: force XHR implementation on browser/UMD environment
-                    { find: 'httpie', replacement: path.resolve('./node_modules/httpie/xhr/index.js' ) },
+                    { find: '@colyseus/httpie', replacement: path.resolve('./node_modules/@colyseus/httpie/xhr/index.js' ) },
 
                     // ws: force browser.js version.
                     { find: 'ws', replacement: path.resolve('./node_modules/ws/browser.js' ) },

rollup.config.mjs

@@ -1,4 +1,4 @@
-import { ServerError } from './errors/ServerError';
+import { ServerError } from './errors/Errors';
 import { Room } from './Room';
 import { SchemaConstructor } from './serializer/SchemaSerializer';
 import { HTTP } from "./HTTP";

src/Client.ts

@@ -1,6 +1,6 @@
 import { Client } from "./Client";
-import { ServerError } from "./errors/ServerError";
-import * as httpie from "httpie";
+import { AbortError, ServerError } from "./errors/Errors";
+import * as httpie from "@colyseus/httpie";
 
 export class HTTP {
     public authToken: string;
@@ -28,6 +28,10 @@ export class HTTP {
 
     protected request(method: "get" | "post" | "put" | "del", path: string, options: Partial<httpie.Options> = {}): Promise<httpie.Response> {
         return httpie[method](this.client['getHttpEndpoint'](path), this.getOptions(options)).catch((e: any) => {
+            if (e.aborted) {
+                throw new AbortError("Request aborted");
+            }
+
             const status = e.statusCode; //  || -1
             const message = e.data?.error || e.statusMessage || e.message; //  || "offline"
 

src/HTTP.ts

@@ -9,7 +9,7 @@ import { createSignal } from './core/signal';
 
 import { decode, encode, Iterator } from '@colyseus/schema';
 import { SchemaConstructor, SchemaSerializer } from './serializer/SchemaSerializer';
-import { CloseCode } from './errors/ServerError';
+import { CloseCode } from './errors/Errors';
 
 import { Packr, unpack } from '@colyseus/msgpackr';
 

src/Room.ts

@@ -13,3 +13,10 @@ export class ServerError extends Error {
     this.code = code;
   }
 }
+
+export class AbortError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AbortError";
+  }
+}

src/errors/ServerError.ts renamed to src/errors/Errors.ts

@@ -4,7 +4,7 @@ export { Client, JoinOptions, MatchMakeError, type EndpointSettings, type Client
 export { Protocol, ErrorCode, SeatReservation } from './Protocol';
 export { Room, RoomAvailable } from './Room';
 export { Auth, type AuthSettings, type PopupSettings } from "./Auth";
-export { ServerError } from './errors/ServerError';
+export { ServerError } from './errors/Errors';
 
 /*
  * Serializers

src/index.ts

@@ -1,17 +1,48 @@
 import './util';
-import { describe, beforeAll, test } from "vitest";
+import { describe, beforeAll, test, afterAll, beforeEach } from "vitest";
 import assert from "assert";
 import { Client } from "../src";
 
+import { createServer, Server } from 'http';
+import { AddressInfo } from 'net';
+import { AbortError } from '../src/errors/Errors';
+
+function handler(req, res) {
+    setTimeout(() => {
+        res.setHeader('Content-Type', 'application/json');
+        res.end('{invalid_json');
+    }, 60);
+}
+
+export async function startDummyLocalServer() {
+	return new Promise(res => {
+		let app = createServer(handler).listen();
+		let close = app.close.bind(app);
+		let { port } = app.address() as AddressInfo;
+		return res({ port, close });
+	});
+}
+
+
 describe("HTTP", function() {
     let client: Client;
+    let localServer: any;
 
-    beforeAll(() => {
-        client = new Client("ws://localhost:4545");
+    beforeAll(async () => {
+        localServer = await startDummyLocalServer();
+    });
+
+    beforeEach(() => {
+        client = new Client(`http://localhost:${localServer.port}`);
+    });
+
+    afterAll(() => {
+        localServer.close();
     });
 
     describe("errors", () => {
         test("should return 'offline' error when requesting offline service", async () => {
+            client = new Client(`http://localhost:9090`);
             try {
                 await client.http.post("/anything");
             } catch (e) {
@@ -20,4 +51,23 @@ describe("HTTP", function() {
         });
     });
 
+    describe("AbortController", () => {
+        test("should abort request", async () => {
+            let abortError: AbortError | undefined = undefined;
+
+            const controller = new AbortController();
+            setTimeout(() => controller.abort(), 5);
+
+            try {
+                await client.http.get("/anything", { signal: controller.signal });
+
+            } catch (e: any) {
+                abortError = e;
+            }
+
+            assert.ok(abortError);
+            assert.strictEqual(abortError!.name, 'AbortError');
+        });
+    });
+
 });