@budibase/server 2.1.45 → 2.1.46-alpha.0

package/src/tests/utilities/{TestConfiguration.js → TestConfiguration.ts}

@@ -1,7 +1,7 @@
-require("../../db").init()
-const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
-const env = require("../../environment")
-const {
+import { init as dbInit } from "../../db"
+dbInit()
+import env from "../../environment"
+import {
   basicTable,
   basicRow,
   basicRole,
@@ -12,21 +12,24 @@ const {
   basicLayout,
   basicWebhook,
   TENANT_ID,
-} = require("./structures")
-const controllers = require("./controllers")
+} from "./structures"
+import {
+  constants,
+  tenancy,
+  sessions,
+  cache,
+  context,
+  db as dbCore,
+  encryption,
+  auth,
+  roles,
+} from "@budibase/backend-core"
+import * as controllers from "./controllers"
+import { cleanup } from "../../utilities/fileSystem"
+import newid from "../../db/newid"
+import { generateUserMetadataID } from "../../db/utils"
+import { startup } from "../../startup"
 const supertest = require("supertest")
-const { cleanup } = require("../../utilities/fileSystem")
-const { Cookies, Headers } = require("@budibase/backend-core/constants")
-const { jwt } = require("@budibase/backend-core/auth")
-const { doInTenant, doWithGlobalDB } = require("@budibase/backend-core/tenancy")
-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 { DocumentType, generateUserMetadataID } = require("../../db/utils")
-const { startup } = require("../../startup")
 
 const GLOBAL_USER_ID = "us_uuid1"
 const EMAIL = "babs@babs.com"
@@ -35,10 +38,26 @@ const LASTNAME = "Barbington"
 const CSRF_TOKEN = "e3727778-7af0-4226-b5eb-f43cbe60a306"
 
 class TestConfiguration {
+  server: any
+  request: any
+  started: boolean
+  appId: string | null
+  allApps: any[]
+  app: any
+  prodApp: any
+  prodAppId: any
+  user: any
+  globalUserId: any
+  userMetadataId: any
+  table: any
+  linkedTable: any
+  automation: any
+  datasource: any
+
   constructor(openServer = true) {
     if (openServer) {
       // use a random port because it doesn't matter
-      env.PORT = 0
+      env.PORT = "0"
       this.server = require("../../app")
       // we need the request for logging in, involves cookies, hard to fake
       this.request = supertest(this.server)
@@ -79,11 +98,11 @@ class TestConfiguration {
     }
   }
 
-  async doInContext(appId, task) {
+  async doInContext(appId: string | null, task: any) {
     if (!appId) {
       appId = this.appId
     }
-    return doInTenant(TENANT_ID, () => {
+    return tenancy.doInTenant(TENANT_ID, () => {
       // check if already in a context
       if (context.getAppId() == null && appId !== null) {
         return context.doInAppContext(appId, async () => {
@@ -116,14 +135,16 @@ class TestConfiguration {
     if (this.server) {
       this.server.close()
     }
-    cleanup(this.allApps.map(app => app.appId))
+    if (this.allApps) {
+      cleanup(this.allApps.map(app => app.appId))
+    }
   }
 
   // UTILS
 
-  async _req(body, params, controlFunc) {
+  async _req(body: any, params: any, controlFunc: any) {
     // create a fake request ctx
-    const request = {}
+    const request: any = {}
     const appId = this.appId
     request.appId = appId
     // fake cookies, we don't need them
@@ -152,8 +173,8 @@ class TestConfiguration {
     admin = false,
     email = EMAIL,
     roles,
-  } = {}) {
-    return doWithGlobalDB(TENANT_ID, async db => {
+  }: any = {}) {
+    return tenancy.doWithGlobalDB(TENANT_ID, async (db: any) => {
       let existing
       try {
         existing = await db.get(id)
@@ -168,7 +189,7 @@ class TestConfiguration {
         firstName,
         lastName,
       }
-      await createASession(id, {
+      await sessions.createASession(id, {
         sessionId: "sessionid",
         tenantId: TENANT_ID,
         csrfToken: CSRF_TOKEN,
@@ -210,14 +231,14 @@ class TestConfiguration {
       admin,
       roles,
     })
-    await userCache.invalidateUser(globalId)
+    await cache.user.invalidateUser(globalId)
     return {
       ...resp,
       globalId,
     }
   }
 
-  async login({ roleId, userId, builder, prodApp = false } = {}) {
+  async login({ roleId, userId, builder, prodApp = false }: any = {}) {
     const appId = prodApp ? this.prodAppId : this.appId
     return context.doInAppContext(appId, async () => {
       userId = !userId ? `us_uuid1` : userId
@@ -225,19 +246,19 @@ class TestConfiguration {
         throw "Server has not been opened, cannot login."
       }
       // make sure the user exists in the global DB
-      if (roleId !== BUILTIN_ROLE_IDS.PUBLIC) {
+      if (roleId !== roles.BUILTIN_ROLE_IDS.PUBLIC) {
         await this.globalUser({
           id: userId,
           builder,
           roles: { [this.prodAppId]: roleId },
         })
       }
-      await createASession(userId, {
+      await sessions.createASession(userId, {
         sessionId: "sessionid",
         tenantId: TENANT_ID,
       })
       // have to fake this
-      const auth = {
+      const authObj = {
         userId,
         sessionId: "sessionid",
         tenantId: TENANT_ID,
@@ -246,45 +267,45 @@ class TestConfiguration {
         roleId: roleId,
         appId,
       }
-      const authToken = jwt.sign(auth, env.JWT_SECRET)
-      const appToken = jwt.sign(app, env.JWT_SECRET)
+      const authToken = auth.jwt.sign(authObj, env.JWT_SECRET)
+      const appToken = auth.jwt.sign(app, env.JWT_SECRET)
 
       // returning necessary request headers
-      await userCache.invalidateUser(userId)
+      await cache.user.invalidateUser(userId)
       return {
         Accept: "application/json",
         Cookie: [
-          `${Cookies.Auth}=${authToken}`,
-          `${Cookies.CurrentApp}=${appToken}`,
+          `${constants.Cookie.Auth}=${authToken}`,
+          `${constants.Cookie.CurrentApp}=${appToken}`,
         ],
-        [Headers.APP_ID]: appId,
+        [constants.Header.APP_ID]: appId,
       }
     })
   }
 
   defaultHeaders(extras = {}) {
-    const auth = {
+    const authObj = {
       userId: GLOBAL_USER_ID,
       sessionId: "sessionid",
       tenantId: TENANT_ID,
     }
     const app = {
-      roleId: BUILTIN_ROLE_IDS.ADMIN,
+      roleId: roles.BUILTIN_ROLE_IDS.ADMIN,
       appId: this.appId,
     }
-    const authToken = jwt.sign(auth, env.JWT_SECRET)
-    const appToken = jwt.sign(app, env.JWT_SECRET)
-    const headers = {
+    const authToken = auth.jwt.sign(authObj, env.JWT_SECRET)
+    const appToken = auth.jwt.sign(app, env.JWT_SECRET)
+    const headers: any = {
       Accept: "application/json",
       Cookie: [
-        `${Cookies.Auth}=${authToken}`,
-        `${Cookies.CurrentApp}=${appToken}`,
+        `${constants.Cookie.Auth}=${authToken}`,
+        `${constants.Cookie.CurrentApp}=${appToken}`,
       ],
-      [Headers.CSRF_TOKEN]: CSRF_TOKEN,
+      [constants.Header.CSRF_TOKEN]: CSRF_TOKEN,
       ...extras,
     }
     if (this.appId) {
-      headers[Headers.APP_ID] = this.appId
+      headers[constants.Header.APP_ID] = this.appId
     }
     return headers
   }
@@ -292,18 +313,18 @@ class TestConfiguration {
   publicHeaders({ prodApp = true } = {}) {
     const appId = prodApp ? this.prodAppId : this.appId
 
-    const headers = {
+    const headers: any = {
       Accept: "application/json",
     }
     if (appId) {
-      headers[Headers.APP_ID] = appId
+      headers[constants.Header.APP_ID] = appId
     }
     return headers
   }
 
   async roleHeaders({
     email = EMAIL,
-    roleId = BUILTIN_ROLE_IDS.ADMIN,
+    roleId = roles.BUILTIN_ROLE_IDS.ADMIN,
     builder = false,
     prodApp = true,
   } = {}) {
@@ -313,15 +334,17 @@ class TestConfiguration {
   // API
 
   async generateApiKey(userId = GLOBAL_USER_ID) {
-    return doWithGlobalDB(TENANT_ID, async db => {
-      const id = generateDevInfoID(userId)
+    return tenancy.doWithGlobalDB(TENANT_ID, async (db: any) => {
+      const id = dbCore.generateDevInfoID(userId)
       let devInfo
       try {
         devInfo = await db.get(id)
       } catch (err) {
         devInfo = { _id: id, userId }
       }
-      devInfo.apiKey = encrypt(`${TENANT_ID}${SEPARATOR}${newid()}`)
+      devInfo.apiKey = encryption.encrypt(
+        `${TENANT_ID}${dbCore.SEPARATOR}${newid()}`
+      )
       await db.put(devInfo)
       return devInfo.apiKey
     })
@@ -329,13 +352,15 @@ class TestConfiguration {
 
   // APP
 
-  async createApp(appName) {
+  async createApp(appName: string) {
     // create dev app
     // clear any old app
     this.appId = null
+    // @ts-ignore
     await context.updateAppId(null)
     this.app = await this._req({ name: appName }, null, controllers.app.create)
     this.appId = this.app.appId
+    // @ts-ignore
     await context.updateAppId(this.appId)
 
     // create production app
@@ -349,40 +374,41 @@ class TestConfiguration {
 
   async deploy() {
     await this._req(null, null, controllers.deploy.deployApp)
+    // @ts-ignore
     const prodAppId = this.getAppId().replace("_dev", "")
     this.prodAppId = prodAppId
 
     return context.doInAppContext(prodAppId, async () => {
       const db = context.getProdAppDB()
-      return await db.get(DocumentType.APP_METADATA)
+      return await db.get(dbCore.DocumentType.APP_METADATA)
     })
   }
 
   // TABLE
 
-  async updateTable(config = null) {
+  async updateTable(config?: any) {
     config = config || basicTable()
     this.table = await this._req(config, null, controllers.table.save)
     return this.table
   }
 
-  async createTable(config = null) {
+  async createTable(config?: any) {
     if (config != null && config._id) {
       delete config._id
     }
     return this.updateTable(config)
   }
 
-  async getTable(tableId = null) {
+  async getTable(tableId?: string) {
     tableId = tableId || this.table._id
     return this._req(null, { tableId }, controllers.table.find)
   }
 
-  async createLinkedTable(relationshipType = null, links = ["link"]) {
+  async createLinkedTable(relationshipType?: string, links: any = ["link"]) {
     if (!this.table) {
       throw "Must have created a table first."
     }
-    const tableConfig = basicTable()
+    const tableConfig: any = basicTable()
     tableConfig.primaryDisplay = "name"
     for (let link of links) {
       tableConfig.schema[link] = {
@@ -401,7 +427,7 @@ class TestConfiguration {
   }
 
   async createAttachmentTable() {
-    const table = basicTable()
+    const table: any = basicTable()
     table.schema.attachment = {
       type: "attachment",
     }
@@ -410,7 +436,7 @@ class TestConfiguration {
 
   // ROW
 
-  async createRow(config = null) {
+  async createRow(config: any = null) {
     if (!this.table) {
       throw "Test requires table to be configured."
     }
@@ -419,11 +445,11 @@ class TestConfiguration {
     return this._req(config, { tableId }, controllers.row.save)
   }
 
-  async getRow(tableId, rowId) {
+  async getRow(tableId: string, rowId: string) {
     return this._req(null, { tableId, rowId }, controllers.row.find)
   }
 
-  async getRows(tableId) {
+  async getRows(tableId: string) {
     if (!tableId && this.table) {
       tableId = this.table._id
     }
@@ -432,12 +458,12 @@ class TestConfiguration {
 
   // ROLE
 
-  async createRole(config = null) {
+  async createRole(config?: any) {
     config = config || basicRole()
     return this._req(config, null, controllers.role.save)
   }
 
-  async addPermission(roleId, resourceId, level = "read") {
+  async addPermission(roleId: string, resourceId: string, level = "read") {
     return this._req(
       null,
       {
@@ -451,7 +477,7 @@ class TestConfiguration {
 
   // VIEW
 
-  async createView(config) {
+  async createView(config?: any) {
     if (!this.table) {
       throw "Test requires table to be configured."
     }
@@ -464,7 +490,7 @@ class TestConfiguration {
 
   // AUTOMATION
 
-  async createAutomation(config) {
+  async createAutomation(config?: any) {
     config = config || basicAutomation()
     if (config._rev) {
       delete config._rev
@@ -479,7 +505,7 @@ class TestConfiguration {
     return this._req(null, null, controllers.automation.fetch)
   }
 
-  async deleteAutomation(automation = null) {
+  async deleteAutomation(automation?: any) {
     automation = automation || this.automation
     if (!automation) {
       return
@@ -491,7 +517,7 @@ class TestConfiguration {
     )
   }
 
-  async createWebhook(config = null) {
+  async createWebhook(config?: any) {
     if (!this.automation) {
       throw "Must create an automation before creating webhook."
     }
@@ -501,14 +527,14 @@ class TestConfiguration {
 
   // DATASOURCE
 
-  async createDatasource(config = null) {
+  async createDatasource(config?: any) {
     config = config || basicDatasource()
     const response = await this._req(config, null, controllers.datasource.save)
     this.datasource = response.datasource
     return this.datasource
   }
 
-  async updateDatasource(datasource) {
+  async updateDatasource(datasource: any) {
     const response = await this._req(
       datasource,
       { datasourceId: datasource._id },
@@ -518,7 +544,7 @@ class TestConfiguration {
     return this.datasource
   }
 
-  async restDatasource(cfg) {
+  async restDatasource(cfg?: any) {
     return this.createDatasource({
       datasource: {
         ...basicDatasource().datasource,
@@ -553,7 +579,14 @@ class TestConfiguration {
 
   // QUERY
 
-  async previewQuery(request, config, datasource, fields, params, verb) {
+  async previewQuery(
+    request: any,
+    config: any,
+    datasource: any,
+    fields: any,
+    params: any,
+    verb: string
+  ) {
     return request
       .post(`/api/queries/preview`)
       .send({
@@ -568,7 +601,7 @@ class TestConfiguration {
       .expect(200)
   }
 
-  async createQuery(config = null) {
+  async createQuery(config?: any) {
     if (!this.datasource && !config) {
       throw "No datasource created for query."
     }
@@ -578,17 +611,17 @@ class TestConfiguration {
 
   // SCREEN
 
-  async createScreen(config = null) {
+  async createScreen(config?: any) {
     config = config || basicScreen()
     return this._req(config, null, controllers.screen.save)
   }
 
   // LAYOUT
 
-  async createLayout(config = null) {
+  async createLayout(config?: any) {
     config = config || basicLayout()
     return await this._req(config, null, controllers.layout.save)
   }
 }
 
-module.exports = TestConfiguration
+export = TestConfiguration

package/src/tests/utilities/controllers.ts

@@ -0,0 +1,14 @@
+export * as table from "../../api/controllers/table"
+export * as row from "../../api/controllers/row"
+export * as role from "../../api/controllers/role"
+export * as perms from "../../api/controllers/permission"
+export * as view from "../../api/controllers/view"
+export * as app from "../../api/controllers/application"
+export * as user from "../../api/controllers/user"
+export * as automation from "../../api/controllers/automation"
+export * as datasource from "../../api/controllers/datasource"
+export * as query from "../../api/controllers/query"
+export * as screen from "../../api/controllers/screen"
+export * as webhook from "../../api/controllers/webhook"
+export * as layout from "../../api/controllers/layout"
+export * as deploy from "../../api/controllers/deploy"

package/src/tests/utilities/{index.js → index.ts}

@@ -1,5 +1,5 @@
-exports.makePartial = obj => {
-  const newObj = {}
+export function makePartial(obj: any) {
+  const newObj: any = {}
   for (let key of Object.keys(obj)) {
     if (typeof obj[key] === "object") {
       newObj[key] = exports.makePartial(obj[key])