@budibase/server 1.2.37 → 1.2.38

package/src/integrations/googlesheets.ts

@@ -1,12 +1,13 @@
 import {
-  DatasourceFieldTypes,
+  DatasourceFieldType,
   Integration,
+  QueryType,
+  Table,
+  TableSchema,
   QueryJson,
-  QueryTypes,
-} from "../definitions/datasource"
+  DatasourcePlus,
+} from "@budibase/types"
 import { OAuth2Client } from "google-auth-library"
-import { DatasourcePlus } from "./base/datasourcePlus"
-import { Table, TableSchema } from "../definitions/common"
 import { buildExternalTableId } from "./utils"
 import { DataSourceOperation, FieldTypes } from "../constants"
 import { GoogleSpreadsheet } from "google-spreadsheet"
@@ -53,59 +54,59 @@ module GoogleSheetsModule {
     datasource: {
       spreadsheetId: {
         display: "Google Sheet URL",
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         required: true,
       },
     },
     query: {
       create: {
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: {
           sheet: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
           row: {
-            type: QueryTypes.JSON,
+            type: QueryType.JSON,
             required: true,
           },
         },
       },
       read: {
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: {
           sheet: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
         },
       },
       update: {
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: {
           sheet: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
           rowIndex: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
           row: {
-            type: QueryTypes.JSON,
+            type: QueryType.JSON,
             required: true,
           },
         },
       },
       delete: {
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: {
           sheet: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
           rowIndex: {
-            type: DatasourceFieldTypes.NUMBER,
+            type: DatasourceFieldType.NUMBER,
             required: true,
           },
         },

package/src/integrations/index.ts

@@ -13,54 +13,54 @@ const googlesheets = require("./googlesheets")
 const firebase = require("./firebase")
 const redis = require("./redis")
 const snowflake = require("./snowflake")
-const { SourceNames } = require("../definitions/datasource")
+const { SourceName } = require("@budibase/types")
 const environment = require("../environment")
 
 const DEFINITIONS = {
-  [SourceNames.POSTGRES]: postgres.schema,
-  [SourceNames.DYNAMODB]: dynamodb.schema,
-  [SourceNames.MONGODB]: mongodb.schema,
-  [SourceNames.ELASTICSEARCH]: elasticsearch.schema,
-  [SourceNames.COUCHDB]: couchdb.schema,
-  [SourceNames.SQL_SERVER]: sqlServer.schema,
-  [SourceNames.S3]: s3.schema,
-  [SourceNames.AIRTABLE]: airtable.schema,
-  [SourceNames.MYSQL]: mysql.schema,
-  [SourceNames.ARANGODB]: arangodb.schema,
-  [SourceNames.REST]: rest.schema,
-  [SourceNames.FIRESTORE]: firebase.schema,
-  [SourceNames.REDIS]: redis.schema,
-  [SourceNames.SNOWFLAKE]: snowflake.schema,
+  [SourceName.POSTGRES]: postgres.schema,
+  [SourceName.DYNAMODB]: dynamodb.schema,
+  [SourceName.MONGODB]: mongodb.schema,
+  [SourceName.ELASTICSEARCH]: elasticsearch.schema,
+  [SourceName.COUCHDB]: couchdb.schema,
+  [SourceName.SQL_SERVER]: sqlServer.schema,
+  [SourceName.S3]: s3.schema,
+  [SourceName.AIRTABLE]: airtable.schema,
+  [SourceName.MYSQL]: mysql.schema,
+  [SourceName.ARANGODB]: arangodb.schema,
+  [SourceName.REST]: rest.schema,
+  [SourceName.FIRESTORE]: firebase.schema,
+  [SourceName.REDIS]: redis.schema,
+  [SourceName.SNOWFLAKE]: snowflake.schema,
 }
 
 const INTEGRATIONS = {
-  [SourceNames.POSTGRES]: postgres.integration,
-  [SourceNames.DYNAMODB]: dynamodb.integration,
-  [SourceNames.MONGODB]: mongodb.integration,
-  [SourceNames.ELASTICSEARCH]: elasticsearch.integration,
-  [SourceNames.COUCHDB]: couchdb.integration,
-  [SourceNames.SQL_SERVER]: sqlServer.integration,
-  [SourceNames.S3]: s3.integration,
-  [SourceNames.AIRTABLE]: airtable.integration,
-  [SourceNames.MYSQL]: mysql.integration,
-  [SourceNames.ARANGODB]: arangodb.integration,
-  [SourceNames.REST]: rest.integration,
-  [SourceNames.FIRESTORE]: firebase.integration,
-  [SourceNames.GOOGLE_SHEETS]: googlesheets.integration,
-  [SourceNames.REDIS]: redis.integration,
-  [SourceNames.FIREBASE]: firebase.integration,
-  [SourceNames.SNOWFLAKE]: snowflake.integration,
+  [SourceName.POSTGRES]: postgres.integration,
+  [SourceName.DYNAMODB]: dynamodb.integration,
+  [SourceName.MONGODB]: mongodb.integration,
+  [SourceName.ELASTICSEARCH]: elasticsearch.integration,
+  [SourceName.COUCHDB]: couchdb.integration,
+  [SourceName.SQL_SERVER]: sqlServer.integration,
+  [SourceName.S3]: s3.integration,
+  [SourceName.AIRTABLE]: airtable.integration,
+  [SourceName.MYSQL]: mysql.integration,
+  [SourceName.ARANGODB]: arangodb.integration,
+  [SourceName.REST]: rest.integration,
+  [SourceName.FIRESTORE]: firebase.integration,
+  [SourceName.GOOGLE_SHEETS]: googlesheets.integration,
+  [SourceName.REDIS]: redis.integration,
+  [SourceName.FIREBASE]: firebase.integration,
+  [SourceName.SNOWFLAKE]: snowflake.integration,
 }
 
 // optionally add oracle integration if the oracle binary can be installed
 if (process.arch && !process.arch.startsWith("arm")) {
   const oracle = require("./oracle")
-  DEFINITIONS[SourceNames.ORACLE] = oracle.schema
-  INTEGRATIONS[SourceNames.ORACLE] = oracle.integration
+  DEFINITIONS[SourceName.ORACLE] = oracle.schema
+  INTEGRATIONS[SourceName.ORACLE] = oracle.integration
 }
 
 if (environment.SELF_HOSTED) {
-  DEFINITIONS[SourceNames.GOOGLE_SHEETS] = googlesheets.schema
+  DEFINITIONS[SourceName.GOOGLE_SHEETS] = googlesheets.schema
 }
 
 module.exports = {

package/src/integrations/microsoftSqlServer.ts

@@ -1,20 +1,21 @@
 import {
-  DatasourceFieldTypes,
+  DatasourceFieldType,
   Integration,
   Operation,
+  Table,
+  TableSchema,
   QueryJson,
-  QueryTypes,
+  QueryType,
   SqlQuery,
-} from "../definitions/datasource"
+  DatasourcePlus,
+} from "@budibase/types"
 import {
   getSqlQuery,
   buildExternalTableId,
   convertSqlType,
   finaliseExternalTables,
-  SqlClients,
+  SqlClient,
 } from "./utils"
-import { DatasourcePlus } from "./base/datasourcePlus"
-import { Table, TableSchema } from "../definitions/common"
 
 module MSSQLModule {
   const sqlServer = require("mssql")
@@ -47,48 +48,48 @@ module MSSQLModule {
     type: "Relational",
     datasource: {
       user: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         required: true,
         default: "localhost",
       },
       password: {
-        type: DatasourceFieldTypes.PASSWORD,
+        type: DatasourceFieldType.PASSWORD,
         required: true,
       },
       server: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "localhost",
       },
       port: {
-        type: DatasourceFieldTypes.NUMBER,
+        type: DatasourceFieldType.NUMBER,
         required: false,
         default: 1433,
       },
       database: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "root",
       },
       schema: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: DEFAULT_SCHEMA,
       },
       encrypt: {
-        type: DatasourceFieldTypes.BOOLEAN,
+        type: DatasourceFieldType.BOOLEAN,
         default: true,
       },
     },
     query: {
       create: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       read: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       update: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       delete: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
     },
   }
@@ -111,7 +112,7 @@ module MSSQLModule {
       "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE'"
 
     constructor(config: MSSQLConfig) {
-      super(SqlClients.MS_SQL)
+      super(SqlClient.MS_SQL)
       this.config = config
       const clientCfg = {
         ...this.config,

package/src/integrations/mongodb.ts

@@ -1,9 +1,9 @@
 import {
   Integration,
-  DatasourceFieldTypes,
-  QueryTypes,
-} from "../definitions/datasource"
-import { IntegrationBase } from "./base/IntegrationBase"
+  DatasourceFieldType,
+  QueryType,
+  IntegrationBase,
+} from "@budibase/types"
 import {
   MongoClient,
   ObjectID,
@@ -29,38 +29,38 @@ module MongoDBModule {
       "MongoDB is a general purpose, document-based, distributed database built for modern application developers and for the cloud era.",
     datasource: {
       connectionString: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         required: true,
         default: "mongodb://localhost:27017",
       },
       db: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         required: true,
       },
     },
     query: {
       create: {
-        type: QueryTypes.JSON,
+        type: QueryType.JSON,
       },
       read: {
-        type: QueryTypes.JSON,
+        type: QueryType.JSON,
       },
       update: {
-        type: QueryTypes.JSON,
+        type: QueryType.JSON,
       },
       delete: {
-        type: QueryTypes.JSON,
+        type: QueryType.JSON,
       },
     },
     extra: {
       collection: {
         displayName: "Collection",
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         required: true,
       },
       actionTypes: {
         displayName: "Action Types",
-        type: DatasourceFieldTypes.LIST,
+        type: DatasourceFieldType.LIST,
         required: true,
         data: {
           read: ["find", "findOne", "findOneAndUpdate", "count", "distinct"],

package/src/integrations/mysql.ts

@@ -1,19 +1,20 @@
 import {
   Integration,
-  DatasourceFieldTypes,
-  QueryTypes,
+  DatasourceFieldType,
+  QueryType,
   QueryJson,
   SqlQuery,
-} from "../definitions/datasource"
-import { Table, TableSchema } from "../definitions/common"
+  Table,
+  TableSchema,
+  DatasourcePlus,
+} from "@budibase/types"
 import {
   getSqlQuery,
-  SqlClients,
+  SqlClient,
   buildExternalTableId,
   convertSqlType,
   finaliseExternalTables,
 } from "./utils"
-import { DatasourcePlus } from "./base/datasourcePlus"
 import dayjs from "dayjs"
 const { NUMBER_REGEX } = require("../utilities")
 
@@ -41,51 +42,51 @@ module MySQLModule {
       "MySQL Database Service is a fully managed database service to deploy cloud-native applications. ",
     datasource: {
       host: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "localhost",
         required: true,
       },
       port: {
-        type: DatasourceFieldTypes.NUMBER,
+        type: DatasourceFieldType.NUMBER,
         default: 3306,
         required: false,
       },
       user: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "root",
         required: true,
       },
       password: {
-        type: DatasourceFieldTypes.PASSWORD,
+        type: DatasourceFieldType.PASSWORD,
         default: "root",
         required: true,
       },
       database: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         required: true,
       },
       ssl: {
-        type: DatasourceFieldTypes.OBJECT,
+        type: DatasourceFieldType.OBJECT,
         required: false,
       },
       rejectUnauthorized: {
-        type: DatasourceFieldTypes.BOOLEAN,
+        type: DatasourceFieldType.BOOLEAN,
         default: true,
         required: false,
       },
     },
     query: {
       create: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       read: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       update: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       delete: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
     },
   }
@@ -119,7 +120,7 @@ module MySQLModule {
     public schemaErrors: Record<string, string> = {}
 
     constructor(config: MySQLConfig) {
-      super(SqlClients.MY_SQL)
+      super(SqlClient.MY_SQL)
       this.config = config
       if (config.ssl && Object.keys(config.ssl).length === 0) {
         delete config.ssl

package/src/integrations/oracle.ts

@@ -1,17 +1,19 @@
 import {
-  DatasourceFieldTypes,
+  DatasourceFieldType,
   Integration,
   Operation,
   QueryJson,
-  QueryTypes,
+  QueryType,
   SqlQuery,
-} from "../definitions/datasource"
+  Table,
+  DatasourcePlus,
+} from "@budibase/types"
 import {
   buildExternalTableId,
   convertSqlType,
   finaliseExternalTables,
   getSqlQuery,
-  SqlClients,
+  SqlClient,
 } from "./utils"
 import oracledb, {
   BindParameters,
@@ -21,8 +23,6 @@ import oracledb, {
   Result,
 } from "oracledb"
 import Sql from "./base/sql"
-import { Table } from "../definitions/common"
-import { DatasourcePlus } from "./base/datasourcePlus"
 import { FieldTypes } from "../constants"
 
 module OracleModule {
@@ -45,40 +45,40 @@ module OracleModule {
       "Oracle Database is an object-relational database management system developed by Oracle Corporation",
     datasource: {
       host: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "localhost",
         required: true,
       },
       port: {
-        type: DatasourceFieldTypes.NUMBER,
+        type: DatasourceFieldType.NUMBER,
         required: true,
         default: 1521,
       },
       database: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         required: true,
       },
       user: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         required: true,
       },
       password: {
-        type: DatasourceFieldTypes.PASSWORD,
+        type: DatasourceFieldType.PASSWORD,
         required: true,
       },
     },
     query: {
       create: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       read: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       update: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       delete: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
     },
   }
@@ -172,7 +172,7 @@ module OracleModule {
           OR cons.status IS NULL)
     `
     constructor(config: OracleConfig) {
-      super(SqlClients.ORACLE)
+      super(SqlClient.ORACLE)
       this.config = config
     }
 

package/src/integrations/postgres.ts

@@ -1,19 +1,19 @@
 import {
   Integration,
-  DatasourceFieldTypes,
-  QueryTypes,
+  DatasourceFieldType,
+  QueryType,
   QueryJson,
   SqlQuery,
-} from "../definitions/datasource"
-import { Table } from "../definitions/common"
+  Table,
+  DatasourcePlus,
+} from "@budibase/types"
 import {
   getSqlQuery,
   buildExternalTableId,
   convertSqlType,
   finaliseExternalTables,
-  SqlClients,
+  SqlClient,
 } from "./utils"
-import { DatasourcePlus } from "./base/datasourcePlus"
 
 module PostgresModule {
   const { Client, types } = require("pg")
@@ -52,63 +52,63 @@ module PostgresModule {
       "PostgreSQL, also known as Postgres, is a free and open-source relational database management system emphasizing extensibility and SQL compliance.",
     datasource: {
       host: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "localhost",
         required: true,
       },
       port: {
-        type: DatasourceFieldTypes.NUMBER,
+        type: DatasourceFieldType.NUMBER,
         required: true,
         default: 5432,
       },
       database: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "postgres",
         required: true,
       },
       user: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "root",
         required: true,
       },
       password: {
-        type: DatasourceFieldTypes.PASSWORD,
+        type: DatasourceFieldType.PASSWORD,
         default: "root",
         required: true,
       },
       schema: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "public",
         required: true,
       },
       ssl: {
-        type: DatasourceFieldTypes.BOOLEAN,
+        type: DatasourceFieldType.BOOLEAN,
         default: false,
         required: false,
       },
       rejectUnauthorized: {
-        type: DatasourceFieldTypes.BOOLEAN,
+        type: DatasourceFieldType.BOOLEAN,
         default: false,
         required: false,
       },
       ca: {
-        type: DatasourceFieldTypes.LONGFORM,
+        type: DatasourceFieldType.LONGFORM,
         default: false,
         required: false,
       },
     },
     query: {
       create: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       read: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       update: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
       delete: {
-        type: QueryTypes.SQL,
+        type: QueryType.SQL,
       },
     },
   }
@@ -133,7 +133,7 @@ module PostgresModule {
     `
 
     constructor(config: PostgresConfig) {
-      super(SqlClients.POSTGRES)
+      super(SqlClient.POSTGRES)
       this.config = config
 
       let newConfig = {

package/src/integrations/queries/sql.ts

@@ -1,6 +1,5 @@
 import { findHBSBlocks, processStringSync } from "@budibase/string-templates"
-import { Integration } from "../../definitions/datasource"
-import { DatasourcePlus } from "../base/datasourcePlus"
+import { DatasourcePlus } from "@budibase/types"
 
 const CONST_CHAR_REGEX = new RegExp("'[^']*'", "g")