@kichu12348/bunify 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kichu12348/bunify",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kichu12348/bunify.git"

package/src/core.ts

@@ -22,10 +22,10 @@ export type BunifyRequest<T extends RouteSchema = RouteSchema, D = {}> = {
 
 type Reply = ReturnType<typeof createReply>;
 
-export type BunifyReply<T extends RouteSchema = RouteSchema> = Reply & {
-  send: (content: T["Reply"] | Response) => Response;
-  json: (data: T["Reply"]) => Response;
-};
+// export type BunifyReply<T extends RouteSchema = RouteSchema> = Reply & {
+//   send: (content: T["Reply"] | Response) => Response;
+//   json: (data: T["Reply"]) => Response;
+// };
 
 export type Handler<T extends RouteSchema = RouteSchema, D = {}> = (
   request: BunifyRequest<T, D>,
@@ -68,59 +68,67 @@ interface RegisterOptions {
   prefix?: string;
 }
 
-function createReply() {
-  let status = 200;
-  const headers = new Headers();
-  let body: any = null;
-  let sent = false;
-
-  return {
-    get sent() {
-      return sent;
-    },
-
-    status(code: number) {
-      status = code;
-      return this;
-    },
-    code(code: number) {
-      return this.status(code);
-    },
-    headers(key: string, value: string) {
-      headers.set(key, value);
-      return this;
-    },
-    json(data: any) {
-      return this.headers("Content-Type", "application/json").send(data);
-    },
-    redirect(url: string) {
-      return this.status(302).headers("Location", url).send(null);
-    },
-    html(content: string) {
-      return this.headers("Content-Type", "text/html").send(content);
-    },
-    send(content: any) {
-      if (sent) {
-        throw new Error("Reply has already been sent.");
-      }
-      sent = true;
-      if (content instanceof Response) return content;
+// Look at how lean this is! No closures, no heavy standard objects.
+export class BunifyReply<T extends RouteSchema = RouteSchema> {
+  private _status: number = 200;
+  private _headers: Record<string, string> = {}; // Fast, plain object
+  private _body: any = null;
+  public sent: boolean = false;
 
-      if (typeof content === "object") {
-        headers.set("Content-Type", "application/json");
-        content = JSON.stringify(content);
-      }
+  status(code: number) {
+    this._status = code;
+    return this;
+  }
 
-      body = content;
-      return this.build();
-    },
+  code(code: number) {
+    return this.status(code);
+  }
 
-    build() {
-      if (body instanceof Response) return body;
+  headers(key: string, value: string) {
+    this._headers[key] = value;
+    return this;
+  }
 
-      return new Response(body, { status, headers });
-    },
-  };
+  json(data: T["Reply"]) {
+    return this.headers("Content-Type", "application/json").send(data);
+  }
+
+  redirect(url: string) {
+    return this.status(302).headers("Location", url).send(null);
+  }
+
+  html(content: string) {
+    return this.headers("Content-Type", "text/html").send(content);
+  }
+
+  send(content: T["Reply"] | Response | null) {
+    if (this.sent) {
+      throw new Error("Reply has already been sent.");
+    }
+    this.sent = true;
+
+    if (content instanceof Response) return content;
+
+    if (typeof content === "object" && content !== null) {
+      this._headers["Content-Type"] = "application/json";
+      content = JSON.stringify(content) as any;
+    }
+
+    this._body = content;
+    return this.build();
+  }
+
+  build() {
+    if (this._body instanceof Response) return this._body;
+    return new Response(this._body, {
+      status: this._status,
+      headers: this._headers,
+    });
+  }
+}
+
+function createReply() {
+  return new BunifyReply();
 }
 
 export class Bunify<Decorators extends Record<string, any> = {}> {
@@ -156,14 +164,26 @@ export class Bunify<Decorators extends Record<string, any> = {}> {
       handler,
     );
     const wrappedHandler = async (req: Bun.BunRequest) => {
-      const url = new URL(req.url);
-
+      let parsedQuery: any = null;
       const request: BunifyRequest<T, Decorators> = {
         raw: req,
-        query: Object.fromEntries(url.searchParams.entries()) as BunifyRequest<
-          T,
-          Decorators
-        >["query"],
+        // Lazily parse query parameters when accessed for the first time to optimize performance
+        get query() {
+          if (parsedQuery !== null) return parsedQuery;
+
+          const urlStr = req.url;
+          const queryStart = urlStr.indexOf("?", 8);
+
+          if (queryStart === -1) {
+            parsedQuery = {};
+            return parsedQuery;
+          }
+
+          const queryString = urlStr.substring(queryStart + 1);
+          parsedQuery = Object.fromEntries(new URLSearchParams(queryString));
+
+          return parsedQuery;
+        },
         params: (req.params || {}) as BunifyRequest<T, Decorators>["params"],
         json: () => req.json(),
         text: () => req.text(),
@@ -207,23 +227,15 @@ export class Bunify<Decorators extends Record<string, any> = {}> {
       request: BunifyRequest<T, Decorators>,
       reply: BunifyReply<T>,
     ) => {
-      let index = -1;
-      const next = async (i: number): Promise<any> => {
-        if (i <= index) {
-          throw new Error("next() called multiple times");
-        }
-        index = i;
-
-        if (i === middlewares.length) {
-          return handler(request, reply);
+      for (let i = 0; i < middlewares.length; i++) {
+        const fn = middlewares[i];
+        if (fn) {
+          await fn(request, reply, async () => {});
+          if (reply.sent) return;
         }
-
-        const mw = middlewares[i];
-        if (mw) {
-          return mw(request, reply, () => next(i + 1));
-        }
-      };
-      return next(0);
+      }
+      const res = await handler(request, reply);
+      if (res !== undefined && !reply.sent) return reply.send(res);
     };
   }
 
@@ -236,25 +248,18 @@ export class Bunify<Decorators extends Record<string, any> = {}> {
     return { handler, middlewares };
   }
 
-  private runHooks<T extends RouteSchema>(
+  private async runHooks<T extends RouteSchema>(
     hooks: Middleware<T, Decorators>[],
     request: BunifyRequest<T, Decorators>,
     reply: BunifyReply<T>,
   ) {
-    let index = -1;
-
-    const next = async (i: number): Promise<any> => {
-      if (i <= index) {
-        throw new Error("next() called multiple times in hooks");
-      }
-      index = i;
-
+    for (let i = 0; i < hooks.length; i++) {
       const fn = hooks[i];
-      if (!fn) return;
-
-      return fn(request, reply, () => next(i + 1));
-    };
-    return next(0);
+      if (fn) {
+        await fn(request, reply, async () => {});
+        if (reply.sent) return;
+      }
+    }
   }
 
   private async runPipeline<T extends RouteSchema>(
@@ -262,29 +267,34 @@ export class Bunify<Decorators extends Record<string, any> = {}> {
     reply: BunifyReply<T>,
     handler: Handler<T, Decorators>,
   ) {
-    let res = await this.runHooks(
-      this.hooks.onRequest as Middleware<T, Decorators>[],
-      request,
-      reply,
-    );
-    if (reply.sent) return;
-
-    res = await this.runHooks(
-      this.hooks.preHandler as Middleware<T, Decorators>[],
-      request,
-      reply,
-    );
-    if (reply.sent) return;
+    if (this.hooks.onRequest.length > 0) {
+      await this.runHooks(
+        this.hooks.onRequest as Middleware<T, Decorators>[],
+        request,
+        reply,
+      );
+      if (reply.sent) return;
+    }
 
-    res = await handler(request, reply);
-    if (reply.sent) return res;
+    if (this.hooks.preHandler.length > 0) {
+      await this.runHooks(
+        this.hooks.preHandler as Middleware<T, Decorators>[],
+        request,
+        reply,
+      );
+      if (reply.sent) return;
+    }
 
-    await this.runHooks(
-      this.hooks.onResponse as Middleware<T, Decorators>[],
-      request,
-      reply,
-    );
+    const res = await handler(request, reply);
+    if (res !== undefined && !reply.sent) return reply.send(res);
 
+    if (this.hooks.onResponse.length > 0) {
+      await this.runHooks(
+        this.hooks.onResponse as Middleware<T, Decorators>[],
+        request,
+        reply,
+      );
+    }
     return res;
   }
 
@@ -360,9 +370,13 @@ export class Bunify<Decorators extends Record<string, any> = {}> {
     this.addRoute("PATCH", path, handlers);
   }
 
-  listen(port: number, callback?: (address: string) => void) {
+  listen(
+    { port, host = "" }: { port: number; host?: string },
+    callback?: (address: string) => void,
+  ) {
     const server = Bun.serve({
       port: port,
+      hostname: host,
       routes: this.routes,
       fetch: async () => {
         return new Response("Not Found", { status: 404 });