@budibase/server 1.0.100 → 1.0.103

package/src/environment.js

@@ -46,6 +46,8 @@ module.exports = {
   MULTI_TENANCY: process.env.MULTI_TENANCY,
   HTTP_MIGRATIONS: process.env.HTTP_MIGRATIONS,
   API_REQ_LIMIT_PER_SEC: process.env.API_REQ_LIMIT_PER_SEC,
+  GOOGLE_CLIENT_ID: process.env.GOOGLE_CLIENT_ID,
+  GOOGLE_CLIENT_SECRET: process.env.GOOGLE_CLIENT_SECRET,
   // environment
   NODE_ENV: process.env.NODE_ENV,
   JEST_WORKER_ID: process.env.JEST_WORKER_ID,

package/src/integrations/base/sql.ts

@@ -31,11 +31,8 @@ function parse(input: any) {
   if (typeof input !== "string") {
     return input
   }
-  if (input === MAX_ISO_DATE) {
-    return new Date(8640000000000000)
-  }
-  if (input === MIN_ISO_DATE) {
-    return new Date(-8640000000000000)
+  if (input === MAX_ISO_DATE || input === MIN_ISO_DATE) {
+    return null
   }
   if (isIsoDateString(input)) {
     return new Date(input)
@@ -134,11 +131,19 @@ class InternalBuilder {
     }
     if (filters.range) {
       iterate(filters.range, (key, value) => {
-        if (!value.high || !value.low) {
-          return
+        if (value.low && value.high) {
+          // Use a between operator if we have 2 valid range values
+          const fnc = allOr ? "orWhereBetween" : "whereBetween"
+          query = query[fnc](key, [value.low, value.high])
+        } else if (value.low) {
+          // Use just a single greater than operator if we only have a low
+          const fnc = allOr ? "orWhere" : "where"
+          query = query[fnc](key, ">", value.low)
+        } else if (value.high) {
+          // Use just a single less than operator if we only have a high
+          const fnc = allOr ? "orWhere" : "where"
+          query = query[fnc](key, "<", value.high)
         }
-        const fnc = allOr ? "orWhereBetween" : "whereBetween"
-        query = query[fnc](key, [value.low, value.high])
       })
     }
     if (filters.equal) {

package/src/integrations/dynamodb.ts

@@ -131,7 +131,9 @@ module DynamoModule {
 
     constructor(config: DynamoDBConfig) {
       this.config = config
-      this.connect()
+      if (!this.config.endpoint) {
+        this.connect()
+      }
       let options = {
         correctClockSkew: true,
         endpoint: config.endpoint ? config.endpoint : undefined,

package/src/integrations/firebase.ts

@@ -0,0 +1,205 @@
+import {
+  DatasourceFieldTypes,
+  Integration,
+  QueryTypes,
+} from "../definitions/datasource"
+import { IntegrationBase } from "./base/IntegrationBase"
+import { Firestore, WhereFilterOp } from "@google-cloud/firestore"
+
+module Firebase {
+  interface FirebaseConfig {
+    email: string
+    privateKey: string
+    projectId: string
+    serviceAccount?: string
+  }
+
+  const SCHEMA: Integration = {
+    docs: "https://firebase.google.com/docs/firestore/quickstart",
+    friendlyName: "Firestore",
+    description:
+      "Cloud Firestore is a flexible, scalable database for mobile, web, and server development from Firebase and Google Cloud.",
+    datasource: {
+      email: {
+        type: DatasourceFieldTypes.STRING,
+        required: true,
+      },
+      privateKey: {
+        type: DatasourceFieldTypes.STRING,
+        required: true,
+      },
+      projectId: {
+        type: DatasourceFieldTypes.STRING,
+        required: true,
+      },
+      serviceAccount: {
+        type: DatasourceFieldTypes.JSON,
+        required: false,
+      },
+    },
+    query: {
+      create: {
+        type: QueryTypes.JSON,
+      },
+      read: {
+        type: QueryTypes.JSON,
+      },
+      update: {
+        type: QueryTypes.JSON,
+      },
+      delete: {
+        type: QueryTypes.JSON,
+      },
+    },
+    extra: {
+      collection: {
+        displayName: "Collection",
+        type: DatasourceFieldTypes.STRING,
+        required: true,
+      },
+      filterField: {
+        displayName: "Filter field",
+        type: DatasourceFieldTypes.STRING,
+        required: false,
+      },
+      filter: {
+        displayName: "Filter comparison",
+        type: DatasourceFieldTypes.LIST,
+        required: false,
+        data: {
+          read: [
+            "==",
+            "<",
+            "<=",
+            "==",
+            "!=",
+            ">=",
+            ">",
+            "array-contains",
+            "in",
+            "not-in",
+            "array-contains-any",
+          ],
+        },
+      },
+      filterValue: {
+        displayName: "Filter value",
+        type: DatasourceFieldTypes.STRING,
+        required: false,
+      },
+    },
+  }
+
+  class FirebaseIntegration implements IntegrationBase {
+    private config: FirebaseConfig
+    private db: Firestore
+
+    constructor(config: FirebaseConfig) {
+      this.config = config
+      if (config.serviceAccount) {
+        const serviceAccount = JSON.parse(config.serviceAccount)
+        this.db = new Firestore({
+          projectId: serviceAccount.project_id,
+          credentials: {
+            client_email: serviceAccount.client_email,
+            private_key: serviceAccount.private_key,
+          },
+        })
+      } else {
+        this.db = new Firestore({
+          projectId: config.projectId,
+          credentials: {
+            client_email: config.email,
+            private_key: config.privateKey,
+          },
+        })
+      }
+    }
+
+    async create(query: { json: object; extra: { [key: string]: string } }) {
+      try {
+        const documentReference = this.db
+          .collection(query.extra.collection)
+          .doc()
+        await documentReference.set({ ...query.json, id: documentReference.id })
+        const snapshot = await documentReference.get()
+        return snapshot.data()
+      } catch (err) {
+        console.error("Error writing to Firestore", err)
+        throw err
+      }
+    }
+
+    async read(query: { json: object; extra: { [key: string]: string } }) {
+      try {
+        let snapshot
+        const collectionRef = this.db.collection(query.extra.collection)
+        if (
+          query.extra.filterField &&
+          query.extra.filter &&
+          query.extra.filterValue
+        ) {
+          snapshot = await collectionRef
+            .where(
+              query.extra.filterField,
+              query.extra.filter as WhereFilterOp,
+              query.extra.filterValue
+            )
+            .get()
+        } else {
+          snapshot = await collectionRef.get()
+        }
+        const result: any[] = []
+        snapshot.forEach(doc => result.push(doc.data()))
+
+        return result
+      } catch (err) {
+        console.error("Error querying Firestore", err)
+        throw err
+      }
+    }
+
+    async update(query: {
+      json: Record<string, any>
+      extra: { [key: string]: string }
+    }) {
+      try {
+        await this.db
+          .collection(query.extra.collection)
+          .doc(query.json.id)
+          .update(query.json)
+
+        return (
+          await this.db
+            .collection(query.extra.collection)
+            .doc(query.json.id)
+            .get()
+        ).data()
+      } catch (err) {
+        console.error("Error writing to firebase", err)
+        throw err
+      }
+    }
+
+    async delete(query: {
+      json: { id: string }
+      extra: { [key: string]: string }
+    }) {
+      try {
+        await this.db
+          .collection(query.extra.collection)
+          .doc(query.json.id)
+          .delete()
+        return true
+      } catch (err) {
+        console.error("Error writing to mongodb", err)
+        throw err
+      }
+    }
+  }
+
+  module.exports = {
+    schema: SCHEMA,
+    integration: FirebaseIntegration,
+  }
+}

package/src/integrations/googlesheets.ts

@@ -10,6 +10,7 @@ import { Table, TableSchema } from "../definitions/common"
 import { buildExternalTableId } from "./utils"
 import { DataSourceOperation, FieldTypes } from "../constants"
 import { GoogleSpreadsheet } from "google-spreadsheet"
+import env from "../environment"
 
 module GoogleSheetsModule {
   const { getGlobalDB } = require("@budibase/backend-core/tenancy")
@@ -138,13 +139,27 @@ module GoogleSheetsModule {
       try {
         // Initialise oAuth client
         const db = getGlobalDB()
-        const googleConfig = await getScopedConfig(db, {
+        let googleConfig = await getScopedConfig(db, {
           type: Configs.GOOGLE,
         })
+
+        if (!googleConfig) {
+          googleConfig = {
+            clientID: env.GOOGLE_CLIENT_ID,
+            clientSecret: env.GOOGLE_CLIENT_SECRET,
+          }
+        }
+
         const oauthClient = new OAuth2Client({
           clientId: googleConfig.clientID,
           clientSecret: googleConfig.clientSecret,
         })
+        oauthClient.on("tokens", tokens => {
+          oauthClient.setCredentials({
+            refresh_token: googleConfig.refreshToken,
+            access_token: tokens.access_token,
+          })
+        })
         oauthClient.credentials.access_token = this.config.auth.accessToken
         oauthClient.credentials.refresh_token = this.config.auth.refreshToken
         this.client.useOAuth2Client(oauthClient)

package/src/integrations/index.ts

@@ -10,6 +10,7 @@ const mysql = require("./mysql")
 const arangodb = require("./arangodb")
 const rest = require("./rest")
 const googlesheets = require("./googlesheets")
+const firebase = require("./firebase")
 const { SourceNames } = require("../definitions/datasource")
 const environment = require("../environment")
 
@@ -39,6 +40,8 @@ const INTEGRATIONS = {
   [SourceNames.MYSQL]: mysql.integration,
   [SourceNames.ARANGODB]: arangodb.integration,
   [SourceNames.REST]: rest.integration,
+  [SourceNames.FIREBASE]: firebase.integration,
+  [SourceNames.GOOGLE_SHEETS]: googlesheets.integration,
 }
 
 // optionally add oracle integration if the oracle binary can be installed
@@ -50,7 +53,6 @@ if (!(process.arch === "arm64" && process.platform === "darwin")) {
 
 if (environment.SELF_HOSTED) {
   DEFINITIONS[SourceNames.GOOGLE_SHEETS] = googlesheets.schema
-  INTEGRATIONS[SourceNames.GOOGLE_SHEETS] = googlesheets.integration
 }
 
 module.exports = {

package/src/integrations/rest.ts

@@ -11,6 +11,7 @@ import {
   PaginationValues,
 } from "../definitions/datasource"
 import { IntegrationBase } from "./base/IntegrationBase"
+import { get } from "lodash"
 
 const BodyTypes = {
   NONE: "none",
@@ -163,7 +164,7 @@ module RestModule {
       // Check if a pagination cursor exists in the response
       let nextCursor = null
       if (pagination?.responseParam) {
-        nextCursor = data?.[pagination.responseParam]
+        nextCursor = get(data, pagination.responseParam)
       }
 
       return {

package/src/integrations/tests/sql.spec.js

@@ -187,4 +187,55 @@ describe("SQL query builder", () => {
       sql: `select * from (select * from \`${TABLE_NAME}\` limit ?) as \`${TABLE_NAME}\``
     })
   })
+
+  it("should use greater than when only low range specified", () => {
+    const date = new Date()
+    const query = sql._query(generateReadJson({
+      filters: {
+        range: {
+          property: {
+            low: date,
+          }
+        }
+      }
+    }))
+    expect(query).toEqual({
+      bindings: [date, limit],
+      sql: `select * from (select * from "${TABLE_NAME}" where "${TABLE_NAME}"."property" > $1 limit $2) as "${TABLE_NAME}"`
+    })
+  })
+
+  it("should use less than when only high range specified", () => {
+    const date = new Date()
+    const query = sql._query(generateReadJson({
+      filters: {
+        range: {
+          property: {
+            high: date,
+          }
+        }
+      }
+    }))
+    expect(query).toEqual({
+      bindings: [date, limit],
+      sql: `select * from (select * from "${TABLE_NAME}" where "${TABLE_NAME}"."property" < $1 limit $2) as "${TABLE_NAME}"`
+    })
+  })
+
+  it("should use greater than when only low range specified", () => {
+    const date = new Date()
+    const query = sql._query(generateReadJson({
+      filters: {
+        range: {
+          property: {
+            low: date,
+          }
+        }
+      }
+    }))
+    expect(query).toEqual({
+      bindings: [date, limit],
+      sql: `select * from (select * from "${TABLE_NAME}" where "${TABLE_NAME}"."property" > $1 limit $2) as "${TABLE_NAME}"`
+    })
+  })
 })