@budibase/server 0.9.136 → 0.9.140-alpha.0

package/src/api/controllers/metadata.js

@@ -0,0 +1,46 @@
+const { MetadataTypes } = require("../../constants")
+const CouchDB = require("../../db")
+const { generateMetadataID } = require("../../db/utils")
+const { saveEntityMetadata, deleteEntityMetadata } = require("../../utilities")
+
+exports.getTypes = async ctx => {
+  ctx.body = {
+    types: MetadataTypes,
+  }
+}
+
+exports.saveMetadata = async ctx => {
+  const { type, entityId } = ctx.params
+  if (type === MetadataTypes.AUTOMATION_TEST_HISTORY) {
+    ctx.throw(400, "Cannot save automation history type")
+  }
+  ctx.body = await saveEntityMetadata(
+    ctx.appId,
+    type,
+    entityId,
+    ctx.request.body
+  )
+}
+
+exports.deleteMetadata = async ctx => {
+  const { type, entityId } = ctx.params
+  await deleteEntityMetadata(ctx.appId, type, entityId)
+  ctx.body = {
+    message: "Metadata deleted successfully",
+  }
+}
+
+exports.getMetadata = async ctx => {
+  const { type, entityId } = ctx.params
+  const db = new CouchDB(ctx.appId)
+  const id = generateMetadataID(type, entityId)
+  try {
+    ctx.body = await db.get(id)
+  } catch (err) {
+    if (err.status === 404) {
+      ctx.body = {}
+    } else {
+      ctx.throw(err.status, err)
+    }
+  }
+}

package/src/api/controllers/query.js

@@ -160,8 +160,6 @@ exports.execute = async function (ctx) {
   )
 
   const integration = new Integration(datasource.config)
-  console.log(query)
-  // ctx.body = {}
   // call the relevant CRUD method on the integration class
   ctx.body = formatResponse(await integration[query.queryVerb](enrichedQuery))
   // cleanup

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

@@ -276,7 +276,7 @@ module External {
     }
 
     outputProcessing(
-      rows: Row[],
+      rows: Row[] = [],
       table: Table,
       relationships: RelationshipsJson[]
     ) {

package/src/api/controllers/row/index.js

@@ -113,6 +113,7 @@ exports.destroy = async function (ctx) {
 exports.search = async ctx => {
   const tableId = getTableId(ctx)
   try {
+    ctx.status = 200
     ctx.body = await pickApi(tableId).search(ctx)
   } catch (err) {
     ctx.throw(400, err)

package/src/api/controllers/row/internal.js

@@ -23,6 +23,19 @@ const CALCULATION_TYPES = {
   STATS: "stats",
 }
 
+async function storeResponse(ctx, db, row, oldTable, table) {
+  row.type = "row"
+  const response = await db.put(row)
+  // don't worry about rev, tables handle rev/lastID updates
+  if (!isEqual(oldTable, table)) {
+    await db.put(table)
+  }
+  row._rev = response.rev
+  // process the row before return, to include relationships
+  row = await outputProcessing(ctx, table, row, { squash: false })
+  return { row, table }
+}
+
 exports.patch = async ctx => {
   const appId = ctx.appId
   const db = new CouchDB(appId)
@@ -77,14 +90,7 @@ exports.patch = async ctx => {
     return { row: ctx.body, table }
   }
 
-  const response = await db.put(row)
-  // don't worry about rev, tables handle rev/lastID updates
-  if (!isEqual(dbTable, table)) {
-    await db.put(table)
-  }
-  row._rev = response.rev
-  row.type = "row"
-  return { row, table }
+  return storeResponse(ctx, db, row, dbTable, table)
 }
 
 exports.save = async function (ctx) {
@@ -118,14 +124,7 @@ exports.save = async function (ctx) {
     table,
   })
 
-  row.type = "row"
-  const response = await db.put(row)
-  // don't worry about rev, tables handle rev/lastID updates
-  if (!isEqual(dbTable, table)) {
-    await db.put(table)
-  }
-  row._rev = response.rev
-  return { row, table }
+  return storeResponse(ctx, db, row, dbTable, table)
 }
 
 exports.fetchView = async ctx => {
@@ -221,34 +220,47 @@ exports.destroy = async function (ctx) {
   const appId = ctx.appId
   const db = new CouchDB(appId)
   const { _id, _rev } = ctx.request.body
-  const row = await db.get(_id)
+  let row = await db.get(_id)
 
   if (row.tableId !== ctx.params.tableId) {
     throw "Supplied tableId doesn't match the row's tableId"
   }
+  const table = await db.get(row.tableId)
+  // update the row to include full relationships before deleting them
+  row = await outputProcessing(ctx, table, row, { squash: false })
+  // now remove the relationships
   await linkRows.updateLinks({
     appId,
     eventType: linkRows.EventType.ROW_DELETE,
     row,
     tableId: row.tableId,
   })
+
+  let response
   if (ctx.params.tableId === InternalTables.USER_METADATA) {
     ctx.params = {
       id: _id,
     }
     await userController.destroyMetadata(ctx)
-    return { response: ctx.body, row }
+    response = ctx.body
   } else {
-    const response = await db.remove(_id, _rev)
-    return { response, row }
+    response = await db.remove(_id, _rev)
   }
+  return { response, row }
 }
 
 exports.bulkDestroy = async ctx => {
   const appId = ctx.appId
-  const { rows } = ctx.request.body
   const db = new CouchDB(appId)
+  const tableId = ctx.params.tableId
+  const table = await db.get(tableId)
+  let { rows } = ctx.request.body
+
+  // before carrying out any updates, make sure the rows are ready to be returned
+  // they need to be the full rows (including previous relationships) for automations
+  rows = await outputProcessing(ctx, table, rows, { squash: false })
 
+  // remove the relationships first
   let updates = rows.map(row =>
     linkRows.updateLinks({
       appId,
@@ -257,8 +269,7 @@ exports.bulkDestroy = async ctx => {
       tableId: row.tableId,
     })
   )
-  // TODO remove special user case in future
-  if (ctx.params.tableId === InternalTables.USER_METADATA) {
+  if (tableId === InternalTables.USER_METADATA) {
     updates = updates.concat(
       rows.map(row => {
         ctx.params = {

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

@@ -2,11 +2,9 @@ require("svelte/register")
 
 const send = require("koa-send")
 const { resolve, join } = require("../../../utilities/centralPath")
-const fetch = require("node-fetch")
 const uuid = require("uuid")
 const { ObjectStoreBuckets } = require("../../../constants")
 const { processString } = require("@budibase/string-templates")
-const { budibaseTempDir } = require("../../../utilities/budibaseDir")
 const { getDeployedApps } = require("../../../utilities/workerRequests")
 const CouchDB = require("../../../db")
 const {
@@ -15,7 +13,7 @@ const {
   TOP_LEVEL_PATH,
 } = require("../../../utilities/fileSystem")
 const env = require("../../../environment")
-const { objectStoreUrl, clientLibraryPath } = require("../../../utilities")
+const { clientLibraryPath } = require("../../../utilities")
 const { upload } = require("../../../utilities/fileSystem")
 const { attachmentsRelativeURL } = require("../../../utilities")
 const { DocumentTypes } = require("../../../db/utils")
@@ -50,9 +48,6 @@ async function checkForSelfHostedURL(ctx) {
   }
 }
 
-// this was the version before we started versioning the component library
-const COMP_LIB_BASE_APP_VERSION = "0.2.5"
-
 exports.serveBuilder = async function (ctx) {
   let builderPath = resolve(TOP_LEVEL_PATH, "builder")
   await send(ctx, ctx.file, { root: builderPath })
@@ -109,36 +104,3 @@ exports.serveClientLibrary = async function (ctx) {
     root: join(NODE_MODULES_PATH, "@budibase", "client", "dist"),
   })
 }
-
-exports.serveComponentLibrary = async function (ctx) {
-  const appId = ctx.query.appId || ctx.appId
-
-  if (env.isDev() || env.isTest()) {
-    const componentLibraryPath = join(
-      budibaseTempDir(),
-      appId,
-      "node_modules",
-      "@budibase",
-      "standard-components",
-      "package",
-      "dist"
-    )
-    return send(ctx, "/index.js", { root: componentLibraryPath })
-  }
-  const db = new CouchDB(appId)
-  const appInfo = await db.get(DocumentTypes.APP_METADATA)
-
-  let componentLib = "componentlibrary"
-  if (appInfo && appInfo.version) {
-    componentLib += `-${appInfo.version}`
-  } else {
-    componentLib += `-${COMP_LIB_BASE_APP_VERSION}`
-  }
-  const S3_URL = encodeURI(
-    join(objectStoreUrl(), componentLib, ctx.query.library, "dist", "index.js")
-  )
-  const response = await fetch(S3_URL)
-  const body = await response.text()
-  ctx.type = "application/javascript"
-  ctx.body = body
-}

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

@@ -7,7 +7,10 @@
 
 <svelte:head>
   <meta charset="utf8" />
-  <meta name="viewport" content="width=device-width" />
+  <meta
+    name="viewport"
+    content="width=device-width, initial-scale=1.0, viewport-fit=cover"
+  />
 
   <title>{title}</title>
   <link rel="icon" type="image/png" href={favicon} />

package/src/api/controllers/user.js

@@ -33,6 +33,7 @@ exports.fetchMetadata = async function (ctx) {
     users.push({
       ...user,
       ...info,
+      tableId: InternalTables.USER_METADATA,
       // make sure the ID is always a local ID, not a global one
       _id: generateUserMetadataID(user._id),
     })

package/src/api/routes/automation.js

@@ -9,6 +9,10 @@ const {
 } = require("@budibase/auth/permissions")
 const Joi = require("joi")
 const { bodyResource, paramResource } = require("../../middleware/resourceId")
+const {
+  middleware: appInfoMiddleware,
+  AppType,
+} = require("../../middleware/appInfo")
 
 const router = Router()
 
@@ -22,7 +26,6 @@ function generateStepSchema(allowStepTypes) {
     tagline: Joi.string().required(),
     icon: Joi.string().required(),
     params: Joi.object(),
-    // TODO: validate args a bit more deeply
     args: Joi.object(),
     type: Joi.string().required().valid(...allowStepTypes),
   }).unknown(true)
@@ -31,7 +34,6 @@ function generateStepSchema(allowStepTypes) {
 function generateValidator(existing = false) {
   // prettier-ignore
   return joiValidator.body(Joi.object({
-    live: Joi.bool(),
     _id: existing ? Joi.string().required() : Joi.string(),
     _rev: existing ? Joi.string().required() : Joi.string(),
     name: Joi.string().required(),
@@ -54,11 +56,6 @@ router
     authorized(BUILDER),
     controller.getActionList
   )
-  .get(
-    "/api/automations/logic/list",
-    authorized(BUILDER),
-    controller.getLogicList
-  )
   .get(
     "/api/automations/definitions/list",
     authorized(BUILDER),
@@ -84,17 +81,25 @@ router
     generateValidator(false),
     controller.create
   )
+  .delete(
+    "/api/automations/:id/:rev",
+    paramResource("id"),
+    authorized(BUILDER),
+    controller.destroy
+  )
   .post(
     "/api/automations/:id/trigger",
+    appInfoMiddleware({ appType: AppType.PROD }),
     paramResource("id"),
     authorized(PermissionTypes.AUTOMATION, PermissionLevels.EXECUTE),
     controller.trigger
   )
-  .delete(
-    "/api/automations/:id/:rev",
+  .post(
+    "/api/automations/:id/test",
+    appInfoMiddleware({ appType: AppType.DEV }),
     paramResource("id"),
-    authorized(BUILDER),
-    controller.destroy
+    authorized(PermissionTypes.AUTOMATION, PermissionLevels.EXECUTE),
+    controller.test
   )
 
 module.exports = router

package/src/api/routes/index.js

@@ -22,6 +22,7 @@ const datasourceRoutes = require("./datasource")
 const queryRoutes = require("./query")
 const hostingRoutes = require("./hosting")
 const backupRoutes = require("./backup")
+const metadataRoutes = require("./metadata")
 const devRoutes = require("./dev")
 
 exports.mainRoutes = [
@@ -46,6 +47,7 @@ exports.mainRoutes = [
   queryRoutes,
   hostingRoutes,
   backupRoutes,
+  metadataRoutes,
   devRoutes,
   // these need to be handled last as they still use /api/:tableId
   // this could be breaking as koa may recognise other routes as this

package/src/api/routes/metadata.js

@@ -0,0 +1,38 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/metadata")
+const {
+  middleware: appInfoMiddleware,
+  AppType,
+} = require("../../middleware/appInfo")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/auth/permissions")
+
+const router = Router()
+
+router
+  .post(
+    "/api/metadata/:type/:entityId",
+    authorized(BUILDER),
+    appInfoMiddleware({ appType: AppType.DEV }),
+    controller.saveMetadata
+  )
+  .delete(
+    "/api/metadata/:type/:entityId",
+    authorized(BUILDER),
+    appInfoMiddleware({ appType: AppType.DEV }),
+    controller.deleteMetadata
+  )
+  .get(
+    "/api/metadata/type",
+    authorized(BUILDER),
+    appInfoMiddleware({ appType: AppType.DEV }),
+    controller.getTypes
+  )
+  .get(
+    "/api/metadata/:type/:entityId",
+    authorized(BUILDER),
+    appInfoMiddleware({ appType: AppType.DEV }),
+    controller.getMetadata
+  )
+
+module.exports = router

package/src/api/routes/static.js

@@ -44,7 +44,6 @@ router
     authorized(PermissionTypes.TABLE, PermissionLevels.WRITE),
     controller.uploadFile
   )
-  .get("/componentlibrary", controller.serveComponentLibrary)
   // TODO: this likely needs to be secured in some way
   .get("/:appId/:path*", controller.serveApp)
 

package/src/api/routes/tests/automation.spec.js

@@ -2,6 +2,7 @@ const {
   checkBuilderEndpoint,
   getAllTableRows,
   clearAllAutomations,
+  testAutomation,
 } = require("./utilities/TestFunctions")
 const setup = require("./utilities")
 const { basicAutomation } = setup.structures
@@ -10,7 +11,6 @@ const MAX_RETRIES = 4
 
 let ACTION_DEFINITIONS = {}
 let TRIGGER_DEFINITIONS = {}
-let LOGIC_DEFINITIONS = {}
 
 describe("/automations", () => {
   let request = setup.getRequest()
@@ -23,15 +23,6 @@ describe("/automations", () => {
     await config.init()
   })
 
-  const triggerWorkflow = async automation => {
-    return await request
-      .post(`/api/automations/${automation._id}/trigger`)
-      .send({ name: "Test", description: "TEST" })
-      .set(config.defaultHeaders())
-      .expect('Content-Type', /json/)
-      .expect(200)
-  }
-
   describe("get definitions", () => {
     it("returns a list of definitions for actions", async () => {
       const res = await request
@@ -44,7 +35,7 @@ describe("/automations", () => {
       ACTION_DEFINITIONS = res.body
     })
 
-    it("returns a list of definitions for triggers", async () => {
+    it("returns a list of definitions for triggerInfo", async () => {
       const res = await request
         .get(`/api/automations/trigger/list`)
         .set(config.defaultHeaders())
@@ -55,17 +46,6 @@ describe("/automations", () => {
       TRIGGER_DEFINITIONS = res.body
     })
 
-    it("returns a list of definitions for actions", async () => {
-      const res = await request
-        .get(`/api/automations/logic/list`)
-        .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
-        .expect(200)
-
-      expect(Object.keys(res.body).length).not.toEqual(0)
-      LOGIC_DEFINITIONS = res.body
-    })
-
     it("returns all of the definitions in one", async () => {
       const res = await request
         .get(`/api/automations/definitions/list`)
@@ -75,7 +55,6 @@ describe("/automations", () => {
 
       expect(Object.keys(res.body.action).length).toBeGreaterThanOrEqual(Object.keys(ACTION_DEFINITIONS).length)
       expect(Object.keys(res.body.trigger).length).toEqual(Object.keys(TRIGGER_DEFINITIONS).length)
-      expect(Object.keys(res.body.logic).length).toEqual(Object.keys(LOGIC_DEFINITIONS).length)
     })
   })
 
@@ -168,14 +147,13 @@ describe("/automations", () => {
       automation.definition.steps[0].inputs.row.tableId = table._id
       automation = await config.createAutomation(automation)
       await setup.delay(500)
-      const res = await triggerWorkflow(automation)
+      const res = await testAutomation(config, automation)
       // this looks a bit mad but we don't actually have a way to wait for a response from the automation to
       // know that it has finished all of its actions - this is currently the best way
       // also when this runs in CI it is very temper-mental so for now trying to make run stable by repeating until it works
       // TODO: update when workflow logs are a thing
       for (let tries = 0; tries < MAX_RETRIES; tries++) {
-        expect(res.body.message).toEqual(`Automation ${automation._id} has been triggered.`)
-        expect(res.body.automation.name).toEqual(automation.name)
+        expect(res.body).toBeDefined()
         await setup.delay(500)
         let elements = await getAllTableRows(config)
         // don't test it unless there are values to test

package/src/api/routes/tests/metadata.spec.js

@@ -0,0 +1,65 @@
+const { testAutomation } = require("./utilities/TestFunctions")
+const setup = require("./utilities")
+const { MetadataTypes } = require("../../../constants")
+
+describe("/metadata", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+  let automation
+
+  afterAll(setup.afterAll)
+
+  beforeEach(async () => {
+    await config.init()
+    automation = await config.createAutomation()
+  })
+
+  async function createMetadata(data, type = MetadataTypes.AUTOMATION_TEST_INPUT) {
+    const res = await request
+      .post(`/api/metadata/${type}/${automation._id}`)
+      .send(data)
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    expect(res.body._rev).toBeDefined()
+  }
+
+  async function getMetadata(type) {
+    const res = await request
+      .get(`/api/metadata/${type}/${automation._id}`)
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    return res.body
+  }
+
+  describe("save", () => {
+    it("should be able to save some metadata", async () => {
+      await createMetadata({ test: "a" })
+      const testInput = await getMetadata(MetadataTypes.AUTOMATION_TEST_INPUT)
+      expect(testInput.test).toBe("a")
+    })
+
+    it("should save history metadata on automation run", async () => {
+      // this should have created some history
+      await testAutomation(config, automation)
+      const metadata = await getMetadata(MetadataTypes.AUTOMATION_TEST_HISTORY)
+      expect(metadata).toBeDefined()
+      expect(metadata.history.length).toBe(1)
+      expect(typeof metadata.history[0].occurredAt).toBe("number")
+    })
+  })
+
+  describe("destroy", () => {
+    it("should be able to delete some test inputs", async () => {
+      const res = await request
+        .delete(`/api/metadata/${MetadataTypes.AUTOMATION_TEST_INPUT}/${automation._id}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body.message).toBeDefined()
+      const metadata = await getMetadata(MetadataTypes.AUTOMATION_TEST_INPUT)
+      expect(metadata.test).toBeUndefined()
+    })
+  })
+})

package/src/api/routes/tests/utilities/TestFunctions.js

@@ -101,3 +101,17 @@ exports.checkPermissionsEndpoint = async ({
 exports.getDB = config => {
   return new CouchDB(config.getAppId())
 }
+
+exports.testAutomation = async (config, automation) => {
+  return await config.request
+    .post(`/api/automations/${automation._id}/test`)
+    .send({
+      row: {
+        name: "Test",
+        description: "TEST",
+      },
+    })
+    .set(config.defaultHeaders())
+    .expect("Content-Type", /json/)
+    .expect(200)
+}

package/src/app.ts

@@ -88,8 +88,8 @@ module.exports = server.listen(env.PORT || 0, async () => {
   env._set("PORT", server.address().port)
   eventEmitter.emitPort(env.PORT)
   fileSystem.init()
-  await automations.init()
   await redis.init()
+  await automations.init()
 })
 
 process.on("uncaughtException", err => {