Server-Side Row Model - Exporting

import {
  AdaptableColumnBase,
  AdaptableOptions,
  BooleanFunctionName,
  ModuleExpressionFunctionsContext,
  ProcessExportContext,
  Report,
  ExportResultData,
  ReportData,
  SystemReportName,
} from '@adaptabletools/adaptable';

const API_BASE: string = 'https://serverside-demo.adaptabletools.com/.netlify/functions/athletes'!;

const REPORTS_HANDLED_CLIENT_SIDE: (SystemReportName | string)[] = [
  'Current Layout',
  'Selected Data',
];

interface RequestReportConfig {
  report: Report;
  reportColumns: AdaptableColumnBase[];
  reportQueryAST?: any;
}

export async function handleExport(
  context: ProcessExportContext
): Promise<ExportResultData | boolean> {
  const {report, reportFormat} = context;
  if (REPORTS_HANDLED_CLIENT_SIDE.includes(report.Name)) {
    //  these reports are client-side specific and will be handled by the default behaviour (which is to export the client-side data)
    return true;
  }

  // everything else ('All Data' or any other custom Reports) will be handled server-side

  const reportColumns =
    report.Name === 'All Data'
      ? // sending an empty array will cause the server to use all columns
        []
      : context.getReportColumns().filter(column => {
          // for simplicity's sake, we're only going to filter out the special (synthetic) columns (Calculated, FreeText, Action)
          // otherwise we would have to evaluate them on the server as well
          return !context.adaptableApi.columnApi.isCalculatedColumn(
            column.columnId
          );
        });

  const reportConfig: RequestReportConfig = {
    report,
    reportColumns,
  };

  if (report.Query?.BooleanExpression) {
    reportConfig.reportQueryAST =
      context.adaptableApi.expressionApi.getASTForExpression(
        report.Query.BooleanExpression
      );
  }

  const serverSideResponse = await fetch(`${API_BASE}/report`, {
    method: 'post',
    body: JSON.stringify(reportConfig),
    headers: {'Content-Type': 'application/json; charset=utf-8'},
  });
  const serverSideResultData: ExportResultData =
    await serverSideResponse.json();

  if (serverSideResultData.type !== 'json') {
    console.log(
      'In this showcase we always return JSON from the server, so this should never happen'
    );
    return serverSideResultData;
  }

  if (reportFormat === 'CSV') {
    const csvContent = context.convertToCsv(serverSideResultData.data);
    return {
      type: 'csv',
      data: csvContent,
    };
  }
  if (reportFormat === 'Excel' || reportFormat === 'VisualExcel') {
    const excelBLob = context.convertToExcel(serverSideResultData.data);
    return {
      type: 'excel',
      data: excelBLob,
    };
  }

  return serverSideResultData;
}

export const adaptableOptions: AdaptableOptions = {
  primaryKey: 'id',
  adaptableId: 'SSRM: Export',
  exportOptions: {
    processExport: handleExport,
    systemReportNames: ['All Data', 'Current Layout'],
    systemReportFormats: ['Excel', 'CSV', 'JSON'],
  },
  initialState: {
    Dashboard: {
      PinnedToolbars: ['Export'],
    },
    Theme: {
      CurrentTheme: 'dark',
    },
    Export: {
      CurrentReport: 'US Golden Athletes',
      CurrentFormat: 'Excel',
      Reports: [
        {
          Name: 'US Golden Athletes',
          ReportColumnScope: 'ScopeColumns',
          Scope: {
            ColumnIds: ['athlete', 'gold', 'sport', 'year', 'country'],
          },
          ReportRowScope: 'ExpressionRows',
          Query: {
            BooleanExpression: '[country]="United States" AND [gold]>0',
          },
        },
      ],
    },
    Layout: {
      CurrentLayout: 'SSRM Layout',
      Layouts: [
        {
          Name: 'SSRM Layout',
          TableColumns: [
            'athlete',
            'gold',
            'silver',
            'bronze',
            'country',
            'sport',
            'year',
          ],
          ColumnSizing: {
            athlete: {Width: 175},
            bronze: {Width: 100},
            country: {Width: 125},
            gold: {Width: 100},
            silver: {Width: 100},
            sport: {Width: 175},
            year: {Width: 115},
          },
        },
      ],
    },
  },
};