@budibase/worker 2.2.12-alpha.2 → 2.2.12

package/jest.config.ts

@@ -19,8 +19,6 @@ 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.12-alpha.2",
+  "version": "2.2.12",
   "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.12-alpha.2",
-    "@budibase/pro": "2.2.12-alpha.1",
-    "@budibase/string-templates": "2.2.12-alpha.2",
-    "@budibase/types": "2.2.12-alpha.2",
+    "@budibase/backend-core": "^2.2.12",
+    "@budibase/pro": "2.2.11",
+    "@budibase/string-templates": "^2.2.12",
+    "@budibase/types": "^2.2.12",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
@@ -73,11 +73,10 @@
     "@types/jest": "26.0.23",
     "@types/jsonwebtoken": "8.5.1",
     "@types/koa": "2.13.4",
-    "@types/koa__router": "8.0.8",
+    "@types/koa__router": "8.0.11",
     "@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",
@@ -95,5 +94,5 @@
     "typescript": "4.7.3",
     "update-dotenv": "1.1.1"
   },
-  "gitHead": "f33fe0fc19b1a8566d7c1262bb329fbecdaa9586"
+  "gitHead": "01d4b731bff015e11bcb691dce007ab1c95d36c0"
 }

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

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

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

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

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

@@ -1,47 +1,11 @@
-import { structures, TestConfiguration } from "../../../../tests"
-import { context, db, permissions, roles } from "@budibase/backend-core"
-import { Mock } from "jest-mock"
+import { TestConfiguration } from "../../../../tests"
 
-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",
-  })
-}
+// TODO
 
 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()
   })
 
@@ -54,35 +18,10 @@ describe("/api/global/roles", () => {
   })
 
   describe("GET /api/global/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
-      )
-    })
+    it("retrieves roles", () => {})
   })
 
-  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("GET /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")
-    })
-  })
+  describe("DELETE /api/global/roles/:appId", () => {})
 })

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

@@ -1,17 +1,4 @@
-import {
-  addBaseTemplates,
-  EmailTemplates,
-  getTemplates,
-} from "../../../../constants/templates"
-import {
-  EmailTemplatePurpose,
-  TemplateMetadata,
-  TemplateMetadataNames,
-  TemplateType,
-} from "../../../../constants"
 import { TestConfiguration } from "../../../../tests"
-import { join } from "path"
-import { readStaticFile } from "../../../../../src/utilities/fileSystem"
 
 // TODO
 
@@ -31,85 +18,18 @@ describe("/api/global/template", () => {
   })
 
   describe("GET /api/global/template/definitions", () => {
-    describe("retrieves definitions", () => {
-      it("checks description definitions", async () => {
-        let result = await config.api.templates.definitions()
+    it("retrieves definitions", () => {})
+  })
 
-        expect(result.body.info[EmailTemplatePurpose.BASE].description).toEqual(
-          TemplateMetadata[TemplateType.EMAIL][0].description
-        )
-        expect(
-          result.body.info[EmailTemplatePurpose.PASSWORD_RECOVERY].description
-        ).toEqual(TemplateMetadata[TemplateType.EMAIL][1].description)
-        expect(
-          result.body.info[EmailTemplatePurpose.WELCOME].description
-        ).toEqual(TemplateMetadata[TemplateType.EMAIL][2].description)
-        expect(
-          result.body.info[EmailTemplatePurpose.INVITATION].description
-        ).toEqual(TemplateMetadata[TemplateType.EMAIL][3].description)
-        expect(
-          result.body.info[EmailTemplatePurpose.CUSTOM].description
-        ).toEqual(TemplateMetadata[TemplateType.EMAIL][4].description)
-      })
+  describe("POST /api/global/template", () => {})
 
-      it("checks description bindings", async () => {
-        let result = await config.api.templates.definitions()
+  describe("GET /api/global/template", () => {})
 
-        expect(result.body.bindings[EmailTemplatePurpose.BASE]).toEqual(
-          TemplateMetadata[TemplateType.EMAIL][0].bindings
-        )
-        expect(
-          result.body.bindings[EmailTemplatePurpose.PASSWORD_RECOVERY]
-        ).toEqual(TemplateMetadata[TemplateType.EMAIL][1].bindings)
-        expect(result.body.bindings[EmailTemplatePurpose.WELCOME]).toEqual(
-          TemplateMetadata[TemplateType.EMAIL][2].bindings
-        )
-        expect(result.body.bindings[EmailTemplatePurpose.INVITATION]).toEqual(
-          TemplateMetadata[TemplateType.EMAIL][3].bindings
-        )
-        expect(result.body.bindings[EmailTemplatePurpose.CUSTOM]).toEqual(
-          TemplateMetadata[TemplateType.EMAIL][4].bindings
-        )
-      })
-    })
-  })
+  describe("GET /api/global/template/:type", () => {})
 
-  describe("POST /api/global/template", () => {
-    it("adds a new template", async () => {
-      let purpose = "base"
-      let contents = "Test contents"
-      let updatedTemplate = {
-        contents: contents,
-        purpose: purpose,
-        type: "email",
-      }
-      await config.api.templates.saveTemplate(updatedTemplate)
-      let res = await config.api.templates.getTemplate()
-      let newTemplate = res.body.find((t: any) => (t.purpose = purpose))
-      expect(newTemplate.contents).toEqual(contents)
-    })
-  })
+  describe("GET /api/global/template/:ownerId", () => {})
 
-  describe("GET /api/global/template", () => {
-    it("fetches templates", async () => {
-      let res = await config.api.templates.getTemplate()
-      expect(
-        res.body.find((t: any) => t.purpose === EmailTemplatePurpose.BASE)
-      ).toBeDefined()
-      expect(
-        res.body.find((t: any) => t.purpose === EmailTemplatePurpose.CUSTOM)
-      ).toBeDefined()
-      expect(
-        res.body.find((t: any) => t.purpose === EmailTemplatePurpose.INVITATION)
-      ).toBeDefined()
-      expect(
-        res.body.find(
-          (t: any) => t.purpose === EmailTemplatePurpose.PASSWORD_RECOVERY
-        )
-      ).toBeDefined()
-      expect(
-        res.body.find((t: any) => t.purpose === EmailTemplatePurpose.WELCOME)
-      ).toBeDefined()
-    })
-  })
+  describe("GET /api/global/template/:id", () => {})
+
+  describe("DELETE /api/global/template/:id/:rev", () => {})
 })

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

@@ -116,7 +116,7 @@ describe("/api/global/users", () => {
 
     it("should ignore users existing in other tenants", async () => {
       const user = await config.createUser()
-      jest.clearAllMocks()
+      jest.resetAllMocks()
 
       await tenancy.doInTenant(TENANT_1, async () => {
         const response = await config.api.users.bulkCreateUsers([user])
@@ -229,7 +229,7 @@ describe("/api/global/users", () => {
 
     it("should not be able to create user that exists in other tenant", async () => {
       const user = await config.createUser()
-      jest.clearAllMocks()
+      jest.resetAllMocks()
 
       await tenancy.doInTenant(TENANT_1, async () => {
         delete user._id