@budibase/server 1.0.80 → 1.0.81-alpha.0

package/specs/resources/user.js

@@ -0,0 +1,126 @@
+const { object } = require("./utils")
+const Resource = require("./utils/Resource")
+
+const user = {
+  _id: "us_693a73206518477283a8d5ae31103252",
+  email: "test@test.com",
+  roles: {
+    app_957b12f943d348faa61db7e18e088d0f: "BASIC",
+  },
+  builder: {
+    global: false,
+  },
+  admin: {
+    global: true,
+  },
+  tenantId: "default",
+  status: "active",
+  budibaseAccess: true,
+  csrfToken: "9c70291d-7137-48f9-9166-99ab5473a3d4",
+  userId: "us_693a73206518477283a8d5ae31103252",
+  roleId: "ADMIN",
+  role: {
+    _id: "ADMIN",
+    name: "Admin",
+    permissionId: "admin",
+    inherits: "POWER",
+  },
+}
+
+const userSchema = object(
+  {
+    email: {
+      description: "The email address of the user, this must be unique.",
+      type: "string",
+    },
+    password: {
+      description:
+        "The password of the user if using password based login - this will never be returned. This can be" +
+        " left out of subsequent requests (updates) and will be enriched back into the user structure.",
+      type: "string",
+    },
+    status: {
+      description: "The status of the user, if they are active.",
+      type: "string",
+      enum: ["active"],
+    },
+    firstName: {
+      description: "The first name of the user",
+      type: "string",
+    },
+    lastName: {
+      description: "The last name of the user",
+      type: "string",
+    },
+    forceResetPassword: {
+      description:
+        "If set to true forces the user to reset their password on first login.",
+      type: "boolean",
+    },
+    builder: {
+      description: "Describes if the user is a builder user or not.",
+      type: "object",
+      properties: {
+        global: {
+          description:
+            "If set to true the user will be able to build any app in the system.",
+          type: "boolean",
+        },
+      },
+    },
+    admin: {
+      description: "Describes if the user is an admin user or not.",
+      type: "object",
+      properties: {
+        global: {
+          description:
+            "If set to true the user will be able to administrate the system.",
+          type: "boolean",
+        },
+      },
+    },
+    roles: {
+      description:
+        "Contains the roles of the user per app (assuming they are not a builder user).",
+      type: "object",
+      additionalProperties: {
+        type: "string",
+        description:
+          "A map of app ID (production app ID, minus the _dev component) to a role ID, e.g. ADMIN.",
+      },
+    },
+  },
+  { required: ["email", "roles"] }
+)
+
+const userOutputSchema = {
+  ...userSchema,
+  properties: {
+    ...userSchema.properties,
+    _id: {
+      description: "The ID of the user.",
+      type: "string",
+    },
+  },
+  required: [...userSchema.required, "_id"],
+}
+
+module.exports = new Resource()
+  .setExamples({
+    user: {
+      value: {
+        data: user,
+      },
+    },
+    users: {
+      value: {
+        data: [user],
+      },
+    },
+  })
+  .setSchemas({
+    user: userSchema,
+    userOutput: object({
+      data: userOutputSchema,
+    }),
+  })

package/specs/resources/utils/Resource.js

@@ -0,0 +1,26 @@
+class Resource {
+  constructor() {
+    this.examples = {}
+    this.schemas = {}
+  }
+
+  setExamples(examples) {
+    this.examples = examples
+    return this
+  }
+
+  setSchemas(schemas) {
+    this.schemas = schemas
+    return this
+  }
+
+  getExamples() {
+    return this.examples
+  }
+
+  getSchemas() {
+    return this.schemas
+  }
+}
+
+module.exports = Resource

package/specs/resources/utils/index.js

@@ -0,0 +1,11 @@
+exports.object = (props, opts) => {
+  const base = {
+    type: "object",
+    properties: props,
+    ...opts,
+  }
+  if (Object.keys(props).length > 0 && (!opts || !opts.required)) {
+    base.required = Object.keys(props)
+  }
+  return base
+}

package/specs/security.js

@@ -0,0 +1,7 @@
+exports.ApiKeyAuth = {
+  type: "apiKey",
+  in: "header",
+  name: "x-budibase-api-key",
+  description:
+    "Your individual API key, this will provide access based on the configured RBAC settings of your user.",
+}

package/src/api/controllers/application.js

@@ -263,6 +263,7 @@ exports.create = async ctx => {
     tenantId: getTenantId(),
     updatedAt: new Date().toISOString(),
     createdAt: new Date().toISOString(),
+    status: AppStatus.DEV,
   }
   const response = await db.put(newApplication, { force: true })
   newApplication._rev = response.rev

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

@@ -0,0 +1,74 @@
+const { getAllApps } = require("@budibase/backend-core/db")
+const { updateAppId } = require("@budibase/backend-core/context")
+import { search as stringSearch } from "./utils"
+import { default as controller } from "../application"
+import { Application } from "../../../definitions/common"
+
+function fixAppID(app: Application, params: any) {
+  if (!params) {
+    return app
+  }
+  if (!app._id && params.appId) {
+    app._id = params.appId
+  }
+  return app
+}
+
+async function setResponseApp(ctx: any) {
+  if (ctx.body && ctx.body.appId && (!ctx.params || !ctx.params.appId)) {
+    ctx.params = { appId: ctx.body.appId }
+  }
+  await controller.fetchAppPackage(ctx)
+}
+
+export async function search(ctx: any, next: any) {
+  const { name } = ctx.request.body
+  const apps = await getAllApps({ all: true })
+  ctx.body = stringSearch(apps, name)
+  await next()
+}
+
+export async function create(ctx: any, next: any) {
+  if (!ctx.request.body || !ctx.request.body.useTemplate) {
+    ctx.request.body = {
+      useTemplate: false,
+      ...ctx.request.body,
+    }
+  }
+  await controller.create(ctx)
+  await setResponseApp(ctx)
+  await next()
+}
+
+export async function read(ctx: any, next: any) {
+  updateAppId(ctx.params.appId)
+  await setResponseApp(ctx)
+  await next()
+}
+
+export async function update(ctx: any, next: any) {
+  ctx.request.body = fixAppID(ctx.request.body, ctx.params)
+  updateAppId(ctx.params.appId)
+  await controller.update(ctx)
+  await setResponseApp(ctx)
+  await next()
+}
+
+export async function destroy(ctx: any, next: any) {
+  updateAppId(ctx.params.appId)
+  // get the app before deleting it
+  await setResponseApp(ctx)
+  const body = ctx.body
+  await controller.delete(ctx)
+  // overwrite the body again
+  ctx.body = body
+  await next()
+}
+
+export default {
+  create,
+  update,
+  read,
+  destroy,
+  search,
+}

package/src/api/controllers/public/mapping/applications.ts

@@ -0,0 +1,32 @@
+import { Application } from "./types"
+
+function application(body: any): Application {
+  let app = body?.application ? body.application : body
+  return {
+    _id: app.appId,
+    name: app.name,
+    url: app.url,
+    status: app.status,
+    createdAt: app.createdAt,
+    updatedAt: app.updatedAt,
+    version: app.version,
+    tenantId: app.tenantId,
+    lockedBy: app.lockedBy,
+  }
+}
+
+function mapApplication(ctx: any): { data: Application } {
+  return {
+    data: application(ctx.body),
+  }
+}
+
+function mapApplications(ctx: any): { data: Application[] } {
+  const apps = ctx.body.map((body: any) => application(body))
+  return { data: apps }
+}
+
+export default {
+  mapApplication,
+  mapApplications,
+}

package/src/api/controllers/public/mapping/index.ts

@@ -0,0 +1,13 @@
+import tables from "./tables"
+import applications from "./applications"
+import users from "./users"
+import rows from "./rows"
+import queries from "./queries"
+
+export default {
+  ...tables,
+  ...applications,
+  ...users,
+  ...rows,
+  ...queries,
+}

package/src/api/controllers/public/mapping/queries.ts

@@ -0,0 +1,39 @@
+import { Query, ExecuteQuery } from "./types"
+
+function query(body: any): Query {
+  return {
+    _id: body._id,
+    datasourceId: body.datasourceId,
+    parameters: body.parameters,
+    fields: body.fields,
+    queryVerb: body.queryVerb,
+    name: body.name,
+    schema: body.schema,
+    transformer: body.transformer,
+    readable: body.readable,
+  }
+}
+
+function mapQueries(ctx: any): { data: Query[] } {
+  const queries = ctx.body.map((body: any) => query(body))
+  return {
+    data: queries,
+  }
+}
+
+function mapQueryExecution(ctx: any): ExecuteQuery {
+  // very little we can map here, structure mostly unknown
+  return {
+    data: ctx.body.data,
+    pagination: ctx.body.pagination,
+    extra: {
+      raw: ctx.body.raw,
+      headers: ctx.body.headers,
+    },
+  }
+}
+
+export default {
+  mapQueries,
+  mapQueryExecution,
+}

package/src/api/controllers/public/mapping/rows.ts

@@ -0,0 +1,31 @@
+import { Row, RowSearch } from "./types"
+
+function row(body: any): Row {
+  delete body._rev
+  // have to input everything, since structure unknown
+  return {
+    ...body,
+    _id: body._id,
+    tableId: body.tableId,
+  }
+}
+
+function mapRowSearch(ctx: any): RowSearch {
+  const rows = ctx.body.rows.map((body: any) => row(body))
+  return {
+    data: rows,
+    hasNextPage: ctx.body.hasNextPage,
+    bookmark: ctx.body.bookmark,
+  }
+}
+
+function mapRow(ctx: any): { data: Row } {
+  return {
+    data: row(ctx.body),
+  }
+}
+
+export default {
+  mapRowSearch,
+  mapRow,
+}

package/src/api/controllers/public/mapping/tables.ts

@@ -0,0 +1,26 @@
+import { Table } from "./types"
+
+function table(body: any): Table {
+  return {
+    _id: body._id,
+    name: body.name,
+    schema: body.schema,
+    primaryDisplay: body.primaryDisplay,
+  }
+}
+
+function mapTable(ctx: any): { data: Table } {
+  return {
+    data: table(ctx.body),
+  }
+}
+
+function mapTables(ctx: any): { data: Table[] } {
+  const tables = ctx.body.map((body: any) => table(body))
+  return { data: tables }
+}
+
+export default {
+  mapTable,
+  mapTables,
+}

package/src/api/controllers/public/mapping/types.ts

@@ -0,0 +1,13 @@
+import { components } from "../../../../definitions/openapi"
+
+export type Query = components["schemas"]["query"]
+export type ExecuteQuery = components["schemas"]["executeQueryOutput"]
+
+export type Application = components["schemas"]["applicationOutput"]["data"]
+
+export type Table = components["schemas"]["tableOutput"]["data"]
+
+export type Row = components["schemas"]["rowOutput"]["data"]
+export type RowSearch = components["schemas"]["searchOutput"]
+
+export type User = components["schemas"]["userOutput"]["data"]

package/src/api/controllers/public/mapping/users.ts

@@ -0,0 +1,32 @@
+import { User } from "./types"
+
+function user(body: any): User {
+  return {
+    _id: body._id,
+    email: body.email,
+    password: body.password,
+    status: body.status,
+    firstName: body.firstName,
+    lastName: body.lastName,
+    forceResetPassword: body.forceResetPassword,
+    builder: body.builder,
+    admin: body.admin,
+    roles: body.roles,
+  }
+}
+
+function mapUser(ctx: any): { data: User } {
+  return {
+    data: user(ctx.body),
+  }
+}
+
+function mapUsers(ctx: any): { data: User[] } {
+  const users = ctx.body.map((body: any) => user(body))
+  return { data: users }
+}
+
+export default {
+  mapUser,
+  mapUsers,
+}

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

@@ -0,0 +1,20 @@
+import { search as stringSearch } from "./utils"
+import { default as queryController } from "../query"
+
+export async function search(ctx: any, next: any) {
+  await queryController.fetch(ctx)
+  const { name } = ctx.request.body
+  ctx.body = stringSearch(ctx.body, name)
+  await next()
+}
+
+export async function execute(ctx: any, next: any) {
+  // don't wrap this, already returns "data"
+  await queryController.executeV2(ctx)
+  await next()
+}
+
+export default {
+  search,
+  execute,
+}

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

@@ -0,0 +1,77 @@
+import { default as rowController } from "../row"
+import { addRev } from "./utils"
+import { Row } from "../../../definitions/common"
+
+// makes sure that the user doesn't need to pass in the type, tableId or _id params for
+// the call to be correct
+function fixRow(row: Row, params: any) {
+  if (!params || !row) {
+    return row
+  }
+  if (params.rowId) {
+    row._id = params.rowId
+  }
+  if (params.tableId) {
+    row.tableId = params.tableId
+  }
+  if (!row.type) {
+    row.type = "row"
+  }
+  return row
+}
+
+export async function search(ctx: any, next: any) {
+  let { sort, paginate, bookmark, limit, query } = ctx.request.body
+  // update the body to the correct format of the internal search
+  if (!sort) {
+    sort = {}
+  }
+  ctx.request.body = {
+    sort: sort.column,
+    sortType: sort.type,
+    sortOrder: sort.order,
+    bookmark,
+    paginate,
+    limit,
+    query,
+  }
+  await rowController.search(ctx)
+  await next()
+}
+
+export async function create(ctx: any, next: any) {
+  ctx.request.body = fixRow(ctx.request.body, ctx.params)
+  await rowController.save(ctx)
+  await next()
+}
+
+export async function read(ctx: any, next: any) {
+  await rowController.fetchEnrichedRow(ctx)
+  await next()
+}
+
+export async function update(ctx: any, next: any) {
+  ctx.request.body = await addRev(fixRow(ctx.request.body, ctx.params.tableId))
+  await rowController.save(ctx)
+  await next()
+}
+
+export async function destroy(ctx: any, next: any) {
+  // set the body as expected, with the _id and _rev fields
+  ctx.request.body = await addRev(
+    fixRow({ _id: ctx.params.rowId }, ctx.params.tableId)
+  )
+  await rowController.destroy(ctx)
+  // destroy controller doesn't currently return the row as the body, need to adjust this
+  // in the public API to be correct
+  ctx.body = ctx.row
+  await next()
+}
+
+export default {
+  create,
+  read,
+  update,
+  destroy,
+  search,
+}

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

@@ -0,0 +1,56 @@
+import { search as stringSearch, addRev } from "./utils"
+import { default as controller } from "../table"
+import { Table } from "../../../definitions/common"
+
+function fixTable(table: Table, params: any) {
+  if (!params || !table) {
+    return table
+  }
+  if (params.tableId) {
+    table._id = params.tableId
+  }
+  if (!table.type) {
+    table.type = "table"
+  }
+  return table
+}
+
+export async function search(ctx: any, next: any) {
+  const { name } = ctx.request.body
+  await controller.fetch(ctx)
+  ctx.body = stringSearch(ctx.body, name)
+  await next()
+}
+
+export async function create(ctx: any, next: any) {
+  await controller.save(ctx)
+  await next()
+}
+
+export async function read(ctx: any, next: any) {
+  await controller.find(ctx)
+  await next()
+}
+
+export async function update(ctx: any, next: any) {
+  ctx.request.body = await addRev(
+    fixTable(ctx.request.body, ctx.params),
+    ctx.params.tableId
+  )
+  await controller.save(ctx)
+  await next()
+}
+
+export async function destroy(ctx: any, next: any) {
+  await controller.destroy(ctx)
+  ctx.body = ctx.table
+  await next()
+}
+
+export default {
+  create,
+  read,
+  update,
+  destroy,
+  search,
+}

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

@@ -0,0 +1,82 @@
+import {
+  allGlobalUsers,
+  deleteGlobalUser,
+  readGlobalUser,
+  saveGlobalUser,
+} from "../../../utilities/workerRequests"
+import { search as stringSearch } from "./utils"
+
+const { getProdAppID } = require("@budibase/backend-core/db")
+
+function fixUser(ctx: any) {
+  if (!ctx.request.body) {
+    return ctx
+  }
+  if (!ctx.request.body._id && ctx.params.userId) {
+    ctx.request.body._id = ctx.params.userId
+  }
+  if (!ctx.request.body.roles) {
+    ctx.request.body.roles = {}
+  } else {
+    const newRoles: { [key: string]: string } = {}
+    for (let [appId, role] of Object.entries(ctx.request.body.roles)) {
+      // @ts-ignore
+      newRoles[getProdAppID(appId)] = role
+    }
+    ctx.request.body.roles = newRoles
+  }
+  return ctx
+}
+
+function getUser(ctx: any, userId?: string) {
+  if (userId) {
+    ctx.params = { userId }
+  } else if (!ctx.params?.userId) {
+    throw "No user ID provided for getting"
+  }
+  return readGlobalUser(ctx)
+}
+
+export async function search(ctx: any, next: any) {
+  const { name } = ctx.request.body
+  const users = await allGlobalUsers(ctx)
+  ctx.body = stringSearch(users, name, "email")
+  await next()
+}
+
+export async function create(ctx: any, next: any) {
+  const response = await saveGlobalUser(fixUser(ctx))
+  ctx.body = await getUser(ctx, response._id)
+  await next()
+}
+
+export async function read(ctx: any, next: any) {
+  ctx.body = await readGlobalUser(ctx)
+  await next()
+}
+
+export async function update(ctx: any, next: any) {
+  const user = await readGlobalUser(ctx)
+  ctx.request.body = {
+    ...ctx.request.body,
+    _rev: user._rev,
+  }
+  const response = await saveGlobalUser(fixUser(ctx))
+  ctx.body = await getUser(ctx, response._id)
+  await next()
+}
+
+export async function destroy(ctx: any, next: any) {
+  const user = await getUser(ctx)
+  await deleteGlobalUser(ctx)
+  ctx.body = user
+  await next()
+}
+
+export default {
+  create,
+  read,
+  update,
+  destroy,
+  search,
+}