cpeak 2.7.0 → 2.8.0

package/lib/types.ts

@@ -1,13 +1,20 @@
-import { IncomingMessage, ServerResponse } from "node:http";
+import { IncomingMessage, ServerResponse, type Server } from "node:http";
 import type { Readable } from "node:stream";
 import type { Buffer } from "node:buffer";
 import type { CompressionOptions } from "./internal/types";
+import type { CpeakIncomingMessage, CpeakServerResponse } from "./index";
 
 export type { Cpeak } from "./index";
 
+export type CpeakHttpServer = Server<
+  typeof CpeakIncomingMessage,
+  typeof CpeakServerResponse
+>;
+
 // For constructor options passed to `cpeak()`
 export interface CpeakOptions {
   compression?: boolean | CompressionOptions;
+  mimeTypes?: StringMap;
 }
 
 // Extending Node.js's Request and Response objects to add our custom properties
@@ -26,12 +33,12 @@ export interface CpeakRequest<
 }
 
 export interface CpeakResponse extends ServerResponse {
-  sendFile: (path: string, mime: string) => Promise<void>;
+  sendFile: (path: string, mime?: string) => Promise<void>;
   status: (code: number) => CpeakResponse;
   attachment: (filename?: string) => CpeakResponse;
   cookie: (name: string, value: string, options?: any) => CpeakResponse;
   redirect: (location: string) => void;
-  json: (data: any) => void | Promise<void>; // sync when compression is off, async when enabled
+  json: (data: any) => Promise<void>;
   compress: (
     mime: string,
     body: Buffer | string | Readable,
@@ -41,39 +48,30 @@ export interface CpeakResponse extends ServerResponse {
 }
 
 export type Next = (err?: any) => void;
-export type HandleErr = (err: any) => void;
 
 // beforeEach middleware: (req, res, next)
 export type Middleware<ReqBody = any, ReqParams = any> = (
   req: CpeakRequest<ReqBody, ReqParams>,
   res: CpeakResponse,
   next: Next
-) => void;
+) => unknown;
 
-// Route middleware:      (req, res, next, handleErr)
+// Route middleware: (req, res, next)
 export type RouteMiddleware<ReqBody = any, ReqParams = any> = (
   req: CpeakRequest<ReqBody, ReqParams>,
   res: CpeakResponse,
-  next: Next,
-  handleErr: HandleErr
-) => void | Promise<void>;
+  next: Next
+) => unknown;
 
-// Route handlers: (req, res, handleErr)
+// Route handlers: (req, res). To signal an error, throw it.
 export type Handler<ReqBody = any, ReqParams = any> = (
   req: CpeakRequest<ReqBody, ReqParams>,
-  res: CpeakResponse,
-  handleErr: HandleErr
-) => void | Promise<void>;
+  res: CpeakResponse
+) => unknown;
 
-// For a route object value in Cpeak.routes. The key is the method name.
+// Represents a single registered route.
 export interface Route {
   path: string;
-  regex: RegExp;
   middleware: RouteMiddleware[];
   cb: Handler;
 }
-
-// For Cpeak.routes:
-export interface RoutesMap {
-  [method: string]: Route[];
-}

package/lib/utils/render.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import { frameworkError } from "../";
 import { compressAndSend } from "../internal/compression";
+import { MIME_TYPES } from "../internal/mimeTypes";
 import type { CpeakRequest, CpeakResponse, Next } from "../types";
 
 function renderTemplate(
@@ -59,14 +60,18 @@ const render = () => {
     res.render = async (
       path: string,
       data: Record<string, unknown>,
-      mime: string
+      mime?: string
     ) => {
-      // check if mime is specified, if not return an error
       if (!mime) {
-        throw frameworkError(
-          `MIME type is missing. You called res.render("${path}", ...) but forgot to provide the third "mime" argument.`,
-          res.render
-        );
+        const dotIndex = path.lastIndexOf(".");
+        const fileExtension = dotIndex >= 0 ? path.slice(dotIndex + 1) : "";
+        mime = MIME_TYPES[fileExtension];
+        if (!mime) {
+          throw frameworkError(
+            `MIME type is missing for "${path}". Pass it as the third argument or register the extension via cpeak({ mimeTypes: { ${fileExtension || "ext"}: "..." } }).`,
+            res.render
+          );
+        }
       }
 
       let fileStr = await fs.readFile(path, "utf-8");

package/lib/utils/serveStatic.ts

@@ -1,39 +1,40 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import type { StringMap, CpeakRequest, CpeakResponse, Next } from "../types";
-
-const MIME_TYPES: StringMap = {
-  html: "text/html",
-  css: "text/css",
-  js: "application/javascript",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  png: "image/png",
-  svg: "image/svg+xml",
-  txt: "text/plain",
-  eot: "application/vnd.ms-fontobject",
-  otf: "font/otf",
-  ttf: "font/ttf",
-  woff: "font/woff",
-  woff2: "font/woff2",
-  gif: "image/gif",
-  ico: "image/x-icon",
-  json: "application/json",
-  webmanifest: "application/manifest+json"
-};
+import { MIME_TYPES } from "../internal/mimeTypes";
+import type { CpeakRequest, CpeakResponse, Next } from "../types";
 
 const serveStatic = (
   folderPath: string,
-  newMimeTypes?: StringMap,
-  options?: { prefix?: string }
+  options?: { prefix?: string; live?: boolean }
 ) => {
-  // For new user defined mime types
-  if (newMimeTypes) {
-    Object.assign(MIME_TYPES, newMimeTypes);
-  }
-
   const prefix = options?.prefix ?? "";
+  const live = options?.live ?? false;
+
+  // This process the folder on every request, which is useful during development when files are changing often.
+  // In production, it's better to process the folder once and store the file paths in memory for faster access if file names are not changing often.
+  // If file names dynamically change often in production, then live option can be set to true to process the folder on every request, but it may have performance implications.
+  if (live) {
+    const resolvedFolder = path.resolve(folderPath);
+
+    return async function (req: CpeakRequest, res: CpeakResponse, next: Next) {
+      const url = req.url;
+      if (typeof url !== "string") return next();
+
+      const pathname = url.split("?")[0];
+      const unprefixed = prefix ? pathname.slice(prefix.length) : pathname;
+      const filePath = path.join(resolvedFolder, unprefixed);
+      const fileExtension = path.extname(filePath).slice(1);
+      const mime = MIME_TYPES[fileExtension];
+
+      if (!mime || !filePath.startsWith(resolvedFolder)) return next();
+
+      const stat = await fs.promises.stat(filePath).catch(() => null);
+      if (stat?.isFile()) return res.sendFile(filePath, mime);
+
+      next();
+    };
+  }
 
   function processFolder(folderPath: string, parentFolder: string) {
     const staticFiles: string[] = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cpeak",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "A minimal and fast Node.js HTTP framework.",
   "type": "module",
   "scripts": {