index.ts

import { AdminForthPlugin, suggestIfTypo, AdminForthFilterOperators, Filters, AdminForthDataTypes } from "adminforth";
import type { IAdminForth, IHttpServer, AdminForthResourceColumn, AdminForthComponentDeclaration, AdminForthResource } from "adminforth";
import type { PluginOptions } from './types.js';

export default class ImportExport extends AdminForthPlugin {
  options: PluginOptions;
  emailField: AdminForthResourceColumn;
  authResourceId: string;
  adminforth: IAdminForth;

  constructor(options: PluginOptions) {
    super(options, import.meta.url);
    this.options = options;
  }

  async modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
    super.modifyResourceConfig(adminforth, resourceConfig);
    if (!resourceConfig.options.pageInjections) {
      resourceConfig.options.pageInjections = {};
    }
    if (!resourceConfig.options.pageInjections.list) {
      resourceConfig.options.pageInjections.list = {};
    }
    if (!resourceConfig.options.pageInjections.list.threeDotsDropdownItems) {
      resourceConfig.options.pageInjections.list.threeDotsDropdownItems = [];
    }
    (resourceConfig.options.pageInjections.list.threeDotsDropdownItems as AdminForthComponentDeclaration[]).push({
      file: this.componentPath('ExportCsv.vue'),
      meta: { pluginInstanceId: this.pluginInstanceId, select: 'all' }
    }, {
      file: this.componentPath('ExportCsv.vue'),
      meta: { pluginInstanceId: this.pluginInstanceId, select: 'filtered' }
    }, {
      file: this.componentPath('ImportCsv.vue'),
      meta: { pluginInstanceId: this.pluginInstanceId }
    });


    // simply modify resourceConfig or adminforth.config. You can get access to plugin options via this.options;
  }
  
  validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
    // optional method where you can safely check field types after database discovery was performed
  }

  instanceUniqueRepresentation(pluginOptions: any) : string {
    // optional method to return unique string representation of plugin instance. 
    // Needed if plugin can have multiple instances on one resource 
    return `${this.pluginInstanceId}`;
  }

  setupEndpoints(server: IHttpServer) {
    server.endpoint({
      method: 'POST',
      path: `/plugin/${this.pluginInstanceId}/export-csv`,
      noAuth: true,
      handler: async ({ body }) => {
        const { filters, sort } = body;

        const data = await this.adminforth.connectors[this.resourceConfig.dataSource].getData({
          resource: this.resourceConfig,
          limit: 1e6,
          offset: 0,
          filters: this.adminforth.connectors[this.resourceConfig.dataSource].validateAndNormalizeInputFilters(filters),
          sort,
          getTotals: true,
        });

        // prepare data for PapaParse unparse
        const columns = this.resourceConfig.columns.filter((col) => !col.virtual);

        const columnsToForceQuote = columns.map(col => {
          return col.type !== AdminForthDataTypes.FLOAT 
            && col.type !== AdminForthDataTypes.INTEGER 
            && col.type !== AdminForthDataTypes.BOOLEAN;
        })

        const fields = columns.map((col) => col.name);

        const rows = data.data.map((row) => {
          return columns.map((col) => row[col.name]);
        });

        return { 
          data: { fields, data: rows }, 
          columnsToForceQuote, 
          exportedCount: data.total, 
          ok: true 
        };
      }
    });

    server.endpoint({
      method: 'POST',
      path: `/plugin/${this.pluginInstanceId}/import-csv`,
      noAuth: true,
      handler: async ({ body }) => {
        const { data } = body;
        const columns = this.getColumnNames(data);
        const { errors, resourceColumns } = this.validateColumns(columns);
        if (errors.length > 0) {
          return { ok: false, errors };
        }
        const primaryKeyColumn = this.resourceConfig.columns.find(col => col.primaryKey);
        const rows = this.buildRowsFromData(data, columns, resourceColumns, { coerceTypes: true });

        console.log('Prepared rows for import:', rows);

        let importedCount = 0;
        let updatedCount = 0;

        await Promise.all(rows.map(async (row) => {
          try {
            if (primaryKeyColumn && row[primaryKeyColumn.name]) {
              const existingRecord = await this.adminforth.resource(this.resourceConfig.resourceId)
                .list([Filters.EQ(primaryKeyColumn.name, row[primaryKeyColumn.name])]);
              
              if (existingRecord.length > 0) {
                await this.adminforth.resource(this.resourceConfig.resourceId)
                  .update(row[primaryKeyColumn.name], row);
                updatedCount++;
                return;
              }
            }
            await this.adminforth.resource(this.resourceConfig.resourceId).create(row);
            importedCount++;
          } catch (e) {
            errors.push(e.message);
          }
        }));

        return { ok: true, importedCount, updatedCount, errors };
      }
    });

    server.endpoint({
      method: 'POST',
      path: `/plugin/${this.pluginInstanceId}/import-csv-new-only`,
      noAuth: true,
      handler: async ({ body }) => {
        const { data } = body;
        const columns = this.getColumnNames(data);
        const { errors, resourceColumns } = this.validateColumns(columns);
        if (errors.length > 0) {
          return { ok: false, errors };
        }

        const primaryKeyColumn = this.resourceConfig.columns.find(col => col.primaryKey);
        const rows = this.buildRowsFromData(data, columns, resourceColumns, { coerceTypes: true });

        let importedCount = 0;

        await Promise.all(rows.map(async (row) => {
          try {
            if (primaryKeyColumn && row[primaryKeyColumn.name]) {
              const existingRecord = await this.adminforth.resource(this.resourceConfig.resourceId)
                .list([Filters.EQ(primaryKeyColumn.name, row[primaryKeyColumn.name])]);
              
              if (existingRecord.length > 0) {
                return;
              }
            }
            await this.adminforth.resource(this.resourceConfig.resourceId).create(row);
            importedCount++;
          } catch (e) {
            errors.push(e.message);
          }
        }));

        return { ok: true, importedCount, errors };
      }
    });

    server.endpoint({
      method: 'POST',
      path: `/plugin/${this.pluginInstanceId}/check-records`,
      noAuth: true,
      handler: async ({ body }) => {
        const { data } = body as { data: Record<string, unknown[]> };
        const primaryKeyColumn = this.resourceConfig.columns.find(col => col.primaryKey);
        const columns = this.getColumnNames(data);
        const rows = this.buildRowsFromData(data, columns, undefined, { coerceTypes: false });

        const primaryKeys = rows
          .map(row => primaryKeyColumn ? row[primaryKeyColumn.name] : undefined)
          .filter(key => key !== undefined && key !== null && key !== '');

        const existingRecords = await this.adminforth
          .resource(this.resourceConfig.resourceId)
          .list([{
            field: primaryKeyColumn.name,
            operator: AdminForthFilterOperators.IN,
            value: primaryKeys,
          }]);

        return {
          ok: true,
          total: rows.length,
          existingCount: existingRecords.length,
          newCount: rows.length - existingRecords.length,
        };

      }
    });
  }

  private getColumnNames(data: Record<string, unknown[]>): string[] {
    return Object.keys(data ?? {});
  }

  private validateColumns(columns: string[]): {
    errors: string[];
    resourceColumns: AdminForthResourceColumn[];
  } {
    const errors: string[] = [];
    const resourceColumns: AdminForthResourceColumn[] = [];

    columns.forEach((col) => {
      const resourceColumn = this.resourceConfig.columns.find((c) => c.name === col);
      if (!resourceColumn) {
        const similar = suggestIfTypo(this.resourceConfig.columns.map((c) => c.name), col);
        errors.push(
          `Column '${col}' defined in CSV not found in resource '${this.resourceConfig.resourceId}'. ${
            similar
              ? `If you mean '${similar}', rename it in CSV`
              : 'If column is in database but not in resource configuration, add it with showIn:[]'
          }`
        );
        return;
      }
      resourceColumns.push(resourceColumn);
    });

    return { errors, resourceColumns };
  }

  private buildRowsFromData(
    data: Record<string, unknown[]>,
    columns: string[],
    resourceColumns?: AdminForthResourceColumn[],
    { coerceTypes }: { coerceTypes: boolean } = { coerceTypes: true }
  ) {
    const columnValues: unknown[][] = Object.values(data ?? {});
    if (columns.length === 0 || columnValues.length === 0) {
      return [];
    }

    const rows: Record<string, unknown>[] = [];
    const rowCount = columnValues[0].length;

    for (let i = 0; i < rowCount; i++) {
      const row: Record<string, unknown> = {};
      for (let j = 0; j < columns.length; j++) {
        const val = columnValues[j][i];
        const resourceCol = resourceColumns ? resourceColumns[j] : undefined;
        row[columns[j]] = coerceTypes
          ? this.coerceValue(resourceCol, val)
          : val;
      }
      rows.push(row);
    }

    return rows;
  }

  private coerceValue(resourceCol: AdminForthResourceColumn | undefined, val: unknown): unknown {
    if (!resourceCol || val === '') {
      return val;
    }

    if (
      (resourceCol.type === AdminForthDataTypes.INTEGER
        || resourceCol.type === AdminForthDataTypes.FLOAT)
    ) {
      return +val;
    }

    if (resourceCol.type === AdminForthDataTypes.BOOLEAN) {
      if (typeof val === 'string') {
        return val.toLowerCase() === 'true' || val === '1';
      }
      return val === 1 || val === true;
    }

    return val;
  }

}