@adonix.org/cloud-spark 0.0.157 → 0.0.159

package/dist/index.js

@@ -36,6 +36,9 @@ var HttpHeader;
   HttpHeader2.ACCESS_CONTROL_EXPOSE_HEADERS = "Access-Control-Expose-Headers";
   HttpHeader2.ACCESS_CONTROL_MAX_AGE = "Access-Control-Max-Age";
   HttpHeader2.ACCESS_CONTROL_REQUEST_HEADERS = "Access-Control-Request-Headers";
+  HttpHeader2.SEC_WEBSOCKET_VERSION = "Sec-WebSocket-Version";
+  HttpHeader2.CONNECTION = "Connection";
+  HttpHeader2.UPGRADE = "Upgrade";
 })(HttpHeader || (HttpHeader = {}));
 var Method = /* @__PURE__ */ ((Method4) => {
   Method4["GET"] = "GET";
@@ -113,6 +116,32 @@ var Time = {
   // 60 * 60 * 24 * 365
 };
 
+// src/constants/websocket.ts
+var WS_UPGRADE = "upgrade";
+var WS_WEBSOCKET = "websocket";
+var WS_VERSION = "13";
+var WS_MAX_CLOSE_CODE = 4999;
+var WS_MAX_REASON_CHARS = 123;
+var CloseCode = {
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  PROTOCOL_ERROR: 1002,
+  UNSUPPORTED_DATA: 1003,
+  NO_STATUS: 1005,
+  ABNORMAL: 1006,
+  INVALID_PAYLOAD: 1007,
+  POLICY_VIOLATION: 1008,
+  MESSAGE_TOO_BIG: 1009,
+  MISSING_EXTENSION: 1010,
+  INTERNAL_ERROR: 1011,
+  TLS_HANDSHAKE: 1015
+};
+var WS_RESERVED_CODES = /* @__PURE__ */ new Set([
+  CloseCode.NO_STATUS,
+  CloseCode.ABNORMAL,
+  CloseCode.TLS_HANDSHAKE
+]);
+
 // src/guards/basic.ts
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
@@ -404,6 +433,8 @@ var BaseResponse = class {
   status = StatusCodes2.OK;
   /** Optional status text. Defaults to standard reason phrase. */
   statusText;
+  /** Enable websocket responses. */
+  webSocket = null;
   /** Default media type of the response body. */
   mediaType = "text/plain" /* PLAIN_TEXT */;
   /** Converts current state to ResponseInit for constructing a Response. */
@@ -411,7 +442,9 @@ var BaseResponse = class {
     return {
       headers: this.headers,
       status: this.status,
-      statusText: this.statusText ?? getReasonPhrase(this.status)
+      statusText: this.statusText ?? getReasonPhrase(this.status),
+      webSocket: this.webSocket,
+      encodeBody: "automatic"
     };
   }
   /** Sets a header, overwriting any existing value. */
@@ -446,8 +479,8 @@ var WorkerResponse = class extends CacheResponse {
     super(cache2);
     this.body = body;
   }
-  /** Builds the Response object with body, headers, and status. */
-  async getResponse() {
+  /** Builds the Response with body, headers, and status. */
+  async create() {
     this.addCacheHeader();
     const body = this.status === StatusCodes2.NO_CONTENT ? null : this.body;
     if (body) this.addContentType();
@@ -487,6 +520,13 @@ var TextResponse = class extends SuccessResponse {
     this.mediaType = "text/plain" /* PLAIN_TEXT */;
   }
 };
+var WebSocketResponse = class extends WorkerResponse {
+  constructor(client) {
+    super(null);
+    this.status = StatusCodes2.SWITCHING_PROTOCOLS;
+    this.webSocket = client;
+  }
+};
 var Head = class extends WorkerResponse {
   constructor(get) {
     super();
@@ -503,6 +543,18 @@ var Options = class extends SuccessResponse {
 
 // src/middleware/cors/constants.ts
 var ALLOW_ALL_ORIGINS = "*";
+var SIMPLE_METHODS = /* @__PURE__ */ new Set([GET, HEAD, OPTIONS]);
+var SKIP_CORS_STATUSES = [
+  StatusCodes.SWITCHING_PROTOCOLS,
+  StatusCodes.CONTINUE,
+  StatusCodes.PROCESSING,
+  StatusCodes.EARLY_HINTS,
+  StatusCodes.MOVED_PERMANENTLY,
+  StatusCodes.MOVED_TEMPORARILY,
+  StatusCodes.SEE_OTHER,
+  StatusCodes.TEMPORARY_REDIRECT,
+  StatusCodes.PERMANENT_REDIRECT
+];
 var defaultCorsConfig = {
   allowedOrigins: [ALLOW_ALL_ORIGINS],
   allowedHeaders: [HttpHeader.CONTENT_TYPE],
@@ -512,7 +564,6 @@ var defaultCorsConfig = {
 };
 
 // src/middleware/cors/utils.ts
-var SIMPLE_METHODS = /* @__PURE__ */ new Set([GET, HEAD, OPTIONS]);
 async function options(worker, cors2) {
   const options2 = new Options();
   const origin = getOrigin(worker.request);
@@ -521,9 +572,9 @@ async function options(worker, cors2) {
     setAllowCredentials(options2.headers, cors2, origin);
   }
   setAllowMethods(options2.headers, worker);
-  setMaxAge(options2.headers, cors2);
   setAllowHeaders(options2.headers, cors2);
-  return options2.getResponse();
+  setMaxAge(options2.headers, cors2);
+  return options2.create();
 }
 async function apply(response, worker, cors2) {
   const clone = new ClonedResponse(response);
@@ -532,9 +583,9 @@ async function apply(response, worker, cors2) {
   if (origin) {
     setAllowOrigin(clone.headers, cors2, origin);
     setAllowCredentials(clone.headers, cors2, origin);
+    setExposedHeaders(clone.headers, cors2);
   }
-  setExposedHeaders(clone.headers, cors2);
-  return clone.getResponse();
+  return clone.create();
 }
 function setAllowOrigin(headers, cors2, origin) {
   if (allowAllOrigins(cors2)) {
@@ -583,6 +634,12 @@ function deleteCorsHeaders(headers) {
   headers.delete(HttpHeader.ACCESS_CONTROL_EXPOSE_HEADERS);
   headers.delete(HttpHeader.ACCESS_CONTROL_ALLOW_CREDENTIALS);
 }
+function skipCors(response) {
+  const { status, headers } = response;
+  if (SKIP_CORS_STATUSES.includes(status)) return true;
+  if (headers.has(HttpHeader.UPGRADE)) return true;
+  return false;
+}
 
 // src/guards/cors.ts
 function assertCorsInit(value) {
@@ -641,6 +698,7 @@ var CorsHandler = class extends Middleware {
       return options(worker, this.config);
     }
     const response = await next();
+    if (skipCors(response)) return response;
     return apply(response, worker, this.config);
   }
 };
@@ -691,6 +749,12 @@ var MethodNotAllowed = class extends HttpError {
     this.setHeader(HttpHeader.ALLOW, methods);
   }
 };
+var UpgradeRequired = class extends HttpError {
+  constructor() {
+    super(StatusCodes3.UPGRADE_REQUIRED);
+    this.headers.set(HttpHeader.SEC_WEBSOCKET_VERSION, WS_VERSION);
+  }
+};
 var InternalServerError = class extends HttpError {
   constructor(details) {
     super(StatusCodes3.INTERNAL_SERVER_ERROR, details);
@@ -712,7 +776,295 @@ var ServiceUnavailable = class extends HttpError {
   }
 };
 
-// src/workers/base-worker.ts
+// src/middleware/websocket/utils.ts
+function hasConnectionHeader(headers) {
+  return getHeaderValues(headers, HttpHeader.CONNECTION).some(
+    (value) => value.toLowerCase() === WS_UPGRADE
+  );
+}
+function hasUpgradeHeader(headers) {
+  return getHeaderValues(headers, HttpHeader.UPGRADE).some(
+    (value) => value.toLowerCase() === WS_WEBSOCKET
+  );
+}
+function hasWebSocketVersion(headers) {
+  return headers.get(HttpHeader.SEC_WEBSOCKET_VERSION)?.trim() === WS_VERSION;
+}
+
+// src/middleware/websocket/handler.ts
+function websocket(path = "/") {
+  return new WebSocketHandler(path);
+}
+var WebSocketHandler = class extends Middleware {
+  constructor(path) {
+    super();
+    this.path = path;
+  }
+  handle(worker, next) {
+    if (worker.request.method !== GET) {
+      return next();
+    }
+    if (this.getPath(worker.request) !== this.path) {
+      return next();
+    }
+    const headers = worker.request.headers;
+    if (!hasConnectionHeader(headers)) {
+      return new BadRequest("Missing or invalid Connection header").create();
+    }
+    if (!hasUpgradeHeader(headers)) {
+      return new BadRequest("Missing or invalid Upgrade header").create();
+    }
+    if (!hasWebSocketVersion(headers)) {
+      return new UpgradeRequired().create();
+    }
+    return next();
+  }
+  getPath(request) {
+    return new URL(request.url).pathname;
+  }
+};
+
+// src/guards/websocket.ts
+function isBinary(value) {
+  return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+function isSendable(value) {
+  if (isString(value)) return value.length > 0;
+  if (isBinary(value)) return value.byteLength > 0;
+  return false;
+}
+function safeCloseCode(code) {
+  if (!isNumber(code)) return CloseCode.NORMAL;
+  if (isCodeInRange(code) && !isReservedCode(code)) return code;
+  return CloseCode.NORMAL;
+}
+function isCodeInRange(code) {
+  return code >= CloseCode.NORMAL && code <= WS_MAX_CLOSE_CODE;
+}
+function isReservedCode(code) {
+  return WS_RESERVED_CODES.has(code);
+}
+function safeReason(reason) {
+  if (!isString(reason)) return;
+  return reason.replace(/[^\x20-\x7E]/g, "").slice(0, WS_MAX_REASON_CHARS);
+}
+function assertSerializable(value) {
+  if (value === null || typeof value !== "object") {
+    throw new TypeError("WebSocket attachment must be a non-null object");
+  }
+  try {
+    JSON.stringify(value);
+  } catch {
+    throw new TypeError("WebSocket attachment is non-serializable");
+  }
+}
+
+// src/websocket/events.ts
+var WebSocketEvents = class _WebSocketEvents {
+  server;
+  static isCustomEvent(type) {
+    return ["open", "warn"].includes(type);
+  }
+  customListeners = {};
+  constructor(server) {
+    this.server = server;
+  }
+  addEventListener(type, listener, options2) {
+    if (_WebSocketEvents.isCustomEvent(type)) {
+      let arr = this.customListeners[type];
+      if (!arr) {
+        arr = [];
+        this.customListeners[type] = arr;
+      }
+      arr.push(listener);
+    } else {
+      const finalOptions = type === "close" ? { ...options2, once: true } : options2;
+      this.server.addEventListener(
+        type,
+        listener,
+        finalOptions
+      );
+    }
+  }
+  removeEventListener(type, listener) {
+    if (_WebSocketEvents.isCustomEvent(type)) {
+      const arr = this.customListeners[type];
+      if (arr) {
+        const index = arr.indexOf(listener);
+        if (index !== -1) arr.splice(index, 1);
+      }
+    } else {
+      this.server.removeEventListener(
+        type,
+        listener
+      );
+    }
+  }
+  dispatch(type, ev, once = false) {
+    const listeners = this.customListeners[type]?.slice() ?? [];
+    if (once) {
+      this.customListeners[type] = [];
+    }
+    listeners.forEach((listener) => listener(ev));
+  }
+  warn(msg) {
+    this.dispatch("warn", { type: "warn", message: msg });
+  }
+  open() {
+    this.dispatch("open", new Event("open"), true);
+  }
+};
+
+// src/websocket/base.ts
+var BaseWebSocket = class extends WebSocketEvents {
+  accepted = false;
+  server;
+  constructor(server) {
+    super(server);
+    this.server = server;
+    this.server.addEventListener("close", this.onclose);
+  }
+  send(data) {
+    if (this.isState(WebSocket.CONNECTING, WebSocket.CLOSED)) {
+      this.warn("Cannot send: WebSocket not open");
+      return;
+    }
+    if (!isSendable(data)) {
+      this.warn("Cannot send: empty or invalid data");
+      return;
+    }
+    this.server.send(data);
+  }
+  get attachment() {
+    return this.server.deserializeAttachment() ?? {};
+  }
+  attach(attachment) {
+    if (attachment === void 0) return;
+    if (attachment === null) {
+      this.server.serializeAttachment({});
+    } else {
+      assertSerializable(attachment);
+      this.server.serializeAttachment(attachment);
+    }
+  }
+  get readyState() {
+    if (!this.accepted) return WebSocket.CONNECTING;
+    return this.server.readyState;
+  }
+  isState(...states) {
+    return states.includes(this.readyState);
+  }
+  close(code, reason) {
+    this.server.removeEventListener("close", this.onclose);
+    this.server.close(safeCloseCode(code), safeReason(reason));
+  }
+  onclose = (event) => {
+    this.close(event.code, event.reason);
+  };
+};
+
+// src/websocket/new.ts
+var NewConnectionBase = class extends BaseWebSocket {
+  client;
+  constructor() {
+    const pair = new WebSocketPair();
+    const [client, server] = [pair[0], pair[1]];
+    super(server);
+    this.client = client;
+  }
+  acceptWebSocket(ctx, tags) {
+    ctx.acceptWebSocket(this.server, tags);
+    return this.ready();
+  }
+  accept() {
+    this.server.accept();
+    return this.ready();
+  }
+  ready() {
+    this.accepted = true;
+    this.open();
+    return this.client;
+  }
+};
+
+// src/websocket/restore.ts
+var RestoredConnectionBase = class extends BaseWebSocket {
+  constructor(ws) {
+    super(ws);
+    this.accepted = true;
+  }
+  accept() {
+    throw new Error("Do not call accept() on restore");
+  }
+  acceptWebSocket() {
+    throw new Error("Do not call acceptWebSocket() on restore");
+  }
+};
+
+// src/websocket/sessions.ts
+var WebSocketSessions = class {
+  map = /* @__PURE__ */ new Map();
+  create(attachment) {
+    class NewConnection extends NewConnectionBase {
+      constructor(sessions) {
+        super();
+        this.sessions = sessions;
+      }
+      accept() {
+        this.addEventListener("close", () => this.sessions.unregister(this.server));
+        this.sessions.register(this.server, this);
+        return super.accept();
+      }
+      acceptWebSocket(ctx, tags) {
+        this.sessions.register(this.server, this);
+        return super.acceptWebSocket(ctx, tags);
+      }
+    }
+    const connection = new NewConnection(this);
+    connection.attach(attachment);
+    return connection;
+  }
+  restore(ws) {
+    class RestoredConnection extends RestoredConnectionBase {
+      constructor(sessions, restore) {
+        super(restore);
+        sessions.register(this.server, this);
+      }
+    }
+    return new RestoredConnection(this, ws);
+  }
+  restoreAll(all) {
+    const restored = [];
+    for (const ws of all) {
+      restored.push(this.restore(ws));
+    }
+    return restored;
+  }
+  get(ws) {
+    return this.map.get(ws);
+  }
+  values() {
+    return this.map.values();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  close(ws, code, reason) {
+    ws.close(safeCloseCode(code), safeReason(reason));
+    return this.unregister(ws);
+  }
+  *[Symbol.iterator]() {
+    yield* this.values();
+  }
+  register(ws, con) {
+    this.map.set(ws, con);
+  }
+  unregister(ws) {
+    return this.map.delete(ws);
+  }
+};
+
+// src/workers/base.ts
 var BaseWorker = class {
   constructor(_request, _env, _ctx) {
     this._request = _request;
@@ -731,6 +1083,16 @@ var BaseWorker = class {
   get ctx() {
     return this._ctx;
   }
+  /**
+   * Checks if the given HTTP method is allowed for this worker.
+   * @param method HTTP method string
+   * @returns true if the method is allowed
+   */
+  isAllowed(method) {
+    const methods = this.getAllowedMethods();
+    assertMethods(methods);
+    return isMethod(method) && methods.includes(method);
+  }
   /**
    * Creates a new instance of the current Worker subclass.
    *
@@ -741,6 +1103,23 @@ var BaseWorker = class {
     const ctor = this.constructor;
     return new ctor(request, this.env, this.ctx);
   }
+  /**
+   * Simplify and standardize {@link Response} creation by extending {@link WorkerResponse}
+   * or any of its subclasses and passing to this method.
+   *
+   * Or directly use any of the built-in classes.
+   *
+   * ```ts
+   * this.response(TextResponse, "Hello World!")
+   * ```
+   *
+   * @param ResponseClass The response class to instantiate
+   * @param args Additional constructor arguments
+   * @returns A Promise resolving to the {@link Response} object
+   */
+  async response(ResponseClass, ...args) {
+    return new ResponseClass(...args).create();
+  }
   /**
    * **Ignite** your `Worker` implementation into a Cloudflare handler.
    *
@@ -764,10 +1143,16 @@ function assertMiddleware(handler) {
   }
 }
 
-// src/workers/middleware-worker.ts
+// src/workers/middleware.ts
 var MiddlewareWorker = class extends BaseWorker {
   /** Middleware handlers registered for this worker. */
   middlewares = [];
+  /**
+   * Hook for subclasses to perform any initialization.
+   */
+  init() {
+    return;
+  }
   /**
    * Add a middleware instance to this worker.
    *
@@ -796,21 +1181,21 @@ var MiddlewareWorker = class extends BaseWorker {
   }
 };
 
-// src/workers/basic-worker.ts
+// src/workers/basic.ts
 var BasicWorker = class extends MiddlewareWorker {
   /**
    * Entry point to handle a fetch request.
    */
   async fetch() {
     if (!this.isAllowed(this.request.method)) {
-      return this.getResponse(MethodNotAllowed, this);
+      return this.response(MethodNotAllowed, this);
     }
     try {
       await this.init();
       return await super.fetch();
     } catch (error) {
       console.error(error);
-      return this.getResponse(InternalServerError);
+      return this.response(InternalServerError);
     }
   }
   /**
@@ -827,47 +1212,31 @@ var BasicWorker = class extends MiddlewareWorker {
       DELETE: () => this.delete(),
       OPTIONS: () => this.options()
     };
-    return (handler[method] ?? (() => this.getResponse(MethodNotAllowed, this)))();
-  }
-  /**
-   * Hook for subclasses to perform any initialization.
-   */
-  init() {
-    return;
-  }
-  /**
-   * Checks if the given HTTP method is allowed for this worker.
-   * @param method HTTP method string
-   * @returns true if the method is allowed
-   */
-  isAllowed(method) {
-    const methods = this.getAllowedMethods();
-    assertMethods(methods);
-    return isMethod(method) && methods.includes(method);
+    return (handler[method] ?? (() => this.response(MethodNotAllowed, this)))();
   }
   /** Override and implement this method for GET requests. */
   async get() {
-    return this.getResponse(MethodNotImplemented, this);
+    return this.response(MethodNotImplemented, this);
   }
   /** Override and implement this method for PUT requests. */
   async put() {
-    return this.getResponse(MethodNotImplemented, this);
+    return this.response(MethodNotImplemented, this);
   }
   /** Override and implement this method for POST requests. */
   async post() {
-    return this.getResponse(MethodNotImplemented, this);
+    return this.response(MethodNotImplemented, this);
   }
   /** Override and implement this method for PATCH requests. */
   async patch() {
-    return this.getResponse(MethodNotImplemented, this);
+    return this.response(MethodNotImplemented, this);
   }
   /** Override and implement this method for DELETE requests. */
   async delete() {
-    return this.getResponse(MethodNotImplemented, this);
+    return this.response(MethodNotImplemented, this);
   }
   /** Returns a default empty OPTIONS response. */
   async options() {
-    return this.getResponse(Options);
+    return this.response(Options);
   }
   /**
    * Default handler for HEAD requests.
@@ -880,7 +1249,7 @@ var BasicWorker = class extends MiddlewareWorker {
     const worker = this.create(
       new Request(this.request.url, { method: GET, headers: this.request.headers })
     );
-    return this.getResponse(Head, await worker.fetch());
+    return this.response(Head, await worker.fetch());
   }
   /**
    * DEFAULT allowed HTTP methods for subclasses.
@@ -891,23 +1260,6 @@ var BasicWorker = class extends MiddlewareWorker {
   getAllowedMethods() {
     return [GET, HEAD, OPTIONS];
   }
-  /**
-   * Simplify and standardize {@link Response} creation by extending {@link WorkerResponse}
-   * or any of its subclasses and passing to this method.
-   *
-   * Or directly use any of the built-in classes.
-   *
-   * ```ts
-   * this.getResponse(TextResponse, "Hello World!")
-   * ```
-   *
-   * @param ResponseClass The response class to instantiate
-   * @param args Additional constructor arguments
-   * @returns A Promise resolving to the {@link Response} object
-   */
-  async getResponse(ResponseClass, ...args) {
-    return new ResponseClass(...args).getResponse();
-  }
 };
 
 // src/routes.ts
@@ -953,7 +1305,7 @@ var Routes = class {
   }
 };
 
-// src/workers/route-worker.ts
+// src/workers/route.ts
 var RouteWorker = class _RouteWorker extends BasicWorker {
   /** Internal table of registered routes. */
   _routes = new Routes();
@@ -1022,19 +1374,19 @@ var RouteWorker = class _RouteWorker extends BasicWorker {
     return BaseWorker.prototype.isPrototypeOf(handler.prototype);
   }
   async get() {
-    return this.getResponse(NotFound);
+    return this.response(NotFound);
   }
   async put() {
-    return this.getResponse(NotFound);
+    return this.response(NotFound);
   }
   async post() {
-    return this.getResponse(NotFound);
+    return this.response(NotFound);
   }
   async patch() {
-    return this.getResponse(NotFound);
+    return this.response(NotFound);
   }
   async delete() {
-    return this.getResponse(NotFound);
+    return this.response(NotFound);
   }
 };
 export {
@@ -1042,6 +1394,7 @@ export {
   BasicWorker,
   CacheControl,
   ClonedResponse,
+  CloseCode,
   DELETE,
   Forbidden,
   GET,
@@ -1056,7 +1409,6 @@ export {
   Method,
   MethodNotAllowed,
   MethodNotImplemented,
-  Middleware,
   NotFound,
   NotImplemented,
   OPTIONS,
@@ -1071,6 +1423,15 @@ export {
   TextResponse,
   Time,
   Unauthorized,
+  UpgradeRequired,
+  WS_MAX_CLOSE_CODE,
+  WS_MAX_REASON_CHARS,
+  WS_RESERVED_CODES,
+  WS_UPGRADE,
+  WS_VERSION,
+  WS_WEBSOCKET,
+  WebSocketResponse,
+  WebSocketSessions,
   WorkerResponse,
   assertMethods,
   cache,
@@ -1084,6 +1445,7 @@ export {
   mergeHeader,
   setHeader,
   sortSearchParams,
-  stripSearchParams
+  stripSearchParams,
+  websocket
 };
 //# sourceMappingURL=index.js.map