@budibase/server 2.5.6-alpha.9 → 2.5.7

package/src/sdk/app/applications/tests/sync.spec.ts

@@ -1,137 +0,0 @@
-import TestConfiguration from "../../../../tests/utilities/TestConfiguration"
-import { events, context, roles, constants } from "@budibase/backend-core"
-import { init } from "../../../../events"
-import { rawUserMetadata } from "../../../users/utils"
-import EventEmitter from "events"
-import { UserGroup, UserMetadata, UserRoles, User } from "@budibase/types"
-
-const config = new TestConfiguration()
-let app, group: UserGroup, groupUser: User
-const ROLE_ID = roles.BUILTIN_ROLE_IDS.BASIC
-
-const emitter = new EventEmitter()
-
-function updateCb(docId: string) {
-  const isGroup = docId.startsWith(constants.DocumentType.GROUP)
-  if (isGroup) {
-    emitter.emit("update-group")
-  } else {
-    emitter.emit("update-user")
-  }
-}
-
-init(updateCb)
-
-function waitForUpdate(opts: { group?: boolean }) {
-  return new Promise<void>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject()
-    }, 5000)
-    const event = opts?.group ? "update-group" : "update-user"
-    emitter.on(event, () => {
-      clearTimeout(timeout)
-      resolve()
-    })
-  })
-}
-
-beforeAll(async () => {
-  app = await config.init("syncApp")
-})
-
-async function createUser(email: string, roles: UserRoles, builder?: boolean) {
-  const user = await config.createUser({
-    email,
-    roles,
-    builder: builder || false,
-    admin: false,
-  })
-  await context.doInContext(config.appId!, async () => {
-    await events.user.created(user)
-  })
-  return user
-}
-
-async function removeUserRole(user: User) {
-  const final = await config.globalUser({
-    ...user,
-    id: user._id,
-    roles: {},
-    builder: false,
-    admin: false,
-  })
-  await context.doInContext(config.appId!, async () => {
-    await events.user.updated(final)
-  })
-}
-
-async function createGroupAndUser(email: string) {
-  groupUser = await config.createUser({
-    email,
-    roles: {},
-    builder: false,
-    admin: false,
-  })
-  group = await config.createGroup()
-  await config.addUserToGroup(group._id!, groupUser._id!)
-}
-
-async function removeUserFromGroup() {
-  await config.removeUserFromGroup(group._id!, groupUser._id!)
-  return context.doInContext(config.appId!, async () => {
-    await events.user.updated(groupUser)
-  })
-}
-
-async function getUserMetadata(): Promise<UserMetadata[]> {
-  return context.doInContext(config.appId!, async () => {
-    return await rawUserMetadata()
-  })
-}
-
-function buildRoles() {
-  return { [config.prodAppId!]: ROLE_ID }
-}
-
-describe("app user/group sync", () => {
-  const groupEmail = "test2@test.com",
-    normalEmail = "test@test.com"
-  async function checkEmail(
-    email: string,
-    opts?: { group?: boolean; notFound?: boolean }
-  ) {
-    await waitForUpdate(opts || {})
-    const metadata = await getUserMetadata()
-    const found = metadata.find(data => data.email === email)
-    if (opts?.notFound) {
-      expect(found).toBeUndefined()
-    } else {
-      expect(found).toBeDefined()
-    }
-  }
-
-  it("should be able to sync a new user, add then remove", async () => {
-    const user = await createUser(normalEmail, buildRoles())
-    await checkEmail(normalEmail)
-    await removeUserRole(user)
-    await checkEmail(normalEmail, { notFound: true })
-  })
-
-  it("should be able to sync a group", async () => {
-    await createGroupAndUser(groupEmail)
-    await checkEmail(groupEmail, { group: true })
-  })
-
-  it("should be able to remove user from group", async () => {
-    if (!group) {
-      await createGroupAndUser(groupEmail)
-    }
-    await removeUserFromGroup()
-    await checkEmail(groupEmail, { notFound: true })
-  })
-
-  it("should be able to handle builder users", async () => {
-    await createUser("test3@test.com", {}, true)
-    await checkEmail("test3@test.com")
-  })
-})

package/src/sdk/plugins/index.ts

@@ -1,5 +0,0 @@
-import * as plugins from "./plugins"
-
-export default {
-  ...plugins,
-}

package/src/sdk/plugins/plugins.ts

@@ -1,41 +0,0 @@
-import { FileType, Plugin, PluginSource, PluginType } from "@budibase/types"
-import {
-  db as dbCore,
-  objectStore,
-  plugins as pluginCore,
-  tenancy,
-} from "@budibase/backend-core"
-import { fileUpload } from "../../api/controllers/plugin/file"
-import env from "../../environment"
-import { clientAppSocket } from "../../websockets"
-import { sdk as pro } from "@budibase/pro"
-
-export async function fetch(type?: PluginType) {
-  const db = tenancy.getGlobalDB()
-  const response = await db.allDocs(
-    dbCore.getPluginParams(null, {
-      include_docs: true,
-    })
-  )
-  let plugins = response.rows.map((row: any) => row.doc) as Plugin[]
-  plugins = objectStore.enrichPluginURLs(plugins)
-  if (type) {
-    return plugins.filter((plugin: Plugin) => plugin.schema?.type === type)
-  } else {
-    return plugins
-  }
-}
-
-export async function processUploaded(plugin: FileType, source?: PluginSource) {
-  const { metadata, directory } = await fileUpload(plugin)
-  pluginCore.validate(metadata?.schema)
-
-  // Only allow components in cloud
-  if (!env.SELF_HOSTED && metadata?.schema?.type !== PluginType.COMPONENT) {
-    throw new Error("Only component plugins are supported outside of self-host")
-  }
-
-  const doc = await pro.plugins.storePlugin(metadata, directory, source)
-  clientAppSocket.emit("plugin-update", { name: doc.name, hash: doc.hash })
-  return doc
-}

package/src/websockets/client.ts

@@ -1,11 +0,0 @@
-import Socket from "./websocket"
-import authorized from "../middleware/authorized"
-import http from "http"
-import Koa from "koa"
-import { permissions } from "@budibase/backend-core"
-
-export default class ClientAppWebsocket extends Socket {
-  constructor(app: Koa, server: http.Server) {
-    super(app, server, "/socket/client", [authorized(permissions.BUILDER)])
-  }
-}

package/src/websockets/grid.ts

@@ -1,55 +0,0 @@
-import authorized from "../middleware/authorized"
-import Socket from "./websocket"
-import { permissions } from "@budibase/backend-core"
-import http from "http"
-import Koa from "koa"
-
-export default class GridSocket extends Socket {
-  constructor(app: Koa, server: http.Server) {
-    super(app, server, "/socket/grid", [authorized(permissions.BUILDER)])
-
-    this.io.on("connection", socket => {
-      const user = socket.data.user
-      console.log(`Spreadsheet user connected: ${user?.id}`)
-
-      // Socket state
-      let currentRoom: string
-
-      // Initial identification of connected spreadsheet
-      socket.on("select-table", async (tableId, callback) => {
-        // Leave current room
-        if (currentRoom) {
-          socket.to(currentRoom).emit("user-disconnect", socket.data.user)
-          socket.leave(currentRoom)
-        }
-
-        // Join new room
-        currentRoom = tableId
-        socket.join(currentRoom)
-        socket.to(currentRoom).emit("user-update", socket.data.user)
-
-        // Reply with all users in current room
-        const sockets = await this.io.in(currentRoom).fetchSockets()
-        callback({
-          users: sockets.map(socket => socket.data.user),
-          id: user.id,
-        })
-      })
-
-      // Handle users selecting a new cell
-      socket.on("select-cell", cellId => {
-        socket.data.user.selectedCellId = cellId
-        if (currentRoom) {
-          socket.to(currentRoom).emit("user-update", socket.data.user)
-        }
-      })
-
-      // Disconnection cleanup
-      socket.on("disconnect", () => {
-        if (currentRoom) {
-          socket.to(currentRoom).emit("user-disconnect", socket.data.user)
-        }
-      })
-    })
-  }
-}

package/src/websockets/index.ts

@@ -1,14 +0,0 @@
-import http from "http"
-import Koa from "koa"
-import GridSocket from "./grid"
-import ClientAppSocket from "./client"
-
-let clientAppSocket: ClientAppSocket
-let gridSocket: GridSocket
-
-export const initialise = (app: Koa, server: http.Server) => {
-  clientAppSocket = new ClientAppSocket(app, server)
-  gridSocket = new GridSocket(app, server)
-}
-
-export { clientAppSocket, gridSocket }

package/src/websockets/websocket.ts

@@ -1,83 +0,0 @@
-import { Server } from "socket.io"
-import http from "http"
-import Koa from "koa"
-import Cookies from "cookies"
-import { userAgent } from "koa-useragent"
-import { auth } from "@budibase/backend-core"
-import currentApp from "../middleware/currentapp"
-
-export default class Socket {
-  io: Server
-
-  constructor(
-    app: Koa,
-    server: http.Server,
-    path: string,
-    additionalMiddlewares?: any[]
-  ) {
-    this.io = new Server(server, {
-      path,
-    })
-
-    // Attach default middlewares
-    const authenticate = auth.buildAuthMiddleware([], {
-      publicAllowed: true,
-    })
-    const middlewares = [
-      userAgent,
-      authenticate,
-      currentApp,
-      ...(additionalMiddlewares || []),
-    ]
-
-    // Apply middlewares
-    this.io.use(async (socket, next) => {
-      // Build fake koa context
-      const res = new http.ServerResponse(socket.request)
-      const ctx: any = {
-        ...app.createContext(socket.request, res),
-
-        // Additional overrides needed to make our middlewares work with this
-        // fake koa context
-        cookies: new Cookies(socket.request, res),
-        get: (field: string) => socket.request.headers[field],
-        throw: (code: number, message: string) => {
-          throw new Error(message)
-        },
-
-        // Needed for koa-useragent middleware
-        headers: socket.request.headers,
-        header: socket.request.headers,
-
-        // We don't really care about the path since it will never contain
-        // an app ID
-        path: "/socket",
-      }
-
-      // Run all koa middlewares
-      try {
-        for (let [idx, middleware] of middlewares.entries()) {
-          await middleware(ctx, () => {
-            if (idx === middlewares.length - 1) {
-              // Middlewares are finished.
-              // Extract some data from our enriched koa context to persist
-              // as metadata for the socket
-              socket.data.user = {
-                id: ctx.user._id,
-                email: ctx.user.email,
-              }
-              next()
-            }
-          })
-        }
-      } catch (error: any) {
-        next(error)
-      }
-    })
-  }
-
-  // Emit an event to all sockets
-  emit(event: string, payload: any) {
-    this.io.sockets.emit(event, payload)
-  }
-}