@budibase/server 1.0.219 → 1.0.220-alpha.2

package/dist/automations/logging/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.checkAppMetadata = exports.storeLog = void 0;
+const env = __importStar(require("../../environment"));
+const pro_1 = require("@budibase/pro");
+const backend_core_1 = require("@budibase/backend-core");
+function storeLog(automation, results) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // can disable this if un-needed in self-host, also only do this for prod apps
+        if (env.DISABLE_AUTOMATION_LOGS) {
+            return;
+        }
+        yield pro_1.automations.logs.storeLog(automation, results);
+    });
+}
+exports.storeLog = storeLog;
+function checkAppMetadata(apps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const maxStartDate = yield pro_1.automations.logs.oldestLogDate();
+        for (let metadata of apps) {
+            if (!metadata.automationErrors) {
+                continue;
+            }
+            for (let [key, errors] of Object.entries(metadata.automationErrors)) {
+                const updated = [];
+                for (let error of errors) {
+                    const startDate = error.split(backend_core_1.db.SEPARATOR)[2];
+                    if (startDate > maxStartDate) {
+                        updated.push(error);
+                    }
+                }
+                metadata.automationErrors[key] = updated;
+            }
+        }
+        return apps;
+    });
+}
+exports.checkAppMetadata = checkAppMetadata;

package/dist/automations/steps/executeQuery.js

@@ -88,7 +88,7 @@ exports.run = function ({ inputs, appId, emitter }) {
             },
         });
         try {
-            yield queryController.executeV2(ctx);
+            yield queryController.executeV2(ctx, { isAutomation: true });
             const _b = ctx.body, { data } = _b, rest = __rest(_b, ["data"]);
             return {
                 response: data,

package/dist/automations/steps/filter.js

@@ -56,46 +56,55 @@ exports.definition = {
         outputs: {
             properties: {
                 success: {
+                    type: "boolean",
+                    description: "Whether the action was successful",
+                },
+                result: {
                     type: "boolean",
                     description: "Whether the logic block passed",
                 },
             },
-            required: ["success"],
+            required: ["success", "result"],
         },
     },
 };
 exports.run = function filter({ inputs }) {
     return __awaiter(this, void 0, void 0, function* () {
-        let { field, condition, value } = inputs;
-        // coerce types so that we can use them
-        if (!isNaN(value) && !isNaN(field)) {
-            value = parseFloat(value);
-            field = parseFloat(field);
-        }
-        else if (!isNaN(Date.parse(value)) && !isNaN(Date.parse(field))) {
-            value = Date.parse(value);
-            field = Date.parse(field);
-        }
-        let success = false;
-        if (typeof field !== "object" && typeof value !== "object") {
-            switch (condition) {
-                case FilterConditions.EQUAL:
-                    success = field === value;
-                    break;
-                case FilterConditions.NOT_EQUAL:
-                    success = field !== value;
-                    break;
-                case FilterConditions.GREATER_THAN:
-                    success = field > value;
-                    break;
-                case FilterConditions.LESS_THAN:
-                    success = field < value;
-                    break;
+        try {
+            let { field, condition, value } = inputs;
+            // coerce types so that we can use them
+            if (!isNaN(value) && !isNaN(field)) {
+                value = parseFloat(value);
+                field = parseFloat(field);
+            }
+            else if (!isNaN(Date.parse(value)) && !isNaN(Date.parse(field))) {
+                value = Date.parse(value);
+                field = Date.parse(field);
+            }
+            let result = false;
+            if (typeof field !== "object" && typeof value !== "object") {
+                switch (condition) {
+                    case FilterConditions.EQUAL:
+                        result = field === value;
+                        break;
+                    case FilterConditions.NOT_EQUAL:
+                        result = field !== value;
+                        break;
+                    case FilterConditions.GREATER_THAN:
+                        result = field > value;
+                        break;
+                    case FilterConditions.LESS_THAN:
+                        result = field < value;
+                        break;
+                }
+            }
+            else {
+                result = false;
             }
+            return { success: true, result };
         }
-        else {
-            success = false;
+        catch (err) {
+            return { success: false, result: false };
         }
-        return { success };
     });
 };

package/dist/automations/triggers.js

@@ -95,7 +95,7 @@ exports.externalTrigger = function (automation, params, { getResponses } = {}) {
             // values are likely to be submitted as strings, so we shall convert to correct type
             const coercedFields = {};
             const fields = automation.definition.trigger.inputs.fields;
-            for (let key of Object.keys(fields)) {
+            for (let key of Object.keys(fields || {})) {
                 coercedFields[key] = coerce(params.fields[key], fields[key]);
             }
             params.fields = coercedFields;

package/dist/db/linkedRows/index.js

@@ -56,6 +56,7 @@ function getLinksForRows(rows) {
         // have to get unique as the previous table query can
         // return duplicates, could be querying for both tables in a relation
         return getUniqueByProp(responses
+            .filter(el => el != null)
             // create a unique ID which we can use for getting only unique ones
             .map(el => (Object.assign(Object.assign({}, el), { unique: el.id + el.thisId + el.fieldName }))), "unique");
     });

package/dist/db/utils.js

@@ -1,39 +1,13 @@
 "use strict";
 const newid = require("./newid");
-const { DocumentTypes: CoreDocTypes, getRoleParams, generateRoleID, APP_DEV_PREFIX, APP_PREFIX, SEPARATOR, StaticDatabases, isDevAppID, isProdAppID, getDevelopmentAppID, generateAppID, } = require("@budibase/backend-core/db");
+const { DocumentTypes: CoreDocTypes, getRoleParams, generateRoleID, APP_DEV_PREFIX, APP_PREFIX, SEPARATOR, StaticDatabases, isDevAppID, isProdAppID, getDevelopmentAppID, generateAppID, getQueryIndex, ViewNames, } = require("@budibase/backend-core/db");
 const UNICODE_MAX = "\ufff0";
 const AppStatus = {
     DEV: "development",
     ALL: "all",
     DEPLOYED: "published",
 };
-const DocumentTypes = {
-    APP: CoreDocTypes.APP,
-    DEV: CoreDocTypes.DEV,
-    APP_DEV: CoreDocTypes.APP_DEV,
-    APP_METADATA: CoreDocTypes.APP_METADATA,
-    ROLE: CoreDocTypes.ROLE,
-    TABLE: "ta",
-    ROW: "ro",
-    USER: "us",
-    AUTOMATION: "au",
-    LINK: "li",
-    WEBHOOK: "wh",
-    INSTANCE: "inst",
-    LAYOUT: "layout",
-    SCREEN: "screen",
-    DATASOURCE: "datasource",
-    DATASOURCE_PLUS: "datasource_plus",
-    QUERY: "query",
-    DEPLOYMENTS: "deployments",
-    METADATA: "metadata",
-    MEM_VIEW: "view",
-    USER_FLAG: "flag",
-};
-const ViewNames = {
-    LINK: "by_link",
-    ROUTING: "screen_routes",
-};
+const DocumentTypes = Object.assign(Object.assign({}, CoreDocTypes), { TABLE: "ta", ROW: "ro", USER: "us", AUTOMATION: "au", LINK: "li", WEBHOOK: "wh", INSTANCE: "inst", LAYOUT: "layout", SCREEN: "screen", DATASOURCE: "datasource", DATASOURCE_PLUS: "datasource_plus", QUERY: "query", DEPLOYMENTS: "deployments", METADATA: "metadata", MEM_VIEW: "view", USER_FLAG: "flag" });
 const InternalTables = {
     USER_METADATA: "ta_users",
 };
@@ -54,6 +28,7 @@ exports.isDevAppID = isDevAppID;
 exports.isProdAppID = isProdAppID;
 exports.USER_METDATA_PREFIX = `${DocumentTypes.ROW}${SEPARATOR}${InternalTables.USER_METADATA}${SEPARATOR}`;
 exports.LINK_USER_METADATA_PREFIX = `${DocumentTypes.LINK}${SEPARATOR}${InternalTables.USER_METADATA}${SEPARATOR}`;
+exports.TABLE_ROW_PREFIX = `${DocumentTypes.ROW}${SEPARATOR}${DocumentTypes.TABLE}`;
 exports.ViewNames = ViewNames;
 exports.InternalTables = InternalTables;
 exports.DocumentTypes = DocumentTypes;
@@ -66,9 +41,7 @@ exports.generateAppID = generateAppID;
 exports.generateDevAppID = getDevelopmentAppID;
 exports.generateRoleID = generateRoleID;
 exports.getRoleParams = getRoleParams;
-exports.getQueryIndex = viewName => {
-    return `database/${viewName}`;
-};
+exports.getQueryIndex = getQueryIndex;
 /**
  * If creating DB allDocs/query params with only a single top level ID this can be used, this
  * is usually the case as most of our docs are top level e.g. tables, automations, users and so on.

package/dist/definitions/datasource.js

@@ -52,6 +52,7 @@ var SourceNames;
     SourceNames["GOOGLE_SHEETS"] = "GOOGLE_SHEETS";
     SourceNames["FIRESTORE"] = "FIRESTORE";
     SourceNames["REDIS"] = "REDIS";
+    SourceNames["SNOWFLAKE"] = "SNOWFLAKE";
 })(SourceNames = exports.SourceNames || (exports.SourceNames = {}));
 var IncludeRelationships;
 (function (IncludeRelationships) {

package/dist/environment.js

@@ -62,10 +62,13 @@ module.exports = {
     DYNAMO_ENDPOINT: process.env.DYNAMO_ENDPOINT,
     QUERY_THREAD_TIMEOUT: parseIntSafe(process.env.QUERY_THREAD_TIMEOUT),
     SQL_MAX_ROWS: process.env.SQL_MAX_ROWS,
+    BB_ADMIN_USER_EMAIL: process.env.BB_ADMIN_USER_EMAIL,
+    BB_ADMIN_USER_PASSWORD: process.env.BB_ADMIN_USER_PASSWORD,
     // flags
     ALLOW_DEV_AUTOMATIONS: process.env.ALLOW_DEV_AUTOMATIONS,
     DISABLE_THREADING: process.env.DISABLE_THREADING,
     DISABLE_DEVELOPER_LICENSE: process.env.DISABLE_DEVELOPER_LICENSE,
+    DISABLE_AUTOMATION_LOGS: process.env.DISABLE_AUTOMATION_LOGS,
     MULTI_TENANCY: process.env.MULTI_TENANCY,
     ENABLE_ANALYTICS: process.env.ENABLE_ANALYTICS,
     SELF_HOSTED: process.env.SELF_HOSTED,

package/dist/integrations/airtable.js

@@ -17,6 +17,7 @@ var AirtableModule;
         docs: "https://airtable.com/api",
         description: "Airtable is a spreadsheet-database hybrid, with the features of a database but applied to a spreadsheet.",
         friendlyName: "Airtable",
+        type: "Spreadsheet",
         datasource: {
             apiKey: {
                 type: datasource_1.DatasourceFieldTypes.PASSWORD,

package/dist/integrations/arangodb.js

@@ -16,6 +16,7 @@ var ArangoModule;
     const SCHEMA = {
         docs: "https://github.com/arangodb/arangojs",
         friendlyName: "ArangoDB",
+        type: "Non-relational",
         description: "ArangoDB is a scalable open-source multi-model database natively supporting graph, document and search. All supported data models & access patterns can be combined in queries allowing for maximal flexibility. ",
         datasource: {
             url: {

package/dist/integrations/base/sql.js

@@ -89,6 +89,25 @@ function parseFilters(filters) {
     }
     return filters;
 }
+function generateSelectStatement(json, knex) {
+    var _a;
+    const { resource, meta } = json;
+    const schema = (_a = meta === null || meta === void 0 ? void 0 : meta.table) === null || _a === void 0 ? void 0 : _a.schema;
+    return resource.fields.map(field => {
+        const fieldNames = field.split(/\./g);
+        const tableName = fieldNames[0];
+        const columnName = fieldNames[1];
+        if (columnName &&
+            (schema === null || schema === void 0 ? void 0 : schema[columnName]) &&
+            knex.client.config.client === utils_1.SqlClients.POSTGRES) {
+            const externalType = schema[columnName].externalType;
+            if (externalType === null || externalType === void 0 ? void 0 : externalType.includes("money")) {
+                return knex.raw(`"${tableName}"."${columnName}"::money::numeric as "${field}"`);
+            }
+        }
+        return `${field} as ${field}`;
+    });
+}
 class InternalBuilder {
     constructor(client) {
         this.client = client;
@@ -209,7 +228,7 @@ class InternalBuilder {
         }
         return query;
     }
-    addRelationships(knex, query, fields, fromTable, relationships) {
+    addRelationships(query, fromTable, relationships) {
         if (!relationships) {
             return query;
         }
@@ -311,7 +330,7 @@ class InternalBuilder {
         if (resource.fields && resource.fields.length > 0) {
             // select the resources as the format "table.columnName" - this is what is provided
             // by the resource builder further up
-            selectStatement = resource.fields.map(field => `${field} as ${field}`);
+            selectStatement = generateSelectStatement(json, knex);
         }
         let foundLimit = limit || BASE_LIMIT;
         // handle pagination
@@ -347,7 +366,7 @@ class InternalBuilder {
             preQuery = this.addSorting(preQuery, json);
         }
         // handle joins
-        query = this.addRelationships(knex, preQuery, selectStatement, tableName, relationships);
+        query = this.addRelationships(preQuery, tableName, relationships);
         return this.addFilters(query, filters, { relationship: true });
     }
     update(knex, json, opts) {

package/dist/integrations/couchdb.js

@@ -16,6 +16,7 @@ var CouchDBModule;
     const SCHEMA = {
         docs: "https://docs.couchdb.org/en/stable/",
         friendlyName: "CouchDB",
+        type: "Non-relational",
         description: "Apache CouchDB is an open-source document-oriented NoSQL database, implemented in Erlang.",
         datasource: {
             url: {

package/dist/integrations/dynamodb.js

@@ -18,6 +18,7 @@ var DynamoModule;
         docs: "https://github.com/dabit3/dynamodb-documentclient-cheat-sheet",
         description: "Amazon DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale.",
         friendlyName: "DynamoDB",
+        type: "Non-relational",
         datasource: {
             region: {
                 type: datasource_1.DatasourceFieldTypes.STRING,

package/dist/integrations/elasticsearch.js

@@ -17,6 +17,7 @@ var ElasticsearchModule;
         docs: "https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html",
         description: "Elasticsearch is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents.",
         friendlyName: "ElasticSearch",
+        type: "Non-relational",
         datasource: {
             url: {
                 type: datasource_1.DatasourceFieldTypes.STRING,

package/dist/integrations/firebase.js

@@ -16,6 +16,7 @@ var Firebase;
     const SCHEMA = {
         docs: "https://firebase.google.com/docs/firestore/quickstart",
         friendlyName: "Firestore",
+        type: "Non-relational",
         description: "Cloud Firestore is a flexible, scalable database for mobile, web, and server development from Firebase and Google Cloud.",
         datasource: {
             email: {

package/dist/integrations/googlesheets.js

@@ -33,6 +33,7 @@ var GoogleSheetsModule;
         docs: "https://developers.google.com/sheets/api/quickstart/nodejs",
         description: "Create and collaborate on online spreadsheets in real-time and from any device. ",
         friendlyName: "Google Sheets",
+        type: "Spreadsheet",
         datasource: {
             spreadsheetId: {
                 display: "Google Sheet URL",

package/dist/integrations/index.js

@@ -13,6 +13,7 @@ const rest = require("./rest");
 const googlesheets = require("./googlesheets");
 const firebase = require("./firebase");
 const redis = require("./redis");
+const snowflake = require("./snowflake");
 const { SourceNames } = require("../definitions/datasource");
 const environment = require("../environment");
 const DEFINITIONS = {
@@ -29,6 +30,7 @@ const DEFINITIONS = {
     [SourceNames.REST]: rest.schema,
     [SourceNames.FIRESTORE]: firebase.schema,
     [SourceNames.REDIS]: redis.schema,
+    [SourceNames.SNOWFLAKE]: snowflake.schema,
 };
 const INTEGRATIONS = {
     [SourceNames.POSTGRES]: postgres.integration,
@@ -45,6 +47,8 @@ const INTEGRATIONS = {
     [SourceNames.FIRESTORE]: firebase.integration,
     [SourceNames.GOOGLE_SHEETS]: googlesheets.integration,
     [SourceNames.REDIS]: redis.integration,
+    [SourceNames.FIREBASE]: firebase.integration,
+    [SourceNames.SNOWFLAKE]: snowflake.integration,
 };
 // optionally add oracle integration if the oracle binary can be installed
 if (!(process.arch === "arm64" && process.platform === "darwin")) {

package/dist/integrations/microsoftSqlServer.js

@@ -21,6 +21,7 @@ var MSSQLModule;
         plus: true,
         description: "Microsoft SQL Server is a relational database management system developed by Microsoft. ",
         friendlyName: "MS SQL Server",
+        type: "Relational",
         datasource: {
             user: {
                 type: datasource_1.DatasourceFieldTypes.STRING,
@@ -201,7 +202,7 @@ var MSSQLModule;
                         if (typeof name !== "string") {
                             continue;
                         }
-                        schema[name] = Object.assign({ autocolumn: !!autoColumns.find((col) => col === name), name: name }, (0, utils_1.convertSqlType)(def.DATA_TYPE));
+                        schema[name] = Object.assign(Object.assign({ autocolumn: !!autoColumns.find((col) => col === name), name: name }, (0, utils_1.convertSqlType)(def.DATA_TYPE)), { externalType: def.DATA_TYPE });
                     }
                     tables[tableName] = {
                         _id: (0, utils_1.buildExternalTableId)(datasourceId, tableName),

package/dist/integrations/mongodb.js

@@ -16,6 +16,7 @@ var MongoDBModule;
     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: {

package/dist/integrations/mysql.js

@@ -24,6 +24,7 @@ var MySQLModule;
         docs: "https://github.com/sidorares/node-mysql2",
         plus: true,
         friendlyName: "MySQL",
+        type: "Relational",
         description: "MySQL Database Service is a fully managed database service to deploy cloud-native applications. ",
         datasource: {
             host: {
@@ -187,7 +188,7 @@ var MySQLModule;
                             const isAuto = typeof column.Extra === "string" &&
                                 (column.Extra === "auto_increment" ||
                                     column.Extra.toLowerCase().includes("generated"));
-                            schema[columnName] = Object.assign({ name: columnName, autocolumn: isAuto, constraints }, (0, utils_1.convertSqlType)(column.Type));
+                            schema[columnName] = Object.assign(Object.assign({ name: columnName, autocolumn: isAuto, constraints }, (0, utils_1.convertSqlType)(column.Type)), { externalType: column.Type });
                         }
                         if (!tables[tableName]) {
                             tables[tableName] = {

package/dist/integrations/oracle.js

@@ -24,6 +24,7 @@ var OracleModule;
         docs: "https://github.com/oracle/node-oracledb",
         plus: true,
         friendlyName: "Oracle",
+        type: "Relational",
         description: "Oracle Database is an object-relational database management system developed by Oracle Corporation",
         datasource: {
             host: {

package/dist/integrations/postgres.js

@@ -29,6 +29,7 @@ var PostgresModule;
         docs: "https://node-postgres.com",
         plus: true,
         friendlyName: "PostgreSQL",
+        type: "Relational",
         description: "PostgreSQL, also known as Postgres, is a free and open-source relational database management system emphasizing extensibility and SQL compliance.",
         datasource: {
             host: {
@@ -229,7 +230,7 @@ var PostgresModule;
                             column.column_default.startsWith("nextval");
                         const isGenerated = column.is_generated && column.is_generated !== "NEVER";
                         const isAuto = hasDefault || identity || isGenerated;
-                        tables[tableName].schema[columnName] = Object.assign({ autocolumn: isAuto, name: columnName }, (0, utils_1.convertSqlType)(column.data_type));
+                        tables[tableName].schema[columnName] = Object.assign(Object.assign({ autocolumn: isAuto, name: columnName }, (0, utils_1.convertSqlType)(column.data_type)), { externalType: column.data_type });
                     }
                     const final = (0, utils_1.finaliseExternalTables)(tables, entities);
                     this.tables = final.tables;

package/dist/integrations/queries/sql.js

@@ -5,6 +5,9 @@ const string_templates_1 = require("@budibase/string-templates");
 const CONST_CHAR_REGEX = new RegExp("'[^']*'", "g");
 function enrichQueryFields(fields, parameters = {}) {
     const enrichedQuery = Array.isArray(fields) ? [] : {};
+    if (!fields || !parameters) {
+        return enrichedQuery;
+    }
     // enrich the fields with dynamic parameters
     for (let key of Object.keys(fields)) {
         if (fields[key] == null) {

package/dist/integrations/redis.js

@@ -20,6 +20,7 @@ var RedisModule;
         docs: "https://redis.io/docs/",
         description: "",
         friendlyName: "Redis",
+        type: "Non-relational",
         datasource: {
             host: {
                 type: "string",

package/dist/integrations/rest.js

@@ -56,6 +56,7 @@ var RestModule;
         docs: "https://github.com/node-fetch/node-fetch",
         description: "With the REST API datasource, you can connect, query and pull data from multiple REST APIs. You can then use the retrieved data to build apps.",
         friendlyName: "REST API",
+        type: "API",
         datasource: {
             url: {
                 type: datasource_1.DatasourceFieldTypes.STRING,
@@ -251,7 +252,7 @@ var RestModule;
                     input.body = form;
                     break;
                 case BodyTypes.XML:
-                    if (object != null) {
+                    if (object != null && Object.keys(object).length) {
                         string = new XmlBuilder().buildObject(object);
                     }
                     input.body = string;

package/dist/integrations/s3.js

@@ -17,6 +17,7 @@ var S3Module;
         docs: "https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html",
         description: "Amazon Simple Storage Service (Amazon S3) is an object storage service that offers industry-leading scalability, data availability, security, and performance.",
         friendlyName: "Amazon S3",
+        type: "Object store",
         datasource: {
             region: {
                 type: "string",

package/dist/integrations/snowflake.js

@@ -0,0 +1,102 @@
+"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 snowflake_promise_1 = require("snowflake-promise");
+var SnowflakeModule;
+(function (SnowflakeModule) {
+    const SCHEMA = {
+        docs: "https://developers.snowflake.com/",
+        description: "Snowflake is a solution for data warehousing, data lakes, data engineering, data science, data application development, and securely sharing and consuming shared data.",
+        friendlyName: "Snowflake",
+        type: "Relational",
+        datasource: {
+            account: {
+                type: "string",
+                required: true,
+            },
+            username: {
+                type: "string",
+                required: true,
+            },
+            password: {
+                type: "password",
+                required: true,
+            },
+            warehouse: {
+                type: "string",
+                required: true,
+            },
+            database: {
+                type: "string",
+                required: true,
+            },
+            schema: {
+                type: "string",
+                required: true,
+            },
+        },
+        query: {
+            create: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            read: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            update: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            delete: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+        },
+    };
+    class SnowflakeIntegration {
+        constructor(config) {
+            this.client = new snowflake_promise_1.Snowflake(config);
+        }
+        internalQuery(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.client.connect();
+                try {
+                    return yield this.client.execute(query.sql);
+                }
+                catch (err) {
+                    throw (err === null || err === void 0 ? void 0 : err.message.split(":")[1]) || (err === null || err === void 0 ? void 0 : err.message);
+                }
+            });
+        }
+        create(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.internalQuery(query);
+            });
+        }
+        read(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.internalQuery(query);
+            });
+        }
+        update(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.internalQuery(query);
+            });
+        }
+        delete(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.internalQuery(query);
+            });
+        }
+    }
+    module.exports = {
+        schema: SCHEMA,
+        integration: SnowflakeIntegration,
+    };
+})(SnowflakeModule || (SnowflakeModule = {}));