@budibase/server 1.0.200-alpha.3 → 1.0.200

package/src/tests/utilities/TestConfiguration.js

@@ -55,10 +55,6 @@ class TestConfiguration {
     return this.appId
   }
 
-  getProdAppId() {
-    return this.prodAppId
-  }
-
   async doInContext(appId, task) {
     if (!appId) {
       appId = this.appId
@@ -75,26 +71,6 @@ class TestConfiguration {
     })
   }
 
-  // SETUP /  TEARDOWN
-
-  // use a new id as the name to avoid name collisions
-  async init(appName = newid()) {
-    await this.globalUser()
-    return this.createApp(appName)
-  }
-
-  end() {
-    if (!this) {
-      return
-    }
-    if (this.server) {
-      this.server.close()
-    }
-    cleanup(this.allApps.map(app => app.appId))
-  }
-
-  // UTILS
-
   async _req(config, params, controlFunc) {
     const request = {}
     // fake cookies, we don't need them
@@ -115,11 +91,24 @@ class TestConfiguration {
     })
   }
 
-  // USER / AUTH
+  async generateApiKey(userId = GLOBAL_USER_ID) {
+    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 = encrypt(`${TENANT_ID}${SEPARATOR}${newid()}`)
+      await db.put(devInfo)
+      return devInfo.apiKey
+    })
+  }
+
   async globalUser({
     id = GLOBAL_USER_ID,
     builder = true,
-    admin = false,
     email = EMAIL,
     roles,
   } = {}) {
@@ -146,11 +135,6 @@ class TestConfiguration {
       } else {
         user.builder = { global: false }
       }
-      if (admin) {
-        user.admin = { global: true }
-      } else {
-        user.admin = { global: false }
-      }
       const resp = await db.put(user)
       return {
         _rev: resp._rev,
@@ -159,71 +143,20 @@ class TestConfiguration {
     })
   }
 
-  async createUser(
-    id = null,
-    email = EMAIL,
-    builder = true,
-    admin = false,
-    roles = {}
-  ) {
-    const globalId = !id ? `us_${Math.random()}` : `us_${id}`
-    const resp = await this.globalUser({
-      id: globalId,
-      email,
-      builder,
-      admin,
-      roles,
-    })
-    await userCache.invalidateUser(globalId)
-    return {
-      ...resp,
-      globalId,
-    }
+  // use a new id as the name to avoid name collisions
+  async init(appName = newid()) {
+    await this.globalUser()
+    return this.createApp(appName)
   }
 
-  async login({ roleId, userId, builder, prodApp = false } = {}) {
-    const appId = prodApp ? this.prodAppId : this.appId
-    return context.doInAppContext(appId, async () => {
-      userId = !userId ? `us_uuid1` : userId
-      if (!this.request) {
-        throw "Server has not been opened, cannot login."
-      }
-      // make sure the user exists in the global DB
-      if (roleId !== BUILTIN_ROLE_IDS.PUBLIC) {
-        await this.globalUser({
-          id: userId,
-          builder,
-          roles: { [this.prodAppId]: roleId },
-        })
-      }
-      await createASession(userId, {
-        sessionId: "sessionid",
-        tenantId: TENANT_ID,
-      })
-      // have to fake this
-      const auth = {
-        userId,
-        sessionId: "sessionid",
-        tenantId: TENANT_ID,
-      }
-      const app = {
-        roleId: roleId,
-        appId,
-      }
-      const authToken = jwt.sign(auth, env.JWT_SECRET)
-      const appToken = jwt.sign(app, env.JWT_SECRET)
-
-      // returning necessary request headers
-      await userCache.invalidateUser(userId)
-      return {
-        Accept: "application/json",
-        Cookie: [
-          `${Cookies.Auth}=${authToken}`,
-          `${Cookies.CurrentApp}=${appToken}`,
-        ],
-        [Headers.APP_ID]: appId,
-      }
-    })
+  end() {
+    if (!this) {
+      return
+    }
+    if (this.server) {
+      this.server.close()
+    }
+    cleanup(this.allApps.map(app => app.appId))
   }
 
   defaultHeaders(extras = {}) {
@@ -274,25 +207,6 @@ class TestConfiguration {
     return this.login({ email, roleId, builder, prodApp })
   }
 
-  // API
-
-  async generateApiKey(userId = GLOBAL_USER_ID) {
-    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 = encrypt(`${TENANT_ID}${SEPARATOR}${newid()}`)
-      await db.put(devInfo)
-      return devInfo.apiKey
-    })
-  }
-
-  // APP
-
   async createApp(appName) {
     // create dev app
     // clear any old app
@@ -325,8 +239,6 @@ class TestConfiguration {
     })
   }
 
-  // TABLE
-
   async updateTable(config = null) {
     config = config || basicTable()
     this.table = await this._req(config, null, controllers.table.save)
@@ -375,8 +287,6 @@ class TestConfiguration {
     return this.createTable(table)
   }
 
-  // ROW
-
   async createRow(config = null) {
     if (!this.table) {
       throw "Test requires table to be configured."
@@ -397,8 +307,6 @@ class TestConfiguration {
     return this._req(null, { tableId }, controllers.row.fetch)
   }
 
-  // ROLE
-
   async createRole(config = null) {
     config = config || basicRole()
     return this._req(config, null, controllers.role.save)
@@ -416,21 +324,18 @@ class TestConfiguration {
     )
   }
 
-  // VIEW
-
   async createView(config) {
     if (!this.table) {
       throw "Test requires table to be configured."
     }
     const view = config || {
+      map: "function(doc) { emit(doc[doc.key], doc._id); } ",
       tableId: this.table._id,
       name: "ViewTest",
     }
     return this._req(view, null, controllers.view.save)
   }
 
-  // AUTOMATION
-
   async createAutomation(config) {
     config = config || basicAutomation()
     if (config._rev) {
@@ -458,16 +363,6 @@ class TestConfiguration {
     )
   }
 
-  async createWebhook(config = null) {
-    if (!this.automation) {
-      throw "Must create an automation before creating webhook."
-    }
-    config = config || basicWebhook(this.automation._id)
-    return (await this._req(config, null, controllers.webhook.save)).webhook
-  }
-
-  // DATASOURCE
-
   async createDatasource(config = null) {
     config = config || basicDatasource()
     const response = await this._req(config, null, controllers.datasource.save)
@@ -518,8 +413,6 @@ class TestConfiguration {
     return { datasource, query: basedOnQuery }
   }
 
-  // QUERY
-
   async previewQuery(request, config, datasource, fields) {
     return request
       .post(`/api/queries/preview`)
@@ -543,19 +436,78 @@ class TestConfiguration {
     return this._req(config, null, controllers.query.save)
   }
 
-  // SCREEN
-
   async createScreen(config = null) {
     config = config || basicScreen()
     return this._req(config, null, controllers.screen.save)
   }
 
-  // LAYOUT
+  async createWebhook(config = null) {
+    if (!this.automation) {
+      throw "Must create an automation before creating webhook."
+    }
+    config = config || basicWebhook(this.automation._id)
+    return (await this._req(config, null, controllers.webhook.save)).webhook
+  }
 
   async createLayout(config = null) {
     config = config || basicLayout()
     return await this._req(config, null, controllers.layout.save)
   }
+
+  async createUser(id = null, email = EMAIL) {
+    const globalId = !id ? `us_${Math.random()}` : `us_${id}`
+    const resp = await this.globalUser({ id: globalId, email })
+    await userCache.invalidateUser(globalId)
+    return {
+      ...resp,
+      globalId,
+    }
+  }
+
+  async login({ roleId, userId, builder, prodApp = false } = {}) {
+    const appId = prodApp ? this.prodAppId : this.appId
+    return context.doInAppContext(appId, async () => {
+      userId = !userId ? `us_uuid1` : userId
+      if (!this.request) {
+        throw "Server has not been opened, cannot login."
+      }
+      // make sure the user exists in the global DB
+      if (roleId !== BUILTIN_ROLE_IDS.PUBLIC) {
+        await this.globalUser({
+          id: userId,
+          builder,
+          roles: { [this.prodAppId]: roleId },
+        })
+      }
+      await createASession(userId, {
+        sessionId: "sessionid",
+        tenantId: TENANT_ID,
+      })
+      // have to fake this
+      const auth = {
+        userId,
+        sessionId: "sessionid",
+        tenantId: TENANT_ID,
+      }
+      const app = {
+        roleId: roleId,
+        appId,
+      }
+      const authToken = jwt.sign(auth, env.JWT_SECRET)
+      const appToken = jwt.sign(app, env.JWT_SECRET)
+
+      // returning necessary request headers
+      await userCache.invalidateUser(userId)
+      return {
+        Accept: "application/json",
+        Cookie: [
+          `${Cookies.Auth}=${authToken}`,
+          `${Cookies.CurrentApp}=${appToken}`,
+        ],
+        [Headers.APP_ID]: appId,
+      }
+    })
+  }
 }
 
 module.exports = TestConfiguration

package/src/tests/utilities/structures.js

@@ -3,8 +3,6 @@ const { BUILTIN_PERMISSION_IDS } = require("@budibase/backend-core/permissions")
 const { createHomeScreen } = require("../../constants/screens")
 const { EMPTY_LAYOUT } = require("../../constants/layouts")
 const { cloneDeep } = require("lodash/fp")
-const { v4: uuidv4 } = require("uuid")
-const { TRIGGER_DEFINITIONS, ACTION_DEFINITIONS } = require("../../automations")
 
 exports.TENANT_ID = "default"
 
@@ -30,75 +28,6 @@ exports.basicTable = () => {
   }
 }
 
-exports.basicView = tableId => {
-  return {
-    tableId,
-    name: "ViewTest",
-  }
-}
-
-exports.filterView = tableId => {
-  return {
-    ...this.basicView(tableId),
-    filters: [
-      {
-        value: 0,
-        condition: "MT",
-        key: "count",
-      },
-    ],
-  }
-}
-
-exports.calculationView = tableId => {
-  return {
-    ...this.basicView(tableId),
-    field: "count",
-    calculation: "sum",
-  }
-}
-
-exports.view = tableId => {
-  return {
-    ...this.filterView(tableId),
-    ...this.calculationView(tableId),
-  }
-}
-
-exports.automationStep = (actionDefinition = ACTION_DEFINITIONS.CREATE_ROW) => {
-  return {
-    id: uuidv4(),
-    ...actionDefinition,
-  }
-}
-
-exports.automationTrigger = (
-  triggerDefinition = TRIGGER_DEFINITIONS.ROW_SAVED
-) => {
-  return {
-    id: uuidv4(),
-    ...triggerDefinition,
-  }
-}
-
-exports.newAutomation = ({ steps, trigger } = {}) => {
-  const automation = exports.basicAutomation()
-
-  if (trigger) {
-    automation.definition.trigger = trigger
-  } else {
-    automation.definition.trigger = exports.automationTrigger()
-  }
-
-  if (steps) {
-    automation.definition.steps = steps
-  } else {
-    automation.definition.steps = [exports.automationStep()]
-  }
-
-  return automation
-}
-
 exports.basicAutomation = () => {
   return {
     name: "My Automation",

package/tsconfig.build.json

@@ -1,25 +1,10 @@
 {
-  "compilerOptions": {
-    "target": "es6",
-    "module": "commonjs",
-    "lib": ["es2020"],
-    "allowJs": true,
-    "strict": true,
-    "noImplicitAny": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "incremental": true,
-    "types": [ "node", "jest" ],
-    "outDir": "dist",
-    "skipLibCheck": true
-  },
-  "include": [
-    "src/**/*"
-  ],
+  // Used for building with tsc
+  "extends": "./tsconfig.json",
   "exclude": [
     "node_modules",
-    "dist",
-    "**/*.spec.ts",
-    "**/*.spec.js"
+    "**/*.json",
+    "**/*.spec.js",
+    "**/*.spec.ts"
   ]
 }

package/tsconfig.json

@@ -1,30 +1,25 @@
 {
-  "extends": "./tsconfig.build.json",
   "compilerOptions": {
-    "composite": true,
-    "declaration": true,
-    "sourceMap": true,
-    "baseUrl": ".",
-    "paths": {
-      "@budibase/types": ["../types/src"],
-      "@budibase/backend-core": ["../backend-core/src"],
-      "@budibase/backend-core/*": ["../backend-core/*"]
-    }
+    "target": "es6",
+    "module": "commonjs",
+    "lib": ["es2019"],
+    "allowJs": true,
+    "outDir": "dist",
+    "strict": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "incremental": true,
+    "types": [ "node", "jest"],
   },
-  "ts-node": {
-    "require": ["tsconfig-paths/register"]
-  },
-  "references": [
-    { "path": "../types" },
-    { "path": "../backend-core" },
-  ],
   "include": [
-    "src/**/*",
-    "specs",
-    "package.json"
+    "./src/**/*",
+    "./src/module.d.ts"
   ],
   "exclude": [
     "node_modules",
-    "dist"
+    "**/*.json",
+    "**/*.spec.js",
+    // "**/*.spec.ts" // don't exclude spec.ts files for editor support
   ]
-}
+}