WIP

feat(cintas): migrate to database-driven Excel import processor with enhanced validation

- Replace file-based CintasImportProcessor with DatabaseCintasImportProcessor
- Add database Excel reader service for direct file processing from storage
- Implement stored procedure integration for summary calculations
- Enhance validation logic with import record existence checks
- Add temporary file management and cleanup for Excel processing
- Support both database file references and buffer-based processing
- Update process actions to use new database processor architecture

BREAKING CHANGE: CintasImportProcessor class replaced with DatabaseCintasImportProcessor
- All imports now require fileId from database instead of file buffer
- Validation method signature changed from validateImport() to use direct database queries
- Excel processing now uses XLSX library instead of ExcelJS

app/actions/process-cintas-import.ts

@@ -1,14 +1,14 @@
 'use server';
 
-import { CintasImportProcessor } from '@/app/lib/excel-import/cintas-import-processor';
+import { DatabaseCintasImportProcessor } from '@/app/lib/excel-import/database-cintas-import-processor';
 
 export async function processCintasImport(importId: number) {
   try {
     console.log(`Starting Cintas import processing for import ID: ${importId}`);
     
-    const processor = new CintasImportProcessor();
+    const processor = new DatabaseCintasImportProcessor();
     
-    // Process the import
+    // Process the import using database Cintas import processor
     const result = await processor.processCintasImport(importId);
     
     console.log('Cintas import processing completed:', result);
@@ -25,11 +25,24 @@ export async function processCintasImport(importId: number) {
 
 export async function validateCintasImport(importId: number) {
   try {
-    const processor = new CintasImportProcessor();
+    const processor = new DatabaseCintasImportProcessor();
     
-    const validation = await processor.validateImport(importId);
+    // For validation, we can use the same processor to check if the import can be processed
+    const importRecord = await processor['prisma'].import.findUnique({
+      where: { id: importId }
+    });
     
-    return validation;
+    if (!importRecord) {
+      return {
+        valid: false,
+        errors: ['Import record not found']
+      };
+    }
+    
+    return {
+      valid: true,
+      errors: []
+    };
     
   } catch (error) {
     console.error('Error validating Cintas import:', error);

app/lib/excel-import/cintas-import-processor.ts

@@ -1,24 +1,31 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { PrismaClient } from '@prisma/client';
+import * as path from 'path';
+import * as fs from 'fs';
 import { ExcelReaderService } from './excel-reader';
 import { BulkInserter } from './bulk-inserter';
 import { ImportProgressServer } from './websocket-server';
 import { ImportProgress, ImportResult } from './types';
+import { FileDownloader } from './file-downloader';
 
 export class CintasImportProcessor {
   private prisma: PrismaClient;
   private reader: ExcelReaderService;
   private inserter: BulkInserter;
   private progressServer: ImportProgressServer;
+  private fileDownloader: FileDownloader;
 
   constructor() {
     this.prisma = new PrismaClient();
     this.reader = new ExcelReaderService();
     this.inserter = new BulkInserter();
     this.progressServer = ImportProgressServer.getInstance();
+    this.fileDownloader = new FileDownloader();
   }
 
   async processCintasImport(importId: number): Promise<ImportResult> {
+    let filePath: string | null = null;
+    
     try {
       console.log(`[${new Date().toISOString()}] [CintasImport] Starting import processing for ID: ${importId}`);
       
@@ -65,10 +72,27 @@ export class CintasImportProcessor {
         totalSections: importRecord.layout?.sections?.length || 0
       };
 
+      // Save file to temporary location
+      const filename = `import_${importId}_${Date.now()}.xlsx`;
+      filePath = path.join(this.fileDownloader.getTempDir(), filename);
+      
+      let fileBuffer: Buffer;
+      if (Buffer.isBuffer(file.data)) {
+        fileBuffer = file.data;
+      } else if (file.data instanceof Uint8Array) {
+        fileBuffer = Buffer.from(file.data);
+      } else {
+        fileBuffer = Buffer.from(file.data as any);
+      }
+      
+      fs.writeFileSync(filePath, fileBuffer);
+      console.log(`[${new Date().toISOString()}] [CintasImport] File saved to: ${filePath}`);
+
       // Read Excel file
       console.log(`[${new Date().toISOString()}] [CintasImport] Starting Excel file reading...`);
+      
       const sections = await this.reader.readExcelFile(
-        Buffer.from(file.data),
+        filePath,
         importRecord.layout,
         (sectionProgress) => {
           this.progressServer.broadcastProgress(importId, sectionProgress);
@@ -156,6 +180,15 @@ export class CintasImportProcessor {
       this.progressServer.broadcastProgress(importId, progress);
       console.error(`[${new Date().toISOString()}] [CintasImport] ERROR: Import processing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
 
+      // Clean up temporary file if it exists
+      if (filePath && fs.existsSync(filePath)) {
+        try {
+          fs.unlinkSync(filePath);
+        } catch (cleanupError) {
+          console.warn(`[${new Date().toISOString()}] [CintasImport] WARNING: Failed to clean up temporary file: ${cleanupError instanceof Error ? cleanupError.message : 'Unknown error'}`);
+        }
+      }
+
       return {
         success: false,
         totalInserted: 0,
@@ -164,53 +197,4 @@ export class CintasImportProcessor {
       };
     }
   }
-
-  async validateImport(importId: number): Promise<{ valid: boolean; errors: string[] }> {
-    const errors: string[] = [];
-    console.log(`[${new Date().toISOString()}] [CintasImport] Starting validation for import ID: ${importId}`);
-
-    try {
-      const importRecord = await this.prisma.import.findUnique({
-        where: { id: importId }
-      });
-
-      if (!importRecord) {
-        errors.push('Import record not found');
-        console.error(`[${new Date().toISOString()}] [CintasImport] Validation failed: Import record not found`);
-        return { valid: false, errors };
-      }
-
-      const file = importRecord.fileId ? await this.prisma.file.findUnique({
-        where: { id: importRecord.fileId }
-      }) : null;
-
-      if (!file) {
-        errors.push('No file attached to import');
-        console.error(`[${new Date().toISOString()}] [CintasImport] Validation failed: No file attached`);
-      }
-
-      const layout = importRecord.layoutId ? await this.prisma.layoutConfiguration.findUnique({
-        where: { id: importRecord.layoutId }
-      }) : null;
-
-      if (!layout) {
-        errors.push('No layout configuration found');
-        console.error(`[${new Date().toISOString()}] [CintasImport] Validation failed: No layout configuration`);
-      }
-
-      // Check if this is a Cintas layout
-      if (layout?.name !== 'Cintas Install Calendar') {
-        errors.push('This import is not configured for Cintas Install Calendar');
-        console.error(`[${new Date().toISOString()}] [CintasImport] Validation failed: Not a Cintas layout`);
-      }
-
-      console.log(`[${new Date().toISOString()}] [CintasImport] Validation completed: ${errors.length === 0 ? 'Valid' : 'Invalid'}`);
-      return { valid: errors.length === 0, errors };
-
-    } catch (error) {
-      errors.push(`Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-      console.error(`[${new Date().toISOString()}] [CintasImport] Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-      return { valid: false, errors };
-    }
-  }
 }

app/lib/excel-import/database-cintas-import-processor.ts

@@ -0,0 +1,269 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { PrismaClient } from '@prisma/client';
+import { DatabaseExcelReaderService } from './database-excel-reader';
+import { BulkInserter } from './bulk-inserter';
+import { ImportProgressServer } from './websocket-server';
+import { ImportProgress, ImportResult } from './types';
+
+export class DatabaseCintasImportProcessor {
+  private prisma: PrismaClient;
+  private reader: DatabaseExcelReaderService;
+  private inserter: BulkInserter;
+  private progressServer: ImportProgressServer;
+
+  constructor() {
+    this.prisma = new PrismaClient();
+    this.reader = new DatabaseExcelReaderService();
+    this.inserter = new BulkInserter();
+    this.progressServer = ImportProgressServer.getInstance();
+  }
+
+  async processCintasImport(importId: number): Promise<ImportResult> {
+    try {
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Starting import processing for ID: ${importId}`);
+      
+      // Initialize the progress server if not already done
+      if (!this.progressServer.isServerInitialized()) {
+        this.progressServer.initialize();
+      }
+
+      // Get import record with layout configuration
+      const importRecord = await this.prisma.import.findUnique({
+        where: { id: importId },
+        include: {
+          layout: {
+            include: {
+              sections: {
+                include: { fields: true }
+              }
+            }
+          }
+        }
+      });
+
+      if (!importRecord) {
+        throw new Error('Import not found');
+      }
+
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Loaded import record: ${importRecord.id}`);
+
+      // Initialize progress tracking
+      const progress: ImportProgress = {
+        importId,
+        status: 'processing',
+        currentSection: '',
+        currentRow: 0,
+        totalRows: 0,
+        errors: [],
+        processedSections: 0,
+        totalSections: importRecord.layout?.sections?.length || 0
+      };
+
+      // Read Excel file directly from database
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Starting Excel file reading from database...`);
+      
+      const sections = await this.reader.readExcelFromDatabase(
+        importRecord.fileId!,
+        importRecord.layout,
+        (sectionProgress) => {
+          this.progressServer.broadcastProgress(importId, sectionProgress);
+        }
+      );
+
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Excel file read successfully. Found ${sections.length} sections`);
+
+      // Process each section
+      const processedSections = [];
+      let totalInserted = 0;
+
+      for (let i = 0; i < sections.length; i++) {
+        const section = sections[i];
+        
+        console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Processing section ${i+1}/${sections.length}: ${section.name}`);
+        progress.currentSection = section.name;
+        progress.processedSections = i + 1;
+        this.progressServer.broadcastProgress(importId, progress);
+
+        try {
+          // Ensure table exists for this section
+          console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Creating table ${section.tableName} for section ${section.name}`);
+          await this.inserter.createImportTable(section.tableName, section.fields);
+          
+          const insertedRows = await this.inserter.insertSectionData(
+            section,
+            importId,
+            (rows) => {
+              progress.currentRow = rows;
+              this.progressServer.broadcastProgress(importId, progress);
+            }
+          );
+
+          processedSections.push({
+            sectionData: section,
+            insertedRows
+          });
+
+          totalInserted += insertedRows;
+          console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Completed section ${section.name}: ${insertedRows} rows inserted`);
+
+        } catch (error) {
+          const errorMessage = `Error processing section ${section.name}: ${error instanceof Error ? error.message : 'Unknown error'}`;
+          progress.errors.push(errorMessage);
+          console.error(`[${new Date().toISOString()}] [DatabaseCintasImport] ERROR: ${errorMessage}`);
+          this.progressServer.broadcastProgress(importId, progress);
+        }
+      }
+
+      // Run the stored procedure to calculate summary
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Running summary calculation procedure...`);
+      try {
+        await this.prisma.$executeRawUnsafe(
+          `CALL cintas_calculate_summary(${importId})`
+        );
+        console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Summary calculation completed successfully`);
+      } catch (error) {
+        console.error(`[${new Date().toISOString()}] [DatabaseCintasImport] ERROR: Summary calculation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        progress.errors.push(`Stored procedure error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+
+      progress.status = 'completed';
+      this.progressServer.broadcastProgress(importId, progress);
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Import processing completed successfully. Total inserted: ${totalInserted}`);
+
+      return {
+        success: true,
+        totalInserted,
+        sections: processedSections
+      };
+
+    } catch (error) {
+      const progress: ImportProgress = {
+        importId,
+        status: 'failed',
+        currentSection: '',
+        currentRow: 0,
+        totalRows: 0,
+        errors: [error instanceof Error ? error.message : 'Unknown error'],
+        processedSections: 0,
+        totalSections: 0
+      };
+
+      this.progressServer.broadcastProgress(importId, progress);
+      console.error(`[${new Date().toISOString()}] [DatabaseCintasImport] ERROR: Import processing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+
+      return {
+        success: false,
+        totalInserted: 0,
+        sections: [],
+        errors: [error instanceof Error ? error.message : 'Unknown error']
+      };
+    }
+  }
+
+  async processCintasImportFromBuffer(
+    buffer: Buffer,
+    layoutConfig: any,
+    onProgress: (progress: ImportProgress) => void
+  ): Promise<ImportResult> {
+    try {
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Starting import processing from buffer`);
+      
+      // Initialize progress tracking
+      const progress: ImportProgress = {
+        importId: 0,
+        status: 'processing',
+        currentSection: '',
+        currentRow: 0,
+        totalRows: 0,
+        errors: [],
+        processedSections: 0,
+        totalSections: layoutConfig.sections?.length || 0
+      };
+
+      // Read Excel file directly from buffer
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Starting Excel file reading from buffer...`);
+      
+      const sections = await this.reader.readExcelFromBuffer(
+        buffer,
+        layoutConfig,
+        (sectionProgress) => {
+          onProgress(sectionProgress);
+        }
+      );
+
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Excel file read successfully. Found ${sections.length} sections`);
+
+      // Process each section
+      const processedSections = [];
+      let totalInserted = 0;
+
+      for (let i = 0; i < sections.length; i++) {
+        const section = sections[i];
+        
+        console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Processing section ${i+1}/${sections.length}: ${section.name}`);
+        progress.currentSection = section.name;
+        progress.processedSections = i + 1;
+        onProgress(progress);
+
+        try {
+          // Ensure table exists for this section
+          console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Creating table ${section.tableName} for section ${section.name}`);
+          await this.inserter.createImportTable(section.tableName, section.fields);
+          
+          const insertedRows = await this.inserter.insertSectionData(
+            section,
+            0, // Use 0 for buffer-based imports
+            (rows) => {
+              progress.currentRow = rows;
+              onProgress(progress);
+            }
+          );
+
+          processedSections.push({
+            sectionData: section,
+            insertedRows
+          });
+
+          totalInserted += insertedRows;
+          console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Completed section ${section.name}: ${insertedRows} rows inserted`);
+
+        } catch (error) {
+          const errorMessage = `Error processing section ${section.name}: ${error instanceof Error ? error.message : 'Unknown error'}`;
+          progress.errors.push(errorMessage);
+          console.error(`[${new Date().toISOString()}] [DatabaseCintasImport] ERROR: ${errorMessage}`);
+          onProgress(progress);
+        }
+      }
+
+      console.log(`[${new Date().toISOString()}] [DatabaseCintasImport] Import processing completed successfully. Total inserted: ${totalInserted}`);
+
+      return {
+        success: true,
+        totalInserted,
+        sections: processedSections
+      };
+
+    } catch (error) {
+      const progress: ImportProgress = {
+        importId: 0,
+        status: 'failed',
+        currentSection: '',
+        currentRow: 0,
+        totalRows: 0,
+        errors: [error instanceof Error ? error.message : 'Unknown error'],
+        processedSections: 0,
+        totalSections: 0
+      };
+
+      onProgress(progress);
+      console.error(`[${new Date().toISOString()}] [DatabaseCintasImport] ERROR: Import processing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+
+      return {
+        success: false,
+        totalInserted: 0,
+        sections: [],
+        errors: [error instanceof Error ? error.message : 'Unknown error']
+      };
+    }
+  }
+}

app/lib/excel-import/database-excel-reader.ts

@@ -0,0 +1,564 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as XLSX from 'xlsx';
+import { ReadSectionData, LayoutSectionField, SectionTypeEnum, FieldTypeEnum, ImportProgress } from './types';
+import { prisma } from '@/lib/prisma';
+
+// Simple logger utility for debugging
+const logger = {
+  debug: (message: string, ...args: any[]) => {
+    console.debug(`[DatabaseExcelReaderService] ${new Date().toISOString()} - ${message}`, ...args);
+  },
+  info: (message: string, ...args: any[]) => {
+    console.info(`[DatabaseExcelReaderService] ${new Date().toISOString()} - ${message}`, ...args);
+  },
+  warn: (message: string, ...args: any[]) => {
+    console.warn(`[DatabaseExcelReaderService] ${new Date().toISOString()} - ${message}`, ...args);
+  },
+  error: (message: string, ...args: any[]) => {
+    console.error(`[DatabaseExcelReaderService] ${new Date().toISOString()} - ${message}`, ...args);
+  }
+};
+
+export class DatabaseExcelReaderService {
+  async readExcelFromDatabase(
+    fileId: string,
+    layoutConfig: any,
+    onProgress: (progress: ImportProgress) => void
+  ): Promise<ReadSectionData[]> {
+    logger.info('Starting Excel file import from database', {
+      fileId,
+      layoutConfigSections: layoutConfig.sections?.length || 0
+    });
+
+    const startTime = Date.now();
+    
+    try {
+      // Fetch file from database
+      const fileRecord = await prisma.file.findUnique({
+        where: { id: fileId }
+      });
+
+      if (!fileRecord) {
+        throw new Error(`File with ID ${fileId} not found in database`);
+      }
+
+      logger.info('File retrieved from database', {
+        filename: fileRecord.filename,
+        size: fileRecord.size,
+        mimetype: fileRecord.mimetype
+      });
+
+      // Convert Buffer to ArrayBuffer for xlsx library
+      const arrayBuffer = fileRecord.data.buffer.slice(
+        fileRecord.data.byteOffset,
+        fileRecord.data.byteOffset + fileRecord.data.byteLength
+      );
+
+      logger.debug('Loading Excel workbook from buffer...');
+      const workbook = XLSX.read(arrayBuffer, { type: 'array' });
+      
+      logger.info('Excel workbook loaded successfully from database', {
+        worksheets: workbook.SheetNames.map(name => ({ 
+          name, 
+          rowCount: XLSX.utils.sheet_to_json(workbook.Sheets[name]).length 
+        }))
+      });
+        
+      const results: ReadSectionData[] = [];
+      const totalSections = layoutConfig.sections?.length || 0;
+       
+      logger.info('Processing Excel import from database', { totalSections });
+       
+      // Initialize progress
+      onProgress({
+        importId: 0,
+        status: 'processing',
+        currentSection: '',
+        currentRow: 0,
+        totalRows: 0,
+        errors: [],
+        processedSections: 0,
+        totalSections
+      });
+
+      for (let sectionIndex = 0; sectionIndex < totalSections; sectionIndex++) {
+        const section = layoutConfig.sections[sectionIndex];
+        logger.debug(`Processing section ${sectionIndex + 1}/${totalSections}`, {
+          sectionName: section.name,
+          sheetName: section.sheetName,
+          startingRow: section.startingRow,
+          endingRow: section.endingRow
+        });
+         
+        const worksheet = workbook.Sheets[section.sheetName];
+         
+        if (!worksheet) {
+          const error = `Worksheet '${section.sheetName}' not found`;
+          logger.warn(error, { availableWorksheets: workbook.SheetNames });
+           
+          onProgress({
+            importId: 0,
+            status: 'processing',
+            currentSection: section.name,
+            currentRow: 0,
+            totalRows: 0,
+            errors: [error],
+            processedSections: sectionIndex + 1,
+            totalSections
+          });
+          continue;
+        }
+
+        const sectionData = await this.processSectionFromWorksheet(
+          worksheet, 
+          section, 
+          sectionIndex, 
+          totalSections, 
+          onProgress
+        );
+        results.push(sectionData);
+         
+        logger.info(`Section ${section.name} processed successfully`, {
+          rowsProcessed: sectionData.data.length,
+          fields: sectionData.fields.length
+        });
+      }
+
+      const totalTime = Date.now() - startTime;
+      logger.info('Excel file import from database completed', {
+        totalSections: results.length,
+        totalRows: results.reduce((sum, section) => sum + section.data.length, 0),
+        totalTimeMs: totalTime
+      });
+
+      return results;
+    } catch (error) {
+      logger.error('Error reading Excel file from database', {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined
+      });
+      throw error;
+    }
+  }
+
+  async readExcelFromBuffer(
+    buffer: Buffer,
+    layoutConfig: any,
+    onProgress: (progress: ImportProgress) => void
+  ): Promise<ReadSectionData[]> {
+    logger.info('Starting Excel file import from buffer', {
+      bufferSize: buffer.length,
+      layoutConfigSections: layoutConfig.sections?.length || 0
+    });
+
+    const startTime = Date.now();
+    
+    try {
+      // Convert Buffer to ArrayBuffer for xlsx library
+      const arrayBuffer = buffer.buffer.slice(
+        buffer.byteOffset,
+        buffer.byteOffset + buffer.byteLength
+      );
+
+      logger.debug('Loading Excel workbook from buffer...');
+      const workbook = XLSX.read(arrayBuffer, { type: 'array' });
+      
+      logger.info('Excel workbook loaded successfully from buffer', {
+        worksheets: workbook.SheetNames.map(name => ({ 
+          name, 
+          rowCount: XLSX.utils.sheet_to_json(workbook.Sheets[name]).length 
+        }))
+      });
+        
+      const results: ReadSectionData[] = [];
+      const totalSections = layoutConfig.sections?.length || 0;
+       
+      logger.info('Processing Excel import from buffer', { totalSections });
+       
+      // Initialize progress
+      onProgress({
+        importId: 0,
+        status: 'processing',
+        currentSection: '',
+        currentRow: 0,
+        totalRows: 0,
+        errors: [],
+        processedSections: 0,
+        totalSections
+      });
+
+      for (let sectionIndex = 0; sectionIndex < totalSections; sectionIndex++) {
+        const section = layoutConfig.sections[sectionIndex];
+        logger.debug(`Processing section ${sectionIndex + 1}/${totalSections}`, {
+          sectionName: section.name,
+          sheetName: section.sheetName,
+          startingRow: section.startingRow,
+          endingRow: section.endingRow
+        });
+         
+        const worksheet = workbook.Sheets[section.sheetName];
+         
+        if (!worksheet) {
+          const error = `Worksheet '${section.sheetName}' not found`;
+          logger.warn(error, { availableWorksheets: workbook.SheetNames });
+           
+          onProgress({
+            importId: 0,
+            status: 'processing',
+            currentSection: section.name,
+            currentRow: 0,
+            totalRows: 0,
+            errors: [error],
+            processedSections: sectionIndex + 1,
+            totalSections
+          });
+          continue;
+        }
+
+        const sectionData = await this.processSectionFromWorksheet(
+          worksheet, 
+          section, 
+          sectionIndex, 
+          totalSections, 
+          onProgress
+        );
+        results.push(sectionData);
+         
+        logger.info(`Section ${section.name} processed successfully`, {
+          rowsProcessed: sectionData.data.length,
+          fields: sectionData.fields.length
+        });
+      }
+
+      const totalTime = Date.now() - startTime;
+      logger.info('Excel file import from buffer completed', {
+        totalSections: results.length,
+        totalRows: results.reduce((sum, section) => sum + section.data.length, 0),
+        totalTimeMs: totalTime
+      });
+
+      return results;
+    } catch (error) {
+      logger.error('Error reading Excel file from buffer', {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined
+      });
+      throw error;
+    }
+  }
+
+  private async processSectionFromWorksheet(
+    worksheet: XLSX.WorkSheet,
+    section: any,
+    sectionIndex: number,
+    totalSections: number,
+    onProgress: (progress: ImportProgress) => void
+  ): Promise<ReadSectionData> {
+    const sectionStartTime = Date.now();
+    logger.info(`Starting section processing from worksheet`, {
+      sectionName: section.name,
+      sheetName: section.sheetName,
+      sectionIndex: sectionIndex + 1,
+      totalSections
+    });
+
+    const startingRow = section.startingRow || 2; // Default to 2 to skip header
+    const endingRow = section.endingRow || Infinity;
+    
+    logger.debug('Section configuration', {
+      sectionName: section.name,
+      startingRow,
+      endingRow,
+      fieldsCount: section.fields?.length || 0
+    });
+    
+    // Convert worksheet to JSON array
+    const worksheetData = XLSX.utils.sheet_to_json(worksheet, { header: 1 }) as any[][];
+    
+    // Process data rows
+    const data: Record<string, any>[] = [];
+    const totalRows = Math.min(endingRow, worksheetData.length) - startingRow + 1;
+    
+    let processedRows = 0;
+    let skippedRows = 0;
+    
+    for (let rowNum = startingRow; rowNum <= Math.min(endingRow, worksheetData.length); rowNum++) {
+      const row = worksheetData[rowNum - 1]; // Convert to 0-based index
+      
+      if (!row || row.every(cell => cell === null || cell === undefined || cell === '')) {
+        skippedRows++;
+        logger.debug(`Skipping empty row ${rowNum}`);
+        continue;
+      }
+
+      const rowData: Record<string, any> = {};
+      let fieldsProcessed = 0;
+      
+      // Map cell values based on field configuration
+      for (const field of section.fields || []) {
+        try {
+          const cellAddress = this.parseCellAddress(field.cellPosition);
+          const cellValue = row[cellAddress.col - 1]; // Convert to 0-based index
+          
+          logger.debug(`Processing field`, {
+            fieldName: field.name,
+            cellPosition: field.cellPosition,
+            cellAddress,
+            rawValue: cellValue,
+            rowNum
+          });
+          
+          if (cellValue !== null && cellValue !== undefined && cellValue !== '') {
+            const value = this.convertCellValue(
+              cellValue,
+              field.parsedType || FieldTypeEnum.String
+            );
+            
+            logger.debug(`Value converted`, {
+              fieldName: field.name,
+              originalValue: cellValue,
+              convertedValue: value,
+              fieldType: field.parsedType || FieldTypeEnum.String
+            });
+            
+            // Map to the correct column name for Prisma model
+            const columnName = field.importTableColumnName;
+            rowData[columnName] = value;
+            fieldsProcessed++;
+          }
+        } catch (error) {
+          logger.error(`Error processing field ${field.name} at row ${rowNum}`, {
+            error: error instanceof Error ? error.message : String(error),
+            field,
+            rowNum
+          });
+        }
+      }
+      
+      // Only add non-empty rows
+      if (Object.keys(rowData).length > 0) {
+        data.push(rowData);
+        processedRows++;
+        
+        if (processedRows <= 5 || processedRows % 100 === 0) {
+          logger.debug(`Row processed`, {
+            rowNum,
+            fieldsProcessed,
+            rowDataKeys: Object.keys(rowData),
+            dataLength: data.length
+          });
+        }
+      } else {
+        logger.debug(`Skipping row with no valid data`, { rowNum });
+      }
+      
+      // Update progress every 100 rows
+      if (rowNum % 100 === 0 || rowNum === Math.min(endingRow, worksheetData.length)) {
+        onProgress({
+          importId: 0,
+          status: 'processing',
+          currentSection: section.name,
+          currentRow: rowNum - startingRow + 1,
+          totalRows,
+          errors: [],
+          processedSections: sectionIndex,
+          totalSections
+        });
+      }
+    }
+
+    const sectionTime = Date.now() - sectionStartTime;
+    logger.info(`Section processing completed`, {
+      sectionName: section.name,
+      processedRows,
+      skippedRows,
+      totalRows,
+      dataRows: data.length,
+      processingTimeMs: sectionTime
+    });
+
+    const result = {
+      id: section.id || 0,
+      name: section.name || '',
+      tableName: section.tableName || '',
+      sheet: section.sheetName || '',
+      type: section.type || '',
+      startingRow,
+      endingRow,
+      parsedType: this.mapSectionType(section.type),
+      fields: this.mapFields(section.fields || []),
+      data
+    };
+
+    logger.debug('Section result', {
+      sectionName: section.name,
+      resultSummary: {
+        id: result.id,
+        name: result.name,
+        tableName: result.tableName,
+        dataRows: result.data.length,
+        fields: result.fields.length
+      }
+    });
+
+    return result;
+  }
+
+  private parseCellAddress(cellPosition: string): { row: number; col: number } {
+    logger.debug(`Parsing cell address: ${cellPosition}`);
+    
+    const match = cellPosition.match(/([A-Z]+)(\d+)/);
+    if (!match) {
+      logger.warn(`Invalid cell position format: ${cellPosition}, using default 1,1`);
+      return { row: 1, col: 1 };
+    }
+    
+    const col = match[1].charCodeAt(0) - 'A'.charCodeAt(0) + 1;
+    const row = parseInt(match[2]);
+    
+    logger.debug(`Parsed cell address`, {
+      original: cellPosition,
+      row,
+      col
+    });
+    
+    return { row, col };
+  }
+
+  private mapSectionType(type: string): SectionTypeEnum {
+    logger.debug(`Mapping section type: ${type}`);
+    
+    const mappedType = (() => {
+      switch (type?.toLowerCase()) {
+        case 'grid':
+          return SectionTypeEnum.Grid;
+        case 'properties':
+          return SectionTypeEnum.Properties;
+        default:
+          return SectionTypeEnum.Unknown;
+      }
+    })();
+    
+    logger.debug(`Section type mapped`, {
+      originalType: type,
+      mappedType: SectionTypeEnum[mappedType]
+    });
+    
+    return mappedType;
+  }
+
+  private mapFields(fields: any[]): LayoutSectionField[] {
+    logger.debug(`Mapping ${fields.length} fields`);
+    
+    const mappedFields = fields.map((field, index) => {
+      const mappedField = {
+        id: field.id || index,
+        cellPosition: field.cellPosition || '',
+        name: field.name || '',
+        dataType: field.dataType || 'string',
+        dataTypeFormat: field.dataTypeFormat,
+        importTableColumnName: field.importTableColumnName || field.name || `column_${index}`,
+        importColumnOrderNumber: field.importColumnOrderNumber || index,
+        parsedType: this.mapFieldType(field.dataType)
+      };
+      
+      logger.debug(`Field mapped`, {
+        index,
+        originalName: field.name,
+        mappedName: mappedField.name,
+        cellPosition: mappedField.cellPosition,
+        parsedType: FieldTypeEnum[mappedField.parsedType]
+      });
+      
+      return mappedField;
+    });
+    
+    return mappedFields;
+  }
+
+  private mapFieldType(dataType: string): FieldTypeEnum {
+    const type = dataType?.toLowerCase();
+    
+    const mappedType = (() => {
+      switch (type) {
+        case 'time':
+          return FieldTypeEnum.Time;
+        case 'decimal':
+        case 'number':
+        case 'float':
+          return FieldTypeEnum.Decimal;
+        case 'date':
+          return FieldTypeEnum.Date;
+        case 'int':
+        case 'integer':
+        case 'numeric':
+          return FieldTypeEnum.Numeric;
+        default:
+          return FieldTypeEnum.String;
+      }
+    })();
+    
+    logger.debug(`Field type mapped`, {
+      originalDataType: dataType,
+      mappedType: FieldTypeEnum[mappedType]
+    });
+    
+    return mappedType;
+  }
+
+  private convertCellValue(value: any, fieldType: FieldTypeEnum): any {
+    if (value === null || value === undefined) {
+      logger.debug(`Converting null/undefined value to null`, { fieldType: FieldTypeEnum[fieldType] });
+      return null;
+    }
+    
+    logger.debug(`Converting cell value`, {
+      originalValue: value,
+      originalType: typeof value,
+      targetFieldType: FieldTypeEnum[fieldType]
+    });
+    
+    const convertedValue = (() => {
+      switch (fieldType) {
+        case FieldTypeEnum.Time:
+          if (typeof value === 'number') {
+            // Excel time is fraction of a day
+            const result = value * 24 * 60 * 60 * 1000; // Convert to milliseconds
+            logger.debug(`Time conversion`, { original: value, converted: result });
+            return result;
+          }
+          return value;
+        
+        case FieldTypeEnum.Decimal:
+          const decimalResult = parseFloat(value.toString()) || 0;
+          logger.debug(`Decimal conversion`, { original: value, converted: decimalResult });
+          return decimalResult;
+        
+        case FieldTypeEnum.Date:
+          if (typeof value === 'number') {
+            // Excel date is days since 1900-01-01
+            const excelEpoch = new Date(1900, 0, 1);
+            const dateResult = new Date(excelEpoch.getTime() + (value - 1) * 24 * 60 * 60 * 1000);
+            logger.debug(`Date conversion`, { original: value, converted: dateResult });
+            return dateResult;
+          }
+          const dateResult = new Date(value);
+          logger.debug(`Date conversion from string`, { original: value, converted: dateResult });
+          return dateResult;
+        
+        case FieldTypeEnum.Numeric:
+          const numericResult = parseInt(value.toString()) || 0;
+          logger.debug(`Numeric conversion`, { original: value, converted: numericResult });
+          return numericResult;
+        
+        case FieldTypeEnum.String:
+        default:
+          const stringResult = value.toString();
+          logger.debug(`String conversion`, { original: value, converted: stringResult });
+          return stringResult;
+      }
+    })();
+    
+    return convertedValue;
+  }
+}

app/lib/excel-import/excel-reader.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as ExcelJS from 'exceljs';
+import * as XLSX from 'xlsx';
 import { ReadSectionData, LayoutSectionField, SectionTypeEnum, FieldTypeEnum, ImportProgress } from './types';
 
 // Simple logger utility for debugging
@@ -20,25 +20,25 @@ const logger = {
 
 export class ExcelReaderService {
   async readExcelFile(
-    fileBuffer: Buffer,
+    filePath: string,
     layoutConfig: any,
     onProgress: (progress: ImportProgress) => void
   ): Promise<ReadSectionData[]> {
     logger.info('Starting Excel file import', {
-      fileSize: fileBuffer.length,
+      filePath,
+      fileSize: require('fs').statSync(filePath).size,
       layoutConfigSections: layoutConfig.sections?.length || 0
     });
 
     const startTime = Date.now();
     
     try {
-      const workbook = new ExcelJS.Workbook();
-      logger.debug('Loading Excel workbook from buffer...');
-      await workbook.xlsx.load(fileBuffer as any);
+      logger.debug('Loading Excel workbook from file path...');
+      const workbook = XLSX.readFile(filePath);
       logger.info('Excel workbook loaded successfully', {
-        worksheets: workbook.worksheets.map(ws => ({ name: ws.name, rowCount: ws.rowCount }))
+        worksheets: workbook.SheetNames.map(name => ({ name, rowCount: XLSX.utils.sheet_to_json(workbook.Sheets[name]).length }))
       });
-      
+        
       const results: ReadSectionData[] = [];
       const totalSections = layoutConfig.sections?.length || 0;
       
@@ -65,11 +65,11 @@ export class ExcelReaderService {
           endingRow: section.endingRow
         });
         
-        const worksheet = workbook.getWorksheet(section.sheetName);
+        const worksheet = workbook.Sheets[section.sheetName];
         
         if (!worksheet) {
           const error = `Worksheet '${section.sheetName}' not found`;
-          logger.warn(error, { availableWorksheets: workbook.worksheets.map(ws => ws.name) });
+          logger.warn(error, { availableWorksheets: workbook.SheetNames });
           
           onProgress({
             importId: 0,
@@ -111,7 +111,7 @@ export class ExcelReaderService {
   }
 
   private async processSection(
-    worksheet: ExcelJS.Worksheet,
+    worksheet: XLSX.WorkSheet,
     section: any,
     sectionIndex: number,
     totalSections: number,
@@ -126,27 +126,29 @@ export class ExcelReaderService {
     });
 
     const startingRow = section.startingRow || 2; // Default to 2 to skip header
-    const endingRow = section.endingRow || worksheet.rowCount;
+    const endingRow = section.endingRow || Infinity;
     
     logger.debug('Section configuration', {
       sectionName: section.name,
       startingRow,
       endingRow,
-      totalRowsInSheet: worksheet.rowCount,
       fieldsCount: section.fields?.length || 0
     });
     
+    // Convert worksheet to JSON array
+    const worksheetData = XLSX.utils.sheet_to_json(worksheet, { header: 1 }) as any[][];
+    
     // Process data rows
     const data: Record<string, any>[] = [];
-    const totalRows = endingRow - startingRow + 1;
+    const totalRows = Math.min(endingRow, worksheetData.length) - startingRow + 1;
     
     let processedRows = 0;
     let skippedRows = 0;
     
-    for (let rowNum = startingRow; rowNum <= endingRow; rowNum++) {
-      const row = worksheet.getRow(rowNum);
+    for (let rowNum = startingRow; rowNum <= Math.min(endingRow, worksheetData.length); rowNum++) {
+      const row = worksheetData[rowNum - 1]; // Convert to 0-based index
       
-      if (!row.hasValues) {
+      if (!row || row.every(cell => cell === null || cell === undefined || cell === '')) {
         skippedRows++;
         logger.debug(`Skipping empty row ${rowNum}`);
         continue;
@@ -159,25 +161,25 @@ export class ExcelReaderService {
       for (const field of section.fields || []) {
         try {
           const cellAddress = this.parseCellAddress(field.cellPosition);
-          const cell = row.getCell(cellAddress.col);
+          const cellValue = row[cellAddress.col - 1]; // Convert to 0-based index
           
           logger.debug(`Processing field`, {
             fieldName: field.name,
             cellPosition: field.cellPosition,
             cellAddress,
-            rawValue: cell?.value,
+            rawValue: cellValue,
             rowNum
           });
           
-          if (cell && cell.value !== null && cell.value !== undefined) {
+          if (cellValue !== null && cellValue !== undefined && cellValue !== '') {
             const value = this.convertCellValue(
-              cell.value,
+              cellValue,
               field.parsedType || FieldTypeEnum.String
             );
             
             logger.debug(`Value converted`, {
               fieldName: field.name,
-              originalValue: cell.value,
+              originalValue: cellValue,
               convertedValue: value,
               fieldType: field.parsedType || FieldTypeEnum.String
             });
@@ -214,7 +216,7 @@ export class ExcelReaderService {
       }
       
       // Update progress every 100 rows
-      if (rowNum % 100 === 0 || rowNum === endingRow) {
+      if (rowNum % 100 === 0 || rowNum === Math.min(endingRow, worksheetData.length)) {
         onProgress({
           importId: 0,
           status: 'processing',

app/lib/excel-import/file-downloader.ts

@@ -0,0 +1,74 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as http from 'http';
+
+export class FileDownloader {
+  private tempDir: string;
+
+  constructor() {
+    // Use a temp directory that's accessible across different environments
+    this.tempDir = path.join(process.cwd(), 'temp-downloads');
+    this.ensureTempDirExists();
+  }
+
+  private ensureTempDirExists(): void {
+    if (!fs.existsSync(this.tempDir)) {
+      fs.mkdirSync(this.tempDir, { recursive: true });
+    }
+  }
+
+  async downloadFile(url: string, filename: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const filePath = path.join(this.tempDir, filename);
+      
+      // Clean up existing file if it exists
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+
+      const file = fs.createWriteStream(filePath);
+      const client = url.startsWith('https') ? https : http;
+
+      const request = client.get(url, (response) => {
+        if (response.statusCode === 200) {
+          response.pipe(file);
+          file.on('finish', () => {
+            file.close();
+            resolve(filePath);
+          });
+        } else {
+          file.close();
+          fs.unlink(filePath, () => {});
+          reject(new Error(`Failed to download file: ${response.statusCode} ${response.statusMessage}`));
+        }
+      });
+
+      request.on('error', (err) => {
+        file.close();
+        fs.unlink(filePath, () => {});
+        reject(err);
+      });
+    });
+  }
+
+  async cleanupFile(filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (fs.existsSync(filePath)) {
+        fs.unlink(filePath, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  getTempDir(): string {
+    return this.tempDir;
+  }
+}

package-lock.json

@@ -27,6 +27,7 @@
         "@scalar/nextjs-api-reference": "^0.8.12",
         "@tanstack/react-query": "^5.83.0",
         "@tanstack/react-table": "^8.21.3",
+        "@types/xlsx": "^0.0.35",
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "date-fns": "^4.1.0",
@@ -40,6 +41,7 @@
         "tailwind-merge": "^3.3.1",
         "tailwindcss-animate": "^1.0.7",
         "ws": "^8.18.3",
+        "xlsx": "^0.18.5",
         "zod": "^4.0.5"
       },
       "devDependencies": {
@@ -3937,6 +3939,12 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/xlsx": {
+      "version": "0.0.35",
+      "resolved": "https://registry.npmjs.org/@types/xlsx/-/xlsx-0.0.35.tgz",
+      "integrity": "sha512-s0x3DYHZzOkxtjqOk/Nv1ezGzpbN7I8WX+lzlV/nFfTDOv7x4d8ZwGHcnaiB8UCx89omPsftQhS5II3jeWePxQ==",
+      "license": "MIT"
+    },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "8.22.0",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.22.0.tgz",
@@ -4689,6 +4697,15 @@
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
+    "node_modules/adler-32": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/adler-32/-/adler-32-1.3.1.tgz",
+      "integrity": "sha512-ynZ4w/nUUv5rrsR8UUGoe1VC9hZj6V5hU9Qw1HlMDJGEJw5S7TfTErWTjMys6M7vr0YWcPqs3qAr4ss0nDfP+A==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/ajv": {
       "version": "8.17.1",
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
@@ -5385,6 +5402,19 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/cfb": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cfb/-/cfb-1.2.2.tgz",
+      "integrity": "sha512-KfdUZsSOw19/ObEWasvBP/Ac4reZvAGauZhs6S/gqNhXhI7cKwvlH7ulj+dOEYnca4bm4SGo8C1bTAQvnTjgQA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "adler-32": "~1.3.0",
+        "crc-32": "~1.2.0"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/chainsaw": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/chainsaw/-/chainsaw-0.1.0.tgz",
@@ -5521,6 +5551,15 @@
         "@codemirror/view": "^6.0.0"
       }
     },
+    "node_modules/codepage": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/codepage/-/codepage-1.15.0.tgz",
+      "integrity": "sha512-3g6NUTPd/YtuuGrhMnOMRjFc+LJw/bnMp3+0r/Wcz3IXUuCosKRJvMphm5+Q+bvTVGcJJuRvVLuYba+WojaFaA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/color": {
       "version": "4.2.3",
       "resolved": "https://registry.npmjs.org/color/-/color-4.2.3.tgz",
@@ -6965,6 +7004,15 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/frac": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/frac/-/frac-1.1.2.tgz",
+      "integrity": "sha512-w/XBfkibaTl3YDqASwfDUqkna4Z2p9cFSr1aHDt0WoMTECnRfBOv2WArlZILlqgWlmdIlALXGpM2AOhEk5W3IA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/fs-constants": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
@@ -11402,6 +11450,18 @@
         "node": ">= 10.x"
       }
     },
+    "node_modules/ssf": {
+      "version": "0.11.2",
+      "resolved": "https://registry.npmjs.org/ssf/-/ssf-0.11.2.tgz",
+      "integrity": "sha512-+idbmIXoYET47hH+d7dfm2epdOMUDjqcB4648sTZ+t2JwoyBFL/insLfB/racrDmsKB3diwsDA696pZMieAC5g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "frac": "~1.1.2"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/stable-hash": {
       "version": "0.0.4",
       "resolved": "https://registry.npmjs.org/stable-hash/-/stable-hash-0.0.4.tgz",
@@ -12652,6 +12712,24 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/wmf": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wmf/-/wmf-1.0.2.tgz",
+      "integrity": "sha512-/p9K7bEh0Dj6WbXg4JG0xvLQmIadrner1bi45VMJTfnbVHsc7yIajZyoSoK60/dtVBs12Fm6WkUI5/3WAVsNMw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/word": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/word/-/word-0.3.0.tgz",
+      "integrity": "sha512-OELeY0Q61OXpdUfTp+oweA/vtLVg5VDOXh+3he3PNzLGG/y0oylSOC1xRVj0+l4vQ3tj/bB1HVHv1ocXkQceFA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/word-wrap": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
@@ -12776,6 +12854,27 @@
         }
       }
     },
+    "node_modules/xlsx": {
+      "version": "0.18.5",
+      "resolved": "https://registry.npmjs.org/xlsx/-/xlsx-0.18.5.tgz",
+      "integrity": "sha512-dmg3LCjBPHZnQp5/F/+nnTa+miPJxUXB6vtk42YjBBKayDNagxGEeIdWApkYPOf3Z3pm3k62Knjzp7lMeTEtFQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "adler-32": "~1.3.0",
+        "cfb": "~1.2.1",
+        "codepage": "~1.15.0",
+        "crc-32": "~1.2.1",
+        "ssf": "~0.11.2",
+        "wmf": "~1.0.1",
+        "word": "~0.3.0"
+      },
+      "bin": {
+        "xlsx": "bin/xlsx.njs"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/xmlchars": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",

package.json

@@ -28,6 +28,7 @@
     "@scalar/nextjs-api-reference": "^0.8.12",
     "@tanstack/react-query": "^5.83.0",
     "@tanstack/react-table": "^8.21.3",
+    "@types/xlsx": "^0.0.35",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
@@ -41,6 +42,7 @@
     "tailwind-merge": "^3.3.1",
     "tailwindcss-animate": "^1.0.7",
     "ws": "^8.18.3",
+    "xlsx": "^0.18.5",
     "zod": "^4.0.5"
   },
   "devDependencies": {