cpeak 2.4.3 → 2.6.0

package/dist/index.js

@@ -4,6 +4,60 @@ import fs3 from "fs/promises";
 import { createReadStream } from "fs";
 import { pipeline } from "stream/promises";
 
+// lib/utils/parseJSON.ts
+import { Buffer as Buffer2 } from "buffer";
+function isJSON(contentType) {
+  if (!contentType) return false;
+  if (contentType === "application/json") return true;
+  return contentType.startsWith("application/json") || contentType.includes("+json");
+}
+var parseJSON = (options = {}) => {
+  const limit = options.limit || 1024 * 1024;
+  return (req, res, next) => {
+    if (!isJSON(req.headers["content-type"])) return next();
+    const chunks = [];
+    let bytesReceived = 0;
+    const onData = (chunk) => {
+      bytesReceived += chunk.length;
+      if (bytesReceived > limit) {
+        req.pause();
+        req.removeListener("data", onData);
+        req.removeListener("end", onEnd);
+        next(
+          frameworkError(
+            "JSON body too large",
+            onData,
+            "CPEAK_ERR_PAYLOAD_TOO_LARGE" /* PAYLOAD_TOO_LARGE */,
+            413
+            // HTTP 413 Payload Too Large
+          )
+        );
+        return;
+      }
+      chunks.push(chunk);
+    };
+    const onEnd = () => {
+      try {
+        const rawBody = chunks.length === 1 ? chunks[0].toString("utf-8") : Buffer2.concat(chunks).toString("utf-8");
+        req.body = rawBody ? JSON.parse(rawBody) : {};
+        next();
+      } catch (err) {
+        next(
+          frameworkError(
+            "Invalid JSON format",
+            onEnd,
+            "CPEAK_ERR_INVALID_JSON" /* INVALID_JSON */,
+            400
+            // HTTP 400 Bad Request
+          )
+        );
+      }
+    };
+    req.on("data", onData);
+    req.on("end", onEnd);
+  };
+};
+
 // lib/utils/serveStatic.ts
 import fs from "fs";
 import path from "path";
@@ -20,12 +74,17 @@ var MIME_TYPES = {
   otf: "font/otf",
   ttf: "font/ttf",
   woff: "font/woff",
-  woff2: "font/woff2"
+  woff2: "font/woff2",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  json: "application/json",
+  webmanifest: "application/manifest+json"
 };
-var serveStatic = (folderPath, newMimeTypes) => {
+var serveStatic = (folderPath, newMimeTypes, options) => {
   if (newMimeTypes) {
     Object.assign(MIME_TYPES, newMimeTypes);
   }
+  const prefix = options?.prefix ?? "";
   function processFolder(folderPath2, parentFolder) {
     const staticFiles = [];
     const files = fs.readdirSync(folderPath2);
@@ -46,7 +105,7 @@ var serveStatic = (folderPath, newMimeTypes) => {
     const filesMap2 = {};
     for (const file of filesArray) {
       const fileExtension = path.extname(file).slice(1);
-      filesMap2[file] = {
+      filesMap2[prefix + file] = {
         path: folderPath + file,
         mime: MIME_TYPES[fileExtension]
       };
@@ -57,32 +116,15 @@ var serveStatic = (folderPath, newMimeTypes) => {
   return function(req, res, next) {
     const url = req.url;
     if (typeof url !== "string") return next();
-    if (Object.prototype.hasOwnProperty.call(filesMap, url)) {
-      const fileRoute = filesMap[url];
+    const pathname = url.split("?")[0];
+    if (Object.prototype.hasOwnProperty.call(filesMap, pathname)) {
+      const fileRoute = filesMap[pathname];
       return res.sendFile(fileRoute.path, fileRoute.mime);
     }
     next();
   };
 };
 
-// lib/utils/parseJSON.ts
-var parseJSON = (req, res, next) => {
-  function isJSON(contentType = "") {
-    const [type] = contentType.split(";");
-    return type.trim().toLowerCase() === "application/json" || /\+json$/i.test(type.trim());
-  }
-  if (!isJSON(req.headers["content-type"])) return next();
-  let body = "";
-  req.on("data", (chunk) => {
-    body += chunk.toString("utf-8");
-  });
-  req.on("end", () => {
-    body = JSON.parse(body);
-    req.body = body;
-    return next();
-  });
-};
-
 // lib/utils/render.ts
 import fs2 from "fs/promises";
 function renderTemplate(templateStr, data) {
@@ -108,7 +150,6 @@ function renderTemplate(templateStr, data) {
   return result.join("");
 }
 var render = () => {
-  console.log("render.ts loaded");
   return function(req, res, next) {
     res.render = async (path2, data, mime) => {
       if (!mime) {
@@ -126,11 +167,270 @@ var render = () => {
   };
 };
 
+// lib/utils/swagger.ts
+var swagger = (spec, prefix = "/api-docs") => {
+  const initializerJs = `window.onload = function() {
+  SwaggerUIBundle({
+    url: "${prefix}/spec.json",
+    dom_id: '#swagger-ui',
+    presets: [SwaggerUIBundle.presets.apis, SwaggerUIStandalonePreset],
+    layout: "StandaloneLayout"
+  });
+};`;
+  return (req, res, next) => {
+    if (req.url === prefix || req.url === `${prefix}/`) {
+      res.writeHead(302, { Location: `${prefix}/index.html` });
+      res.end();
+      return;
+    }
+    if (req.url === `${prefix}/spec.json`) {
+      return res.json(spec);
+    }
+    if (req.url === `${prefix}/swagger-initializer.js`) {
+      res.setHeader("Content-Type", "application/javascript");
+      res.end(initializerJs);
+      return;
+    }
+    next();
+  };
+};
+
+// lib/utils/auth.ts
+import { randomBytes, pbkdf2, createHmac, timingSafeEqual } from "crypto";
+import { promisify } from "util";
+var pbkdf2Async = promisify(pbkdf2);
+var DEFAULTS = {
+  iterations: 21e4,
+  keylen: 64,
+  digest: "sha512",
+  saltSize: 32,
+  hmacAlgorithm: "sha256",
+  tokenIdSize: 20,
+  tokenExpiry: 7 * 24 * 60 * 60 * 1e3
+  // 7 days in ms
+};
+async function hashPassword(password, options) {
+  const iterations = options?.iterations ?? DEFAULTS.iterations;
+  const keylen = options?.keylen ?? DEFAULTS.keylen;
+  const digest = options?.digest ?? DEFAULTS.digest;
+  const saltSize = options?.saltSize ?? DEFAULTS.saltSize;
+  const salt = randomBytes(saltSize);
+  const hash = await pbkdf2Async(password, salt, iterations, keylen, digest);
+  return `pbkdf2:${iterations}:${keylen}:${digest}:${salt.toString("hex")}:${hash.toString("hex")}`;
+}
+async function verifyPassword(password, stored) {
+  const withoutPrefix = stored.slice(stored.indexOf(":") + 1);
+  const parts = withoutPrefix.split(":");
+  if (parts.length !== 5) return false;
+  const [itersStr, keylenStr, digest, saltHex, hashHex] = parts;
+  const iterations = parseInt(itersStr, 10);
+  const keylen = parseInt(keylenStr, 10);
+  if (!digest || !saltHex || !hashHex || isNaN(iterations) || isNaN(keylen))
+    return false;
+  const salt = Buffer.from(saltHex, "hex");
+  const hash = await pbkdf2Async(password, salt, iterations, keylen, digest);
+  const storedHash = Buffer.from(hashHex, "hex");
+  if (storedHash.length !== hash.length) return false;
+  return timingSafeEqual(hash, storedHash);
+}
+function signToken(tokenId, secret, algorithm) {
+  const sig = createHmac(algorithm, secret).update(tokenId).digest("hex");
+  return `${tokenId}.${sig}`;
+}
+function extractTokenId(token, secret, algorithm) {
+  const dot = token.indexOf(".");
+  if (dot === -1) return null;
+  const tokenId = token.slice(0, dot);
+  const sig = token.slice(dot + 1);
+  const expected = createHmac(algorithm, secret).update(tokenId).digest("hex");
+  const expectedBuf = Buffer.from(expected, "hex");
+  const actualBuf = Buffer.from(sig, "hex");
+  if (expectedBuf.length !== actualBuf.length) return null;
+  if (!timingSafeEqual(expectedBuf, actualBuf)) return null;
+  return tokenId;
+}
+function auth(options) {
+  if (!options.secret || options.secret.length < 32) {
+    throw frameworkError(
+      "Secret must be at least 32 characters. HMAC security is only as strong as the key.",
+      auth,
+      "CPEAK_ERR_WEAK_SECRET" /* WEAK_SECRET */
+    );
+  }
+  const {
+    secret,
+    saveToken,
+    findToken,
+    revokeToken,
+    tokenExpiry = DEFAULTS.tokenExpiry,
+    hmacAlgorithm = DEFAULTS.hmacAlgorithm,
+    tokenIdSize = DEFAULTS.tokenIdSize
+  } = options;
+  const pbkdfOpts = {
+    iterations: options.iterations,
+    keylen: options.keylen,
+    digest: options.digest,
+    saltSize: options.saltSize
+  };
+  const _hashPassword = ({ password }) => hashPassword(password, pbkdfOpts);
+  const login = async ({
+    password,
+    hashedPassword,
+    userId
+  }) => {
+    const isMatch = await verifyPassword(password, hashedPassword);
+    if (!isMatch) return null;
+    const tokenId = randomBytes(tokenIdSize).toString("hex");
+    const token = signToken(tokenId, secret, hmacAlgorithm);
+    await saveToken(tokenId, userId, new Date(Date.now() + tokenExpiry));
+    return token;
+  };
+  const verifyToken = async (token) => {
+    if (!token) return null;
+    const tokenId = extractTokenId(token, secret, hmacAlgorithm);
+    if (!tokenId) return null;
+    const record = await findToken(tokenId);
+    if (!record) return null;
+    if (new Date(record.expiresAt) < /* @__PURE__ */ new Date()) return null;
+    return { userId: record.userId };
+  };
+  const logout = revokeToken ? async (token) => {
+    const tokenId = extractTokenId(token, secret, hmacAlgorithm);
+    if (!tokenId) return false;
+    await revokeToken(tokenId);
+    return true;
+  } : void 0;
+  return (req, _res, next) => {
+    req.hashPassword = _hashPassword;
+    req.login = login;
+    req.verifyToken = verifyToken;
+    if (logout) req.logout = logout;
+    next();
+  };
+}
+
+// lib/utils/cookieParser.ts
+import { createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+function sign(value, secret) {
+  const sig = createHmac2("sha256", secret).update(value).digest("base64url");
+  return `s:${value}.${sig}`;
+}
+function unsign(signed, secret) {
+  if (!signed.startsWith("s:")) return false;
+  const withoutPrefix = signed.slice(2);
+  const lastDot = withoutPrefix.lastIndexOf(".");
+  if (lastDot === -1) return false;
+  const value = withoutPrefix.slice(0, lastDot);
+  const sig = withoutPrefix.slice(lastDot + 1);
+  const expected = createHmac2("sha256", secret).update(value).digest("base64url");
+  const expectedBuf = Buffer.from(expected);
+  const actualBuf = Buffer.from(sig);
+  if (expectedBuf.length !== actualBuf.length) return false;
+  if (!timingSafeEqual2(expectedBuf, actualBuf)) return false;
+  return value;
+}
+function parseRawCookies(header) {
+  const cookies = /* @__PURE__ */ Object.create(null);
+  if (!header) return cookies;
+  const pairs = header.split(";");
+  for (let i = 0; i < pairs.length; i++) {
+    const pair = pairs[i];
+    const equalSignIndex = pair.indexOf("=");
+    if (equalSignIndex === -1) continue;
+    const key = pair.slice(0, equalSignIndex).trim();
+    if (!key || cookies[key] !== void 0) continue;
+    let val = pair.slice(equalSignIndex + 1).trim();
+    if (val.length > 1 && val[0] === '"' && val[val.length - 1] === '"') {
+      val = val.slice(1, -1);
+    }
+    try {
+      cookies[key] = val.indexOf("%") !== -1 ? decodeURIComponent(val) : val;
+    } catch (e) {
+      cookies[key] = val;
+    }
+  }
+  return cookies;
+}
+function buildSetCookieHeader(name, value, options) {
+  const parts = [`${name}=${encodeURIComponent(value)}`];
+  const path2 = options.path ?? "/";
+  parts.push(`Path=${path2}`);
+  if (options.domain) parts.push(`Domain=${options.domain}`);
+  if (options.maxAge !== void 0)
+    parts.push(`Max-Age=${Math.floor(options.maxAge / 1e3)}`);
+  if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+  if (options.httpOnly) parts.push("HttpOnly");
+  if (options.secure) parts.push("Secure");
+  if (options.sameSite) parts.push(`SameSite=${options.sameSite}`);
+  return parts.join("; ");
+}
+function appendSetCookie(res, header) {
+  const existing = res.getHeader("Set-Cookie");
+  if (!existing) {
+    res.setHeader("Set-Cookie", [header]);
+  } else if (Array.isArray(existing)) {
+    res.setHeader("Set-Cookie", [...existing, header]);
+  } else {
+    res.setHeader("Set-Cookie", [String(existing), header]);
+  }
+}
+function cookieParser(options = {}) {
+  const { secret } = options;
+  if (secret !== void 0 && secret.length < 32) {
+    throw frameworkError(
+      "Secret must be at least 32 characters. HMAC security is only as strong as the key.",
+      cookieParser,
+      "CPEAK_ERR_WEAK_SECRET" /* WEAK_SECRET */
+    );
+  }
+  return (req, res, next) => {
+    const rawHeader = req.headers["cookie"] || "";
+    const raw = parseRawCookies(rawHeader);
+    const cookies = /* @__PURE__ */ Object.create(null);
+    const signedCookies = /* @__PURE__ */ Object.create(null);
+    for (const [key, val] of Object.entries(raw)) {
+      if (val.startsWith("s:") && secret) {
+        signedCookies[key] = unsign(val, secret);
+      } else {
+        cookies[key] = val;
+      }
+    }
+    req.cookies = cookies;
+    req.signedCookies = signedCookies;
+    res.cookie = (name, value, options2 = {}) => {
+      let finalValue = value;
+      if (options2.signed) {
+        if (!secret)
+          throw new Error(
+            "cookieParser: secret is required to use signed cookies"
+          );
+        finalValue = sign(value, secret);
+      }
+      appendSetCookie(res, buildSetCookieHeader(name, finalValue, options2));
+      return res;
+    };
+    res.clearCookie = (name, options2 = {}) => {
+      appendSetCookie(
+        res,
+        buildSetCookieHeader(name, "", {
+          ...options2,
+          maxAge: 0,
+          expires: /* @__PURE__ */ new Date(0)
+        })
+      );
+      return res;
+    };
+    next();
+  };
+}
+
 // lib/index.ts
-function frameworkError(message, skipFn, code) {
+function frameworkError(message, skipFn, code, status) {
   const err = new Error(message);
   Error.captureStackTrace(err, skipFn);
+  err.cpeak_err = true;
   if (code) err.code = code;
+  if (status) err.status = status;
   return err;
 }
 var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
@@ -138,196 +438,242 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   ErrorCode2["FILE_NOT_FOUND"] = "CPEAK_ERR_FILE_NOT_FOUND";
   ErrorCode2["NOT_A_FILE"] = "CPEAK_ERR_NOT_A_FILE";
   ErrorCode2["SEND_FILE_FAIL"] = "CPEAK_ERR_SEND_FILE_FAIL";
+  ErrorCode2["INVALID_JSON"] = "CPEAK_ERR_INVALID_JSON";
+  ErrorCode2["PAYLOAD_TOO_LARGE"] = "CPEAK_ERR_PAYLOAD_TOO_LARGE";
+  ErrorCode2["WEAK_SECRET"] = "CPEAK_ERR_WEAK_SECRET";
   return ErrorCode2;
 })(ErrorCode || {});
+var CpeakIncomingMessage = class extends http.IncomingMessage {
+  // We define body and params here for better V8 optimization (not changing the shape of the object at runtime)
+  body = void 0;
+  params = {};
+  #query;
+  // Parse the URL parameters (like /users?key1=value1&key2=value2)
+  // We will call this query to be more familiar with other node.js frameworks.
+  // This is a getter method (accessed like a property)
+  get query() {
+    if (this.#query) return this.#query;
+    const url = this.url || "";
+    const qIndex = url.indexOf("?");
+    if (qIndex === -1) {
+      this.#query = {};
+    } else {
+      const searchParams = new URLSearchParams(url.substring(qIndex + 1));
+      this.#query = Object.fromEntries(searchParams.entries());
+    }
+    return this.#query;
+  }
+};
+var CpeakServerResponse = class extends http.ServerResponse {
+  // Send a file back to the client
+  async sendFile(path2, mime) {
+    if (!mime) {
+      throw frameworkError(
+        'MIME type is missing. Use res.sendFile(path, "mime-type").',
+        this.sendFile,
+        "CPEAK_ERR_MISSING_MIME" /* MISSING_MIME */
+      );
+    }
+    try {
+      const stat = await fs3.stat(path2);
+      if (!stat.isFile()) {
+        throw frameworkError(
+          `Not a file: ${path2}`,
+          this.sendFile,
+          "CPEAK_ERR_NOT_A_FILE" /* NOT_A_FILE */
+        );
+      }
+      this.setHeader("Content-Type", mime);
+      this.setHeader("Content-Length", String(stat.size));
+      await pipeline(createReadStream(path2), this);
+    } catch (err) {
+      if (err?.code === "ENOENT") {
+        throw frameworkError(
+          `File not found: ${path2}`,
+          this.sendFile,
+          "CPEAK_ERR_FILE_NOT_FOUND" /* FILE_NOT_FOUND */
+        );
+      }
+      throw frameworkError(
+        `Failed to send file: ${path2}`,
+        this.sendFile,
+        "CPEAK_ERR_SEND_FILE_FAIL" /* SEND_FILE_FAIL */
+      );
+    }
+  }
+  // Set the status code of the response
+  status(code) {
+    this.statusCode = code;
+    return this;
+  }
+  // Set the Content-Disposition header to prompt the user to download a file
+  attachment(filename) {
+    const contentDisposition = filename ? `attachment; filename="${filename}"` : "attachment";
+    this.setHeader("Content-Disposition", contentDisposition);
+    return this;
+  }
+  // Redirects to a new URL
+  redirect(location) {
+    this.writeHead(302, { Location: location });
+    this.end();
+  }
+  // Send a json data back to the client (for small json data, less than the highWaterMark)
+  json(data) {
+    this.setHeader("Content-Type", "application/json");
+    this.end(JSON.stringify(data));
+  }
+};
 var Cpeak = class {
-  server;
-  routes;
-  middleware;
-  _handleErr;
+  #server;
+  #routes;
+  #middleware;
+  #handleErr;
   constructor() {
-    this.server = http.createServer();
-    this.routes = {};
-    this.middleware = [];
-    this.server.on("request", (req, res) => {
-      res.sendFile = async (path2, mime) => {
-        if (!mime) {
-          throw frameworkError(
-            'MIME type is missing. Use res.sendFile(path, "mime-type").',
-            res.sendFile,
-            "CPEAK_ERR_MISSING_MIME" /* MISSING_MIME */
-          );
-        }
-        try {
-          const stat = await fs3.stat(path2);
-          if (!stat.isFile()) {
-            throw frameworkError(
-              `Not a file: ${path2}`,
-              res.sendFile,
-              "CPEAK_ERR_NOT_A_FILE" /* NOT_A_FILE */
-            );
-          }
-          res.setHeader("Content-Type", mime);
-          res.setHeader("Content-Length", String(stat.size));
-          await pipeline(createReadStream(path2), res);
-        } catch (err) {
-          if (err?.code === "ENOENT") {
-            throw frameworkError(
-              `File not found: ${path2}`,
-              res.sendFile,
-              "CPEAK_ERR_FILE_NOT_FOUND" /* FILE_NOT_FOUND */
-            );
+    this.#server = http.createServer({
+      IncomingMessage: CpeakIncomingMessage,
+      ServerResponse: CpeakServerResponse
+    });
+    this.#routes = {};
+    this.#middleware = [];
+    this.#server.on(
+      "request",
+      async (req, res) => {
+        const qIndex = req.url?.indexOf("?");
+        const urlWithoutQueries = qIndex === -1 ? req.url || "" : req.url?.substring(0, qIndex);
+        const dispatchError = (error) => {
+          if (res.headersSent) {
+            req.socket?.destroy();
+            return;
           }
-          throw frameworkError(
-            `Failed to send file: ${path2}`,
-            res.sendFile,
-            "CPEAK_ERR_SEND_FILE_FAIL" /* SEND_FILE_FAIL */
-          );
-        }
-      };
-      res.status = (code) => {
-        res.statusCode = code;
-        return res;
-      };
-      res.redirect = (location) => {
-        res.writeHead(302, { Location: location });
-        res.end();
-        return res;
-      };
-      res.json = (data) => {
-        res.setHeader("Content-Type", "application/json");
-        res.end(JSON.stringify(data));
-      };
-      const urlWithoutParams = req.url?.split("?")[0];
-      const params = new URLSearchParams(req.url?.split("?")[1]);
-      const paramsObject = Object.fromEntries(params.entries());
-      req.params = paramsObject;
-      req.query = paramsObject;
-      const runHandler = (req2, res2, middleware, cb, index) => {
-        if (index === middleware.length) {
-          try {
-            const handlerResult = cb(req2, res2, (error) => {
-              res2.setHeader("Connection", "close");
-              this._handleErr?.(error, req2, res2);
-            });
-            if (handlerResult && typeof handlerResult.then === "function") {
-              handlerResult.catch((error) => {
-                res2.setHeader("Connection", "close");
-                this._handleErr?.(error, req2, res2);
-              });
+          res.setHeader("Connection", "close");
+          this.#handleErr?.(error, req, res);
+        };
+        const runHandler = async (req2, res2, middleware, cb, index) => {
+          if (index === middleware.length) {
+            try {
+              await cb(req2, res2, dispatchError);
+            } catch (error) {
+              dispatchError(error);
+            }
+          } else {
+            try {
+              await middleware[index](
+                req2,
+                res2,
+                // The next function
+                async (error) => {
+                  if (error) {
+                    return dispatchError(error);
+                  }
+                  await runHandler(req2, res2, middleware, cb, index + 1);
+                },
+                // Error handler for a route middleware
+                dispatchError
+              );
+            } catch (error) {
+              dispatchError(error);
             }
-            return handlerResult;
-          } catch (error) {
-            res2.setHeader("Connection", "close");
-            this._handleErr?.(error, req2, res2);
           }
-        } else {
-          try {
-            const middlewareResult = middleware[index](
-              req2,
-              res2,
-              // The next function
-              (error) => {
-                if (error) {
-                  res2.setHeader("Connection", "close");
-                  return this._handleErr?.(error, req2, res2);
+        };
+        const runMiddleware = async (req2, res2, middleware, index) => {
+          if (index === middleware.length) {
+            const routes = this.#routes[req2.method?.toLowerCase() || ""];
+            if (routes && typeof routes[Symbol.iterator] === "function")
+              for (const route of routes) {
+                const match = urlWithoutQueries?.match(route.regex);
+                if (match) {
+                  const pathVariables = this.#extractPathVariables(
+                    route.path,
+                    match
+                  );
+                  req2.params = pathVariables;
+                  return await runHandler(
+                    req2,
+                    res2,
+                    route.middleware,
+                    route.cb,
+                    0
+                  );
                 }
-                runHandler(req2, res2, middleware, cb, index + 1);
-              },
-              // Error handler for a route middleware
-              (error) => {
-                res2.setHeader("Connection", "close");
-                this._handleErr?.(error, req2, res2);
               }
-            );
-            if (middlewareResult && typeof middlewareResult.then === "function") {
-              middlewareResult.catch((error) => {
-                res2.setHeader("Connection", "close");
-                this._handleErr?.(error, req2, res2);
+            return res2.status(404).json({ error: `Cannot ${req2.method} ${urlWithoutQueries}` });
+          } else {
+            try {
+              await middleware[index](req2, res2, async (err) => {
+                if (err) {
+                  return dispatchError(err);
+                }
+                await runMiddleware(req2, res2, middleware, index + 1);
               });
+            } catch (error) {
+              dispatchError(error);
             }
-          } catch (error) {
-            res2.setHeader("Connection", "close");
-            this._handleErr?.(error, req2, res2);
           }
-        }
-      };
-      const runMiddleware = (req2, res2, middleware, index) => {
-        if (index === middleware.length) {
-          const routes = this.routes[req2.method?.toLowerCase() || ""];
-          if (routes && typeof routes[Symbol.iterator] === "function")
-            for (const route of routes) {
-              const match = urlWithoutParams?.match(route.regex);
-              if (match) {
-                const vars = this.#extractVars(route.path, match);
-                req2.vars = vars;
-                return runHandler(req2, res2, route.middleware, route.cb, 0);
-              }
-            }
-          return res2.status(404).json({ error: `Cannot ${req2.method} ${urlWithoutParams}` });
-        } else {
-          middleware[index](req2, res2, () => {
-            runMiddleware(req2, res2, middleware, index + 1);
-          });
-        }
-      };
-      runMiddleware(req, res, this.middleware, 0);
-    });
+        };
+        await runMiddleware(req, res, this.#middleware, 0);
+      }
+    );
   }
   route(method, path2, ...args) {
-    if (!this.routes[method]) this.routes[method] = [];
+    if (!this.#routes[method]) this.#routes[method] = [];
     const cb = args.pop();
     if (!cb || typeof cb !== "function") {
       throw new Error("Route definition must include a handler");
     }
     const middleware = args.flat();
     const regex = this.#pathToRegex(path2);
-    this.routes[method].push({ path: path2, regex, middleware, cb });
+    this.#routes[method].push({ path: path2, regex, middleware, cb });
   }
   beforeEach(cb) {
-    this.middleware.push(cb);
+    this.#middleware.push(cb);
   }
   handleErr(cb) {
-    this._handleErr = cb;
+    this.#handleErr = cb;
   }
   listen(port, cb) {
-    return this.server.listen(port, cb);
+    return this.#server.listen(port, cb);
+  }
+  address() {
+    return this.#server.address();
   }
   close(cb) {
-    this.server.close(cb);
+    this.#server.close(cb);
   }
   // ------------------------------
   // PRIVATE METHODS:
   // ------------------------------
   #pathToRegex(path2) {
-    const varNames = [];
-    const regexString = "^" + path2.replace(/:\w+/g, (match, offset) => {
-      varNames.push(match.slice(1));
-      return "([^/]+)";
-    }) + "$";
-    const regex = new RegExp(regexString);
-    return regex;
+    const regexString = "^" + path2.replace(/:\w+/g, "([^/]+)").replace(/\*/g, ".*") + "$";
+    return new RegExp(regexString);
   }
-  #extractVars(path2, match) {
-    const varNames = (path2.match(/:\w+/g) || []).map(
-      (varParam) => varParam.slice(1)
+  #extractPathVariables(path2, match) {
+    const paramNames = (path2.match(/:\w+/g) || []).map(
+      (param) => param.slice(1)
     );
-    const vars = {};
-    varNames.forEach((name, index) => {
-      vars[name] = match[index + 1];
+    const params = {};
+    paramNames.forEach((name, index) => {
+      params[name] = match[index + 1];
     });
-    return vars;
+    return params;
   }
 };
 function cpeak() {
   return new Cpeak();
 }
 export {
+  Cpeak,
+  CpeakIncomingMessage,
+  CpeakServerResponse,
   ErrorCode,
+  auth,
+  cookieParser,
   cpeak as default,
   frameworkError,
+  hashPassword,
   parseJSON,
   render,
-  serveStatic
+  serveStatic,
+  swagger,
+  verifyPassword
 };
 //# sourceMappingURL=index.js.map