@budibase/server 1.0.95 → 1.0.98-alpha.0

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

package/src/middleware/currentapp.js

@@ -1,5 +1,5 @@
 const {
-  getAppId,
+  getAppIdFromCtx,
   setCookie,
   getCookie,
   clearCookie,
@@ -17,7 +17,7 @@ const { doInAppContext } = require("@budibase/backend-core/context")
 
 module.exports = async (ctx, next) => {
   // try to get the appID from the request
-  let requestAppId = getAppId(ctx)
+  let requestAppId = await getAppIdFromCtx(ctx)
   // get app cookie if it exists
   let appCookie = null
   try {
@@ -71,21 +71,22 @@ module.exports = async (ctx, next) => {
   }
 
   return doInAppContext(appId, async () => {
-    let noCookieSet = false
+    let skipCookie = false
     // if the user not in the right tenant then make sure they have no permissions
     // need to judge this only based on the request app ID,
     if (
       env.MULTI_TENANCY &&
       ctx.user &&
       requestAppId &&
-      !isUserInAppTenant(requestAppId)
+      !isUserInAppTenant(requestAppId, ctx.user)
     ) {
       // don't error, simply remove the users rights (they are a public user)
       delete ctx.user.builder
       delete ctx.user.admin
       delete ctx.user.roles
+      ctx.isAuthenticated = false
       roleId = BUILTIN_ROLE_IDS.PUBLIC
-      noCookieSet = true
+      skipCookie = true
     }
 
     ctx.appId = appId
@@ -105,7 +106,7 @@ module.exports = async (ctx, next) => {
       (requestAppId !== appId ||
         appCookie == null ||
         appCookie.appId !== requestAppId) &&
-      !noCookieSet
+      !skipCookie
     ) {
       setCookie(ctx, { appId }, Cookies.CurrentApp)
     }

package/src/middleware/publicApi.js

@@ -1,9 +1,9 @@
 const { Headers } = require("@budibase/backend-core/constants")
-const { getAppId } = require("@budibase/backend-core/utils")
+const { getAppIdFromCtx } = require("@budibase/backend-core/utils")
 
 module.exports = function ({ requiresAppId } = {}) {
   return async (ctx, next) => {
-    const appId = getAppId(ctx)
+    const appId = await getAppIdFromCtx(ctx)
     if (requiresAppId && !appId) {
       ctx.throw(
         400,

package/src/middleware/tests/authorized.spec.js

@@ -35,9 +35,7 @@ class TestConfiguration {
   }
 
   executeMiddleware() {
-    return doInAppContext(APP_ID, () => {
-      return this.middleware(this.ctx, this.next)
-    })
+    return this.middleware(this.ctx, this.next)
   }
 
   setUser(user) {

package/src/middleware/tests/currentapp.spec.js

@@ -38,7 +38,7 @@ function mockAuthWithNoCookie() {
     },
   }))
   jest.mock("@budibase/backend-core/utils", () => ({
-    getAppId: jest.fn(),
+    getAppIdFromCtx: jest.fn(),
     setCookie: jest.fn(),
     getCookie: jest.fn(),
   }))
@@ -51,7 +51,7 @@ function mockAuthWithCookie() {
   jest.resetModules()
   mockWorker()
   jest.mock("@budibase/backend-core/utils", () => ({
-    getAppId: () => {
+    getAppIdFromCtx: () => {
       return "app_test"
     },
     setCookie: jest.fn(),
@@ -143,7 +143,7 @@ describe("Current app middleware", () => {
     it("should perform correct when no cookie exists", async () => {
       mockReset()
       jest.mock("@budibase/backend-core/utils", () => ({
-        getAppId: () => {
+        getAppIdFromCtx: () => {
           return "app_test"
         },
         setCookie: jest.fn(),
@@ -158,7 +158,7 @@ describe("Current app middleware", () => {
     it("lastly check what occurs when cookie doesn't need updated", async () => {
       mockReset()
       jest.mock("@budibase/backend-core/utils", () => ({
-        getAppId: () => {
+        getAppIdFromCtx: () => {
           return "app_test"
         },
         setCookie: jest.fn(),

package/src/tests/utilities/TestConfiguration.js

@@ -80,7 +80,7 @@ class TestConfiguration {
       return request.body
     }
     // check if already in a context
-    if (context.getAppId() == null) {
+    if (context.getAppId() == null && this.appId !== null) {
       return context.doInAppContext(this.appId, async () => {
         return run()
       })

package/.eslintrc

@@ -1,13 +0,0 @@
-{
-  "globals": {
-    "emit": true,
-    "key": true
-  },
-  "parser": "@typescript-eslint/parser",
-  "env": {
-    "node": true
-  },
-  "extends": ["eslint:recommended"],
-  "rules": {
-  }
-}