@budibase/server 1.0.99 → 1.0.102

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/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/api/routes/analytics.js

@@ -4,7 +4,7 @@ const controller = require("../controllers/analytics")
 const router = Router()
 
 router
-  .get("/api/analytics", controller.isEnabled)
-  .post("/api/analytics/ping", controller.endUserPing)
+  .get("/api/bbtel", controller.isEnabled)
+  .post("/api/bbtel/ping", controller.endUserPing)
 
 module.exports = router

package/src/api/routes/tests/misc.spec.js

@@ -11,10 +11,10 @@ describe("run misc tests", () => {
     await config.init()
   })
 
-  describe("/analytics", () => {
+  describe("/bbtel", () => {
       it("check if analytics enabled", async () => {
         const res = await request
-          .get(`/api/analytics`)
+          .get(`/api/bbtel`)
           .set(config.defaultHeaders())
           .expect("Content-Type", /json/)
           .expect(200)

package/src/automations/utils.js

@@ -17,10 +17,14 @@ const Runner = new Thread(ThreadType.AUTOMATION)
 exports.processEvent = async job => {
   try {
     // need to actually await these so that an error can be captured properly
+    console.log(
+      `${job.data.automation.appId} automation ${job.data.automation._id} running`
+    )
     return await Runner.run(job)
   } catch (err) {
+    const errJson = JSON.stringify(err)
     console.error(
-      `${job.data.automation.appId} automation ${job.data.automation._id} was unable to run - ${err}`
+      `${job.data.automation.appId} automation ${job.data.automation._id} was unable to run - ${errJson}`
     )
     console.trace(err)
     return { err }

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 {
@@ -181,11 +182,7 @@ export interface QueryJson {
 
 export interface SqlQuery {
   sql: string
-  bindings?:
-    | string[]
-    | {
-        [key: string]: any
-      }
+  bindings?: string[]
 }
 
 export interface QueryOptions {