@budibase/server 2.1.44 → 2.1.46-alpha.0

package/src/db/views/{staticViews.js → staticViews.ts}

@@ -1,5 +1,6 @@
-const { getAppDB } = require("@budibase/backend-core/context")
-const { DocumentType, SEPARATOR, ViewName, SearchIndexes } = require("../utils")
+import { context } from "@budibase/backend-core"
+import { DocumentType, SEPARATOR, ViewName, SearchIndexes } from "../utils"
+import { LinkDocument, Row } from "@budibase/types"
 const SCREEN_PREFIX = DocumentType.SCREEN + SEPARATOR
 
 /**************************************************
@@ -19,16 +20,17 @@ const SCREEN_PREFIX = DocumentType.SCREEN + SEPARATOR
  * @returns {Promise<void>} The view now exists, please note that the next view of this query will actually build it,
  * so it may be slow.
  */
-exports.createLinkView = async () => {
-  const db = getAppDB()
+export async function createLinkView() {
+  const db = context.getAppDB()
   const designDoc = await db.get("_design/database")
   const view = {
-    map: function (doc) {
+    map: function (doc: LinkDocument) {
       // everything in this must remain constant as its going to Pouch, no external variables
       if (doc.type === "link") {
         let doc1 = doc.doc1
         let doc2 = doc.doc2
         // eslint-disable-next-line no-undef
+        // @ts-ignore
         emit([doc1.tableId, doc1.rowId], {
           id: doc2.rowId,
           thisId: doc1.rowId,
@@ -37,6 +39,7 @@ exports.createLinkView = async () => {
         // if linking to same table can't emit twice
         if (doc1.tableId !== doc2.tableId) {
           // eslint-disable-next-line no-undef
+          // @ts-ignore
           emit([doc2.tableId, doc2.rowId], {
             id: doc1.rowId,
             thisId: doc2.rowId,
@@ -53,8 +56,8 @@ exports.createLinkView = async () => {
   await db.put(designDoc)
 }
 
-exports.createRoutingView = async () => {
-  const db = getAppDB()
+export async function createRoutingView() {
+  const db = context.getAppDB()
   const designDoc = await db.get("_design/database")
   const view = {
     // if using variables in a map function need to inject them before use
@@ -74,8 +77,8 @@ exports.createRoutingView = async () => {
   await db.put(designDoc)
 }
 
-async function searchIndex(indexName, fnString) {
-  const db = getAppDB()
+async function searchIndex(indexName: string, fnString: string) {
+  const db = context.getAppDB()
   const designDoc = await db.get("_design/database")
   designDoc.indexes = {
     [indexName]: {
@@ -86,11 +89,11 @@ async function searchIndex(indexName, fnString) {
   await db.put(designDoc)
 }
 
-exports.createAllSearchIndex = async () => {
+export async function createAllSearchIndex() {
   await searchIndex(
     SearchIndexes.ROWS,
-    function (doc) {
-      function idx(input, prev) {
+    function (doc: Row) {
+      function idx(input: Row, prev?: string) {
         for (let key of Object.keys(input)) {
           let idxKey = prev != null ? `${prev}.${key}` : key
           idxKey = idxKey.replace(/ /g, "_")
@@ -98,6 +101,7 @@ exports.createAllSearchIndex = async () => {
             for (let val of input[key]) {
               if (typeof val !== "object") {
                 // eslint-disable-next-line no-undef
+                // @ts-ignore
                 index(idxKey, val, { store: true })
               }
             }
@@ -106,17 +110,20 @@ exports.createAllSearchIndex = async () => {
           }
           if (typeof input[key] === "string") {
             // eslint-disable-next-line no-undef
+            // @ts-ignore
             index(idxKey, input[key].toLowerCase(), { store: true })
           } else if (typeof input[key] !== "object") {
             // eslint-disable-next-line no-undef
+            // @ts-ignore
             index(idxKey, input[key], { store: true })
           } else {
             idx(input[key], idxKey)
           }
         }
       }
-      if (doc._id.startsWith("ro_")) {
+      if (doc._id!.startsWith("ro_")) {
         // eslint-disable-next-line no-undef
+        // @ts-ignore
         index("default", doc._id)
         idx(doc)
       }

package/src/{environment.js → environment.ts}

@@ -1,4 +1,4 @@
-const { join } = require("path")
+import { join } from "path"
 
 function isTest() {
   return isCypress() || isJest()
@@ -28,7 +28,7 @@ if (!LOADED && isDev() && !isTest()) {
   LOADED = true
 }
 
-function parseIntSafe(number) {
+function parseIntSafe(number?: string) {
   if (number) {
     return parseInt(number)
   }
@@ -36,7 +36,7 @@ function parseIntSafe(number) {
 
 let inThread = false
 
-module.exports = {
+const environment = {
   // important - prefer app port to generic port
   PORT: process.env.APP_PORT || process.env.PORT,
   JWT_SECRET: process.env.JWT_SECRET,
@@ -86,9 +86,10 @@ module.exports = {
   SELF_HOSTED: process.env.SELF_HOSTED,
   // old
   CLIENT_ID: process.env.CLIENT_ID,
-  _set(key, value) {
+  _set(key: string, value: any) {
     process.env[key] = value
-    module.exports[key] = value
+    // @ts-ignore
+    environment[key] = value
   },
   isTest,
   isJest,
@@ -108,13 +109,16 @@ module.exports = {
 
 // threading can cause memory issues with node-ts in development
 if (isDev() && module.exports.DISABLE_THREADING == null) {
-  module.exports._set("DISABLE_THREADING", "1")
+  environment._set("DISABLE_THREADING", "1")
 }
 
 // clean up any environment variable edge cases
 for (let [key, value] of Object.entries(module.exports)) {
   // handle the edge case of "0" to disable an environment variable
   if (value === "0") {
-    module.exports[key] = 0
+    // @ts-ignore
+    environment[key] = 0
   }
 }
+
+export = environment

package/src/events/{AutomationEmitter.js → AutomationEmitter.ts}

@@ -1,6 +1,7 @@
-const { rowEmission, tableEmission } = require("./utils")
-const mainEmitter = require("./index")
-const env = require("../environment")
+import { rowEmission, tableEmission } from "./utils"
+import mainEmitter from "./index"
+import env from "../environment"
+import { Table, Row } from "@budibase/types"
 
 // max number of automations that can chain on top of each other
 // TODO: in future make this configurable at the automation level
@@ -13,14 +14,17 @@ const MAX_AUTOMATION_CHAIN = env.SELF_HOSTED ? 5 : 0
  * from getting stuck endlessly chaining.
  */
 class AutomationEmitter {
-  constructor(chainCount) {
+  chainCount: number
+  metadata: { automationChainCount: number }
+
+  constructor(chainCount: number) {
     this.chainCount = chainCount
     this.metadata = {
       automationChainCount: chainCount,
     }
   }
 
-  emitRow(eventName, appId, row, table = null) {
+  emitRow(eventName: string, appId: string, row: Row, table?: Table) {
     // don't emit even if we've reached max automation chain
     if (this.chainCount >= MAX_AUTOMATION_CHAIN) {
       return
@@ -35,11 +39,12 @@ class AutomationEmitter {
     })
   }
 
-  emitTable(eventName, appId, table = null) {
+  emitTable(eventName: string, appId: string, table?: Table) {
     // don't emit even if we've reached max automation chain
     if (this.chainCount > MAX_AUTOMATION_CHAIN) {
       return
     }
+
     tableEmission({
       emitter: mainEmitter,
       eventName,
@@ -50,4 +55,4 @@ class AutomationEmitter {
   }
 }
 
-module.exports = AutomationEmitter
+export = AutomationEmitter

package/src/events/{index.js → BudibaseEmitter.ts}

@@ -1,5 +1,6 @@
-const EventEmitter = require("events").EventEmitter
-const { rowEmission, tableEmission } = require("./utils")
+import { EventEmitter } from "events"
+import { rowEmission, tableEmission } from "./utils"
+import { Table, Row } from "@budibase/types"
 
 /**
  * keeping event emitter in one central location as it might be used for things other than
@@ -12,19 +13,17 @@ const { rowEmission, tableEmission } = require("./utils")
  * This is specifically quite important for template strings used in automations.
  */
 class BudibaseEmitter extends EventEmitter {
-  emitRow(eventName, appId, row, table = null) {
+  emitRow(eventName: string, appId: string, row: Row, table?: Table) {
     rowEmission({ emitter: this, eventName, appId, row, table })
   }
 
-  emitTable(eventName, appId, table = null) {
+  emitTable(eventName: string, appId: string, table?: Table) {
     tableEmission({ emitter: this, eventName, appId, table })
   }
 
-  emitPort(portNumber) {
+  emitPort(portNumber?: number | string) {
     this.emit("internal:port", portNumber)
   }
 }
 
-const emitter = new BudibaseEmitter()
-
-module.exports = emitter
+export = BudibaseEmitter

package/src/events/index.ts

@@ -0,0 +1,5 @@
+import BudibaseEmitter from "./BudibaseEmitter"
+
+const emitter = new BudibaseEmitter()
+
+export = emitter

package/src/events/utils.ts

@@ -0,0 +1,78 @@
+import { Table, Row } from "@budibase/types"
+import BudibaseEmitter from "./BudibaseEmitter"
+
+type BBEventOpts = {
+  emitter: BudibaseEmitter
+  eventName: string
+  appId: string
+  table?: Table
+  row?: Row
+  metadata?: any
+}
+
+interface BBEventTable extends Table {
+  tableId?: string
+}
+
+type BBEvent = {
+  appId: string
+  tableId?: string
+  row?: Row
+  table?: BBEventTable
+  id?: string
+  revision?: string
+  metadata?: any
+}
+
+export function rowEmission({
+  emitter,
+  eventName,
+  appId,
+  row,
+  table,
+  metadata,
+}: BBEventOpts) {
+  let event: BBEvent = {
+    row,
+    appId,
+    tableId: row?.tableId,
+  }
+  if (table) {
+    event.table = table
+  }
+  event.id = row?._id
+  if (row?._rev) {
+    event.revision = row._rev
+  }
+  if (metadata) {
+    event.metadata = metadata
+  }
+  emitter.emit(eventName, event)
+}
+
+export function tableEmission({
+  emitter,
+  eventName,
+  appId,
+  table,
+  metadata,
+}: BBEventOpts) {
+  const tableId = table?._id
+  const inputTable: BBEventTable | undefined = table
+  if (inputTable) {
+    inputTable.tableId = tableId
+  }
+  let event: BBEvent = {
+    table: inputTable,
+    appId,
+    tableId: tableId,
+  }
+  event.id = tableId
+  if (table?._rev) {
+    event.revision = table._rev
+  }
+  if (metadata) {
+    event.metadata = metadata
+  }
+  emitter.emit(eventName, event)
+}

package/src/integrations/base/sql.ts

@@ -96,7 +96,7 @@ function generateSelectStatement(
 ): (string | Knex.Raw)[] {
   const { resource, meta } = json
   const schema = meta?.table?.schema
-  return resource.fields.map(field => {
+  return resource!.fields.map(field => {
     const fieldNames = field.split(/\./g)
     const tableName = fieldNames[0]
     const columnName = fieldNames[1]

package/src/integrations/base/sqlTable.ts

@@ -185,7 +185,7 @@ class SqlTableQueryBuilder {
           json.table,
           json.meta.tables,
           json.meta.table,
-          json.meta.renamed
+          json.meta.renamed!
         )
         break
       case Operation.DELETE_TABLE:

package/src/integrations/base/types.ts

@@ -0,0 +1,134 @@
+export interface MSSQLTablesResponse {
+  TABLE_CATALOG: string
+  TABLE_SCHEMA: string
+  TABLE_NAME: string
+  TABLE_TYPE: string
+}
+
+export interface MSSQLColumn {
+  IS_COMPUTED: number
+  IS_IDENTITY: number
+  TABLE_CATALOG: string
+  TABLE_SCHEMA: string
+  TABLE_NAME: string
+  COLUMN_NAME: string
+  ORDINAL_POSITION: number
+  COLUMN_DEFAULT: null | any
+  IS_NULLABLE: "NO" | "YES"
+  DATA_TYPE: string
+  CHARACTER_MAXIMUM_LENGTH: null | number
+  CHARACTER_OCTET_LENGTH: null | number
+  NUMERIC_PRECISION: null | number
+  NUMERIC_PRECISION_RADIX: null | number
+  NUMERIC_SCALE: null | number
+  DATETIME_PRECISION: null | string
+  CHARACTER_SET_CATALOG: null | string
+  CHARACTER_SET_SCHEMA: null | string
+  CHARACTER_SET_NAME: null | string
+  COLLATION_CATALOG: null | string
+  COLLATION_SCHEMA: null | string
+  COLLATION_NAME: null | string
+  DOMAIN_CATALOG: null | string
+  DOMAIN_SCHEMA: null | string
+  DOMAIN_NAME: null | string
+}
+
+export interface PostgresColumn {
+  table_catalog: string
+  table_schema: string
+  table_name: string
+  column_name: string
+  ordinal_position: number
+  column_default: null | any
+  is_nullable: "NO" | "YES"
+  data_type: string
+  character_maximum_length: null | number
+  character_octet_length: null | number
+  numeric_precision: null | number
+  numeric_precision_radix: null | number
+  numeric_scale: null | number
+  datetime_precision: null | string
+  interval_type: null | string
+  interval_precision: null | string
+  character_set_catalog: null | string
+  character_set_schema: null | string
+  character_set_name: null | string
+  collation_catalog: null | string
+  collation_schema: null | string
+  collation_name: null | string
+  domain_catalog: null | string
+  domain_schema: null | string
+  domain_name: null | string
+  udt_catalog: string
+  udt_schema: string
+  udt_name: string
+  scope_catalog: null | string
+  scope_schema: null | string
+  scope_name: null | string
+  maximum_cardinality: null | string
+  dtd_identifier: string
+  is_self_referencing: "NO" | "YES"
+  is_identity: "NO" | "YES"
+  identity_generation: null | number
+  identity_start: null | number
+  identity_increment: null | number
+  identity_maximum: null | number
+  identity_minimum: null | number
+  identity_cycle: "NO" | "YES"
+  is_generated: "NEVER"
+  generation_expression: null | string
+  is_updatable: "NO" | "YES"
+}
+
+export interface MySQLColumn {
+  Field: string
+  Type: string
+  Null: "NO" | "YES"
+  Key: "PRI" | "MUL" | ""
+  Default: null | any
+  Extra: null | string
+}
+
+/**
+ * Raw query response
+ */
+export interface OracleColumnsResponse {
+  TABLE_NAME: string
+  COLUMN_NAME: string
+  DATA_TYPE: string
+  DATA_DEFAULT: null | string
+  COLUMN_ID: number
+  CONSTRAINT_NAME: null | string
+  CONSTRAINT_TYPE: null | string
+  R_CONSTRAINT_NAME: null | string
+  SEARCH_CONDITION: null | string
+}
+
+/**
+ * An oracle constraint
+ */
+export interface OracleConstraint {
+  name: string
+  type: string
+  relatedConstraintName: null | string
+  searchCondition: null | string
+}
+
+/**
+ * An oracle column and it's related constraints
+ */
+export interface OracleColumn {
+  name: string
+  type: string
+  default: null | string
+  id: number
+  constraints: { [key: string]: OracleConstraint }
+}
+
+/**
+ * An oracle table and it's related columns
+ */
+export interface OracleTable {
+  name: string
+  columns: { [key: string]: OracleColumn }
+}

package/src/integrations/elasticsearch.ts

@@ -5,10 +5,13 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-const { Client } = require("@elastic/elasticsearch")
+import { Client, ClientOptions } from "@elastic/elasticsearch"
 
 interface ElasticsearchConfig {
   url: string
+  ssl?: boolean
+  ca?: string
+  rejectUnauthorized?: boolean
 }
 
 const SCHEMA: Integration = {
@@ -23,6 +26,21 @@ const SCHEMA: Integration = {
       required: true,
       default: "http://localhost:9200",
     },
+    ssl: {
+      type: DatasourceFieldType.BOOLEAN,
+      default: false,
+      required: false,
+    },
+    rejectUnauthorized: {
+      type: DatasourceFieldType.BOOLEAN,
+      default: true,
+      required: false,
+    },
+    ca: {
+      type: DatasourceFieldType.LONGFORM,
+      default: false,
+      required: false,
+    },
   },
   query: {
     create: {
@@ -81,7 +99,19 @@ class ElasticSearchIntegration implements IntegrationBase {
 
   constructor(config: ElasticsearchConfig) {
     this.config = config
-    this.client = new Client({ node: config.url })
+
+    const clientConfig: ClientOptions = {
+      node: this.config.url,
+    }
+
+    if (this.config.ssl) {
+      clientConfig.ssl = {
+        rejectUnauthorized: this.config.rejectUnauthorized,
+        ca: this.config.ca || undefined,
+      }
+    }
+
+    this.client = new Client(clientConfig)
   }
 
   async create(query: { index: string; json: object }) {

package/src/integrations/googlesheets.ts

@@ -12,10 +12,7 @@ import { buildExternalTableId } from "./utils"
 import { DataSourceOperation, FieldTypes } from "../constants"
 import { GoogleSpreadsheet } from "google-spreadsheet"
 import env from "../environment"
-
-const { getGlobalDB } = require("@budibase/backend-core/tenancy")
-const { getScopedConfig } = require("@budibase/backend-core/db")
-const { Configs } = require("@budibase/backend-core/constants")
+import { tenancy, db as dbCore, constants } from "@budibase/backend-core"
 const fetch = require("node-fetch")
 
 interface GoogleSheetsConfig {
@@ -176,9 +173,9 @@ class GoogleSheetsIntegration implements DatasourcePlus {
   async connect() {
     try {
       // Initialise oAuth client
-      const db = getGlobalDB()
-      let googleConfig = await getScopedConfig(db, {
-        type: Configs.GOOGLE,
+      const db = tenancy.getGlobalDB()
+      let googleConfig = await dbCore.getScopedConfig(db, {
+        type: constants.Config.GOOGLE,
       })
 
       if (!googleConfig) {
@@ -269,6 +266,7 @@ class GoogleSheetsIntegration implements DatasourcePlus {
         this.deleteTable(json?.table?.name),
     }
 
+    // @ts-ignore
     const internalQueryMethod = handlers[json.endpoint.operation]
 
     return await internalQueryMethod()

package/src/integrations/index.ts

@@ -67,50 +67,54 @@ if (
   INTEGRATIONS[SourceName.ORACLE] = oracle.integration
 }
 
-module.exports = {
-  getDefinitions: async () => {
-    const pluginSchemas: { [key: string]: Integration } = {}
-    if (environment.SELF_HOSTED) {
-      const plugins = await getPlugins(PluginType.DATASOURCE)
-      // extract the actual schema from each custom
-      for (let plugin of plugins) {
-        const sourceId = plugin.name
-        pluginSchemas[sourceId] = {
-          ...plugin.schema["schema"],
-          custom: true,
-        }
-        if (plugin.iconUrl) {
-          pluginSchemas[sourceId].iconUrl = plugin.iconUrl
-        }
+export async function getDefinitions() {
+  const pluginSchemas: { [key: string]: Integration } = {}
+  if (environment.SELF_HOSTED) {
+    const plugins = await getPlugins(PluginType.DATASOURCE)
+    // extract the actual schema from each custom
+    for (let plugin of plugins) {
+      const sourceId = plugin.name
+      pluginSchemas[sourceId] = {
+        ...plugin.schema["schema"],
+        custom: true,
+      }
+      if (plugin.iconUrl) {
+        pluginSchemas[sourceId].iconUrl = plugin.iconUrl
       }
     }
-    return {
-      ...cloneDeep(DEFINITIONS),
-      ...pluginSchemas,
-    }
-  },
-  getIntegration: async (integration: string) => {
-    if (INTEGRATIONS[integration]) {
-      return INTEGRATIONS[integration]
-    }
-    if (environment.SELF_HOSTED) {
-      const plugins = await getPlugins(PluginType.DATASOURCE)
-      for (let plugin of plugins) {
-        if (plugin.name === integration) {
-          // need to use commonJS require due to its dynamic runtime nature
-          const retrieved: any = await getDatasourcePlugin(
-            plugin.name,
-            plugin.jsUrl,
-            plugin.schema?.hash
-          )
-          if (retrieved.integration) {
-            return retrieved.integration
-          } else {
-            return retrieved
-          }
+  }
+  return {
+    ...cloneDeep(DEFINITIONS),
+    ...pluginSchemas,
+  }
+}
+
+export async function getIntegration(integration: string) {
+  if (INTEGRATIONS[integration]) {
+    return INTEGRATIONS[integration]
+  }
+  if (environment.SELF_HOSTED) {
+    const plugins = await getPlugins(PluginType.DATASOURCE)
+    for (let plugin of plugins) {
+      if (plugin.name === integration) {
+        // need to use commonJS require due to its dynamic runtime nature
+        const retrieved: any = await getDatasourcePlugin(
+          plugin.name,
+          plugin.jsUrl,
+          plugin.schema?.hash
+        )
+        if (retrieved.integration) {
+          return retrieved.integration
+        } else {
+          return retrieved
         }
       }
     }
-    throw new Error("No datasource implementation found.")
-  },
+  }
+  throw new Error("No datasource implementation found.")
+}
+
+export default {
+  getDefinitions,
+  getIntegration,
 }