json-rest-api 1.0.13 → 1.0.15

package/plugins/core/connectors/lib/busboy-detector.js

@@ -1,19 +1,19 @@
 /**
  * Busboy File Detector for HTTP Multipart Uploads
- * 
+ *
  * This detector handles multipart/form-data uploads using the busboy library.
  * It's suitable for both HTTP and Express connectors.
- * 
+ *
  * Features:
  * - Streaming parser (memory efficient)
  * - Configurable file size limits
  * - Automatic field parsing
  * - No temporary files by default (keeps in memory)
- * 
+ *
  * Usage:
  * ```javascript
  * import { createBusboyDetector } from 'jsonrestapi/plugins/core/lib/busboy-detector.js';
- * 
+ *
  * api.use(HttpPlugin, {
  *   fileParser: 'busboy',
  *   fileParserOptions: {
@@ -23,20 +23,20 @@
  * ```
  */
 
-import { requirePackage } from 'hooked-api';
-import { Readable } from 'stream';
+import { requirePackage } from 'hooked-api'
+import { Readable } from 'stream'
 
-let Busboy;
+let Busboy
 try {
-  Busboy = (await import('busboy')).default;
+  Busboy = (await import('busboy')).default
 } catch (e) {
-  requirePackage('busboy', 'express/http-connector', 
-    'Busboy is required for multipart/form-data file uploads. This is a peer dependency.');
+  requirePackage('busboy', 'express/http-connector',
+    'Busboy is required for multipart/form-data file uploads. This is a peer dependency.')
 }
 
 /**
  * Creates a busboy-based file detector
- * 
+ *
  * @param {Object} options - Busboy configuration options
  * @param {Object} options.limits - Size limits
  * @param {number} options.limits.fileSize - Max file size in bytes
@@ -44,132 +44,132 @@ try {
  * @param {number} options.limits.fields - Max number of fields
  * @returns {Object} Detector object with detect() and parse() methods
  */
-export function createBusboyDetector(options = {}) {
+export function createBusboyDetector (options = {}) {
   return {
     name: 'busboy-multipart',
-    
+
     /**
      * Check if this detector can handle the request
      * @param {Object} params - Request parameters
      * @returns {boolean} True if this is a multipart request
      */
     detect: (params) => {
-      const req = params._httpReq || params._expressReq;
-      if (!req || !req.headers) return false;
-      
-      const contentType = req.headers['content-type'] || '';
-      return contentType.includes('multipart/form-data');
+      const req = params._httpReq || params._expressReq
+      if (!req || !req.headers) return false
+
+      const contentType = req.headers['content-type'] || ''
+      return contentType.includes('multipart/form-data')
     },
-    
+
     /**
      * Parse multipart data from the request
      * @param {Object} params - Request parameters
      * @returns {Promise<{fields: Object, files: Object}>} Parsed data
      */
     parse: async (params) => {
-      const req = params._httpReq || params._expressReq;
-      
+      const req = params._httpReq || params._expressReq
+
       return new Promise((resolve, reject) => {
         const busboy = new Busboy({
           headers: req.headers,
           ...options
-        });
-        
-        const fields = {};
-        const files = {};
-        const filePromises = [];
-        
+        })
+
+        const fields = {}
+        const files = {}
+        const filePromises = []
+
         // Handle fields
         busboy.on('field', (fieldname, val) => {
           // Handle array notation (field[] or field[0])
-          const arrayMatch = fieldname.match(/^(.+)\[\d*\]$/);
+          const arrayMatch = fieldname.match(/^(.+)\[\d*\]$/)
           if (arrayMatch) {
-            const baseName = arrayMatch[1];
+            const baseName = arrayMatch[1]
             if (!fields[baseName]) {
-              fields[baseName] = [];
+              fields[baseName] = []
             }
             if (Array.isArray(fields[baseName])) {
-              fields[baseName].push(val);
+              fields[baseName].push(val)
             }
           } else {
-            fields[fieldname] = val;
+            fields[fieldname] = val
           }
-        });
-        
+        })
+
         // Handle files
         busboy.on('file', (fieldname, file, filename, encoding, mimetype) => {
-          const chunks = [];
-          let size = 0;
-          
+          const chunks = []
+          let size = 0
+
           const filePromise = new Promise((fileResolve, fileReject) => {
             file.on('data', (chunk) => {
-              chunks.push(chunk);
-              size += chunk.length;
-            });
-            
+              chunks.push(chunk)
+              size += chunk.length
+            })
+
             file.on('limit', () => {
-              fileReject(new Error(`File size limit exceeded for field '${fieldname}'`));
-            });
-            
+              fileReject(new Error(`File size limit exceeded for field '${fieldname}'`))
+            })
+
             file.on('end', () => {
               files[fieldname] = {
-                filename: filename,
-                mimetype: mimetype,
-                encoding: encoding,
-                size: size,
+                filename,
+                mimetype,
+                encoding,
+                size,
                 data: Buffer.concat(chunks)
-              };
-              fileResolve();
-            });
-            
-            file.on('error', fileReject);
-          });
-          
-          filePromises.push(filePromise);
-        });
-        
+              }
+              fileResolve()
+            })
+
+            file.on('error', fileReject)
+          })
+
+          filePromises.push(filePromise)
+        })
+
         // Handle completion
         busboy.on('finish', async () => {
           try {
             // Wait for all files to be fully read
-            await Promise.all(filePromises);
-            resolve({ fields, files });
+            await Promise.all(filePromises)
+            resolve({ fields, files })
           } catch (error) {
-            reject(error);
+            reject(error)
           }
-        });
-        
+        })
+
         // Handle errors
         busboy.on('error', (error) => {
-          reject(error);
-        });
-        
+          reject(error)
+        })
+
         // Handle limit errors
         busboy.on('partsLimit', () => {
-          reject(new Error('Parts limit exceeded'));
-        });
-        
+          reject(new Error('Parts limit exceeded'))
+        })
+
         busboy.on('filesLimit', () => {
-          reject(new Error('Files limit exceeded'));
-        });
-        
+          reject(new Error('Files limit exceeded'))
+        })
+
         busboy.on('fieldsLimit', () => {
-          reject(new Error('Fields limit exceeded'));
-        });
-        
+          reject(new Error('Fields limit exceeded'))
+        })
+
         // Pipe request to busboy
         if (req.pipe) {
-          req.pipe(busboy);
+          req.pipe(busboy)
         } else if (req.on) {
           // For already buffered requests
-          const stream = new Readable();
-          stream.push(req.body || req);
-          stream.push(null);
-          stream.pipe(busboy);
+          const stream = new Readable()
+          stream.push(req.body || req)
+          stream.push(null)
+          stream.pipe(busboy)
         } else {
-          reject(new Error('Request object is not a stream'));
+          reject(new Error('Request object is not a stream'))
         }
-      });
+      })
     }
-  };
-}
+  }
+}

package/plugins/core/connectors/lib/formidable-detector.js

@@ -1,20 +1,20 @@
 /**
  * Formidable File Detector for HTTP Multipart Uploads
- * 
+ *
  * This detector handles multipart/form-data uploads using the formidable library.
  * Unlike busboy, formidable saves files to disk temporarily, which is better
  * for large files.
- * 
+ *
  * Features:
  * - Disk-based storage (better for large files)
  * - Automatic temp file cleanup
  * - Progress tracking support
  * - Built-in file type detection
- * 
+ *
  * Usage:
  * ```javascript
  * import { createFormidableDetector } from 'jsonrestapi/plugins/core/lib/formidable-detector.js';
- * 
+ *
  * api.use(ExpressPlugin, {
  *   fileParser: 'formidable',
  *   fileParserOptions: {
@@ -26,21 +26,21 @@
  * ```
  */
 
-import { requirePackage } from 'hooked-api';
-import { promises as fs } from 'fs';
-import path from 'path';
+import { requirePackage } from 'hooked-api'
+import { promises as fs } from 'fs'
+import path from 'path'
 
-let formidable;
+let formidable
 try {
-  formidable = (await import('formidable')).default;
+  formidable = (await import('formidable')).default
 } catch (e) {
-  requirePackage('formidable', 'express/http-connector', 
-    'Formidable is required for multipart/form-data file uploads with disk storage. This is a peer dependency.');
+  requirePackage('formidable', 'express/http-connector',
+    'Formidable is required for multipart/form-data file uploads with disk storage. This is a peer dependency.')
 }
 
 /**
  * Creates a formidable-based file detector
- * 
+ *
  * @param {Object} options - Formidable configuration options
  * @param {string} options.uploadDir - Directory for temporary files
  * @param {boolean} options.keepExtensions - Keep file extensions
@@ -48,91 +48,91 @@ try {
  * @param {boolean} options.multiples - Allow multiple files per field
  * @returns {Object} Detector object with detect() and parse() methods
  */
-export function createFormidableDetector(options = {}) {
+export function createFormidableDetector (options = {}) {
   // Set default upload directory
-  const uploadDir = options.uploadDir || path.join(process.cwd(), 'uploads', 'temp');
-  
+  const uploadDir = options.uploadDir || path.join(process.cwd(), 'uploads', 'temp')
+
   return {
     name: 'formidable-multipart',
-    
+
     /**
      * Check if this detector can handle the request
      * @param {Object} params - Request parameters
      * @returns {boolean} True if this is a multipart request
      */
     detect: (params) => {
-      const req = params._httpReq || params._expressReq;
-      if (!req || !req.headers) return false;
-      
-      const contentType = req.headers['content-type'] || '';
-      return contentType.includes('multipart/form-data');
+      const req = params._httpReq || params._expressReq
+      if (!req || !req.headers) return false
+
+      const contentType = req.headers['content-type'] || ''
+      return contentType.includes('multipart/form-data')
     },
-    
+
     /**
      * Parse multipart data from the request
      * @param {Object} params - Request parameters
      * @returns {Promise<{fields: Object, files: Object}>} Parsed data
      */
     parse: async (params) => {
-      const req = params._httpReq || params._expressReq;
-      
+      const req = params._httpReq || params._expressReq
+
       // Ensure upload directory exists
-      await fs.mkdir(uploadDir, { recursive: true });
-      
+      await fs.mkdir(uploadDir, { recursive: true })
+
       // Create form parser
       const form = formidable({
         uploadDir,
         keepExtensions: true,
         ...options
-      });
-      
+      })
+
       // Parse the request
-      const [fields, fileUploads] = await form.parse(req);
-      
+      const [fields, fileUploads] = await form.parse(req)
+
       // Normalize formidable's file format to our standard format
-      const files = {};
-      
+      const files = {}
+
       for (const [fieldname, uploadedFiles] of Object.entries(fileUploads)) {
         // Formidable returns arrays for multiple files
-        const fileArray = Array.isArray(uploadedFiles) ? uploadedFiles : [uploadedFiles];
-        
+        const fileArray = Array.isArray(uploadedFiles) ? uploadedFiles : [uploadedFiles]
+
         // For now, just take the first file (TODO: handle multiple files per field)
-        const file = fileArray[0];
-        
+        const file = fileArray[0]
+
         if (file) {
           // Read file data into memory (for small files)
           // For large files, you might want to keep them on disk
-          const data = await fs.readFile(file.filepath);
-          
+          const data = await fs.readFile(file.filepath)
+
           files[fieldname] = {
             filename: file.originalFilename || 'unknown',
             mimetype: file.mimetype || 'application/octet-stream',
             size: file.size,
-            data: data,
+            data,
             filepath: file.filepath, // Keep for reference
-            
+
             // Cleanup function to remove temp file
             cleanup: async () => {
               try {
-                await fs.unlink(file.filepath);
+                await fs.unlink(file.filepath)
               } catch (error) {
                 // File might already be deleted, ignore
                 if (error.code !== 'ENOENT') {
-                  throw error;
+                  throw error
                 }
               }
             }
-          };
+          }
         }
       }
-      
+
       // Normalize fields (formidable returns arrays for repeated fields)
-      const normalizedFields = {};
+      const normalizedFields = {}
       for (const [key, value] of Object.entries(fields)) {
-        normalizedFields[key] = Array.isArray(value) && value.length === 1 ? value[0] : value;
+        normalizedFields[key] = Array.isArray(value) && value.length === 1 ? value[0] : value
       }
-      
-      return { fields: normalizedFields, files };
+
+      return { fields: normalizedFields, files }
     }
-  };
-}
+  }
+}