@colyseus/core 0.16.24 → 0.17.1

package/src/Debug.ts

@@ -0,0 +1,37 @@
+import debug from 'debug';
+import { logger } from './Logger.ts';
+import { ServerError } from './errors/ServerError.ts';
+
+export const debugConnection = debug('colyseus:connection');
+debugConnection.log = console.debug.bind(console); // STDOUT
+
+export const debugDriver = debug('colyseus:driver');
+debugDriver.log = console.debug.bind(console); // STDOUT
+
+export const debugMatchMaking = debug('colyseus:matchmaking');
+debugMatchMaking.log = console.debug.bind(console); // STDOUT
+
+export const debugMessage = debug('colyseus:message');
+debugMessage.log = console.debug.bind(console); // STDOUT
+
+export const debugPatch = debug('colyseus:patch');
+debugPatch.log = console.debug.bind(console); // STDOUT
+
+export const debugPresence = debug('colyseus:presence');
+debugPresence.log = console.debug.bind(console); // STDOUT
+
+export const debugError = debug('colyseus:errors');
+debugError.log = console.error.bind(console); // STDERR
+
+export const debugDevMode = debug('colyseus:devmode');
+debugDevMode.log = console.debug.bind(console); // STDOUT
+
+export const debugAndPrintError = (e: Error | string) => {
+  const message = (e instanceof Error) ? e.stack : e;
+
+  if (!(e instanceof ServerError)) {
+    logger.error(message);
+  }
+
+  debugError.call(debugError, message);
+};

package/src/IPC.ts

@@ -0,0 +1,124 @@
+import { debugAndPrintError } from './Debug.ts';
+import { type Presence } from './presence/Presence.ts';
+import { IpcProtocol } from './Protocol.ts';
+import { generateId, REMOTE_ROOM_SHORT_TIMEOUT } from './utils/Utils.ts';
+
+export async function requestFromIPC<T>(
+  presence: Presence,
+  publishToChannel: string,
+  method: string | undefined,
+  args: any[],
+  rejectionTimeout: number = REMOTE_ROOM_SHORT_TIMEOUT,
+): Promise<T> {
+  return new Promise<T>(async (resolve, reject) => {
+    let unsubscribeTimeout: NodeJS.Timeout;
+
+    const requestId = generateId();
+    const channel = `ipc:${requestId}`;
+
+    const unsubscribe = () => {
+      presence.unsubscribe(channel);
+      clearTimeout(unsubscribeTimeout);
+    };
+
+    await presence.subscribe(channel, (message: [IpcProtocol, any]) => {
+      const [code, data] = message;
+      if (code === IpcProtocol.SUCCESS) {
+        resolve(data);
+
+      } else if (code === IpcProtocol.ERROR) {
+        let error: any = data;
+
+        // parse error message + code
+        try { error = JSON.parse(data) } catch (e) {}
+
+        // turn string message into Error instance
+        if (typeof(error) === "string") {
+          error = new Error(error);
+        }
+
+        reject(error);
+      }
+      unsubscribe();
+    });
+
+    presence.publish(publishToChannel, [method, requestId, args]);
+
+    unsubscribeTimeout = setTimeout(() => {
+      unsubscribe();
+      reject(new Error("ipc_timeout"));
+    }, rejectionTimeout);
+  });
+}
+
+export async function subscribeIPC(
+  presence: Presence,
+  channel: string,
+  replyCallback: (method: string, args: any[]) => any,
+) {
+  await presence.subscribe(channel, (message) => {
+    const [method, requestId, args] = message;
+
+    const reply = (code, data) => {
+      presence.publish(`ipc:${requestId}`, [code, data]);
+    };
+
+    // reply with method result
+    let response: any;
+    try {
+      response = replyCallback(method, args);
+
+    } catch (e: any) {
+      debugAndPrintError(e);
+      const error = (typeof(e.code) !== "undefined")
+        ? { code: e.code, message: e.message }
+        : e.message;
+      return reply(IpcProtocol.ERROR, JSON.stringify(error));
+    }
+
+    if (!(response instanceof Promise)) {
+      return reply(IpcProtocol.SUCCESS, response);
+    }
+
+    response.
+      then((result) => reply(IpcProtocol.SUCCESS, result)).
+      catch((e) => {
+        // user might have called `reject()` without arguments.
+        const err = e && e.message || e;
+        reply(IpcProtocol.ERROR, err);
+      });
+  });
+}
+
+/**
+ * Wait for a room creation notification via presence publish/subscribe
+ */
+export function subscribeWithTimeout(
+  presence: Presence,
+  channel: string,
+  timeout: number,
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let timeoutHandle: NodeJS.Timeout;
+    let resolved = false;
+
+    const unsubscribe = () => {
+      presence.unsubscribe(channel);
+      clearTimeout(timeoutHandle);
+    };
+
+    presence.subscribe(channel, (roomId: string) => {
+      if (resolved) return;
+      resolved = true;
+      unsubscribe();
+      resolve(roomId);
+    });
+
+    timeoutHandle = setTimeout(() => {
+      if (resolved) return;
+      resolved = true;
+      unsubscribe();
+      reject(new Error("timeout"));
+    }, timeout);
+  });
+}

package/src/Logger.ts

@@ -0,0 +1,30 @@
+//
+// Abstract logging adaptor
+//
+export class Logger {
+  debug(...args) {
+    logger.debug(...args);
+  }
+
+  error(...args) {
+    logger.error(...args);
+  }
+
+  info(...args) {
+    logger.info(...args);
+  }
+
+  trace(...args) {
+    logger.trace(...args);
+  }
+
+  warn(...args) {
+    logger.warn(...args);
+  }
+}
+
+export let logger: Logger = console;
+
+export function setLogger(instance: Logger) {
+  logger = instance;
+}