@budibase/worker 2.4.44-alpha.1 → 2.4.44-alpha.11

package/src/api/routes/index.ts

@@ -1,5 +1,5 @@
 import Router from "@koa/router"
-import { api } from "@budibase/pro"
+import { api as pro } from "@budibase/pro"
 import userRoutes from "./global/users"
 import configRoutes from "./global/configs"
 import workspaceRoutes from "./global/workspaces"
@@ -17,9 +17,6 @@ import migrationRoutes from "./system/migrations"
 import accountRoutes from "./system/accounts"
 import restoreRoutes from "./system/restore"
 
-let userGroupRoutes = api.groups
-let auditLogRoutes = api.auditLogs
-
 export const routes: Router[] = [
   configRoutes,
   userRoutes,
@@ -33,10 +30,11 @@ export const routes: Router[] = [
   statusRoutes,
   selfRoutes,
   licenseRoutes,
-  userGroupRoutes,
-  auditLogRoutes,
+  pro.groups,
+  pro.auditLogs,
   migrationRoutes,
   accountRoutes,
   restoreRoutes,
   eventRoutes,
+  pro.scim,
 ]

package/src/environment.ts

@@ -47,7 +47,6 @@ const environment = {
   // flags
   NODE_ENV: process.env.NODE_ENV,
   SELF_HOSTED: !!parseInt(process.env.SELF_HOSTED || ""),
-  LOG_LEVEL: process.env.LOG_LEVEL,
   MULTI_TENANCY: process.env.MULTI_TENANCY,
   DISABLE_ACCOUNT_PORTAL: process.env.DISABLE_ACCOUNT_PORTAL,
   SMTP_FALLBACK_ENABLED: process.env.SMTP_FALLBACK_ENABLED,

package/src/index.ts

@@ -2,10 +2,6 @@ if (process.env.DD_APM_ENABLED) {
   require("./ddApm")
 }
 
-if (process.env.ELASTIC_APM_ENABLED) {
-  require("./elasticApm")
-}
-
 // need to load environment first
 import env from "./environment"
 import { Scope } from "@sentry/node"
@@ -31,10 +27,11 @@ import api from "./api"
 import * as redis from "./utilities/redis"
 const Sentry = require("@sentry/node")
 const koaSession = require("koa-session")
-const logger = require("koa-pino-logger")
 const { userAgent } = require("koa-useragent")
 
 import destroyable from "server-destroy"
+import { initPro } from "./initPro"
+import { handleScimBody } from "./middleware/handleScimBody"
 
 // configure events to use the pro audit log write
 // can't integrate directly into backend-core due to cyclic issues
@@ -54,10 +51,12 @@ const app: Application = new Koa()
 app.keys = ["secret", "key"]
 
 // set up top level koa middleware
+app.use(handleScimBody)
 app.use(koaBody({ multipart: true }))
+
 app.use(koaSession(app))
-app.use(middleware.logging)
-app.use(logger(logging.pinoSettings()))
+app.use(middleware.correlation)
+app.use(middleware.pino)
 app.use(userAgent)
 
 // authentication
@@ -108,6 +107,7 @@ const shutdown = () => {
 
 export default server.listen(parseInt(env.PORT || "4002"), async () => {
   console.log(`Worker running on ${JSON.stringify(server.address())}`)
+  await initPro()
   await redis.init()
 })
 

package/src/initPro.ts

@@ -0,0 +1,13 @@
+import { sdk as proSdk } from "@budibase/pro"
+import * as userSdk from "./sdk/users"
+
+export const initPro = async () => {
+  await proSdk.init({
+    scimUserServiceConfig: {
+      functions: {
+        saveUser: userSdk.save,
+        removeUser: (id: string) => userSdk.destroy(id),
+      },
+    },
+  })
+}

package/src/middleware/handleScimBody.ts

@@ -0,0 +1,12 @@
+import { Ctx } from "@budibase/types"
+
+export const handleScimBody = (ctx: Ctx, next: any) => {
+  var type = ctx.req.headers["content-type"] || ""
+  type = type.split(";")[0]
+
+  if (type === "application/scim+json") {
+    ctx.req.headers["content-type"] = "application/json"
+  }
+
+  return next()
+}

package/src/sdk/users/users.ts

@@ -15,6 +15,7 @@ import {
   utils,
   ViewName,
   env as coreEnv,
+  context,
 } from "@budibase/backend-core"
 import {
   AccountMetadata,
@@ -37,8 +38,6 @@ import { EmailTemplatePurpose } from "../../constants"
 import * as pro from "@budibase/pro"
 import * as accountSdk from "../accounts"
 
-const PAGE_LIMIT = 8
-
 export const allUsers = async () => {
   const db = tenancy.getGlobalDB()
   const response = await db.allDocs(
@@ -68,43 +67,6 @@ export const getUsersByAppAccess = async (appId?: string) => {
   return response
 }
 
-export const paginatedUsers = async ({
-  page,
-  email,
-  appId,
-}: SearchUsersRequest = {}) => {
-  const db = tenancy.getGlobalDB()
-  // get one extra document, to have the next page
-  const opts: any = {
-    include_docs: true,
-    limit: PAGE_LIMIT + 1,
-  }
-  // add a startkey if the page was specified (anchor)
-  if (page) {
-    opts.startkey = page
-  }
-  // property specifies what to use for the page/anchor
-  let userList,
-    property = "_id",
-    getKey
-  if (appId) {
-    userList = await usersCore.searchGlobalUsersByApp(appId, opts)
-    getKey = (doc: any) => usersCore.getGlobalUserByAppPage(appId, doc)
-  } else if (email) {
-    userList = await usersCore.searchGlobalUsersByEmail(email, opts)
-    property = "email"
-  } else {
-    // no search, query allDocs
-    const response = await db.allDocs(dbUtils.getGlobalUserParams(null, opts))
-    userList = response.rows.map((row: any) => row.doc)
-  }
-  return dbUtils.pagination(userList, PAGE_LIMIT, {
-    paginate: true,
-    property,
-    getKey,
-  })
-}
-
 export async function getUserByEmail(email: string) {
   return usersCore.getGlobalUserByEmail(email)
 }
@@ -576,7 +538,7 @@ export const bulkDelete = async (
   return response
 }
 
-export const destroy = async (id: string, currentUser: any) => {
+export const destroy = async (id: string) => {
   const db = tenancy.getGlobalDB()
   const dbUser = (await db.get(id)) as User
   const userId = dbUser._id as string
@@ -586,7 +548,7 @@ export const destroy = async (id: string, currentUser: any) => {
     const email = dbUser.email
     const account = await accounts.getAccount(email)
     if (account) {
-      if (email === currentUser.email) {
+      if (dbUser.userId === context.getIdentity()!._id) {
         throw new HTTPError('Please visit "Account" to delete this user', 400)
       } else {
         throw new HTTPError("Account holder cannot be deleted", 400)

package/src/tests/TestConfiguration.ts

@@ -20,9 +20,18 @@ import {
   auth,
   constants,
   env as coreEnv,
+  db as dbCore,
+  encryption,
+  utils,
 } from "@budibase/backend-core"
 import structures, { CSRF_TOKEN } from "./structures"
-import { SaveUserResponse, User, AuthToken } from "@budibase/types"
+import {
+  SaveUserResponse,
+  User,
+  AuthToken,
+  SCIMConfig,
+  ConfigType,
+} from "@budibase/types"
 import API from "./api"
 
 class TestConfiguration {
@@ -31,6 +40,7 @@ class TestConfiguration {
   api: API
   tenantId: string
   user?: User
+  apiKey?: string
   userPassword = "test"
 
   constructor(opts: { openServer: boolean } = { openServer: true }) {
@@ -49,6 +59,12 @@ class TestConfiguration {
     this.api = new API(this)
   }
 
+  async useNewTenant() {
+    this.tenantId = structures.tenant.id()
+
+    await this.beforeAll()
+  }
+
   getRequest() {
     return this.request
   }
@@ -201,6 +217,12 @@ class TestConfiguration {
     return { [constants.Header.API_KEY]: coreEnv.INTERNAL_API_KEY }
   }
 
+  bearerAPIHeaders() {
+    return {
+      [constants.Header.AUTHORIZATION]: `Bearer ${this.apiKey}`,
+    }
+  }
+
   adminOnlyResponse = () => {
     return { message: "Admin user only endpoint.", status: 403 }
   }
@@ -213,6 +235,20 @@ class TestConfiguration {
     })
     await context.doInTenant(this.tenantId!, async () => {
       this.user = await this.createUser(user)
+
+      const db = context.getGlobalDB()
+
+      const id = dbCore.generateDevInfoID(this.user._id)
+      // TODO: dry
+      this.apiKey = encryption.encrypt(
+        `${this.tenantId}${dbCore.SEPARATOR}${utils.newid()}`
+      )
+      const devInfo = {
+        _id: id,
+        userId: this.user._id,
+        apiKey: this.apiKey,
+      }
+      await db.put(devInfo)
     })
   }
 
@@ -305,6 +341,19 @@ class TestConfiguration {
       controllers.config.save
     )
   }
+
+  // CONFIGS - SCIM
+
+  async setSCIMConfig(enabled: boolean) {
+    await this.deleteConfig(Config.SCIM)
+    const config: SCIMConfig = {
+      type: ConfigType.SCIM,
+      config: { enabled },
+    }
+
+    await this._req(config, null, controllers.config.save)
+    return config
+  }
 }
 
 export default TestConfiguration

package/src/tests/api/index.ts

@@ -15,6 +15,9 @@ import { RolesAPI } from "./roles"
 import { TemplatesAPI } from "./templates"
 import { LicenseAPI } from "./license"
 import { AuditLogAPI } from "./auditLogs"
+import { ScimUsersAPI } from "./scim/users"
+import { ScimGroupsAPI } from "./scim/groups"
+
 export default class API {
   accounts: AccountAPI
   auth: AuthAPI
@@ -32,6 +35,8 @@ export default class API {
   templates: TemplatesAPI
   license: LicenseAPI
   auditLogs: AuditLogAPI
+  scimUsersAPI: ScimUsersAPI
+  scimGroupsAPI: ScimGroupsAPI
 
   constructor(config: TestConfiguration) {
     this.accounts = new AccountAPI(config)
@@ -50,5 +55,7 @@ export default class API {
     this.templates = new TemplatesAPI(config)
     this.license = new LicenseAPI(config)
     this.auditLogs = new AuditLogAPI(config)
+    this.scimUsersAPI = new ScimUsersAPI(config)
+    this.scimGroupsAPI = new ScimGroupsAPI(config)
   }
 }

package/src/tests/api/scim/groups.ts

@@ -0,0 +1,94 @@
+import {
+  ScimCreateGroupRequest,
+  ScimGroupListResponse,
+  ScimGroupResponse,
+  ScimUpdateRequest,
+} from "@budibase/types"
+import TestConfiguration from "../../TestConfiguration"
+import { RequestSettings, ScimTestAPI } from "./shared"
+
+export class ScimGroupsAPI extends ScimTestAPI {
+  constructor(config: TestConfiguration) {
+    super(config)
+  }
+
+  get = async (
+    requestSettings?: Partial<RequestSettings> & {
+      params?: {
+        startIndex?: number
+        pageSize?: number
+        filter?: string
+      }
+    }
+  ) => {
+    let url = `/api/global/scim/v2/groups?`
+    const params = requestSettings?.params
+    if (params?.pageSize) {
+      url += `count=${params.pageSize}&`
+    }
+    if (params?.startIndex) {
+      url += `startIndex=${params.startIndex}&`
+    }
+    if (params?.filter) {
+      url += `filter=${params.filter}&`
+    }
+    const res = await this.call(url, "get", requestSettings)
+    return res.body as ScimGroupListResponse
+  }
+
+  post = async (
+    {
+      body,
+    }: {
+      body: ScimCreateGroupRequest
+    },
+    requestSettings?: Partial<RequestSettings>
+  ) => {
+    const res = await this.call(
+      `/api/global/scim/v2/groups`,
+      "post",
+      requestSettings,
+      body
+    )
+
+    return res.body as ScimGroupResponse
+  }
+
+  find = async (id: string, requestSettings?: Partial<RequestSettings>) => {
+    const res = await this.call(
+      `/api/global/scim/v2/groups/${id}`,
+      "get",
+      requestSettings
+    )
+    return res.body as ScimGroupResponse
+  }
+
+  delete = async (id: string, requestSettings?: Partial<RequestSettings>) => {
+    const res = await this.call(
+      `/api/global/scim/v2/groups/${id}`,
+      "delete",
+      requestSettings
+    )
+    return res.body as ScimGroupResponse
+  }
+
+  patch = async (
+    {
+      id,
+      body,
+    }: {
+      id: string
+      body: ScimUpdateRequest
+    },
+    requestSettings?: Partial<RequestSettings>
+  ) => {
+    const res = await this.call(
+      `/api/global/scim/v2/groups/${id}`,
+      "patch",
+      requestSettings,
+      body
+    )
+
+    return res.body as ScimGroupResponse
+  }
+}

package/src/tests/api/scim/shared.ts

@@ -0,0 +1,44 @@
+import TestConfiguration from "../../TestConfiguration"
+import { TestAPI } from "../base"
+
+const defaultConfig = {
+  expect: 200,
+  setHeaders: true,
+  skipContentTypeCheck: false,
+}
+
+export type RequestSettings = typeof defaultConfig
+
+export abstract class ScimTestAPI extends TestAPI {
+  constructor(config: TestConfiguration) {
+    super(config)
+  }
+
+  call = (
+    url: string,
+    method: "get" | "post" | "patch" | "delete",
+    requestSettings?: Partial<RequestSettings>,
+    body?: object
+  ) => {
+    const { expect, setHeaders } = { ...defaultConfig, ...requestSettings }
+    let request = this.request[method](url).expect(expect)
+
+    request = request.set(
+      "content-type",
+      "application/scim+json; charset=utf-8"
+    )
+
+    if (method !== "delete" && !requestSettings?.skipContentTypeCheck) {
+      request = request.expect("Content-Type", /json/)
+    }
+
+    if (body) {
+      request = request.send(body)
+    }
+
+    if (setHeaders) {
+      request = request.set(this.config.bearerAPIHeaders())
+    }
+    return request
+  }
+}

package/src/tests/api/scim/users.ts

@@ -0,0 +1,94 @@
+import {
+  ScimUserListResponse,
+  ScimCreateUserRequest,
+  ScimUserResponse,
+  ScimUpdateRequest,
+} from "@budibase/types"
+import TestConfiguration from "../../TestConfiguration"
+import { RequestSettings, ScimTestAPI } from "./shared"
+
+export class ScimUsersAPI extends ScimTestAPI {
+  constructor(config: TestConfiguration) {
+    super(config)
+  }
+
+  get = async (
+    requestSettings?: Partial<RequestSettings> & {
+      params?: {
+        startIndex?: number
+        pageSize?: number
+        filter?: string
+      }
+    }
+  ) => {
+    let url = `/api/global/scim/v2/users?`
+    const params = requestSettings?.params
+    if (params?.pageSize) {
+      url += `count=${params.pageSize}&`
+    }
+    if (params?.startIndex) {
+      url += `startIndex=${params.startIndex}&`
+    }
+    if (params?.filter) {
+      url += `filter=${params.filter}&`
+    }
+    const res = await this.call(url, "get", requestSettings)
+    return res.body as ScimUserListResponse
+  }
+
+  find = async (id: string, requestSettings?: Partial<RequestSettings>) => {
+    const res = await this.call(
+      `/api/global/scim/v2/users/${id}`,
+      "get",
+      requestSettings
+    )
+    return res.body as ScimUserResponse
+  }
+
+  post = async (
+    {
+      body,
+    }: {
+      body: ScimCreateUserRequest
+    },
+    requestSettings?: Partial<RequestSettings>
+  ) => {
+    const res = await this.call(
+      `/api/global/scim/v2/users`,
+      "post",
+      requestSettings,
+      body
+    )
+
+    return res.body as ScimUserResponse
+  }
+
+  patch = async (
+    {
+      id,
+      body,
+    }: {
+      id: string
+      body: ScimUpdateRequest
+    },
+    requestSettings?: Partial<RequestSettings>
+  ) => {
+    const res = await this.call(
+      `/api/global/scim/v2/users/${id}`,
+      "patch",
+      requestSettings,
+      body
+    )
+
+    return res.body as ScimUserResponse
+  }
+
+  delete = async (id: string, requestSettings?: Partial<RequestSettings>) => {
+    const res = await this.call(
+      `/api/global/scim/v2/users/${id}`,
+      "delete",
+      requestSettings
+    )
+    return res.body as ScimUserResponse
+  }
+}

package/src/tests/jestEnv.ts

@@ -2,7 +2,6 @@ process.env.SELF_HOSTED = "0"
 process.env.NODE_ENV = "jest"
 process.env.JWT_SECRET = "test-jwtsecret"
 process.env.LOG_LEVEL = process.env.LOG_LEVEL || "error"
-process.env.ENABLE_4XX_HTTP_LOGGING = "0"
 process.env.MULTI_TENANCY = "1"
 process.env.MINIO_URL = "http://localhost"
 process.env.MINIO_ACCESS_KEY = "test"

package/src/tests/jestSetup.ts

@@ -1,5 +1,3 @@
-import "./logging"
-
 import { mocks, testContainerUtils } from "@budibase/backend-core/tests"
 import env from "../environment"
 import { env as coreEnv, timers } from "@budibase/backend-core"

package/src/elasticApm.ts

@@ -1,10 +0,0 @@
-import apm from "elastic-apm-node"
-
-// enable APM if configured
-if (process.env.ELASTIC_APM_ENABLED) {
-  console.log("Starting elastic-apm-node")
-  apm.start({
-    serviceName: process.env.SERVICE,
-    environment: process.env.BUDIBASE_ENVIRONMENT,
-  })
-}

package/src/tests/logging.ts

@@ -1,34 +0,0 @@
-export enum LogLevel {
-  TRACE = "trace",
-  DEBUG = "debug",
-  INFO = "info",
-  WARN = "warn",
-  ERROR = "error",
-}
-
-const LOG_INDEX: { [key in LogLevel]: number } = {
-  [LogLevel.TRACE]: 1,
-  [LogLevel.DEBUG]: 2,
-  [LogLevel.INFO]: 3,
-  [LogLevel.WARN]: 4,
-  [LogLevel.ERROR]: 5,
-}
-
-const setIndex = LOG_INDEX[process.env.LOG_LEVEL as LogLevel]
-
-if (setIndex > LOG_INDEX.trace) {
-  global.console.trace = jest.fn()
-}
-
-if (setIndex > LOG_INDEX.debug) {
-  global.console.debug = jest.fn()
-}
-
-if (setIndex > LOG_INDEX.info) {
-  global.console.info = jest.fn()
-  global.console.log = jest.fn()
-}
-
-if (setIndex > LOG_INDEX.warn) {
-  global.console.warn = jest.fn()
-}