@solidstarters/solid-core 1.2.193 → 1.2.201

package/src/services/excel.service.ts

@@ -3,7 +3,6 @@ import * as ExcelJS from 'exceljs';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { PassThrough, Readable } from 'stream';
 
-
 export interface ExcelReadOptions {
   pageSize?: number; // Number of records per page
   hasHeaderRow?: boolean; // Whether the first row contains headers
@@ -17,6 +16,11 @@ export interface ExcelReadResult {
   data: Record<string, any>[]; // Data records in the current page
 }
 
+export interface ExcelReadAllResult {
+  headers: string[];
+  rows: Record<string, any>[];
+}
+
 @Injectable()
 export class ExcelService {
   private logger = new Logger(ExcelService.name);
@@ -59,7 +63,7 @@ export class ExcelService {
         //   headers.reduce((acc, header) => ({ ...acc, [header]: '' }), {})
         // ).commit(); // Write a dummy record with headers
 
-         workbook.commit();
+        workbook.commit();
         return passThrough;
       }
 
@@ -86,7 +90,7 @@ export class ExcelService {
         this.logger.debug(`✅ Chunk ${chunkIndex} written to Excel`);
       }
 
-       workbook.commit();
+      workbook.commit();
       // passThrough.end(); // ✅ Properly close the stream
     } catch (error) {
       this.logger.error(`❌ Error writing Excel: ${error.message}`);
@@ -159,4 +163,143 @@ export class ExcelService {
     }
   }
 
+  private cleanString(value: any): string {
+    return (value === null || value === undefined ? '' : String(value))
+      .replace(/\uFEFF/g, '') // BOM
+      .replace(/\u00A0/g, ' ') // NBSP
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+
+  private normalizeCellValue(value: any, sharedStrings?: any[]): any {
+    if (value === undefined || value === null) return null;
+
+    // ExcelJS streaming shared string ref: { sharedString: number }
+    if (typeof value === 'object' && value && 'sharedString' in value) {
+      const idx = (value as any).sharedString;
+      const resolved = sharedStrings?.[idx];
+      // sharedStrings may store objects or plain strings depending on ExcelJS internals
+      if (resolved === undefined || resolved === null) return null;
+      if (typeof resolved === 'string') return resolved;
+      if (typeof resolved === 'object') {
+        if ('text' in resolved && typeof (resolved as any).text === 'string') return (resolved as any).text;
+        if ('richText' in resolved && Array.isArray((resolved as any).richText)) {
+          return (resolved as any).richText.map((item: any) => item?.text ?? '').join('');
+        }
+        if ('value' in resolved) return (resolved as any).value;
+      }
+      return resolved;
+    }
+
+    // ExcelJS can return rich objects for styled cells; unwrap to plain text/primitive
+    if (typeof value === 'object' && value) {
+      // Plain rich cell: { text: '...' }
+      if ('text' in value && typeof (value as any).text === 'string') return (value as any).text;
+
+      // Rich text: { richText: [{text:'a'}, ...] }
+      if ('richText' in value && Array.isArray((value as any).richText)) {
+        return (value as any).richText.map((item: any) => item?.text ?? '').join('');
+      }
+
+      // Formula cells: { formula: '...', result: ... }
+      if ('result' in value) return (value as any).result;
+      if ('formula' in value) return (value as any).formula;
+
+      // Hyperlinks: { text: '...', hyperlink: '...' }
+      if ('hyperlink' in value && typeof (value as any).hyperlink === 'string') {
+        return (value as any).text ?? (value as any).hyperlink;
+      }
+
+      // Sometimes primitive nested under .value
+      if ('value' in value) return this.normalizeCellValue((value as any).value, sharedStrings);
+    }
+
+    return value;
+  }
+
+  public async readExcelFromStreamNonStreaming(
+    stream: Readable,
+    options?: ExcelReadOptions & { worksheetIndex?: number; maxRows?: number }
+  ): Promise<ExcelReadAllResult> {
+    const {
+      hasHeaderRow = true,
+      providedHeaders = [],
+      worksheetIndex = 0, // 0-based
+      maxRows,
+    } = options || {};
+
+    // 1) Read entire stream into a Buffer
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const buffer = Buffer.concat(chunks);
+
+    // 2) Load workbook (non-streaming)
+    const workbook = new ExcelJS.Workbook();
+    // @ts-ignore
+    await workbook.xlsx.load(buffer);
+
+    const worksheet = workbook.worksheets?.[worksheetIndex];
+    if (!worksheet) {
+      return { headers: [], rows: [] };
+    }
+
+    // 3) Determine headers
+    let headers: string[] = [];
+
+    const firstRow = worksheet.getRow(1);
+    const firstRowValues = Array.isArray(firstRow.values) ? (firstRow.values as any[]).slice(1) : [];
+
+    const normalizeNonStreamingCell = (v: any) => {
+      // In non-streaming ExcelJS, cell.value can be:
+      // - string/number/boolean/date
+      // - {richText}, {text}, {hyperlink}, {formula,result}, etc.
+      // We'll reuse your normalizeCellValue but without sharedStrings
+      return this.normalizeCellValue(v);
+    };
+
+    if (hasHeaderRow) {
+      headers = firstRowValues.map((v) => this.cleanString(normalizeNonStreamingCell(v)));
+    } else if (providedHeaders.length) {
+      headers = providedHeaders.map((h) => this.cleanString(h));
+    } else {
+      headers = firstRowValues.map((_, idx) => `${idx}`);
+    }
+
+    // If headers are all blank and hasHeaderRow=true, treat as no headers (avoid mapping everything to "")
+    if (hasHeaderRow && headers.length > 0 && headers.every((h) => !h)) {
+      this.logger.warn(`ExcelService.readExcelFromStreamNonStreaming: header row appears blank`);
+    }
+
+    // 4) Read rows
+    const rows: Record<string, any>[] = [];
+
+    const startRowNumber = hasHeaderRow ? 2 : 1;
+    const lastRowNumber = worksheet.rowCount || 0;
+
+    for (let r = startRowNumber; r <= lastRowNumber; r++) {
+      if (maxRows && rows.length >= maxRows) break;
+
+      const row = worksheet.getRow(r);
+      const rawValues = Array.isArray(row.values) ? (row.values as any[]).slice(1) : [];
+      const values = rawValues.map((v) => normalizeNonStreamingCell(v));
+
+      // Align row width to header width
+      while (values.length < headers.length) values.push(null);
+      if (values.length > headers.length) values.length = headers.length;
+
+      const record = headers.reduce((acc, key, i) => {
+        acc[key] = values[i] ?? null;
+        return acc;
+      }, {} as Record<string, any>);
+
+      // Skip fully empty rows
+      if (Object.values(record).every((v) => v === null || this.cleanString(v) === '')) continue;
+
+      rows.push(record);
+    }
+
+    return { headers, rows };
+  }
 }