@budibase/server 1.2.37 → 1.2.38

package/src/integrations/redis.ts

@@ -1,8 +1,4 @@
-import {
-  DatasourceFieldTypes,
-  Integration,
-  QueryTypes,
-} from "../definitions/datasource"
+import { DatasourceFieldType, Integration, QueryType } from "@budibase/types"
 import Redis from "ioredis"
 
 module RedisModule {
@@ -40,36 +36,36 @@ module RedisModule {
     },
     query: {
       create: {
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: {
           key: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
           value: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
           ttl: {
-            type: DatasourceFieldTypes.NUMBER,
+            type: DatasourceFieldType.NUMBER,
           },
         },
       },
       read: {
         readable: true,
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: {
           key: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
         },
       },
       delete: {
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: {
           key: {
-            type: DatasourceFieldTypes.STRING,
+            type: DatasourceFieldType.STRING,
             required: true,
           },
         },
@@ -77,7 +73,7 @@ module RedisModule {
       command: {
         readable: true,
         displayName: "Redis Command",
-        type: QueryTypes.JSON,
+        type: QueryType.JSON,
       },
     },
   }

package/src/integrations/rest.ts

@@ -1,16 +1,18 @@
 import {
   Integration,
-  DatasourceFieldTypes,
-  QueryTypes,
-  RestConfig,
-  RestQueryFields as RestQuery,
+  DatasourceFieldType,
+  QueryType,
   PaginationConfig,
+  IntegrationBase,
+  PaginationValues,
+  RestQueryFields as RestQuery,
+} from "@budibase/types"
+import {
+  RestConfig,
   AuthType,
   BasicAuthConfig,
   BearerAuthConfig,
-  PaginationValues,
 } from "../definitions/datasource"
-import { IntegrationBase } from "./base/IntegrationBase"
 import { get } from "lodash"
 
 const BodyTypes = {
@@ -24,27 +26,27 @@ const BodyTypes = {
 
 const coreFields = {
   path: {
-    type: DatasourceFieldTypes.STRING,
+    type: DatasourceFieldType.STRING,
     display: "URL",
   },
   queryString: {
-    type: DatasourceFieldTypes.STRING,
+    type: DatasourceFieldType.STRING,
   },
   headers: {
-    type: DatasourceFieldTypes.OBJECT,
+    type: DatasourceFieldType.OBJECT,
   },
   enabledHeaders: {
-    type: DatasourceFieldTypes.OBJECT,
+    type: DatasourceFieldType.OBJECT,
   },
   requestBody: {
-    type: DatasourceFieldTypes.JSON,
+    type: DatasourceFieldType.JSON,
   },
   bodyType: {
-    type: DatasourceFieldTypes.STRING,
+    type: DatasourceFieldType.STRING,
     enum: Object.values(BodyTypes),
   },
   pagination: {
-    type: DatasourceFieldTypes.OBJECT,
+    type: DatasourceFieldType.OBJECT,
   },
 }
 
@@ -67,13 +69,13 @@ module RestModule {
     type: "API",
     datasource: {
       url: {
-        type: DatasourceFieldTypes.STRING,
+        type: DatasourceFieldType.STRING,
         default: "",
         required: false,
         deprecated: true,
       },
       defaultHeaders: {
-        type: DatasourceFieldTypes.OBJECT,
+        type: DatasourceFieldType.OBJECT,
         required: false,
         default: {},
       },
@@ -82,30 +84,30 @@ module RestModule {
       create: {
         readable: true,
         displayName: "POST",
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: coreFields,
       },
       read: {
         displayName: "GET",
         readable: true,
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: coreFields,
       },
       update: {
         displayName: "PUT",
         readable: true,
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: coreFields,
       },
       patch: {
         displayName: "PATCH",
         readable: true,
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: coreFields,
       },
       delete: {
         displayName: "DELETE",
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: coreFields,
       },
     },

package/src/integrations/s3.ts

@@ -1,5 +1,4 @@
-import { Integration, QueryTypes } from "../definitions/datasource"
-import { IntegrationBase } from "./base/IntegrationBase"
+import { Integration, QueryType, IntegrationBase } from "@budibase/types"
 
 module S3Module {
   const AWS = require("aws-sdk")
@@ -44,7 +43,7 @@ module S3Module {
     },
     query: {
       read: {
-        type: QueryTypes.FIELDS,
+        type: QueryType.FIELDS,
         fields: {
           bucket: {
             type: "string",

package/src/integrations/snowflake.ts

@@ -1,4 +1,4 @@
-import { Integration, QueryTypes, SqlQuery } from "../definitions/datasource"
+import { Integration, QueryType, SqlQuery } from "@budibase/types"
 import { Snowflake } from "snowflake-promise"
 
 module SnowflakeModule {
@@ -45,16 +45,16 @@ module SnowflakeModule {
     },
     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,
       },
     },
   }

package/src/integrations/tests/sql.spec.js

@@ -1,5 +1,5 @@
 const Sql = require("../base/sql")
-const { SqlClients } = require("../utils")
+const { SqlClient } = require("../utils")
 
 const TABLE_NAME = "test"
 
@@ -47,7 +47,7 @@ function generateDeleteJson(table = TABLE_NAME, filters = {}) {
 
 describe("SQL query builder", () => {
   const limit = 500
-  const client = SqlClients.POSTGRES
+  const client = SqlClient.POSTGRES
   let sql
 
   beforeEach(() => {
@@ -174,7 +174,7 @@ describe("SQL query builder", () => {
   })
 
   it("should work with MS-SQL", () => {
-    const query = new Sql(SqlClients.MS_SQL, 10)._query(generateReadJson())
+    const query = new Sql(SqlClient.MS_SQL, 10)._query(generateReadJson())
     expect(query).toEqual({
       bindings: [10],
       sql: `select * from (select top (@p0) * from [${TABLE_NAME}]) as [${TABLE_NAME}]`
@@ -182,7 +182,7 @@ describe("SQL query builder", () => {
   })
 
   it("should work with MySQL", () => {
-    const query = new Sql(SqlClients.MY_SQL, 10)._query(generateReadJson())
+    const query = new Sql(SqlClient.MY_SQL, 10)._query(generateReadJson())
     expect(query).toEqual({
       bindings: [10],
       sql: `select * from (select * from \`${TABLE_NAME}\` limit ?) as \`${TABLE_NAME}\``
@@ -241,7 +241,7 @@ describe("SQL query builder", () => {
   })
 
   it("should use like expression for MS-SQL when filter is contains", () => {
-    const query = new Sql(SqlClients.MS_SQL, 10)._query(generateReadJson({
+    const query = new Sql(SqlClient.MS_SQL, 10)._query(generateReadJson({
       filters: {
         contains: {
           age: 20,
@@ -256,7 +256,7 @@ describe("SQL query builder", () => {
   })
 
   it("should use JSON_CONTAINS expression for MySQL when filter is contains", () => {
-    const query = new Sql(SqlClients.MY_SQL, 10)._query(generateReadJson({
+    const query = new Sql(SqlClient.MY_SQL, 10)._query(generateReadJson({
       filters: {
         contains: {
           age: 20,
@@ -271,7 +271,7 @@ describe("SQL query builder", () => {
   })
 
   it("should use jsonb operator expression for PostgreSQL when filter is contains", () => {
-    const query = new Sql(SqlClients.POSTGRES, 10)._query(generateReadJson({
+    const query = new Sql(SqlClient.POSTGRES, 10)._query(generateReadJson({
       filters: {
         contains: {
           age: 20,

package/src/integrations/utils.ts

@@ -1,6 +1,5 @@
-import { SourceNames, SqlQuery } from "../definitions/datasource"
-import { Datasource, Table } from "../definitions/common"
-import { DocumentTypes, SEPARATOR } from "../db/utils"
+import { SourceName, SqlQuery, Datasource, Table } from "@budibase/types"
+import { DocumentType, SEPARATOR } from "../db/utils"
 import { FieldTypes, BuildSchemaErrors, InvalidColumns } from "../constants"
 
 const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`
@@ -68,7 +67,7 @@ const SQL_TYPE_MAP = {
   ...SQL_MISC_TYPE_MAP,
 }
 
-export enum SqlClients {
+export enum SqlClient {
   MS_SQL = "mssql",
   POSTGRES = "pg",
   MY_SQL = "mysql2",
@@ -76,7 +75,7 @@ export enum SqlClients {
 }
 
 export function isExternalTable(tableId: string) {
-  return tableId.includes(DocumentTypes.DATASOURCE)
+  return tableId.includes(DocumentType.DATASOURCE)
 }
 
 export function buildExternalTableId(datasourceId: string, tableName: string) {
@@ -169,10 +168,10 @@ export function isSQL(datasource: Datasource): boolean {
     return false
   }
   const SQL = [
-    SourceNames.POSTGRES,
-    SourceNames.SQL_SERVER,
-    SourceNames.MYSQL,
-    SourceNames.ORACLE,
+    SourceName.POSTGRES,
+    SourceName.SQL_SERVER,
+    SourceName.MYSQL,
+    SourceName.ORACLE,
   ]
   return SQL.indexOf(datasource.source) !== -1
 }

package/src/middleware/builder.js

@@ -6,7 +6,7 @@ const {
   setDebounce,
 } = require("../utilities/redis")
 const { doWithDB } = require("@budibase/backend-core/db")
-const { DocumentTypes, getGlobalIDFromUserMetadataID } = require("../db/utils")
+const { DocumentType, getGlobalIDFromUserMetadataID } = require("../db/utils")
 const { PermissionTypes } = require("@budibase/backend-core/permissions")
 const { app: appCache } = require("@budibase/backend-core/cache")
 
@@ -49,7 +49,7 @@ async function updateAppUpdatedAt(ctx) {
     return
   }
   await doWithDB(appId, async db => {
-    const metadata = await db.get(DocumentTypes.APP_METADATA)
+    const metadata = await db.get(DocumentType.APP_METADATA)
     metadata.updatedAt = new Date().toISOString()
 
     metadata.updatedBy = getGlobalIDFromUserMetadataID(ctx.user.userId)

package/src/migrations/functions/appUrls.ts

@@ -1,4 +1,4 @@
-const { DocumentTypes } = require("@budibase/backend-core/db")
+const { DocumentType } = require("@budibase/backend-core/db")
 import { getAppUrl } from "../../api/controllers/application"
 
 /**
@@ -11,7 +11,7 @@ import { getAppUrl } from "../../api/controllers/application"
 export const run = async (appDb: any) => {
   let metadata
   try {
-    metadata = await appDb.get(DocumentTypes.APP_METADATA)
+    metadata = await appDb.get(DocumentType.APP_METADATA)
   } catch (e) {
     // sometimes the metadata document doesn't exist
     // exit early instead of failing the migration

package/src/migrations/functions/backfill/app/queries.ts

@@ -1,6 +1,6 @@
 import { events } from "@budibase/backend-core"
 import { getQueryParams } from "../../../../db/utils"
-import { Query, Datasource } from "@budibase/types"
+import { Query, Datasource, SourceName } from "@budibase/types"
 
 const getQueries = async (appDb: any): Promise<Query[]> => {
   const response = await appDb.allDocs(
@@ -31,8 +31,9 @@ export const backfill = async (appDb: any, timestamp: string | number) => {
       // and the query has not
       if (e.status === 404) {
         datasource = {
+          type: "unknown",
           _id: query.datasourceId,
-          source: "unknown",
+          source: SourceName.UNKNOWN,
         }
       } else {
         throw e

package/src/migrations/functions/backfill/app.ts

@@ -62,7 +62,7 @@ export const run = async (appDb: any) => {
     await events.backfillCache.start(EVENTS)
 
     let timestamp: string | number = DEFAULT_TIMESTAMP
-    const app: App = await appDb.get(dbUtils.DocumentTypes.APP_METADATA)
+    const app: App = await appDb.get(dbUtils.DocumentType.APP_METADATA)
     if (app.createdAt) {
       timestamp = app.createdAt as string
     }

package/src/migrations/functions/backfill/global/users.ts

@@ -4,7 +4,7 @@ import { DEFAULT_TIMESTAMP } from ".."
 
 // manually define user doc params - normally server doesn't read users from the db
 const getUserParams = (props: any) => {
-  return dbUtils.getDocParams(dbUtils.DocumentTypes.USER, null, props)
+  return dbUtils.getDocParams(dbUtils.DocumentType.USER, null, props)
 }
 
 export const getUsers = async (globalDb: any): Promise<User[]> => {

package/src/migrations/functions/tests/appUrls.spec.js

@@ -1,4 +1,4 @@
-const { DocumentTypes, doWithDB } = require("@budibase/backend-core/db")
+const {  DocumentType, doWithDB } = require("@budibase/backend-core/db")
 const TestConfig = require("../../../tests/utilities/TestConfiguration")
 
 const migration = require("../appUrls")
@@ -15,11 +15,11 @@ describe("run", () => {
   it("runs successfully", async () => {
     const app = await config.createApp("testApp")
     const metadata = await doWithDB(app.appId, async db => {
-      const metadataDoc = await db.get(DocumentTypes.APP_METADATA)
+      const metadataDoc = await db.get( DocumentType.APP_METADATA)
       delete metadataDoc.url
       await db.put(metadataDoc)
       await migration.run(db)
-      return await db.get(DocumentTypes.APP_METADATA)
+      return await db.get( DocumentType.APP_METADATA)
     })
     expect(metadata.url).toEqual("/testapp")
   })

package/src/migrations/tests/index.spec.ts

@@ -2,7 +2,7 @@ import {
   events,
   migrations,
   tenancy,
-  DocumentTypes,
+  DocumentType,
   context,
   db,
 } from "@budibase/backend-core"
@@ -17,7 +17,7 @@ const timestamp = mocks.date.MOCK_DATE.toISOString()
 const clearMigrations = async () => {
   const dbs = [context.getDevAppDB(), context.getProdAppDB()]
   for (const db of dbs) {
-    const doc = await db.get(DocumentTypes.MIGRATIONS)
+    const doc = await db.get(DocumentType.MIGRATIONS)
     const newDoc = { _id: doc._id, _rev: doc._rev }
     await db.put(newDoc)
   }

package/src/tests/utilities/TestConfiguration.js

@@ -25,7 +25,7 @@ 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 { DocumentTypes } = require("../../db/utils")
+const { DocumentType } = require("../../db/utils")
 
 const GLOBAL_USER_ID = "us_uuid1"
 const EMAIL = "babs@babs.com"
@@ -344,7 +344,7 @@ class TestConfiguration {
 
     return context.doInAppContext(prodAppId, async () => {
       const db = context.getProdAppDB()
-      return await db.get(DocumentTypes.APP_METADATA)
+      return await db.get(DocumentType.APP_METADATA)
     })
   }
 

package/src/threads/automation.ts

@@ -11,7 +11,7 @@ import { storeLog } from "../automations/logging"
 import { Automation, AutomationStep, AutomationStatus } from "@budibase/types"
 import {
   LoopStep,
-  LoopStepTypes,
+  LoopStepType,
   LoopInput,
   AutomationEvent,
   TriggerOutput,
@@ -35,12 +35,12 @@ function typecastForLooping(loopStep: LoopStep, input: LoopInput) {
   }
   try {
     switch (loopStep.inputs.option) {
-      case LoopStepTypes.ARRAY:
+      case LoopStepType.ARRAY:
         if (typeof input.binding === "string") {
           return JSON.parse(input.binding)
         }
         break
-      case LoopStepTypes.STRING:
+      case LoopStepType.STRING:
         if (Array.isArray(input.binding)) {
           return input.binding.join(",")
         }

package/src/utilities/routing/index.js

@@ -1,11 +1,11 @@
 const { createRoutingView } = require("../../db/views/staticViews")
-const { ViewNames, getQueryIndex, UNICODE_MAX } = require("../../db/utils")
+const { ViewName, getQueryIndex, UNICODE_MAX } = require("../../db/utils")
 const { getAppDB } = require("@budibase/backend-core/context")
 
 exports.getRoutingInfo = async () => {
   const db = getAppDB()
   try {
-    const allRouting = await db.query(getQueryIndex(ViewNames.ROUTING), {
+    const allRouting = await db.query(getQueryIndex(ViewName.ROUTING), {
       startKey: "",
       endKey: UNICODE_MAX,
     })

package/src/utilities/security.js

@@ -8,7 +8,7 @@ const {
   lowerBuiltinRoleID,
   getBuiltinRoles,
 } = require("@budibase/backend-core/roles")
-const { DocumentTypes } = require("../db/utils")
+const { DocumentType } = require("../db/utils")
 
 const CURRENTLY_SUPPORTED_LEVELS = [
   PermissionLevels.WRITE,
@@ -17,19 +17,19 @@ const CURRENTLY_SUPPORTED_LEVELS = [
 ]
 
 exports.getPermissionType = resourceId => {
-  const docType = Object.values(DocumentTypes).filter(docType =>
+  const docType = Object.values(DocumentType).filter(docType =>
     resourceId.startsWith(docType)
   )[0]
   switch (docType) {
-    case DocumentTypes.TABLE:
-    case DocumentTypes.ROW:
+    case DocumentType.TABLE:
+    case DocumentType.ROW:
       return PermissionTypes.TABLE
-    case DocumentTypes.AUTOMATION:
+    case DocumentType.AUTOMATION:
       return PermissionTypes.AUTOMATION
-    case DocumentTypes.WEBHOOK:
+    case DocumentType.WEBHOOK:
       return PermissionTypes.WEBHOOK
-    case DocumentTypes.QUERY:
-    case DocumentTypes.DATASOURCE:
+    case DocumentType.QUERY:
+    case DocumentType.DATASOURCE:
       return PermissionTypes.QUERY
     default:
       // views don't have an ID, will end up here

package/dist/integrations/base/IntegrationBase.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/integrations/base/datasourcePlus.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/src/integrations/base/IntegrationBase.ts

@@ -1,6 +0,0 @@
-export interface IntegrationBase {
-  create?(query: any): Promise<any[] | any>
-  read?(query: any): Promise<any[] | any>
-  update?(query: any): Promise<any[] | any>
-  delete?(query: any): Promise<any[] | any>
-}

package/src/integrations/base/datasourcePlus.ts

@@ -1,13 +0,0 @@
-import { Table } from "../../definitions/common"
-import { IntegrationBase } from "./IntegrationBase"
-
-export interface DatasourcePlus extends IntegrationBase {
-  tables: Record<string, Table>
-  schemaErrors: Record<string, string>
-
-  // if the datasource supports the use of bindings directly (to protect against SQL injection)
-  // this returns the format of the identifier
-  getBindingIdentifier(): string
-  getStringConcat(parts: string[]): string
-  buildSchema(datasourceId: string, entities: Record<string, Table>): any
-}