@budibase/server 0.0.32 → 0.0.999-alpha.30

package/src/db/linkedRows/index.ts

@@ -0,0 +1,217 @@
+import LinkController from "./LinkController"
+import {
+  IncludeDocs,
+  getLinkDocuments,
+  createLinkView,
+  getUniqueByProp,
+  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"
+
+/**
+ * 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 = {
+  ROW_SAVE: "row:save",
+  ROW_UPDATE: "row:update",
+  ROW_DELETE: "row:delete",
+  TABLE_SAVE: "table:save",
+  TABLE_UPDATED: "table:updated",
+  TABLE_DELETE: "table:delete",
+}
+
+function clearRelationshipFields(table: Table, rows: Row[]) {
+  for (let [key, field] of Object.entries(table.schema)) {
+    if (field.type === FieldTypes.LINK) {
+      rows = rows.map(row => {
+        delete row[key]
+        return row
+      })
+    }
+  }
+  return rows
+}
+
+async function getLinksForRows(rows: Row[]) {
+  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[][]
+  )
+  // have to get unique as the previous table query can
+  // return duplicates, could be querying for both tables in a relation
+  return getUniqueByProp(
+    responses
+      .filter(el => el != null)
+      // create a unique ID which we can use for getting only unique ones
+      .map(el => ({ ...el, unique: el.id + el.thisId + el.fieldName })),
+    "unique"
+  )
+}
+
+async function getFullLinkedDocs(links: LinkDocumentValue[]) {
+  // create DBs
+  const db = context.getAppDB()
+  const linkedRowIds = links.map(link => link.id)
+  const uniqueRowIds = [...new Set(linkedRowIds)]
+  let dbRows = (await db.allDocs(getMultiIDParams(uniqueRowIds))).rows.map(
+    row => row.doc
+  )
+  // convert the unique db rows back to a full list of linked rows
+  const linked = linkedRowIds
+    .map(id => dbRows.find(row => row && row._id === id))
+    .filter(row => row != null)
+  // need to handle users as specific cases
+  let [users, other] = partition(linked, linkRow =>
+    linkRow._id.startsWith(USER_METDATA_PREFIX)
+  )
+  users = await getGlobalUsersFromMetadata(users)
+  return [...other, ...users]
+}
+
+/**
+ * Update link documents for a row or table - this is to be called by the API controller when a change is occurring.
+ * @param {string} args.eventType states what type of change which is occurring, means this can be expanded upon in the
+ * future quite easily (all updates go through one function).
+ * @param {string} args.tableId The ID of the of the table which is being changed.
+ * @param {object|undefined} args.row The row which is changing, e.g. created, updated or deleted.
+ * @param {object|undefined} args.table If the table has already been retrieved this can be used to reduce database gets.
+ * @param {object|undefined} args.oldTable If the table is being updated then the old table can be provided for differencing.
+ * @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
+}) {
+  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!
+  }
+  let linkController = new LinkController(args)
+  try {
+    if (
+      !(await linkController.doesTableHaveLinkedFields(table)) &&
+      (oldTable == null ||
+        !(await linkController.doesTableHaveLinkedFields(oldTable)))
+    ) {
+      return baseReturnObj
+    }
+  } catch (err) {
+    return baseReturnObj
+  }
+  switch (eventType) {
+    case EventType.ROW_SAVE:
+    case EventType.ROW_UPDATE:
+      return await linkController.rowSaved()
+    case EventType.ROW_DELETE:
+      return await linkController.rowDeleted()
+    case EventType.TABLE_SAVE:
+      return await linkController.tableSaved()
+    case EventType.TABLE_UPDATED:
+      return await linkController.tableUpdated()
+    case EventType.TABLE_DELETE:
+      return await linkController.tableDeleted()
+    default:
+      throw "Type of event is not known, linked row handler requires update."
+  }
+}
+
+/**
+ * Given a table and a list of rows this will retrieve all of the attached docs and enrich them into the row.
+ * This is required for formula fields, this may only be utilised internally (for now).
+ * @param {object} table The table from which the rows originated.
+ * @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[]) {
+  const linkedTableIds = getLinkedTableIDs(table)
+  if (linkedTableIds.length === 0) {
+    return rows
+  }
+  // get all the links
+  const links = (await getLinksForRows(rows)).filter(link =>
+    rows.some(row => row._id === link.thisId)
+  )
+  // clear any existing links that could be dupe'd
+  rows = clearRelationshipFields(table, rows)
+  // now get the docs and combine into the rows
+  let linked = await getFullLinkedDocs(links)
+  const linkedTables: Table[] = []
+  for (let row of rows) {
+    for (let link of links.filter(link => link.thisId === row._id)) {
+      if (row[link.fieldName] == null) {
+        row[link.fieldName] = []
+      }
+      const linkedRow = linked.find(row => row._id === link.id)
+      if (linkedRow) {
+        const linkedTableId =
+          linkedRow.tableId || getRelatedTableForField(table, link.fieldName)
+        const linkedTable = await getLinkedTable(linkedTableId, linkedTables)
+        if (linkedTable) {
+          row[link.fieldName].push(processFormulas(linkedTable, linkedRow))
+        }
+      }
+    }
+  }
+  return rows
+}
+
+/**
+ * This function will take the given enriched rows and squash the links to only contain the primary display field.
+ * @param {object} table The table from which the rows originated.
+ * @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[]
+) {
+  // 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 || {})) {
+      if (schema.type !== FieldTypes.LINK || !Array.isArray(row[column])) {
+        continue
+      }
+      const newLinks = []
+      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]) {
+          obj.primaryDisplay = link[linkedTable.primaryDisplay]
+        }
+        newLinks.push(obj)
+      }
+      row[column] = newLinks
+    }
+  }
+  return enriched
+}

package/src/db/linkedRows/linkUtils.ts

@@ -0,0 +1,125 @@
+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"
+
+/**
+ * Only needed so that boolean parameters are being used for includeDocs
+ * @type {{EXCLUDE: boolean, INCLUDE: boolean}}
+ */
+export const IncludeDocs = {
+  INCLUDE: true,
+  EXCLUDE: false,
+}
+
+/**
+ * Gets the linking documents, not the linked documents themselves.
+ * @param {string} args.tableId The table which we are searching for linked rows against.
+ * @param {string|null} args.fieldName The name of column/field which is being altered, only looking for
+ * linking documents that are related to it. If this is not specified then the table level will be assumed.
+ * @param {string|null} args.rowId The ID of the row which we want to find linking documents for -
+ * if this is not specified then it will assume table or field level depending on whether the
+ * field name has been specified.
+ * @param {boolean|null} args.includeDocs whether to include docs in the response call, this is considerably slower so only
+ * use this if actually interested in the docs themselves.
+ * @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[]> {
+  const { tableId, rowId, includeDocs } = args
+  const db = context.getAppDB()
+  let params: any
+  if (rowId != null) {
+    params = { key: [tableId, rowId] }
+  }
+  // only table is known
+  else {
+    params = { startKey: [tableId], endKey: [tableId, {}] }
+  }
+  params.include_docs = !!includeDocs
+  try {
+    let linkRows = (await db.query(getQueryIndex(ViewName.LINK), params)).rows
+    // filter to get unique entries
+    const foundIds: string[] = []
+    linkRows = linkRows.filter(link => {
+      // make sure anything unique is the correct key
+      if (
+        (tableId && link.key[0] !== tableId) ||
+        (rowId && link.key[1] !== rowId)
+      ) {
+        return false
+      }
+      const unique = foundIds.indexOf(link.id) === -1
+      if (unique) {
+        foundIds.push(link.id)
+      }
+      return unique
+    })
+
+    if (includeDocs) {
+      return linkRows.map(row => row.doc) as LinkDocument[]
+    } else {
+      return linkRows.map(row => row.value) as LinkDocumentValue[]
+    }
+  } catch (err: any) {
+    // 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])
+    } else {
+      /* istanbul ignore next */
+      logging.logAlert("Failed to get link documents", err)
+      throw err
+    }
+  }
+}
+
+export function getUniqueByProp(array: any[], prop: string) {
+  return array.filter((obj, pos, arr) => {
+    return arr.map(mapObj => mapObj[prop]).indexOf(obj[prop]) === pos
+  })
+}
+
+export function getLinkedTableIDs(table: Table) {
+  return Object.values(table.schema)
+    .filter((column: FieldSchema) => column.type === FieldTypes.LINK)
+    .map(column => column.tableId)
+}
+
+export async function getLinkedTable(id: string, tables: Table[]) {
+  const db = context.getAppDB()
+  let linkedTable = tables.find(table => table._id === id)
+  if (linkedTable) {
+    return linkedTable
+  }
+  linkedTable = await db.get(id)
+  if (linkedTable) {
+    tables.push(linkedTable)
+  }
+  return linkedTable
+}
+
+export function getRelatedTableForField(table: Table, fieldName: string) {
+  // look to see if its on the table, straight in the schema
+  const field = table.schema[fieldName]
+  if (field != null) {
+    return field.tableId
+  }
+  for (let column of Object.values(table.schema)) {
+    if (column.type === FieldTypes.LINK && column.fieldName === fieldName) {
+      return column.tableId
+    }
+  }
+  return null
+}

package/src/db/newid.ts

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

package/src/db/tests/linkController.spec.js

@@ -0,0 +1,236 @@
+const TestConfig = require("../../tests/utilities/TestConfiguration")
+const { basicRow, basicLinkedRow, basicTable } = require("../../tests/utilities/structures")
+const LinkController = require("../linkedRows/LinkController").default
+const { context } = require("@budibase/backend-core")
+const { RelationshipTypes } = require("../../constants")
+const { cloneDeep } = require("lodash/fp")
+
+describe("test the link controller", () => {
+  let config = new TestConfig(false)
+  let table1, table2, appId
+
+  beforeAll(async () => {
+    const app = await config.init()
+    appId = app.appId
+  })
+
+  beforeEach(async () => {
+    const { _id } = await config.createTable()
+    table2 = await config.createLinkedTable(RelationshipTypes.MANY_TO_MANY, ["link", "link2"])
+    // update table after creating link
+    table1 = await config.getTable(_id)
+  })
+
+  afterAll(config.end)
+
+  async function createLinkController(table, row = null, oldTable = null) {
+    return context.doInAppContext(appId, () => {
+      const linkConfig = {
+        tableId: table._id,
+        table,
+      }
+      if (row) {
+        linkConfig.row = row
+      }
+      if (oldTable) {
+        linkConfig.oldTable = oldTable
+      }
+      return new LinkController(linkConfig)
+    })
+  }
+
+  async function createLinkedRow(linkField = "link", t1 = table1, t2 = table2) {
+    const row = await config.createRow(basicRow(t2._id))
+    const { _id } = await config.createRow(basicLinkedRow(t1._id, row._id, linkField))
+    return config.getRow(t1._id, _id)
+  }
+
+  it("should be able to confirm if two table schemas are equal", async () => {
+    const controller = await createLinkController(table1)
+    let equal = controller.areLinkSchemasEqual(table2.schema.link, table2.schema.link)
+    expect(equal).toEqual(true)
+    equal = controller.areLinkSchemasEqual(table1.schema.link, table2.schema.link)
+    expect(equal).toEqual(false)
+  })
+
+  it("should be able to check the relationship types across two fields", async () => {
+    const controller = await createLinkController(table1)
+    // empty case
+    let output = controller.handleRelationshipType({}, {})
+    expect(output.linkedField.relationshipType).toEqual(RelationshipTypes.MANY_TO_MANY)
+    expect(output.linkerField.relationshipType).toEqual(RelationshipTypes.MANY_TO_MANY)
+    output = controller.handleRelationshipType({ relationshipType: RelationshipTypes.MANY_TO_MANY }, {})
+    expect(output.linkedField.relationshipType).toEqual(RelationshipTypes.MANY_TO_MANY)
+    expect(output.linkerField.relationshipType).toEqual(RelationshipTypes.MANY_TO_MANY)
+    output = controller.handleRelationshipType({ relationshipType: RelationshipTypes.MANY_TO_ONE }, {})
+    expect(output.linkedField.relationshipType).toEqual(RelationshipTypes.ONE_TO_MANY)
+    expect(output.linkerField.relationshipType).toEqual(RelationshipTypes.MANY_TO_ONE)
+    output = controller.handleRelationshipType({ relationshipType: RelationshipTypes.ONE_TO_MANY }, {})
+    expect(output.linkedField.relationshipType).toEqual(RelationshipTypes.MANY_TO_ONE)
+    expect(output.linkerField.relationshipType).toEqual(RelationshipTypes.ONE_TO_MANY)
+  })
+
+  it("should be able to delete a row", async () => {
+    const row = await createLinkedRow()
+    const controller = await createLinkController(table1, row)
+    await context.doInAppContext(appId, async () => {
+      // get initial count
+      const beforeLinks = await controller.getRowLinkDocs(row._id)
+      await controller.rowDeleted()
+      let afterLinks = await controller.getRowLinkDocs(row._id)
+      expect(beforeLinks.length).toEqual(1)
+      expect(afterLinks.length).toEqual(0)
+    })
+  })
+
+  it("shouldn't throw an error when deleting a row with no links", async () => {
+    const row = await config.createRow(basicRow(table1._id))
+    const controller = await createLinkController(table1, row)
+    await context.doInAppContext(appId, async () => {
+      let error
+      try {
+        await controller.rowDeleted()
+      } catch (err) {
+        error = err
+      }
+      expect(error).toBeUndefined()
+    })
+  })
+
+  it("should throw an error when validating a table which is invalid", async () => {
+    const controller = await createLinkController(table1)
+    const copyTable = {
+      ...table1
+    }
+    copyTable.schema.otherTableLink = {
+      type: "link",
+      fieldName: "link",
+      tableId: table2._id,
+    }
+    let error
+    try {
+      controller.validateTable(copyTable)
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeDefined()
+    expect(error.message).toEqual("Cannot re-use the linked column name for a linked table.")
+  })
+
+  it("should be able to remove a link when saving/updating the row", async () => {
+    const row = await createLinkedRow()
+    // remove the link from the row
+    row.link = []
+    const controller = await createLinkController(table1, row)
+    await context.doInAppContext(appId, async () => {
+      await controller.rowSaved()
+      let links = await controller.getRowLinkDocs(row._id)
+      expect(links.length).toEqual(0)
+    })
+  })
+
+  it("should be able to delete a table and have links deleted", async () => {
+    await createLinkedRow()
+    const controller = await createLinkController(table1)
+    await context.doInAppContext(appId, async () => {
+      let before = await controller.getTableLinkDocs()
+      await controller.tableDeleted()
+      let after = await controller.getTableLinkDocs()
+      expect(before.length).toEqual(1)
+      expect(after.length).toEqual(0)
+    })
+  })
+
+  it("should be able to remove a linked field from a table", async () => {
+    await createLinkedRow()
+    await createLinkedRow("link2")
+    const controller = await createLinkController(table1, null, table1)
+    await context.doInAppContext(appId, async () => {
+      let before = await controller.getTableLinkDocs()
+      await controller.removeFieldFromTable("link")
+      let after = await controller.getTableLinkDocs()
+      expect(before.length).toEqual(2)
+      // shouldn't delete the other field
+      expect(after.length).toEqual(1)
+    })
+  })
+
+  it("should throw an error when overwriting a link column", async () => {
+    const update = cloneDeep(table1)
+    update.schema.link.relationshipType = RelationshipTypes.MANY_TO_ONE
+    let error
+    try {
+      const controller = await createLinkController(update)
+      await controller.tableSaved()
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeDefined()
+  })
+
+  it("should be able to remove a field view table update", async () => {
+    await createLinkedRow()
+    await createLinkedRow()
+    const newTable = cloneDeep(table1)
+    delete newTable.schema.link
+    const controller = await createLinkController(newTable, null, table1)
+    await context.doInAppContext(appId, async () => {
+      await controller.tableUpdated()
+      const links = await controller.getTableLinkDocs()
+      expect(links.length).toEqual(0)
+    })
+  })
+
+  it("shouldn't allow one to many having many relationships against it", async () => {
+    const firstTable = await config.createTable()
+    const { _id } = await config.createLinkedTable(RelationshipTypes.MANY_TO_ONE, ["link"])
+    const linkTable = await config.getTable(_id)
+    // an initial row to link around
+    const row = await createLinkedRow("link", linkTable, firstTable)
+    let error
+    try {
+      // create another row to initiate the error
+      await config.createRow(basicLinkedRow(row.tableId, row.link[0]))
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeDefined()
+  })
+
+  it("should not error if a link being created doesn't exist", async () => {
+    let error
+    try {
+      await config.createRow(basicLinkedRow(table1._id, "invalid"))
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeUndefined()
+  })
+
+  it("make sure auto column goes onto other row too", async () => {
+    const table = await config.createTable()
+    const tableCfg = basicTable()
+    tableCfg.schema.link = {
+      type: "link",
+      fieldName: "link",
+      tableId: table._id,
+      name: "link",
+      autocolumn: true,
+    }
+    await config.createTable(tableCfg)
+    const afterTable = await config.getTable(table._id)
+    expect(afterTable.schema.link.autocolumn).toBe(true)
+  })
+
+  it("should be able to link to self", async () => {
+    const table = await config.createTable()
+    table.schema.link = {
+      type: "link",
+      fieldName: "link",
+      tableId: table._id,
+      name: "link",
+      autocolumn: true,
+    }
+    await config.updateTable(table)
+  })
+})

package/src/db/tests/linkTests.spec.js

@@ -0,0 +1,65 @@
+const TestConfig = require("../../tests/utilities/TestConfiguration")
+const { basicTable } = require("../../tests/utilities/structures")
+const linkUtils = require("../linkedRows/linkUtils")
+const { context } = require("@budibase/backend-core")
+
+describe("test link functionality", () => {
+  const config = new TestConfig(false)
+  let appId
+
+  describe("getLinkedTable", () => {
+    let table
+    beforeAll(async () => {
+      const app = await config.init()
+      appId = app.appId
+      table = await config.createTable()
+    })
+
+    it("should be able to retrieve a linked table from a list", async () => {
+      await context.doInAppContext(appId, async () => {
+        const retrieved = await linkUtils.getLinkedTable(table._id, [table])
+        expect(retrieved._id).toBe(table._id)
+      })
+    })
+
+    it("should be able to retrieve a table from DB and update list", async () => {
+      const tables = []
+      await context.doInAppContext(appId, async () => {
+        const retrieved = await linkUtils.getLinkedTable(table._id, tables)
+        expect(retrieved._id).toBe(table._id)
+        expect(tables[0]).toBeDefined()
+      })
+    })
+  })
+
+  describe("getRelatedTableForField", () => {
+    let link = basicTable()
+    link.schema.link = {
+      fieldName: "otherLink",
+      tableId: "tableID",
+      type: "link",
+    }
+
+    it("should get the field from the table directly", () => {
+      expect(linkUtils.getRelatedTableForField(link, "link")).toBe("tableID")
+    })
+
+    it("should get the field from the link", () => {
+      expect(linkUtils.getRelatedTableForField(link, "otherLink")).toBe("tableID")
+    })
+  })
+
+  describe("getLinkDocuments", () => {
+    it("should create the link view when it doesn't exist", async () => {
+      // create the DB and a very basic app design DB
+      await context.doInAppContext(appId, async () => {
+        const output = await linkUtils.getLinkDocuments({
+          tableId: "test",
+          rowId: "test",
+          includeDocs: false,
+        })
+        expect(Array.isArray(output)).toBe(true)
+      })
+    })
+  })
+})