@budibase/server 2.5.6-alpha.4 → 2.5.6-alpha.41

package/src/tests/utilities/structures.ts

@@ -1,18 +1,22 @@
-import { permissions, roles } from "@budibase/backend-core"
+import { permissions, roles, utils } from "@budibase/backend-core"
 import { createHomeScreen } from "../../constants/screens"
 import { EMPTY_LAYOUT } from "../../constants/layouts"
 import { cloneDeep } from "lodash/fp"
-import { ACTION_DEFINITIONS, TRIGGER_DEFINITIONS } from "../../automations"
+import {
+  BUILTIN_ACTION_DEFINITIONS,
+  TRIGGER_DEFINITIONS,
+} from "../../automations"
 import {
   Automation,
   AutomationActionStepId,
+  AutomationStep,
+  AutomationStepType,
+  AutomationTrigger,
   AutomationTriggerStepId,
   Datasource,
   SourceName,
 } from "@budibase/types"
 
-const { v4: uuidv4 } = require("uuid")
-
 export function basicTable() {
   return {
     name: "TestTable",
@@ -71,19 +75,19 @@ export function view(tableId: string) {
 }
 
 export function automationStep(
-  actionDefinition = ACTION_DEFINITIONS.CREATE_ROW
-) {
+  actionDefinition = BUILTIN_ACTION_DEFINITIONS.CREATE_ROW
+): AutomationStep {
   return {
-    id: uuidv4(),
+    id: utils.newid(),
     ...actionDefinition,
   }
 }
 
 export function automationTrigger(
   triggerDefinition = TRIGGER_DEFINITIONS.ROW_SAVED
-) {
+): AutomationTrigger {
   return {
-    id: uuidv4(),
+    id: utils.newid(),
     ...triggerDefinition,
   }
 }
@@ -106,7 +110,7 @@ export function newAutomation({ steps, trigger }: any = {}) {
   return automation
 }
 
-export function basicAutomation(appId?: string) {
+export function basicAutomation(appId?: string): Automation {
   return {
     name: "My Automation",
     screenId: "kasdkfldsafkl",
@@ -119,18 +123,22 @@ export function basicAutomation(appId?: string) {
         tagline: "test",
         icon: "test",
         description: "test",
-        type: "trigger",
+        type: AutomationStepType.TRIGGER,
         id: "test",
         inputs: {},
         schema: {
-          inputs: {},
-          outputs: {},
+          inputs: {
+            properties: {},
+          },
+          outputs: {
+            properties: {},
+          },
         },
       },
       steps: [],
     },
     type: "automation",
-    appId,
+    appId: appId!,
   }
 }
 
@@ -154,7 +162,7 @@ export function loopAutomation(tableId: string, loopOpts?: any): Automation {
           inputs: {
             tableId,
           },
-          schema: ACTION_DEFINITIONS.QUERY_ROWS.schema,
+          schema: BUILTIN_ACTION_DEFINITIONS.QUERY_ROWS.schema,
         },
         {
           id: "c",
@@ -163,7 +171,7 @@ export function loopAutomation(tableId: string, loopOpts?: any): Automation {
           internal: true,
           inputs: loopOpts,
           blockToLoop: "d",
-          schema: ACTION_DEFINITIONS.LOOP.schema,
+          schema: BUILTIN_ACTION_DEFINITIONS.LOOP.schema,
         },
         {
           id: "d",
@@ -173,7 +181,7 @@ export function loopAutomation(tableId: string, loopOpts?: any): Automation {
           inputs: {
             text: "log statement",
           },
-          schema: ACTION_DEFINITIONS.SERVER_LOG.schema,
+          schema: BUILTIN_ACTION_DEFINITIONS.SERVER_LOG.schema,
         },
       ],
       trigger: {

package/src/threads/automation.ts

@@ -27,8 +27,8 @@ import { processObject } from "@budibase/string-templates"
 import { cloneDeep } from "lodash/fp"
 import * as sdkUtils from "../sdk/utils"
 import env from "../environment"
-const FILTER_STEP_ID = actions.ACTION_DEFINITIONS.FILTER.stepId
-const LOOP_STEP_ID = actions.ACTION_DEFINITIONS.LOOP.stepId
+const FILTER_STEP_ID = actions.BUILTIN_ACTION_DEFINITIONS.FILTER.stepId
+const LOOP_STEP_ID = actions.BUILTIN_ACTION_DEFINITIONS.LOOP.stepId
 const CRON_STEP_ID = triggerDefs.CRON.stepId
 const STOPPED_STATUS = { success: true, status: AutomationStatus.STOPPED }
 

package/src/utilities/fileSystem/plugin.ts

@@ -5,6 +5,7 @@ import { join } from "path"
 import { objectStore } from "@budibase/backend-core"
 
 const DATASOURCE_PATH = join(budibaseTempDir(), "datasource")
+const AUTOMATION_PATH = join(budibaseTempDir(), "automation")
 
 export const getPluginMetadata = async (path: string) => {
   let metadata: any = {}
@@ -33,12 +34,12 @@ export const getPluginMetadata = async (path: string) => {
   return { metadata, directory: path }
 }
 
-export const getDatasourcePlugin = async (plugin: Plugin) => {
+async function getPluginImpl(path: string, plugin: Plugin) {
   const hash = plugin.schema?.hash
-  if (!fs.existsSync(DATASOURCE_PATH)) {
-    fs.mkdirSync(DATASOURCE_PATH)
+  if (!fs.existsSync(path)) {
+    fs.mkdirSync(path)
   }
-  const filename = join(DATASOURCE_PATH, plugin.name)
+  const filename = join(path, plugin.name)
   const metadataName = `${filename}.bbmetadata`
   if (fs.existsSync(filename)) {
     const currentHash = fs.readFileSync(metadataName, "utf8")
@@ -62,3 +63,11 @@ export const getDatasourcePlugin = async (plugin: Plugin) => {
 
   return require(filename)
 }
+
+export const getDatasourcePlugin = async (plugin: Plugin) => {
+  return getPluginImpl(DATASOURCE_PATH, plugin)
+}
+
+export const getAutomationPlugin = async (plugin: Plugin) => {
+  return getPluginImpl(AUTOMATION_PATH, plugin)
+}

package/src/utilities/rowProcessor/utils.ts

@@ -1,11 +1,11 @@
 import {
-  FieldTypes,
-  FormulaTypes,
   AutoFieldDefaultNames,
   AutoFieldSubTypes,
+  FieldTypes,
+  FormulaTypes,
 } from "../../constants"
 import { processStringSync } from "@budibase/string-templates"
-import { FieldSchema, Table, Row } from "@budibase/types"
+import { FieldSchema, FieldType, Row, Table } from "@budibase/types"
 
 /**
  * If the subtype has been lost for any reason this works out what
@@ -50,6 +50,7 @@ export function processFormulas(
     const isStatic = schema.formulaType === FormulaTypes.STATIC
     if (
       schema.type !== FieldTypes.FORMULA ||
+      schema.formula == null ||
       (dynamic && isStatic) ||
       (!dynamic && !isStatic)
     ) {
@@ -57,13 +58,11 @@ export function processFormulas(
     }
     // iterate through rows and process formula
     for (let i = 0; i < rowArray.length; i++) {
-      if (schema.formula) {
-        let row = rowArray[i]
-        let context = contextRows ? contextRows[i] : row
-        rowArray[i] = {
-          ...row,
-          [column]: processStringSync(schema.formula, context),
-        }
+      let row = rowArray[i]
+      let context = contextRows ? contextRows[i] : row
+      rowArray[i] = {
+        ...row,
+        [column]: processStringSync(schema.formula, context),
       }
     }
   }

package/src/watch.ts

@@ -3,7 +3,7 @@ import env from "./environment"
 import chokidar from "chokidar"
 import fs from "fs"
 import { constants, tenancy } from "@budibase/backend-core"
-import { processUploadedPlugin } from "./api/controllers/plugin"
+import pluginsSdk from "./sdk/plugins"
 
 export function watch() {
   const watchPath = path.join(env.PLUGINS_DIR, "./**/*.tar.gz")
@@ -27,7 +27,7 @@ export function watch() {
           const split = path.split("/")
           const name = split[split.length - 1]
           console.log("Importing plugin:", path)
-          await processUploadedPlugin({ name, path })
+          await pluginsSdk.processUploaded({ name, path })
         } catch (err: any) {
           const message = err?.message ? err?.message : err
           console.error("Failed to import plugin:", message)

package/src/websockets/client.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,83 @@
+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)
+  }
+}

package/tsconfig.build.json

@@ -8,13 +8,11 @@
     "esModuleInterop": true,
     "resolveJsonModule": true,
     "incremental": true,
-    "types": [ "node", "jest" ],
-    "outDir": "dist",
+    "types": ["node", "jest"],
+    "outDir": "dist/src",
     "skipLibCheck": true
   },
-  "include": [
-    "src/**/*"
-  ],
+  "include": ["src/**/*"],
   "exclude": [
     "node_modules",
     "dist",

package/tsconfig.json

@@ -5,6 +5,7 @@
     "declaration": true,
     "sourceMap": true,
     "baseUrl": ".",
+    "outDir": "dist",
     "paths": {
       "@budibase/types": ["../types/src"],
       "@budibase/backend-core": ["../backend-core/src"],
@@ -23,6 +24,6 @@
     { "path": "../shared-core" },
     { "path": "../../../budibase-pro/packages/pro" }
   ],
-  "include": ["src/**/*", "specs", "package.json"],
+  "include": ["src/**/*", "specs"],
   "exclude": ["node_modules", "dist"]
 }