@budibase/server 2.1.43-alpha.2 → 2.1.43

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

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

package/src/tests/utilities/controllers.js

@@ -0,0 +1,16 @@
+module.exports = {
+  table: require("../../api/controllers/table"),
+  row: require("../../api/controllers/row"),
+  role: require("../../api/controllers/role"),
+  perms: require("../../api/controllers/permission"),
+  view: require("../../api/controllers/view"),
+  app: require("../../api/controllers/application"),
+  user: require("../../api/controllers/user"),
+  automation: require("../../api/controllers/automation"),
+  datasource: require("../../api/controllers/datasource"),
+  query: require("../../api/controllers/query"),
+  screen: require("../../api/controllers/screen"),
+  webhook: require("../../api/controllers/webhook"),
+  layout: require("../../api/controllers/layout"),
+  deploy: require("../../api/controllers/deploy"),
+}

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

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