vibe-gx 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-gx",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "A lightweight, regex-based Node.js web framework built for speed and simplicity.",
   "type": "module",
   "main": "vibe.js",

package/utils/core/parser.js

@@ -54,6 +54,19 @@ function parseMultipart(req, res, media, options, resolve, reject) {
   let bb;
   let fileError = null;
   const streaming = media.streaming === true;
+  let pendingWrites = 0;
+  let busboyFinished = false;
+
+  // Helper to check if we're done
+  const checkComplete = () => {
+    if (busboyFinished && pendingWrites === 0) {
+      if (fileError) {
+        reject(fileError);
+      } else {
+        resolve();
+      }
+    }
+  };
 
   try {
     bb = busboy({
@@ -75,9 +88,15 @@ function parseMultipart(req, res, media, options, resolve, reject) {
     const { filename, mimeType } = info;
     if (!filename) return file.resume();
 
-    // File type validation
+    // File type validation - support wildcards like "image/*"
     if (media.allowedTypes && Array.isArray(media.allowedTypes)) {
-      if (!media.allowedTypes.includes(mimeType)) {
+      const isAllowed = media.allowedTypes.some((allowed) => {
+        if (allowed.endsWith("/*")) {
+          return mimeType.startsWith(allowed.slice(0, -1));
+        }
+        return allowed === mimeType;
+      });
+      if (!isAllowed) {
         fileError = new Error(
           `File type '${mimeType}' not allowed. Allowed: ${media.allowedTypes.join(", ")}`,
         );
@@ -92,6 +111,8 @@ function parseMultipart(req, res, media, options, resolve, reject) {
     }
 
     // BUFFERING MODE: Write to disk
+    pendingWrites++;
+
     const parent = media.public ? options.publicFolder || "" : "";
     const dest = path.resolve(
       path.join(parent, media.dest || (media.public ? "uploads" : "private")),
@@ -103,6 +124,8 @@ function parseMultipart(req, res, media, options, resolve, reject) {
       !dest.startsWith(path.resolve(options.publicFolder || ""))
     ) {
       console.warn("Attempted upload outside public folder, skipping");
+      pendingWrites--;
+      checkComplete();
       return file.resume();
     }
 
@@ -110,6 +133,8 @@ function parseMultipart(req, res, media, options, resolve, reject) {
       if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
     } catch (err) {
       console.error("Failed to create upload folder:", err);
+      pendingWrites--;
+      checkComplete();
       return file.resume();
     }
 
@@ -137,17 +162,24 @@ function parseMultipart(req, res, media, options, resolve, reject) {
       file.unpipe(writeStream);
       writeStream.end();
       // Clean up partial file
-      fs.unlink(filePath, () => {});
+      fs.unlink(filePath, () => {
+        pendingWrites--;
+        checkComplete();
+      });
     });
 
     file.on("error", (err) => {
       console.error("File stream error:", err);
       writeStream.end();
+      pendingWrites--;
+      checkComplete();
     });
 
     writeStream.on("error", (err) => {
       console.error("Write stream error:", err);
       file.resume();
+      pendingWrites--;
+      checkComplete();
     });
 
     writeStream.on("finish", () => {
@@ -160,6 +192,8 @@ function parseMultipart(req, res, media, options, resolve, reject) {
           size,
         });
       }
+      pendingWrites--;
+      checkComplete();
     });
 
     file.pipe(writeStream);
@@ -172,11 +206,8 @@ function parseMultipart(req, res, media, options, resolve, reject) {
   });
 
   bb.on("finish", () => {
-    if (fileError) {
-      reject(fileError);
-    } else {
-      resolve();
-    }
+    busboyFinished = true;
+    checkComplete();
   });
 
   req.pipe(bb);

package/vibe.d.ts

@@ -26,15 +26,26 @@ export interface UploadedFile {
 
 /**
  * Configuration for file uploads on a specific route.
+ *
+ * @example
+ * {
+ *   dest: "uploads",
+ *   maxSize: 5 * 1024 * 1024,  // 5MB
+ *   allowedTypes: ["image/jpeg", "image/png"],
+ *   public: true
+ * }
  */
 export interface MediaOptions {
   /** Save file inside the configured public folder. Default: true */
   public?: boolean;
   /** Subfolder destination for uploads (e.g., "uploads/avatars") */
   dest?: string;
-  /** Maximum allowed file size in bytes. Default: 10 MB */
+  /** Maximum allowed file size in bytes. Default: 10 MB (10485760) */
   maxSize?: number;
-  /** Allowed MIME types (e.g., ["image/png", "image/jpeg"]) */
+  /**
+   * Allowed MIME types. Supports wildcards like "image/*"
+   * @example ["image/jpeg", "image/png", "application/pdf"]
+   */
   allowedTypes?: string[];
   /** Enable streaming mode for large files. Use req.on('file', ...) */
   streaming?: boolean;
@@ -42,11 +53,40 @@ export interface MediaOptions {
 
 /**
  * Options for registering a route.
+ *
+ * @example
+ * // With interceptor only
+ * { intercept: authMiddleware }
+ *
+ * @example
+ * // With file upload
+ * {
+ *   intercept: authMiddleware,
+ *   media: {
+ *     dest: "uploads",
+ *     maxSize: 10 * 1024 * 1024,
+ *     allowedTypes: ["image/*"]
+ *   }
+ * }
  */
 export interface RouteOptions {
-  /** Middleware(s) to run before the main handler */
+  /**
+   * Middleware function(s) to run before the handler.
+   * Return false to stop execution.
+   * @example
+   * intercept: (req, res) => {
+   *   if (!req.headers.authorization) {
+   *     res.unauthorized();
+   *     return false;
+   *   }
+   *   return true;
+   * }
+   */
   intercept?: Interceptor | Interceptor[];
-  /** Configuration for file uploads */
+  /**
+   * Configuration for file uploads (multipart/form-data).
+   * Files will be available in req.files array.
+   */
   media?: MediaOptions;
 }
 
@@ -175,13 +215,45 @@ export const color: Record<ColorName, (text: string) => string>;
 
 /**
  * Route registration function.
- * Supports two signatures:
- * 1. (path, handler)
- * 2. (path, options, handler)
+ *
+ * @example
+ * // Simple handler
+ * app.get("/path", (req, res) => { ... });
+ *
+ * @example
+ * // Static response
+ * app.get("/", "Hello World");
+ *
+ * @example
+ * // With options (interceptor + file upload)
+ * app.post("/upload", {
+ *   intercept: authMiddleware,
+ *   media: {
+ *     dest: "uploads",
+ *     maxSize: 10 * 1024 * 1024,
+ *     allowedTypes: ["image/*"]
+ *   }
+ * }, handler);
  */
 export interface RouteRegistrar {
+  /**
+   * Register a route with a handler or static response.
+   * @param path - Route path (e.g., "/users/:id")
+   * @param handler - Handler function, string, number, or object
+   */
   (path: string, handler: Handler | string | number | object): void;
-  (path: string, options: RouteOptions, handler: Handler): void;
+
+  /**
+   * Register a route with options and handler.
+   * @param path - Route path (e.g., "/upload")
+   * @param options - Route options (intercept, media)
+   * @param handler - Handler function
+   */
+  (
+    path: string,
+    options: RouteOptions,
+    handler: Handler | string | number | object,
+  ): void;
 }
 
 /** Sub-router or prefixed router instance */