@budibase/server 2.1.32-alpha.4 → 2.1.32-alpha.6

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

@@ -13,28 +13,28 @@ import {
 } from "../../../constants"
 import { getViews, saveView } from "../view/utils"
 import viewTemplate from "../view/viewBuilder"
-const { getAppDB } = require("@budibase/backend-core/context")
 import { cloneDeep } from "lodash/fp"
 import { quotas } from "@budibase/pro"
-import { events } from "@budibase/backend-core"
+import { events, context } from "@budibase/backend-core"
+import { Database } from "@budibase/types"
 
 export async function clearColumns(table: any, columnNames: any) {
-  const db = getAppDB()
+  const db: Database = context.getAppDB()
   const rows = await db.allDocs(
     getRowParams(table._id, null, {
       include_docs: true,
     })
   )
-  return db.bulkDocs(
+  return (await db.bulkDocs(
     rows.rows.map(({ doc }: any) => {
       columnNames.forEach((colName: any) => delete doc[colName])
       return doc
     })
-  )
+  )) as { id: string; _rev?: string }[]
 }
 
 export async function checkForColumnUpdates(oldTable: any, updatedTable: any) {
-  const db = getAppDB()
+  const db = context.getAppDB()
   let updatedRows = []
   const rename = updatedTable._rename
   let deletedColumns: any = []
@@ -133,7 +133,7 @@ export async function handleDataImport(user: any, table: any, dataImport: any) {
     return table
   }
 
-  const db = getAppDB()
+  const db = context.getAppDB()
   // Populate the table with rows imported from CSV in a bulk update
   const data = await transform({
     ...dataImport,
@@ -150,7 +150,7 @@ export async function handleDataImport(user: any, table: any, dataImport: any) {
 }
 
 export async function handleSearchIndexes(table: any) {
-  const db = getAppDB()
+  const db = context.getAppDB()
   // create relevant search indexes
   if (table.indexes && table.indexes.length > 0) {
     const currentIndexes = await db.getIndexes()
@@ -214,7 +214,7 @@ class TableSaveFunctions {
   rows: any
 
   constructor({ user, oldTable, dataImport }: any) {
-    this.db = getAppDB()
+    this.db = context.getAppDB()
     this.user = user
     this.oldTable = oldTable
     this.dataImport = dataImport
@@ -338,7 +338,7 @@ export function generateJunctionTableName(
   return `jt_${table.name}_${relatedTable.name}_${column.name}_${column.fieldName}`
 }
 
-export function foreignKeyStructure(keyName: any, meta = null) {
+export function foreignKeyStructure(keyName: any, meta?: any) {
   const structure: any = {
     type: FieldTypes.NUMBER,
     constraints: {},

package/src/api/controllers/{templates.js → templates.ts}

@@ -1,17 +1,20 @@
-const fetch = require("node-fetch")
-const { downloadTemplate } = require("../../utilities/fileSystem")
-const env = require("../../environment")
+import nodeFetch from "node-fetch"
+import { downloadTemplate as dlTemplate } from "../../utilities/fileSystem"
+import env from "../../environment"
+import { BBContext } from "@budibase/types"
 
 // development flag, can be used to test against templates exported locally
 const DEFAULT_TEMPLATES_BUCKET =
   "prod-budi-templates.s3-eu-west-1.amazonaws.com"
 
-exports.fetch = async function (ctx) {
+export async function fetch(ctx: BBContext) {
   let type = env.TEMPLATE_REPOSITORY
   let response,
     error = false
   try {
-    response = await fetch(`https://${DEFAULT_TEMPLATES_BUCKET}/manifest.json`)
+    response = await nodeFetch(
+      `https://${DEFAULT_TEMPLATES_BUCKET}/manifest.json`
+    )
     if (response.status !== 200) {
       error = true
     }
@@ -29,10 +32,10 @@ exports.fetch = async function (ctx) {
 
 // can't currently test this, have to ignore from coverage
 /* istanbul ignore next */
-exports.downloadTemplate = async function (ctx) {
+export async function downloadTemplate(ctx: BBContext) {
   const { type, name } = ctx.params
 
-  await downloadTemplate(type, name)
+  await dlTemplate(type, name)
 
   ctx.body = {
     message: `template ${type}:${name} downloaded successfully.`,

package/src/api/controllers/{user.js → user.ts}

@@ -1,23 +1,22 @@
-const {
+import {
   generateUserMetadataID,
   getUserMetadataParams,
   generateUserFlagID,
-} = require("../../db/utils")
-const { InternalTables } = require("../../db/utils")
-const { getGlobalUsers, getRawGlobalUser } = require("../../utilities/global")
-const { getFullUser } = require("../../utilities/users")
-const { isEqual } = require("lodash")
-const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
-const {
-  getDevelopmentAppID,
-  getProdAppIDs,
-  dbExists,
-} = require("@budibase/backend-core/db")
-const { UserStatus } = require("@budibase/backend-core/constants")
-const { getAppDB, doInAppContext } = require("@budibase/backend-core/context")
+} from "../../db/utils"
+import { InternalTables } from "../../db/utils"
+import { getGlobalUsers, getRawGlobalUser } from "../../utilities/global"
+import { getFullUser } from "../../utilities/users"
+import { isEqual } from "lodash"
+import {
+  context,
+  constants,
+  roles as rolesCore,
+  db as dbCore,
+} from "@budibase/backend-core"
+import { BBContext, User } from "@budibase/types"
 
 async function rawMetadata() {
-  const db = getAppDB()
+  const db = context.getAppDB()
   return (
     await db.allDocs(
       getUserMetadataParams(null, {
@@ -27,9 +26,9 @@ async function rawMetadata() {
   ).rows.map(row => row.doc)
 }
 
-function combineMetadataAndUser(user, metadata) {
+function combineMetadataAndUser(user: any, metadata: any) {
   // skip users with no access
-  if (user.roleId === BUILTIN_ROLE_IDS.PUBLIC) {
+  if (user.roleId === rolesCore.BUILTIN_ROLE_IDS.PUBLIC) {
     return null
   }
   delete user._rev
@@ -55,9 +54,9 @@ function combineMetadataAndUser(user, metadata) {
   return null
 }
 
-exports.syncGlobalUsers = async () => {
+export async function syncGlobalUsers() {
   // sync user metadata
-  const db = getAppDB()
+  const db = context.getAppDB()
   const [users, metadata] = await Promise.all([getGlobalUsers(), rawMetadata()])
   const toWrite = []
   for (let user of users) {
@@ -69,13 +68,13 @@ exports.syncGlobalUsers = async () => {
   await db.bulkDocs(toWrite)
 }
 
-exports.syncUser = async function (ctx) {
+export async function syncUser(ctx: BBContext) {
   let deleting = false,
-    user
+    user: User | any
   const userId = ctx.params.id
   try {
     user = await getRawGlobalUser(userId)
-  } catch (err) {
+  } catch (err: any) {
     if (err && err.status === 404) {
       user = {}
       deleting = true
@@ -92,21 +91,21 @@ exports.syncUser = async function (ctx) {
   let prodAppIds
   // if they are a builder then get all production app IDs
   if ((user.builder && user.builder.global) || deleting) {
-    prodAppIds = await getProdAppIDs()
+    prodAppIds = await dbCore.getProdAppIDs()
   } else {
     prodAppIds = Object.entries(roles)
-      .filter(entry => entry[1] !== BUILTIN_ROLE_IDS.PUBLIC)
+      .filter(entry => entry[1] !== rolesCore.BUILTIN_ROLE_IDS.PUBLIC)
       .map(([appId]) => appId)
   }
   for (let prodAppId of prodAppIds) {
     const roleId = roles[prodAppId]
-    const devAppId = getDevelopmentAppID(prodAppId)
+    const devAppId = dbCore.getDevelopmentAppID(prodAppId)
     for (let appId of [prodAppId, devAppId]) {
-      if (!(await dbExists(appId))) {
+      if (!(await dbCore.dbExists(appId))) {
         continue
       }
-      await doInAppContext(appId, async () => {
-        const db = getAppDB()
+      await context.doInAppContext(appId, async () => {
+        const db = context.getAppDB()
         const metadataId = generateUserMetadataID(userId)
         let metadata
         try {
@@ -127,8 +126,8 @@ exports.syncUser = async function (ctx) {
           ? combineMetadataAndUser(user, metadata)
           : {
               ...metadata,
-              status: UserStatus.INACTIVE,
-              metadata: BUILTIN_ROLE_IDS.PUBLIC,
+              status: constants.UserStatus.INACTIVE,
+              metadata: rolesCore.BUILTIN_ROLE_IDS.PUBLIC,
             }
         // if its null then there was no updates required
         if (combined) {
@@ -142,10 +141,9 @@ exports.syncUser = async function (ctx) {
   }
 }
 
-exports.fetchMetadata = async function (ctx) {
-  const database = getAppDB()
+export async function fetchMetadata(ctx: BBContext) {
   const global = await getGlobalUsers()
-  const metadata = await rawMetadata(database)
+  const metadata = await rawMetadata()
   const users = []
   for (let user of global) {
     // find the metadata that matches up to the global ID
@@ -162,18 +160,18 @@ exports.fetchMetadata = async function (ctx) {
   ctx.body = users
 }
 
-exports.updateSelfMetadata = async function (ctx) {
+export async function updateSelfMetadata(ctx: BBContext) {
   // overwrite the ID with current users
-  ctx.request.body._id = ctx.user._id
+  ctx.request.body._id = ctx.user?._id
   // make sure no stale rev
   delete ctx.request.body._rev
   // make sure no csrf token
   delete ctx.request.body.csrfToken
-  await exports.updateMetadata(ctx)
+  await updateMetadata(ctx)
 }
 
-exports.updateMetadata = async function (ctx) {
-  const db = getAppDB()
+export async function updateMetadata(ctx: BBContext) {
+  const db = context.getAppDB()
   const user = ctx.request.body
   // this isn't applicable to the user
   delete user.roles
@@ -184,8 +182,8 @@ exports.updateMetadata = async function (ctx) {
   ctx.body = await db.put(metadata)
 }
 
-exports.destroyMetadata = async function (ctx) {
-  const db = getAppDB()
+export async function destroyMetadata(ctx: BBContext) {
+  const db = context.getAppDB()
   try {
     const dbUser = await db.get(ctx.params.id)
     await db.remove(dbUser._id, dbUser._rev)
@@ -197,18 +195,18 @@ exports.destroyMetadata = async function (ctx) {
   }
 }
 
-exports.findMetadata = async function (ctx) {
+export async function findMetadata(ctx: BBContext) {
   ctx.body = await getFullUser(ctx, ctx.params.id)
 }
 
-exports.setFlag = async function (ctx) {
-  const userId = ctx.user._id
+export async function setFlag(ctx: BBContext) {
+  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 = getAppDB()
+  const flagDocId = generateUserFlagID(userId!)
+  const db = context.getAppDB()
   let doc
   try {
     doc = await db.get(flagDocId)
@@ -220,10 +218,10 @@ exports.setFlag = async function (ctx) {
   ctx.body = { message: "Flag set successfully" }
 }
 
-exports.getFlags = async function (ctx) {
-  const userId = ctx.user._id
-  const docId = generateUserFlagID(userId)
-  const db = getAppDB()
+export async function getFlags(ctx: BBContext) {
+  const userId = ctx.user?._id
+  const docId = generateUserFlagID(userId!)
+  const db = context.getAppDB()
   let doc
   try {
     doc = await db.get(docId)

package/src/api/controllers/view/{exporters.js → exporters.ts}

@@ -1,4 +1,6 @@
-exports.csv = function (headers, rows) {
+import { Row } from "@budibase/types"
+
+export function csv(headers: string[], rows: Row[]) {
   let csv = headers.map(key => `"${key}"`).join(",")
 
   for (let row of rows) {
@@ -16,11 +18,11 @@ exports.csv = function (headers, rows) {
   return csv
 }
 
-exports.json = function (headers, rows) {
+export function json(headers: string[], rows: Row[]) {
   return JSON.stringify(rows, undefined, 2)
 }
 
-exports.ExportFormats = {
+export const ExportFormats = {
   CSV: "csv",
   JSON: "json",
 }

package/src/api/controllers/view/{index.js → index.ts}

@@ -1,21 +1,29 @@
-const viewTemplate = require("./viewBuilder")
-const { apiFileReturn } = require("../../../utilities/fileSystem")
-const exporters = require("./exporters")
-const { saveView, getView, getViews, deleteView } = require("./utils")
-const { fetchView } = require("../row")
-const { FieldTypes } = require("../../../constants")
-const { getAppDB } = require("@budibase/backend-core/context")
-const { events } = require("@budibase/backend-core")
-const { DocumentType } = require("../../../db/utils")
+import viewTemplate from "./viewBuilder"
+import { apiFileReturn } from "../../../utilities/fileSystem"
+import * as exporters from "./exporters"
+import { deleteView, getView, getViews, saveView } from "./utils"
+import { fetchView } from "../row"
+import { FieldTypes } from "../../../constants"
+import { context, events } from "@budibase/backend-core"
+import { DocumentType } from "../../../db/utils"
+import sdk from "../../../sdk"
+import {
+  BBContext,
+  Row,
+  Table,
+  TableExportFormat,
+  TableSchema,
+  View,
+} from "@budibase/types"
+
 const { cloneDeep, isEqual } = require("lodash")
-const sdk = require("../../../sdk")
 
-exports.fetch = async ctx => {
+export async function fetch(ctx: BBContext) {
   ctx.body = await getViews()
 }
 
-exports.save = async ctx => {
-  const db = getAppDB()
+export async function save(ctx: BBContext) {
+  const db = context.getAppDB()
   const { originalName, ...viewToSave } = ctx.request.body
   const view = viewTemplate(viewToSave)
   const viewName = viewToSave.name
@@ -47,7 +55,7 @@ exports.save = async ctx => {
   }
 }
 
-const calculationEvents = async (existingView, newView) => {
+export async function calculationEvents(existingView: View, newView: View) {
   const existingCalculation = existingView && existingView.calculation
   const newCalculation = newView && newView.calculation
 
@@ -68,7 +76,7 @@ const calculationEvents = async (existingView, newView) => {
   }
 }
 
-const filterEvents = async (existingView, newView) => {
+export async function filterEvents(existingView: View, newView: View) {
   const hasExistingFilters = !!(
     existingView &&
     existingView.filters &&
@@ -93,7 +101,7 @@ const filterEvents = async (existingView, newView) => {
   }
 }
 
-const handleViewEvents = async (existingView, newView) => {
+async function handleViewEvents(existingView: View, newView: View) {
   if (!existingView) {
     await events.view.created(newView)
   } else {
@@ -103,8 +111,8 @@ const handleViewEvents = async (existingView, newView) => {
   await filterEvents(existingView, newView)
 }
 
-exports.destroy = async ctx => {
-  const db = getAppDB()
+export async function destroy(ctx: BBContext) {
+  const db = context.getAppDB()
   const viewName = decodeURI(ctx.params.viewName)
   const view = await deleteView(viewName)
   const table = await db.get(view.meta.tableId)
@@ -115,11 +123,11 @@ exports.destroy = async ctx => {
   ctx.body = view
 }
 
-exports.exportView = async ctx => {
-  const viewName = decodeURI(ctx.query.view)
+export async function exportView(ctx: BBContext) {
+  const viewName = decodeURI(ctx.query.view as string)
   const view = await getView(viewName)
 
-  const format = ctx.query.format
+  const format = ctx.query.format as string
   if (!format || !Object.values(exporters.ExportFormats).includes(format)) {
     ctx.throw(400, "Format must be specified, either csv or json")
   }
@@ -130,6 +138,7 @@ exports.exportView = async ctx => {
     ctx.query = {
       group: view.meta.groupBy,
       calculation: view.meta.calculation,
+      // @ts-ignore
       stats: !!view.meta.field,
       field: view.meta.field,
     }
@@ -140,11 +149,11 @@ exports.exportView = async ctx => {
   }
 
   await fetchView(ctx)
-  let rows = ctx.body
+  let rows = ctx.body as Row[]
 
-  let schema = view && view.meta && view.meta.schema
+  let schema: TableSchema = view && view.meta && view.meta.schema
   const tableId = ctx.params.tableId || view.meta.tableId
-  const table = await sdk.tables.getTable(tableId)
+  const table: Table = await sdk.tables.getTable(tableId)
   if (!schema) {
     schema = table.schema
   }
@@ -175,15 +184,15 @@ exports.exportView = async ctx => {
 
   // Export part
   let headers = Object.keys(schema)
-  const exporter = exporters[format]
+  const exporter = format === "csv" ? exporters.csv : exporters.json
   const filename = `${viewName}.${format}`
   // send down the file
   ctx.attachment(filename)
   ctx.body = apiFileReturn(exporter(headers, rows))
 
   if (viewName.startsWith(DocumentType.TABLE)) {
-    await events.table.exported(table, format)
+    await events.table.exported(table, format as TableExportFormat)
   } else {
-    await events.view.exported(table, format)
+    await events.view.exported(table, format as TableExportFormat)
   }
 }

package/src/api/controllers/view/{utils.js → utils.ts}

@@ -1,16 +1,17 @@
-const {
+import {
   ViewName,
   generateMemoryViewID,
   getMemoryViewParams,
   DocumentType,
   SEPARATOR,
-} = require("../../../db/utils")
-const env = require("../../../environment")
-const { getAppDB } = require("@budibase/backend-core/context")
-const viewBuilder = require("./viewBuilder")
+} from "../../../db/utils"
+import env from "../../../environment"
+import { context } from "@budibase/backend-core"
+import viewBuilder from "./viewBuilder"
+import { Database } from "@budibase/types"
 
-exports.getView = async viewName => {
-  const db = getAppDB()
+export async function getView(viewName: string) {
+  const db = context.getAppDB()
   if (env.SELF_HOSTED) {
     const designDoc = await db.get("_design/database")
     return designDoc.views[viewName]
@@ -23,7 +24,7 @@ exports.getView = async viewName => {
     try {
       const viewDoc = await db.get(generateMemoryViewID(viewName))
       return viewDoc.view
-    } catch (err) {
+    } catch (err: any) {
       // Return null when PouchDB doesn't found the view
       if (err.status === 404) {
         return null
@@ -34,14 +35,15 @@ exports.getView = async viewName => {
   }
 }
 
-exports.getViews = async () => {
-  const db = getAppDB()
+export async function getViews() {
+  const db = context.getAppDB()
   const response = []
   if (env.SELF_HOSTED) {
     const designDoc = await db.get("_design/database")
     for (let name of Object.keys(designDoc.views)) {
       // Only return custom views, not built ins
-      if (Object.values(ViewName).indexOf(name) !== -1) {
+      const viewNames = Object.values(ViewName) as string[]
+      if (viewNames.indexOf(name) !== -1) {
         continue
       }
       response.push({
@@ -67,8 +69,12 @@ exports.getViews = async () => {
   return response
 }
 
-exports.saveView = async (originalName, viewName, viewTemplate) => {
-  const db = getAppDB()
+export async function saveView(
+  originalName: string | null,
+  viewName: string,
+  viewTemplate: any
+) {
+  const db = context.getAppDB()
   if (env.SELF_HOSTED) {
     const designDoc = await db.get("_design/database")
     designDoc.views = {
@@ -83,7 +89,7 @@ exports.saveView = async (originalName, viewName, viewTemplate) => {
   } else {
     const id = generateMemoryViewID(viewName)
     const originalId = originalName ? generateMemoryViewID(originalName) : null
-    const viewDoc = {
+    const viewDoc: any = {
       _id: id,
       view: viewTemplate,
       name: viewName,
@@ -105,8 +111,8 @@ exports.saveView = async (originalName, viewName, viewTemplate) => {
   }
 }
 
-exports.deleteView = async viewName => {
-  const db = getAppDB()
+export async function deleteView(viewName: string) {
+  const db = context.getAppDB()
   if (env.SELF_HOSTED) {
     const designDoc = await db.get("_design/database")
     const view = designDoc.views[viewName]
@@ -121,7 +127,7 @@ exports.deleteView = async viewName => {
   }
 }
 
-exports.migrateToInMemoryView = async (db, viewName) => {
+export async function migrateToInMemoryView(db: Database, viewName: string) {
   // delete the view initially
   const designDoc = await db.get("_design/database")
   // run the view back through the view builder to update it
@@ -131,7 +137,7 @@ exports.migrateToInMemoryView = async (db, viewName) => {
   await exports.saveView(db, null, viewName, view)
 }
 
-exports.migrateToDesignView = async (db, viewName) => {
+export async function migrateToDesignView(db: Database, viewName: string) {
   let view = await db.get(generateMemoryViewID(viewName))
   const designDoc = await db.get("_design/database")
   designDoc.views[viewName] = viewBuilder(view.view.meta)
@@ -139,7 +145,7 @@ exports.migrateToDesignView = async (db, viewName) => {
   await db.remove(view._id, view._rev)
 }
 
-exports.getFromDesignDoc = async (db, viewName) => {
+export async function getFromDesignDoc(db: Database, viewName: string) {
   const designDoc = await db.get("_design/database")
   let view = designDoc.views[viewName]
   if (view == null) {
@@ -148,7 +154,7 @@ exports.getFromDesignDoc = async (db, viewName) => {
   return view
 }
 
-exports.getFromMemoryDoc = async (db, viewName) => {
+export async function getFromMemoryDoc(db: Database, viewName: string) {
   let view = await db.get(generateMemoryViewID(viewName))
   if (view) {
     view = view.view

package/src/api/{index.js → index.ts}

@@ -1,20 +1,15 @@
-const Router = require("@koa/router")
-const {
-  buildAuthMiddleware,
-  auditLog,
-  buildTenancyMiddleware,
-} = require("@budibase/backend-core/auth")
-const { errors } = require("@budibase/backend-core")
-const currentApp = require("../middleware/currentapp")
+import Router from "@koa/router"
+import { errors, auth } from "@budibase/backend-core"
+import currentApp from "../middleware/currentapp"
+import zlib from "zlib"
+import { mainRoutes, staticRoutes, publicRoutes } from "./routes"
+import pkg from "../../package.json"
+import env from "../environment"
+import { middleware as pro } from "@budibase/pro"
+export { shutdown } from "./routes/public"
 const compress = require("koa-compress")
-const zlib = require("zlib")
-const { mainRoutes, staticRoutes, publicRoutes } = require("./routes")
-const pkg = require("../../package.json")
-const env = require("../environment")
-const { middleware: pro } = require("@budibase/pro")
-const { shutdown } = require("./routes/public")
 
-const router = new Router()
+export const router: Router = new Router()
 
 router.get("/health", ctx => (ctx.status = 200))
 router.get("/version", ctx => (ctx.body = pkg.version))
@@ -42,7 +37,7 @@ router
   // re-direct before any middlewares occur
   .redirect("/", "/builder")
   .use(
-    buildAuthMiddleware(null, {
+    auth.buildAuthMiddleware(null, {
       publicAllowed: true,
     })
   )
@@ -50,19 +45,20 @@ router
   // the server can be public anywhere, so nowhere should throw errors
   // if the tenancy has not been set, it'll have to be discovered at application layer
   .use(
-    buildTenancyMiddleware(null, null, {
+    auth.buildTenancyMiddleware(null, null, {
       noTenancyRequired: true,
     })
   )
   .use(pro.licensing())
+  // @ts-ignore
   .use(currentApp)
-  .use(auditLog)
+  .use(auth.auditLog)
 
 // error handling middleware
 router.use(async (ctx, next) => {
   try {
     await next()
-  } catch (err) {
+  } catch (err: any) {
     ctx.status = err.status || err.statusCode || 500
     const error = errors.getPublicError(err)
     ctx.body = {
@@ -91,6 +87,3 @@ router.use(publicRoutes.allowedMethods())
 // WARNING - static routes will catch everything else after them this must be last
 router.use(staticRoutes.routes())
 router.use(staticRoutes.allowedMethods())
-
-module.exports.router = router
-module.exports.shutdown = shutdown

package/src/api/routes/analytics.ts

@@ -0,0 +1,9 @@
+import Router from "@koa/router"
+import * as controller from "../controllers/analytics"
+
+const router: Router = new Router()
+
+router.get("/api/bbtel", controller.isEnabled)
+router.post("/api/bbtel/ping", controller.ping)
+
+export = router