@budibase/server 1.0.49-alpha.9 → 1.0.49

package/src/integrations/googlesheets.ts

@@ -1,353 +0,0 @@
-import {
-  DatasourceFieldTypes,
-  Integration,
-  QueryJson,
-  QueryTypes,
-} from "../definitions/datasource"
-import { OAuth2Client } from "google-auth-library"
-import { DatasourcePlus } from "./base/datasourcePlus"
-import { Row, Table, TableSchema } from "../definitions/common"
-import { buildExternalTableId } from "./utils"
-import { DataSourceOperation, FieldTypes } from "../constants"
-import { GoogleSpreadsheet } from "google-spreadsheet"
-import { table } from "console"
-
-module GoogleSheetsModule {
-  const { getGlobalDB } = require("@budibase/backend-core/tenancy")
-  const { getScopedConfig } = require("@budibase/backend-core/db")
-  const { Configs } = require("@budibase/backend-core/constants")
-
-  interface GoogleSheetsConfig {
-    spreadsheetId: string
-    auth: OAuthClientConfig
-  }
-
-  interface OAuthClientConfig {
-    appId: string
-    accessToken: string
-    refreshToken: string
-  }
-
-  const SCHEMA: Integration = {
-    plus: true,
-    auth: {
-      type: "google",
-    },
-    relationships: false,
-    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,
-      },
-    },
-    query: {
-      create: {
-        type: QueryTypes.FIELDS,
-        fields: {
-          sheet: {
-            type: DatasourceFieldTypes.STRING,
-            required: true,
-          },
-          row: {
-            type: QueryTypes.JSON,
-            required: true,
-          },
-        },
-      },
-      read: {
-        type: QueryTypes.FIELDS,
-        fields: {
-          sheet: {
-            type: DatasourceFieldTypes.STRING,
-            required: true,
-          },
-        },
-      },
-      update: {
-        type: QueryTypes.FIELDS,
-        fields: {
-          sheet: {
-            type: DatasourceFieldTypes.STRING,
-            required: true,
-          },
-          rowIndex: {
-            type: DatasourceFieldTypes.STRING,
-            required: true,
-          },
-          row: {
-            type: QueryTypes.JSON,
-            required: true,
-          },
-        },
-      },
-      delete: {
-        type: QueryTypes.FIELDS,
-        fields: {
-          sheet: {
-            type: DatasourceFieldTypes.STRING,
-            required: true,
-          },
-          rowIndex: {
-            type: DatasourceFieldTypes.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
-      const spreadsheetId = this.cleanSpreadsheetUrl(this.config.spreadsheetId)
-      this.client = new GoogleSpreadsheet(spreadsheetId)
-    }
-
-    /**
-     * Pull the spreadsheet ID out from a valid google sheets URL
-     * @param spreadsheetId - the URL or standard spreadsheetId of the google sheet
-     * @returns spreadsheet Id of the google sheet
-     */
-    cleanSpreadsheetUrl(spreadsheetId: string) {
-      if (!spreadsheetId) {
-        throw new Error(
-          "You must set a spreadsheet ID in your configuration to fetch tables."
-        )
-      }
-      const parts = spreadsheetId.split("/")
-      return parts.length > 5 ? parts[5] : spreadsheetId
-    }
-
-    async connect() {
-      try {
-        // Initialise oAuth client
-        const db = getGlobalDB()
-        const googleConfig = await getScopedConfig(db, {
-          type: Configs.GOOGLE,
-        })
-        const oauthClient = new OAuth2Client({
-          clientId: googleConfig.clientID,
-          clientSecret: googleConfig.clientSecret,
-        })
-        oauthClient.credentials.access_token = this.config.auth.accessToken
-        oauthClient.credentials.refresh_token = this.config.auth.refreshToken
-        this.client.useOAuth2Client(oauthClient)
-        await this.client.loadInfo()
-      } catch (err) {
-        console.error("Error connecting to google sheets", err)
-        throw err
-      }
-    }
-
-    async buildSchema(datasourceId: string) {
-      await this.connect()
-      const sheets = await this.client.sheetsByIndex
-      const tables: Record<string, Table> = {}
-      for (let sheet of sheets) {
-        // must fetch rows to determine schema
-        await sheet.getRows()
-        // build schema
-        const schema: TableSchema = {}
-
-        // 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
-
-      const handlers = {
-        [DataSourceOperation.CREATE]: () =>
-          this.create({ sheet, row: json.body }),
-        [DataSourceOperation.READ]: () => this.read({ sheet }),
-        [DataSourceOperation.UPDATE]: () =>
-          this.update({
-            // exclude the header row and zero index
-            rowIndex: json.extra?.idFilter?.equal?.rowNumber - 2,
-            sheet,
-            row: json.body,
-          }),
-        [DataSourceOperation.DELETE]: () =>
-          this.delete({
-            // exclude the header row and zero index
-            rowIndex: json.extra?.idFilter?.equal?.rowNumber - 2,
-            sheet,
-          }),
-        [DataSourceOperation.CREATE_TABLE]: () =>
-          this.createTable(json?.table?.name),
-        [DataSourceOperation.UPDATE_TABLE]: () => this.updateTable(json.table),
-        [DataSourceOperation.DELETE_TABLE]: () =>
-          this.deleteTable(json?.table?.name),
-      }
-
-      const internalQueryMethod = handlers[json.endpoint.operation]
-
-      return await internalQueryMethod()
-    }
-
-    buildRowObject(headers: string[], values: string[], rowNumber: number) {
-      const rowObject: { rowNumber: number; [key: string]: any } = { rowNumber }
-      for (let i = 0; i < headers.length; i++) {
-        rowObject._id = rowNumber
-        rowObject[headers[i]] = values[i]
-      }
-      return rowObject
-    }
-
-    async createTable(name?: string) {
-      try {
-        await this.connect()
-        const sheet = await this.client.addSheet({ title: name })
-        return sheet
-      } catch (err) {
-        console.error("Error creating new table in google sheets", err)
-        throw err
-      }
-    }
-
-    async updateTable(table?: any) {
-      try {
-        await this.connect()
-        const sheet = await this.client.sheetsByTitle[table.name]
-        await sheet.loadHeaderRow()
-
-        if (table._rename) {
-          const headers = []
-          for (let header of sheet.headerValues) {
-            if (header === table._rename.old) {
-              headers.push(table._rename.updated)
-            } else {
-              headers.push(header)
-            }
-          }
-          await sheet.setHeaderRow(headers)
-        } else {
-          let newField = Object.keys(table.schema).find(
-            key => !sheet.headerValues.includes(key)
-          )
-          await sheet.setHeaderRow([...sheet.headerValues, newField])
-        }
-      } catch (err) {
-        console.error("Error updating table in google sheets", err)
-        throw err
-      }
-    }
-
-    async deleteTable(sheet: any) {
-      try {
-        await this.connect()
-        const sheetToDelete = await this.client.sheetsByTitle[sheet]
-        return await sheetToDelete.delete()
-      } catch (err) {
-        console.error("Error deleting table in google sheets", err)
-        throw err
-      }
-    }
-
-    async create(query: { sheet: string; row: any }) {
-      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: any }) {
-      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 = 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,
-  }
-}

package/src/migrations/functions/appUrls.ts

@@ -1,34 +0,0 @@
-const { DocumentTypes } = require("@budibase/backend-core/db")
-import { getAppUrl } from "../../api/controllers/application"
-
-/**
- * Date:
- * January 2022
- *
- * Description:
- * Add the url to the app metadata if it doesn't exist
- */
-export const run = async (appDb: any) => {
-  let metadata
-  try {
-    metadata = await appDb.get(DocumentTypes.APP_METADATA)
-  } catch (e) {
-    // sometimes the metadata document doesn't exist
-    // exit early instead of failing the migration
-    console.error("Error retrieving app metadata. Skipping", e)
-    return
-  }
-
-  if (!metadata.url) {
-    const context = {
-      request: {
-        body: {
-          name: metadata.name,
-        },
-      },
-    }
-    metadata.url = getAppUrl(context)
-    console.log(`Adding url to app: ${metadata.url}`)
-    await appDb.put(metadata)
-  }
-}

package/src/migrations/functions/quotas1.ts

@@ -1,20 +0,0 @@
-import { runQuotaMigration } from "./usageQuotas"
-import * as syncApps from "./usageQuotas/syncApps"
-import * as syncRows from "./usageQuotas/syncRows"
-
-/**
- * Date:
- * January 2022
- *
- * Description:
- * Synchronise the app and row quotas to the state of the db after it was
- * discovered that the quota resets were still in place and the row quotas
- * weren't being decremented correctly.
- */
-
-export const run = async () => {
-  await runQuotaMigration(async () => {
-    await syncApps.run()
-    await syncRows.run()
-  })
-}

package/src/migrations/functions/tests/appUrls.spec.js

@@ -1,29 +0,0 @@
-const { DocumentTypes } = require("@budibase/backend-core/db")
-const env = require("../../../environment")
-const TestConfig = require("../../../tests/utilities/TestConfiguration")
-
-const migration = require("../appUrls")
-
-describe("run", () => {
-  let config = new TestConfig(false)
-  const CouchDB = config.getCouch()
-
-  beforeEach(async () => {
-    await config.init()
-  })
-
-  afterAll(config.end)  
-
-  it("runs successfully", async () => {
-    const app = await config.createApp("testApp")
-    const appDb = new CouchDB(app.appId)
-    let metadata = await appDb.get(DocumentTypes.APP_METADATA)
-    delete metadata.url
-    await appDb.put(metadata)
-    
-    await migration.run(appDb)
-
-    metadata = await appDb.get(DocumentTypes.APP_METADATA)
-    expect(metadata.url).toEqual("/testapp")
-  })
-})

package/src/migrations/functions/tests/quotas1.spec.js

@@ -1,27 +0,0 @@
-const env = require("../../../environment")
-const TestConfig = require("../../../tests/utilities/TestConfiguration")
-
-const syncApps = jest.fn()
-const syncRows = jest.fn()
-
-jest.mock("../usageQuotas/syncApps", () => ({ run: syncApps }) )
-jest.mock("../usageQuotas/syncRows", () => ({ run: syncRows }) )
-
-const migration = require("../quotas1")
-
-describe("run", () => {
-  let config = new TestConfig(false)
-
-  beforeEach(async () => {
-    await config.init()
-    env._set("USE_QUOTAS", 1)
-  })
-
-  afterAll(config.end)  
-
-  it("runs ", async () => {
-    await migration.run()
-    expect(syncApps).toHaveBeenCalledTimes(1)
-    expect(syncRows).toHaveBeenCalledTimes(1)
-  })
-})

package/src/migrations/functions/tests/userEmailViewCasing.spec.js

@@ -1,25 +0,0 @@
-const TestConfig = require("../../../tests/utilities/TestConfiguration")
-const { getGlobalDB } = require("@budibase/backend-core/tenancy")
-
-// mock email view creation
-const coreDb = require("@budibase/backend-core/db")
-const createUserEmailView = jest.fn()
-coreDb.createUserEmailView = createUserEmailView
-
-const migration = require("../userEmailViewCasing")
-
-describe("run", () => {
-  let config = new TestConfig(false)
-  const globalDb = getGlobalDB()
-
-  beforeEach(async () => {
-    await config.init()
-  })
-
-  afterAll(config.end)  
-
-  it("runs successfully", async () => {
-    await migration.run(globalDb)
-    expect(createUserEmailView).toHaveBeenCalledTimes(1)
-  })
-})

package/src/migrations/functions/usageQuotas/index.ts

@@ -1,8 +0,0 @@
-const { useQuotas } = require("../../../utilities/usageQuota")
-
-export const runQuotaMigration = async (migration: Function) => {
-  if (!useQuotas()) {
-    return
-  }
-  await migration()
-}

package/src/migrations/functions/usageQuotas/syncApps.ts

@@ -1,18 +0,0 @@
-import { getGlobalDB, getTenantId } from "@budibase/backend-core/tenancy"
-import { getAllApps } from "@budibase/backend-core/db"
-import { getUsageQuotaDoc } from "../../../utilities/usageQuota"
-
-export const run = async () => {
-  const db = getGlobalDB()
-  // get app count
-  // @ts-ignore
-  const devApps = await getAllApps({ dev: true })
-  const appCount = devApps ? devApps.length : 0
-
-  // sync app count
-  const tenantId = getTenantId()
-  console.log(`[Tenant: ${tenantId}] Syncing app count: ${appCount}`)
-  const usageDoc = await getUsageQuotaDoc(db)
-  usageDoc.usageQuota.apps = appCount
-  await db.put(usageDoc)
-}

package/src/migrations/functions/usageQuotas/syncRows.ts

@@ -1,22 +0,0 @@
-import { getGlobalDB, getTenantId } from "@budibase/backend-core/tenancy"
-import { getAllApps } from "@budibase/backend-core/db"
-import { getUsageQuotaDoc } from "../../../utilities/usageQuota"
-import { getUniqueRows } from "../../../utilities/usageQuota/rows"
-
-export const run = async () => {
-  const db = getGlobalDB()
-  // get all rows in all apps
-  // @ts-ignore
-  const allApps = await getAllApps({ all: true })
-  // @ts-ignore
-  const appIds = allApps ? allApps.map((app: { appId: any }) => app.appId) : []
-  const rows = await getUniqueRows(appIds)
-  const rowCount = rows ? rows.length : 0
-
-  // sync row count
-  const tenantId = getTenantId()
-  console.log(`[Tenant: ${tenantId}] Syncing row count: ${rowCount}`)
-  const usageDoc = await getUsageQuotaDoc(db)
-  usageDoc.usageQuota.rows = rowCount
-  await db.put(usageDoc)
-}

package/src/migrations/functions/usageQuotas/tests/syncApps.spec.js

@@ -1,37 +0,0 @@
-const { getGlobalDB } = require("@budibase/backend-core/tenancy")
-const TestConfig = require("../../../../tests/utilities/TestConfiguration")
-const { getUsageQuotaDoc, update, Properties } = require("../../../../utilities/usageQuota")
-const syncApps = require("../syncApps")
-const env = require("../../../../environment")
-
-describe("syncApps", () => {
-  let config = new TestConfig(false)
-
-  beforeEach(async () => {
-    await config.init()
-    env._set("USE_QUOTAS", 1)
-  })
-
-  afterAll(config.end)  
-
-  it("runs successfully", async () => {
-    // create the usage quota doc and mock usages
-    const db = getGlobalDB()
-    await getUsageQuotaDoc(db)
-    await update(Properties.APPS, 3)
-
-    let usageDoc = await getUsageQuotaDoc(db)
-    expect(usageDoc.usageQuota.apps).toEqual(3)
-
-    // create an extra app to test the migration
-    await config.createApp("quota-test")
-
-    // migrate
-    await syncApps.run()
-
-    // assert the migration worked 
-    usageDoc = await getUsageQuotaDoc(db)
-    expect(usageDoc.usageQuota.apps).toEqual(2)
-  })
-})
-

package/src/migrations/functions/usageQuotas/tests/syncRows.spec.js

@@ -1,43 +0,0 @@
-const { getGlobalDB } = require("@budibase/backend-core/tenancy")
-const TestConfig = require("../../../../tests/utilities/TestConfiguration")
-const { getUsageQuotaDoc, update, Properties } = require("../../../../utilities/usageQuota")
-const syncRows = require("../syncRows")
-const env = require("../../../../environment")
-
-describe("syncRows", () => {
-  let config = new TestConfig(false)
-
-  beforeEach(async () => {
-    await config.init()
-    env._set("USE_QUOTAS", 1)
-  })
-
-  afterAll(config.end)  
-
-  it("runs successfully", async () => {
-    // create the usage quota doc and mock usages
-    const db = getGlobalDB()
-    await getUsageQuotaDoc(db)
-    await update(Properties.ROW, 300)
-
-    let usageDoc = await getUsageQuotaDoc(db)
-    expect(usageDoc.usageQuota.rows).toEqual(300)
-
-    // app 1
-    await config.createTable()
-    await config.createRow()
-    // app 2
-    await config.createApp("second-app")
-    await config.createTable()
-    await config.createRow()
-    await config.createRow()
-    
-    // migrate
-    await syncRows.run()
-
-    // assert the migration worked 
-    usageDoc = await getUsageQuotaDoc(db)
-    expect(usageDoc.usageQuota.rows).toEqual(3)
-  })
-})
-

package/src/migrations/functions/userEmailViewCasing.ts

@@ -1,13 +0,0 @@
-const { createUserEmailView } = require("@budibase/backend-core/db")
-
-/**
- * Date:
- * October 2021
- *
- * Description:
- * Recreate the user email view to include latest changes i.e. lower casing the email address
- */
-
-export const run = async (db: any) => {
-  await createUserEmailView(db)
-}

package/src/migrations/index.ts

@@ -1,56 +0,0 @@
-import CouchDB from "../db"
-const {
-  MIGRATION_TYPES,
-  runMigrations,
-} = require("@budibase/backend-core/migrations")
-
-// migration functions
-import * as userEmailViewCasing from "./functions/userEmailViewCasing"
-import * as quota1 from "./functions/quotas1"
-import * as appUrls from "./functions/appUrls"
-
-export interface Migration {
-  type: string
-  name: string
-  opts?: object
-  fn: Function
-}
-
-/**
- * e.g.
- * {
- *   tenantIds: ['bb'],
- *   force: {
- *    global: ['quota_1']
- *   }
- * }
- */
-export interface MigrationOptions {
-  tenantIds?: string[]
-  forced?: {
-    [type: string]: string[]
-  }
-}
-
-export const MIGRATIONS: Migration[] = [
-  {
-    type: MIGRATION_TYPES.GLOBAL,
-    name: "user_email_view_casing",
-    fn: userEmailViewCasing.run,
-  },
-  {
-    type: MIGRATION_TYPES.GLOBAL,
-    name: "quotas_1",
-    fn: quota1.run,
-  },
-  {
-    type: MIGRATION_TYPES.APP,
-    name: "app_urls",
-    opts: { all: true },
-    fn: appUrls.run,
-  },
-]
-
-export const migrate = async (options?: MigrationOptions) => {
-  await runMigrations(CouchDB, MIGRATIONS, options)
-}