@budibase/server 2.1.45 → 2.1.46-alpha.0

package/src/api/controllers/application.ts

@@ -14,42 +14,46 @@ import {
   DocumentType,
   AppStatus,
 } from "../../db/utils"
-const {
-  BUILTIN_ROLE_IDS,
-  AccessController,
-} = require("@budibase/backend-core/roles")
-const { CacheKeys, bustCache } = require("@budibase/backend-core/cache")
-const {
-  getAllApps,
-  isDevAppID,
-  getProdAppID,
-  Replication,
-} = require("@budibase/backend-core/db")
+import {
+  db as dbCore,
+  roles,
+  cache,
+  tenancy,
+  context,
+  errors,
+  events,
+  migrations,
+} from "@budibase/backend-core"
 import { USERS_TABLE_SCHEMA } from "../../constants"
+import { buildDefaultDocs } from "../../db/defaultData/datasource_bb_default"
 import { removeAppFromUserRoles } from "../../utilities/workerRequests"
-import { clientLibraryPath, stringToReadStream } from "../../utilities"
+import {
+  clientLibraryPath,
+  stringToReadStream,
+  isQsTrue,
+} from "../../utilities"
 import { getLocksById } from "../../utilities/redis"
 import {
   updateClientLibrary,
   backupClientLibrary,
   revertClientLibrary,
 } from "../../utilities/fileSystem/clientLibrary"
-const { getTenantId, isMultiTenant } = require("@budibase/backend-core/tenancy")
-import { syncGlobalUsers } from "./user"
-const { app: appCache } = require("@budibase/backend-core/cache")
 import { cleanupAutomations } from "../../automations/utils"
-import { context } from "@budibase/backend-core"
 import { checkAppMetadata } from "../../automations/logging"
 import { getUniqueRows } from "../../utilities/usageQuota/rows"
 import { quotas, groups } from "@budibase/pro"
-import { errors, events, migrations } from "@budibase/backend-core"
-import { App, Layout, Screen, MigrationType } from "@budibase/types"
+import {
+  App,
+  Layout,
+  Screen,
+  MigrationType,
+  BBContext,
+  Database,
+} from "@budibase/types"
 import { BASE_LAYOUT_PROP_IDS } from "../../constants/layouts"
 import { enrichPluginURLs } from "../../utilities/plugins"
 import sdk from "../../sdk"
 
-const URL_REGEX_SLASH = /\/|\\/g
-
 // utility function, need to do away with this
 async function getLayouts() {
   const db = context.getAppDB()
@@ -73,29 +77,18 @@ async function getScreens() {
   ).rows.map((row: any) => row.doc)
 }
 
-function getUserRoleId(ctx: any) {
-  return !ctx.user.role || !ctx.user.role._id
-    ? BUILTIN_ROLE_IDS.PUBLIC
+function getUserRoleId(ctx: BBContext) {
+  return !ctx.user?.role || !ctx.user.role._id
+    ? roles.BUILTIN_ROLE_IDS.PUBLIC
     : ctx.user.role._id
 }
 
-export const getAppUrl = (ctx: any) => {
-  // construct the url
-  let url
-  if (ctx.request.body.url) {
-    // if the url is provided, use that
-    url = encodeURI(ctx.request.body.url)
-  } else if (ctx.request.body.name) {
-    // otherwise use the name
-    url = encodeURI(`${ctx.request.body.name}`)
-  }
-  if (url) {
-    url = `/${url.replace(URL_REGEX_SLASH, "")}`.toLowerCase()
-  }
-  return url
-}
-
-const checkAppUrl = (ctx: any, apps: any, url: any, currentAppId?: string) => {
+function checkAppUrl(
+  ctx: BBContext,
+  apps: App[],
+  url: string,
+  currentAppId?: string
+) {
   if (currentAppId) {
     apps = apps.filter((app: any) => app.appId !== currentAppId)
   }
@@ -104,12 +97,12 @@ const checkAppUrl = (ctx: any, apps: any, url: any, currentAppId?: string) => {
   }
 }
 
-const checkAppName = (
-  ctx: any,
-  apps: any,
-  name: any,
+function checkAppName(
+  ctx: BBContext,
+  apps: App[],
+  name: string,
   currentAppId?: string
-) => {
+) {
   // TODO: Replace with Joi
   if (!name) {
     ctx.throw(400, "Name is required")
@@ -122,8 +115,8 @@ const checkAppName = (
   }
 }
 
-async function createInstance(template: any) {
-  const tenantId = isMultiTenant() ? getTenantId() : null
+async function createInstance(template: any, includeSampleData: boolean) {
+  const tenantId = tenancy.isMultiTenant() ? tenancy.getTenantId() : null
   const baseAppId = generateAppID(tenantId)
   const appId = generateDevAppID(baseAppId)
   await context.updateAppId(appId)
@@ -154,15 +147,27 @@ async function createInstance(template: any) {
   } else {
     // create the users table
     await db.put(USERS_TABLE_SCHEMA)
+
+    if (includeSampleData) {
+      // create ootb stock db
+      await addDefaultTables(db)
+    }
   }
 
   return { _id: appId }
 }
 
-export const fetch = async (ctx: any) => {
+async function addDefaultTables(db: Database) {
+  const defaultDbDocs = buildDefaultDocs()
+
+  // add in the default db data docs - tables, datasource, rows and links
+  await db.bulkDocs([...defaultDbDocs])
+}
+
+export async function fetch(ctx: BBContext) {
   const dev = ctx.query && ctx.query.status === AppStatus.DEV
   const all = ctx.query && ctx.query.status === AppStatus.ALL
-  const apps = await getAllApps({ dev, all })
+  const apps = (await dbCore.getAllApps({ dev, all })) as App[]
 
   const appIds = apps
     .filter((app: any) => app.status === "development")
@@ -184,10 +189,10 @@ export const fetch = async (ctx: any) => {
   ctx.body = await checkAppMetadata(apps)
 }
 
-export const fetchAppDefinition = async (ctx: any) => {
+export async function fetchAppDefinition(ctx: BBContext) {
   const layouts = await getLayouts()
   const userRoleId = getUserRoleId(ctx)
-  const accessController = new AccessController()
+  const accessController = new roles.AccessController()
   const screens = await accessController.checkScreensAccess(
     await getScreens(),
     userRoleId
@@ -199,7 +204,7 @@ export const fetchAppDefinition = async (ctx: any) => {
   }
 }
 
-export const fetchAppPackage = async (ctx: any) => {
+export async function fetchAppPackage(ctx: BBContext) {
   const db = context.getAppDB()
   let application = await db.get(DocumentType.APP_METADATA)
   const layouts = await getLayouts()
@@ -209,9 +214,9 @@ export const fetchAppPackage = async (ctx: any) => {
   application.usedPlugins = enrichPluginURLs(application.usedPlugins)
 
   // Only filter screens if the user is not a builder
-  if (!(ctx.user.builder && ctx.user.builder.global)) {
+  if (!(ctx.user?.builder && ctx.user.builder.global)) {
     const userRoleId = getUserRoleId(ctx)
-    const accessController = new AccessController()
+    const accessController = new roles.AccessController()
     screens = await accessController.checkScreensAccess(screens, userRoleId)
   }
 
@@ -223,11 +228,12 @@ export const fetchAppPackage = async (ctx: any) => {
   }
 }
 
-const performAppCreate = async (ctx: any) => {
-  const apps = await getAllApps({ dev: true })
-  const name = ctx.request.body.name
+async function performAppCreate(ctx: BBContext) {
+  const apps = (await dbCore.getAllApps({ dev: true })) as App[]
+  const name = ctx.request.body.name,
+    possibleUrl = ctx.request.body.url
   checkAppName(ctx, apps, name)
-  const url = getAppUrl(ctx)
+  const url = sdk.applications.getAppUrl({ name, url: possibleUrl })
   checkAppUrl(ctx, apps, url)
 
   const { useTemplate, templateKey, templateString } = ctx.request.body
@@ -239,7 +245,8 @@ const performAppCreate = async (ctx: any) => {
   if (ctx.request.files && ctx.request.files.templateFile) {
     instanceConfig.file = ctx.request.files.templateFile
   }
-  const instance = await createInstance(instanceConfig)
+  const includeSampleData = isQsTrue(ctx.request.body.sampleData)
+  const instance = await createInstance(instanceConfig, includeSampleData)
   const appId = instance._id
   const db = context.getAppDB()
 
@@ -254,7 +261,7 @@ const performAppCreate = async (ctx: any) => {
     url: url,
     template: templateKey,
     instance,
-    tenantId: getTenantId(),
+    tenantId: tenancy.getTenantId(),
     updatedAt: new Date().toISOString(),
     createdAt: new Date().toISOString(),
     status: AppStatus.DEV,
@@ -313,11 +320,11 @@ const performAppCreate = async (ctx: any) => {
     await createApp(appId)
   }
 
-  await appCache.invalidateAppMetadata(appId, newApplication)
+  await cache.app.invalidateAppMetadata(appId, newApplication)
   return newApplication
 }
 
-const creationEvents = async (request: any, app: App) => {
+async function creationEvents(request: any, app: App) {
   let creationFns: ((app: App) => Promise<void>)[] = []
 
   const body = request.body
@@ -342,8 +349,8 @@ const creationEvents = async (request: any, app: App) => {
   }
 }
 
-const appPostCreate = async (ctx: any, app: App) => {
-  const tenantId = getTenantId()
+async function appPostCreate(ctx: BBContext, app: App) {
+  const tenantId = tenancy.getTenantId()
   await migrations.backPopulateMigrations({
     type: MigrationType.APP,
     tenantId,
@@ -356,12 +363,14 @@ const appPostCreate = async (ctx: any, app: App) => {
     const rowCount = rows ? rows.length : 0
     if (rowCount) {
       try {
-        await quotas.addRows(rowCount)
+        await context.doInAppContext(app.appId, () => {
+          return quotas.addRows(rowCount)
+        })
       } catch (err: any) {
         if (err.code && err.code === errors.codes.USAGE_LIMIT_EXCEEDED) {
           // this import resulted in row usage exceeding the quota
           // delete the app
-          // skip pre and post steps as no rows have been added to quotas yet
+          // skip pre- and post-steps as no rows have been added to quotas yet
           ctx.params.appId = app.appId
           await destroyApp(ctx)
         }
@@ -371,24 +380,25 @@ const appPostCreate = async (ctx: any, app: App) => {
   }
 }
 
-export const create = async (ctx: any) => {
+export async function create(ctx: BBContext) {
   const newApplication = await quotas.addApp(() => performAppCreate(ctx))
   await appPostCreate(ctx, newApplication)
-  await bustCache(CacheKeys.CHECKLIST)
+  await cache.bustCache(cache.CacheKey.CHECKLIST)
   ctx.body = newApplication
   ctx.status = 200
 }
 
 // This endpoint currently operates as a PATCH rather than a PUT
 // Thus name and url fields are handled only if present
-export const update = async (ctx: any) => {
-  const apps = await getAllApps({ dev: true })
+export async function update(ctx: BBContext) {
+  const apps = (await dbCore.getAllApps({ dev: true })) as App[]
   // validation
-  const name = ctx.request.body.name
+  const name = ctx.request.body.name,
+    possibleUrl = ctx.request.body.url
   if (name) {
     checkAppName(ctx, apps, name, ctx.params.appId)
   }
-  const url = getAppUrl(ctx)
+  const url = sdk.applications.getAppUrl({ name, url: possibleUrl })
   if (url) {
     checkAppUrl(ctx, apps, url, ctx.params.appId)
     ctx.request.body.url = url
@@ -400,7 +410,7 @@ export const update = async (ctx: any) => {
   ctx.body = app
 }
 
-export const updateClient = async (ctx: any) => {
+export async function updateClient(ctx: BBContext) {
   // Get current app version
   const db = context.getAppDB()
   const application = await db.get(DocumentType.APP_METADATA)
@@ -424,7 +434,7 @@ export const updateClient = async (ctx: any) => {
   ctx.body = app
 }
 
-export const revertClient = async (ctx: any) => {
+export async function revertClient(ctx: BBContext) {
   // Check app can be reverted
   const db = context.getAppDB()
   const application = await db.get(DocumentType.APP_METADATA)
@@ -450,12 +460,15 @@ export const revertClient = async (ctx: any) => {
   ctx.body = app
 }
 
-const destroyApp = async (ctx: any) => {
+async function destroyApp(ctx: BBContext) {
   let appId = ctx.params.appId
   let isUnpublish = ctx.query && ctx.query.unpublish
 
   if (isUnpublish) {
-    appId = getProdAppID(appId)
+    appId = dbCore.getProdAppID(appId)
+    const devAppId = dbCore.getDevAppID(appId)
+    // sync before removing the published app
+    await sdk.applications.syncApp(devAppId)
   }
 
   const db = isUnpublish ? context.getProdAppDB() : context.getAppDB()
@@ -481,16 +494,16 @@ const destroyApp = async (ctx: any) => {
   else {
     await removeAppFromUserRoles(ctx, appId)
   }
-  await appCache.invalidateAppMetadata(appId)
+  await cache.app.invalidateAppMetadata(appId)
   return result
 }
 
-const preDestroyApp = async (ctx: any) => {
+async function preDestroyApp(ctx: BBContext) {
   const { rows } = await getUniqueRows([ctx.params.appId])
   ctx.rowCount = rows.length
 }
 
-const postDestroyApp = async (ctx: any) => {
+async function postDestroyApp(ctx: BBContext) {
   const rowCount = ctx.rowCount
   await groups.cleanupApp(ctx.params.appId)
   if (rowCount) {
@@ -498,7 +511,7 @@ const postDestroyApp = async (ctx: any) => {
   }
 }
 
-export const destroy = async (ctx: any) => {
+export async function destroy(ctx: BBContext) {
   await preDestroyApp(ctx)
   const result = await destroyApp(ctx)
   await postDestroyApp(ctx)
@@ -506,64 +519,16 @@ export const destroy = async (ctx: any) => {
   ctx.body = result
 }
 
-export const sync = async (ctx: any, next: any) => {
-  if (env.DISABLE_AUTO_PROD_APP_SYNC) {
-    ctx.status = 200
-    ctx.body = {
-      message:
-        "App sync disabled. You can reenable with the DISABLE_AUTO_PROD_APP_SYNC environment variable.",
-    }
-    return next()
-  }
-
+export async function sync(ctx: BBContext) {
   const appId = ctx.params.appId
-  if (!isDevAppID(appId)) {
-    ctx.throw(400, "This action cannot be performed for production apps")
-  }
-
-  // replicate prod to dev
-  const prodAppId = getProdAppID(appId)
-
-  try {
-    // specific case, want to make sure setup is skipped
-    const prodDb = context.getProdAppDB({ skip_setup: true })
-    const info = await prodDb.info()
-    if (info.error) throw info.error
-  } catch (err) {
-    // the database doesn't exist. Don't replicate
-    ctx.status = 200
-    ctx.body = {
-      message: "App sync not required, app not deployed.",
-    }
-    return next()
-  }
-
-  const replication = new Replication({
-    source: prodAppId,
-    target: appId,
-  })
-  let error
   try {
-    await replication.replicate(replication.appReplicateOpts())
-  } catch (err) {
-    error = err
-  } finally {
-    await replication.close()
-  }
-
-  // sync the users
-  await syncGlobalUsers()
-
-  if (error) {
-    ctx.throw(400, error)
-  } else {
-    ctx.body = {
-      message: "App sync completed successfully.",
-    }
+    ctx.body = await sdk.applications.syncApp(appId)
+  } catch (err: any) {
+    ctx.throw(err.status || 400, err.message)
   }
 }
 
-export const updateAppPackage = async (appPackage: any, appId: any) => {
+export async function updateAppPackage(appPackage: any, appId: any) {
   return context.doInAppContext(appId, async () => {
     const db = context.getAppDB()
     const application = await db.get(DocumentType.APP_METADATA)
@@ -579,12 +544,12 @@ export const updateAppPackage = async (appPackage: any, appId: any) => {
 
     await db.put(newAppPackage)
     // remove any cached metadata, so that it will be updated
-    await appCache.invalidateAppMetadata(appId)
+    await cache.app.invalidateAppMetadata(appId)
     return newAppPackage
   })
 }
 
-const migrateAppNavigation = async () => {
+async function migrateAppNavigation() {
   const db = context.getAppDB()
   const existing: App = await db.get(DocumentType.APP_METADATA)
   const layouts: Layout[] = await getLayouts()

package/src/api/controllers/auth.ts

@@ -3,6 +3,7 @@ import { InternalTables } from "../../db/utils"
 import { getFullUser } from "../../utilities/users"
 import { roles, context } from "@budibase/backend-core"
 import { groups } from "@budibase/pro"
+import { ContextUser, User, Row } from "@budibase/types"
 
 const PUBLIC_ROLE = roles.BUILTIN_ROLE_IDS.PUBLIC
 
@@ -24,7 +25,7 @@ export async function fetchSelf(ctx: any) {
   }
 
   const appId = context.getAppId()
-  const user = await getFullUser(ctx, userId)
+  const user: ContextUser = await getFullUser(ctx, userId)
   // this shouldn't be returned by the app self
   delete user.roles
   // forward the csrf token from the session
@@ -34,7 +35,7 @@ export async function fetchSelf(ctx: any) {
     const db = context.getAppDB()
     // check for group permissions
     if (!user.roleId || user.roleId === PUBLIC_ROLE) {
-      const groupRoleId = await groups.getGroupRoleId(user, appId)
+      const groupRoleId = await groups.getGroupRoleId(user as User, appId)
       user.roleId = groupRoleId || user.roleId
     }
     // remove the full roles structure
@@ -42,7 +43,7 @@ export async function fetchSelf(ctx: any) {
     try {
       const userTable = await db.get(InternalTables.USER_METADATA)
       // specifically needs to make sure is enriched
-      ctx.body = await outputProcessing(userTable, user)
+      ctx.body = await outputProcessing(userTable, user as Row)
     } catch (err: any) {
       let response
       // user didn't exist in app, don't pretend they do