@budibase/server 2.2.12-alpha.7 → 2.2.12-alpha.71

package/dist/integrations/index.js

@@ -32,8 +32,8 @@ const oracle_1 = __importDefault(require("./oracle"));
 const plugin_1 = require("../api/controllers/plugin");
 const types_1 = require("@budibase/types");
 const fileSystem_1 = require("../utilities/fileSystem");
-const environment = require("../environment");
-const { cloneDeep } = require("lodash");
+const environment_1 = __importDefault(require("../environment"));
+const lodash_1 = require("lodash");
 const DEFINITIONS = {
     [types_1.SourceName.POSTGRES]: postgres_1.default.schema,
     [types_1.SourceName.DYNAMODB]: dynamodb_1.default.schema,
@@ -79,7 +79,7 @@ if (process.arch &&
 function getDefinitions() {
     return __awaiter(this, void 0, void 0, function* () {
         const pluginSchemas = {};
-        if (environment.SELF_HOSTED) {
+        if (environment_1.default.SELF_HOSTED) {
             const plugins = yield (0, plugin_1.getPlugins)(types_1.PluginType.DATASOURCE);
             // extract the actual schema from each custom
             for (let plugin of plugins) {
@@ -90,7 +90,7 @@ function getDefinitions() {
                 }
             }
         }
-        return Object.assign(Object.assign({}, cloneDeep(DEFINITIONS)), pluginSchemas);
+        return Object.assign(Object.assign({}, (0, lodash_1.cloneDeep)(DEFINITIONS)), pluginSchemas);
     });
 }
 exports.getDefinitions = getDefinitions;
@@ -99,7 +99,7 @@ function getIntegration(integration) {
         if (INTEGRATIONS[integration]) {
             return INTEGRATIONS[integration];
         }
-        if (environment.SELF_HOSTED) {
+        if (environment_1.default.SELF_HOSTED) {
             const plugins = yield (0, plugin_1.getPlugins)(types_1.PluginType.DATASOURCE);
             for (let plugin of plugins) {
                 if (plugin.name === integration) {

package/dist/integrations/mongodb.js

@@ -15,290 +15,330 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@budibase/types");
 const mongodb_1 = require("mongodb");
-const SCHEMA = {
-    docs: "https://github.com/mongodb/node-mongodb-native",
-    friendlyName: "MongoDB",
-    type: "Non-relational",
-    description: "MongoDB is a general purpose, document-based, distributed database built for modern application developers and for the cloud era.",
-    datasource: {
-        connectionString: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-            default: "mongodb://localhost:27017",
-        },
-        db: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
+const environment_1 = __importDefault(require("../environment"));
+const getSchema = () => {
+    let schema = {
+        docs: "https://github.com/mongodb/node-mongodb-native",
+        friendlyName: "MongoDB",
+        type: "Non-relational",
+        description: "MongoDB is a general purpose, document-based, distributed database built for modern application developers and for the cloud era.",
+        datasource: {
+            connectionString: {
+                type: types_1.DatasourceFieldType.STRING,
+                required: true,
+                default: "mongodb://localhost:27017",
+                display: "Connection string",
+            },
+            db: {
+                type: types_1.DatasourceFieldType.STRING,
+                required: true,
+                display: "DB",
+            },
         },
+        query: {
+            create: {
+                type: types_1.QueryType.JSON,
+            },
+            read: {
+                type: types_1.QueryType.JSON,
+            },
+            update: {
+                type: types_1.QueryType.JSON,
+            },
+            delete: {
+                type: types_1.QueryType.JSON,
+            },
+            aggregate: {
+                type: types_1.QueryType.JSON,
+                readable: true,
+                steps: [
+                    {
+                        key: "$addFields",
+                        template: "{\n\t\n}",
+                    },
+                    {
+                        key: "$bucket",
+                        template: `{
+    "groupBy": "",
+    "boundaries": [],
+    "default": "",
+    "output": {}
+  }`,
+                    },
+                    {
+                        key: "$bucketAuto",
+                        template: `{
+    "groupBy": "",
+    "buckets": 1,
+    "output": {},
+    "granularity": "R5"
+  }`,
+                    },
+                    {
+                        key: "$changeStream",
+                        template: `{
+    "allChangesForCluster": true,
+    "fullDocument": "",
+    "fullDocumentBeforeChange": "",
+    "resumeAfter": 1,
+    "showExpandedEvents": true,
+    "startAfter": {},
+    "startAtOperationTime": ""
+  }`,
+                    },
+                    {
+                        key: "$collStats",
+                        template: `{
+    "latencyStats": { "histograms": true } },
+    "storageStats": { "scale": 1 } },
+    "count": {},
+    "queryExecStats": {}
+  }`,
+                    },
+                    {
+                        key: "$count",
+                        template: ``,
+                    },
+                    {
+                        key: "$densify",
+                        template: `{
+    "field": "",
+    "partitionByFields": [],
+    "range": {
+      "step": 1,
+      "unit": 1,
+      "bounds": "full"
+    }
+  }`,
+                    },
+                    {
+                        key: "$documents",
+                        template: `[]`,
+                    },
+                    {
+                        key: "$facet",
+                        template: `{\n\t\n}`,
+                    },
+                    {
+                        key: "$fill",
+                        template: `{
+    "partitionBy": "",
+    "partitionByFields": [],
+    "sortBy": {},
+    "output": {}
+  }`,
+                    },
+                    {
+                        key: "$geoNear",
+                        template: `{
+    "near": { 
+      "type": "Point", 
+      "coordinates": [ 
+        -73.98142, 40.71782
+      ] 
     },
-    query: {
-        create: {
-            type: types_1.QueryType.JSON,
-        },
-        read: {
-            type: types_1.QueryType.JSON,
-        },
-        update: {
-            type: types_1.QueryType.JSON,
-        },
-        delete: {
-            type: types_1.QueryType.JSON,
+    "key": "location",
+    "distanceField": "dist.calculated",
+    "query": { "category": "Parks" }
+  }`,
+                    },
+                    {
+                        key: "$graphLookup",
+                        template: `{
+    "from": "",
+    "startWith": "",
+    "connectFromField": "",
+    "connectToField": "",
+    "as": "",
+    "maxDepth": 1,
+    "depthField": "",
+    "restrictSearchWithMatch": {}
+  }`,
+                    },
+                    {
+                        key: "$group",
+                        template: `{
+    "_id": ""
+  }`,
+                    },
+                    {
+                        key: "$indexStats",
+                        template: "{\n\t\n}",
+                    },
+                    {
+                        key: "$limit",
+                        template: `1`,
+                    },
+                    {
+                        key: "$listLocalSessions",
+                        template: `{\n\t\n}`,
+                    },
+                    {
+                        key: "$listSessions",
+                        template: `{\n\t\n}`,
+                    },
+                    {
+                        key: "$lookup",
+                        template: `{
+    "from": "",
+    "localField": "",
+    "foreignField": "",
+    "as": ""
+  }`,
+                    },
+                    {
+                        key: "$match",
+                        template: "{\n\t\n}",
+                    },
+                    {
+                        key: "$merge",
+                        template: `{
+    "into": {},
+    "on": "_id",
+    "whenMatched": "replace",
+    "whenNotMatched": "insert"
+  }`,
+                    },
+                    {
+                        key: "$out",
+                        template: `{
+    "db": "",
+    "coll": ""
+  }`,
+                    },
+                    {
+                        key: "$planCacheStats",
+                        template: "{\n\t\n}",
+                    },
+                    {
+                        key: "$project",
+                        template: "{\n\t\n}",
+                    },
+                    {
+                        key: "$redact",
+                        template: "",
+                    },
+                    {
+                        key: "$replaceRoot",
+                        template: `{ "newRoot": "" }`,
+                    },
+                    {
+                        key: "$replaceWith",
+                        template: ``,
+                    },
+                    {
+                        key: "$sample",
+                        template: `{ "size": 3 }`,
+                    },
+                    {
+                        key: "$set",
+                        template: "{\n\t\n}",
+                    },
+                    {
+                        key: "$setWindowFields",
+                        template: `{
+    "partitionBy": "",
+    "sortBy": {},
+    "output": {}
+  }`,
+                    },
+                    {
+                        key: "$skip",
+                        template: `1`,
+                    },
+                    {
+                        key: "$sort",
+                        template: "{\n\t\n}",
+                    },
+                    {
+                        key: "$sortByCount",
+                        template: "",
+                    },
+                    {
+                        key: "$unionWith",
+                        template: `{
+    "coll": "",
+    "pipeline": []
+  }`,
+                    },
+                    {
+                        key: "$unset",
+                        template: "",
+                    },
+                    {
+                        key: "$unwind",
+                        template: `{
+    "path": "",
+    "includeArrayIndex": "",
+    "preserveNullAndEmptyArrays": true
+  }`,
+                    },
+                ],
+            },
         },
-        aggregate: {
-            type: types_1.QueryType.JSON,
-            readable: true,
-            steps: [
-                {
-                    key: "$addFields",
-                    template: "{\n\t\n}",
-                },
-                {
-                    key: "$bucket",
-                    template: `{
-  "groupBy": "",
-  "boundaries": [],
-  "default": "",
-  "output": {}
-}`,
-                },
-                {
-                    key: "$bucketAuto",
-                    template: `{
-  "groupBy": "",
-  "buckets": 1,
-  "output": {},
-  "granularity": "R5"
-}`,
-                },
-                {
-                    key: "$changeStream",
-                    template: `{
-  "allChangesForCluster": true,
-  "fullDocument": "",
-  "fullDocumentBeforeChange": "",
-  "resumeAfter": 1,
-  "showExpandedEvents": true,
-  "startAfter": {},
-  "startAtOperationTime": ""
-}`,
-                },
-                {
-                    key: "$collStats",
-                    template: `{
-  "latencyStats": { "histograms": true } },
-  "storageStats": { "scale": 1 } },
-  "count": {},
-  "queryExecStats": {}
-}`,
-                },
-                {
-                    key: "$count",
-                    template: ``,
-                },
-                {
-                    key: "$densify",
-                    template: `{
-  "field": "",
-  "partitionByFields": [],
-  "range": {
-    "step": 1,
-    "unit": 1,
-    "bounds": "full"
-  }
-}`,
-                },
-                {
-                    key: "$documents",
-                    template: `[]`,
-                },
-                {
-                    key: "$facet",
-                    template: `{\n\t\n}`,
-                },
-                {
-                    key: "$fill",
-                    template: `{
-  "partitionBy": "",
-  "partitionByFields": [],
-  "sortBy": {},
-  "output": {}
-}`,
-                },
-                {
-                    key: "$geoNear",
-                    template: `{
-  "near": { 
-    "type": "Point", 
-    "coordinates": [ 
-      -73.98142, 40.71782
-    ] 
-  },
-  "key": "location",
-  "distanceField": "dist.calculated",
-  "query": { "category": "Parks" }
-}`,
-                },
-                {
-                    key: "$graphLookup",
-                    template: `{
-  "from": "",
-  "startWith": "",
-  "connectFromField": "",
-  "connectToField": "",
-  "as": "",
-  "maxDepth": 1,
-  "depthField": "",
-  "restrictSearchWithMatch": {}
-}`,
-                },
-                {
-                    key: "$group",
-                    template: `{
-  "_id": ""
-}`,
-                },
-                {
-                    key: "$indexStats",
-                    template: "{\n\t\n}",
-                },
-                {
-                    key: "$limit",
-                    template: `1`,
-                },
-                {
-                    key: "$listLocalSessions",
-                    template: `{\n\t\n}`,
-                },
-                {
-                    key: "$listSessions",
-                    template: `{\n\t\n}`,
-                },
-                {
-                    key: "$lookup",
-                    template: `{
-  "from": "",
-  "localField": "",
-  "foreignField": "",
-  "as": ""
-}`,
-                },
-                {
-                    key: "$match",
-                    template: "{\n\t\n}",
-                },
-                {
-                    key: "$merge",
-                    template: `{
-  "into": {},
-  "on": "_id",
-  "whenMatched": "replace",
-  "whenNotMatched": "insert"
-}`,
-                },
-                {
-                    key: "$out",
-                    template: `{
-  "db": "",
-  "coll": ""
-}`,
-                },
-                {
-                    key: "$planCacheStats",
-                    template: "{\n\t\n}",
-                },
-                {
-                    key: "$project",
-                    template: "{\n\t\n}",
-                },
-                {
-                    key: "$redact",
-                    template: "",
-                },
-                {
-                    key: "$replaceRoot",
-                    template: `{ "newRoot": "" }`,
-                },
-                {
-                    key: "$replaceWith",
-                    template: ``,
-                },
-                {
-                    key: "$sample",
-                    template: `{ "size": 3 }`,
-                },
-                {
-                    key: "$set",
-                    template: "{\n\t\n}",
-                },
-                {
-                    key: "$setWindowFields",
-                    template: `{
-  "partitionBy": "",
-  "sortBy": {},
-  "output": {}
-}`,
-                },
-                {
-                    key: "$skip",
-                    template: `1`,
-                },
-                {
-                    key: "$sort",
-                    template: "{\n\t\n}",
-                },
-                {
-                    key: "$sortByCount",
-                    template: "",
-                },
-                {
-                    key: "$unionWith",
-                    template: `{
-  "coll": "",
-  "pipeline": []
-}`,
-                },
-                {
-                    key: "$unset",
-                    template: "",
-                },
-                {
-                    key: "$unwind",
-                    template: `{
-  "path": "",
-  "includeArrayIndex": "",
-  "preserveNullAndEmptyArrays": true
-}`,
+        extra: {
+            collection: {
+                displayName: "Collection",
+                type: types_1.DatasourceFieldType.STRING,
+                required: true,
+            },
+            actionType: {
+                displayName: "Query Type",
+                type: types_1.DatasourceFieldType.LIST,
+                required: true,
+                data: {
+                    read: ["find", "findOne", "findOneAndUpdate", "count", "distinct"],
+                    create: ["insertOne", "insertMany"],
+                    update: ["updateOne", "updateMany"],
+                    delete: ["deleteOne", "deleteMany"],
+                    aggregate: ["json", "pipeline"],
                 },
-            ],
-        },
-    },
-    extra: {
-        collection: {
-            displayName: "Collection",
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-        actionType: {
-            displayName: "Query Type",
-            type: types_1.DatasourceFieldType.LIST,
-            required: true,
-            data: {
-                read: ["find", "findOne", "findOneAndUpdate", "count", "distinct"],
-                create: ["insertOne", "insertMany"],
-                update: ["updateOne", "updateMany"],
-                delete: ["deleteOne", "deleteMany"],
-                aggregate: ["json", "pipeline"],
             },
         },
-    },
+    };
+    if (environment_1.default.SELF_HOSTED) {
+        schema.datasource = Object.assign(Object.assign({}, schema.datasource), { 
+            //@ts-ignore
+            tls: {
+                type: types_1.DatasourceFieldType.FIELD_GROUP,
+                display: "Configure SSL",
+                fields: {
+                    tlsCertificateFile: {
+                        type: types_1.DatasourceFieldType.STRING,
+                        required: false,
+                        display: "Certificate file path",
+                    },
+                    tlsCertificateKeyFile: {
+                        type: types_1.DatasourceFieldType.STRING,
+                        required: false,
+                        display: "Certificate Key file path",
+                    },
+                    tlsCAFile: {
+                        type: types_1.DatasourceFieldType.STRING,
+                        required: false,
+                        display: "CA file path",
+                    },
+                },
+            } });
+    }
+    return schema;
 };
+const SCHEMA = getSchema();
 class MongoIntegration {
     constructor(config) {
         this.config = config;
-        this.client = new mongodb_1.MongoClient(config.connectionString);
+        const options = {
+            tlsCertificateFile: config.tlsCertificateFile || undefined,
+            tlsCertificateKeyFile: config.tlsCertificateKeyFile || undefined,
+            tlsCAFile: config.tlsCAFile || undefined,
+        };
+        this.client = new mongodb_1.MongoClient(config.connectionString, options);
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/integrations/mysql.js

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@budibase/types");
 const utils_1 = require("./utils");
 const dayjs_1 = __importDefault(require("dayjs"));
-const { NUMBER_REGEX } = require("../utilities");
+const utilities_1 = require("../utilities");
 const sql_1 = __importDefault(require("./base/sql"));
 const mysql = require("mysql2/promise");
 const SCHEMA = {
@@ -81,7 +81,7 @@ function bindingTypeCoerce(bindings) {
         if (typeof binding !== "string") {
             continue;
         }
-        const matches = binding.match(NUMBER_REGEX);
+        const matches = binding.match(utilities_1.NUMBER_REGEX);
         // check if number first
         if (matches && matches[0] !== "" && !isNaN(Number(matches[0]))) {
             bindings[i] = parseFloat(binding);