oauth-callback 1.2.0 → 1.2.1

package/README.md

@@ -413,6 +413,9 @@ bun test
 # Build
 bun run build
 
+# Run documentation locally
+bun run docs:dev        # Start VitePress dev server at http://localhost:5173
+
 # Run examples
 bun run example:demo    # Interactive demo
 bun run example:github  # GitHub OAuth example

package/dist/index.js

@@ -585,270 +585,129 @@ function renderError(params) {
 
 // src/server.ts
 function generateCallbackHTML(params, successHtml, errorHtml) {
-  if (params.error) {
-    if (errorHtml) {
-      return errorHtml.replace(/{{error}}/g, params.error || "").replace(/{{error_description}}/g, params.error_description || "").replace(/{{error_uri}}/g, params.error_uri || "");
-    }
-    return renderError({
-      error: params.error,
-      error_description: params.error_description,
-      error_uri: params.error_uri
-    });
-  }
-  return successHtml || successTemplate;
+  if (!params.error)
+    return successHtml || successTemplate;
+  if (errorHtml)
+    return errorHtml.replace(/{{error}}/g, params.error || "").replace(/{{error_description}}/g, params.error_description || "").replace(/{{error_uri}}/g, params.error_uri || "");
+  return renderError({
+    error: params.error,
+    error_description: params.error_description,
+    error_uri: params.error_uri
+  });
 }
 
-class BunCallbackServer {
-  server;
-  callbackPromise;
-  callbackPath = "/callback";
+class BaseCallbackServer {
+  callbackListeners = new Map;
   successHtml;
   errorHtml;
   onRequest;
   abortHandler;
-  async start(options) {
-    const {
-      port,
-      hostname = "localhost",
-      successHtml,
-      errorHtml,
-      signal,
-      onRequest
-    } = options;
+  signal;
+  setup(options) {
+    const { successHtml, errorHtml, signal, onRequest } = options;
     this.successHtml = successHtml;
     this.errorHtml = errorHtml;
     this.onRequest = onRequest;
-    if (signal) {
-      if (signal.aborted) {
-        throw new Error("Operation aborted");
-      }
-      this.abortHandler = () => {
-        this.stop();
-        if (this.callbackPromise) {
-          this.callbackPromise.reject(new Error("Operation aborted"));
-        }
-      };
-      signal.addEventListener("abort", this.abortHandler);
-    }
-    this.server = Bun.serve({
-      port,
-      hostname,
-      fetch: (request) => this.handleRequest(request)
-    });
+    this.signal = signal;
+    if (!signal)
+      return;
+    if (signal.aborted)
+      throw new Error("Operation aborted");
+    this.abortHandler = () => this.stop();
+    signal.addEventListener("abort", this.abortHandler);
   }
   handleRequest(request) {
-    if (this.onRequest) {
-      this.onRequest(request);
-    }
+    this.onRequest?.(request);
     const url = new URL(request.url);
-    if (url.pathname === this.callbackPath) {
-      const params = {};
-      for (const [key, value] of url.searchParams) {
-        params[key] = value;
-      }
-      if (this.callbackPromise) {
-        this.callbackPromise.resolve(params);
-      }
-      return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
-        status: 200,
-        headers: { "Content-Type": "text/html" }
-      });
-    }
-    return new Response("Not Found", { status: 404 });
+    const listener = this.callbackListeners.get(url.pathname);
+    if (!listener)
+      return new Response("Not Found", { status: 404 });
+    const params = {};
+    for (const [key, value] of url.searchParams)
+      params[key] = value;
+    listener.resolve(params);
+    return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
+      status: 200,
+      headers: { "Content-Type": "text/html" }
+    });
   }
   async waitForCallback(path2, timeout) {
-    this.callbackPath = path2;
-    return new Promise((resolve, reject) => {
-      let isResolved = false;
-      const timer = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          this.callbackPromise = undefined;
-          reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path2}`));
-        }
-      }, timeout);
-      const wrappedResolve = (result) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          resolve(result);
-        }
-      };
-      const wrappedReject = (error) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          reject(error);
-        }
-      };
-      this.callbackPromise = { resolve: wrappedResolve, reject: wrappedReject };
-    });
+    if (this.callbackListeners.has(path2))
+      return Promise.reject(new Error(`A listener for the path "${path2}" is already active.`));
+    try {
+      return await Promise.race([
+        new Promise((resolve, reject) => {
+          this.callbackListeners.set(path2, { resolve, reject });
+        }),
+        new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path2}`));
+          }, timeout);
+        })
+      ]);
+    } finally {
+      this.callbackListeners.delete(path2);
+    }
   }
   async stop() {
-    if (this.abortHandler) {
-      const signal = this.server?.signal;
-      if (signal) {
-        signal.removeEventListener("abort", this.abortHandler);
-      }
+    if (this.abortHandler && this.signal) {
+      this.signal.removeEventListener("abort", this.abortHandler);
       this.abortHandler = undefined;
     }
-    if (this.callbackPromise) {
-      this.callbackPromise.reject(new Error("Server stopped before callback received"));
-      this.callbackPromise = undefined;
-    }
-    if (this.server) {
-      this.server.stop();
-      this.server = undefined;
-    }
+    for (const listener of this.callbackListeners.values())
+      listener.reject(new Error("Server stopped before callback received"));
+    this.callbackListeners.clear();
+    await this.stopServer();
   }
 }
 
-class DenoCallbackServer {
+class BunCallbackServer extends BaseCallbackServer {
   server;
-  callbackPromise;
-  callbackPath = "/callback";
-  abortController;
-  successHtml;
-  errorHtml;
-  onRequest;
-  abortHandler;
   async start(options) {
-    const {
+    this.setup(options);
+    const { port, hostname = "localhost" } = options;
+    this.server = Bun.serve({
       port,
-      hostname = "localhost",
-      successHtml,
-      errorHtml,
-      signal,
-      onRequest
-    } = options;
-    this.successHtml = successHtml;
-    this.errorHtml = errorHtml;
-    this.onRequest = onRequest;
-    this.abortController = new AbortController;
-    if (signal) {
-      if (signal.aborted) {
-        throw new Error("Operation aborted");
-      }
-      this.abortHandler = () => {
-        this.abortController?.abort();
-        if (this.callbackPromise) {
-          this.callbackPromise.reject(new Error("Operation aborted"));
-        }
-      };
-      signal.addEventListener("abort", this.abortHandler);
-    }
-    this.server = Deno.serve({ port, hostname, signal: this.abortController.signal }, (request) => this.handleRequest(request));
-  }
-  handleRequest(request) {
-    if (this.onRequest) {
-      this.onRequest(request);
-    }
-    const url = new URL(request.url);
-    if (url.pathname === this.callbackPath) {
-      const params = {};
-      for (const [key, value] of url.searchParams) {
-        params[key] = value;
-      }
-      if (this.callbackPromise) {
-        this.callbackPromise.resolve(params);
-      }
-      return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
-        status: 200,
-        headers: { "Content-Type": "text/html" }
-      });
-    }
-    return new Response("Not Found", { status: 404 });
-  }
-  async waitForCallback(path2, timeout) {
-    this.callbackPath = path2;
-    return new Promise((resolve, reject) => {
-      let isResolved = false;
-      const timer = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          this.callbackPromise = undefined;
-          reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path2}`));
-        }
-      }, timeout);
-      const wrappedResolve = (result) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          resolve(result);
-        }
-      };
-      const wrappedReject = (error) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          reject(error);
-        }
-      };
-      this.callbackPromise = { resolve: wrappedResolve, reject: wrappedReject };
+      hostname,
+      fetch: (request) => this.handleRequest(request)
     });
   }
-  async stop() {
-    if (this.abortHandler) {
-      const signal = this.server?.signal;
-      if (signal) {
-        signal.removeEventListener("abort", this.abortHandler);
-      }
-      this.abortHandler = undefined;
-    }
-    if (this.callbackPromise) {
-      this.callbackPromise.reject(new Error("Server stopped before callback received"));
-      this.callbackPromise = undefined;
-    }
-    if (this.abortController) {
-      this.abortController.abort();
-      this.abortController = undefined;
-    }
+  async stopServer() {
+    if (!this.server)
+      return;
+    this.server.stop();
     this.server = undefined;
   }
 }
 
-class NodeCallbackServer {
+class DenoCallbackServer extends BaseCallbackServer {
+  abortController;
+  async start(options) {
+    this.setup(options);
+    const { port, hostname = "localhost" } = options;
+    this.abortController = new AbortController;
+    options.signal?.addEventListener("abort", () => this.abortController?.abort());
+    Deno.serve({ port, hostname, signal: this.abortController.signal }, (request) => this.handleRequest(request));
+  }
+  async stopServer() {
+    if (!this.abortController)
+      return;
+    this.abortController.abort();
+    this.abortController = undefined;
+  }
+}
+
+class NodeCallbackServer extends BaseCallbackServer {
   server;
-  callbackPromise;
-  callbackPath = "/callback";
-  successHtml;
-  errorHtml;
-  onRequest;
-  abortHandler;
   async start(options) {
-    const {
-      port,
-      hostname = "localhost",
-      successHtml,
-      errorHtml,
-      signal,
-      onRequest
-    } = options;
-    this.successHtml = successHtml;
-    this.errorHtml = errorHtml;
-    this.onRequest = onRequest;
-    if (signal) {
-      if (signal.aborted) {
-        throw new Error("Operation aborted");
-      }
-      this.abortHandler = () => {
-        this.stop();
-        if (this.callbackPromise) {
-          this.callbackPromise.reject(new Error("Operation aborted"));
-        }
-      };
-      signal.addEventListener("abort", this.abortHandler);
-    }
+    this.setup(options);
+    const { port, hostname = "localhost" } = options;
     const { createServer } = await import("node:http");
     return new Promise((resolve, reject) => {
       this.server = createServer(async (req, res) => {
         try {
-          const request = this.nodeToWebRequest(req, port);
-          const response = await this.handleRequest(request);
+          const request = this.nodeToWebRequest(req, port, hostname);
+          const response = this.handleRequest(request);
           res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
           const body = await response.text();
           res.end(body);
@@ -857,102 +716,43 @@ class NodeCallbackServer {
           res.end("Internal Server Error");
         }
       });
+      if (options.signal)
+        options.signal.addEventListener("abort", () => this.server?.close());
       this.server.listen(port, hostname, () => resolve());
       this.server.on("error", reject);
     });
   }
-  nodeToWebRequest(req, port) {
-    const url = new URL(req.url, `http://localhost:${port}`);
+  async stopServer() {
+    if (!this.server)
+      return;
+    return new Promise((resolve) => {
+      this.server?.close(() => {
+        this.server = undefined;
+        resolve();
+      });
+    });
+  }
+  nodeToWebRequest(req, port, hostname) {
+    const host = req.headers.host || `${hostname}:${port}`;
+    const url = new URL(req.url, `http://${host}`);
     const headers = new Headers;
     for (const [key, value] of Object.entries(req.headers)) {
-      if (typeof value === "string") {
+      if (typeof value === "string")
         headers.set(key, value);
-      } else if (Array.isArray(value)) {
+      else if (Array.isArray(value))
         headers.set(key, value.join(", "));
-      }
     }
     return new Request(url.toString(), {
       method: req.method,
       headers
     });
   }
-  async handleRequest(request) {
-    if (this.onRequest) {
-      this.onRequest(request);
-    }
-    const url = new URL(request.url);
-    if (url.pathname === this.callbackPath) {
-      const params = {};
-      for (const [key, value] of url.searchParams) {
-        params[key] = value;
-      }
-      if (this.callbackPromise) {
-        this.callbackPromise.resolve(params);
-      }
-      return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
-        status: 200,
-        headers: { "Content-Type": "text/html" }
-      });
-    }
-    return new Response("Not Found", { status: 404 });
-  }
-  async waitForCallback(path2, timeout) {
-    this.callbackPath = path2;
-    return new Promise((resolve, reject) => {
-      let isResolved = false;
-      const timer = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          this.callbackPromise = undefined;
-          reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path2}`));
-        }
-      }, timeout);
-      const wrappedResolve = (result) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          resolve(result);
-        }
-      };
-      const wrappedReject = (error) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          reject(error);
-        }
-      };
-      this.callbackPromise = { resolve: wrappedResolve, reject: wrappedReject };
-    });
-  }
-  async stop() {
-    if (this.abortHandler) {
-      const signal = this.server?.signal;
-      if (signal) {
-        signal.removeEventListener("abort", this.abortHandler);
-      }
-      this.abortHandler = undefined;
-    }
-    if (this.callbackPromise) {
-      this.callbackPromise.reject(new Error("Server stopped before callback received"));
-      this.callbackPromise = undefined;
-    }
-    if (this.server) {
-      return new Promise((resolve) => {
-        this.server.close(() => resolve());
-        this.server = undefined;
-      });
-    }
-  }
 }
 function createCallbackServer() {
-  if (typeof Bun !== "undefined") {
+  if (typeof Bun !== "undefined")
     return new BunCallbackServer;
-  }
-  if (typeof Deno !== "undefined") {
+  if (typeof Deno !== "undefined")
     return new DenoCallbackServer;
-  }
   return new NodeCallbackServer;
 }
 // src/storage/memory.ts