@budibase/server 1.0.91-alpha.2 → 1.0.91-alpha.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/server",
   "email": "hi@budibase.com",
-  "version": "1.0.91-alpha.2",
+  "version": "1.0.91-alpha.5",
   "description": "Budibase Web Server",
   "main": "src/index.ts",
   "repository": {
@@ -71,12 +71,13 @@
   "license": "GPL-3.0",
   "dependencies": {
     "@apidevtools/swagger-parser": "^10.0.3",
-    "@budibase/backend-core": "^1.0.91-alpha.2",
-    "@budibase/client": "^1.0.91-alpha.2",
-    "@budibase/string-templates": "^1.0.91-alpha.2",
+    "@budibase/backend-core": "^1.0.91-alpha.5",
+    "@budibase/client": "^1.0.91-alpha.5",
+    "@budibase/string-templates": "^1.0.91-alpha.5",
     "@bull-board/api": "^3.7.0",
     "@bull-board/koa": "^3.7.0",
     "@elastic/elasticsearch": "7.10.0",
+    "@google-cloud/firestore": "^5.0.2",
     "@koa/router": "8.0.0",
     "@sendgrid/mail": "7.1.1",
     "@sentry/node": "^6.0.0",
@@ -175,5 +176,5 @@
   "optionalDependencies": {
     "oracledb": "^5.3.0"
   },
-  "gitHead": "b25cacf6b86fe7551b3eb63707e2505d78394783"
+  "gitHead": "0ef164c14981ac1fc025372c79c0e365a7d7eb99"
 }

package/src/api/controllers/row/internal.js

@@ -85,7 +85,11 @@ exports.patch = async ctx => {
   const isUserTable = tableId === InternalTables.USER_METADATA
   let oldRow
   try {
-    oldRow = await db.get(inputs._id)
+    let dbTable = await db.get(tableId)
+    oldRow = await outputProcessing(
+      dbTable,
+      await findRow(ctx, tableId, inputs._id)
+    )
   } catch (err) {
     if (isUserTable) {
       // don't include the rev, it'll be the global rev

package/src/definitions/datasource.ts

@@ -48,6 +48,7 @@ export enum SourceNames {
   REST = "REST",
   ORACLE = "ORACLE",
   GOOGLE_SHEETS = "GOOGLE_SHEETS",
+  FIREBASE = "FIREBASE",
 }
 
 export enum IncludeRelationships {

package/src/integrations/base/sql.ts

@@ -27,11 +27,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)
@@ -130,11 +127,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/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/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")
 
@@ -25,6 +26,7 @@ const DEFINITIONS = {
   [SourceNames.MYSQL]: mysql.schema,
   [SourceNames.ARANGODB]: arangodb.schema,
   [SourceNames.REST]: rest.schema,
+  [SourceNames.FIREBASE]: firebase.schema,
 }
 
 const INTEGRATIONS = {
@@ -39,6 +41,7 @@ const INTEGRATIONS = {
   [SourceNames.MYSQL]: mysql.integration,
   [SourceNames.ARANGODB]: arangodb.integration,
   [SourceNames.REST]: rest.integration,
+  [SourceNames.FIREBASE]: firebase.integration,
 }
 
 // optionally add oracle integration if the oracle binary can be installed

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}"`
+    })
+  })
 })