@coderbuzz/ken 0.1.0

package/dist/uws-VNY2LPIZ.js

@@ -0,0 +1,622 @@
+import {
+  canUseNativeRoute
+} from "./chunk-2BOPD5H7.js";
+import {
+  BaseContext
+} from "./chunk-2MK26YDD.js";
+import {
+  EMPTY_PARAMS,
+  Router,
+  WS_DEFAULTS,
+  WsReadyState,
+  createExecutor,
+  createNotFoundExecutor,
+  toResponse
+} from "./chunk-DPU3PBLP.js";
+
+// src/context/uws.ts
+var UwsContext = class extends BaseContext {
+  res;
+  // Pre-read values (must be read sync during callback)
+  _method;
+  _url;
+  _rawQuery;
+  _headersMap;
+  _bodyBuffer = null;
+  /**
+   * Constructor - MUST read all request data synchronously.
+   * uWs HttpRequest becomes invalid after callback returns.
+   */
+  constructor(req, res, params = EMPTY_PARAMS, getRemoteInfo, schema) {
+    super(params, getRemoteInfo, schema);
+    this.res = res;
+    this._method = req.getMethod().toUpperCase();
+    this._url = req.getUrl();
+    this._rawQuery = req.getQuery();
+    this._headersMap = /* @__PURE__ */ new Map();
+    req.forEach((key, value) => {
+      this._headersMap.set(key.toLowerCase(), value);
+    });
+  }
+  get url() {
+    return this._rawQuery ? `${this._url}?${this._rawQuery}` : this._url;
+  }
+  get method() {
+    return this._method;
+  }
+  get body() {
+    return null;
+  }
+  _getRawHeaders() {
+    return {
+      get: (key) => this._headersMap.get(key.toLowerCase()) ?? null
+    };
+  }
+  _getRawUrl() {
+    return this.url;
+  }
+  /**
+   * Lazily parses and validates headers.
+   */
+  get headers() {
+    let cached = this._headers;
+    if (cached !== null) return cached;
+    const schema = this._schema?.headers;
+    if (schema !== void 0) {
+      const result = {};
+      for (const key in schema) {
+        const validator = schema[key];
+        result[key] = validator(this._headersMap.get(key.toLowerCase()) || "");
+      }
+      this._headers = result;
+      return result;
+    }
+    const h = {};
+    this._headersMap.forEach((v, k) => h[k] = v);
+    this._headers = h;
+    return h;
+  }
+  /**
+   * Read body buffer from uWs response
+   */
+  _readBody() {
+    if (this._bodyBuffer !== null) return Promise.resolve(this._bodyBuffer);
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      this.res.onData((chunk, isLast) => {
+        chunks.push(Buffer.from(chunk));
+        if (isLast) {
+          this._bodyBuffer = Buffer.concat(chunks);
+          resolve(this._bodyBuffer);
+        }
+      });
+      this.res.onAborted(() => {
+        reject(new Error("Request aborted"));
+      });
+    });
+  }
+  /**
+   * Lazily parses and validates JSON body.
+   */
+  get json() {
+    if (this._json) return this._json;
+    const validator = this._schema?.json;
+    if (validator) {
+      this._json = (async () => {
+        const buffer = await this._readBody();
+        const data = JSON.parse(buffer.toString("utf8"));
+        try {
+          return validator(data);
+        } catch (err) {
+          throw new Error(`JSON Body validation failed: ${err.message}`);
+        }
+      })();
+    } else {
+      this._json = (async () => {
+        try {
+          const buffer = await this._readBody();
+          return JSON.parse(buffer.toString("utf8"));
+        } catch {
+          return null;
+        }
+      })();
+    }
+    return this._json;
+  }
+  /**
+   * Lazily parses and validates text body.
+   */
+  get text() {
+    if (this._text) return this._text;
+    const validator = this._schema?.text;
+    if (validator) {
+      this._text = (async () => {
+        const buffer = await this._readBody();
+        const data = buffer.toString("utf8");
+        try {
+          return validator(data);
+        } catch (err) {
+          throw new Error(`Text Body validation failed: ${err.message}`);
+        }
+      })();
+    } else {
+      this._text = (async () => {
+        const buffer = await this._readBody();
+        return buffer.toString("utf8");
+      })();
+    }
+    return this._text;
+  }
+  /**
+   * Lazily parses and validates form body.
+   * Supports both application/x-www-form-urlencoded and multipart/form-data
+   */
+  get form() {
+    if (this._form) return this._form;
+    const schema = this._schema?.form;
+    this._form = (async () => {
+      const buffer = await this._readBody();
+      const contentType = this._headersMap.get("content-type") || "";
+      if (contentType.startsWith("multipart/form-data")) {
+        const fullUrl = `http://localhost${this.url}`;
+        const headers = new Headers();
+        this._headersMap.forEach((value, key) => {
+          headers.set(key, value);
+        });
+        const request = new Request(fullUrl, {
+          method: this.method,
+          headers,
+          body: new Uint8Array(buffer),
+          // @ts-ignore - duplex is needed for streaming
+          duplex: "half"
+        });
+        const formData2 = await request.formData();
+        if (schema) {
+          const result = {};
+          for (const key in schema) {
+            try {
+              result[key] = schema[key](formData2.get(key));
+            } catch (err) {
+              throw new Error(`Form Body validation failed for "${key}": ${err.message}`);
+            }
+          }
+          return result;
+        }
+        return formData2;
+      }
+      const text = buffer.toString("utf8");
+      const formData = /* @__PURE__ */ new Map();
+      const pairs = text.split("&");
+      for (const pair of pairs) {
+        const [key, value] = pair.split("=");
+        if (key) {
+          formData.set(
+            decodeURIComponent(key),
+            value ? decodeURIComponent(value.replace(/\+/g, " ")) : ""
+          );
+        }
+      }
+      if (schema) {
+        const result = {};
+        for (const key in schema) {
+          try {
+            result[key] = schema[key](formData.get(key) ?? null);
+          } catch (err) {
+            throw new Error(`Form Body validation failed for "${key}": ${err.message}`);
+          }
+        }
+        return result;
+      }
+      return Object.fromEntries(formData);
+    })();
+    return this._form;
+  }
+};
+
+// src/ws/uws.ts
+var textDecoder = new TextDecoder();
+var UwsWsPeer = class {
+  ws;
+  _remoteAddress = null;
+  readyState = WsReadyState.OPEN;
+  constructor(ws) {
+    this.ws = ws;
+  }
+  get data() {
+    return this.ws.getUserData().userData;
+  }
+  set data(value) {
+    this.ws.getUserData().userData = value;
+  }
+  get remoteAddress() {
+    if (this._remoteAddress === null) {
+      this._remoteAddress = textDecoder.decode(this.ws.getRemoteAddressAsText());
+    }
+    return this._remoteAddress;
+  }
+  send(data, compress) {
+    const isBinary = typeof data !== "string";
+    return this.ws.send(data, isBinary, compress);
+  }
+  close(code, reason) {
+    this.ws.end(code, reason);
+  }
+  subscribe(topic) {
+    this.ws.subscribe(topic);
+  }
+  unsubscribe(topic) {
+    this.ws.unsubscribe(topic);
+  }
+  publish(topic, data, compress) {
+    const isBinary = typeof data !== "string";
+    this.ws.publish(topic, data, isBinary, compress);
+  }
+  isSubscribed(topic) {
+    return this.ws.isSubscribed(topic);
+  }
+  ping(data) {
+    this.ws.ping(data);
+  }
+  pong(_data) {
+  }
+};
+function createUwsWsConfig(handler, options = {}) {
+  const opts = { ...WS_DEFAULTS, ...options };
+  const peerMap = /* @__PURE__ */ new WeakMap();
+  function getPeer(ws) {
+    let peer = peerMap.get(ws);
+    if (!peer) {
+      peer = new UwsWsPeer(ws);
+      peerMap.set(ws, peer);
+    }
+    return peer;
+  }
+  const behavior = {
+    maxPayloadLength: opts.maxPayloadLength,
+    maxBackpressure: opts.backpressureLimit,
+    idleTimeout: opts.idleTimeout,
+    sendPingsAutomatically: opts.pingInterval > 0,
+    compression: opts.perMessageDeflate ? 1 : 0,
+    // SHARED_COMPRESSOR
+    upgrade: handler.upgrade ? async (res, req, context) => {
+      const headers = new Headers();
+      req.forEach((key, value) => {
+        headers.set(key, value);
+      });
+      const query = req.getQuery();
+      const url = `http://localhost${req.getUrl()}${query ? "?" + query : ""}`;
+      const request = new Request(url, { method: req.getMethod().toUpperCase(), headers });
+      let aborted = false;
+      res.onAborted(() => {
+        aborted = true;
+      });
+      try {
+        const result = await handler.upgrade(request);
+        if (aborted) return;
+        if (result instanceof Response) {
+          res.cork(() => {
+            res.writeStatus(`${result.status}`);
+            result.headers.forEach((v, k) => {
+              res.writeHeader(k, v);
+            });
+            res.end();
+          });
+          return;
+        }
+        res.cork(() => {
+          res.upgrade(
+            { userData: result },
+            req.getHeader("sec-websocket-key"),
+            req.getHeader("sec-websocket-protocol"),
+            req.getHeader("sec-websocket-extensions"),
+            context
+          );
+        });
+      } catch {
+        if (!aborted) {
+          res.cork(() => {
+            res.writeStatus("500").end();
+          });
+        }
+      }
+    } : void 0,
+    open(ws) {
+      const peer = getPeer(ws);
+      try {
+        handler.open?.(peer);
+      } catch {
+      }
+    },
+    message(ws, message, isBinary) {
+      const peer = getPeer(ws);
+      try {
+        const data = isBinary ? message : new TextDecoder().decode(message);
+        handler.message(peer, data);
+      } catch {
+      }
+    },
+    close(ws, code, message) {
+      const peer = getPeer(ws);
+      peer.readyState = WsReadyState.CLOSED;
+      peerMap.delete(ws);
+      const reason = message.byteLength > 0 ? new TextDecoder().decode(message) : "";
+      try {
+        handler.close?.(peer, code, reason);
+      } catch {
+      }
+    },
+    ping: handler.ping ? (ws, message) => {
+      const peer = getPeer(ws);
+      try {
+        handler.ping(peer, message);
+      } catch {
+      }
+    } : void 0,
+    pong: handler.pong ? (ws, message) => {
+      const peer = getPeer(ws);
+      try {
+        handler.pong(peer, message);
+      } catch {
+      }
+    } : void 0
+  };
+  return { behavior };
+}
+
+// src/runtime/uws.ts
+var textDecoder2 = new TextDecoder();
+async function sendUwsResponse(uwsRes, response, aborted) {
+  if (aborted.value) return;
+  const status = `${response.status} ${response.statusText || "OK"}`;
+  const body = response.body;
+  uwsRes.cork(() => {
+    uwsRes.writeStatus(status);
+    response.headers.forEach((value, key) => {
+      uwsRes.writeHeader(key, value);
+    });
+    if (!body) {
+      uwsRes.end();
+    }
+  });
+  if (body && !aborted.value) {
+    const reader = body.getReader();
+    try {
+      while (!aborted.value) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        uwsRes.cork(() => {
+          uwsRes.write(value);
+        });
+      }
+    } finally {
+      reader.releaseLock();
+      if (!aborted.value) {
+        uwsRes.cork(() => {
+          uwsRes.end();
+        });
+      }
+    }
+  }
+}
+function getRemoteInfoFromUws(res) {
+  return () => {
+    const addressBuffer = res.getRemoteAddressAsText();
+    const address = textDecoder2.decode(addressBuffer);
+    return {
+      address,
+      port: 0
+      // uWS doesn't provide port
+    };
+  };
+}
+function toUwsPattern(kenPath) {
+  return kenPath;
+}
+function extractUwsParams(req, pattern) {
+  const paramNames = [];
+  const parts = pattern.split("/");
+  for (const part of parts) {
+    if (part.startsWith(":")) {
+      paramNames.push(part.slice(1).replace("?", ""));
+    }
+  }
+  if (paramNames.length === 0) {
+    return {};
+  }
+  const params = {};
+  for (let i = 0; i < paramNames.length; i++) {
+    const value = req.getParameter(i);
+    if (value) {
+      params[paramNames[i]] = value;
+    }
+  }
+  return params;
+}
+var uwsContextFactory = ({ req, res }, params, getRemoteInfo, schema) => new UwsContext(req, res, params, getRemoteInfo, schema);
+function server({ port, hostname, router }) {
+  let listenSocket = void 0;
+  const getUws = async () => {
+    try {
+      const uws = await import("uWebSockets.js");
+      return uws;
+    } catch {
+      throw new Error("uWebSockets.js is required for uWS runtime. Install with: npm install uWebSockets.js");
+    }
+  };
+  return {
+    async run() {
+      if (listenSocket) {
+        listenSocket.close();
+      }
+      const uws = await getUws();
+      const app = uws.App();
+      const wsRoutes = router.wsRoutes || [];
+      for (const wsRoute of wsRoutes) {
+        const wsConfig = createUwsWsConfig(wsRoute.handler, wsRoute.options);
+        app.ws(wsRoute.path, wsConfig.behavior);
+      }
+      const nativeRoutes = [];
+      const fallbackRoutes = [];
+      for (const route of router.routes) {
+        let mergedSchema = route.schema;
+        if (typeof router.matchMiddleware === "function" && typeof router.mergeSchemas === "function") {
+          const matchedMiddleware = router.matchMiddleware(route.path);
+          mergedSchema = router.mergeSchemas(matchedMiddleware, route.schema);
+        }
+        if (canUseNativeRoute(route.path)) {
+          nativeRoutes.push({
+            method: route.method,
+            pattern: route.path,
+            handler: route.handler,
+            schema: mergedSchema,
+            staticValue: route.staticValue
+          });
+        } else {
+          fallbackRoutes.push({ ...route, schema: mergedSchema });
+        }
+      }
+      for (const route of nativeRoutes) {
+        const uwsPattern = toUwsPattern(route.pattern);
+        const methodLower = route.method.toLowerCase();
+        const registerMethod = methodLower === "delete" ? "del" : methodLower;
+        if (route.staticValue !== void 0) {
+          const cachedResponse = toResponse(route.staticValue);
+          const status = `${cachedResponse.status} ${cachedResponse.statusText || "OK"}`;
+          const headers = [];
+          cachedResponse.headers.forEach((v, k) => headers.push([k, v]));
+          cachedResponse.text().then((body) => {
+            const headerCount = headers.length;
+            if (headerCount === 1) {
+              const [hk, hv] = headers[0];
+              app[registerMethod](uwsPattern, (res) => {
+                res.cork(() => {
+                  res.writeStatus(status);
+                  res.writeHeader(hk, hv);
+                  res.end(body);
+                });
+              });
+            } else {
+              app[registerMethod](uwsPattern, (res) => {
+                res.cork(() => {
+                  res.writeStatus(status);
+                  for (let i = 0; i < headerCount; i++) {
+                    res.writeHeader(headers[i][0], headers[i][1]);
+                  }
+                  res.end(body);
+                });
+              });
+            }
+          });
+        } else if (route.handler) {
+          const executor = createExecutor(uwsContextFactory, route.handler, route.schema);
+          const pattern = route.pattern;
+          app[registerMethod](uwsPattern, async (res, req) => {
+            const aborted = { value: false };
+            res.onAborted(() => {
+              aborted.value = true;
+            });
+            const params = extractUwsParams(req, pattern);
+            const getRemoteInfo = getRemoteInfoFromUws(res);
+            try {
+              const result = await executor({ req, res }, params, getRemoteInfo);
+              if (!aborted.value) {
+                const response = toResponse(result);
+                await sendUwsResponse(res, response, aborted);
+              }
+            } catch (error) {
+              if (!aborted.value) {
+                const errResponse = error instanceof Response ? error : new Response(error instanceof Error ? error.message : String(error), { status: 500 });
+                await sendUwsResponse(res, errResponse, aborted);
+              }
+            }
+          });
+        }
+      }
+      const fallbackRouter = new Router();
+      let match = null;
+      if (fallbackRoutes.length > 0) {
+        for (const route of fallbackRoutes) {
+          if (route.handler) {
+            const executor = createExecutor(uwsContextFactory, route.handler, route.schema);
+            fallbackRouter.registerCompiled(route.method, route.path, executor, route.schema);
+          } else if (route.staticValue !== void 0) {
+            const staticValue = route.staticValue;
+            fallbackRouter.registerCompiled(route.method, route.path, () => staticValue, route.schema, toResponse(staticValue));
+          }
+        }
+        match = fallbackRouter.matcher();
+      }
+      const notFoundExecutor = createNotFoundExecutor(router, uwsContextFactory);
+      app.any("/*", async (res, req) => {
+        const aborted = { value: false };
+        res.onAborted(() => {
+          aborted.value = true;
+        });
+        const method = req.getMethod().toUpperCase();
+        const pathname = req.getUrl();
+        const matchResult = match ? match(method, pathname) : void 0;
+        if (matchResult !== void 0) {
+          const getRemoteInfo = getRemoteInfoFromUws(res);
+          try {
+            if (matchResult.response !== void 0) {
+              await sendUwsResponse(res, matchResult.response.clone(), aborted);
+            } else {
+              const result = await matchResult.handler({ req, res }, matchResult.params, getRemoteInfo);
+              if (!aborted.value) {
+                const response = toResponse(result);
+                await sendUwsResponse(res, response, aborted);
+              }
+            }
+          } catch (error) {
+            if (!aborted.value) {
+              const errResponse = error instanceof Response ? error : new Response(error instanceof Error ? error.message : String(error), { status: 500 });
+              await sendUwsResponse(res, errResponse, aborted);
+            }
+          }
+        } else {
+          if (notFoundExecutor) {
+            const getRemoteInfo = getRemoteInfoFromUws(res);
+            try {
+              const result = await notFoundExecutor({ req, res }, getRemoteInfo, pathname);
+              if (!aborted.value) {
+                const response = toResponse(result);
+                await sendUwsResponse(res, response, aborted);
+              }
+            } catch (error) {
+              if (!aborted.value) {
+                const errResponse = error instanceof Response ? error : new Response(error instanceof Error ? error.message : String(error), { status: 500 });
+                await sendUwsResponse(res, errResponse, aborted);
+              }
+            }
+          } else {
+            res.cork(() => {
+              res.writeStatus("404").end("Not Found");
+            });
+          }
+        }
+      });
+      return new Promise((resolve, reject) => {
+        const listenPort = port || 3e3;
+        const listenHost = hostname || "0.0.0.0";
+        app.listen(listenHost, listenPort, (token) => {
+          if (token) {
+            listenSocket = token;
+            resolve({ hostname: listenHost, port: listenPort });
+          } else {
+            reject(new Error(`Failed to listen on ${listenHost}:${listenPort}`));
+          }
+        });
+      });
+    },
+    stop() {
+      if (listenSocket) {
+        listenSocket.close();
+        listenSocket = void 0;
+      }
+    }
+  };
+}
+export {
+  server
+};
+//# sourceMappingURL=uws-VNY2LPIZ.js.map