@budibase/server 2.1.43-alpha.1 → 2.1.43

package/src/db/linkedRows/{LinkController.ts → LinkController.js}

@@ -1,33 +1,59 @@
-import { IncludeDocs, getLinkDocuments } from "./linkUtils"
-import { InternalTables, getUserMetadataParams } from "../utils"
-import Sentry from "@sentry/node"
-import { FieldTypes, RelationshipTypes } from "../../constants"
-import { context } from "@budibase/backend-core"
-import LinkDocument from "./LinkDocument"
-import {
-  Database,
-  FieldSchema,
-  LinkDocumentValue,
-  Row,
-  Table,
-} from "@budibase/types"
+const { IncludeDocs, getLinkDocuments } = require("./linkUtils")
+const {
+  generateLinkID,
+  InternalTables,
+  getUserMetadataParams,
+} = require("../utils")
+const Sentry = require("@sentry/node")
+const { FieldTypes, RelationshipTypes } = require("../../constants")
+const { getAppDB } = require("@budibase/backend-core/context")
 
-type LinkControllerOpts = {
-  tableId?: string
-  row?: Row
-  table?: Table
-  oldTable?: Table
+/**
+ * Creates a new link document structure which can be put to the database. It is important to
+ * note that while this talks about linker/linked the link is bi-directional and for all intent
+ * and purposes it does not matter from which direction the link was initiated.
+ * @param {string} tableId1 The ID of the first table (the linker).
+ * @param {string} tableId2 The ID of the second table (the linked).
+ * @param {string} fieldName1 The name of the field in the linker table.
+ * @param {string} fieldName2 The name of the field in the linked table.
+ * @param {string} rowId1 The ID of the row which is acting as the linker.
+ * @param {string} rowId2 The ID of the row which is acting as the linked.
+ * @constructor
+ */
+function LinkDocument(
+  tableId1,
+  fieldName1,
+  rowId1,
+  tableId2,
+  fieldName2,
+  rowId2
+) {
+  // build the ID out of unique references to this link document
+  this._id = generateLinkID(
+    tableId1,
+    tableId2,
+    rowId1,
+    rowId2,
+    fieldName1,
+    fieldName2
+  )
+  // required for referencing in view
+  this.type = FieldTypes.LINK
+  this.doc1 = {
+    tableId: tableId1,
+    fieldName: fieldName1,
+    rowId: rowId1,
+  }
+  this.doc2 = {
+    tableId: tableId2,
+    fieldName: fieldName2,
+    rowId: rowId2,
+  }
 }
 
 class LinkController {
-  _db: Database
-  _tableId?: string
-  _row?: Row
-  _table?: Table
-  _oldTable?: Table
-
-  constructor({ tableId, row, table, oldTable }: LinkControllerOpts) {
-    this._db = context.getAppDB()
+  constructor({ tableId, row, table, oldTable }) {
+    this._db = getAppDB()
     this._tableId = tableId
     this._row = row
     this._table = table
@@ -44,7 +70,7 @@ class LinkController {
       this._table =
         this._table == null ? await this._db.get(this._tableId) : this._table
     }
-    return this._table!
+    return this._table
   }
 
   /**
@@ -54,7 +80,7 @@ class LinkController {
    * @returns {Promise<boolean>} True if there are any linked fields, otherwise it will return
    * false.
    */
-  async doesTableHaveLinkedFields(table?: Table) {
+  async doesTableHaveLinkedFields(table = null) {
     if (table == null) {
       table = await this.table()
     }
@@ -70,7 +96,7 @@ class LinkController {
   /**
    * Utility function for main getLinkDocuments function - refer to it for functionality.
    */
-  getRowLinkDocs(rowId: string) {
+  getRowLinkDocs(rowId) {
     return getLinkDocuments({
       tableId: this._tableId,
       rowId,
@@ -81,23 +107,23 @@ class LinkController {
   /**
    * Utility function for main getLinkDocuments function - refer to it for functionality.
    */
-  async getTableLinkDocs() {
-    return (await getLinkDocuments({
+  getTableLinkDocs() {
+    return getLinkDocuments({
       tableId: this._tableId,
       includeDocs: IncludeDocs.INCLUDE,
-    })) as LinkDocument[]
+    })
   }
 
   /**
    * Makes sure the passed in table schema contains valid relationship structures.
    */
-  validateTable(table: Table) {
+  validateTable(table) {
     const usedAlready = []
     for (let schema of Object.values(table.schema)) {
       if (schema.type !== FieldTypes.LINK) {
         continue
       }
-      const unique = schema.tableId! + schema?.fieldName
+      const unique = schema.tableId + schema.fieldName
       if (usedAlready.indexOf(unique) !== -1) {
         throw new Error(
           "Cannot re-use the linked column name for a linked table."
@@ -110,7 +136,7 @@ class LinkController {
   /**
    * Returns whether the two link schemas are equal (in the important parts, not a pure equality check)
    */
-  areLinkSchemasEqual(linkSchema1: FieldSchema, linkSchema2: FieldSchema) {
+  areLinkSchemasEqual(linkSchema1, linkSchema2) {
     const compareFields = [
       "name",
       "type",
@@ -120,7 +146,6 @@ class LinkController {
       "relationshipType",
     ]
     for (let field of compareFields) {
-      // @ts-ignore
       if (linkSchema1[field] !== linkSchema2[field]) {
         return false
       }
@@ -132,7 +157,7 @@ class LinkController {
    * Given the link field of this table, and the link field of the linked table, this makes sure
    * the state of relationship type is accurate on both.
    */
-  handleRelationshipType(linkerField: FieldSchema, linkedField: FieldSchema) {
+  handleRelationshipType(linkerField, linkedField) {
     if (
       !linkerField.relationshipType ||
       linkerField.relationshipType === RelationshipTypes.MANY_TO_MANY
@@ -159,10 +184,10 @@ class LinkController {
    */
   async rowSaved() {
     const table = await this.table()
-    const row = this._row!
+    const row = this._row
     const operations = []
     // get link docs to compare against
-    const linkDocs = (await this.getRowLinkDocs(row._id!)) as LinkDocument[]
+    const linkDocs = await this.getRowLinkDocs(row._id)
     for (let fieldName of Object.keys(table.schema)) {
       // get the links this row wants to make
       const rowField = row[fieldName]
@@ -182,32 +207,30 @@ class LinkController {
 
         // if 1:N, ensure that this ID is not already attached to another record
         const linkedTable = await this._db.get(field.tableId)
-        const linkedSchema = linkedTable.schema[field.fieldName!]
+        const linkedSchema = linkedTable.schema[field.fieldName]
 
         // We need to map the global users to metadata in each app for relationships
         if (field.tableId === InternalTables.USER_METADATA) {
           const users = await this._db.allDocs(getUserMetadataParams(null, {}))
           const metadataRequired = rowField.filter(
-            (userId: string) => !users.rows.some(user => user.id === userId)
+            userId => !users.rows.some(user => user.id === userId)
           )
 
           // ensure non-existing user metadata is created in the app DB
           await this._db.bulkDocs(
-            metadataRequired.map((userId: string) => ({ _id: userId }))
+            metadataRequired.map(userId => ({ _id: userId }))
           )
         }
 
         // iterate through the link IDs in the row field, see if any don't exist already
         for (let linkId of rowField) {
-          if (
-            linkedSchema?.relationshipType === RelationshipTypes.ONE_TO_MANY
-          ) {
+          if (linkedSchema.relationshipType === RelationshipTypes.ONE_TO_MANY) {
             let links = (
-              (await getLinkDocuments({
+              await getLinkDocuments({
                 tableId: field.tableId,
                 rowId: linkId,
                 includeDocs: IncludeDocs.EXCLUDE,
-              })) as LinkDocumentValue[]
+              })
             ).filter(
               link =>
                 link.id !== row._id && link.fieldName === linkedSchema.name
@@ -232,11 +255,11 @@ class LinkController {
             }
             operations.push(
               new LinkDocument(
-                table._id!,
+                table._id,
                 fieldName,
-                row._id!,
-                field.tableId!,
-                field.fieldName!,
+                row._id,
+                field.tableId,
+                field.fieldName,
                 linkId
               )
             )
@@ -269,9 +292,9 @@ class LinkController {
    * be accurate. This also returns the row that was deleted.
    */
   async rowDeleted() {
-    const row = this._row!
+    const row = this._row
     // need to get the full link docs to be be able to delete it
-    const linkDocs = await this.getRowLinkDocs(row._id!)
+    const linkDocs = await this.getRowLinkDocs(row._id)
     if (linkDocs.length === 0) {
       return null
     }
@@ -290,13 +313,13 @@ class LinkController {
    * @param {string} fieldName The field to be removed from the table.
    * @returns {Promise<void>} The table has now been updated.
    */
-  async removeFieldFromTable(fieldName: string) {
+  async removeFieldFromTable(fieldName) {
     let oldTable = this._oldTable
-    let field = oldTable?.schema[fieldName] as FieldSchema
+    let field = oldTable.schema[fieldName]
     const linkDocs = await this.getTableLinkDocs()
     let toDelete = linkDocs.filter(linkDoc => {
       let correctFieldName =
-        linkDoc.doc1.tableId === oldTable?._id
+        linkDoc.doc1.tableId === oldTable._id
           ? linkDoc.doc1.fieldName
           : linkDoc.doc2.fieldName
       return correctFieldName === fieldName
@@ -311,9 +334,7 @@ class LinkController {
     )
     // remove schema from other table
     let linkedTable = await this._db.get(field.tableId)
-    if (field.fieldName) {
-      delete linkedTable.schema[field.fieldName]
-    }
+    delete linkedTable.schema[field.fieldName]
     await this._db.put(linkedTable)
   }
 
@@ -330,7 +351,7 @@ class LinkController {
     const schema = table.schema
     for (let fieldName of Object.keys(schema)) {
       const field = schema[fieldName]
-      if (field.type === FieldTypes.LINK && field.fieldName) {
+      if (field.type === FieldTypes.LINK) {
         // handle this in a separate try catch, want
         // the put to bubble up as an error, if can't update
         // table for some reason
@@ -387,8 +408,8 @@ class LinkController {
     const oldTable = this._oldTable
     // first start by checking if any link columns have been deleted
     const newTable = await this.table()
-    for (let fieldName of Object.keys(oldTable?.schema || {})) {
-      const field = oldTable?.schema[fieldName] as FieldSchema
+    for (let fieldName of Object.keys(oldTable.schema)) {
+      const field = oldTable.schema[fieldName]
       // this field has been removed from the table schema
       if (
         field.type === FieldTypes.LINK &&
@@ -414,7 +435,7 @@ class LinkController {
     for (let fieldName of Object.keys(schema)) {
       const field = schema[fieldName]
       try {
-        if (field.type === FieldTypes.LINK && field.fieldName) {
+        if (field.type === FieldTypes.LINK) {
           const linkedTable = await this._db.get(field.tableId)
           delete linkedTable.schema[field.fieldName]
           await this._db.put(linkedTable)
@@ -441,4 +462,4 @@ class LinkController {
   }
 }
 
-export = LinkController
+module.exports = LinkController

package/src/db/linkedRows/{index.ts → index.js}

@@ -1,5 +1,5 @@
-import LinkController from "./LinkController"
-import {
+const LinkController = require("./LinkController")
+const {
   IncludeDocs,
   getLinkDocuments,
   createLinkView,
@@ -7,24 +7,21 @@ import {
   getRelatedTableForField,
   getLinkedTableIDs,
   getLinkedTable,
-} from "./linkUtils"
-import { flatten } from "lodash"
-import { FieldTypes } from "../../constants"
-import { getMultiIDParams, USER_METDATA_PREFIX } from "../utils"
-import { partition } from "lodash"
-import { getGlobalUsersFromMetadata } from "../../utilities/global"
-import { processFormulas } from "../../utilities/rowProcessor"
-import { context } from "@budibase/backend-core"
-import { Table, Row, LinkDocumentValue } from "@budibase/types"
-
-export { IncludeDocs, getLinkDocuments, createLinkView } from "./linkUtils"
+} = require("./linkUtils")
+const { flatten } = require("lodash")
+const { FieldTypes } = require("../../constants")
+const { getMultiIDParams, USER_METDATA_PREFIX } = require("../../db/utils")
+const { partition } = require("lodash")
+const { getGlobalUsersFromMetadata } = require("../../utilities/global")
+const { processFormulas } = require("../../utilities/rowProcessor/utils")
+const { getAppDB } = require("@budibase/backend-core/context")
 
 /**
  * This functionality makes sure that when rows with links are created, updated or deleted they are processed
  * correctly - making sure that no stale links are left around and that all links have been made successfully.
  */
 
-export const EventType = {
+const EventType = {
   ROW_SAVE: "row:save",
   ROW_UPDATE: "row:update",
   ROW_DELETE: "row:delete",
@@ -33,7 +30,13 @@ export const EventType = {
   TABLE_DELETE: "table:delete",
 }
 
-function clearRelationshipFields(table: Table, rows: Row[]) {
+exports.EventType = EventType
+// re-export search here for ease of use
+exports.IncludeDocs = IncludeDocs
+exports.getLinkDocuments = getLinkDocuments
+exports.createLinkView = createLinkView
+
+function clearRelationshipFields(table, rows) {
   for (let [key, field] of Object.entries(table.schema)) {
     if (field.type === FieldTypes.LINK) {
       rows = rows.map(row => {
@@ -45,17 +48,18 @@ function clearRelationshipFields(table: Table, rows: Row[]) {
   return rows
 }
 
-async function getLinksForRows(rows: Row[]) {
+async function getLinksForRows(rows) {
   const tableIds = [...new Set(rows.map(el => el.tableId))]
   // start by getting all the link values for performance reasons
-  const promises = tableIds.map(tableId =>
-    getLinkDocuments({
-      tableId: tableId,
-      includeDocs: IncludeDocs.EXCLUDE,
-    })
-  )
   const responses = flatten(
-    (await Promise.all(promises)) as LinkDocumentValue[][]
+    await Promise.all(
+      tableIds.map(tableId =>
+        getLinkDocuments({
+          tableId: tableId,
+          includeDocs: IncludeDocs.EXCLUDE,
+        })
+      )
+    )
   )
   // have to get unique as the previous table query can
   // return duplicates, could be querying for both tables in a relation
@@ -68,9 +72,9 @@ async function getLinksForRows(rows: Row[]) {
   )
 }
 
-async function getFullLinkedDocs(links: LinkDocumentValue[]) {
+async function getFullLinkedDocs(links) {
   // create DBs
-  const db = context.getAppDB()
+  const db = getAppDB()
   const linkedRowIds = links.map(link => link.id)
   const uniqueRowIds = [...new Set(linkedRowIds)]
   let dbRows = (await db.allDocs(getMultiIDParams(uniqueRowIds))).rows.map(
@@ -99,18 +103,12 @@ async function getFullLinkedDocs(links: LinkDocumentValue[]) {
  * @returns {Promise<object>} When the update is complete this will respond successfully. Returns the row for
  * row operations and the table for table operations.
  */
-export async function updateLinks(args: {
-  tableId?: string
-  eventType: string
-  row?: Row
-  table?: Table
-  oldTable?: Table
-}) {
+exports.updateLinks = async function (args) {
   const { eventType, row, tableId, table, oldTable } = args
   const baseReturnObj = row == null ? table : row
   // make sure table ID is set
   if (tableId == null && table != null) {
-    args.tableId = table._id!
+    args.tableId = table._id
   }
   let linkController = new LinkController(args)
   try {
@@ -148,7 +146,7 @@ export async function updateLinks(args: {
  * @param {array<object>} rows The rows which are to be enriched.
  * @return {Promise<*>} returns the rows with all of the enriched relationships on it.
  */
-export async function attachFullLinkedDocs(table: Table, rows: Row[]) {
+exports.attachFullLinkedDocs = async (table, rows) => {
   const linkedTableIds = getLinkedTableIDs(table)
   if (linkedTableIds.length === 0) {
     return rows
@@ -161,7 +159,7 @@ export async function attachFullLinkedDocs(table: Table, rows: Row[]) {
   rows = clearRelationshipFields(table, rows)
   // now get the docs and combine into the rows
   let linked = await getFullLinkedDocs(links)
-  const linkedTables: Table[] = []
+  const linkedTables = []
   for (let row of rows) {
     for (let link of links.filter(link => link.thisId === row._id)) {
       if (row[link.fieldName] == null) {
@@ -187,16 +185,13 @@ export async function attachFullLinkedDocs(table: Table, rows: Row[]) {
  * @param {array<object>} enriched The pre-enriched rows (full docs) which are to be squashed.
  * @returns {Promise<Array>} The rows after having their links squashed to only contain the ID and primary display.
  */
-export async function squashLinksToPrimaryDisplay(
-  table: Table,
-  enriched: Row[]
-) {
+exports.squashLinksToPrimaryDisplay = async (table, enriched) => {
   // will populate this as we find them
   const linkedTables = [table]
   for (let row of enriched) {
     // this only fetches the table if its not already in array
-    const rowTable = await getLinkedTable(row.tableId!, linkedTables)
-    for (let [column, schema] of Object.entries(rowTable?.schema || {})) {
+    const rowTable = await getLinkedTable(row.tableId, linkedTables)
+    for (let [column, schema] of Object.entries(rowTable.schema)) {
       if (schema.type !== FieldTypes.LINK || !Array.isArray(row[column])) {
         continue
       }
@@ -204,8 +199,8 @@ export async function squashLinksToPrimaryDisplay(
       for (let link of row[column]) {
         const linkTblId = link.tableId || getRelatedTableForField(table, column)
         const linkedTable = await getLinkedTable(linkTblId, linkedTables)
-        const obj: any = { _id: link._id }
-        if (linkedTable?.primaryDisplay && link[linkedTable.primaryDisplay]) {
+        const obj = { _id: link._id }
+        if (link[linkedTable.primaryDisplay]) {
           obj.primaryDisplay = link[linkedTable.primaryDisplay]
         }
         newLinks.push(obj)

package/src/db/linkedRows/{linkUtils.ts → linkUtils.js}

@@ -1,24 +1,20 @@
-import { ViewName, getQueryIndex } from "../utils"
-import { FieldTypes } from "../../constants"
-import { createLinkView } from "../views/staticViews"
-import { context, logging } from "@budibase/backend-core"
-import {
-  FieldSchema,
-  LinkDocument,
-  LinkDocumentValue,
-  Table,
-} from "@budibase/types"
-export { createLinkView } from "../views/staticViews"
+const Sentry = require("@sentry/node")
+const { ViewName, getQueryIndex } = require("../utils")
+const { FieldTypes } = require("../../constants")
+const { createLinkView } = require("../views/staticViews")
+const { getAppDB } = require("@budibase/backend-core/context")
 
 /**
  * Only needed so that boolean parameters are being used for includeDocs
  * @type {{EXCLUDE: boolean, INCLUDE: boolean}}
  */
-export const IncludeDocs = {
+exports.IncludeDocs = {
   INCLUDE: true,
   EXCLUDE: false,
 }
 
+exports.createLinkView = createLinkView
+
 /**
  * Gets the linking documents, not the linked documents themselves.
  * @param {string} args.tableId The table which we are searching for linked rows against.
@@ -32,14 +28,10 @@ export const IncludeDocs = {
  * @returns {Promise<object[]>} This will return an array of the linking documents that were found
  * (if any).
  */
-export async function getLinkDocuments(args: {
-  tableId?: string
-  rowId?: string
-  includeDocs?: any
-}): Promise<LinkDocumentValue[] | LinkDocument[]> {
+exports.getLinkDocuments = async function (args) {
   const { tableId, rowId, includeDocs } = args
-  const db = context.getAppDB()
-  let params: any
+  const db = getAppDB()
+  let params
   if (rowId != null) {
     params = { key: [tableId, rowId] }
   }
@@ -51,7 +43,7 @@ export async function getLinkDocuments(args: {
   try {
     let linkRows = (await db.query(getQueryIndex(ViewName.LINK), params)).rows
     // filter to get unique entries
-    const foundIds: string[] = []
+    const foundIds = []
     linkRows = linkRows.filter(link => {
       // make sure anything unique is the correct key
       if (
@@ -68,37 +60,36 @@ export async function getLinkDocuments(args: {
     })
 
     if (includeDocs) {
-      return linkRows.map(row => row.doc) as LinkDocument[]
+      return linkRows.map(row => row.doc)
     } else {
-      return linkRows.map(row => row.value) as LinkDocumentValue[]
+      return linkRows.map(row => row.value)
     }
-  } catch (err: any) {
+  } catch (err) {
     // check if the view doesn't exist, it should for all new instances
     if (err != null && err.name === "not_found") {
-      await createLinkView()
-      return getLinkDocuments(arguments[0])
+      await exports.createLinkView()
+      return exports.getLinkDocuments(arguments[0])
     } else {
       /* istanbul ignore next */
-      logging.logAlert("Failed to get link documents", err)
-      throw err
+      Sentry.captureException(err)
     }
   }
 }
 
-export function getUniqueByProp(array: any[], prop: string) {
+exports.getUniqueByProp = (array, prop) => {
   return array.filter((obj, pos, arr) => {
     return arr.map(mapObj => mapObj[prop]).indexOf(obj[prop]) === pos
   })
 }
 
-export function getLinkedTableIDs(table: Table) {
+exports.getLinkedTableIDs = table => {
   return Object.values(table.schema)
-    .filter((column: FieldSchema) => column.type === FieldTypes.LINK)
+    .filter(column => column.type === FieldTypes.LINK)
     .map(column => column.tableId)
 }
 
-export async function getLinkedTable(id: string, tables: Table[]) {
-  const db = context.getAppDB()
+exports.getLinkedTable = async (id, tables) => {
+  const db = getAppDB()
   let linkedTable = tables.find(table => table._id === id)
   if (linkedTable) {
     return linkedTable
@@ -110,7 +101,7 @@ export async function getLinkedTable(id: string, tables: Table[]) {
   return linkedTable
 }
 
-export function getRelatedTableForField(table: Table, fieldName: string) {
+exports.getRelatedTableForField = (table, fieldName) => {
   // look to see if its on the table, straight in the schema
   const field = table.schema[fieldName]
   if (field != null) {

package/src/db/{newid.ts → newid.js}

@@ -1,5 +1,5 @@
 const { v4 } = require("uuid")
 
-export = function (): string {
+module.exports = function () {
   return v4().replace(/-/g, "")
 }