@budibase/server 1.0.91-alpha.6 → 1.0.93

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

@@ -1,240 +0,0 @@
-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/integrations/firebase.ts

@@ -1,205 +0,0 @@
-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,
-  }
-}