Concern Exports

import { FromCollection } from "@nestbolt/excel";

class UsersExport implements FromCollection {
  constructor(private readonly usersService: UsersService) {}

  async collection() {
    return await this.usersService.findAll();
  }
}

import { FromArray } from "@nestbolt/excel";

class ReportExport implements FromArray {
  array() {
    return [
      [1, "Alice", "alice@example.com", 100],
      [2, "Bob", "bob@example.com", 200],
      [3, "Charlie", "charlie@example.com", 150],
    ];
  }
}

import { FromCollection, WithHeadings } from "@nestbolt/excel";

class UsersExport implements FromCollection, WithHeadings {
  collection() {
    return this.users;
  }

  headings() {
    return ["ID", "Name", "Email", "Department"];
  }
}

headings() {
  return [
    ["User Report - Q1 2026"],           // title row
    ["ID", "Name", "Email", "Department"], // column headers
  ];
}

import { FromCollection, WithHeadings, WithMapping } from "@nestbolt/excel";

class UsersExport implements FromCollection, WithHeadings, WithMapping<User> {
  collection() {
    return this.users;
  }

  headings() {
    return ["ID", "Full Name", "Email", "Active"];
  }

  map(user: User) {
    return [
      user.id,
      `${user.firstName} ${user.lastName}`,
      user.email,
      user.isActive ? "Yes" : "No",
    ];
  }
}

import { FromCollection, WithTitle } from "@nestbolt/excel";

class UsersExport implements FromCollection, WithTitle {
  collection() {
    return this.users;
  }

  title() {
    return "Active Users";
  }
}

import { WithMultipleSheets, FromCollection, WithHeadings, WithTitle } from "@nestbolt/excel";

class JanuarySheet implements FromCollection, WithHeadings, WithTitle {
  collection() { return this.januaryData; }
  headings() { return ["Date", "Revenue", "Expenses"]; }
  title() { return "January"; }
}

class FebruarySheet implements FromCollection, WithHeadings, WithTitle {
  collection() { return this.februaryData; }
  headings() { return ["Date", "Revenue", "Expenses"]; }
  title() { return "February"; }
}

class QuarterlyReport implements WithMultipleSheets {
  sheets() {
    return [
      new JanuarySheet(),
      new FebruarySheet(),
      new SummarySheet(),
    ];
  }
}

// Usage:
return this.excelService.downloadAsStream(new QuarterlyReport(), "q1-report.xlsx");

import { FromCollection, WithCustomStartCell } from "@nestbolt/excel";

class ReportExport implements FromCollection, WithCustomStartCell {
  collection() {
    return this.data;
  }

  startCell() {
    return "C3";
  }
}

import { FromCollection, WithColumnWidths } from "@nestbolt/excel";

class UsersExport implements FromCollection, WithColumnWidths {
  collection() {
    return this.users;
  }

  columnWidths() {
    return {
      A: 8,   // ID column -- narrow
      B: 30,  // Name column -- wide
      C: 35,  // Email column -- wider
      D: 15,  // Department
    };
  }
}

import { FromCollection, WithColumnFormatting } from "@nestbolt/excel";

class FinancialExport implements FromCollection, WithColumnFormatting {
  collection() {
    return this.transactions;
  }

  columnFormats() {
    return {
      A: "yyyy-mm-dd",     // date column
      B: "#,##0.00",       // amount with two decimals
      C: "$#,##0.00",      // currency
      D: "0.00%",          // percentage
    };
  }
}

import { FromCollection, WithHeadings, WithStyles } from "@nestbolt/excel";

class StyledExport implements FromCollection, WithHeadings, WithStyles {
  collection() {
    return this.data;
  }

  headings() {
    return ["ID", "Name", "Revenue"];
  }

  styles() {
    return {
      // Style an entire row (row 1 = heading row)
      1: {
        font: { bold: true, size: 12, color: "FFFFFF" },
        fill: { type: "pattern", pattern: "solid", fgColor: "4472C4" },
        alignment: { horizontal: "center" },
      },

      // Style an entire column
      C: {
        numFmt: "$#,##0.00",
        alignment: { horizontal: "right" },
      },

      // Style a specific cell
      A1: {
        font: { bold: true, size: 14 },
        border: {
          bottom: { style: "medium", color: "000000" },
        },
      },
    };
  }
}

import { FromCollection, ShouldAutoSize } from "@nestbolt/excel";

class UsersExport implements FromCollection, ShouldAutoSize {
  readonly shouldAutoSize = true as const;

  collection() {
    return this.users;
  }
}

import { FromCollection, WithHeadings, WithAutoFilter } from "@nestbolt/excel";

class UsersExport implements FromCollection, WithHeadings, WithAutoFilter {
  collection() {
    return this.users;
  }

  headings() {
    return ["ID", "Name", "Email", "Department"];
  }

  autoFilter() {
    return "auto"; // automatically covers A1:D1
  }
}

autoFilter() {
  return "A1:D1";  // explicit range
}

import { FromCollection, WithHeadings, WithFrozenRows } from "@nestbolt/excel";

class UsersExport implements FromCollection, WithHeadings, WithFrozenRows {
  collection() {
    return this.users;
  }

  headings() {
    return ["ID", "Name", "Email"];
  }

  frozenRows() {
    return 1; // freeze the heading row
  }
}

import { FromCollection, WithFrozenColumns } from "@nestbolt/excel";

class WideReport implements FromCollection, WithFrozenColumns {
  collection() {
    return this.data;
  }

  frozenColumns() {
    return 2; // freeze columns A and B
  }
}

class DataExport
  implements FromCollection, WithHeadings, WithFrozenRows, WithFrozenColumns
{
  collection() { return this.data; }
  headings() { return ["ID", "Category", "Jan", "Feb", "Mar", "Apr"]; }
  frozenRows() { return 1; }
  frozenColumns() { return 2; }
}

import { FromCollection, WithProperties } from "@nestbolt/excel";

class AuditExport implements FromCollection, WithProperties {
  collection() {
    return this.auditRecords;
  }

  properties() {
    return {
      creator: "MyApp v2.1",
      lastModifiedBy: "Export Service",
      title: "Audit Log Export",
      subject: "Security Audit Records",
      description: "Exported on " + new Date().toISOString(),
      keywords: "audit security logs",
      category: "Reports",
      company: "Acme Corp",
      manager: "Jane Smith",
    };
  }
}

import { FromCollection, WithCsvSettings } from "@nestbolt/excel";

class EuropeanExport implements FromCollection, WithCsvSettings {
  collection() {
    return this.data;
  }

  csvSettings() {
    return {
      delimiter: ";",       // semicolon for European locales
      quoteChar: '"',
      lineEnding: "\r\n",   // Windows line endings
      useBom: true,         // BOM for Excel compatibility
      encoding: "utf-8",
    };
  }
}

import {
  FromCollection,
  WithHeadings,
  WithEvents,
  ExcelExportEvent,
} from "@nestbolt/excel";
import type {
  BeforeExportEventPayload,
  BeforeSheetEventPayload,
  AfterSheetEventPayload,
} from "@nestbolt/excel";

class UsersExport implements FromCollection, WithHeadings, WithEvents {
  collection() {
    return this.users;
  }

  headings() {
    return ["ID", "Name", "Email"];
  }

  registerEvents() {
    return {
      [ExcelExportEvent.BEFORE_EXPORT]: (event: BeforeExportEventPayload) => {
        // Called once, before any sheets are created
        // event.workbook -- the ExcelJS Workbook instance
        // event.exportable -- the export class instance
        console.log("Starting export...");
      },

      [ExcelExportEvent.BEFORE_SHEET]: (event: BeforeSheetEventPayload) => {
        // Called before each sheet is populated
        // event.worksheet -- the ExcelJS Worksheet instance
        // event.exportable -- the export class instance
      },

      [ExcelExportEvent.AFTER_SHEET]: (event: AfterSheetEventPayload) => {
        // Called after each sheet is fully populated
        // event.worksheet -- the ExcelJS Worksheet instance
        const ws = event.worksheet;

        // Add data validation to a column
        ws.getColumn("C").eachCell((cell, rowNumber) => {
          if (rowNumber > 1) {
            cell.dataValidation = {
              type: "textLength",
              operator: "greaterThan",
              formulae: [0],
              showErrorMessage: true,
              errorTitle: "Invalid",
              error: "Email cannot be empty",
            };
          }
        });
      },

      [ExcelExportEvent.BEFORE_WRITING]: (event) => {
        // Called once, after all sheets are populated but before the
        // workbook is serialized to a buffer
        // event.workbook -- the finalized ExcelJS Workbook
      },
    };
  }
}

const result = await this.excelService.download(
  new UsersExport(users),
  "users.xlsx",
);

@Get("export")
async exportUsers() {
  const users = await this.usersService.findAll();
  return this.excelService.downloadAsStream(new UsersExport(users), "users.xlsx");
}

await this.excelService.store(
  new UsersExport(users),
  "reports/users.xlsx",
);

// Write to a named disk
await this.excelService.store(
  new UsersExport(users),
  "reports/users.xlsx",
  undefined,  // auto-detect type from extension
  "s3",
);

import { ExcelType } from "@nestbolt/excel";

const buffer = await this.excelService.raw(new UsersExport(users), ExcelType.XLSX);

class FinancialReport
  implements
    FromCollection,
    WithHeadings,
    WithMapping,
    WithTitle,
    WithColumnWidths,
    WithColumnFormatting,
    WithStyles,
    WithAutoFilter,
    WithFrozenRows,
    WithProperties,
    ShouldAutoSize,
    WithEvents
{
  readonly shouldAutoSize = true as const;

  constructor(private readonly transactions: Transaction[]) {}

  collection() {
    return this.transactions;
  }

  headings() {
    return ["Date", "Description", "Category", "Amount", "Balance"];
  }

  map(tx: Transaction) {
    return [tx.date, tx.description, tx.category, tx.amount, tx.runningBalance];
  }

  title() {
    return "Transactions";
  }

  columnWidths() {
    return { A: 12, B: 40, C: 18, D: 14, E: 14 };
  }

  columnFormats() {
    return { A: "yyyy-mm-dd", D: "#,##0.00", E: "#,##0.00" };
  }

  styles() {
    return {
      1: {
        font: { bold: true, color: "FFFFFF" },
        fill: { type: "pattern" as const, pattern: "solid" as const, fgColor: "2F5496" },
      },
    };
  }

  autoFilter() {
    return "auto";
  }

  frozenRows() {
    return 1;
  }

  properties() {
    return { creator: "Finance App", title: "Monthly Transactions" };
  }

  registerEvents() {
    return {
      [ExcelExportEvent.AFTER_SHEET]: ({ worksheet }) => {
        // Add a summary row at the bottom
        const lastRow = worksheet.lastRow?.number ?? 1;
        const summaryRow = worksheet.getRow(lastRow + 2);
        summaryRow.getCell(3).value = "Total:";
        summaryRow.getCell(3).font = { bold: true };
        summaryRow.getCell(4).value = { formula: `SUM(D2:D${lastRow})` };
        summaryRow.getCell(4).numFmt = "#,##0.00";
      },
    };
  }
}