cpeak 2.5.0 → 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,68 +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/paseJSON.ts
-import { Buffer } 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") : Buffer.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/render.ts
 import fs2 from "fs/promises";
 function renderTemplate(templateStr, data) {
@@ -161,6 +167,263 @@ 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, status) {
   const err = new Error(message);
@@ -177,27 +440,28 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   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;
+  #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;
+    if (this.#query) return this.#query;
     const url = this.url || "";
     const qIndex = url.indexOf("?");
     if (qIndex === -1) {
-      this._query = {};
+      this.#query = {};
     } else {
       const searchParams = new URLSearchParams(url.substring(qIndex + 1));
-      this._query = Object.fromEntries(searchParams.entries());
+      this.#query = Object.fromEntries(searchParams.entries());
     }
-    return this._query;
+    return this.#query;
   }
 };
 var CpeakServerResponse = class extends http.ServerResponse {
@@ -242,11 +506,16 @@ var CpeakServerResponse = class extends http.ServerResponse {
     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();
-    return this;
   }
   // Send a json data back to the client (for small json data, less than the highWaterMark)
   json(data) {
@@ -255,129 +524,127 @@ var CpeakServerResponse = class extends http.ServerResponse {
   }
 };
 var Cpeak = class {
-  server;
-  routes;
-  middleware;
-  _handleErr;
+  #server;
+  #routes;
+  #middleware;
+  #handleErr;
   constructor() {
-    this.server = http.createServer({
+    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 runHandler = async (req2, res2, middleware, cb, index) => {
-        if (index === middleware.length) {
-          try {
-            await cb(req2, res2, (error) => {
-              res2.setHeader("Connection", "close");
-              this._handleErr?.(error, req2, res2);
-            });
-          } catch (error) {
-            res2.setHeader("Connection", "close");
-            this._handleErr?.(error, req2, res2);
+    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;
           }
-        } else {
-          try {
-            await middleware[index](
-              req2,
-              res2,
-              // The next function
-              async (error) => {
-                if (error) {
-                  res2.setHeader("Connection", "close");
-                  return this._handleErr?.(error, req2, res2);
-                }
-                await runHandler(req2, res2, middleware, cb, index + 1);
-              },
-              // Error handler for a route middleware
-              (error) => {
-                res2.setHeader("Connection", "close");
-                this._handleErr?.(error, req2, res2);
-              }
-            );
-          } 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);
+            }
           }
-        }
-      };
-      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
-                );
+        };
+        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
+                  );
+                }
               }
+            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);
             }
-          return res2.status(404).json({ error: `Cannot ${req2.method} ${urlWithoutQueries}` });
-        } else {
-          try {
-            await middleware[index](req2, res2, async (err) => {
-              if (err) {
-                res2.setHeader("Connection", "close");
-                return this._handleErr?.(err, req2, res2);
-              }
-              await runMiddleware(req2, res2, middleware, index + 1);
-            });
-          } catch (error) {
-            res2.setHeader("Connection", "close");
-            this._handleErr?.(error, req2, res2);
           }
-        }
-      };
-      await 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 paramNames = [];
-    const regexString = "^" + path2.replace(/:\w+/g, (match, offset) => {
-      paramNames.push(match.slice(1));
-      return "([^/]+)";
-    }) + "$";
-    const regex = new RegExp(regexString);
-    return regex;
+    const regexString = "^" + path2.replace(/:\w+/g, "([^/]+)").replace(/\*/g, ".*") + "$";
+    return new RegExp(regexString);
   }
   #extractPathVariables(path2, match) {
     const paramNames = (path2.match(/:\w+/g) || []).map(
@@ -394,11 +661,19 @@ 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