@budibase/server 1.0.80 → 1.0.81-alpha.2

package/src/api/routes/public/index.ts

@@ -0,0 +1,118 @@
+import appEndpoints from "./applications"
+import queryEndpoints from "./queries"
+import tableEndpoints from "./tables"
+import rowEndpoints from "./rows"
+import userEndpoints from "./users"
+import usage from "../../../middleware/usageQuota"
+import authorized from "../../../middleware/authorized"
+import { paramResource, paramSubResource } from "../../../middleware/resourceId"
+import { CtxFn } from "./utils/Endpoint"
+import mapperMiddleware from "./middleware/mapper"
+import env from "../../../environment"
+// below imports don't have declaration files
+const Router = require("@koa/router")
+const { RateLimit, Stores } = require("koa2-ratelimit")
+const {
+  PermissionLevels,
+  PermissionTypes,
+} = require("@budibase/backend-core/permissions")
+const { getRedisOptions } = require("@budibase/backend-core/redis").utils
+
+const PREFIX = "/api/public/v1"
+// allow a lot more requests when in test
+const DEFAULT_API_REQ_LIMIT_PER_SEC = env.isTest() ? 100 : 10
+
+function getApiLimitPerSecond(): number {
+  if (!env.API_REQ_LIMIT_PER_SEC) {
+    return DEFAULT_API_REQ_LIMIT_PER_SEC
+  }
+  return parseInt(env.API_REQ_LIMIT_PER_SEC)
+}
+
+if (!env.isTest()) {
+  const REDIS_OPTS = getRedisOptions()
+  RateLimit.defaultOptions({
+    store: new Stores.Redis({
+      // @ts-ignore
+      socket: {
+        host: REDIS_OPTS.host,
+        port: REDIS_OPTS.port,
+      },
+      password: REDIS_OPTS.opts.password,
+      database: 1,
+    }),
+  })
+}
+// rate limiting, allows for 2 requests per second
+const limiter = RateLimit.middleware({
+  interval: { sec: 1 },
+  // per ip, per interval
+  max: getApiLimitPerSecond(),
+})
+
+const publicRouter = new Router({
+  prefix: PREFIX,
+})
+
+publicRouter.use(limiter)
+
+function addMiddleware(
+  endpoints: any,
+  middleware: CtxFn,
+  opts: { output: boolean } = { output: false }
+) {
+  if (!endpoints) {
+    return
+  }
+  if (!Array.isArray(endpoints)) {
+    endpoints = [endpoints]
+  }
+  for (let endpoint of endpoints) {
+    if (opts?.output) {
+      endpoint.addOutputMiddleware(middleware)
+    } else {
+      endpoint.addMiddleware(middleware)
+    }
+  }
+}
+
+function addToRouter(endpoints: any) {
+  if (endpoints) {
+    for (let endpoint of endpoints) {
+      endpoint.apply(publicRouter)
+    }
+  }
+}
+
+function applyRoutes(
+  endpoints: any,
+  permType: string,
+  resource: string,
+  subResource?: string
+) {
+  const paramMiddleware = subResource
+    ? paramSubResource(resource, subResource)
+    : paramResource(resource)
+  // add the parameter capture middleware
+  addMiddleware(endpoints.read, paramMiddleware)
+  addMiddleware(endpoints.write, paramMiddleware)
+  // add the authorization middleware, using the correct perm type
+  addMiddleware(endpoints.read, authorized(permType, PermissionLevels.READ))
+  addMiddleware(endpoints.write, authorized(permType, PermissionLevels.WRITE))
+  // add the usage quota middleware
+  addMiddleware(endpoints.write, usage)
+  // add the output mapper middleware
+  addMiddleware(endpoints.read, mapperMiddleware, { output: true })
+  addMiddleware(endpoints.write, mapperMiddleware, { output: true })
+  addToRouter(endpoints.read)
+  addToRouter(endpoints.write)
+}
+
+applyRoutes(appEndpoints, PermissionTypes.APP, "appId")
+applyRoutes(tableEndpoints, PermissionTypes.TABLE, "tableId")
+applyRoutes(userEndpoints, PermissionTypes.USER, "userId")
+applyRoutes(queryEndpoints, PermissionTypes.QUERY, "queryId")
+// needs to be applied last for routing purposes, don't override other endpoints
+applyRoutes(rowEndpoints, PermissionTypes.TABLE, "tableId", "rowId")
+
+module.exports = publicRouter

package/src/api/routes/public/middleware/mapper.ts

@@ -0,0 +1,81 @@
+import mapping from "../../../controllers/public/mapping"
+
+enum Resources {
+  APPLICATION = "applications",
+  TABLES = "tables",
+  ROWS = "rows",
+  USERS = "users",
+  QUERIES = "queries",
+  SEARCH = "search",
+}
+
+function isArrayResponse(ctx: any) {
+  return ctx.url.endsWith(Resources.SEARCH) || Array.isArray(ctx.body)
+}
+
+function processApplications(ctx: any) {
+  if (isArrayResponse(ctx)) {
+    return mapping.mapApplications(ctx)
+  } else {
+    return mapping.mapApplication(ctx)
+  }
+}
+
+function processTables(ctx: any) {
+  if (isArrayResponse(ctx)) {
+    return mapping.mapTables(ctx)
+  } else {
+    return mapping.mapTable(ctx)
+  }
+}
+
+function processRows(ctx: any) {
+  if (isArrayResponse(ctx)) {
+    return mapping.mapRowSearch(ctx)
+  } else {
+    return mapping.mapRow(ctx)
+  }
+}
+
+function processUsers(ctx: any) {
+  if (isArrayResponse(ctx)) {
+    return mapping.mapUsers(ctx)
+  } else {
+    return mapping.mapUser(ctx)
+  }
+}
+
+function processQueries(ctx: any) {
+  if (isArrayResponse(ctx)) {
+    return mapping.mapQueries(ctx)
+  } else {
+    return mapping.mapQueryExecution(ctx)
+  }
+}
+
+export default async (ctx: any, next: any) => {
+  let urlParts = ctx.url.split("/")
+  urlParts = urlParts.slice(4, urlParts.length)
+  let body = {}
+  switch (urlParts[0]) {
+    case Resources.APPLICATION:
+      body = processApplications(ctx)
+      break
+    case Resources.TABLES:
+      if (urlParts[2] === Resources.ROWS) {
+        body = processRows(ctx)
+      } else {
+        body = processTables(ctx)
+      }
+      break
+    case Resources.USERS:
+      body = processUsers(ctx)
+      break
+    case Resources.QUERIES:
+      body = processQueries(ctx)
+      break
+  }
+  // update the body based on what has occurred in the mapper
+  ctx.body = body
+  await next()
+}

package/src/api/routes/public/queries.ts

@@ -0,0 +1,81 @@
+import controller from "../../controllers/public/queries"
+import Endpoint from "./utils/Endpoint"
+import { nameValidator } from "../utils/validators"
+
+const read = [],
+  write = []
+
+/**
+ * @openapi
+ * /queries/{queryId}:
+ *   post:
+ *     summary: Execute a query
+ *     description: Queries which have been created within a Budibase app can be executed using this,
+ *     tags:
+ *       - queries
+ *     parameters:
+ *       - $ref: '#/components/parameters/queryId'
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/executeQuery'
+ *     responses:
+ *       200:
+ *         description: Returns the result of the query execution.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/executeQueryOutput'
+ *             examples:
+ *               REST:
+ *                 $ref: '#/components/examples/restResponse'
+ *               SQL:
+ *                 $ref: '#/components/examples/sqlResponse'
+ *
+ */
+write.push(new Endpoint("post", "/queries/:queryId", controller.execute))
+
+/**
+ * @openapi
+ * /queries/search:
+ *   post:
+ *     summary: Search for queries
+ *     description: Based on query properties (currently only name) search for queries.
+ *     tags:
+ *       - queries
+ *     parameters:
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/nameSearch'
+ *     responses:
+ *       200:
+ *         description: Returns the queries found based on the search parameters.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               required:
+ *                 - data
+ *               properties:
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     $ref: '#/components/schemas/query'
+ *             examples:
+ *               queries:
+ *                 $ref: '#/components/examples/queries'
+ */
+read.push(
+  new Endpoint("post", "/queries/search", controller.search).addMiddleware(
+    nameValidator()
+  )
+)
+
+export default { read, write }

package/src/api/routes/public/rows.ts

@@ -0,0 +1,242 @@
+import controller from "../../controllers/public/rows"
+import Endpoint from "./utils/Endpoint"
+import { externalSearchValidator } from "../utils/validators"
+
+const read = [],
+  write = []
+
+/**
+ * @openapi
+ * /tables/{tableId}/rows:
+ *   post:
+ *     summary: Create a row
+ *     description: Creates a row within the specified table.
+ *     tags:
+ *       - rows
+ *     parameters:
+ *       - $ref: '#/components/parameters/tableId'
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/row'
+ *           examples:
+ *             row:
+ *               $ref: '#/components/examples/inputRow'
+ *     responses:
+ *       200:
+ *         description: Returns the created row, including the ID which has been generated for it.
+ *           This can be found in the Budibase portal, viewed under the developer information.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/rowOutput'
+ *             examples:
+ *               row:
+ *                 $ref: '#/components/examples/row'
+ */
+write.push(new Endpoint("post", "/tables/:tableId/rows", controller.create))
+
+/**
+ * @openapi
+ * /tables/{tableId}/rows/{rowId}:
+ *   put:
+ *     summary: Update a row
+ *     description: Updates a row within the specified table.
+ *     tags:
+ *       - rows
+ *     parameters:
+ *       - $ref: '#/components/parameters/tableId'
+ *       - $ref: '#/components/parameters/rowId'
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/row'
+ *           examples:
+ *             row:
+ *               $ref: '#/components/examples/inputRow'
+ *     responses:
+ *       200:
+ *         description: Returns the created row, including the ID which has been generated for it.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/rowOutput'
+ *             examples:
+ *               row:
+ *                 $ref: '#/components/examples/row'
+ */
+write.push(
+  new Endpoint("put", "/tables/:tableId/rows/:rowId", controller.update)
+)
+
+/**
+ * @openapi
+ * /tables/{tableId}/rows/{rowId}:
+ *   delete:
+ *     summary: Delete a row
+ *     description: Deletes a row within the specified table.
+ *     tags:
+ *       - rows
+ *     parameters:
+ *       - $ref: '#/components/parameters/tableId'
+ *       - $ref: '#/components/parameters/rowId'
+ *       - $ref: '#/components/parameters/appId'
+ *     responses:
+ *       200:
+ *         description: Returns the deleted row, including the ID which has been generated for it.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/rowOutput'
+ *             examples:
+ *               row:
+ *                 $ref: '#/components/examples/row'
+ */
+write.push(
+  new Endpoint("delete", "/tables/:tableId/rows/:rowId", controller.destroy)
+)
+
+/**
+ * @openapi
+ * /tables/{tableId}/rows/{rowId}:
+ *   get:
+ *     summary: Retrieve a row
+ *     description: This gets a single row, it will be enriched with the full related rows, rather than
+ *       the squashed "primaryDisplay" format returned by the search endpoint.
+ *     tags:
+ *       - rows
+ *     parameters:
+ *       - $ref: '#/components/parameters/tableId'
+ *       - $ref: '#/components/parameters/rowId'
+ *       - $ref: '#/components/parameters/appId'
+ *     responses:
+ *       200:
+ *         description: Returns the retrieved row.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/rowOutput'
+ *             examples:
+ *               enrichedRow:
+ *                 $ref: '#/components/examples/enrichedRow'
+ */
+read.push(new Endpoint("get", "/tables/:tableId/rows/:rowId", controller.read))
+
+/**
+ * @openapi
+ * /tables/{tableId}/rows/search:
+ *   post:
+ *     summary: Search for rows
+ *     tags:
+ *       - rows
+ *     parameters:
+ *       - $ref: '#/components/parameters/tableId'
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - query
+ *             properties:
+ *               query:
+ *                 type: object
+ *                 properties:
+ *                   string:
+ *                     type: object
+ *                     example:
+ *                       columnName1: value
+ *                       columnName2: value
+ *                     description: A map of field name to the string to search for,
+ *                       this will look for rows that have a value starting with the
+ *                       string value.
+ *                     additionalProperties:
+ *                       type: string
+ *                       description: The value to search for in the column.
+ *                   fuzzy:
+ *                     type: object
+ *                     description: A fuzzy search, only supported by internal tables.
+ *                   range:
+ *                     type: object
+ *                     description: Searches within a range, the format of this must be
+ *                       columnName -> [low, high].
+ *                     example:
+ *                       columnName1: [10, 20]
+ *                   equal:
+ *                     type: object
+ *                     description: Searches for rows that have a column value that is
+ *                       exactly the value set.
+ *                   notEqual:
+ *                     type: object
+ *                     description: Searches for any row which does not contain the specified
+ *                       column value.
+ *                   empty:
+ *                     type: object
+ *                     description: Searches for rows which do not contain the specified column.
+ *                       The object should simply contain keys of the column names, these
+ *                       can map to any value.
+ *                     example:
+ *                       columnName1: ""
+ *                   notEmpty:
+ *                     type: object
+ *                     description: Searches for rows which have the specified column.
+ *                   oneOf:
+ *                     type: object
+ *                     description: Searches for rows which have a column value that is any
+ *                       of the specified values. The format of this must be columnName -> [value1, value2].
+ *               paginate:
+ *                 type: boolean
+ *                 description: Enables pagination, by default this is disabled.
+ *               bookmark:
+ *                 oneOf:
+ *                   - type: string
+ *                   - type: integer
+ *                 description: If retrieving another page, the bookmark from the previous request must be supplied.
+ *               limit:
+ *                 type: integer
+ *                 description: The maximum number of rows to return, useful when paginating, for internal tables this
+ *                   will be limited to 1000, for SQL tables it will be 5000.
+ *               sort:
+ *                 type: object
+ *                 description: A set of parameters describing the sort behaviour of the search.
+ *                 properties:
+ *                   order:
+ *                     type: string
+ *                     enum: [ascending, descending]
+ *                     description: The order of the sort, by default this is ascending.
+ *                   column:
+ *                     type: string
+ *                     description: The name of the column by which the rows will be sorted.
+ *                   type:
+ *                     type: string
+ *                     enum: [string, number]
+ *                     description: Defines whether the column should be treated as a string
+ *                       or as numbers when sorting.
+ *     responses:
+ *       200:
+ *         description: The response will contain an array of rows that match the search parameters.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/searchOutput'
+ *             examples:
+ *               search:
+ *                 $ref: '#/components/examples/rows'
+ */
+read.push(
+  new Endpoint(
+    "post",
+    "/tables/:tableId/rows/search",
+    controller.search
+  ).addMiddleware(externalSearchValidator())
+)
+
+export default { read, write }

package/src/api/routes/public/tables.ts

@@ -0,0 +1,169 @@
+import controller from "../../controllers/public/tables"
+import Endpoint from "./utils/Endpoint"
+import { tableValidator, nameValidator } from "../utils/validators"
+
+const read = [],
+  write = []
+
+/**
+ * @openapi
+ * /tables:
+ *   post:
+ *     summary: Create a table
+ *     description: Create a table, this could be internal or external.
+ *     tags:
+ *       - tables
+ *     parameters:
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/table'
+ *           examples:
+ *             table:
+ *               $ref: '#/components/examples/table'
+ *     responses:
+ *       200:
+ *         description: Returns the created table, including the ID which has been generated for it. This can be
+ *           internal or external data sources.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/tableOutput'
+ *             examples:
+ *               table:
+ *                 $ref: '#/components/examples/table'
+ */
+write.push(
+  new Endpoint("post", "/tables", controller.create).addMiddleware(
+    tableValidator()
+  )
+)
+
+/**
+ * @openapi
+ * /tables/{tableId}:
+ *   put:
+ *     summary: Update a table
+ *     description: Update a table, this could be internal or external.
+ *     tags:
+ *       - tables
+ *     parameters:
+ *       - $ref: '#/components/parameters/tableId'
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/table'
+ *           examples:
+ *             table:
+ *               $ref: '#/components/examples/table'
+ *     responses:
+ *       200:
+ *         description: Returns the updated table.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/tableOutput'
+ *             examples:
+ *               table:
+ *                 $ref: '#/components/examples/table'
+ */
+write.push(
+  new Endpoint("put", "/tables/:tableId", controller.update).addMiddleware(
+    tableValidator()
+  )
+)
+
+/**
+ * @openapi
+ * /tables/{tableId}:
+ *   delete:
+ *     summary: Delete a table
+ *     description: Delete a table, this could be internal or external.
+ *     tags:
+ *       - tables
+ *     parameters:
+ *       - $ref: '#/components/parameters/tableId'
+ *       - $ref: '#/components/parameters/appId'
+ *     responses:
+ *       200:
+ *         description: Returns the deleted table.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/tableOutput'
+ *             examples:
+ *               table:
+ *                 $ref: '#/components/examples/table'
+ */
+write.push(new Endpoint("delete", "/tables/:tableId", controller.destroy))
+
+/**
+ * @openapi
+ * /tables/{tableId}:
+ *   get:
+ *     summary: Retrieve a table
+ *     description: Lookup a table, this could be internal or external.
+ *     tags:
+ *       - tables
+ *     parameters:
+ *       - $ref: '#/components/parameters/tableId'
+ *       - $ref: '#/components/parameters/appId'
+ *     responses:
+ *       200:
+ *         description: Returns the retrieved table.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/tableOutput'
+ *             examples:
+ *               table:
+ *                 $ref: '#/components/examples/table'
+ */
+read.push(new Endpoint("get", "/tables/:tableId", controller.read))
+
+/**
+ * @openapi
+ * /tables/search:
+ *   post:
+ *     summary: Search for tables
+ *     description: Based on table properties (currently only name) search for tables. This could be
+ *       an internal or an external table.
+ *     tags:
+ *       - tables
+ *     parameters:
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/nameSearch'
+ *     responses:
+ *       200:
+ *         description: Returns the found tables, based on the search parameters.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               required:
+ *                 - data
+ *               properties:
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     $ref: '#/components/schemas/table'
+ *             examples:
+ *               tables:
+ *                 $ref: '#/components/examples/tables'
+ */
+read.push(
+  new Endpoint("post", "/tables/search", controller.search).addMiddleware(
+    nameValidator()
+  )
+)
+
+export default { read, write }