@budibase/server 1.0.91-alpha.3 → 1.0.91

package/dist/integrations/firebase.js

@@ -1,192 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const datasource_1 = require("../definitions/datasource");
-const firestore_1 = require("@google-cloud/firestore");
-var Firebase;
-(function (Firebase) {
-    const SCHEMA = {
-        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: datasource_1.DatasourceFieldTypes.STRING,
-                required: true,
-            },
-            privateKey: {
-                type: datasource_1.DatasourceFieldTypes.STRING,
-                required: true,
-            },
-            projectId: {
-                type: datasource_1.DatasourceFieldTypes.STRING,
-                required: true,
-            },
-            serviceAccount: {
-                type: datasource_1.DatasourceFieldTypes.JSON,
-                required: false,
-            },
-        },
-        query: {
-            create: {
-                type: datasource_1.QueryTypes.JSON,
-            },
-            read: {
-                type: datasource_1.QueryTypes.JSON,
-            },
-            update: {
-                type: datasource_1.QueryTypes.JSON,
-            },
-            delete: {
-                type: datasource_1.QueryTypes.JSON,
-            },
-        },
-        extra: {
-            collection: {
-                displayName: "Collection",
-                type: datasource_1.DatasourceFieldTypes.STRING,
-                required: true,
-            },
-            filterField: {
-                displayName: "Filter field",
-                type: datasource_1.DatasourceFieldTypes.STRING,
-                required: false,
-            },
-            filter: {
-                displayName: "Filter comparison",
-                type: datasource_1.DatasourceFieldTypes.LIST,
-                required: false,
-                data: {
-                    read: [
-                        "==",
-                        "<",
-                        "<=",
-                        "==",
-                        "!=",
-                        ">=",
-                        ">",
-                        "array-contains",
-                        "in",
-                        "not-in",
-                        "array-contains-any",
-                    ],
-                },
-            },
-            filterValue: {
-                displayName: "Filter value",
-                type: datasource_1.DatasourceFieldTypes.STRING,
-                required: false,
-            },
-        },
-    };
-    class FirebaseIntegration {
-        constructor(config) {
-            this.config = config;
-            if (config.serviceAccount) {
-                const serviceAccount = JSON.parse(config.serviceAccount);
-                this.db = new firestore_1.Firestore({
-                    projectId: serviceAccount.project_id,
-                    credentials: {
-                        client_email: serviceAccount.client_email,
-                        private_key: serviceAccount.private_key,
-                    },
-                });
-            }
-            else {
-                this.db = new firestore_1.Firestore({
-                    projectId: config.projectId,
-                    credentials: {
-                        client_email: config.email,
-                        private_key: config.privateKey,
-                    },
-                });
-            }
-        }
-        create(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const documentReference = this.db
-                        .collection(query.extra.collection)
-                        .doc();
-                    yield documentReference.set(Object.assign(Object.assign({}, query.json), { id: documentReference.id }));
-                    const snapshot = yield documentReference.get();
-                    return snapshot.data();
-                }
-                catch (err) {
-                    console.error("Error writing to Firestore", err);
-                    throw err;
-                }
-            });
-        }
-        read(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    let snapshot;
-                    const collectionRef = this.db.collection(query.extra.collection);
-                    if (query.extra.filterField &&
-                        query.extra.filter &&
-                        query.extra.filterValue) {
-                        snapshot = yield collectionRef
-                            .where(query.extra.filterField, query.extra.filter, query.extra.filterValue)
-                            .get();
-                    }
-                    else {
-                        snapshot = yield collectionRef.get();
-                    }
-                    const result = [];
-                    snapshot.forEach(doc => result.push(doc.data()));
-                    return result;
-                }
-                catch (err) {
-                    console.error("Error querying Firestore", err);
-                    throw err;
-                }
-            });
-        }
-        update(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield this.db
-                        .collection(query.extra.collection)
-                        .doc(query.json.id)
-                        .update(query.json);
-                    return (yield this.db
-                        .collection(query.extra.collection)
-                        .doc(query.json.id)
-                        .get()).data();
-                }
-                catch (err) {
-                    console.error("Error writing to firebase", err);
-                    throw err;
-                }
-            });
-        }
-        delete(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield 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,
-    };
-})(Firebase || (Firebase = {}));

package/src/api/controllers/query/import/sources/openapi3.ts

@@ -1,205 +0,0 @@
-import { ImportInfo } from "./base"
-import { Query, QueryParameter } from "../../../../../definitions/datasource"
-import { OpenAPIV3 } from "openapi-types"
-import { OpenAPISource } from "./base/openapi"
-import { URL } from "url"
-
-const parameterNotRef = (
-  param: OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject
-): param is OpenAPIV3.ParameterObject => {
-  // all refs are deferenced by parser library
-  return true
-}
-
-const requestBodyNotRef = (
-  param: OpenAPIV3.RequestBodyObject | OpenAPIV3.ReferenceObject | undefined
-): param is OpenAPIV3.RequestBodyObject => {
-  // all refs are deferenced by parser library
-  return param !== undefined
-}
-
-const schemaNotRef = (
-  param: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined
-): param is OpenAPIV3.SchemaObject => {
-  // all refs are deferenced by parser library
-  return param !== undefined
-}
-
-const isOpenAPI3 = (document: any): document is OpenAPIV3.Document => {
-  return document.openapi.includes("3.0")
-}
-
-const methods: string[] = Object.values(OpenAPIV3.HttpMethods)
-
-const isOperation = (
-  key: string,
-  pathItem: any
-): pathItem is OpenAPIV3.OperationObject => {
-  return methods.includes(key)
-}
-
-const isParameter = (
-  key: string,
-  pathItem: any
-): pathItem is OpenAPIV3.ParameterObject => {
-  return !isOperation(key, pathItem)
-}
-
-const getRequestBody = (operation: OpenAPIV3.OperationObject) => {
-  if (requestBodyNotRef(operation.requestBody)) {
-    const request: OpenAPIV3.RequestBodyObject = operation.requestBody
-    const supportedMimeTypes = getMimeTypes(operation)
-    if (supportedMimeTypes.length > 0) {
-      const mimeType = supportedMimeTypes[0]
-
-      // try get example from request
-      const content = request.content[mimeType]
-      if (content.example) {
-        return content.example
-      }
-
-      // try get example from schema
-      if (schemaNotRef(content.schema)) {
-        const schema = content.schema
-        if (schema.example) {
-          return schema.example
-        }
-      }
-    }
-  }
-  return undefined
-}
-
-const getMimeTypes = (operation: OpenAPIV3.OperationObject): string[] => {
-  if (requestBodyNotRef(operation.requestBody)) {
-    const request: OpenAPIV3.RequestBodyObject = operation.requestBody
-    return Object.keys(request.content)
-  }
-  return []
-}
-
-/**
- * OpenAPI Version 3.0
- * https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.0.md
- */
-export class OpenAPI3 extends OpenAPISource {
-  document!: OpenAPIV3.Document
-
-  isSupported = async (data: string): Promise<boolean> => {
-    try {
-      const document: any = await this.parseData(data)
-      if (isOpenAPI3(document)) {
-        this.document = document
-        return true
-      } else {
-        return false
-      }
-    } catch (err) {
-      return false
-    }
-  }
-
-  getInfo = async (): Promise<ImportInfo> => {
-    const name = this.document.info.title || "OpenAPI Import"
-    return {
-      name,
-    }
-  }
-
-  getQueries = async (datasourceId: string): Promise<Query[]> => {
-    let url: string | URL | undefined
-    if (this.document.servers?.length) {
-      url = this.document.servers[0].url
-      try {
-        url = new URL(url)
-      } catch (err) {
-        // unable to construct url, e.g. with variables
-        // proceed with string form of url
-      }
-    }
-
-    const queries: Query[] = []
-
-    for (let [path, pathItemObject] of Object.entries(this.document.paths)) {
-      // parameters that apply to every operation in the path
-      let pathParams: OpenAPIV3.ParameterObject[] = []
-
-      // pathItemObject can be undefined
-      if (!pathItemObject) {
-        continue
-      }
-
-      for (let [key, opOrParams] of Object.entries(pathItemObject)) {
-        if (isParameter(key, opOrParams)) {
-          const pathParameters = opOrParams as OpenAPIV3.ParameterObject[]
-          pathParams.push(...pathParameters)
-          continue
-        }
-        // can not be a parameter, must be an operation
-        const operation = opOrParams as OpenAPIV3.OperationObject
-
-        const methodName = key
-        const name = operation.operationId || path
-        let queryString = ""
-        const headers: any = {}
-        let requestBody = getRequestBody(operation)
-        const parameters: QueryParameter[] = []
-        const mimeTypes = getMimeTypes(operation)
-
-        if (mimeTypes.length > 0) {
-          headers["Content-Type"] = mimeTypes[0]
-        }
-
-        // combine the path parameters with the operation parameters
-        const operationParams = operation.parameters || []
-        const allParams = [...pathParams, ...operationParams]
-
-        for (let param of allParams) {
-          if (parameterNotRef(param)) {
-            switch (param.in) {
-              case "query":
-                let prefix = ""
-                if (queryString) {
-                  prefix = "&"
-                }
-                queryString = `${queryString}${prefix}${param.name}={{${param.name}}}`
-                break
-              case "header":
-                headers[param.name] = `{{${param.name}}}`
-                break
-              case "path":
-                // do nothing: param is already in the path
-                break
-              case "formData":
-                // future enhancement
-                break
-            }
-
-            // add the parameter if it can be bound in our config
-            if (["query", "header", "path"].includes(param.in)) {
-              parameters.push({
-                name: param.name,
-                default: "",
-              })
-            }
-          }
-        }
-
-        const query = this.constructQuery(
-          datasourceId,
-          name,
-          methodName,
-          path,
-          url,
-          queryString,
-          headers,
-          parameters,
-          requestBody
-        )
-        queries.push(query)
-      }
-    }
-
-    return queries
-  }
-}

package/src/api/controllers/query/import/sources/tests/openapi3/data/crud/crud.json

@@ -1,253 +0,0 @@
-{
-  "openapi": "3.0.2",
-  "info": {
-    "description": "A basic swagger file",
-    "version": "1.0.0",
-    "title": "CRUD"
-  },
-  "servers": [
-    {
-      "url": "http://example.com"
-    }
-  ],
-  "tags": [
-    {
-      "name": "entity"
-    }
-  ],
-  "paths": {
-    "/entities": {
-      "post": {
-        "tags": [
-          "entity"
-        ],
-        "operationId": "createEntity",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/CreateEntity"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "successful operation",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/Entity"
-                }
-              }
-            }
-          }
-        }
-      },
-      "get": {
-        "tags": [
-          "entity"
-        ],
-        "operationId": "getEntities",
-        "parameters": [
-          {
-            "$ref": "#/components/parameters/PageParameter"
-          },
-          {
-            "$ref": "#/components/parameters/SizeParameter"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "successful operation",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/Entities"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/entities/{entityId}": {
-      "parameters": [
-        {
-          "$ref": "#/components/parameters/EntityIdParameter"
-        }
-      ],
-      "get": {
-        "tags": [
-          "entity"
-        ],
-        "operationId": "getEntity",
-        "responses": {
-          "200": {
-            "description": "successful operation",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/Entity"
-                }
-              }
-            }
-          }
-        }
-      },
-      "put": {
-        "tags": [
-          "entity"
-        ],
-        "operationId": "updateEntity",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/Entity"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "successful operation",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/Entity"
-                }
-              }
-            }
-          }
-        }
-      },
-      "patch": {
-        "tags": [
-          "entity"
-        ],
-        "operationId": "patchEntity",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/Entity"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "successful operation",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/Entity"
-                }
-              }
-            }
-          }
-        }
-      },
-      "delete": {
-        "tags": [
-          "entity"
-        ],
-        "parameters": [
-          {
-            "$ref": "#/components/parameters/APIKeyParameter"
-          }
-        ],
-        "operationId": "deleteEntity",
-        "responses": {
-          "204": {
-            "description": "successful operation"
-          }
-        }
-      }
-    }
-  },
-  "components": {
-    "parameters": {
-      "EntityIdParameter": {
-        "schema": {
-          "type": "integer",
-          "format": "int64"
-        },
-        "name": "entityId",
-        "in": "path",
-        "required": true
-      },
-     "PageParameter": {
-       "schema": {
-         "type": "integer",
-         "format": "int32"
-        },
-        "name": "page",
-        "in": "query",
-        "required": false
-      },
-      "SizeParameter": {
-        "schema": {
-          "type": "integer",
-          "format": "int32"
-        },
-        "name": "size",
-        "in": "query",
-        "required": false
-      },
-      "APIKeyParameter": {
-        "schema": {
-          "type": "string"
-        },
-        "name": "x-api-key",
-        "in": "header",
-        "required": false
-      }
-    },
-    "schemas": {
-      "CreateEntity": {
-        "type": "object",
-        "properties": {
-          "name": {
-            "type": "string"
-          },
-          "type": {
-            "type": "string"
-          }
-        },
-        "example": {
-          "name": "name",
-          "type": "type"
-        }
-      },
-      "Entity": {
-        "allOf": [
-          {
-            "type": "object",
-            "properties": {
-              "id": {
-                "type": "integer",
-                "format": "int64"
-              }
-            }
-          },
-          {
-            "$ref": "#/components/schemas/CreateEntity"
-          }
-        ],
-        "example": {
-          "id": 1,
-          "name": "name",
-          "type": "type"
-        }
-      },
-      "Entities" : {
-        "type": "array",
-        "items": {
-          "$ref": "#/components/schemas/Entity"
-        }
-      }
-      }
-  }
-}