@budibase/server 0.0.32 → 0.0.999-alpha.31

package/src/api/controllers/row/utils.ts

@@ -0,0 +1,156 @@
+import { InternalTables } from "../../../db/utils"
+import * as userController from "../user"
+import { FieldTypes } from "../../../constants"
+import { context } from "@budibase/backend-core"
+import { makeExternalQuery } from "../../../integrations/base/query"
+import { Row, Table } from "@budibase/types"
+import { Format } from "../view/exporters"
+import { UserCtx } from "@budibase/types"
+import sdk from "../../../sdk"
+const validateJs = require("validate.js")
+const { cloneDeep } = require("lodash/fp")
+
+validateJs.extend(validateJs.validators.datetime, {
+  parse: function (value: string) {
+    return new Date(value).getTime()
+  },
+  // Input is a unix timestamp
+  format: function (value: string) {
+    return new Date(value).toISOString()
+  },
+})
+
+export async function getDatasourceAndQuery(json: any) {
+  const datasourceId = json.endpoint.datasourceId
+  const datasource = await sdk.datasources.get(datasourceId)
+  return makeExternalQuery(datasource, json)
+}
+
+export async function findRow(ctx: UserCtx, tableId: string, rowId: string) {
+  const db = context.getAppDB()
+  let row
+  // TODO remove special user case in future
+  if (tableId === InternalTables.USER_METADATA) {
+    ctx.params = {
+      id: rowId,
+    }
+    await userController.findMetadata(ctx)
+    row = ctx.body
+  } else {
+    row = await db.get(rowId)
+  }
+  if (row.tableId !== tableId) {
+    throw "Supplied tableId does not match the rows tableId"
+  }
+  return row
+}
+
+export async function validate({
+  tableId,
+  row,
+  table,
+}: {
+  tableId?: string
+  row: Row
+  table?: Table
+}) {
+  let fetchedTable: Table
+  if (!table) {
+    fetchedTable = await sdk.tables.getTable(tableId)
+  } else {
+    fetchedTable = table
+  }
+  const errors: any = {}
+  for (let fieldName of Object.keys(fetchedTable.schema)) {
+    const column = fetchedTable.schema[fieldName]
+    const constraints = cloneDeep(column.constraints)
+    const type = column.type
+    // formulas shouldn't validated, data will be deleted anyway
+    if (type === FieldTypes.FORMULA || column.autocolumn) {
+      continue
+    }
+    // special case for options, need to always allow unselected (null)
+    if (type === FieldTypes.OPTIONS && constraints.inclusion) {
+      constraints.inclusion.push(null)
+    }
+    let res
+
+    // Validate.js doesn't seem to handle array
+    if (type === FieldTypes.ARRAY && row[fieldName]) {
+      if (row[fieldName].length) {
+        if (!Array.isArray(row[fieldName])) {
+          row[fieldName] = row[fieldName].split(",")
+        }
+        row[fieldName].map((val: any) => {
+          if (
+            !constraints.inclusion.includes(val) &&
+            constraints.inclusion.length !== 0
+          ) {
+            errors[fieldName] = "Field not in list"
+          }
+        })
+      } else if (constraints.presence && row[fieldName].length === 0) {
+        // non required MultiSelect creates an empty array, which should not throw errors
+        errors[fieldName] = [`${fieldName} is required`]
+      }
+    } else if (
+      (type === FieldTypes.ATTACHMENT || type === FieldTypes.JSON) &&
+      typeof row[fieldName] === "string"
+    ) {
+      // this should only happen if there is an error
+      try {
+        const json = JSON.parse(row[fieldName])
+        if (type === FieldTypes.ATTACHMENT) {
+          if (Array.isArray(json)) {
+            row[fieldName] = json
+          } else {
+            errors[fieldName] = [`Must be an array`]
+          }
+        }
+      } catch (err) {
+        errors[fieldName] = [`Contains invalid JSON`]
+      }
+    } else {
+      res = validateJs.single(row[fieldName], constraints)
+    }
+    if (res) errors[fieldName] = res
+  }
+  return { valid: Object.keys(errors).length === 0, errors }
+}
+
+export function cleanExportRows(
+  rows: any[],
+  schema: any,
+  format: string,
+  columns: string[]
+) {
+  let cleanRows = [...rows]
+
+  const relationships = Object.entries(schema)
+    .filter((entry: any[]) => entry[1].type === FieldTypes.LINK)
+    .map(entry => entry[0])
+
+  relationships.forEach(column => {
+    cleanRows.forEach(row => {
+      delete row[column]
+    })
+    delete schema[column]
+  })
+
+  // Intended to avoid 'undefined' in export
+  if (format === Format.CSV) {
+    const schemaKeys = Object.keys(schema)
+    for (let key of schemaKeys) {
+      if (columns?.length && columns.indexOf(key) > 0) {
+        continue
+      }
+      for (let row of cleanRows) {
+        if (row[key] == null) {
+          row[key] = ""
+        }
+      }
+    }
+  }
+
+  return cleanRows
+}

package/src/api/controllers/screen.ts

@@ -0,0 +1,126 @@
+import { getScreenParams, generateScreenID, DocumentType } from "../../db/utils"
+import {
+  events,
+  context,
+  tenancy,
+  db as dbCore,
+  roles,
+} from "@budibase/backend-core"
+import { updateAppPackage } from "./application"
+import { Plugin, ScreenProps, BBContext } from "@budibase/types"
+
+export async function fetch(ctx: BBContext) {
+  const db = context.getAppDB()
+
+  const screens = (
+    await db.allDocs(
+      getScreenParams(null, {
+        include_docs: true,
+      })
+    )
+  ).rows.map((el: any) => el.doc)
+
+  const roleId = ctx.user?.role?._id as string
+  if (!roleId) {
+    ctx.throw("Unable to retrieve users role ID.")
+  }
+  ctx.body = await new roles.AccessController().checkScreensAccess(
+    screens,
+    roleId
+  )
+}
+
+export async function save(ctx: BBContext) {
+  const db = context.getAppDB()
+  let screen = ctx.request.body
+
+  let eventFn
+  if (!screen._id) {
+    screen._id = generateScreenID()
+    eventFn = events.screen.created
+  }
+
+  const response = await db.put(screen)
+
+  // Find any custom components being used
+  let pluginNames: string[] = []
+  let pluginAdded = false
+  findPlugins(screen.props, pluginNames)
+  if (pluginNames.length) {
+    const globalDB = tenancy.getGlobalDB()
+    const pluginsResponse = await globalDB.allDocs(
+      dbCore.getPluginParams(null, {
+        include_docs: true,
+      })
+    )
+    const requiredPlugins = pluginsResponse.rows
+      .map((row: any) => row.doc)
+      .filter((plugin: Plugin) => {
+        return (
+          plugin.schema.type === "component" &&
+          pluginNames.includes(`plugin/${plugin.name}`)
+        )
+      })
+
+    // Update the app metadata
+    const application = await db.get(DocumentType.APP_METADATA)
+    let usedPlugins = application.usedPlugins || []
+
+    requiredPlugins.forEach((plugin: Plugin) => {
+      if (!usedPlugins.find((x: Plugin) => x._id === plugin._id)) {
+        pluginAdded = true
+        usedPlugins.push({
+          _id: plugin._id,
+          name: plugin.name,
+          version: plugin.version,
+          jsUrl: plugin.jsUrl,
+          hash: plugin.hash,
+        })
+      }
+    })
+
+    if (pluginAdded) {
+      await updateAppPackage({ usedPlugins }, ctx.appId)
+    }
+  }
+
+  if (eventFn) {
+    await eventFn(screen)
+  }
+  ctx.message = `Screen ${screen.name} saved.`
+  ctx.body = {
+    ...screen,
+    _id: response.id,
+    _rev: response.rev,
+    pluginAdded,
+  }
+}
+
+export async function destroy(ctx: BBContext) {
+  const db = context.getAppDB()
+  const id = ctx.params.screenId
+  const screen = await db.get(id)
+
+  await db.remove(id, ctx.params.screenRev)
+
+  await events.screen.deleted(screen)
+  ctx.body = {
+    message: "Screen deleted successfully",
+  }
+  ctx.status = 200
+}
+
+function findPlugins(component: ScreenProps, foundPlugins: string[]) {
+  if (!component) {
+    return
+  }
+  if (component._component.startsWith("plugin")) {
+    if (!foundPlugins.includes(component._component)) {
+      foundPlugins.push(component._component)
+    }
+  }
+  if (!component._children || !component._children.length) {
+    return
+  }
+  component._children.forEach(child => findPlugins(child, foundPlugins))
+}

package/src/api/controllers/script.ts

@@ -0,0 +1,12 @@
+import ScriptRunner from "../../utilities/scriptRunner"
+import { BBContext } from "@budibase/types"
+
+export async function execute(ctx: BBContext) {
+  const { script, context } = ctx.request.body
+  const runner = new ScriptRunner(script, context)
+  ctx.body = runner.execute()
+}
+
+export async function save(ctx: BBContext) {
+  ctx.throw(501, "Not currently implemented")
+}

package/src/api/controllers/static/index.ts

@@ -0,0 +1,241 @@
+require("svelte/register")
+
+import { resolve, join } from "../../../utilities/centralPath"
+const uuid = require("uuid")
+import { ObjectStoreBuckets } from "../../../constants"
+import { processString } from "@budibase/string-templates"
+import {
+  loadHandlebarsFile,
+  NODE_MODULES_PATH,
+  TOP_LEVEL_PATH,
+} from "../../../utilities/fileSystem"
+import env from "../../../environment"
+import { DocumentType } from "../../../db/utils"
+import { context, objectStore, utils, configs } from "@budibase/backend-core"
+import AWS from "aws-sdk"
+import fs from "fs"
+import sdk from "../../../sdk"
+import * as pro from "@budibase/pro"
+
+const send = require("koa-send")
+
+async function prepareUpload({ s3Key, bucket, metadata, file }: any) {
+  const response = await objectStore.upload({
+    bucket,
+    metadata,
+    filename: s3Key,
+    path: file.path,
+    type: file.type,
+  })
+
+  // don't store a URL, work this out on the way out as the URL could change
+  return {
+    size: file.size,
+    name: file.name,
+    url: objectStore.getAppFileUrl(s3Key),
+    extension: [...file.name.split(".")].pop(),
+    key: response.Key,
+  }
+}
+
+export const toggleBetaUiFeature = async function (ctx: any) {
+  const cookieName = `beta:${ctx.params.feature}`
+
+  if (ctx.cookies.get(cookieName)) {
+    utils.clearCookie(ctx, cookieName)
+    ctx.body = {
+      message: `${ctx.params.feature} disabled`,
+    }
+    return
+  }
+
+  let builderPath = resolve(TOP_LEVEL_PATH, "new_design_ui")
+
+  // // download it from S3
+  if (!fs.existsSync(builderPath)) {
+    fs.mkdirSync(builderPath)
+  }
+  await objectStore.downloadTarballDirect(
+    "https://cdn.budi.live/beta:design_ui/new_ui.tar.gz",
+    builderPath
+  )
+  utils.setCookie(ctx, {}, cookieName)
+
+  ctx.body = {
+    message: `${ctx.params.feature} enabled`,
+  }
+}
+
+export const serveBuilder = async function (ctx: any) {
+  const builderPath = resolve(TOP_LEVEL_PATH, "builder")
+  await send(ctx, ctx.file, { root: builderPath })
+}
+
+export const uploadFile = async function (ctx: any) {
+  let files =
+    ctx.request.files.file.length > 1
+      ? Array.from(ctx.request.files.file)
+      : [ctx.request.files.file]
+
+  const uploads = files.map(async (file: any) => {
+    const fileExtension = [...file.name.split(".")].pop()
+    // filenames converted to UUIDs so they are unique
+    const processedFileName = `${uuid.v4()}.${fileExtension}`
+
+    return prepareUpload({
+      file,
+      s3Key: `${context.getProdAppId()}/attachments/${processedFileName}`,
+      bucket: ObjectStoreBuckets.APPS,
+    })
+  })
+
+  ctx.body = await Promise.all(uploads)
+}
+
+export const deleteObjects = async function (ctx: any) {
+  ctx.body = await objectStore.deleteFiles(
+    ObjectStoreBuckets.APPS,
+    ctx.request.body.keys
+  )
+}
+
+export const serveApp = async function (ctx: any) {
+  //Public Settings
+  const { config } = await configs.getSettingsConfigDoc()
+  const branding = await pro.branding.getBrandingConfig(config)
+
+  let db
+  try {
+    db = context.getAppDB({ skip_setup: true })
+    const appInfo = await db.get(DocumentType.APP_METADATA)
+    let appId = context.getAppId()
+
+    if (!env.isJest()) {
+      const App = require("./templates/BudibaseApp.svelte").default
+      const plugins = objectStore.enrichPluginURLs(appInfo.usedPlugins)
+      const { head, html, css } = App.render({
+        metaImage:
+          branding?.metaImageUrl ||
+          "https://res.cloudinary.com/daog6scxm/image/upload/v1666109324/meta-images/budibase-meta-image_uukc1m.png",
+        metaDescription: branding?.metaDescription || "",
+        metaTitle:
+          branding?.metaTitle || `${appInfo.name} - built with Budibase`,
+        title: appInfo.name,
+        production: env.isProd(),
+        appId,
+        clientLibPath: objectStore.clientLibraryUrl(appId!, appInfo.version),
+        usedPlugins: plugins,
+        favicon:
+          branding.faviconUrl !== ""
+            ? objectStore.getGlobalFileUrl("settings", "faviconUrl")
+            : "",
+        logo:
+          config?.logoUrl !== ""
+            ? objectStore.getGlobalFileUrl("settings", "logoUrl")
+            : "",
+      })
+      const appHbs = loadHandlebarsFile(`${__dirname}/templates/app.hbs`)
+      ctx.body = await processString(appHbs, {
+        head,
+        body: html,
+        style: css.code,
+        appId,
+      })
+    } else {
+      // just return the app info for jest to assert on
+      ctx.body = appInfo
+    }
+  } catch (error) {
+    if (!env.isJest()) {
+      const App = require("./templates/BudibaseApp.svelte").default
+      const { head, html, css } = App.render({
+        title: branding?.metaTitle,
+        metaTitle: branding?.metaTitle,
+        metaImage:
+          branding?.metaImageUrl ||
+          "https://res.cloudinary.com/daog6scxm/image/upload/v1666109324/meta-images/budibase-meta-image_uukc1m.png",
+        metaDescription: branding?.metaDescription || "",
+        favicon:
+          branding.faviconUrl !== ""
+            ? objectStore.getGlobalFileUrl("settings", "faviconUrl")
+            : "",
+      })
+
+      const appHbs = loadHandlebarsFile(`${__dirname}/templates/app.hbs`)
+      ctx.body = await processString(appHbs, {
+        head,
+        body: html,
+        style: css.code,
+      })
+    }
+  }
+}
+
+export const serveBuilderPreview = async function (ctx: any) {
+  const db = context.getAppDB({ skip_setup: true })
+  const appInfo = await db.get(DocumentType.APP_METADATA)
+
+  if (!env.isJest()) {
+    let appId = context.getAppId()
+    const previewHbs = loadHandlebarsFile(`${__dirname}/templates/preview.hbs`)
+    ctx.body = await processString(previewHbs, {
+      clientLibPath: objectStore.clientLibraryUrl(appId!, appInfo.version),
+    })
+  } else {
+    // just return the app info for jest to assert on
+    ctx.body = { ...appInfo, builderPreview: true }
+  }
+}
+
+export const serveClientLibrary = async function (ctx: any) {
+  return send(ctx, "budibase-client.js", {
+    root: join(NODE_MODULES_PATH, "@budibase", "client", "dist"),
+  })
+}
+
+export const getSignedUploadURL = async function (ctx: any) {
+  // Ensure datasource is valid
+  let datasource
+  try {
+    const { datasourceId } = ctx.params
+    datasource = await sdk.datasources.get(datasourceId, { enriched: true })
+    if (!datasource) {
+      ctx.throw(400, "The specified datasource could not be found")
+    }
+  } catch (error) {
+    ctx.throw(400, "The specified datasource could not be found")
+  }
+
+  // Ensure we aren't using a custom endpoint
+  if (datasource?.config?.endpoint) {
+    ctx.throw(400, "S3 datasources with custom endpoints are not supported")
+  }
+
+  // Determine type of datasource and generate signed URL
+  let signedUrl
+  let publicUrl
+  const awsRegion = (datasource?.config?.region || "eu-west-1") as string
+  if (datasource?.source === "S3") {
+    const { bucket, key } = ctx.request.body || {}
+    if (!bucket || !key) {
+      ctx.throw(400, "bucket and key values are required")
+      return
+    }
+    try {
+      const s3 = new AWS.S3({
+        region: awsRegion,
+        accessKeyId: datasource?.config?.accessKeyId as string,
+        secretAccessKey: datasource?.config?.secretAccessKey as string,
+        apiVersion: "2006-03-01",
+        signatureVersion: "v4",
+      })
+      const params = { Bucket: bucket, Key: key }
+      signedUrl = s3.getSignedUrl("putObject", params)
+      publicUrl = `https://${bucket}.s3.${awsRegion}.amazonaws.com/${key}`
+    } catch (error) {
+      ctx.throw(400, error)
+    }
+  }
+
+  ctx.body = { signedUrl, publicUrl }
+}

package/src/api/controllers/static/templates/BudibaseApp.svelte

@@ -0,0 +1,135 @@
+<script>
+  export let title = ""
+  export let favicon = ""
+
+  export let metaImage = ""
+  export let metaTitle = ""
+  export let metaDescription = ""
+
+  export let clientLibPath
+  export let usedPlugins
+</script>
+
+<svelte:head>
+  <meta charset="utf8" />
+  <meta
+    name="viewport"
+    content="width=device-width, initial-scale=1.0, viewport-fit=cover"
+  />
+
+  <!-- Primary Meta Tags -->
+  <meta name="title" content={metaTitle} />
+  <meta name="description" content={metaDescription} />
+
+  <!-- Opengraph Meta Tags -->
+  <meta property="og:site_name" content="Budibase" />
+  <meta property="og:title" content={metaTitle} />
+  <meta property="og:description" content={metaDescription} />
+  <meta property="og:type" content="website" />
+  <meta property="og:image" content={metaImage} />
+
+  <!-- Twitter -->
+  <meta property="twitter:card" content="summary_large_image" />
+  <meta property="twitter:site" content="@budibase" />
+  <meta property="twitter:image" content={metaImage} />
+  <meta property="twitter:image:alt" content={metaTitle} />
+  <meta property="twitter:title" content={metaTitle} />
+  <meta property="twitter:description" content={metaDescription} />
+
+  <title>{title}</title>
+  {#if favicon !== ""}
+    <link rel="icon" type="image/png" href={favicon} />
+  {:else}
+    <link rel="icon" type="image/png" href="https://i.imgur.com/Xhdt1YP.png" />
+  {/if}
+
+  <link rel="stylesheet" href="https://rsms.me/inter/inter.css" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" />
+  <link
+    href="https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;600;700&display=swap"
+    rel="stylesheet"
+  />
+  <link
+    href="https://cdn.jsdelivr.net/npm/remixicon@2.5.0/fonts/remixicon.css"
+    rel="stylesheet"
+  />
+  <style>
+    html,
+    body {
+      height: 100%;
+      width: 100%;
+      margin: 0;
+      padding: 0;
+    }
+    *,
+    *:before,
+    *:after {
+      box-sizing: border-box;
+    }
+
+    #error {
+      position: absolute;
+      top: 0;
+      left: 0;
+      height: 100vh;
+      width: 100vw;
+      display: none;
+      font-family: "Source Sans Pro", sans-serif;
+      flex-direction: column;
+      justify-content: center;
+      align-items: center;
+      background: #222;
+      text-align: center;
+      padding: 2rem;
+      gap: 2rem;
+    }
+    #error h1,
+    #error h2 {
+      margin: 0;
+    }
+    #error h1 {
+      color: #ccc;
+      font-size: 3rem;
+      font-weight: 600;
+    }
+    #error h2 {
+      color: #888;
+      font-weight: 400;
+    }
+  </style>
+</svelte:head>
+
+<body id="app">
+  <div id="error">
+    {#if clientLibPath}
+      <h1>There was an error loading your app</h1>
+      <h2>
+        The Budibase client library could not be loaded. Try republishing your
+        app.
+      </h2>
+    {:else}
+      <h2>We couldn't find that application</h2>
+      <p />
+    {/if}
+  </div>
+  <script type="application/javascript">
+    window.INIT_TIME = Date.now()
+  </script>
+  <script type="application/javascript" src={clientLibPath}>
+  </script>
+  <!-- Custom components need inserted after the core client library -->
+  <!-- But before loadBudibase is called -->
+  {#if usedPlugins?.length}
+    {#each usedPlugins as plugin}
+      <script type="application/javascript" src={plugin.jsUrl}></script>
+    {/each}
+  {/if}
+  <script type="application/javascript">
+    if (window.loadBudibase) {
+      window.loadBudibase()
+    } else {
+      console.error("Failed to load the Budibase client")
+      document.getElementById("error").style.display = "flex"
+    }
+  </script>
+</body>

package/src/api/controllers/static/templates/app.hbs

@@ -0,0 +1,13 @@
+<!doctype html>
+<html>
+
+  <head>
+    {{{head}}}
+  </head>
+
+  <script>
+    window["##BUDIBASE_APP_ID##"] = "{{appId}}"
+  </script>
+
+  {{{body}}}
+</html>