@budibase/server 1.0.218 → 1.0.219-alpha.0

package/src/automations/automationUtils.js

@@ -1,5 +1,10 @@
 const { getTable } = require("../api/controllers/table/utils")
-const { findHBSBlocks } = require("@budibase/string-templates")
+const {
+  findHBSBlocks,
+  decodeJSBinding,
+  isJSBinding,
+  encodeJSBinding,
+} = require("@budibase/string-templates")
 
 /**
  * When values are input to the system generally they will be of type string as this is required for template strings.
@@ -77,11 +82,21 @@ exports.getError = err => {
 }
 
 exports.substituteLoopStep = (hbsString, substitute) => {
-  let blocks = findHBSBlocks(hbsString)
+  let blocks = []
+  let checkForJS = isJSBinding(hbsString)
+  if (checkForJS) {
+    hbsString = decodeJSBinding(hbsString)
+    blocks.push(hbsString)
+  } else {
+    blocks = findHBSBlocks(hbsString)
+  }
   for (let block of blocks) {
-    let oldBlock = block
     block = block.replace(/loop/, substitute)
-    hbsString = hbsString.replace(new RegExp(oldBlock, "g"), block)
+    if (checkForJS) {
+      hbsString = encodeJSBinding(block)
+    } else {
+      hbsString = block
+    }
   }
 
   return hbsString

package/src/automations/logging/index.ts

@@ -0,0 +1,35 @@
+import * as env from "../../environment"
+import { AutomationResults, Automation, App } from "@budibase/types"
+import { automations } from "@budibase/pro"
+import { db as dbUtils } from "@budibase/backend-core"
+
+export async function storeLog(
+  automation: Automation,
+  results: AutomationResults
+) {
+  // can disable this if un-needed in self-host, also only do this for prod apps
+  if (env.DISABLE_AUTOMATION_LOGS) {
+    return
+  }
+  await automations.logs.storeLog(automation, results)
+}
+
+export async function checkAppMetadata(apps: App[]) {
+  const maxStartDate = await 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(dbUtils.SEPARATOR)[2]
+        if (startDate > maxStartDate) {
+          updated.push(error)
+        }
+      }
+      metadata.automationErrors[key] = updated
+    }
+  }
+  return apps
+}

package/src/automations/steps/filter.js

@@ -50,43 +50,51 @@ 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 = async function filter({ inputs }) {
-  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
     }
-  } else {
-    success = false
+    return { success: true, result }
+  } catch (err) {
+    return { success: false, result: false }
   }
-  return { success }
 }

package/src/automations/tests/filter.spec.js

@@ -6,7 +6,8 @@ describe("test the filter logic", () => {
     let res = await setup.runStep(setup.actions.FILTER.stepId,
       { field, condition, value }
     )
-    expect(res.success).toEqual(pass)
+    expect(res.result).toEqual(pass)
+    expect(res.success).toEqual(true)
   }
 
   it("should be able test equality", async () => {

package/src/automations/triggers.js

@@ -97,7 +97,7 @@ exports.externalTrigger = async function (
     // 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/src/db/linkedRows/index.js

@@ -65,6 +65,7 @@ async function getLinksForRows(rows) {
   // 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 => ({ ...el, unique: el.id + el.thisId + el.fieldName })),
     "unique"

package/src/db/utils.js

@@ -11,6 +11,8 @@ const {
   isProdAppID,
   getDevelopmentAppID,
   generateAppID,
+  getQueryIndex,
+  ViewNames,
 } = require("@budibase/backend-core/db")
 
 const UNICODE_MAX = "\ufff0"
@@ -22,11 +24,7 @@ const AppStatus = {
 }
 
 const DocumentTypes = {
-  APP: CoreDocTypes.APP,
-  DEV: CoreDocTypes.DEV,
-  APP_DEV: CoreDocTypes.APP_DEV,
-  APP_METADATA: CoreDocTypes.APP_METADATA,
-  ROLE: CoreDocTypes.ROLE,
+  ...CoreDocTypes,
   TABLE: "ta",
   ROW: "ro",
   USER: "us",
@@ -45,11 +43,6 @@ const DocumentTypes = {
   USER_FLAG: "flag",
 }
 
-const ViewNames = {
-  LINK: "by_link",
-  ROUTING: "screen_routes",
-}
-
 const InternalTables = {
   USER_METADATA: "ta_users",
 }
@@ -74,6 +67,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
@@ -88,9 +82,7 @@ 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

package/src/definitions/common.ts

@@ -12,6 +12,7 @@ export interface Application extends Base {
 export interface FieldSchema {
   // TODO: replace with field types enum when done
   type: string
+  externalType?: string
   fieldName?: string
   name: string
   tableId?: string

package/src/definitions/datasource.ts

@@ -50,6 +50,7 @@ export enum SourceNames {
   GOOGLE_SHEETS = "GOOGLE_SHEETS",
   FIRESTORE = "FIRESTORE",
   REDIS = "REDIS",
+  SNOWFLAKE = "SNOWFLAKE",
 }
 
 export enum IncludeRelationships {
@@ -93,6 +94,7 @@ export interface Integration {
   relationships?: boolean
   description: string
   friendlyName: string
+  type?: string
   datasource: {}
   query: {
     [key: string]: QueryDefinition

package/src/environment.js

@@ -78,6 +78,7 @@ module.exports = {
   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/src/integrations/airtable.ts

@@ -18,6 +18,7 @@ module AirtableModule {
     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: DatasourceFieldTypes.PASSWORD,

package/src/integrations/arangodb.ts

@@ -19,6 +19,7 @@ module ArangoModule {
   const SCHEMA: Integration = {
     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: {

package/src/integrations/base/sql.ts

@@ -89,6 +89,28 @@ function parseFilters(filters: SearchFilters | undefined): SearchFilters {
   return filters
 }
 
+function generateSelectStatement(
+  json: QueryJson,
+  knex: Knex
+): (string | Knex.Raw)[] {
+  const { resource, meta } = json
+  const schema = meta?.table?.schema
+  return resource.fields.map(field => {
+    const fieldNames = field.split(/\./g)
+    const tableName = fieldNames[0]
+    const columnName = fieldNames[1]
+    if (columnName && knex.client.config.client === SqlClients.POSTGRES) {
+      const externalType = schema?.[columnName].externalType
+      if (externalType?.includes("money")) {
+        return knex.raw(
+          `"${tableName}"."${columnName}"::money::numeric as "${field}"`
+        )
+      }
+    }
+    return `${field} as ${field}`
+  })
+}
+
 class InternalBuilder {
   private readonly client: string
 
@@ -216,9 +238,7 @@ class InternalBuilder {
   }
 
   addRelationships(
-    knex: Knex,
     query: KnexQuery,
-    fields: string | string[],
     fromTable: string,
     relationships: RelationshipsJson[] | undefined
   ): KnexQuery {
@@ -323,12 +343,12 @@ class InternalBuilder {
     if (!resource) {
       resource = { fields: [] }
     }
-    let selectStatement: string | string[] = "*"
+    let selectStatement: string | (string | Knex.Raw)[] = "*"
     // handle select
     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
@@ -363,13 +383,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 })
   }
 

package/src/integrations/couchdb.ts

@@ -16,6 +16,7 @@ module CouchDBModule {
   const SCHEMA: Integration = {
     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: {

package/src/integrations/dynamodb.ts

@@ -21,6 +21,7 @@ module DynamoModule {
     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: DatasourceFieldTypes.STRING,

package/src/integrations/elasticsearch.ts

@@ -17,6 +17,7 @@ module ElasticsearchModule {
     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: DatasourceFieldTypes.STRING,

package/src/integrations/firebase.ts

@@ -16,6 +16,7 @@ module Firebase {
   const SCHEMA: Integration = {
     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: {

package/src/integrations/googlesheets.ts

@@ -49,6 +49,7 @@ module GoogleSheetsModule {
     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/src/integrations/index.ts

@@ -12,6 +12,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")
 
@@ -29,6 +30,7 @@ const DEFINITIONS = {
   [SourceNames.REST]: rest.schema,
   [SourceNames.FIRESTORE]: firebase.schema,
   [SourceNames.REDIS]: redis.schema,
+  [SourceNames.SNOWFLAKE]: snowflake.schema,
 }
 
 const INTEGRATIONS = {
@@ -46,6 +48,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

package/src/integrations/microsoftSqlServer.ts

@@ -44,6 +44,7 @@ module MSSQLModule {
     description:
       "Microsoft SQL Server is a relational database management system developed by Microsoft. ",
     friendlyName: "MS SQL Server",
+    type: "Relational",
     datasource: {
       user: {
         type: DatasourceFieldTypes.STRING,
@@ -246,6 +247,7 @@ module MSSQLModule {
             autocolumn: !!autoColumns.find((col: string) => col === name),
             name: name,
             ...convertSqlType(def.DATA_TYPE),
+            externalType: def.DATA_TYPE,
           }
         }
         tables[tableName] = {

package/src/integrations/mongodb.ts

@@ -24,6 +24,7 @@ module MongoDBModule {
   const SCHEMA: Integration = {
     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: {

package/src/integrations/mysql.ts

@@ -36,6 +36,7 @@ module 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: {
@@ -232,6 +233,7 @@ module MySQLModule {
               autocolumn: isAuto,
               constraints,
               ...convertSqlType(column.Type),
+              externalType: column.Type,
             }
           }
           if (!tables[tableName]) {

package/src/integrations/oracle.ts

@@ -40,6 +40,7 @@ module 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: {

package/src/integrations/postgres.ts

@@ -47,6 +47,7 @@ module 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: {
@@ -271,6 +272,7 @@ module PostgresModule {
             autocolumn: isAuto,
             name: columnName,
             ...convertSqlType(column.data_type),
+            externalType: column.data_type,
           }
         }
 

package/src/integrations/queries/sql.ts

@@ -9,7 +9,9 @@ export function enrichQueryFields(
   parameters = {}
 ) {
   const enrichedQuery: { [key: string]: any } = 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/src/integrations/redis.ts

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

package/src/integrations/rest.ts

@@ -64,6 +64,7 @@ module RestModule {
     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: DatasourceFieldTypes.STRING,
@@ -286,7 +287,7 @@ module 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/src/integrations/s3.ts

@@ -17,6 +17,7 @@ module S3Module {
     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/src/integrations/snowflake.ts

@@ -0,0 +1,99 @@
+import { Integration, QueryTypes, SqlQuery } from "../definitions/datasource"
+import { Snowflake } from "snowflake-promise"
+
+module SnowflakeModule {
+  interface SnowflakeConfig {
+    account: string
+    username: string
+    password: string
+    warehouse: string
+    database: string
+    schema: string
+  }
+
+  const SCHEMA: Integration = {
+    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: QueryTypes.SQL,
+      },
+      read: {
+        type: QueryTypes.SQL,
+      },
+      update: {
+        type: QueryTypes.SQL,
+      },
+      delete: {
+        type: QueryTypes.SQL,
+      },
+    },
+  }
+
+  class SnowflakeIntegration {
+    private client: Snowflake
+
+    constructor(config: SnowflakeConfig) {
+      this.client = new Snowflake(config)
+    }
+
+    async internalQuery(query: SqlQuery) {
+      await this.client.connect()
+      try {
+        return await this.client.execute(query.sql)
+      } catch (err: any) {
+        throw err?.message.split(":")[1] || err?.message
+      }
+    }
+
+    async create(query: SqlQuery) {
+      return this.internalQuery(query)
+    }
+
+    async read(query: SqlQuery) {
+      return this.internalQuery(query)
+    }
+
+    async update(query: SqlQuery) {
+      return this.internalQuery(query)
+    }
+
+    async delete(query: SqlQuery) {
+      return this.internalQuery(query)
+    }
+  }
+
+  module.exports = {
+    schema: SCHEMA,
+    integration: SnowflakeIntegration,
+  }
+}