@budibase/server 1.0.199 → 1.0.200-alpha.2

package/src/tests/utilities/TestConfiguration.js

@@ -55,6 +55,10 @@ class TestConfiguration {
     return this.appId
   }
 
+  getProdAppId() {
+    return this.prodAppId
+  }
+
   async doInContext(appId, task) {
     if (!appId) {
       appId = this.appId
@@ -71,6 +75,26 @@ 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
@@ -91,24 +115,11 @@ class TestConfiguration {
     })
   }
 
-  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
-    })
-  }
-
+  // USER / AUTH
   async globalUser({
     id = GLOBAL_USER_ID,
     builder = true,
+    admin = false,
     email = EMAIL,
     roles,
   } = {}) {
@@ -135,6 +146,11 @@ 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,
@@ -143,20 +159,71 @@ class TestConfiguration {
     })
   }
 
-  // use a new id as the name to avoid name collisions
-  async init(appName = newid()) {
-    await this.globalUser()
-    return this.createApp(appName)
+  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,
+    }
   }
 
-  end() {
-    if (!this) {
-      return
-    }
-    if (this.server) {
-      this.server.close()
-    }
-    cleanup(this.allApps.map(app => app.appId))
+  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,
+      }
+    })
   }
 
   defaultHeaders(extras = {}) {
@@ -207,6 +274,25 @@ 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
@@ -239,6 +325,8 @@ class TestConfiguration {
     })
   }
 
+  // TABLE
+
   async updateTable(config = null) {
     config = config || basicTable()
     this.table = await this._req(config, null, controllers.table.save)
@@ -287,6 +375,8 @@ class TestConfiguration {
     return this.createTable(table)
   }
 
+  // ROW
+
   async createRow(config = null) {
     if (!this.table) {
       throw "Test requires table to be configured."
@@ -307,6 +397,8 @@ 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)
@@ -324,18 +416,21 @@ 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) {
@@ -363,6 +458,16 @@ 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)
@@ -413,6 +518,8 @@ class TestConfiguration {
     return { datasource, query: basedOnQuery }
   }
 
+  // QUERY
+
   async previewQuery(request, config, datasource, fields) {
     return request
       .post(`/api/queries/preview`)
@@ -436,78 +543,19 @@ 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)
   }
 
-  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
-  }
+  // LAYOUT
 
   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,6 +3,8 @@ 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"
 
@@ -28,6 +30,75 @@ 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,10 +1,25 @@
 {
-  // Used for building with tsc
-  "extends": "./tsconfig.json",
+  "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/**/*"
+  ],
   "exclude": [
     "node_modules",
-    "**/*.json",
-    "**/*.spec.js",
-    "**/*.spec.ts"
+    "dist",
+    "**/*.spec.ts",
+    "**/*.spec.js"
   ]
 }

package/tsconfig.json

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