@budibase/backend-core 2.9.19 → 2.9.21-alpha.0

package/src/db/utils.ts

@@ -1,207 +0,0 @@
-import env from "../environment"
-import { DEFAULT_TENANT_ID, SEPARATOR, DocumentType } from "../constants"
-import { getTenantId, getGlobalDBName } from "../context"
-import { doWithDB, directCouchAllDbs } from "./db"
-import { AppState, DeletedApp, getAppMetadata } from "../cache/appMetadata"
-import { isDevApp, isDevAppID, getProdAppID } from "../docIds/conversions"
-import { App, Database } from "@budibase/types"
-import { getStartEndKeyURL } from "../docIds"
-export * from "../docIds"
-
-/**
- * if in production this will use the CouchDB _all_dbs call to retrieve a list of databases. If testing
- * when using Pouch it will use the pouchdb-all-dbs package.
- * opts.efficient can be provided to make sure this call is always quick in a multi-tenant environment,
- * but it may not be 100% accurate in full efficiency mode (some tenantless apps may be missed).
- */
-export async function getAllDbs(opts = { efficient: false }) {
-  const efficient = opts && opts.efficient
-
-  let dbs: any[] = []
-  async function addDbs(queryString?: string) {
-    const json = await directCouchAllDbs(queryString)
-    dbs = dbs.concat(json)
-  }
-  let tenantId = getTenantId()
-  if (!env.MULTI_TENANCY || (!efficient && tenantId === DEFAULT_TENANT_ID)) {
-    // just get all DBs when:
-    // - single tenancy
-    // - default tenant
-    //    - apps dbs don't contain tenant id
-    //    - non-default tenant dbs are filtered out application side in getAllApps
-    await addDbs()
-  } else {
-    // get prod apps
-    await addDbs(getStartEndKeyURL(DocumentType.APP, tenantId))
-    // get dev apps
-    await addDbs(getStartEndKeyURL(DocumentType.APP_DEV, tenantId))
-    // add global db name
-    dbs.push(getGlobalDBName(tenantId))
-  }
-  return dbs
-}
-
-/**
- * Lots of different points in the system need to find the full list of apps, this will
- * enumerate the entire CouchDB cluster and get the list of databases (every app).
- *
- * @return {Promise<object[]>} returns the app information document stored in each app database.
- */
-export async function getAllApps({
-  dev,
-  all,
-  idsOnly,
-  efficient,
-}: any = {}): Promise<App[] | string[]> {
-  let tenantId = getTenantId()
-  if (!env.MULTI_TENANCY && !tenantId) {
-    tenantId = DEFAULT_TENANT_ID
-  }
-  let dbs = await getAllDbs({ efficient })
-  const appDbNames = dbs.filter((dbName: any) => {
-    if (env.isTest() && !dbName) {
-      return false
-    }
-
-    const split = dbName.split(SEPARATOR)
-    // it is an app, check the tenantId
-    if (split[0] === DocumentType.APP) {
-      // tenantId is always right before the UUID
-      const possibleTenantId = split[split.length - 2]
-
-      const noTenantId =
-        split.length === 2 || possibleTenantId === DocumentType.DEV
-
-      return (
-        (tenantId === DEFAULT_TENANT_ID && noTenantId) ||
-        possibleTenantId === tenantId
-      )
-    }
-    return false
-  })
-  if (idsOnly) {
-    const devAppIds = appDbNames.filter(appId => isDevAppID(appId))
-    const prodAppIds = appDbNames.filter(appId => !isDevAppID(appId))
-    switch (dev) {
-      case true:
-        return devAppIds
-      case false:
-        return prodAppIds
-      default:
-        return appDbNames
-    }
-  }
-  const appPromises = appDbNames.map((app: any) =>
-    // skip setup otherwise databases could be re-created
-    getAppMetadata(app)
-  )
-  if (appPromises.length === 0) {
-    return []
-  } else {
-    const response = await Promise.allSettled(appPromises)
-    const apps = response
-      .filter(
-        (result: any) =>
-          result.status === "fulfilled" &&
-          result.value?.state !== AppState.INVALID
-      )
-      .map(({ value }: any) => value)
-    if (!all) {
-      return apps.filter((app: any) => {
-        if (dev) {
-          return isDevApp(app)
-        }
-        return !isDevApp(app)
-      })
-    } else {
-      return apps.map((app: any) => ({
-        ...app,
-        status: isDevApp(app) ? "development" : "published",
-      }))
-    }
-  }
-}
-
-export async function getAppsByIDs(appIds: string[]) {
-  const settled = await Promise.allSettled(
-    appIds.map(appId => getAppMetadata(appId))
-  )
-  // have to list the apps which exist, some may have been deleted
-  return settled
-    .filter(
-      promise =>
-        promise.status === "fulfilled" &&
-        (promise.value as DeletedApp).state !== AppState.INVALID
-    )
-    .map(promise => (promise as PromiseFulfilledResult<App>).value)
-}
-
-/**
- * Utility function for getAllApps but filters to production apps only.
- */
-export async function getProdAppIDs() {
-  const apps = (await getAllApps({ idsOnly: true })) as string[]
-  return apps.filter((id: any) => !isDevAppID(id))
-}
-
-/**
- * Utility function for the inverse of above.
- */
-export async function getDevAppIDs() {
-  const apps = (await getAllApps({ idsOnly: true })) as string[]
-  return apps.filter((id: any) => isDevAppID(id))
-}
-
-export function isSameAppID(
-  appId1: string | undefined,
-  appId2: string | undefined
-) {
-  if (appId1 == undefined || appId2 == undefined) {
-    return false
-  }
-  return getProdAppID(appId1) === getProdAppID(appId2)
-}
-
-export async function dbExists(dbName: any) {
-  return doWithDB(
-    dbName,
-    async (db: Database) => {
-      return await db.exists()
-    },
-    { skip_setup: true }
-  )
-}
-
-export function pagination<T>(
-  data: T[],
-  pageSize: number,
-  {
-    paginate,
-    property,
-    getKey,
-  }: {
-    paginate: boolean
-    property: string
-    getKey?: (doc: T) => string | undefined
-  } = {
-    paginate: true,
-    property: "_id",
-  }
-) {
-  if (!paginate) {
-    return { data, hasNextPage: false }
-  }
-  const hasNextPage = data.length > pageSize
-  let nextPage = undefined
-  if (!getKey) {
-    getKey = (doc: any) => (property ? doc?.[property] : doc?._id)
-  }
-  if (hasNextPage) {
-    nextPage = getKey(data[pageSize])
-  }
-  return {
-    data: data.slice(0, pageSize),
-    hasNextPage,
-    nextPage,
-  }
-}

package/src/db/views.ts

@@ -1,241 +0,0 @@
-import {
-  DeprecatedViews,
-  DocumentType,
-  SEPARATOR,
-  StaticDatabases,
-  ViewName,
-} from "../constants"
-import { getGlobalDB } from "../context"
-import { doWithDB } from "./"
-import { AllDocsResponse, Database, DatabaseQueryOpts } from "@budibase/types"
-import env from "../environment"
-
-const DESIGN_DB = "_design/database"
-
-function DesignDoc() {
-  return {
-    _id: DESIGN_DB,
-    // view collation information, read before writing any complex views:
-    // https://docs.couchdb.org/en/master/ddocs/views/collation.html#collation-specification
-    views: {},
-  }
-}
-
-interface DesignDocument {
-  views: any
-}
-
-async function removeDeprecated(db: Database, viewName: ViewName) {
-  // @ts-ignore
-  if (!DeprecatedViews[viewName]) {
-    return
-  }
-  try {
-    const designDoc = await db.get<DesignDocument>(DESIGN_DB)
-    // @ts-ignore
-    for (let deprecatedNames of DeprecatedViews[viewName]) {
-      delete designDoc.views[deprecatedNames]
-    }
-    await db.put(designDoc)
-  } catch (err) {
-    // doesn't exist, ignore
-  }
-}
-
-export async function createView(
-  db: any,
-  viewJs: string,
-  viewName: string
-): Promise<void> {
-  let designDoc
-  try {
-    designDoc = (await db.get(DESIGN_DB)) as DesignDocument
-  } catch (err) {
-    // no design doc, make one
-    designDoc = DesignDoc()
-  }
-  const view = {
-    map: viewJs,
-  }
-  designDoc.views = {
-    ...designDoc.views,
-    [viewName]: view,
-  }
-  try {
-    await db.put(designDoc)
-  } catch (err: any) {
-    if (err.status === 409) {
-      return await createView(db, viewJs, viewName)
-    } else {
-      throw err
-    }
-  }
-}
-
-export const createNewUserEmailView = async () => {
-  const db = getGlobalDB()
-  const viewJs = `function(doc) {
-    if (doc._id.startsWith("${DocumentType.USER}${SEPARATOR}")) {
-      emit(doc.email.toLowerCase(), doc._id)
-    }
-  }`
-  await createView(db, viewJs, ViewName.USER_BY_EMAIL)
-}
-
-export const createUserAppView = async () => {
-  const db = getGlobalDB()
-  const viewJs = `function(doc) {
-    if (doc._id.startsWith("${DocumentType.USER}${SEPARATOR}") && doc.roles) {
-      for (let prodAppId of Object.keys(doc.roles)) {
-        let emitted = prodAppId + "${SEPARATOR}" + doc._id
-        emit(emitted, null)
-      }
-    }
-  }`
-  await createView(db, viewJs, ViewName.USER_BY_APP)
-}
-
-export const createApiKeyView = async () => {
-  const db = getGlobalDB()
-  const viewJs = `function(doc) {
-    if (doc._id.startsWith("${DocumentType.DEV_INFO}") && doc.apiKey) {
-      emit(doc.apiKey, doc.userId)
-    }
-  }`
-  await createView(db, viewJs, ViewName.BY_API_KEY)
-}
-
-export interface QueryViewOptions {
-  arrayResponse?: boolean
-}
-
-export async function queryViewRaw<T>(
-  viewName: ViewName,
-  params: DatabaseQueryOpts,
-  db: Database,
-  createFunc: any,
-  opts?: QueryViewOptions
-): Promise<AllDocsResponse<T>> {
-  try {
-    const response = await db.query<T>(`database/${viewName}`, params)
-    // await to catch error
-    return response
-  } catch (err: any) {
-    const pouchNotFound = err && err.name === "not_found"
-    const couchNotFound = err && err.status === 404
-    if (pouchNotFound || couchNotFound) {
-      await removeDeprecated(db, viewName)
-      await createFunc()
-      return queryViewRaw(viewName, params, db, createFunc, opts)
-    } else if (err.status === 409) {
-      // can happen when multiple queries occur at once, view couldn't be created
-      // other design docs being updated, re-run
-      return queryViewRaw(viewName, params, db, createFunc, opts)
-    } else {
-      throw err
-    }
-  }
-}
-
-export const queryView = async <T>(
-  viewName: ViewName,
-  params: DatabaseQueryOpts,
-  db: Database,
-  createFunc: any,
-  opts?: QueryViewOptions
-): Promise<T[] | T | undefined> => {
-  const response = await queryViewRaw<T>(viewName, params, db, createFunc, opts)
-  const rows = response.rows
-  const docs = rows.map((row: any) =>
-    params.include_docs ? row.doc : row.value
-  )
-
-  // if arrayResponse has been requested, always return array regardless of length
-  if (opts?.arrayResponse) {
-    return docs as T[]
-  } else {
-    // return the single document if there is only one
-    return docs.length <= 1 ? (docs[0] as T) : (docs as T[])
-  }
-}
-
-// PLATFORM
-
-async function createPlatformView(viewJs: string, viewName: ViewName) {
-  try {
-    await doWithDB(StaticDatabases.PLATFORM_INFO.name, async (db: Database) => {
-      await createView(db, viewJs, viewName)
-    })
-  } catch (e: any) {
-    if (e.status === 409 && env.isTest()) {
-      // multiple tests can try to initialise platforms views
-      // at once - safe to exit on conflict
-      return
-    }
-    throw e
-  }
-}
-
-export const createPlatformAccountEmailView = async () => {
-  const viewJs = `function(doc) {
-    if (doc._id.startsWith("${DocumentType.ACCOUNT_METADATA}${SEPARATOR}")) {
-      emit(doc.email.toLowerCase(), doc._id)
-    }
-  }`
-  await createPlatformView(viewJs, ViewName.ACCOUNT_BY_EMAIL)
-}
-
-export const createPlatformUserView = async () => {
-  const viewJs = `function(doc) {
-    if (doc.tenantId) {
-      emit(doc._id.toLowerCase(), doc._id)
-    }
-  }`
-  await createPlatformView(viewJs, ViewName.PLATFORM_USERS_LOWERCASE)
-}
-
-export const queryPlatformView = async <T>(
-  viewName: ViewName,
-  params: DatabaseQueryOpts,
-  opts?: QueryViewOptions
-): Promise<T[] | T | undefined> => {
-  const CreateFuncByName: any = {
-    [ViewName.ACCOUNT_BY_EMAIL]: createPlatformAccountEmailView,
-    [ViewName.PLATFORM_USERS_LOWERCASE]: createPlatformUserView,
-  }
-
-  return doWithDB(StaticDatabases.PLATFORM_INFO.name, async (db: Database) => {
-    const createFn = CreateFuncByName[viewName]
-    return queryView(viewName, params, db, createFn, opts)
-  })
-}
-
-const CreateFuncByName: any = {
-  [ViewName.USER_BY_EMAIL]: createNewUserEmailView,
-  [ViewName.BY_API_KEY]: createApiKeyView,
-  [ViewName.USER_BY_APP]: createUserAppView,
-}
-
-export const queryGlobalView = async <T>(
-  viewName: ViewName,
-  params: DatabaseQueryOpts,
-  db?: Database,
-  opts?: QueryViewOptions
-): Promise<T[] | T | undefined> => {
-  // can pass DB in if working with something specific
-  if (!db) {
-    db = getGlobalDB()
-  }
-  const createFn = CreateFuncByName[viewName]
-  return queryView(viewName, params, db!, createFn, opts)
-}
-
-export async function queryGlobalViewRaw<T>(
-  viewName: ViewName,
-  params: DatabaseQueryOpts,
-  opts?: QueryViewOptions
-) {
-  const db = getGlobalDB()
-  const createFn = CreateFuncByName[viewName]
-  return queryViewRaw<T>(viewName, params, db, createFn, opts)
-}

package/src/docIds/conversions.ts

@@ -1,59 +0,0 @@
-import { APP_DEV_PREFIX, APP_PREFIX } from "../constants"
-import { App } from "@budibase/types"
-const NO_APP_ERROR = "No app provided"
-
-export function isDevAppID(appId?: string) {
-  if (!appId) {
-    throw NO_APP_ERROR
-  }
-  return appId.startsWith(APP_DEV_PREFIX)
-}
-
-export function isProdAppID(appId?: string) {
-  if (!appId) {
-    throw NO_APP_ERROR
-  }
-  return appId.startsWith(APP_PREFIX) && !isDevAppID(appId)
-}
-
-export function isDevApp(app: App) {
-  if (!app) {
-    throw NO_APP_ERROR
-  }
-  return isDevAppID(app.appId)
-}
-
-/**
- * Generates a development app ID from a real app ID.
- * @returns {string} the dev app ID which can be used for dev database.
- */
-export function getDevelopmentAppID(appId: string) {
-  if (!appId || appId.startsWith(APP_DEV_PREFIX)) {
-    return appId
-  }
-  // split to take off the app_ element, then join it together incase any other app_ exist
-  const split = appId.split(APP_PREFIX)
-  split.shift()
-  const rest = split.join(APP_PREFIX)
-  return `${APP_DEV_PREFIX}${rest}`
-}
-export const getDevAppID = getDevelopmentAppID
-
-/**
- * Convert a development app ID to a deployed app ID.
- */
-export function getProdAppID(appId: string) {
-  if (!appId || !appId.startsWith(APP_DEV_PREFIX)) {
-    return appId
-  }
-  // split to take off the app_dev element, then join it together incase any other app_ exist
-  const split = appId.split(APP_DEV_PREFIX)
-  split.shift()
-  const rest = split.join(APP_DEV_PREFIX)
-  return `${APP_PREFIX}${rest}`
-}
-
-export function extractAppUUID(id: string) {
-  const split = id?.split("_") || []
-  return split.length ? split[split.length - 1] : null
-}

package/src/docIds/ids.ts

@@ -1,113 +0,0 @@
-import {
-  APP_PREFIX,
-  DocumentType,
-  InternalTable,
-  SEPARATOR,
-} from "../constants"
-import { newid } from "./newid"
-
-/**
- * Generates a new app ID.
- * @returns {string} The new app ID which the app doc can be stored under.
- */
-export const generateAppID = (tenantId?: string | null) => {
-  let id = APP_PREFIX
-  if (tenantId) {
-    id += `${tenantId}${SEPARATOR}`
-  }
-  return `${id}${newid()}`
-}
-
-/**
- * Gets a new row ID for the specified table.
- * @param {string} tableId The table which the row is being created for.
- * @param {string|null} id If an ID is to be used then the UUID can be substituted for this.
- * @returns {string} The new ID which a row doc can be stored under.
- */
-export function generateRowID(tableId: string, id?: string) {
-  id = id || newid()
-  return `${DocumentType.ROW}${SEPARATOR}${tableId}${SEPARATOR}${id}`
-}
-
-/**
- * Generates a new workspace ID.
- * @returns {string} The new workspace ID which the workspace doc can be stored under.
- */
-export function generateWorkspaceID() {
-  return `${DocumentType.WORKSPACE}${SEPARATOR}${newid()}`
-}
-
-/**
- * Generates a new global user ID.
- * @returns {string} The new user ID which the user doc can be stored under.
- */
-export function generateGlobalUserID(id?: any) {
-  return `${DocumentType.USER}${SEPARATOR}${id || newid()}`
-}
-
-/**
- * Generates a new user ID based on the passed in global ID.
- * @param {string} globalId The ID of the global user.
- * @returns {string} The new user ID which the user doc can be stored under.
- */
-export function generateUserMetadataID(globalId: string) {
-  return generateRowID(InternalTable.USER_METADATA, globalId)
-}
-
-/**
- * Breaks up the ID to get the global ID.
- */
-export function getGlobalIDFromUserMetadataID(id: string) {
-  const prefix = `${DocumentType.ROW}${SEPARATOR}${InternalTable.USER_METADATA}${SEPARATOR}`
-  if (!id || !id.includes(prefix)) {
-    return id
-  }
-  return id.split(prefix)[1]
-}
-
-/**
- * Generates a template ID.
- * @param ownerId The owner/user of the template, this could be global or a workspace level.
- */
-export function generateTemplateID(ownerId: any) {
-  return `${DocumentType.TEMPLATE}${SEPARATOR}${ownerId}${SEPARATOR}${newid()}`
-}
-
-export function generateAppUserID(prodAppId: string, userId: string) {
-  return `${prodAppId}${SEPARATOR}${userId}`
-}
-
-/**
- * Generates a new role ID.
- * @returns {string} The new role ID which the role doc can be stored under.
- */
-export function generateRoleID(name: string) {
-  const prefix = `${DocumentType.ROLE}${SEPARATOR}`
-  if (name.startsWith(prefix)) {
-    return name
-  }
-  return `${prefix}${name}`
-}
-
-/**
- * Utility function to be more verbose.
- */
-export function prefixRoleID(name: string) {
-  return generateRoleID(name)
-}
-
-/**
- * Generates a new dev info document ID - this is scoped to a user.
- * @returns {string} The new dev info ID which info for dev (like api key) can be stored under.
- */
-export const generateDevInfoID = (userId: any) => {
-  return `${DocumentType.DEV_INFO}${SEPARATOR}${userId}`
-}
-
-/**
- * Generates a new plugin ID - to be used in the global DB.
- * @returns {string} The new plugin ID which a plugin metadata document can be stored under.
- */
-export const generatePluginID = (name: string) => {
-  return `${DocumentType.PLUGIN}${SEPARATOR}${name}`
-}

package/src/docIds/index.ts

@@ -1,2 +0,0 @@
-export * from "./ids"
-export * from "./params"

package/src/docIds/newid.ts

@@ -1,5 +0,0 @@
-import { v4 } from "uuid"
-
-export function newid() {
-  return v4().replace(/-/g, "")
-}