@budibase/server 1.0.35 → 1.0.42

package/dist/api/controllers/apikeys.js

@@ -8,8 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { StaticDatabases } = require("@budibase/auth/db");
-const { getGlobalDB } = require("@budibase/auth/tenancy");
+const { StaticDatabases } = require("@budibase/backend-core/db");
+const { getGlobalDB } = require("@budibase/backend-core/tenancy");
 const KEYS_DOC = StaticDatabases.GLOBAL.docs.apiKeys;
 function getBuilderMainDoc() {
     return __awaiter(this, void 0, void 0, function* () {

package/dist/api/controllers/application.js

@@ -14,19 +14,19 @@ const packageJson = require("../../../package.json");
 const { createLinkView, createRoutingView, createAllSearchIndex, } = require("../../db/views/staticViews");
 const { getTemplateStream, createApp, deleteApp, } = require("../../utilities/fileSystem");
 const { generateAppID, getLayoutParams, getScreenParams, generateDevAppID, DocumentTypes, AppStatus, } = require("../../db/utils");
-const { BUILTIN_ROLE_IDS, AccessController } = require("@budibase/auth/roles");
+const { BUILTIN_ROLE_IDS, AccessController, } = require("@budibase/backend-core/roles");
 const { BASE_LAYOUTS } = require("../../constants/layouts");
 const { cloneDeep } = require("lodash/fp");
 const { processObject } = require("@budibase/string-templates");
-const { getAllApps, isDevAppID, getDeployedAppID, Replication, } = require("@budibase/auth/db");
+const { getAllApps, isDevAppID, getDeployedAppID, Replication, } = require("@budibase/backend-core/db");
 const { USERS_TABLE_SCHEMA } = require("../../constants");
 const { getDeployedApps, removeAppFromUserRoles, } = require("../../utilities/workerRequests");
 const { clientLibraryPath, stringToReadStream } = require("../../utilities");
 const { getAllLocks } = require("../../utilities/redis");
 const { updateClientLibrary, backupClientLibrary, revertClientLibrary, } = require("../../utilities/fileSystem/clientLibrary");
-const { getTenantId, isMultiTenant } = require("@budibase/auth/tenancy");
+const { getTenantId, isMultiTenant } = require("@budibase/backend-core/tenancy");
 const { syncGlobalUsers } = require("./user");
-const { app: appCache } = require("@budibase/auth/cache");
+const { app: appCache } = require("@budibase/backend-core/cache");
 const { cleanupAutomations } = require("../../automations/utils");
 const URL_REGEX_SLASH = /\/|\\/g;
 // utility function, need to do away with this

package/dist/api/controllers/auth.js

@@ -12,7 +12,7 @@ const CouchDB = require("../../db");
 const { outputProcessing } = require("../../utilities/rowProcessor");
 const { InternalTables } = require("../../db/utils");
 const { getFullUser } = require("../../utilities/users");
-const { BUILTIN_ROLE_IDS } = require("@budibase/auth/roles");
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles");
 exports.fetchSelf = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
     let userId = ctx.user.userId || ctx.user._id;

package/dist/api/controllers/automation.js

@@ -12,10 +12,12 @@ const CouchDB = require("../../db");
 const actions = require("../../automations/actions");
 const triggers = require("../../automations/triggers");
 const { getAutomationParams, generateAutomationID } = require("../../db/utils");
-const { checkForWebhooks, updateTestHistory, } = require("../../automations/utils");
+const { checkForWebhooks, updateTestHistory, removeDeprecated, } = require("../../automations/utils");
 const { deleteEntityMetadata } = require("../../utilities");
 const { MetadataTypes } = require("../../constants");
 const { setTestFlag, clearTestFlag } = require("../../utilities/redis");
+const ACTION_DEFS = removeDeprecated(actions.ACTION_DEFINITIONS);
+const TRIGGER_DEFS = removeDeprecated(triggers.TRIGGER_DEFINITIONS);
 /*************************
  *                       *
  *   BUILDER FUNCTIONS   *
@@ -137,19 +139,19 @@ exports.destroy = function (ctx) {
 };
 exports.getActionList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = actions.ACTION_DEFINITIONS;
+        ctx.body = ACTION_DEFS;
     });
 };
 exports.getTriggerList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = triggers.TRIGGER_DEFINITIONS;
+        ctx.body = TRIGGER_DEFS;
     });
 };
 module.exports.getDefinitionList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         ctx.body = {
-            trigger: triggers.TRIGGER_DEFINITIONS,
-            action: actions.ACTION_DEFINITIONS,
+            trigger: TRIGGER_DEFS,
+            action: ACTION_DEFS,
         };
     });
 };

package/dist/api/controllers/cloud.js

@@ -9,11 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const env = require("../../environment");
-const { getAllApps } = require("@budibase/auth/db");
+const { getAllApps } = require("@budibase/backend-core/db");
 const CouchDB = require("../../db");
 const { exportDB, sendTempFile, readFileSync, } = require("../../utilities/fileSystem");
 const { stringToReadStream } = require("../../utilities");
-const { getGlobalDBName, getGlobalDB } = require("@budibase/auth/tenancy");
+const { getGlobalDBName, getGlobalDB, } = require("@budibase/backend-core/tenancy");
 const { create } = require("./application");
 const { getDocParams, DocumentTypes, isDevAppID } = require("../../db/utils");
 function createApp(appName, appImport) {

package/dist/api/controllers/datasource.js

@@ -13,6 +13,7 @@ const { generateDatasourceID, getDatasourceParams, getQueryParams, DocumentTypes
 const { BuildSchemaErrors, InvalidColumns } = require("../../constants");
 const { integrations } = require("../../integrations");
 const { getDatasourceAndQuery } = require("./row/utils");
+const { invalidateDynamicVariables } = require("../../threads/utils");
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const database = new CouchDB(ctx.appId);
@@ -45,11 +46,39 @@ exports.buildSchemaFromDb = function (ctx) {
         ctx.body = response;
     });
 };
+/**
+ * Check for variables that have been updated or removed and invalidate them.
+ */
+const invalidateVariables = (existingDatasource, updatedDatasource) => __awaiter(void 0, void 0, void 0, function* () {
+    const existingVariables = existingDatasource.config.dynamicVariables;
+    const updatedVariables = updatedDatasource.config.dynamicVariables;
+    const toInvalidate = [];
+    if (!existingVariables) {
+        return;
+    }
+    if (!updatedVariables) {
+        // invalidate all
+        toInvalidate.push(...existingVariables);
+    }
+    else {
+        // invaldate changed / removed
+        existingVariables.forEach(existing => {
+            const unchanged = updatedVariables.find(updated => existing.name === updated.name &&
+                existing.queryId === updated.queryId &&
+                existing.value === updated.value);
+            if (!unchanged) {
+                toInvalidate.push(existing);
+            }
+        });
+    }
+    yield invalidateDynamicVariables(toInvalidate);
+});
 exports.update = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
         const datasourceId = ctx.params.datasourceId;
         let datasource = yield db.get(datasourceId);
+        yield invalidateVariables(datasource, ctx.request.body);
         datasource = Object.assign(Object.assign({}, datasource), ctx.request.body);
         const response = yield db.put(datasource);
         datasource._rev = response.rev;

package/dist/api/controllers/deploy/index.js

@@ -10,10 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const CouchDB = require("../../../db");
 const Deployment = require("./Deployment");
-const { Replication, getDeployedAppID } = require("@budibase/auth/db");
+const { Replication, getDeployedAppID } = require("@budibase/backend-core/db");
 const { DocumentTypes, getAutomationParams } = require("../../../db/utils");
 const { disableAllCrons, enableCronTrigger, } = require("../../../automations/utils");
-const { app: appCache } = require("@budibase/auth/cache");
+const { app: appCache } = require("@budibase/backend-core/cache");
 // the max time we can wait for an invalidation to complete before considering it failed
 const MAX_PENDING_TIME_MS = 30 * 60000;
 const DeploymentStatus = {

package/dist/api/controllers/dev.js

@@ -14,9 +14,9 @@ const env = require("../../environment");
 const { checkSlashesInUrl } = require("../../utilities");
 const { request } = require("../../utilities/workerRequests");
 const { clearLock } = require("../../utilities/redis");
-const { Replication } = require("@budibase/auth").db;
+const { Replication } = require("@budibase/backend-core/db");
 const { DocumentTypes } = require("../../db/utils");
-const { app: appCache } = require("@budibase/auth/cache");
+const { app: appCache } = require("@budibase/backend-core/cache");
 function redirect(ctx, method, path = "global") {
     return __awaiter(this, void 0, void 0, function* () {
         const { devPath } = ctx.params;

package/dist/api/controllers/hosting.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const CouchDB = require("../../db");
 const { getDeployedApps } = require("../../utilities/workerRequests");
-const { getScopedConfig } = require("@budibase/auth/db");
-const { Configs } = require("@budibase/auth").constants;
+const { getScopedConfig } = require("@budibase/backend-core/db");
+const { Configs } = require("@budibase/backend-core/constants");
 const { checkSlashesInUrl } = require("../../utilities");
 exports.fetchUrls = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;

package/dist/api/controllers/permission.js

@@ -8,8 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { getBuiltinPermissions } = require("@budibase/auth/permissions");
-const { isBuiltin, getDBRoleID, getExternalRoleID, getBuiltinRoles, } = require("@budibase/auth/roles");
+const { getBuiltinPermissions } = require("@budibase/backend-core/permissions");
+const { isBuiltin, getDBRoleID, getExternalRoleID, getBuiltinRoles, } = require("@budibase/backend-core/roles");
 const { getRoleParams } = require("../../db/utils");
 const CouchDB = require("../../db");
 const { CURRENTLY_SUPPORTED_LEVELS, getBasePermissions, } = require("../../utilities/security");

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

@@ -0,0 +1,79 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestImporter = void 0;
+const db_1 = __importDefault(require("../../../../db"));
+const validation_1 = require("../validation");
+const utils_1 = require("../../../../db/utils");
+const openapi2_1 = require("./sources/openapi2");
+const curl_1 = require("./sources/curl");
+class RestImporter {
+    constructor(data) {
+        this.init = () => __awaiter(this, void 0, void 0, function* () {
+            for (let source of this.sources) {
+                if (yield source.isSupported(this.data)) {
+                    this.source = source;
+                    break;
+                }
+            }
+        });
+        this.getInfo = () => __awaiter(this, void 0, void 0, function* () {
+            return this.source.getInfo();
+        });
+        this.importQueries = (appId, datasourceId) => __awaiter(this, void 0, void 0, function* () {
+            // constuct the queries
+            let queries = yield this.source.getQueries(datasourceId);
+            // validate queries
+            const errorQueries = [];
+            const schema = validation_1.queryValidation();
+            queries = queries
+                .filter(query => {
+                const validation = schema.validate(query);
+                if (validation.error) {
+                    errorQueries.push(query);
+                    return false;
+                }
+                return true;
+            })
+                .map(query => {
+                query._id = utils_1.generateQueryID(query.datasourceId);
+                return query;
+            });
+            // persist queries
+            const db = new db_1.default(appId);
+            const response = yield db.bulkDocs(queries);
+            // create index to seperate queries and errors
+            const queryIndex = queries.reduce((acc, query) => {
+                if (query._id) {
+                    acc[query._id] = query;
+                }
+                return acc;
+            }, {});
+            // check for failed writes
+            response.forEach((query) => {
+                if (!query.ok) {
+                    errorQueries.push(queryIndex[query.id]);
+                    delete queryIndex[query.id];
+                }
+            });
+            return {
+                errorQueries,
+                queries: Object.values(queryIndex),
+            };
+        });
+        this.data = data;
+        this.sources = [new openapi2_1.OpenAPI2(), new curl_1.Curl()];
+    }
+}
+exports.RestImporter = RestImporter;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportSource = void 0;
+var MethodToVerb;
+(function (MethodToVerb) {
+    MethodToVerb["get"] = "read";
+    MethodToVerb["post"] = "create";
+    MethodToVerb["put"] = "update";
+    MethodToVerb["patch"] = "patch";
+    MethodToVerb["delete"] = "delete";
+})(MethodToVerb || (MethodToVerb = {}));
+class ImportSource {
+    constructor() {
+        this.constructQuery = (datasourceId, name, method, path, url, queryString, headers = {}, parameters = [], body = undefined) => {
+            const readable = true;
+            const queryVerb = this.verbFromMethod(method);
+            const transformer = "return data";
+            const schema = {};
+            path = this.processPath(path);
+            path = `${url.origin}/${path}`;
+            queryString = this.processQuery(queryString);
+            const requestBody = JSON.stringify(body, null, 2);
+            const query = {
+                datasourceId,
+                name,
+                parameters,
+                fields: {
+                    headers,
+                    queryString,
+                    path,
+                    requestBody,
+                },
+                transformer,
+                schema,
+                readable,
+                queryVerb,
+            };
+            return query;
+        };
+        this.verbFromMethod = (method) => {
+            const verb = MethodToVerb[method];
+            if (!verb) {
+                throw new Error(`Unsupported method: ${method}`);
+            }
+            return verb;
+        };
+        this.processPath = (path) => {
+            if (path === null || path === void 0 ? void 0 : path.startsWith("/")) {
+                path = path.substring(1);
+            }
+            // add extra braces around params for binding
+            path = path.replace(/[{]/g, "{{");
+            path = path.replace(/[}]/g, "}}");
+            return path;
+        };
+        this.processQuery = (queryString) => {
+            if (queryString === null || queryString === void 0 ? void 0 : queryString.startsWith("?")) {
+                return queryString.substring(1);
+            }
+            return queryString;
+        };
+    }
+}
+exports.ImportSource = ImportSource;

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

@@ -0,0 +1,42 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPISource = void 0;
+const _1 = require(".");
+const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
+const yaml = require("js-yaml");
+class OpenAPISource extends _1.ImportSource {
+    constructor() {
+        super(...arguments);
+        this.parseData = (data) => __awaiter(this, void 0, void 0, function* () {
+            let json;
+            try {
+                json = JSON.parse(data);
+            }
+            catch (jsonErr) {
+                // couldn't parse json
+                // try to convert yaml -> json
+                try {
+                    json = yaml.load(data);
+                }
+                catch (yamlErr) {
+                    // couldn't parse yaml
+                    throw new Error("Could not parse JSON or YAML");
+                }
+            }
+            return swagger_parser_1.default.validate(json, {});
+        });
+    }
+}
+exports.OpenAPISource = OpenAPISource;

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

@@ -0,0 +1,96 @@
+"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.Curl = void 0;
+const base_1 = require("./base");
+const url_1 = require("url");
+const curlconverter = require("curlconverter");
+const parseCurl = (data) => {
+    const curlJson = curlconverter.toJsonString(data);
+    return JSON.parse(curlJson);
+};
+/**
+ * The curl converter parses the request body into the key field of an object
+ * e.g. --d '{"key":"val"}' produces an object { "{"key":"val"}" : "" }
+ * This is not what we want, so we need to parse out the key from the object
+ */
+const parseBody = (curl) => {
+    if (curl.data) {
+        const keys = Object.keys(curl.data);
+        if (keys.length) {
+            let key = keys[0];
+            try {
+                // filter out the dollar syntax used by curl for shell support
+                if (key.startsWith("$")) {
+                    key = key.substring(1);
+                }
+                return JSON.parse(key);
+            }
+            catch (e) {
+                // do nothing
+            }
+        }
+    }
+    return undefined;
+};
+const parseCookie = (curl) => {
+    if (curl.cookies) {
+        return Object.entries(curl.cookies).reduce((acc, entry) => {
+            const [key, value] = entry;
+            return acc + `${key}=${value}; `;
+        }, "");
+    }
+    return null;
+};
+/**
+ * Curl
+ * https://curl.se/docs/manpage.html
+ */
+class Curl extends base_1.ImportSource {
+    constructor() {
+        super(...arguments);
+        this.isSupported = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const curl = parseCurl(data);
+                this.curl = curl;
+            }
+            catch (err) {
+                return false;
+            }
+            return true;
+        });
+        this.getUrl = () => {
+            return new url_1.URL(this.curl.raw_url);
+        };
+        this.getInfo = () => __awaiter(this, void 0, void 0, function* () {
+            const url = this.getUrl();
+            return {
+                name: url.hostname,
+            };
+        });
+        this.getQueries = (datasourceId) => __awaiter(this, void 0, void 0, function* () {
+            const url = this.getUrl();
+            const name = url.pathname;
+            const path = url.pathname;
+            const method = this.curl.method;
+            const queryString = url.search;
+            const headers = this.curl.headers;
+            const requestBody = parseBody(this.curl);
+            const cookieHeader = parseCookie(this.curl);
+            if (cookieHeader) {
+                headers["Cookie"] = cookieHeader;
+            }
+            const query = this.constructQuery(datasourceId, name, method, path, url, queryString, headers, [], requestBody);
+            return [query];
+        });
+    }
+}
+exports.Curl = Curl;

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

@@ -0,0 +1,142 @@
+"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.OpenAPI2 = 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 isOpenAPI2 = (document) => {
+    if (document.swagger === "2.0") {
+        return true;
+    }
+    else {
+        return false;
+    }
+};
+const methods = Object.values(openapi_types_1.OpenAPIV2.HttpMethods);
+const isOperation = (key, pathItem) => {
+    return methods.includes(key);
+};
+const isParameter = (key, pathItem) => {
+    return !isOperation(key, pathItem);
+};
+/**
+ * OpenAPI Version 2.0 - aka "Swagger"
+ * https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md
+ */
+class OpenAPI2 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 (isOpenAPI2(document)) {
+                    this.document = document;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+            catch (err) {
+                return false;
+            }
+        });
+        this.getUrl = () => {
+            var _a;
+            const scheme = ((_a = this.document.schemes) === null || _a === void 0 ? void 0 : _a.includes("https")) ? "https" : "http";
+            const basePath = this.document.basePath || "";
+            const host = this.document.host || "<host>";
+            return new url_1.URL(`${scheme}://${host}${basePath}`);
+        };
+        this.getInfo = () => __awaiter(this, void 0, void 0, function* () {
+            const name = this.document.info.title || "Swagger Import";
+            return {
+                name,
+            };
+        });
+        this.getQueries = (datasourceId) => __awaiter(this, void 0, void 0, function* () {
+            const url = this.getUrl();
+            const queries = [];
+            for (let [path, pathItem] of Object.entries(this.document.paths)) {
+                // parameters that apply to every operation in the path
+                let pathParams = [];
+                for (let [key, opOrParams] of Object.entries(pathItem)) {
+                    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 = undefined;
+                    const parameters = [];
+                    if (operation.consumes) {
+                        headers["Content-Type"] = operation.consumes[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;
+                                case "body":
+                                    // set the request body to the example provided
+                                    // future enhancement: generate an example from the schema
+                                    let bodyParam = param;
+                                    if (param.schema.example) {
+                                        const schema = bodyParam.schema;
+                                        requestBody = schema.example;
+                                    }
+                                    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: param.default || "",
+                                });
+                            }
+                        }
+                    }
+                    const query = this.constructQuery(datasourceId, name, methodName, path, url, queryString, headers, parameters, requestBody);
+                    queries.push(query);
+                }
+            }
+            return queries;
+        });
+    }
+}
+exports.OpenAPI2 = OpenAPI2;