@budibase/worker 3.28.3 → 3.30.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "3.28.3",
+  "version": "3.30.0",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -66,6 +66,8 @@
     "passport-local": "1.0.0",
     "pouchdb": "9.0.0",
     "pouchdb-all-dbs": "1.1.1",
+    "scim-patch": "^0.8.1",
+    "scim2-parse-filter": "^0.2.8",
     "server-destroy": "1.0.1",
     "undici": "^7.16.0",
     "uuid": "^8.3.2",
@@ -107,5 +109,5 @@
       }
     }
   },
-  "gitHead": "40bc76dc62aa2c1876e442d464c17aa388630975"
+  "gitHead": "58456cc695d2c71a354bcf5c064943b247ad4969"
 }

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

@@ -0,0 +1,38 @@
+import { Readable } from "stream"
+import { events } from "@budibase/backend-core"
+import { auditLogs } from "@budibase/pro"
+import {
+  SearchAuditLogsRequest,
+  SearchAuditLogsResponse,
+  DownloadAuditLogsRequest,
+  DefinitionsAuditLogsResponse,
+  AuditLogSearchParams,
+  UserCtx,
+} from "@budibase/types"
+
+export async function search(
+  ctx: UserCtx<SearchAuditLogsRequest, SearchAuditLogsResponse>
+) {
+  const search: AuditLogSearchParams = ctx.request.body
+  const fetched = await auditLogs.fetch(search)
+  await events.auditLog.filtered(search)
+  ctx.body = fetched
+}
+
+export async function download(
+  ctx: UserCtx<DownloadAuditLogsRequest, Readable>
+) {
+  const search: AuditLogSearchParams = ctx.request.body
+  const { stream } = auditLogs.download(search)
+  await events.auditLog.downloaded(search)
+  ctx.attachment(`audit-logs-${Date.now()}.log`)
+  ctx.body = stream
+}
+
+export async function definitions(
+  ctx: UserCtx<void, DefinitionsAuditLogsResponse>
+) {
+  ctx.body = {
+    events: auditLogs.definitions(),
+  }
+}

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

@@ -0,0 +1,212 @@
+import { csv } from "@budibase/backend-core"
+import {
+  BulkAddUsersToGroupRequest,
+  BulkAddUsersToGroupResponse,
+  Ctx,
+  DatabaseQueryOpts,
+  SearchGroupRequest,
+  SearchGroupResponse,
+  SearchUserGroupResponse,
+  UpdateGroupAppRequest,
+  UpdateGroupAppResponse,
+  UserCtx,
+  UserGroup,
+} from "@budibase/types"
+import { db, groups, users as usersSdk } from "@budibase/pro"
+
+export async function save(ctx: UserCtx) {
+  const group: UserGroup = ctx.request.body
+  group.name = group.name.trim()
+
+  // don't allow updating the roles through this endpoint
+  delete group.roles
+  if (group._id) {
+    const oldGroup = await groups.get(group._id)
+    group.roles = oldGroup.roles
+    group.scimInfo = oldGroup.scimInfo
+  }
+  const response = await groups.save(group)
+  ctx.body = {
+    _id: response.id,
+    _rev: response.rev,
+  }
+}
+
+export async function updateGroupUsers(ctx: UserCtx) {
+  const groupId = ctx.params.groupId
+  const toAdd = ctx.request.body.add,
+    toRemove = ctx.request.body.remove
+  if (
+    (toAdd && !Array.isArray(toAdd)) ||
+    (toRemove && !Array.isArray(toRemove))
+  ) {
+    ctx.throw(400, "Must supply a list of users to add or to remove")
+  }
+  let added, removed
+  if (toAdd) {
+    added = await groups.addUsers(groupId, toAdd)
+  }
+  if (toRemove) {
+    removed = await groups.removeUsers(groupId, toRemove)
+  }
+  ctx.body = { added, removed }
+}
+
+export async function updateGroupApps(
+  ctx: UserCtx<UpdateGroupAppRequest, UpdateGroupAppResponse>
+) {
+  const groupId = ctx.params.groupId
+  const toAdd = ctx.request.body.add,
+    toRemove = ctx.request.body.remove
+  if (
+    (toAdd && !Array.isArray(toAdd)) ||
+    (toRemove && !Array.isArray(toRemove))
+  ) {
+    ctx.throw(
+      400,
+      "Must supply a list of objects, with appId and roleId to add or remove"
+    )
+  }
+  ctx.body = await groups.updateGroupApps(groupId, {
+    appsToAdd: toAdd,
+    appsToRemove: toRemove,
+  })
+}
+
+export async function fetch(ctx: Ctx<SearchGroupRequest, SearchGroupResponse>) {
+  ctx.body = { data: await groups.fetch() }
+}
+
+export async function destroy(ctx: UserCtx) {
+  const { groupId, rev } = ctx.params
+  try {
+    await groups.remove(groupId, rev)
+    ctx.body = { message: "Group deleted successfully" }
+  } catch (err: any) {
+    ctx.throw(err.status, err)
+  }
+}
+
+/**
+ * Gets a group by ID from the global database.
+ */
+export async function find(ctx: UserCtx) {
+  try {
+    ctx.body = await groups.get(ctx.params.groupId)
+  } catch (err: any) {
+    ctx.throw(err.status, err)
+  }
+}
+
+export async function searchUsers(ctx: Ctx<{}, SearchUserGroupResponse>) {
+  const { pageSize = 10, bookmark, emailSearch } = ctx.request.query as any
+  const groupId = ctx.params.groupId
+
+  const params: DatabaseQueryOpts = { limit: pageSize + 1 }
+
+  const users = await db.groups.getGroupUsers(groupId, {
+    ...params,
+    emailSearch,
+    bookmark,
+  })
+
+  const nextBookmark = emailSearch
+    ? users[pageSize]?.email
+    : users[pageSize]?._id
+  const hasNextPage = !!nextBookmark
+
+  ctx.body = {
+    users: users.slice(0, pageSize),
+    bookmark: nextBookmark,
+    hasNextPage,
+  }
+}
+
+export async function bulkAddUsersFromCsv(
+  ctx: UserCtx<BulkAddUsersToGroupRequest, BulkAddUsersToGroupResponse>
+) {
+  const { groupId } = ctx.params
+  const { csvContent } = ctx.request.body
+
+  if (csvContent === undefined || csvContent.trim().length === 0) {
+    ctx.throw(400, "CSV is empty")
+  }
+
+  const csvData = await csv.jsonFromCsvString(csvContent, {
+    allowSingleColumn: true,
+  })
+
+  if (!csvData || csvData.length === 0) {
+    ctx.throw(400, "CSV file is invalid")
+  }
+
+  // Find email column
+  const headers = Object.keys(csvData[0])
+  const emailColumn = headers.find(header =>
+    /^(email|e-mail|email address|mail|e_mail)$/i.test(header.trim())
+  )
+  if (!emailColumn) {
+    ctx.throw(400, "CSV file must contain an email column")
+  }
+
+  // Extract emails from CSV
+  const emails = Array.from(
+    new Set(
+      csvData
+        .map(row => row[emailColumn])
+        .filter(
+          email => email && typeof email === "string" && email.trim().length > 0
+        )
+        .map(email => email.trim())
+    )
+  )
+  if (emails.length === 0) {
+    ctx.throw(400, "No valid email addresses found in CSV")
+  }
+
+  // Check if group exists
+  try {
+    await groups.get(groupId)
+  } catch (err: any) {
+    if (err.status === 404) {
+      ctx.throw(404, "Group not found")
+    } else {
+      throw err
+    }
+  }
+
+  // Find existing users by email
+  const added: { _id: string; email: string }[] = []
+  const skipped: { email: string; reason: string }[] = []
+  const userIds: string[] = []
+
+  const users = await Promise.all(
+    emails.map(email => usersSdk.db.getUserByEmail(email))
+  )
+
+  for (const email of emails) {
+    const user = users.find(u => u?.email === email)
+    if (user) {
+      added.push({
+        _id: user._id!,
+        email: user.email,
+      })
+      userIds.push(user._id!)
+    } else {
+      skipped.push({
+        email,
+        reason: "User not found",
+      })
+    }
+  }
+
+  // Add users to group if any were found
+  if (userIds.length > 0) {
+    await groups.addUsers(groupId, userIds)
+  }
+
+  ctx.body = {
+    added,
+    skipped,
+  }
+}

package/src/api/controllers/global/scim/groups.ts

@@ -0,0 +1,157 @@
+import groupBy from "lodash/groupBy"
+import { patchBodyValidation, scimPatch } from "scim-patch"
+import { filter, parse } from "scim2-parse-filter"
+import {
+  Ctx,
+  ScimCreateGroupRequest,
+  ScimGroupListResponse,
+  ScimGroupResponse,
+  ScimUpdateRequest,
+  UserGroup,
+} from "@budibase/types"
+import { utils } from "@budibase/shared-core"
+import { groups, mappers, scimGroups, scimUsers } from "@budibase/pro"
+
+function cleanResponse(group: ScimGroupResponse, excludedAttributes: string) {
+  for (const attr of (excludedAttributes as string).split(",")) {
+    delete (group as any)[attr]
+  }
+}
+
+export const get = async (ctx: Ctx<void, ScimGroupListResponse>) => {
+  const fetchedGroups = await groups.fetch()
+  let result = fetchedGroups
+    .filter(g => g.scimInfo?.isSync)
+    .map(mappers.group.toScimGroupResponse)
+
+  const { filter: reqFilter, excludedAttributes } = ctx.request.query
+
+  if (reqFilter) {
+    const filterFunc = filter(parse(reqFilter as string))
+    result = result.filter(filterFunc)
+  }
+
+  if (excludedAttributes) {
+    result.forEach((g: any) => {
+      cleanResponse(g, excludedAttributes as string)
+    })
+  }
+
+  ctx.body = {
+    schemas: ["urn:ietf:params:scim:api:messages:2.0:ListResponse"],
+    totalResults: result.length,
+    Resources: result,
+    startIndex: 1,
+    itemsPerPage: result.length,
+  }
+}
+
+export const create = async (
+  ctx: Ctx<ScimCreateGroupRequest, ScimGroupResponse>
+) => {
+  const groupToCreate = mappers.group.fromScimGroup(ctx.request.body)
+  const group = await scimGroups.create(groupToCreate)
+  ctx.body = mappers.group.toScimGroupResponse(group)
+}
+
+export const find = async (ctx: Ctx<void, ScimGroupResponse>) => {
+  const { id } = ctx.params
+  const group = await groups.get(id)
+  const response = mappers.group.toScimGroupResponse(group)
+
+  const { excludedAttributes } = ctx.request.query
+  if (excludedAttributes) {
+    cleanResponse(response, excludedAttributes as string)
+  }
+
+  ctx.body = response
+}
+
+export const remove = async (ctx: Ctx) => {
+  const { id } = ctx.params
+  const existingGroup = await groups.get(id)
+  await groups.remove(id, existingGroup._rev!)
+  ctx.status = 204
+}
+
+export const update = async (
+  ctx: Ctx<ScimUpdateRequest, ScimGroupResponse>
+) => {
+  const { id } = ctx.params
+  const group = await groups.get(id)
+
+  const scimGroup = mappers.group.toScimGroupResponse(group)
+
+  const patchs = ctx.request.body
+  try {
+    // Validate request
+    patchBodyValidation(patchs)
+  } catch (error) {
+    ctx.throw(400)
+  }
+
+  const { true: memberOps, false: fieldOps } = groupBy(
+    patchs.Operations,
+    p => p.path === "members"
+  )
+
+  if (fieldOps?.length) {
+    const patchedScimGroup = scimPatch(scimGroup, fieldOps)
+    if (!patchedScimGroup) {
+      ctx.throw(500)
+    }
+
+    const groupToUpdate: UserGroup = {
+      ...mappers.group.fromScimGroup(patchedScimGroup),
+      _rev: group._rev,
+    }
+    await groups.save(groupToUpdate)
+  }
+
+  if (memberOps?.length) {
+    const usersToAdd = []
+    const usersToRemove = []
+    for (const { op, value } of memberOps) {
+      switch (op) {
+        case "add":
+        case "Add":
+          for (const u of value) {
+            usersToAdd.push(await scimUsers.find(u.value))
+          }
+          break
+        case "remove":
+        case "Remove":
+          for (const u of value) {
+            try {
+              usersToRemove.push(await scimUsers.find(u.value))
+            } catch (e: any) {
+              if (e.status !== 404) {
+                throw e
+              }
+            }
+          }
+          break
+        case "replace":
+        case "Replace":
+          throw new Error("Replacing members is not allowed")
+        default:
+          utils.unreachable(op)
+      }
+    }
+
+    if (usersToAdd.length) {
+      await groups.addUsers(
+        id,
+        usersToAdd.map(u => u._id!)
+      )
+    }
+    if (usersToRemove.length) {
+      await groups.removeUsers(
+        id,
+        usersToRemove.map(u => u._id!)
+      )
+    }
+  }
+
+  ctx.body = mappers.group.toScimGroupResponse(await groups.get(id))
+}

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

@@ -0,0 +1,124 @@
+import { patchBodyValidation, scimPatch } from "scim-patch"
+import { EmailUnavailableError } from "@budibase/backend-core"
+import { mappers, scimUsers } from "@budibase/pro"
+import {
+  Ctx,
+  ScimUserListResponse,
+  ScimCreateUserRequest,
+  ScimUserResponse,
+  ScimUpdateRequest,
+} from "@budibase/types"
+
+function tryGetQueryAsNumber(ctx: Ctx, name: string) {
+  const value = ctx.request.query[name]
+  if (value === undefined) {
+    return undefined
+  }
+
+  return +value
+}
+
+export const get = async (ctx: Ctx<void, ScimUserListResponse>) => {
+  const pageSize = tryGetQueryAsNumber(ctx, "pageSize") ?? 20
+  const skip = tryGetQueryAsNumber(ctx, "startIndex")
+
+  let filters
+  if (ctx.request.query.filter) {
+    filters = mappers.user.userFilters(ctx.request.query.filter as string)
+  }
+
+  const getResponse = await scimUsers.get({ pageSize, skip, filters })
+  ctx.body = {
+    schemas: ["urn:ietf:params:scim:api:messages:2.0:ListResponse"],
+    totalResults: getResponse.total,
+    Resources: getResponse.users.map(mappers.user.toScimUserResponse),
+    startIndex: (skip || 0) + 1,
+    itemsPerPage: pageSize,
+  }
+}
+
+export const find = async (ctx: Ctx<void, ScimUserResponse>) => {
+  const { id } = ctx.params
+  if (typeof id !== "string") {
+    ctx.throw(404)
+  }
+
+  const user = await scimUsers.find(id)
+  ctx.body = mappers.user.toScimUserResponse(user)
+}
+
+export const create = async (
+  ctx: Ctx<ScimCreateUserRequest, ScimUserResponse>
+) => {
+  const userToCreate = mappers.user.fromScimUser(ctx.request.body)
+  try {
+    const user = await scimUsers.create(userToCreate)
+    ctx.body = mappers.user.toScimUserResponse(user)
+  } catch (e) {
+    if (e instanceof EmailUnavailableError) {
+      ctx.throw(409, "Email already in use")
+    }
+
+    throw e
+  }
+}
+
+function isDeactivation(request: ScimUpdateRequest) {
+  const activeFieldChange = request.Operations.find(
+    o => (o.op === "Replace" || o.op === "replace") && o.path === "active"
+  )
+  if (!activeFieldChange) {
+    return false
+  }
+
+  return (
+    activeFieldChange.value === false ||
+    activeFieldChange.value?.toLowerCase?.() === "false"
+  )
+}
+
+export const update = async (ctx: Ctx<ScimUpdateRequest, ScimUserResponse>) => {
+  const user = await scimUsers.find(ctx.params.id)
+  if (!user) {
+    ctx.throw(404)
+  }
+
+  const scimUser = mappers.user.toScimUserResponse(user)
+
+  const patchs = ctx.request.body
+  try {
+    patchBodyValidation(patchs)
+  } catch (error) {
+    // Here if there are an error in you SCIM request.
+  }
+
+  if (isDeactivation(patchs)) {
+    return remove(ctx)
+  }
+
+  let patchedScimUser
+  try {
+    patchedScimUser = scimPatch(scimUser, patchs.Operations)
+  } catch (error) {
+    // Here if there is an error during the patch.
+  }
+
+  if (!patchedScimUser) {
+    ctx.throw(500)
+  }
+
+  const userToUpdate = mappers.user.fromScimUser(patchedScimUser)
+  await scimUsers.update(userToUpdate, { allowChangingEmail: true })
+
+  ctx.body = mappers.user.toScimUserResponse(userToUpdate)
+}
+
+export const remove = async (ctx: Ctx) => {
+  const { id } = ctx.params
+  if (typeof id !== "string") {
+    ctx.throw(404)
+  }
+
+  await scimUsers.remove(id)
+  ctx.status = 204
+}

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

@@ -0,0 +1,46 @@
+import Router from "@koa/router"
+import Joi from "joi"
+import { auth, middleware } from "@budibase/backend-core"
+import { Event } from "@budibase/types"
+import * as controllers from "../../controllers/global/auditLogs"
+
+function buildAuditLogSearchValidator() {
+  return auth.joiValidator.body(
+    Joi.object({
+      userIds: Joi.array().items(Joi.string()).optional(),
+      appIds: Joi.array().items(Joi.string()).optional(),
+      events: Joi.array()
+        .items(Joi.string().valid(...Object.values(Event)))
+        .optional(),
+      startDate: Joi.string().optional().allow(""),
+      endDate: Joi.string().optional().allow(""),
+      fullSearch: Joi.string().optional().allow(""),
+      bookmark: Joi.number(),
+    })
+  )
+}
+
+const router: Router = new Router()
+
+router
+  .post(
+    "/api/global/auditlogs/search",
+    auth.adminOnly,
+    buildAuditLogSearchValidator(),
+    controllers.search
+  )
+  .get(
+    "/api/global/auditlogs/download",
+    auth.adminOnly,
+    // convert query string param to body
+    middleware.querystringToBody,
+    buildAuditLogSearchValidator(),
+    controllers.download
+  )
+  .get(
+    "/api/global/auditlogs/definitions",
+    auth.adminOnly,
+    controllers.definitions
+  )
+
+export default router

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

@@ -0,0 +1,88 @@
+import Router from "@koa/router"
+import Joi from "joi"
+import { auth } from "@budibase/backend-core"
+import { middleware as proMiddleware } from "@budibase/pro"
+import { Feature } from "@budibase/types"
+import * as controller from "../../controllers/global/groups"
+
+const router: Router = new Router()
+
+function buildGroupSaveValidation() {
+  return auth.joiValidator.body(
+    Joi.object({
+      _id: Joi.string().optional(),
+      _rev: Joi.string().optional(),
+      color: Joi.string().required(),
+      icon: Joi.string().required(),
+      name: Joi.string().trim().required().max(50),
+      role: Joi.string().optional(),
+      users: Joi.array().optional(),
+      apps: Joi.array().optional(),
+      roles: Joi.object().optional(),
+      createdAt: Joi.string().optional(),
+      updatedAt: Joi.string().optional(),
+    }).required()
+  )
+}
+
+router
+  .post(
+    "/api/global/groups",
+    auth.adminOnly,
+    proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+    buildGroupSaveValidation(),
+    controller.save
+  )
+  .get(
+    "/api/global/groups",
+    proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+    controller.fetch
+  )
+
+  .delete(
+    "/api/global/groups/:groupId/:rev",
+    proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+    auth.adminOnly,
+    proMiddleware.internalGroupOnly("groupId"),
+    controller.destroy
+  )
+  .get(
+    "/api/global/groups/:groupId",
+    proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+    auth.builderOrAdmin,
+    controller.find
+  )
+  .get(
+    "/api/global/groups/:groupId/users",
+    proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+    auth.builderOrAdmin,
+    controller.searchUsers
+  )
+  // these endpoints adjust existing groups
+  .post(
+    "/api/global/groups/:groupId/users",
+    auth.adminOnly,
+    proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+    proMiddleware.internalGroupOnly("groupId"),
+    controller.updateGroupUsers
+  )
+  .post(
+    "/api/global/groups/:groupId/users/bulk",
+    auth.adminOnly,
+    proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+    proMiddleware.internalGroupOnly("groupId"),
+    auth.joiValidator.body(
+      Joi.object({
+        csvContent: Joi.string().required(),
+      }).required()
+    ),
+    controller.bulkAddUsersFromCsv
+  )
+  .post(
+    "/api/global/groups/:groupId/apps",
+    auth.builderOrAdmin,
+    proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+    controller.updateGroupApps
+  )
+
+export default router

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

@@ -0,0 +1,53 @@
+import Router from "@koa/router"
+import { middleware as proMiddleware } from "@budibase/pro"
+import { Feature } from "@budibase/types"
+import * as userController from "../../controllers/global/scim/users"
+import * as groupController from "../../controllers/global/scim/groups"
+
+const router: Router = new Router({
+  prefix: "/api/global/scim/v2",
+})
+
+router.use(proMiddleware.requireSCIM)
+router.use(proMiddleware.doInScimContext)
+
+router.get("/users", userController.get)
+router.get("/users/:id", proMiddleware.scimUserOnly("id"), userController.find)
+router.post("/users", userController.create)
+router.patch(
+  "/users/:id",
+  proMiddleware.scimUserOnly("id"),
+  userController.update
+)
+router.delete(
+  "/users/:id",
+  proMiddleware.scimUserOnly("id"),
+  userController.remove
+)
+
+router.get("/groups", groupController.get)
+router.post(
+  "/groups",
+  proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+  groupController.create
+)
+router.get(
+  "/groups/:id",
+  proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+  proMiddleware.scimGroupOnly("id"),
+  groupController.find
+)
+router.delete(
+  "/groups/:id",
+  proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+  proMiddleware.scimGroupOnly("id"),
+  groupController.remove
+)
+router.patch(
+  "/groups/:id",
+  proMiddleware.feature.requireFeature(Feature.USER_GROUPS),
+  proMiddleware.scimGroupOnly("id"),
+  groupController.update
+)
+
+export default router

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

@@ -87,6 +87,24 @@ describe("/api/global/users", () => {
       expect(events.user.invited).toHaveBeenCalledTimes(0)
     })
 
+    it("should not invite the same user twice when email casing differs", async () => {
+      const email = structures.users.newEmail().toLowerCase()
+      await config.api.users.sendUserInvite(sendMailMock, email)
+
+      jest.clearAllMocks()
+
+      const { code, res } = await config.api.users.sendUserInvite(
+        sendMailMock,
+        email.toUpperCase(),
+        400
+      )
+
+      expect(res.body.message).toBe(`Unavailable`)
+      expect(sendMailMock).toHaveBeenCalledTimes(0)
+      expect(code).toBeUndefined()
+      expect(events.user.invited).toHaveBeenCalledTimes(0)
+    })
+
     it("should not allow creator users to access single invite endpoint", async () => {
       const user = await createBuilderUser()
 

package/src/api/routes/index.ts

@@ -1,4 +1,3 @@
-import { api as pro } from "@budibase/pro"
 import Router from "@koa/router"
 import { endpointGroupList } from "./endpointGroups"
 
@@ -19,6 +18,9 @@ import "./system/logs"
 import "./system/restore"
 import "./system/status"
 import "./system/tenants"
+import auditLogsRoutes from "./global/auditLogs"
+import groupRoutes from "./global/groups"
+import scimRoutes from "./global/scim"
 
 const endpointGroupsRouter = new Router()
 for (let endpoint of endpointGroupList.listAllEndpoints()) {
@@ -27,7 +29,7 @@ for (let endpoint of endpointGroupList.listAllEndpoints()) {
 
 export const routes: Router[] = [
   endpointGroupsRouter,
-  pro.groups,
-  pro.auditLogs,
-  pro.scim,
+  auditLogsRoutes,
+  groupRoutes,
+  scimRoutes,
 ]

package/src/sdk/users/users.ts

@@ -22,7 +22,7 @@ export async function invite(
 
   // separate duplicates from new users
   for (let user of users) {
-    if (matchedEmails.includes(user.email)) {
+    if (matchedEmails.includes(user.email.toLowerCase())) {
       // This "Unavailable" is load bearing. The tests and frontend both check for it
       // specifically
       response.unsuccessful.push({ email: user.email, reason: "Unavailable" })