@budibase/server 0.0.32 → 0.0.999-alpha.30

package/src/db/utils.ts

@@ -0,0 +1,272 @@
+import newid from "./newid"
+import { db as dbCore } from "@budibase/backend-core"
+
+type Optional = string | null
+
+export const AppStatus = {
+  DEV: "development",
+  ALL: "all",
+  DEPLOYED: "published",
+}
+
+export const BudibaseInternalDB = {
+  _id: "bb_internal",
+  type: dbCore.BUDIBASE_DATASOURCE_TYPE,
+  name: "Budibase DB",
+  source: "BUDIBASE",
+  config: {},
+}
+
+export const SEPARATOR = dbCore.SEPARATOR
+export const StaticDatabases = dbCore.StaticDatabases
+export const DocumentType = dbCore.DocumentType
+export const APP_PREFIX = dbCore.APP_PREFIX
+export const APP_DEV_PREFIX = dbCore.APP_DEV_PREFIX
+export const isDevAppID = dbCore.isDevAppID
+export const isProdAppID = dbCore.isProdAppID
+export const USER_METDATA_PREFIX = `${DocumentType.ROW}${SEPARATOR}${dbCore.InternalTable.USER_METADATA}${SEPARATOR}`
+export const LINK_USER_METADATA_PREFIX = `${DocumentType.LINK}${SEPARATOR}${dbCore.InternalTable.USER_METADATA}${SEPARATOR}`
+export const TABLE_ROW_PREFIX = `${DocumentType.ROW}${SEPARATOR}${DocumentType.TABLE}`
+export const ViewName = dbCore.ViewName
+export const InternalTables = dbCore.InternalTable
+export const UNICODE_MAX = dbCore.UNICODE_MAX
+export const generateAppID = dbCore.generateAppID
+export const generateDevAppID = dbCore.getDevelopmentAppID
+export const generateRoleID = dbCore.generateRoleID
+export const getRoleParams = dbCore.getRoleParams
+export const getQueryIndex = dbCore.getQueryIndex
+export const getDocParams = dbCore.getDocParams
+export const getRowParams = dbCore.getRowParams
+export const generateRowID = dbCore.generateRowID
+export const getUserMetadataParams = dbCore.getUserMetadataParams
+export const generateUserMetadataID = dbCore.generateUserMetadataID
+export const getGlobalIDFromUserMetadataID =
+  dbCore.getGlobalIDFromUserMetadataID
+
+/**
+ * Gets parameters for retrieving tables, this is a utility function for the getDocParams function.
+ */
+export function getTableParams(tableId?: Optional, otherProps = {}) {
+  return getDocParams(DocumentType.TABLE, tableId, otherProps)
+}
+
+/**
+ * Generates a new table ID.
+ * @returns {string} The new table ID which the table doc can be stored under.
+ */
+export function generateTableID() {
+  return `${DocumentType.TABLE}${SEPARATOR}${newid()}`
+}
+
+/**
+ * Given a row ID this will find the table ID within it (only works for internal tables).
+ * @param {string} rowId The ID of the row.
+ * @returns {string} The table ID.
+ */
+export function getTableIDFromRowID(rowId: string) {
+  const components = rowId
+    .split(DocumentType.TABLE + SEPARATOR)[1]
+    .split(SEPARATOR)
+  return `${DocumentType.TABLE}${SEPARATOR}${components[0]}`
+}
+
+/**
+ * Gets parameters for retrieving automations, this is a utility function for the getDocParams function.
+ */
+export function getAutomationParams(
+  automationId?: Optional,
+  otherProps: any = {}
+) {
+  return getDocParams(DocumentType.AUTOMATION, automationId, otherProps)
+}
+
+/**
+ * Generates a new automation ID.
+ * @returns {string} The new automation ID which the automation doc can be stored under.
+ */
+export function generateAutomationID() {
+  return `${DocumentType.AUTOMATION}${SEPARATOR}${newid()}`
+}
+
+/**
+ * Generates a new link doc ID. This is currently not usable with the alldocs call,
+ * instead a view is built to make walking to tree easier.
+ * @param {string} tableId1 The ID of the linker table.
+ * @param {string} tableId2 The ID of the linked table.
+ * @param {string} rowId1 The ID of the linker row.
+ * @param {string} rowId2 The ID of the linked row.
+ * @param {string} fieldName1 The name of the field in the linker row.
+ * @param {string} fieldName2 the name of the field in the linked row.
+ * @returns {string} The new link doc ID which the automation doc can be stored under.
+ */
+export function generateLinkID(
+  tableId1: string,
+  tableId2: string,
+  rowId1: string,
+  rowId2: string,
+  fieldName1: string,
+  fieldName2: string
+) {
+  const tables = `${SEPARATOR}${tableId1}${SEPARATOR}${tableId2}`
+  const rows = `${SEPARATOR}${rowId1}${SEPARATOR}${rowId2}`
+  const fields = `${SEPARATOR}${fieldName1}${SEPARATOR}${fieldName2}`
+  return `${DocumentType.LINK}${tables}${rows}${fields}`
+}
+
+/**
+ * Gets parameters for retrieving link docs, this is a utility function for the getDocParams function.
+ */
+export function getLinkParams(otherProps: any = {}) {
+  return getDocParams(DocumentType.LINK, null, otherProps)
+}
+
+/**
+ * Generates a new layout ID.
+ * @returns {string} The new layout ID which the layout doc can be stored under.
+ */
+export function generateLayoutID(id?: string) {
+  return `${DocumentType.LAYOUT}${SEPARATOR}${id || newid()}`
+}
+
+/**
+ * Gets parameters for retrieving layout, this is a utility function for the getDocParams function.
+ */
+export function getLayoutParams(layoutId?: Optional, otherProps: any = {}) {
+  return getDocParams(DocumentType.LAYOUT, layoutId, otherProps)
+}
+
+/**
+ * Generates a new screen ID.
+ * @returns {string} The new screen ID which the screen doc can be stored under.
+ */
+export function generateScreenID() {
+  return `${DocumentType.SCREEN}${SEPARATOR}${newid()}`
+}
+
+/**
+ * Gets parameters for retrieving screens, this is a utility function for the getDocParams function.
+ */
+export function getScreenParams(screenId?: Optional, otherProps: any = {}) {
+  return getDocParams(DocumentType.SCREEN, screenId, otherProps)
+}
+
+/**
+ * Generates a new webhook ID.
+ * @returns {string} The new webhook ID which the webhook doc can be stored under.
+ */
+export function generateWebhookID() {
+  return `${DocumentType.WEBHOOK}${SEPARATOR}${newid()}`
+}
+
+/**
+ * Gets parameters for retrieving a webhook, this is a utility function for the getDocParams function.
+ */
+export function getWebhookParams(webhookId?: Optional, otherProps: any = {}) {
+  return getDocParams(DocumentType.WEBHOOK, webhookId, otherProps)
+}
+
+/**
+ * Generates a new datasource ID.
+ * @returns {string} The new datasource ID which the webhook doc can be stored under.
+ */
+export function generateDatasourceID({ plus = false } = {}) {
+  return `${
+    plus ? DocumentType.DATASOURCE_PLUS : DocumentType.DATASOURCE
+  }${SEPARATOR}${newid()}`
+}
+
+/**
+ * Gets parameters for retrieving a datasource, this is a utility function for the getDocParams function.
+ */
+export function getDatasourceParams(
+  datasourceId?: Optional,
+  otherProps: any = {}
+) {
+  return getDocParams(DocumentType.DATASOURCE, datasourceId, otherProps)
+}
+
+/**
+ * Generates a new query ID.
+ * @returns {string} The new query ID which the query doc can be stored under.
+ */
+export function generateQueryID(datasourceId: string) {
+  return `${
+    DocumentType.QUERY
+  }${SEPARATOR}${datasourceId}${SEPARATOR}${newid()}`
+}
+
+/**
+ * Generates a metadata ID for automations, used to track errors in recurring
+ * automations etc.
+ */
+export function generateAutomationMetadataID(automationId: string) {
+  return `${DocumentType.AUTOMATION_METADATA}${SEPARATOR}${automationId}`
+}
+
+/**
+ * Retrieve all automation metadata in an app database.
+ */
+export function getAutomationMetadataParams(otherProps: any = {}) {
+  return getDocParams(DocumentType.AUTOMATION_METADATA, null, otherProps)
+}
+
+/**
+ * Gets parameters for retrieving a query, this is a utility function for the getDocParams function.
+ */
+export function getQueryParams(datasourceId?: Optional, otherProps: any = {}) {
+  if (datasourceId == null) {
+    return getDocParams(DocumentType.QUERY, null, otherProps)
+  }
+
+  return getDocParams(
+    DocumentType.QUERY,
+    `${datasourceId}${SEPARATOR}`,
+    otherProps
+  )
+}
+
+/**
+ * Generates a new flag document ID.
+ * @returns {string} The ID of the flag document that was generated.
+ */
+export function generateUserFlagID(userId: string) {
+  return `${DocumentType.USER_FLAG}${SEPARATOR}${userId}`
+}
+
+export function generateMetadataID(type: string, entityId: string) {
+  return `${DocumentType.METADATA}${SEPARATOR}${type}${SEPARATOR}${entityId}`
+}
+
+export function getMetadataParams(
+  type: string,
+  entityId?: Optional,
+  otherProps: any = {}
+) {
+  let docId = `${type}${SEPARATOR}`
+  if (entityId != null) {
+    docId += entityId
+  }
+  return getDocParams(DocumentType.METADATA, docId, otherProps)
+}
+
+export function generateMemoryViewID(viewName: string) {
+  return `${DocumentType.MEM_VIEW}${SEPARATOR}${viewName}`
+}
+
+export function getMemoryViewParams(otherProps: any = {}) {
+  return getDocParams(DocumentType.MEM_VIEW, null, otherProps)
+}
+
+export function generatePluginID(name: string) {
+  return `${DocumentType.PLUGIN}${SEPARATOR}${name}`
+}
+
+/**
+ * This can be used with the db.allDocs to get a list of IDs
+ */
+export function getMultiIDParams(ids: string[]) {
+  return {
+    keys: ids,
+    include_docs: true,
+  }
+}

package/src/db/views/staticViews.ts

@@ -0,0 +1,132 @@
+import { context } from "@budibase/backend-core"
+import { DocumentType, SEPARATOR, ViewName } from "../utils"
+import { LinkDocument, Row, SearchIndex } from "@budibase/types"
+const SCREEN_PREFIX = DocumentType.SCREEN + SEPARATOR
+
+/**************************************************
+ *                  INFORMATION                   *
+ * This file exists purely to keep views separate *
+ *    from the rest of the codebase, the reason   *
+ *    being that they affect coverage and any     *
+ *  functions written in this file cannot import  *
+ *  or make use of any constants/variables that   *
+ *   aren't defined as part of the map function   *
+ *                   itself.                      *
+ **************************************************/
+
+/**
+ * Creates the link view for the instance, this will overwrite the existing one, but this should only
+ * be called if it is found that the view does not exist.
+ * @returns {Promise<void>} The view now exists, please note that the next view of this query will actually build it,
+ * so it may be slow.
+ */
+export async function createLinkView() {
+  const db = context.getAppDB()
+  const designDoc = await db.get("_design/database")
+  const view = {
+    map: function (doc: LinkDocument) {
+      // everything in this must remain constant as its going to Pouch, no external variables
+      if (doc.type === "link") {
+        let doc1 = doc.doc1
+        let doc2 = doc.doc2
+        // eslint-disable-next-line no-undef
+        // @ts-ignore
+        emit([doc1.tableId, doc1.rowId], {
+          id: doc2.rowId,
+          thisId: doc1.rowId,
+          fieldName: doc1.fieldName,
+        })
+        // if linking to same table can't emit twice
+        if (doc1.tableId !== doc2.tableId) {
+          // eslint-disable-next-line no-undef
+          // @ts-ignore
+          emit([doc2.tableId, doc2.rowId], {
+            id: doc1.rowId,
+            thisId: doc2.rowId,
+            fieldName: doc2.fieldName,
+          })
+        }
+      }
+    }.toString(),
+  }
+  designDoc.views = {
+    ...designDoc.views,
+    [ViewName.LINK]: view,
+  }
+  await db.put(designDoc)
+}
+
+export async function createRoutingView() {
+  const db = context.getAppDB()
+  const designDoc = await db.get("_design/database")
+  const view = {
+    // if using variables in a map function need to inject them before use
+    map: `function(doc) {
+      if (doc._id.startsWith("${SCREEN_PREFIX}")) {
+        emit(doc._id, {
+          id: doc._id,
+          routing: doc.routing,
+        })
+      }
+    }`,
+  }
+  designDoc.views = {
+    ...designDoc.views,
+    [ViewName.ROUTING]: view,
+  }
+  await db.put(designDoc)
+}
+
+async function searchIndex(indexName: string, fnString: string) {
+  const db = context.getAppDB()
+  const designDoc = await db.get("_design/database")
+  designDoc.indexes = {
+    [indexName]: {
+      index: fnString,
+      analyzer: "keyword",
+    },
+  }
+  await db.put(designDoc)
+}
+
+export async function createAllSearchIndex() {
+  await searchIndex(
+    SearchIndex.ROWS,
+    function (doc: Row) {
+      function idx(input: Row, prev?: string) {
+        for (let key of Object.keys(input)) {
+          let idxKey = prev != null ? `${prev}.${key}` : key
+          idxKey = idxKey.replace(/ /g, "_")
+          if (Array.isArray(input[key])) {
+            for (let val of input[key]) {
+              if (typeof val !== "object") {
+                // eslint-disable-next-line no-undef
+                // @ts-ignore
+                index(idxKey, val, { store: true })
+              }
+            }
+          } else if (key === "_id" || key === "_rev" || input[key] == null) {
+            continue
+          }
+          if (typeof input[key] === "string") {
+            // eslint-disable-next-line no-undef
+            // @ts-ignore
+            index(idxKey, input[key].toLowerCase(), { store: true })
+          } else if (typeof input[key] !== "object") {
+            // eslint-disable-next-line no-undef
+            // @ts-ignore
+            index(idxKey, input[key], { store: true })
+          } else {
+            idx(input[key], idxKey)
+          }
+        }
+      }
+      if (doc._id!.startsWith("ro_")) {
+        // eslint-disable-next-line no-undef
+        // @ts-ignore
+        index("default", doc._id)
+        idx(doc)
+      }
+    }.toString()
+  )
+}

package/src/ddApm.ts

@@ -0,0 +1,7 @@
+import apm from "dd-trace"
+
+// enable APM if configured
+if (process.env.DD_APM_ENABLED) {
+  console.log("Starting dd-trace")
+  apm.init()
+}

package/src/definitions/automations.ts

@@ -0,0 +1,33 @@
+import { AutomationResults, AutomationStep, Document } from "@budibase/types"
+
+export enum LoopStepType {
+  ARRAY = "Array",
+  STRING = "String",
+}
+
+export interface LoopStep extends AutomationStep {
+  inputs: {
+    option: LoopStepType
+    [key: string]: any
+  }
+}
+
+export interface LoopInput {
+  binding: string[] | string
+}
+
+export interface TriggerOutput {
+  metadata?: any
+  appId?: string
+  timestamp?: number
+}
+
+export interface AutomationContext extends AutomationResults {
+  steps: any[]
+  env?: Record<string, string>
+  trigger: any
+}
+
+export interface AutomationMetadata extends Document {
+  errorCount?: number
+}

package/src/definitions/common.ts

@@ -0,0 +1,54 @@
+import { Document } from "@budibase/types"
+export {
+  Query,
+  Datasource,
+  FieldSchema,
+  TableSchema,
+  Table,
+  Document,
+  Row,
+} from "@budibase/types"
+
+export interface Application extends Document {
+  _id: string
+  appId?: string
+}
+
+interface JsonSchemaField {
+  properties: {
+    [key: string]: {
+      type: string
+      title: string
+      customType?: string
+    }
+  }
+  required?: string[]
+}
+
+export interface AutomationStep {
+  description: string
+  event?: string
+  icon: string
+  id: string
+  inputs: {
+    [key: string]: any
+  }
+  name: string
+  schema: {
+    inputs: JsonSchemaField
+    outputs: JsonSchemaField
+  }
+  stepId: string
+  tagline: string
+  type: string
+}
+
+export interface Automation extends Document {
+  name: string
+  type: string
+  appId?: string
+  definition: {
+    steps: AutomationStep[]
+    trigger?: AutomationStep
+  }
+}

package/src/definitions/datasource.ts

@@ -0,0 +1,9 @@
+/********************************************
+ * This file contains structures which are  *
+ * internal to the server and don't need to *
+ * be exposed for use by other services.    *
+ ********************************************/
+
+export interface QueryOptions {
+  disableReturning?: boolean
+}