@budibase/server 1.0.25 → 1.0.27-alpha.10

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

@@ -50,10 +50,10 @@ exports.validate = async ({ appId, tableId, row, table }) => {
   const errors = {}
   for (let fieldName of Object.keys(table.schema)) {
     const constraints = cloneDeep(table.schema[fieldName].constraints)
+    const type = table.schema[fieldName].type
     // special case for options, need to always allow unselected (null)
     if (
-      table.schema[fieldName].type ===
-        (FieldTypes.OPTIONS || FieldTypes.ARRAY) &&
+      (type === FieldTypes.OPTIONS || type === FieldTypes.ARRAY) &&
       constraints.inclusion
     ) {
       constraints.inclusion.push(null)
@@ -61,17 +61,20 @@ exports.validate = async ({ appId, tableId, row, table }) => {
     let res
 
     // Validate.js doesn't seem to handle array
-    if (
-      table.schema[fieldName].type === FieldTypes.ARRAY &&
-      row[fieldName] &&
-      row[fieldName].length
-    ) {
+    if (type === FieldTypes.ARRAY && row[fieldName] && row[fieldName].length) {
       row[fieldName].map(val => {
         if (!constraints.inclusion.includes(val)) {
           errors[fieldName] = "Field not in list"
         }
       })
-    } else if (table.schema[fieldName].type === FieldTypes.FORMULA) {
+    } else if (type === FieldTypes.JSON && typeof row[fieldName] === "string") {
+      // this should only happen if there is an error
+      try {
+        JSON.parse(row[fieldName])
+      } catch (err) {
+        errors[fieldName] = [`Contains invalid JSON`]
+      }
+    } else if (type === FieldTypes.FORMULA) {
       res = validateJs.single(
         processStringSync(table.schema[fieldName].formula, row),
         constraints

package/src/api/controllers/user.js

@@ -2,6 +2,7 @@ const CouchDB = require("../../db")
 const {
   generateUserMetadataID,
   getUserMetadataParams,
+  generateUserFlagID,
 } = require("../../db/utils")
 const { InternalTables } = require("../../db/utils")
 const { getGlobalUsers, getRawGlobalUser } = require("../../utilities/global")
@@ -195,3 +196,35 @@ exports.destroyMetadata = async function (ctx) {
 exports.findMetadata = async function (ctx) {
   ctx.body = await getFullUser(ctx, ctx.params.id)
 }
+
+exports.setFlag = async function (ctx) {
+  const userId = ctx.user._id
+  const { flag, value } = ctx.request.body
+  if (!flag) {
+    ctx.throw(400, "Must supply a 'flag' field in request body.")
+  }
+  const flagDocId = generateUserFlagID(userId)
+  const db = new CouchDB(ctx.appId)
+  let doc
+  try {
+    doc = await db.get(flagDocId)
+  } catch (err) {
+    doc = { _id: flagDocId }
+  }
+  doc[flag] = value || true
+  await db.put(doc)
+  ctx.body = { message: "Flag set successfully" }
+}
+
+exports.getFlags = async function (ctx) {
+  const userId = ctx.user._id
+  const docId = generateUserFlagID(userId)
+  const db = new CouchDB(ctx.appId)
+  let doc
+  try {
+    doc = await db.get(docId)
+  } catch (err) {
+    doc = { _id: docId }
+  }
+  ctx.body = doc
+}

package/src/api/controllers/webhook.js

@@ -65,6 +65,10 @@ exports.buildSchema = async ctx => {
     let automation = await db.get(webhook.action.target)
     const autoOutputs = automation.definition.trigger.schema.outputs
     let properties = webhook.bodySchema.properties
+    // reset webhook outputs
+    autoOutputs.properties = {
+      body: autoOutputs.properties.body,
+    }
     for (let prop of Object.keys(properties)) {
       autoOutputs.properties[prop] = {
         type: properties[prop].type,

package/src/api/routes/query.js

@@ -1,53 +1,23 @@
 const Router = require("@koa/router")
 const queryController = require("../controllers/query")
 const authorized = require("../../middleware/authorized")
-const Joi = require("joi")
 const {
   PermissionLevels,
   PermissionTypes,
   BUILDER,
 } = require("@budibase/auth/permissions")
-const joiValidator = require("../../middleware/joi-validator")
 const {
   bodyResource,
   bodySubResource,
   paramResource,
 } = require("../../middleware/resourceId")
+const {
+  generateQueryPreviewValidation,
+  generateQueryValidation,
+} = require("../controllers/query/validation")
 
 const router = Router()
 
-function generateQueryValidation() {
-  // prettier-ignore
-  return joiValidator.body(Joi.object({
-    _id: Joi.string(),
-    _rev: Joi.string(),
-    name: Joi.string().required(),
-    fields: Joi.object().required(),
-    datasourceId: Joi.string().required(),
-    readable: Joi.boolean(),
-    parameters: Joi.array().items(Joi.object({
-      name: Joi.string(),
-      default: Joi.string().allow(""),
-    })),
-    queryVerb: Joi.string().allow().required(),
-    extra: Joi.object().optional(),
-    schema: Joi.object({}).required().unknown(true),
-    transformer: Joi.string().optional(),
-  }))
-}
-
-function generateQueryPreviewValidation() {
-  // prettier-ignore
-  return joiValidator.body(Joi.object({
-    fields: Joi.object().required(),
-    queryVerb: Joi.string().allow().required(),
-    extra: Joi.object().optional(),
-    datasourceId: Joi.string().required(),
-    transformer: Joi.string().optional(),
-    parameters: Joi.object({}).required().unknown(true)
-  }))
-}
-
 router
   .get("/api/queries", authorized(BUILDER), queryController.fetch)
   .post(
@@ -57,6 +27,7 @@ router
     generateQueryValidation(),
     queryController.save
   )
+  .post("/api/queries/import", authorized(BUILDER), queryController.import)
   .post(
     "/api/queries/preview",
     bodyResource("datasourceId"),
@@ -70,11 +41,18 @@ router
     authorized(PermissionTypes.QUERY, PermissionLevels.READ),
     queryController.find
   )
+  // DEPRECATED - use new query endpoint for future work
   .post(
     "/api/queries/:queryId",
     paramResource("queryId"),
     authorized(PermissionTypes.QUERY, PermissionLevels.WRITE),
-    queryController.execute
+    queryController.executeV1
+  )
+  .post(
+    "/api/v2/queries/:queryId",
+    paramResource("queryId"),
+    authorized(PermissionTypes.QUERY, PermissionLevels.WRITE),
+    queryController.executeV2
   )
   .delete(
     "/api/queries/:queryId/:revId",

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

@@ -1,5 +1,6 @@
 // Mock out postgres for this
 jest.mock("pg")
+jest.mock("node-fetch")
 
 // Mock isProdAppID to we can later mock the implementation and pretend we are
 // using prod app IDs
@@ -10,6 +11,7 @@ authDb.isProdAppID = mockIsProdAppID
 
 const setup = require("./utilities")
 const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
+const { checkCacheForDynamicVariable } = require("../../../threads/utils")
 const { basicQuery, basicDatasource } = setup.structures
 
 describe("/queries", () => {
@@ -226,4 +228,90 @@ describe("/queries", () => {
         .expect(400)
     })
   })
+
+  describe("test variables", () => {
+    async function restDatasource(cfg) {
+      return await config.createDatasource({
+        datasource: {
+          ...basicDatasource().datasource,
+          source: "REST",
+          config: cfg || {},
+        },
+      })
+    }
+
+    async function dynamicVariableDatasource() {
+      const datasource = await restDatasource()
+      const basedOnQuery = await config.createQuery({
+        ...basicQuery(datasource._id),
+        fields: {
+          path: "www.google.com",
+        },
+      })
+      await config.updateDatasource({
+        ...datasource,
+        config: {
+          dynamicVariables: [
+            { queryId: basedOnQuery._id, name: "variable3", value: "{{ data.0.[value] }}" }
+          ]
+        }
+      })
+      return { datasource, query: basedOnQuery }
+    }
+
+    async function preview(datasource, fields) {
+      return await request
+        .post(`/api/queries/preview`)
+        .send({
+          datasourceId: datasource._id,
+          parameters: {},
+          fields,
+          queryVerb: "read",
+        })
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+    }
+
+    it("should work with static variables", async () => {
+      const datasource = await restDatasource({
+        staticVariables: {
+          variable: "google",
+          variable2: "1",
+        },
+      })
+      const res = await preview(datasource, {
+        path: "www.{{ variable }}.com",
+        queryString: "test={{ variable2 }}",
+      })
+      // these responses come from the mock
+      expect(res.body.schemaFields).toEqual(["url", "opts", "value"])
+      expect(res.body.rows[0].url).toEqual("http://www.google.com?test=1")
+    })
+
+    it("should work with dynamic variables", async () => {
+      const { datasource } = await dynamicVariableDatasource()
+      const res = await preview(datasource, {
+        path: "www.google.com",
+        queryString: "test={{ variable3 }}",
+      })
+      expect(res.body.schemaFields).toEqual(["url", "opts", "value"])
+      expect(res.body.rows[0].url).toContain("doctype html")
+    })
+
+    it("check that it automatically retries on fail with cached dynamics", async () => {
+      const { datasource, query: base } = await dynamicVariableDatasource()
+      // preview once to cache
+      await preview(datasource, { path: "www.google.com", queryString: "test={{ variable3 }}" })
+      // check its in cache
+      const contents = await checkCacheForDynamicVariable(base._id, "variable3")
+      expect(contents.rows.length).toEqual(1)
+      const res = await preview(datasource, {
+        path: "www.failonce.com",
+        queryString: "test={{ variable3 }}",
+      })
+      expect(res.body.schemaFields).toEqual(["fails", "url", "opts"])
+      expect(res.body.rows[0].fails).toEqual(1)
+    })
+  })
 })

package/src/api/routes/user.js

@@ -39,5 +39,15 @@ router
     authorized(PermissionTypes.USER, PermissionLevels.WRITE),
     controller.syncUser
   )
+  .post(
+    "/api/users/flags",
+    authorized(PermissionTypes.USER, PermissionLevels.WRITE),
+    controller.setFlag
+  )
+  .get(
+    "/api/users/flags",
+    authorized(PermissionTypes.USER, PermissionLevels.READ),
+    controller.getFlags
+  )
 
 module.exports = router

package/src/automations/steps/executeQuery.js

@@ -35,6 +35,11 @@ exports.definition = {
           type: "object",
           description: "The response from the datasource execution",
         },
+        info: {
+          type: "object",
+          description:
+            "Some query types may return extra data, like headers from a REST query",
+        },
         success: {
           type: "boolean",
           description: "Whether the action was successful",
@@ -68,13 +73,16 @@ exports.run = async function ({ inputs, appId, emitter }) {
 
   try {
     await queryController.execute(ctx)
+    const { data, ...rest } = ctx.body
     return {
-      response: ctx.body,
+      response: data,
+      info: rest,
       success: true,
     }
   } catch (err) {
     return {
       success: false,
+      info: {},
       response: automationUtils.getError(err),
     }
   }

package/src/automations/steps/outgoingWebhook.js

@@ -13,12 +13,11 @@ const RequestType = {
 const BODY_REQUESTS = [RequestType.POST, RequestType.PUT, RequestType.PATCH]
 
 /**
- * Note, there is some functionality in this that is not currently exposed as it
- * is complex and maybe better to be opinionated here.
- * GET/DELETE requests cannot handle body elements so they will not be sent if configured.
+ * NOTE: this functionality is deprecated - it no longer should be used.
  */
 
 exports.definition = {
+  deprecated: true,
   name: "Outgoing webhook",
   tagline: "Send a {{inputs.requestMethod}} request",
   icon: "Send",

package/src/automations/utils.js

@@ -7,6 +7,7 @@ const newid = require("../db/newid")
 const { updateEntityMetadata } = require("../utilities")
 const { MetadataTypes } = require("../constants")
 const { getDeployedAppID } = require("@budibase/auth/db")
+const { cloneDeep } = require("lodash/fp")
 
 const WH_STEP_ID = definitions.WEBHOOK.stepId
 const CRON_STEP_ID = definitions.CRON.stepId
@@ -42,6 +43,16 @@ exports.updateTestHistory = async (appId, automation, history) => {
   )
 }
 
+exports.removeDeprecated = definitions => {
+  const base = cloneDeep(definitions)
+  for (let key of Object.keys(base)) {
+    if (base[key].deprecated) {
+      delete base[key]
+    }
+  }
+  return base
+}
+
 // end the repetition and the job itself
 exports.disableAllCrons = async appId => {
   const promises = []

package/src/db/utils.js

@@ -40,6 +40,7 @@ const DocumentTypes = {
   DEPLOYMENTS: "deployments",
   METADATA: "metadata",
   MEM_VIEW: "view",
+  USER_FLAG: "flag",
 }
 
 const ViewNames = {
@@ -339,6 +340,14 @@ exports.getQueryParams = (datasourceId = null, otherProps = {}) => {
   )
 }
 
+/**
+ * Generates a new flag document ID.
+ * @returns {string} The ID of the flag document that was generated.
+ */
+exports.generateUserFlagID = userId => {
+  return `${DocumentTypes.USER_FLAG}${SEPARATOR}${userId}`
+}
+
 exports.generateMetadataID = (type, entityId) => {
   return `${DocumentTypes.METADATA}${SEPARATOR}${type}${SEPARATOR}${entityId}`
 }

package/src/definitions/common.ts

@@ -1,6 +1,6 @@
-import { SourceNames } from "./datasource"
+export { Query, Datasource } from "./datasource"
 
-interface Base {
+export interface Base {
   _id?: string
   _rev?: string
 }
@@ -93,17 +93,3 @@ export interface Automation extends Base {
     trigger?: AutomationStep
   }
 }
-
-export interface Datasource extends Base {
-  type: string
-  name: string
-  source: SourceNames
-  // the config is defined by the schema
-  config: {
-    [key: string]: string | number | boolean
-  }
-  plus: boolean
-  entities?: {
-    [key: string]: Table
-  }
-}

package/src/definitions/datasource.ts

@@ -1,4 +1,4 @@
-import { Row, Table } from "./common"
+import { Row, Table, Base } from "./common"
 
 export enum Operation {
   CREATE = "CREATE",
@@ -181,3 +181,85 @@ export interface SqlQuery {
 export interface QueryOptions {
   disableReturning?: boolean
 }
+
+export interface Datasource extends Base {
+  type: string
+  name: string
+  source: SourceNames
+  // the config is defined by the schema
+  config: {
+    [key: string]: string | number | boolean
+  }
+  plus: boolean
+  entities?: {
+    [key: string]: Table
+  }
+}
+
+export enum AuthType {
+  BASIC = "basic",
+  BEARER = "bearer",
+}
+
+interface AuthConfig {
+  _id: string
+  name: string
+  type: AuthType
+  config: BasicAuthConfig | BearerAuthConfig
+}
+
+export interface BasicAuthConfig {
+  username: string
+  password: string
+}
+
+export interface BearerAuthConfig {
+  token: string
+}
+
+export interface QueryParameter {
+  name: string
+  default: string
+}
+
+export interface RestQueryFields {
+  path: string
+  queryString?: string
+  headers: { [key: string]: any }
+  disabledHeaders: { [key: string]: any }
+  requestBody: any
+  bodyType: string
+  json: object
+  method: string
+  authConfigId: string
+}
+
+export interface RestConfig {
+  url: string
+  defaultHeaders: {
+    [key: string]: any
+  }
+  authConfigs: AuthConfig[]
+  staticVariables: {
+    [key: string]: string
+  }
+  dynamicVariables: [
+    {
+      name: string
+      queryId: string
+      value: string
+    }
+  ]
+}
+
+export interface Query {
+  _id?: string
+  datasourceId: string
+  name: string
+  parameters: QueryParameter[]
+  fields: RestQueryFields | any
+  transformer: string | null
+  schema: any
+  readable: boolean
+  queryVerb: string
+}

package/src/integrations/base/IntegrationBase.ts

@@ -1,6 +1,6 @@
 export interface IntegrationBase {
-  create?(query: any): Promise<any[]>
-  read?(query: any): Promise<any[]>
-  update?(query: any): Promise<any[]>
-  delete?(query: any): Promise<any[]>
+  create?(query: any): Promise<any[] | any>
+  read?(query: any): Promise<any[] | any>
+  update?(query: any): Promise<any[] | any>
+  delete?(query: any): Promise<any[] | any>
 }

package/src/integrations/base/sqlTable.ts

@@ -36,7 +36,7 @@ function generateSchema(
       case FieldTypes.STRING:
       case FieldTypes.OPTIONS:
       case FieldTypes.LONGFORM:
-        schema.string(key)
+        schema.text(key)
         break
       case FieldTypes.NUMBER:
         // if meta is specified then this is a junction table entry

package/src/integrations/oracle.ts

@@ -450,7 +450,7 @@ module OracleModule {
             })
             return lastRow.rows
           } else {
-            return [{ [ operation.toLowerCase() ]: true }]
+            return [{ [operation.toLowerCase()]: true }]
           }
         }
       }