@budibase/server 1.0.80-alpha.3 → 1.0.80

package/src/integrations/microsoftSqlServer.ts

@@ -19,7 +19,6 @@ import { Table, TableSchema } from "../definitions/common"
 module MSSQLModule {
   const sqlServer = require("mssql")
   const Sql = require("./base/sql")
-  const DEFAULT_SCHEMA = "dbo"
 
   interface MSSQLConfig {
     user: string
@@ -27,17 +26,9 @@ module MSSQLModule {
     server: string
     port: number
     database: string
-    schema: string
     encrypt?: boolean
   }
 
-  interface TablesResponse {
-    TABLE_CATALOG: string
-    TABLE_SCHEMA: string
-    TABLE_NAME: string
-    TABLE_TYPE: string
-  }
-
   const SCHEMA: Integration = {
     docs: "https://github.com/tediousjs/node-mssql",
     plus: true,
@@ -67,10 +58,6 @@ module MSSQLModule {
         type: DatasourceFieldTypes.STRING,
         default: "root",
       },
-      schema: {
-        type: DatasourceFieldTypes.STRING,
-        default: DEFAULT_SCHEMA,
-      },
       encrypt: {
         type: DatasourceFieldTypes.BOOLEAN,
         default: true,
@@ -92,9 +79,34 @@ module MSSQLModule {
     },
   }
 
+  async function internalQuery(
+    client: any,
+    query: SqlQuery,
+    operation: string | undefined = undefined
+  ) {
+    const request = client.request()
+    try {
+      if (Array.isArray(query.bindings)) {
+        let count = 0
+        for (let binding of query.bindings) {
+          request.input(`p${count++}`, binding)
+        }
+      }
+      // this is a hack to get the inserted ID back,
+      //  no way to do this with Knex nicely
+      const sql =
+        operation === Operation.CREATE
+          ? `${query.sql}; SELECT SCOPE_IDENTITY() AS id;`
+          : query.sql
+      return await request.query(sql)
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err)
+    }
+  }
+
   class SqlServerIntegration extends Sql implements DatasourcePlus {
     private readonly config: MSSQLConfig
-    private index: number = 0
     static pool: any
     public tables: Record<string, Table> = {}
     public schemaErrors: Record<string, string> = {}
@@ -109,62 +121,6 @@ module MSSQLModule {
     TABLES_SQL =
       "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE'"
 
-    constructor(config: MSSQLConfig) {
-      super(SqlClients.MS_SQL)
-      this.config = config
-      const clientCfg = {
-        ...this.config,
-        options: {
-          encrypt: this.config.encrypt,
-          enableArithAbort: true,
-        },
-      }
-      delete clientCfg.encrypt
-      if (!this.pool) {
-        this.pool = new sqlServer.ConnectionPool(clientCfg)
-      }
-    }
-
-    getBindingIdentifier(): string {
-      return `(@p${this.index++})`
-    }
-
-    async connect() {
-      try {
-        this.client = await this.pool.connect()
-      } catch (err) {
-        // @ts-ignore
-        throw new Error(err)
-      }
-    }
-
-    async internalQuery(
-      query: SqlQuery,
-      operation: string | undefined = undefined
-    ) {
-      const client = this.client
-      const request = client.request()
-      this.index = 0
-      try {
-        if (Array.isArray(query.bindings)) {
-          let count = 0
-          for (let binding of query.bindings) {
-            request.input(`p${count++}`, binding)
-          }
-        }
-        // this is a hack to get the inserted ID back,
-        //  no way to do this with Knex nicely
-        const sql =
-          operation === Operation.CREATE
-            ? `${query.sql}; SELECT SCOPE_IDENTITY() AS id;`
-            : query.sql
-        return await request.query(sql)
-      } catch (err) {
-        // @ts-ignore
-        throw new Error(err)
-      }
-    }
-
     getDefinitionSQL(tableName: string) {
       return `select *
               from INFORMATION_SCHEMA.COLUMNS
@@ -193,8 +149,33 @@ module MSSQLModule {
               WHERE TABLE_NAME='${tableName}'`
     }
 
+    constructor(config: MSSQLConfig) {
+      super(SqlClients.MS_SQL)
+      this.config = config
+      const clientCfg = {
+        ...this.config,
+        options: {
+          encrypt: this.config.encrypt,
+          enableArithAbort: true,
+        },
+      }
+      delete clientCfg.encrypt
+      if (!this.pool) {
+        this.pool = new sqlServer.ConnectionPool(clientCfg)
+      }
+    }
+
+    async connect() {
+      try {
+        this.client = await this.pool.connect()
+      } catch (err) {
+        // @ts-ignore
+        throw new Error(err)
+      }
+    }
+
     async runSQL(sql: string) {
-      return (await this.internalQuery(getSqlQuery(sql))).recordset
+      return (await internalQuery(this.client, getSqlQuery(sql))).recordset
     }
 
     /**
@@ -204,14 +185,11 @@ module MSSQLModule {
      */
     async buildSchema(datasourceId: string, entities: Record<string, Table>) {
       await this.connect()
-      let tableInfo: TablesResponse[] = await this.runSQL(this.TABLES_SQL)
-      if (tableInfo == null || !Array.isArray(tableInfo)) {
+      let tableNames = await this.runSQL(this.TABLES_SQL)
+      if (tableNames == null || !Array.isArray(tableNames)) {
         throw "Unable to get list of tables in database"
       }
-
-      const schema = this.config.schema || DEFAULT_SCHEMA
-      const tableNames = tableInfo
-        .filter((record: any) => record.TABLE_SCHEMA === schema)
+      tableNames = tableNames
         .map((record: any) => record.TABLE_NAME)
         .filter((name: string) => this.MASTER_TABLES.indexOf(name) === -1)
 
@@ -260,36 +238,33 @@ module MSSQLModule {
 
     async read(query: SqlQuery | string) {
       await this.connect()
-      const response = await this.internalQuery(getSqlQuery(query))
+      const response = await internalQuery(this.client, getSqlQuery(query))
       return response.recordset
     }
 
     async create(query: SqlQuery | string) {
       await this.connect()
-      const response = await this.internalQuery(getSqlQuery(query))
+      const response = await internalQuery(this.client, getSqlQuery(query))
       return response.recordset || [{ created: true }]
     }
 
     async update(query: SqlQuery | string) {
       await this.connect()
-      const response = await this.internalQuery(getSqlQuery(query))
+      const response = await internalQuery(this.client, getSqlQuery(query))
       return response.recordset || [{ updated: true }]
     }
 
     async delete(query: SqlQuery | string) {
       await this.connect()
-      const response = await this.internalQuery(getSqlQuery(query))
+      const response = await internalQuery(this.client, getSqlQuery(query))
       return response.recordset || [{ deleted: true }]
     }
 
     async query(json: QueryJson) {
-      const schema = this.config.schema
       await this.connect()
-      if (schema && schema !== DEFAULT_SCHEMA && json?.endpoint) {
-        json.endpoint.schema = schema
-      }
       const operation = this._operation(json)
-      const queryFn = (query: any, op: string) => this.internalQuery(query, op)
+      const queryFn = (query: any, op: string) =>
+        internalQuery(this.client, query, op)
       const processFn = (result: any) =>
         result.recordset ? result.recordset : [{ [operation]: true }]
       return this.queryWithReturning(json, queryFn, processFn)

package/src/integrations/mysql.ts

@@ -95,10 +95,6 @@ module MySQLModule {
       this.config = config
     }
 
-    getBindingIdentifier(): string {
-      return "?"
-    }
-
     async connect() {
       this.client = await mysql.createConnection(this.config)
     }

package/src/integrations/oracle.ts

@@ -1,24 +1,24 @@
 import {
-  DatasourceFieldTypes,
   Integration,
-  Operation,
-  QueryJson,
+  DatasourceFieldTypes,
   QueryTypes,
   SqlQuery,
+  QueryJson,
+  Operation,
 } from "../definitions/datasource"
 import {
-  buildExternalTableId,
-  convertSqlType,
   finaliseExternalTables,
   getSqlQuery,
+  buildExternalTableId,
+  convertSqlType,
   SqlClients,
 } from "./utils"
 import oracledb, {
-  BindParameters,
-  Connection,
-  ConnectionAttributes,
   ExecuteOptions,
   Result,
+  Connection,
+  ConnectionAttributes,
+  BindParameters,
 } from "oracledb"
 import Sql from "./base/sql"
 import { Table } from "../definitions/common"
@@ -137,7 +137,6 @@ module OracleModule {
 
   class OracleIntegration extends Sql implements DatasourcePlus {
     private readonly config: OracleConfig
-    private index: number = 1
 
     public tables: Record<string, Table> = {}
     public schemaErrors: Record<string, string> = {}
@@ -175,10 +174,6 @@ module OracleModule {
       this.config = config
     }
 
-    getBindingIdentifier(): string {
-      return `:${this.index++}`
-    }
-
     /**
      * Map the flat tabular columns and constraints data into a nested object
      */
@@ -238,14 +233,20 @@ module OracleModule {
       return oracleTables
     }
 
-    private static isSupportedColumn(column: OracleColumn) {
-      return !UNSUPPORTED_TYPES.includes(column.type)
+    private isSupportedColumn(column: OracleColumn) {
+      if (UNSUPPORTED_TYPES.includes(column.type)) {
+        return false
+      }
+
+      return true
     }
 
-    private static isAutoColumn(column: OracleColumn) {
-      return !!(
-        column.default && column.default.toLowerCase().includes("nextval")
-      )
+    private isAutoColumn(column: OracleColumn) {
+      if (column.default && column.default.toLowerCase().includes("nextval")) {
+        return true
+      }
+
+      return false
     }
 
     /**
@@ -253,7 +254,7 @@ module OracleModule {
      * This matches the default behaviour for generating DDL used in knex.
      */
     private isBooleanType(column: OracleColumn): boolean {
-      return (
+      if (
         column.type.toLowerCase() === "number" &&
         Object.values(column.constraints).filter(c => {
           if (
@@ -272,7 +273,11 @@ module OracleModule {
           }
           return false
         }).length > 0
-      )
+      ) {
+        return true
+      }
+
+      return false
     }
 
     private internalConvertType(column: OracleColumn): string {
@@ -312,9 +317,7 @@ module OracleModule {
         // iterate each column on the table
         Object.values(oracleTable.columns)
           // remove columns that we can't read / save
-          .filter(oracleColumn =>
-            OracleIntegration.isSupportedColumn(oracleColumn)
-          )
+          .filter(oracleColumn => this.isSupportedColumn(oracleColumn))
           // match the order of the columns in the db
           .sort((c1, c2) => c1.id - c2.id)
           .forEach(oracleColumn => {
@@ -322,7 +325,7 @@ module OracleModule {
             let fieldSchema = table.schema[columnName]
             if (!fieldSchema) {
               fieldSchema = {
-                autocolumn: OracleIntegration.isAutoColumn(oracleColumn),
+                autocolumn: this.isAutoColumn(oracleColumn),
                 name: columnName,
                 type: this.internalConvertType(oracleColumn),
               }
@@ -348,13 +351,18 @@ module OracleModule {
     private async internalQuery<T>(query: SqlQuery): Promise<Result<T>> {
       let connection
       try {
-        this.index = 1
         connection = await this.getConnection()
 
         const options: ExecuteOptions = { autoCommit: true }
         const bindings: BindParameters = query.bindings || []
 
-        return await connection.execute<T>(query.sql, bindings, options)
+        const result: Result<T> = await connection.execute<T>(
+          query.sql,
+          bindings,
+          options
+        )
+
+        return result
       } finally {
         if (connection) {
           try {

package/src/integrations/postgres.ts

@@ -103,11 +103,30 @@ module PostgresModule {
     },
   }
 
+  async function internalQuery(client: any, query: SqlQuery) {
+    // need to handle a specific issue with json data types in postgres,
+    // new lines inside the JSON data will break it
+    if (query && query.sql) {
+      const matches = query.sql.match(JSON_REGEX)
+      if (matches && matches.length > 0) {
+        for (let match of matches) {
+          const escaped = escapeDangerousCharacters(match)
+          query.sql = query.sql.replace(match, escaped)
+        }
+      }
+    }
+    try {
+      return await client.query(query.sql, query.bindings || [])
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err)
+    }
+  }
+
   class PostgresIntegration extends Sql implements DatasourcePlus {
     static pool: any
     private readonly client: any
     private readonly config: PostgresConfig
-    private index: number = 1
     public tables: Record<string, Table> = {}
     public schemaErrors: Record<string, string> = {}
 
@@ -144,32 +163,6 @@ module PostgresModule {
       this.setSchema()
     }
 
-    getBindingIdentifier(): string {
-      return `$${this.index++}`
-    }
-
-    async internalQuery(query: SqlQuery) {
-      const client = this.client
-      this.index = 1
-      // need to handle a specific issue with json data types in postgres,
-      // new lines inside the JSON data will break it
-      if (query && query.sql) {
-        const matches = query.sql.match(JSON_REGEX)
-        if (matches && matches.length > 0) {
-          for (let match of matches) {
-            const escaped = escapeDangerousCharacters(match)
-            query.sql = query.sql.replace(match, escaped)
-          }
-        }
-      }
-      try {
-        return await client.query(query.sql, query.bindings || [])
-      } catch (err) {
-        // @ts-ignore
-        throw new Error(err)
-      }
-    }
-
     setSchema() {
       if (!this.config.schema) {
         this.config.schema = "public"
@@ -248,22 +241,22 @@ module PostgresModule {
     }
 
     async create(query: SqlQuery | string) {
-      const response = await this.internalQuery(getSqlQuery(query))
+      const response = await internalQuery(this.client, getSqlQuery(query))
       return response.rows.length ? response.rows : [{ created: true }]
     }
 
     async read(query: SqlQuery | string) {
-      const response = await this.internalQuery(getSqlQuery(query))
+      const response = await internalQuery(this.client, getSqlQuery(query))
       return response.rows
     }
 
     async update(query: SqlQuery | string) {
-      const response = await this.internalQuery(getSqlQuery(query))
+      const response = await internalQuery(this.client, getSqlQuery(query))
       return response.rows.length ? response.rows : [{ updated: true }]
     }
 
     async delete(query: SqlQuery | string) {
-      const response = await this.internalQuery(getSqlQuery(query))
+      const response = await internalQuery(this.client, getSqlQuery(query))
       return response.rows.length ? response.rows : [{ deleted: true }]
     }
 
@@ -273,11 +266,11 @@ module PostgresModule {
       if (Array.isArray(input)) {
         const responses = []
         for (let query of input) {
-          responses.push(await this.internalQuery(query))
+          responses.push(await internalQuery(this.client, query))
         }
         return responses
       } else {
-        const response = await this.internalQuery(input)
+        const response = await internalQuery(this.client, input)
         return response.rows.length ? response.rows : [{ [operation]: true }]
       }
     }

package/src/integrations/utils.ts

@@ -6,63 +6,35 @@ import { FieldTypes, BuildSchemaErrors, InvalidColumns } from "../constants"
 const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`
 const ROW_ID_REGEX = /^\[.*]$/g
 
-const SQL_NUMBER_TYPE_MAP = {
+const SQL_TYPE_MAP = {
+  text: FieldTypes.LONGFORM,
+  varchar: FieldTypes.STRING,
   integer: FieldTypes.NUMBER,
-  int: FieldTypes.NUMBER,
   bigint: FieldTypes.NUMBER,
   decimal: FieldTypes.NUMBER,
   smallint: FieldTypes.NUMBER,
   real: FieldTypes.NUMBER,
+  "double precision": FieldTypes.NUMBER,
+  timestamp: FieldTypes.DATETIME,
+  time: FieldTypes.DATETIME,
+  boolean: FieldTypes.BOOLEAN,
+  json: FieldTypes.JSON,
+  date: FieldTypes.DATETIME,
+  blob: FieldTypes.LONGFORM,
+  enum: FieldTypes.STRING,
   float: FieldTypes.NUMBER,
+  int: FieldTypes.NUMBER,
   numeric: FieldTypes.NUMBER,
   mediumint: FieldTypes.NUMBER,
   dec: FieldTypes.NUMBER,
   double: FieldTypes.NUMBER,
   fixed: FieldTypes.NUMBER,
-  "double precision": FieldTypes.NUMBER,
+  datetime: FieldTypes.DATETIME,
+  tinyint: FieldTypes.BOOLEAN,
+  long: FieldTypes.LONGFORM,
   number: FieldTypes.NUMBER,
   binary_float: FieldTypes.NUMBER,
   binary_double: FieldTypes.NUMBER,
-  money: FieldTypes.NUMBER,
-  smallmoney: FieldTypes.NUMBER,
-}
-
-const SQL_DATE_TYPE_MAP = {
-  timestamp: FieldTypes.DATETIME,
-  time: FieldTypes.DATETIME,
-  datetime: FieldTypes.DATETIME,
-  smalldatetime: FieldTypes.DATETIME,
-  date: FieldTypes.DATETIME,
-}
-
-const SQL_STRING_TYPE_MAP = {
-  varchar: FieldTypes.STRING,
-  char: FieldTypes.STRING,
-  nchar: FieldTypes.STRING,
-  nvarchar: FieldTypes.STRING,
-  ntext: FieldTypes.STRING,
-  enum: FieldTypes.STRING,
-  blob: FieldTypes.LONGFORM,
-  long: FieldTypes.LONGFORM,
-  text: FieldTypes.LONGFORM,
-}
-
-const SQL_BOOLEAN_TYPE_MAP = {
-  boolean: FieldTypes.BOOLEAN,
-  bit: FieldTypes.BOOLEAN,
-  tinyint: FieldTypes.BOOLEAN,
-}
-
-const SQL_MISC_TYPE_MAP = {
-  json: FieldTypes.JSON,
-}
-
-const SQL_TYPE_MAP = {
-  ...SQL_NUMBER_TYPE_MAP,
-  ...SQL_DATE_TYPE_MAP,
-  ...SQL_STRING_TYPE_MAP,
-  ...SQL_BOOLEAN_TYPE_MAP,
-  ...SQL_MISC_TYPE_MAP,
 }
 
 export enum SqlClients {

package/src/tests/utilities/TestConfiguration.js

@@ -25,8 +25,6 @@ const { createASession } = require("@budibase/backend-core/sessions")
 const { user: userCache } = require("@budibase/backend-core/cache")
 const newid = require("../../db/newid")
 const context = require("@budibase/backend-core/context")
-const { generateDevInfoID, SEPARATOR } = require("@budibase/backend-core/db")
-const { encrypt } = require("@budibase/backend-core/encryption")
 
 const GLOBAL_USER_ID = "us_uuid1"
 const EMAIL = "babs@babs.com"
@@ -49,10 +47,6 @@ class TestConfiguration {
     return this.request
   }
 
-  getApp() {
-    return this.app
-  }
-
   getAppId() {
     return this.appId
   }
@@ -89,20 +83,6 @@ class TestConfiguration {
     }
   }
 
-  async generateApiKey(userId = GLOBAL_USER_ID) {
-    const db = getGlobalDB(TENANT_ID)
-    const id = generateDevInfoID(userId)
-    let devInfo
-    try {
-      devInfo = await db.get(id)
-    } catch (err) {
-      devInfo = { _id: id, userId }
-    }
-    devInfo.apiKey = encrypt(`${TENANT_ID}${SEPARATOR}${newid()}`)
-    await db.put(devInfo)
-    return devInfo.apiKey
-  }
-
   async globalUser({
     id = GLOBAL_USER_ID,
     builder = true,
@@ -155,7 +135,7 @@ class TestConfiguration {
     cleanup(this.allApps.map(app => app.appId))
   }
 
-  defaultHeaders(extras = {}) {
+  defaultHeaders() {
     const auth = {
       userId: GLOBAL_USER_ID,
       sessionId: "sessionid",
@@ -174,7 +154,6 @@ class TestConfiguration {
         `${Cookies.CurrentApp}=${appToken}`,
       ],
       [Headers.CSRF_TOKEN]: CSRF_TOKEN,
-      ...extras,
     }
     if (this.appId) {
       headers[Headers.APP_ID] = this.appId
@@ -247,7 +226,7 @@ class TestConfiguration {
 
   async getTable(tableId = null) {
     tableId = tableId || this.table._id
-    return this._req(null, { tableId }, controllers.table.find)
+    return this._req(null, { id: tableId }, controllers.table.find)
   }
 
   async createLinkedTable(relationshipType = null, links = ["link"]) {