@budibase/server 1.0.91-alpha.0 → 1.0.91-alpha.3

package/src/api/controllers/query/import/sources/tests/openapi3/openapi3.spec.js

@@ -0,0 +1,240 @@
+const fs = require("fs")
+const path = require("path")
+
+const { OpenAPI3 } = require("../../openapi3")
+
+const getData = (file, extension) => {
+  return fs.readFileSync(
+    path.join(__dirname, `./data/${file}/${file}.${extension}`),
+    "utf8"
+  )
+}
+
+describe("OpenAPI3 Import", () => {
+  let openapi3
+
+  beforeEach(() => {
+    openapi3 = new OpenAPI3()
+  })
+
+  it("validates unsupported data", async () => {
+    let data
+    let supported
+
+    // non json / yaml
+    data = "curl http://example.com"
+    supported = await openapi3.isSupported(data)
+    expect(supported).toBe(false)
+
+    // Empty
+    data = ""
+    supported = await openapi3.isSupported(data)
+    expect(supported).toBe(false)
+  })
+
+  const runTests = async (filename, test, assertions) => {
+    for (let extension of ["json", "yaml"]) {
+      await test(filename, extension, assertions)
+    }
+  }
+
+  const testImportInfo = async (file, extension) => {
+    await openapi3.isSupported(getData(file, extension))
+    const info = await openapi3.getInfo()
+    expect(info.name).toBe("Swagger Petstore - OpenAPI 3.0")
+  }
+
+  it("returns import info", async () => {
+    await runTests("petstore", testImportInfo)
+  })
+
+  describe("Returns queries", () => {
+    const indexQueries = queries => {
+      return queries.reduce((acc, query) => {
+        acc[query.name] = query
+        return acc
+      }, {})
+    }
+
+    const getQueries = async (file, extension) => {
+      await openapi3.isSupported(getData(file, extension))
+      const queries = await openapi3.getQueries()
+      expect(queries.length).toBe(6)
+      return indexQueries(queries)
+    }
+
+    const testVerb = async (file, extension, assertions) => {
+      const queries = await getQueries(file, extension)
+      for (let [operationId, method] of Object.entries(assertions)) {
+        expect(queries[operationId].queryVerb).toBe(method)
+      }
+    }
+
+    it("populates verb", async () => {
+      const assertions = {
+        createEntity: "create",
+        getEntities: "read",
+        getEntity: "read",
+        updateEntity: "update",
+        patchEntity: "patch",
+        deleteEntity: "delete",
+      }
+      await runTests("crud", testVerb, assertions)
+    })
+
+    const testPath = async (file, extension, assertions) => {
+      const queries = await getQueries(file, extension)
+      for (let [operationId, urlPath] of Object.entries(assertions)) {
+        expect(queries[operationId].fields.path).toBe(urlPath)
+      }
+    }
+
+    it("populates path", async () => {
+      const assertions = {
+        createEntity: "http://example.com/entities",
+        getEntities: "http://example.com/entities",
+        getEntity: "http://example.com/entities/{{entityId}}",
+        updateEntity: "http://example.com/entities/{{entityId}}",
+        patchEntity: "http://example.com/entities/{{entityId}}",
+        deleteEntity: "http://example.com/entities/{{entityId}}",
+      }
+      await runTests("crud", testPath, assertions)
+    })
+
+    const testHeaders = async (file, extension, assertions) => {
+      const queries = await getQueries(file, extension)
+      for (let [operationId, headers] of Object.entries(assertions)) {
+        expect(queries[operationId].fields.headers).toStrictEqual(headers)
+      }
+    }
+
+    const contentTypeHeader = {
+      "Content-Type": "application/json",
+    }
+
+    it("populates headers", async () => {
+      const assertions = {
+        createEntity: {
+          ...contentTypeHeader,
+        },
+        getEntities: {},
+        getEntity: {},
+        updateEntity: {
+          ...contentTypeHeader,
+        },
+        patchEntity: {
+          ...contentTypeHeader,
+        },
+        deleteEntity: {
+          "x-api-key": "{{x-api-key}}",
+        },
+      }
+
+      await runTests("crud", testHeaders, assertions)
+    })
+
+    const testQuery = async (file, extension, assertions) => {
+      const queries = await getQueries(file, extension)
+      for (let [operationId, queryString] of Object.entries(assertions)) {
+        expect(queries[operationId].fields.queryString).toStrictEqual(
+          queryString
+        )
+      }
+    }
+
+    it("populates query", async () => {
+      const assertions = {
+        createEntity: "",
+        getEntities: "page={{page}}&size={{size}}",
+        getEntity: "",
+        updateEntity: "",
+        patchEntity: "",
+        deleteEntity: "",
+      }
+      await runTests("crud", testQuery, assertions)
+    })
+
+    const testParameters = async (file, extension, assertions) => {
+      const queries = await getQueries(file, extension)
+      for (let [operationId, parameters] of Object.entries(assertions)) {
+        expect(queries[operationId].parameters).toStrictEqual(parameters)
+      }
+    }
+
+    it("populates parameters", async () => {
+      const assertions = {
+        createEntity: [],
+        getEntities: [
+          {
+            name: "page",
+            default: "",
+          },
+          {
+            name: "size",
+            default: "",
+          },
+        ],
+        getEntity: [
+          {
+            name: "entityId",
+            default: "",
+          },
+        ],
+        updateEntity: [
+          {
+            name: "entityId",
+            default: "",
+          },
+        ],
+        patchEntity: [
+          {
+            name: "entityId",
+            default: "",
+          },
+        ],
+        deleteEntity: [
+          {
+            name: "entityId",
+            default: "",
+          },
+          {
+            name: "x-api-key",
+            default: "",
+          },
+        ],
+      }
+      await runTests("crud", testParameters, assertions)
+    })
+
+    const testBody = async (file, extension, assertions) => {
+      const queries = await getQueries(file, extension)
+      for (let [operationId, body] of Object.entries(assertions)) {
+        expect(queries[operationId].fields.requestBody).toStrictEqual(
+          JSON.stringify(body, null, 2)
+        )
+      }
+    }
+    it("populates body", async () => {
+      const assertions = {
+        createEntity: {
+          name: "name",
+          type: "type",
+        },
+        getEntities: undefined,
+        getEntity: undefined,
+        updateEntity: {
+          id: 1,
+          name: "name",
+          type: "type",
+        },
+        patchEntity: {
+          id: 1,
+          name: "name",
+          type: "type",
+        },
+        deleteEntity: undefined,
+      }
+      await runTests("crud", testBody, assertions)
+    })
+  })
+})

package/src/api/controllers/query/import/tests/index.spec.js

@@ -23,14 +23,27 @@ const oapi2CrudYaml = getData("openapi2/data/crud/crud.json")
 const oapi2PetstoreJson = getData("openapi2/data/petstore/petstore.json")
 const oapi2PetstoreYaml = getData("openapi2/data/petstore/petstore.json")
 
+// openapi3 
+const oapi3CrudJson = getData("openapi3/data/crud/crud.json")
+const oapi3CrudYaml = getData("openapi3/data/crud/crud.json")
+const oapi3PetstoreJson = getData("openapi3/data/petstore/petstore.json")
+const oapi3PetstoreYaml = getData("openapi3/data/petstore/petstore.json")
+
 // curl
 const curl = getData("curl/data/post.txt")
 
 const datasets = {
+  // openapi2 (swagger)
   oapi2CrudJson,
   oapi2CrudYaml,
   oapi2PetstoreJson,
   oapi2PetstoreYaml,
+  // openapi3
+  oapi3CrudJson,
+  oapi3CrudYaml,
+  oapi3PetstoreJson,
+  oapi3PetstoreYaml,
+  // curl
   curl
 }
 
@@ -56,6 +69,7 @@ describe("Rest Importer", () => {
 
   it("gets info", async () => {
     const assertions = {
+      // openapi2 (swagger)
       "oapi2CrudJson" : {
         name: "CRUD",
       },
@@ -68,6 +82,20 @@ describe("Rest Importer", () => {
       "oapi2PetstoreYaml" :{
         name: "Swagger Petstore",
       },
+      // openapi3
+      "oapi3CrudJson" : {
+        name: "CRUD",
+      },
+      "oapi3CrudYaml" : {
+        name: "CRUD",
+      },
+      "oapi3PetstoreJson" : {
+        name: "Swagger Petstore - OpenAPI 3.0",
+      },
+      "oapi3PetstoreYaml" :{
+        name: "Swagger Petstore - OpenAPI 3.0",
+      },
+      // curl
       "curl": {
         name: "example.com",
       }
@@ -89,6 +117,7 @@ describe("Rest Importer", () => {
     // simple sanity assertions that the whole dataset 
     // makes it through the importer
     const assertions = {
+      // openapi2 (swagger)
       "oapi2CrudJson" : {
         count: 6,
       },
@@ -101,6 +130,20 @@ describe("Rest Importer", () => {
       "oapi2PetstoreYaml" :{
         count: 20,
       },
+      // openapi3
+      "oapi3CrudJson" : {
+        count: 6,
+      },
+      "oapi3CrudYaml" :{
+        count: 6,
+      },
+      "oapi3PetstoreJson" : {
+        count: 19,
+      },
+      "oapi3PetstoreYaml" :{
+        count: 19,
+      },
+      // curl
       "curl": {
         count: 1
       }

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/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