budibase/packages/server/src/integrations/googlesheets.ts

import {
  DatasourceFieldTypes,
  Integration,
  QueryJson,
  QueryTypes,
} from "../definitions/datasource"
import { IntegrationBase } from "./base/IntegrationBase"
import { GoogleSpreadsheet } from "google-spreadsheet"
import { DatasourcePlus } from "./base/datasourcePlus"
import { Table } from "../definitions/common"
import { buildExternalTableId } from "./utils"
import { DataSourceOperation, FieldTypes } from "../constants"

module GoogleSheetsModule {
  interface GoogleSheetsConfig {
    spreadsheetId: string
    clientEmail: string
    privateKey: string
  }

  const SCHEMA: Integration = {
    plus: true,
    docs: "https://developers.google.com/sheets/api/quickstart/nodejs",
    description:
      "Create and collaborate on online spreadsheets in real-time and from any device. ",
    friendlyName: "Google Sheets",
    datasource: {
      spreadsheetId: {
        type: DatasourceFieldTypes.STRING,
        required: true,
      },
      clientEmail: {
        type: DatasourceFieldTypes.STRING,
        required: true,
      },
      privateKey: {
        type: DatasourceFieldTypes.LONGFORM,
        required: true,
      },
    },
    query: {
      create: {
        type: QueryTypes.FIELDS,
        fields: {
          sheet: {
            type: "string",
            required: true,
          },
          row: {
            type: QueryTypes.JSON,
            required: true,
          },
        },
      },
      read: {
        type: QueryTypes.FIELDS,
        fields: {
          sheet: {
            type: "string",
            required: true,
          },
        },
      },
      update: {
        type: QueryTypes.FIELDS,
        fields: {
          sheet: {
            type: "string",
            required: true,
          },
          rowIndex: {
            type: "number",
            required: true,
          },
          row: {
            type: QueryTypes.JSON,
            required: true,
          },
        },
      },
      delete: {
        type: QueryTypes.FIELDS,
        fields: {
          sheet: {
            type: "string",
            required: true,
          },
          rowIndex: {
            type: "number",
            required: true,
          },
        },
      },
    },
  }

  class GoogleSheetsIntegration implements DatasourcePlus {
    private readonly config: GoogleSheetsConfig
    private client: any
    public tables: Record<string, Table> = {}
    public schemaErrors: Record<string, string> = {}

    constructor(config: GoogleSheetsConfig) {
      this.config = config
      this.client = new GoogleSpreadsheet(this.config.spreadsheetId)
    }

    async connect() {
      try {
        await this.client.useServiceAccountAuth({
          // env var values are copied from service account credentials generated by google
          // see "Authentication" section in docs for more info
          client_email: this.config.clientEmail,
          private_key: this.config.privateKey,
        })
        await this.client.loadInfo()
      } catch (err) {
        console.error("Error connecting to google sheets", err)
        throw err
      }
    }

    async buildSchema(datasourceId: string, entities: Record<string, Table>) {
      await this.connect()
      const sheets = await this.client.sheetsByIndex
      const tables = {}
      // tables[tableName] = {
      //   _id: buildExternalTableId(datasourceId, tableName),
      //   primary: primaryKeys,
      //   name: tableName,
      //   schema,
      // }
      for (let sheet of sheets) {
        // must fetch rows to determine schema
        await sheet.getRows()
        // build schema
        const schema = {}

        // build schema from headers
        for (let header of sheet.headerValues) {
          schema[header] = {
            name: header,
            type: FieldTypes.STRING,
          }
        }

        // create tables
        tables[sheet.title] = {
          _id: buildExternalTableId(datasourceId, sheet.title),
          name: sheet.title,
          primary: ["rowNumber"],
          schema,
        }
      }

      this.tables = tables
    }

    async query(json: QueryJson) {
      const sheet = json.endpoint.entityId

      if (json.endpoint.operation === DataSourceOperation.CREATE) {
        return await this.create({
          sheet,
          row: json.body,
        })
      }

      if (json.endpoint.operation === DataSourceOperation.READ) {
        return await this.read({ sheet })
      }

      if (json.endpoint.operation === DataSourceOperation.UPDATE) {
        return await this.update({
          sheet,
          row: json.body,
        })
      }

      if (json.endpoint.operation === DataSourceOperation.DELETE) {
        return await this.delete({})
      }
    }

    buildRowObject(headers: string[], values: string[], rowNumber: number) {
      const rowObject = { rowNumber }
      for (let i = 0; i < headers.length; i++) {
        rowObject[headers[i]] = values[i]
      }
      return rowObject
    }

    async create(query: { sheet: string; row: string | object }) {
      try {
        await this.connect()
        const sheet = await this.client.sheetsByTitle[query.sheet]
        const rowToInsert =
          typeof query.row === "string" ? JSON.parse(query.row) : query.row
        const row = await sheet.addRow(rowToInsert)
        return [
          this.buildRowObject(sheet.headerValues, row._rawData, row._rowNumber),
        ]
      } catch (err) {
        console.error("Error writing to google sheets", err)
        throw err
      }
    }

    async read(query: { sheet: string }) {
      try {
        await this.connect()
        const sheet = await this.client.sheetsByTitle[query.sheet]
        const rows = await sheet.getRows()
        const headerValues = sheet.headerValues
        const response = []
        for (let row of rows) {
          response.push(
            this.buildRowObject(headerValues, row._rawData, row._rowNumber)
          )
        }
        return response
      } catch (err) {
        console.error("Error reading from google sheets", err)
        throw err
      }
    }

    async update(query: { sheet: string; rowIndex: number; row: string }) {
      try {
        await this.connect()
        const sheet = await this.client.sheetsByTitle[query.sheet]
        const rows = await sheet.getRows()
        const row = rows[query.rowIndex]
        if (row) {
          const updateValues = JSON.parse(query.row)
          for (let key in updateValues) {
            row[key] = updateValues[key]
          }
          await row.save()
          return [
            this.buildRowObject(
              sheet.headerValues,
              row._rawData,
              row._rowNumber
            ),
          ]
        } else {
          throw new Error("Row does not exist.")
        }
      } catch (err) {
        console.error("Error reading from google sheets", err)
        throw err
      }
    }

    async delete(query: { sheet: string; rowIndex: number }) {
      await this.connect()
      const sheet = await this.client.sheetsByTitle[query.sheet]
      const rows = await sheet.getRows()
      const row = rows[query.rowIndex]
      if (row) {
        await row.delete()
        return [{ deleted: query.rowIndex }]
      } else {
        throw new Error("Row does not exist.")
      }
    }
  }

  module.exports = {
    schema: SCHEMA,
    integration: GoogleSheetsIntegration,
  }
}