@budibase/worker 2.2.3 → 2.2.4-alpha.0

package/jest.config.ts

@@ -19,6 +19,8 @@ if (!process.env.CI) {
   }
   // add pro sources if they exist
   if (fs.existsSync("../../../budibase-pro")) {
+    config.moduleNameMapper["@budibase/pro/(.*)"] =
+      "<rootDir>/../../../budibase-pro/packages/pro/$1"
     config.moduleNameMapper["@budibase/pro"] =
       "<rootDir>/../../../budibase-pro/packages/pro/src"
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "2.2.3",
+  "version": "2.2.4-alpha.0",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -36,10 +36,10 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "^2.2.3",
-    "@budibase/pro": "2.2.2",
-    "@budibase/string-templates": "^2.2.3",
-    "@budibase/types": "^2.2.3",
+    "@budibase/backend-core": "2.2.4-alpha.0",
+    "@budibase/pro": "2.2.3",
+    "@budibase/string-templates": "2.2.4-alpha.0",
+    "@budibase/types": "2.2.4-alpha.0",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
@@ -73,10 +73,11 @@
     "@types/jest": "26.0.23",
     "@types/jsonwebtoken": "8.5.1",
     "@types/koa": "2.13.4",
-    "@types/koa__router": "8.0.11",
+    "@types/koa__router": "8.0.8",
     "@types/node": "14.18.20",
     "@types/node-fetch": "2.6.1",
     "@types/pouchdb": "6.4.0",
+    "@types/server-destroy": "1.0.1",
     "@types/uuid": "8.3.4",
     "@typescript-eslint/parser": "5.45.0",
     "copyfiles": "2.4.1",
@@ -94,5 +95,5 @@
     "typescript": "4.7.3",
     "update-dotenv": "1.1.1"
   },
-  "gitHead": "1fee98510b81d27546acc7fa1dbcfb89784c8802"
+  "gitHead": "e4f14f013c9627ba5c97aed22a30b697dc9bbcb9"
 }

package/src/api/controllers/global/configs.ts

@@ -7,6 +7,7 @@ import {
   objectStore,
   tenancy,
   db as dbCore,
+  env as coreEnv,
 } from "@budibase/backend-core"
 import { checkAnyUserExists } from "../../../utilities/users"
 import {
@@ -17,127 +18,106 @@ import {
   GoogleConfig,
   OIDCConfig,
   SettingsConfig,
-  BBContext,
+  isGoogleConfig,
+  isOIDCConfig,
+  isSettingsConfig,
+  isSMTPConfig,
+  Ctx,
+  UserCtx,
 } from "@budibase/types"
 
 const getEventFns = async (db: Database, config: ConfigDoc) => {
   const fns = []
-  const type = config.type
 
   let existing
   if (config._id) {
     existing = await db.get(config._id)
   }
 
-  const ssoType = type as SSOType
   if (!existing) {
-    switch (config.type) {
-      case ConfigType.SMTP: {
-        fns.push(events.email.SMTPCreated)
-        break
+    if (isSMTPConfig(config)) {
+      fns.push(events.email.SMTPCreated)
+    } else if (isGoogleConfig(config)) {
+      fns.push(() => events.auth.SSOCreated(ConfigType.GOOGLE))
+      if (config.config.activated) {
+        fns.push(() => events.auth.SSOActivated(ConfigType.GOOGLE))
       }
-      case ConfigType.GOOGLE: {
-        const googleCfg = config as GoogleConfig
-        fns.push(() => events.auth.SSOCreated(ssoType))
-        if (googleCfg.config.activated) {
-          fns.push(() => events.auth.SSOActivated(ssoType))
-        }
-        break
+    } else if (isOIDCConfig(config)) {
+      fns.push(() => events.auth.SSOCreated(ConfigType.OIDC))
+      if (config.config.configs[0].activated) {
+        fns.push(() => events.auth.SSOActivated(ConfigType.OIDC))
       }
-      case ConfigType.OIDC: {
-        const oidcCfg = config as OIDCConfig
-        fns.push(() => events.auth.SSOCreated(ssoType))
-        if (oidcCfg.config.configs[0].activated) {
-          fns.push(() => events.auth.SSOActivated(ssoType))
-        }
-        break
+    } else if (isSettingsConfig(config)) {
+      // company
+      const company = config.config.company
+      if (company && company !== "Budibase") {
+        fns.push(events.org.nameUpdated)
       }
-      case ConfigType.SETTINGS: {
-        // company
-        const settingsCfg = config as SettingsConfig
-        const company = settingsCfg.config.company
-        if (company && company !== "Budibase") {
-          fns.push(events.org.nameUpdated)
-        }
 
-        // logo
-        const logoUrl = settingsCfg.config.logoUrl
-        if (logoUrl) {
-          fns.push(events.org.logoUpdated)
-        }
+      // logo
+      const logoUrl = config.config.logoUrl
+      if (logoUrl) {
+        fns.push(events.org.logoUpdated)
+      }
 
-        // platform url
-        const platformUrl = settingsCfg.config.platformUrl
-        if (
-          platformUrl &&
-          platformUrl !== "http://localhost:10000" &&
-          env.SELF_HOSTED
-        ) {
-          fns.push(events.org.platformURLUpdated)
-        }
-        break
+      // platform url
+      const platformUrl = config.config.platformUrl
+      if (
+        platformUrl &&
+        platformUrl !== "http://localhost:10000" &&
+        env.SELF_HOSTED
+      ) {
+        fns.push(events.org.platformURLUpdated)
       }
     }
   } else {
-    switch (config.type) {
-      case ConfigType.SMTP: {
-        fns.push(events.email.SMTPUpdated)
-        break
+    if (isSMTPConfig(config)) {
+      fns.push(events.email.SMTPUpdated)
+    } else if (isGoogleConfig(config)) {
+      fns.push(() => events.auth.SSOUpdated(ConfigType.GOOGLE))
+      if (!existing.config.activated && config.config.activated) {
+        fns.push(() => events.auth.SSOActivated(ConfigType.GOOGLE))
+      } else if (existing.config.activated && !config.config.activated) {
+        fns.push(() => events.auth.SSODeactivated(ConfigType.GOOGLE))
       }
-      case ConfigType.GOOGLE: {
-        const googleCfg = config as GoogleConfig
-        fns.push(() => events.auth.SSOUpdated(ssoType))
-        if (!existing.config.activated && googleCfg.config.activated) {
-          fns.push(() => events.auth.SSOActivated(ssoType))
-        } else if (existing.config.activated && !googleCfg.config.activated) {
-          fns.push(() => events.auth.SSODeactivated(ssoType))
-        }
-        break
+    } else if (isOIDCConfig(config)) {
+      fns.push(() => events.auth.SSOUpdated(ConfigType.OIDC))
+      if (
+        !existing.config.configs[0].activated &&
+        config.config.configs[0].activated
+      ) {
+        fns.push(() => events.auth.SSOActivated(ConfigType.OIDC))
+      } else if (
+        existing.config.configs[0].activated &&
+        !config.config.configs[0].activated
+      ) {
+        fns.push(() => events.auth.SSODeactivated(ConfigType.OIDC))
       }
-      case ConfigType.OIDC: {
-        const oidcCfg = config as OIDCConfig
-        fns.push(() => events.auth.SSOUpdated(ssoType))
-        if (
-          !existing.config.configs[0].activated &&
-          oidcCfg.config.configs[0].activated
-        ) {
-          fns.push(() => events.auth.SSOActivated(ssoType))
-        } else if (
-          existing.config.configs[0].activated &&
-          !oidcCfg.config.configs[0].activated
-        ) {
-          fns.push(() => events.auth.SSODeactivated(ssoType))
-        }
-        break
+    } else if (isSettingsConfig(config)) {
+      // company
+      const existingCompany = existing.config.company
+      const company = config.config.company
+      if (company && company !== "Budibase" && existingCompany !== company) {
+        fns.push(events.org.nameUpdated)
       }
-      case ConfigType.SETTINGS: {
-        // company
-        const settingsCfg = config as SettingsConfig
-        const existingCompany = existing.config.company
-        const company = settingsCfg.config.company
-        if (company && company !== "Budibase" && existingCompany !== company) {
-          fns.push(events.org.nameUpdated)
-        }
 
-        // logo
-        const existingLogoUrl = existing.config.logoUrl
-        const logoUrl = settingsCfg.config.logoUrl
-        if (logoUrl && existingLogoUrl !== logoUrl) {
-          fns.push(events.org.logoUpdated)
-        }
+      // logo
+      const existingLogoUrl = existing.config.logoUrl
+      const logoUrl = config.config.logoUrl
+      if (logoUrl && existingLogoUrl !== logoUrl) {
+        fns.push(events.org.logoUpdated)
+      }
 
-        // platform url
-        const existingPlatformUrl = existing.config.platformUrl
-        const platformUrl = settingsCfg.config.platformUrl
-        if (
-          platformUrl &&
-          platformUrl !== "http://localhost:10000" &&
-          existingPlatformUrl !== platformUrl &&
-          env.SELF_HOSTED
-        ) {
-          fns.push(events.org.platformURLUpdated)
-        }
-        break
+      // platform url
+      const existingPlatformUrl = existing.config.platformUrl
+      const platformUrl = config.config.platformUrl
+      if (
+        platformUrl &&
+        platformUrl !== "http://localhost:10000" &&
+        existingPlatformUrl !== platformUrl &&
+        env.SELF_HOSTED
+      ) {
+        fns.push(events.org.platformURLUpdated)
       }
     }
   }
@@ -145,7 +125,7 @@ const getEventFns = async (db: Database, config: ConfigDoc) => {
   return fns
 }
 
-export async function save(ctx: BBContext) {
+export async function save(ctx: UserCtx) {
   const db = tenancy.getGlobalDB()
   const { type, workspace, user, config } = ctx.request.body
   let eventFns = await getEventFns(db, ctx.request.body)
@@ -187,7 +167,7 @@ export async function save(ctx: BBContext) {
   }
 }
 
-export async function fetch(ctx: BBContext) {
+export async function fetch(ctx: UserCtx) {
   const db = tenancy.getGlobalDB()
   const response = await db.allDocs(
     dbCore.getConfigParams(
@@ -204,7 +184,7 @@ export async function fetch(ctx: BBContext) {
  * Gets the most granular config for a particular configuration type.
  * The hierarchy is type -> workspace -> user.
  */
-export async function find(ctx: BBContext) {
+export async function find(ctx: UserCtx) {
   const db = tenancy.getGlobalDB()
 
   const { userId, workspaceId } = ctx.query
@@ -237,18 +217,18 @@ export async function find(ctx: BBContext) {
   }
 }
 
-export async function publicOidc(ctx: BBContext) {
+export async function publicOidc(ctx: Ctx) {
   const db = tenancy.getGlobalDB()
   try {
     // Find the config with the most granular scope based on context
-    const oidcConfig = await dbCore.getScopedFullConfig(db, {
+    const oidcConfig: OIDCConfig = await dbCore.getScopedFullConfig(db, {
       type: ConfigType.OIDC,
     })
 
     if (!oidcConfig) {
       ctx.body = {}
     } else {
-      ctx.body = oidcConfig.config.configs.map((config: any) => ({
+      ctx.body = oidcConfig.config.configs.map(config => ({
         logo: config.logo,
         name: config.name,
         uuid: config.uuid,
@@ -259,7 +239,7 @@ export async function publicOidc(ctx: BBContext) {
   }
 }
 
-export async function publicSettings(ctx: BBContext) {
+export async function publicSettings(ctx: Ctx) {
   const db = tenancy.getGlobalDB()
 
   try {
@@ -285,6 +265,16 @@ export async function publicSettings(ctx: BBContext) {
       config = publicConfig
     }
 
+    // enrich the logo url
+    // empty url means deleted
+    if (config.config.logoUrl !== "") {
+      config.config.logoUrl = objectStore.getGlobalFileUrl(
+        "settings",
+        "logoUrl",
+        config.config.logoUrlEtag
+      )
+    }
+
     // google button flag
     if (googleConfig && googleConfig.config) {
       // activated by default for configs pre-activated flag
@@ -311,28 +301,17 @@ export async function publicSettings(ctx: BBContext) {
   }
 }
 
-export async function upload(ctx: BBContext) {
-  if (ctx.request.files == null || ctx.request.files.file.length > 1) {
+export async function upload(ctx: UserCtx) {
+  if (ctx.request.files == null || Array.isArray(ctx.request.files.file)) {
     ctx.throw(400, "One file must be uploaded.")
   }
   const file = ctx.request.files.file
   const { type, name } = ctx.params
 
-  let bucket
-  if (env.SELF_HOSTED) {
-    bucket = objectStore.ObjectStoreBuckets.GLOBAL
-  } else {
-    bucket = objectStore.ObjectStoreBuckets.GLOBAL_CLOUD
-  }
-
-  let key
-  if (env.MULTI_TENANCY) {
-    key = `${tenancy.getTenantId()}/${type}/${name}`
-  } else {
-    key = `${type}/${name}`
-  }
+  let bucket = coreEnv.GLOBAL_BUCKET_NAME
+  const key = objectStore.getGlobalFileS3Key(type, name)
 
-  await objectStore.upload({
+  const result = await objectStore.upload({
     bucket,
     filename: key,
     path: file.path,
@@ -349,24 +328,26 @@ export async function upload(ctx: BBContext) {
       config: {},
     }
   }
-  let url
-  if (env.SELF_HOSTED) {
-    url = `/${bucket}/${key}`
-  } else {
-    url = `${env.CDN_URL}/${key}`
+
+  // save the Etag for cache bursting
+  const etag = result.ETag
+  if (etag) {
+    cfgStructure.config[`${name}Etag`] = etag.replace(/"/g, "")
   }
 
-  cfgStructure.config[`${name}`] = url
-  // write back to db with url updated
+  // save the file key
+  cfgStructure.config[`${name}`] = key
+
+  // write back to db
   await db.put(cfgStructure)
 
   ctx.body = {
     message: "File has been uploaded and url stored to config.",
-    url,
+    url: objectStore.getGlobalFileUrl(type, name, etag),
   }
 }
 
-export async function destroy(ctx: BBContext) {
+export async function destroy(ctx: UserCtx) {
   const db = tenancy.getGlobalDB()
   const { id, rev } = ctx.params
   try {
@@ -378,7 +359,7 @@ export async function destroy(ctx: BBContext) {
   }
 }
 
-export async function configChecklist(ctx: BBContext) {
+export async function configChecklist(ctx: Ctx) {
   const db = tenancy.getGlobalDB()
   const tenantId = tenancy.getTenantId()
 

package/src/api/controllers/global/users.ts

@@ -178,7 +178,7 @@ export const find = async (ctx: any) => {
 
 export const tenantUserLookup = async (ctx: any) => {
   const id = ctx.params.id
-  const user = await tenancy.getTenantUser(id)
+  const user = await sdk.users.getPlatformUser(id)
   if (user) {
     ctx.body = user
   } else {

package/src/api/routes/global/license.ts

@@ -10,4 +10,4 @@ router
   .delete("/api/global/license/info", controller.deleteInfo)
   .get("/api/global/license/usage", controller.getQuotaUsage)
 
-export = router
+export default router

package/src/api/routes/global/tests/groups.spec.ts

@@ -0,0 +1,58 @@
+import { events } from "@budibase/backend-core"
+import { structures, TestConfiguration, mocks } from "../../../../tests"
+
+describe("/api/global/groups", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  beforeEach(async () => {
+    mocks.licenses.useGroups()
+  })
+
+  describe("create", () => {
+    it("should be able to create a new group", async () => {
+      const group = structures.groups.UserGroup()
+      await config.api.groups.saveGroup(group)
+      expect(events.group.created).toBeCalledTimes(1)
+      expect(events.group.updated).not.toBeCalled()
+      expect(events.group.permissionsEdited).not.toBeCalled()
+    })
+  })
+
+  describe("update", () => {
+    it("should be able to update a basic group", async () => {
+      const group = structures.groups.UserGroup()
+      let oldGroup = await config.api.groups.saveGroup(group)
+
+      let updatedGroup = {
+        ...oldGroup.body,
+        ...group,
+        name: "New Name",
+      }
+      await config.api.groups.saveGroup(updatedGroup)
+
+      expect(events.group.updated).toBeCalledTimes(1)
+      expect(events.group.permissionsEdited).not.toBeCalled()
+    })
+
+    describe("destroy", () => {
+      it("should be able to delete a basic group", async () => {
+        const group = structures.groups.UserGroup()
+        let oldGroup = await config.api.groups.saveGroup(group)
+        await config.api.groups.deleteGroup(
+          oldGroup.body._id,
+          oldGroup.body._rev
+        )
+
+        expect(events.group.deleted).toBeCalledTimes(1)
+      })
+    })
+  })
+})

package/src/api/routes/global/tests/license.spec.ts

@@ -1,7 +1,5 @@
 import { TestConfiguration } from "../../../../tests"
 
-// TODO
-
 describe("/api/global/license", () => {
   const config = new TestConfiguration()
 

package/src/api/routes/global/tests/roles.spec.ts

@@ -1,11 +1,47 @@
-import { TestConfiguration } from "../../../../tests"
+import { structures, TestConfiguration } from "../../../../tests"
+import { context, db, permissions, roles } from "@budibase/backend-core"
+import { Mock } from "jest-mock"
 
-// TODO
+jest.mock("@budibase/backend-core", () => {
+  const core = jest.requireActual("@budibase/backend-core")
+  return {
+    ...core,
+    db: {
+      ...core.db,
+    },
+    context: {
+      ...core.context,
+      getAppDB: jest.fn(),
+    },
+  }
+})
+
+const appDb = db.getDB("app_test")
+const mockAppDB = context.getAppDB as Mock
+mockAppDB.mockReturnValue(appDb)
+
+async function addAppMetadata() {
+  await appDb.put({
+    _id: "app_metadata",
+    appId: "app_test",
+    name: "New App",
+    version: "version",
+    url: "url",
+  })
+}
 
 describe("/api/global/roles", () => {
   const config = new TestConfiguration()
+  const role = new roles.Role(
+    db.generateRoleID("newRole"),
+    roles.BUILTIN_ROLE_IDS.BASIC,
+    permissions.BuiltinPermissionID.READ_ONLY
+  )
 
   beforeAll(async () => {
+    console.debug(role)
+    appDb.put(role)
+    await addAppMetadata()
     await config.beforeAll()
   })
 
@@ -18,10 +54,35 @@ describe("/api/global/roles", () => {
   })
 
   describe("GET /api/global/roles", () => {
-    it("retrieves roles", () => {})
+    it("retrieves roles", async () => {
+      const res = await config.api.roles.get()
+      expect(res.body).toBeDefined()
+      expect(res.body["app_test"].roles.length).toEqual(5)
+      expect(res.body["app_test"].roles.map((r: any) => r._id)).toContain(
+        role._id
+      )
+    })
   })
 
-  describe("GET /api/global/roles/:appId", () => {})
+  describe("GET api/global/roles/:appId", () => {
+    it("finds a role by appId", async () => {
+      const res = await config.api.roles.find("app_test")
+      expect(res.body).toBeDefined()
+      expect(res.body.name).toEqual("New App")
+    })
+  })
 
-  describe("DELETE /api/global/roles/:appId", () => {})
+  describe("DELETE /api/global/roles/:appId", () => {
+    it("removes an app role", async () => {
+      let user = structures.users.user()
+      user.roles = {
+        app_test: "role1",
+      }
+      const userResponse = await config.createUser(user)
+      const res = await config.api.roles.remove("app_test")
+      const updatedUser = await config.api.users.getUser(userResponse._id!)
+      expect(updatedUser.body.roles).not.toHaveProperty("app_test")
+      expect(res.body.message).toEqual("App role removed from all users")
+    })
+  })
 })