@budibase/server 1.0.19-alpha.0 → 1.0.21

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

@@ -1,239 +0,0 @@
-const { OpenAPI2 } = require("../../openapi2")
-const fs = require("fs")
-const path = require('path')
-
-const getData = (file, extension) => {
-  return fs.readFileSync(path.join(__dirname, `./data/${file}/${file}.${extension}`), "utf8")
-}
-
-describe("OpenAPI2 Import", () => {
-  let openapi2 
-
-  beforeEach(() => {
-    openapi2 = new OpenAPI2()
-  })
-
-  it("validates unsupported data", async () => {
-    let data
-    let supported
-
-    // non json / yaml
-    data = "curl http://example.com"
-    supported = await openapi2.isSupported(data)
-    expect(supported).toBe(false)
-
-    // Empty
-    data = ""
-    supported = await openapi2.isSupported(data)
-    expect(supported).toBe(false)
-  })
-
-  const init = async (file, extension) => {
-    await openapi2.isSupported(getData(file, extension))
-  }
-
-  const runTests = async (filename, test, assertions) => {
-    for (let extension of ["json", "yaml"]) {
-      await test(filename, extension, assertions)
-    }
-  }
-
-  const testImportInfo = async (file, extension) => {
-    await init(file, extension)
-    const info = await openapi2.getInfo()
-    expect(info.url).toBe("https://petstore.swagger.io/v2")
-    expect(info.name).toBe("Swagger Petstore")
-  }
-
-  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 init(file, extension)
-      const queries = await openapi2.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" : "entities",
-        "getEntities" : "entities",
-        "getEntity" : "entities/{{entityId}}",
-        "updateEntity" : "entities/{{entityId}}",
-        "patchEntity" : "entities/{{entityId}}",
-        "deleteEntity" : "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

@@ -1,115 +0,0 @@
-
-const bulkDocs = jest.fn()
-const db = jest.fn(() => {
-  return {
-    bulkDocs
-  }
-})
-jest.mock("../../../../../db", () => db)
-
-const { RestImporter } = require("../index")
-
-const fs = require("fs")
-const path = require('path')
-
-const getData = (file) => {
-  return fs.readFileSync(path.join(__dirname, `../sources/tests/${file}`), "utf8")
-}
-
-// openapi2 (swagger)
-const oapi2CrudJson = getData("openapi2/data/crud/crud.json")
-const oapi2CrudYaml = getData("openapi2/data/crud/crud.json")
-const oapi2PetstoreJson = getData("openapi2/data/petstore/petstore.json")
-const oapi2PetstoreYaml = getData("openapi2/data/petstore/petstore.json")
-
-// curl
-const curl = getData("curl/data/post.txt")
-
-const datasets = {
-  oapi2CrudJson,
-  oapi2CrudYaml,
-  oapi2PetstoreJson,
-  oapi2PetstoreYaml,
-  curl
-}
-
-describe("Rest Importer", () => {
-  let restImporter 
-
-  const init = async (data) => {
-    restImporter = new RestImporter(data)
-    await restImporter.init()
-  }
-
-  const runTest = async (test, assertions) => {
-    for (let [key, data] of Object.entries(datasets)) {
-      await test(key, data, assertions)
-    }
-  }
-
-  const testGetInfo = async (key, data, assertions) => {
-    await init(data)
-    const info = await restImporter.getInfo()
-    expect(info.name).toBe(assertions[key].name)
-    expect(info.url).toBe(assertions[key].url)
-  }
-
-  it("gets info", async () => {
-    const assertions = {
-      "oapi2CrudJson" : {
-        name: "CRUD",
-        url: "http://example.com"
-      },
-      "oapi2CrudYaml" : {
-        name: "CRUD",
-        url: "http://example.com"
-      },
-      "oapi2PetstoreJson" : {
-        name: "Swagger Petstore",
-        url: "https://petstore.swagger.io/v2"
-      },
-      "oapi2PetstoreYaml" :{
-        name: "Swagger Petstore",
-        url: "https://petstore.swagger.io/v2"
-      },
-      "curl": {
-        name: "example.com",
-        url: "http://example.com"
-      }
-    }
-    await runTest(testGetInfo, assertions)
-  })
-
-  const testImportQueries = async (key, data, assertions) => {
-    await init(data)
-    bulkDocs.mockReturnValue([])
-    const importResult = await restImporter.importQueries("appId", "datasourceId")
-    expect(importResult.errorQueries.length).toBe(0)
-    expect(importResult.queries.length).toBe(assertions[key].count)
-    expect(bulkDocs).toHaveBeenCalledTimes(1)
-    jest.clearAllMocks()
-  }
-
-  it("imports queries", async () => {
-    // simple sanity assertions that the whole dataset 
-    // makes it through the importer
-    const assertions = {
-      "oapi2CrudJson" : {
-        count: 6,
-      },
-      "oapi2CrudYaml" :{
-        count: 6,
-      },
-      "oapi2PetstoreJson" : {
-        count: 20,
-      },
-      "oapi2PetstoreYaml" :{
-        count: 20,
-      },
-      "curl": {
-        count: 1
-      }
-    }
-    await runTest(testImportQueries, assertions)
-  })
-})

package/src/api/controllers/query/validation.js

@@ -1,40 +0,0 @@
-const joiValidator = require("../../../middleware/joi-validator")
-const Joi = require("joi")
-
-exports.queryValidation = () => {
-  return Joi.object({
-    _id: Joi.string(),
-    _rev: Joi.string(),
-    name: Joi.string().required(),
-    fields: Joi.object().required(),
-    datasourceId: Joi.string().required(),
-    readable: Joi.boolean(),
-    parameters: Joi.array().items(
-      Joi.object({
-        name: Joi.string(),
-        default: Joi.string().allow(""),
-      })
-    ),
-    queryVerb: Joi.string().allow().required(),
-    extra: Joi.object().optional(),
-    schema: Joi.object({}).required().unknown(true),
-    transformer: Joi.string().optional(),
-  })
-}
-
-exports.generateQueryValidation = () => {
-  // prettier-ignore
-  return joiValidator.body(exports.queryValidation())
-}
-
-exports.generateQueryPreviewValidation = () => {
-  // prettier-ignore
-  return joiValidator.body(Joi.object({
-    fields: Joi.object().required(),
-    queryVerb: Joi.string().allow().required(),
-    extra: Joi.object().optional(),
-    datasourceId: Joi.string().required(),
-    transformer: Joi.string().optional(),
-    parameters: Joi.object({}).required().unknown(true)
-  }))
-}