@budibase/server 1.0.80-alpha.3 → 1.0.80

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

@@ -1,38 +0,0 @@
-const { getAppDB } = require("@budibase/backend-core/context")
-import { isExternalTable } from "../../../integrations/utils"
-
-export async function addRev(
-  body: { _id?: string; _rev?: string },
-  tableId?: string
-) {
-  if (!body._id || (tableId && isExternalTable(tableId))) {
-    return body
-  }
-  const db = getAppDB()
-  const dbDoc = await db.get(body._id)
-  body._rev = dbDoc._rev
-  return body
-}
-
-/**
- * Performs a case insensitive search on the provided documents, using the
- * provided key and value. This will be a string based search, using the
- * startsWith function.
- */
-export function search(docs: any[], value: any, key = "name") {
-  if (!value || typeof value !== "string") {
-    return docs
-  }
-  value = value.toLowerCase()
-  const filtered = []
-  for (let doc of docs) {
-    if (typeof doc[key] !== "string") {
-      continue
-    }
-    const toTest = doc[key].toLowerCase()
-    if (toTest.startsWith(value)) {
-      filtered.push(doc)
-    }
-  }
-  return filtered
-}

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

@@ -1,156 +0,0 @@
-import controller from "../../controllers/public/applications"
-import Endpoint from "./utils/Endpoint"
-const { nameValidator, applicationValidator } = require("../utils/validators")
-
-const read = [],
-  write = []
-
-/**
- * @openapi
- * /applications:
- *   post:
- *     summary: Create an application
- *     tags:
- *       - applications
- *     parameters:
- *       - $ref: '#/components/parameters/appId'
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             $ref: '#/components/schemas/application'
- *     responses:
- *       200:
- *         description: Returns the created application.
- *         content:
- *           application/json:
- *             schema:
- *               $ref: '#/components/schemas/applicationOutput'
- *             examples:
- *               application:
- *                 $ref: '#/components/examples/application'
- */
-write.push(
-  new Endpoint("post", "/applications", controller.create).addMiddleware(
-    applicationValidator()
-  )
-)
-
-/**
- * @openapi
- * /applications/{appId}:
- *   put:
- *     summary: Update an application
- *     tags:
- *       - applications
- *     parameters:
- *       - $ref: '#/components/parameters/appIdUrl'
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             $ref: '#/components/schemas/application'
- *     responses:
- *       200:
- *         description: Returns the updated application.
- *         content:
- *           application/json:
- *             schema:
- *               $ref: '#/components/schemas/applicationOutput'
- *             examples:
- *               application:
- *                 $ref: '#/components/examples/application'
- */
-write.push(
-  new Endpoint("put", "/applications/:appId", controller.update).addMiddleware(
-    applicationValidator()
-  )
-)
-
-/**
- * @openapi
- * /applications/{appId}:
- *   delete:
- *     summary: Delete an application
- *     tags:
- *       - applications
- *     parameters:
- *       - $ref: '#/components/parameters/appIdUrl'
- *     responses:
- *       200:
- *         description: Returns the deleted application.
- *         content:
- *           application/json:
- *             schema:
- *               $ref: '#/components/schemas/applicationOutput'
- *             examples:
- *               application:
- *                 $ref: '#/components/examples/application'
- */
-write.push(new Endpoint("delete", "/applications/:appId", controller.destroy))
-
-/**
- * @openapi
- * /applications/{appId}:
- *   get:
- *     summary: Retrieve an application
- *     tags:
- *       - applications
- *     parameters:
- *       - $ref: '#/components/parameters/appIdUrl'
- *     responses:
- *       200:
- *         description: Returns the retrieved application.
- *         content:
- *           application/json:
- *             schema:
- *               $ref: '#/components/schemas/applicationOutput'
- *             examples:
- *               application:
- *                 $ref: '#/components/examples/application'
- */
-read.push(new Endpoint("get", "/applications/:appId", controller.read))
-
-/**
- * @openapi
- * /applications/search:
- *   post:
- *     summary: Search for applications
- *     description: Based on application properties (currently only name) search for applications.
- *     tags:
- *       - applications
- *     parameters:
- *       - $ref: '#/components/parameters/appId'
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             $ref: '#/components/schemas/nameSearch'
- *     responses:
- *       200:
- *         description: Returns the applications that were found based on the search parameters.
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               required:
- *                 - data
- *               properties:
- *                 data:
- *                   type: array
- *                   items:
- *                     $ref: '#/components/schemas/application'
- *             examples:
- *               applications:
- *                 $ref: '#/components/examples/applications'
- */
-read.push(
-  new Endpoint("post", "/applications/search", controller.search).addMiddleware(
-    nameValidator()
-  )
-)
-
-export default { read, write }

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

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

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

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