@budibase/server 1.0.99 → 1.0.102

package/dist/api/controllers/integration.js

@@ -8,11 +8,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+const { cloneDeep } = require("lodash");
 const { definitions } = require("../../integrations");
+const { getTenantId } = require("@budibase/backend-core/tenancy");
+const { SourceNames } = require("../../definitions/datasource");
+const googlesheets = require("../../integrations/googlesheets");
+const env = require("../../environment");
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         ctx.status = 200;
-        ctx.body = definitions;
+        const defs = cloneDeep(definitions);
+        // for google sheets integration google verification
+        if (env.EXCLUDE_QUOTAS_TENANTS) {
+            const excludedTenants = env.EXCLUDE_QUOTAS_TENANTS.split(",");
+            const tenantId = getTenantId();
+            if (excludedTenants.includes(tenantId)) {
+                defs[SourceNames.GOOGLE_SHEETS] = googlesheets.schema;
+            }
+        }
+        ctx.body = defs;
     });
 };
 exports.find = function (ctx) {

package/dist/api/controllers/query/import/index.js

@@ -13,6 +13,7 @@ exports.RestImporter = void 0;
 const validation_1 = require("../validation");
 const utils_1 = require("../../../../db/utils");
 const openapi2_1 = require("./sources/openapi2");
+const openapi3_1 = require("./sources/openapi3");
 const curl_1 = require("./sources/curl");
 // @ts-ignore
 const context_1 = require("@budibase/backend-core/context");
@@ -71,7 +72,7 @@ class RestImporter {
             };
         });
         this.data = data;
-        this.sources = [new openapi2_1.OpenAPI2(), new curl_1.Curl()];
+        this.sources = [new openapi2_1.OpenAPI2(), new openapi3_1.OpenAPI3(), new curl_1.Curl()];
     }
 }
 exports.RestImporter = RestImporter;

package/dist/api/controllers/query/import/sources/base/index.js

@@ -17,7 +17,18 @@ class ImportSource {
             const transformer = "return data";
             const schema = {};
             path = this.processPath(path);
-            path = `${url.origin}/${path}`;
+            if (url) {
+                if (typeof url === "string") {
+                    path = `${url}/${path}`;
+                }
+                else {
+                    let href = url.href;
+                    if (href.endsWith("/")) {
+                        href = href.slice(0, -1);
+                    }
+                    path = `${href}/${path}`;
+                }
+            }
             queryString = this.processQuery(queryString);
             const requestBody = JSON.stringify(body, null, 2);
             const query = {

package/dist/api/controllers/query/import/sources/curl.js

@@ -79,7 +79,7 @@ class Curl extends base_1.ImportSource {
         this.getQueries = (datasourceId) => __awaiter(this, void 0, void 0, function* () {
             const url = this.getUrl();
             const name = url.pathname;
-            const path = url.pathname;
+            const path = url.origin + url.pathname;
             const method = this.curl.method;
             const queryString = url.search;
             const headers = this.curl.headers;
@@ -88,7 +88,7 @@ class Curl extends base_1.ImportSource {
             if (cookieHeader) {
                 headers["Cookie"] = cookieHeader;
             }
-            const query = this.constructQuery(datasourceId, name, method, path, url, queryString, headers, [], requestBody);
+            const query = this.constructQuery(datasourceId, name, method, path, undefined, queryString, headers, [], requestBody);
             return [query];
         });
     }

package/dist/api/controllers/query/import/sources/openapi3.js

@@ -0,0 +1,174 @@
+"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 });
+exports.OpenAPI3 = void 0;
+const openapi_types_1 = require("openapi-types");
+const openapi_1 = require("./base/openapi");
+const url_1 = require("url");
+const parameterNotRef = (param) => {
+    // all refs are deferenced by parser library
+    return true;
+};
+const requestBodyNotRef = (param) => {
+    // all refs are deferenced by parser library
+    return param !== undefined;
+};
+const schemaNotRef = (param) => {
+    // all refs are deferenced by parser library
+    return param !== undefined;
+};
+const isOpenAPI3 = (document) => {
+    return document.openapi.includes("3.0");
+};
+const methods = Object.values(openapi_types_1.OpenAPIV3.HttpMethods);
+const isOperation = (key, pathItem) => {
+    return methods.includes(key);
+};
+const isParameter = (key, pathItem) => {
+    return !isOperation(key, pathItem);
+};
+const getRequestBody = (operation) => {
+    if (requestBodyNotRef(operation.requestBody)) {
+        const request = 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) => {
+    if (requestBodyNotRef(operation.requestBody)) {
+        const request = 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
+ */
+class OpenAPI3 extends openapi_1.OpenAPISource {
+    constructor() {
+        super(...arguments);
+        this.isSupported = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const document = yield this.parseData(data);
+                if (isOpenAPI3(document)) {
+                    this.document = document;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+            catch (err) {
+                return false;
+            }
+        });
+        this.getInfo = () => __awaiter(this, void 0, void 0, function* () {
+            const name = this.document.info.title || "OpenAPI Import";
+            return {
+                name,
+            };
+        });
+        this.getQueries = (datasourceId) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let url;
+            if ((_a = this.document.servers) === null || _a === void 0 ? void 0 : _a.length) {
+                url = this.document.servers[0].url;
+                try {
+                    url = new url_1.URL(url);
+                }
+                catch (err) {
+                    // unable to construct url, e.g. with variables
+                    // proceed with string form of url
+                }
+            }
+            const queries = [];
+            for (let [path, pathItemObject] of Object.entries(this.document.paths)) {
+                // parameters that apply to every operation in the path
+                let pathParams = [];
+                // pathItemObject can be undefined
+                if (!pathItemObject) {
+                    continue;
+                }
+                for (let [key, opOrParams] of Object.entries(pathItemObject)) {
+                    if (isParameter(key, opOrParams)) {
+                        const pathParameters = opOrParams;
+                        pathParams.push(...pathParameters);
+                        continue;
+                    }
+                    // can not be a parameter, must be an operation
+                    const operation = opOrParams;
+                    const methodName = key;
+                    const name = operation.operationId || path;
+                    let queryString = "";
+                    const headers = {};
+                    let requestBody = getRequestBody(operation);
+                    const parameters = [];
+                    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;
+        });
+    }
+}
+exports.OpenAPI3 = OpenAPI3;

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

@@ -0,0 +1,253 @@
+{
+  "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"
+        }
+      }
+      }
+  }
+}