Merge pull request #9 from jembi/error_handling_csv_upload

Added detailed error handling

Author: drizzentic

src/routes/index.ts

@@ -3,101 +3,129 @@ import multer from 'multer';
 import { getConfig } from '../config/config';
 import { getCsvHeaders } from '../utils/file-validators';
 import logger from '../logger';
-import fs from 'fs';
+import fs from 'fs/promises';
 import path from 'path';
 import { uploadToMinio } from '../utils/minioClient';
-import e from 'express';
-const routes = express.Router();
 
+// Constants
+const VALID_MIME_TYPES = ['text/csv', 'application/json'] as const;
+type ValidMimeType = typeof VALID_MIME_TYPES[number];
+
+interface UploadResponse {
+  status: 'success' | 'error';
+  code: string;
+  message: string;
+}
+
+const routes = express.Router();
 const bodySizeLimit = getConfig().bodySizeLimit;
-const jsonBodyParser = express.json({
-  type: 'application/json',
-  limit: bodySizeLimit,
+const upload = multer({ 
+  storage: multer.memoryStorage(),
+  fileFilter: (_, file, cb) => {
+    cb(null, VALID_MIME_TYPES.includes(file.mimetype as ValidMimeType));
+  }
 });
 
-const upload = multer({ storage: multer.memoryStorage() });
+// Helper functions
+const createErrorResponse = (code: string, message: string): UploadResponse => ({
+  status: 'error',
+  code,
+  message
+});
 
-const saveCsvToTmp = (fileBuffer: Buffer, fileName: string): string => {
+const createSuccessResponse = (code: string, message: string): UploadResponse => ({
+  status: 'success',
+  code,
+  message
+});
+
+const saveCsvToTmp = async (fileBuffer: Buffer, fileName: string): Promise<string> => {
   const tmpDir = path.join(process.cwd(), 'tmp');
-  
-  // Create tmp directory if it doesn't exist
-  if (!fs.existsSync(tmpDir)) {
-    fs.mkdirSync(tmpDir);
-  }
+  await fs.mkdir(tmpDir, { recursive: true });
 
   const fileUrl = path.join(tmpDir, fileName);
-  fs.writeFileSync(fileUrl, fileBuffer);
-  logger.info(`fileUrl: ${fileUrl}`);
+  await fs.writeFile(fileUrl, fileBuffer);
+  logger.info(`File saved: ${fileUrl}`);
 
   return fileUrl;
 };
 
-const isValidFileType = (file: Express.Multer.File): boolean => {
-  const validMimeTypes = ['text/csv', 'application/json'];
-  return validMimeTypes.includes(file.mimetype);
-};
-
-function validateJsonFile(buffer: Buffer): boolean {
+const validateJsonFile = (buffer: Buffer): boolean => {
   try {
     JSON.parse(buffer.toString());
     return true;
   } catch {
     return false;
   }
-}
-
-routes.post('/upload', upload.single('file'), async (req, res) => {
-  const file = req.file;
-  const bucket = req.query.bucket;
+};
 
-  if (!file) {
-    logger.error('No file uploaded');
-    return res.status(400).send('No file uploaded');
+// File handlers
+const handleCsvFile = async (
+  file: Express.Multer.File, 
+  bucket: string
+): Promise<UploadResponse> => {
+  const headers = getCsvHeaders(file.buffer);
+  if (!headers) {
+    return createErrorResponse('INVALID_CSV_FORMAT', 'Invalid CSV file format');
   }
 
-  if (!bucket) {
-    logger.error('No bucket provided');
-    return res.status(400).send('No bucket provided');
+  const fileUrl = await saveCsvToTmp(file.buffer, file.originalname);
+  try {
+    const uploadResult = await uploadToMinio(fileUrl, file.originalname, bucket, file.mimetype);
+    await fs.unlink(fileUrl);
+
+    return uploadResult.success
+      ? createSuccessResponse('UPLOAD_SUCCESS', uploadResult.message)
+      : createErrorResponse('UPLOAD_FAILED', uploadResult.message);
+  } catch (error) {
+    logger.error('Error uploading file to Minio:', error);
+    throw error;
   }
+};
 
-  if (!isValidFileType(file)) {
-    logger.error(`Invalid file type: ${file.mimetype}`);
-    return res.status(400).send('Invalid file type. Please upload either a CSV or JSON file');
+const handleJsonFile = (file: Express.Multer.File): UploadResponse => {
+  if (!validateJsonFile(file.buffer)) {
+    return createErrorResponse('INVALID_JSON_FORMAT', 'Invalid JSON file format');
   }
+  return createSuccessResponse('JSON_VALID', 'JSON file is valid - Future implementation');
+};
 
-  // For CSV files, validate headers
-  if (file.mimetype === 'text/csv') {
-    const headers = getCsvHeaders(file.buffer);
-    if (!headers) {
-      return res.status(400).send('Invalid CSV file format');
-    }
-    const fileUrl = saveCsvToTmp(file.buffer, file.originalname);
-    try {
-      const uploadResult = await uploadToMinio(fileUrl, file.originalname, bucket as string, file.mimetype);
-      // Clean up the temporary file
-      fs.unlinkSync(fileUrl);
-
-      if (uploadResult) {
-        return res.status(201).send(`File ${file.originalname} uploaded in bucket ${bucket}`);
-      } else {
-        return res.status(400).send(`Object ${file.originalname} already exists in bucket ${bucket}`);
-      }
-    } catch (error) {
-      // Clean up the temporary file in case of error
-      fs.unlinkSync(fileUrl);
-      logger.error('Error uploading file to Minio:', error);
-      return res.status(500).send('Error uploading file');
+// Main route handler
+routes.post('/upload', upload.single('file'), async (req, res) => {
+  try {
+    const file = req.file;
+    const bucket = req.query.bucket as string;
+
+    if (!file) {
+      logger.error('No file uploaded');
+      return res.status(400).json(
+        createErrorResponse('FILE_MISSING', 'No file uploaded')
+      );
     }
-  } else if (file.mimetype === 'application/json') {
-    if (!validateJsonFile(file.buffer)) {
-      return res.status(400).send('Invalid JSON file format');
+
+    if (!bucket) {
+      logger.error('No bucket provided');
+      return res.status(400).json(
+        createErrorResponse('BUCKET_MISSING', 'No bucket provided')
+      );
     }
 
-    return res.status(200).send('JSON file is valid - Future implementation');
-  } else {
-    return res.status(400).send('Invalid file type. Please upload either a CSV or JSON file');
+    const response = file.mimetype === 'text/csv'
+      ? await handleCsvFile(file, bucket)
+      : handleJsonFile(file);
+
+    const statusCode = response.status === 'success' ? 201 : 400;
+    return res.status(statusCode).json(response);
+
+  } catch (error) {
+    logger.error('Error processing upload:', error);
+    return res.status(500).json(
+      createErrorResponse(
+        'INTERNAL_SERVER_ERROR',
+        error instanceof Error ? error.message : 'Unknown error'
+      )
+    );
   }
-  
 });
 
 export default routes;