@budibase/server 1.0.49-alpha.9 → 1.0.49

package/dist/utilities/usageQuota/rows.js

@@ -1,78 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-const { getRowParams, USER_METDATA_PREFIX } = require("../../db/utils");
-const CouchDB = require("../../db");
-const { isDevAppID, getDevelopmentAppID } = require("@budibase/backend-core/db");
-const ROW_EXCLUSIONS = [USER_METDATA_PREFIX];
-const getAppPairs = appIds => {
-    // collect the app ids into dev / prod pairs
-    // keyed by the dev app id
-    const pairs = {};
-    for (let appId of appIds) {
-        const devId = getDevelopmentAppID(appId);
-        if (!pairs[devId]) {
-            pairs[devId] = {};
-        }
-        if (isDevAppID(appId)) {
-            pairs[devId].devId = appId;
-        }
-        else {
-            pairs[devId].prodId = appId;
-        }
-    }
-    return pairs;
-};
-const getAppRows = (appId) => __awaiter(void 0, void 0, void 0, function* () {
-    // need to specify the app ID, as this is used for different apps in one call
-    const appDb = new CouchDB(appId);
-    const response = yield appDb.allDocs(getRowParams(null, null, {
-        include_docs: false,
-    }));
-    return response.rows
-        .map(r => r.id)
-        .filter(id => {
-        for (let exclusion of ROW_EXCLUSIONS) {
-            if (id.startsWith(exclusion)) {
-                return false;
-            }
-        }
-        return true;
-    });
-});
-/**
- * Return a set of all rows in the given app ids.
- * The returned rows will be unique on a per dev/prod app basis.
- * Rows duplicates may exist across apps due to data import so they are not filtered out.
- */
-exports.getUniqueRows = (appIds) => __awaiter(void 0, void 0, void 0, function* () {
-    let uniqueRows = [];
-    const pairs = getAppPairs(appIds);
-    for (let pair of Object.values(pairs)) {
-        let appRows = [];
-        for (let appId of [pair.devId, pair.prodId]) {
-            if (!appId) {
-                continue;
-            }
-            try {
-                appRows.push(yield getAppRows(appId));
-            }
-            catch (e) {
-                console.error(e);
-                // don't error out if we can't count the app rows, just continue
-            }
-        }
-        // ensure uniqueness on a per app pair basis
-        // this can't be done on all rows because app import results in
-        // duplicate row ids across apps
-        uniqueRows = uniqueRows.concat(...new Set(appRows));
-    }
-    return uniqueRows;
-});

package/dist/utilities/usageQuota/usageQuoteReset.js

@@ -1,16 +0,0 @@
-"use strict";
-// UNUSED CODE
-// Preserved for future use
-/* eslint-disable no-unused-vars */
-function getNewQuotaReset() {
-    return Date.now() + 2592000000;
-}
-function resetQuotasIfRequired(quota) {
-    // Check if the quota needs reset
-    if (Date.now() >= quota.quotaReset) {
-        quota.quotaReset = getNewQuotaReset();
-        for (let prop of Object.keys(quota.usageQuota)) {
-            quota.usageQuota[prop] = 0;
-        }
-    }
-}

package/src/api/controllers/migrations.js

@@ -1,13 +0,0 @@
-const { migrate, MIGRATIONS } = require("../../migrations")
-
-exports.migrate = async ctx => {
-  const options = ctx.request.body
-  // don't await as can take a while, just return
-  migrate(options)
-  ctx.status = 200
-}
-
-exports.fetchDefinitions = async ctx => {
-  ctx.body = MIGRATIONS
-  ctx.status = 200
-}

package/src/api/controllers/row/staticFormula.js

@@ -1,156 +0,0 @@
-const { getRowParams } = require("../../../db/utils")
-const {
-  outputProcessing,
-  processAutoColumn,
-  processFormulas,
-} = require("../../../utilities/rowProcessor")
-const { FieldTypes, FormulaTypes } = require("../../../constants")
-const { isEqual } = require("lodash")
-const { cloneDeep } = require("lodash/fp")
-const { getAppDB } = require("@budibase/backend-core/context")
-
-/**
- * This function runs through a list of enriched rows, looks at the rows which
- * are related and then checks if they need the state of their formulas
- * updated.
- * NOTE: this will only for affect static formulas.
- */
-exports.updateRelatedFormula = async (table, enrichedRows) => {
-  const db = getAppDB()
-  // no formula to update, we're done
-  if (!table.relatedFormula) {
-    return
-  }
-  let promises = []
-  for (let enrichedRow of Array.isArray(enrichedRows)
-    ? enrichedRows
-    : [enrichedRows]) {
-    // the related rows by tableId
-    let relatedRows = {}
-    for (let [key, field] of Object.entries(enrichedRow)) {
-      const columnDefinition = table.schema[key]
-      if (columnDefinition && columnDefinition.type === FieldTypes.LINK) {
-        const relatedTableId = columnDefinition.tableId
-        if (!relatedRows[relatedTableId]) {
-          relatedRows[relatedTableId] = []
-        }
-        relatedRows[relatedTableId] = relatedRows[relatedTableId].concat(field)
-      }
-    }
-    for (let tableId of table.relatedFormula) {
-      let relatedTable
-      try {
-        // no rows to update, skip
-        if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
-          continue
-        }
-        relatedTable = await db.get(tableId)
-      } catch (err) {
-        // no error scenario, table doesn't seem to exist anymore, ignore
-      }
-      for (let column of Object.values(relatedTable.schema)) {
-        // needs updated in related rows
-        if (
-          column.type === FieldTypes.FORMULA &&
-          column.formulaType === FormulaTypes.STATIC
-        ) {
-          // re-enrich rows for all the related, don't update the related formula for them
-          promises = promises.concat(
-            relatedRows[tableId].map(related =>
-              exports.finaliseRow(relatedTable, related, {
-                updateFormula: false,
-              })
-            )
-          )
-        }
-      }
-    }
-  }
-  await Promise.all(promises)
-}
-
-exports.updateAllFormulasInTable = async table => {
-  const db = getAppDB()
-  // start by getting the raw rows (which will be written back to DB after update)
-  let rows = (
-    await db.allDocs(
-      getRowParams(table._id, null, {
-        include_docs: true,
-      })
-    )
-  ).rows.map(row => row.doc)
-  // now enrich the rows, note the clone so that we have the base state of the
-  // rows so that we don't write any of the enriched information back
-  let enrichedRows = await outputProcessing(table, cloneDeep(rows), {
-    squash: false,
-  })
-  const updatedRows = []
-  for (let row of rows) {
-    // find the enriched row, if found process the formulas
-    const enrichedRow = enrichedRows.find(enriched => enriched._id === row._id)
-    if (enrichedRow) {
-      const processed = processFormulas(table, cloneDeep(row), {
-        dynamic: false,
-        contextRows: enrichedRow,
-      })
-      // values have changed, need to add to bulk docs to update
-      if (!isEqual(processed, row)) {
-        updatedRows.push(processed)
-      }
-    }
-  }
-  await db.bulkDocs(updatedRows)
-}
-
-/**
- * This function runs at the end of the save/patch functions of the row controller, all this
- * really does is enrich the row, handle any static formula processing, then return the enriched
- * row. The reason we need to return the enriched row is that the automation row created trigger
- * expects the row to be totally enriched/contain all relationships.
- */
-exports.finaliseRow = async (
-  table,
-  row,
-  { oldTable, updateFormula } = { updateFormula: true }
-) => {
-  const db = getAppDB()
-  row.type = "row"
-  // process the row before return, to include relationships
-  let enrichedRow = await outputProcessing(table, cloneDeep(row), {
-    squash: false,
-  })
-  // use enriched row to generate formulas for saving, specifically only use as context
-  row = processFormulas(table, row, {
-    dynamic: false,
-    contextRows: enrichedRow,
-  })
-
-  // don't worry about rev, tables handle rev/lastID updates
-  // if another row has been written since processing this will
-  // handle the auto ID clash
-  if (oldTable && !isEqual(oldTable, table)) {
-    try {
-      await db.put(table)
-    } catch (err) {
-      if (err.status === 409) {
-        const updatedTable = await db.get(table._id)
-        let response = processAutoColumn(null, updatedTable, row, {
-          reprocessing: true,
-        })
-        await db.put(response.table)
-        row = response.row
-      } else {
-        throw err
-      }
-    }
-  }
-  const response = await db.put(row)
-  // for response, calculate the formulas for the enriched row
-  enrichedRow._rev = response.rev
-  enrichedRow = await processFormulas(table, enrichedRow, { dynamic: false })
-  // this updates the related formulas in other rows based on the relations to this row
-  if (updateFormula) {
-    await exports.updateRelatedFormula(table, enrichedRow)
-  }
-  return { row: enrichedRow, table }
-}

package/src/api/controllers/table/bulkFormula.js

@@ -1,173 +0,0 @@
-const { FieldTypes, FormulaTypes } = require("../../../constants")
-const { getAllInternalTables, clearColumns } = require("./utils")
-const { doesContainStrings } = require("@budibase/string-templates")
-const { cloneDeep } = require("lodash/fp")
-const { isEqual, uniq } = require("lodash")
-const { updateAllFormulasInTable } = require("../row/staticFormula")
-const { getAppDB } = require("@budibase/backend-core/context")
-
-function isStaticFormula(column) {
-  return (
-    column.type === FieldTypes.FORMULA &&
-    column.formulaType === FormulaTypes.STATIC
-  )
-}
-
-/**
- * This retrieves the formula columns from a table schema that use a specified column name
- * in the formula.
- */
-function getFormulaThatUseColumn(table, columnNames) {
-  let formula = []
-  columnNames = Array.isArray(columnNames) ? columnNames : [columnNames]
-  for (let column of Object.values(table.schema)) {
-    // not a static formula, or doesn't contain a relationship
-    if (!isStaticFormula(column)) {
-      continue
-    }
-    if (!doesContainStrings(column.formula, columnNames)) {
-      continue
-    }
-    formula.push(column.name)
-  }
-  return formula
-}
-
-/**
- * This functions checks for when a related table, column or related column is deleted, if any
- * tables need to have the formula column removed.
- */
-async function checkIfFormulaNeedsCleared(table, { oldTable, deletion }) {
-  // start by retrieving all tables, remove the current table from the list
-  const tables = (await getAllInternalTables()).filter(
-    tbl => tbl._id !== table._id
-  )
-  const schemaToUse = oldTable ? oldTable.schema : table.schema
-  let removedColumns = Object.values(schemaToUse).filter(
-    column => deletion || !table.schema[column.name]
-  )
-  // remove any formula columns that used related columns
-  for (let removed of removedColumns) {
-    let tableToUse = table
-    // if relationship, get the related table
-    if (removed.type === FieldTypes.LINK) {
-      tableToUse = tables.find(table => table._id === removed.tableId)
-    }
-    const columnsToDelete = getFormulaThatUseColumn(tableToUse, removed.name)
-    if (columnsToDelete.length > 0) {
-      await clearColumns(table, columnsToDelete)
-    }
-    // need a special case, where a column has been removed from this table, but was used
-    // in a different, related tables formula
-    if (!table.relatedFormula) {
-      continue
-    }
-    for (let relatedTableId of table.relatedFormula) {
-      const relatedColumns = Object.values(table.schema).filter(
-        column => column.tableId === relatedTableId
-      )
-      const relatedTable = tables.find(table => table._id === relatedTableId)
-      // look to see if the column was used in a relationship formula,
-      // relationships won't be used for this
-      if (relatedTable && relatedColumns && removed.type !== FieldTypes.LINK) {
-        let relatedFormulaToRemove = []
-        for (let column of relatedColumns) {
-          relatedFormulaToRemove = relatedFormulaToRemove.concat(
-            getFormulaThatUseColumn(relatedTable, [
-              column.fieldName,
-              removed.name,
-            ])
-          )
-        }
-        if (relatedFormulaToRemove.length > 0) {
-          await clearColumns(relatedTable, uniq(relatedFormulaToRemove))
-        }
-      }
-    }
-  }
-}
-
-/**
- * This function adds a note to related tables that they are
- * used in a static formula - so that the link controller
- * can manage hydrating related rows formula fields. This is
- * specifically only for static formula.
- */
-async function updateRelatedFormulaLinksOnTables(
-  table,
-  { deletion } = { deletion: false }
-) {
-  const db = getAppDB()
-  // start by retrieving all tables, remove the current table from the list
-  const tables = (await getAllInternalTables()).filter(
-    tbl => tbl._id !== table._id
-  )
-  // clone the tables, so we can compare at end
-  const initialTables = cloneDeep(tables)
-  // first find the related column names
-  const relatedColumns = Object.values(table.schema).filter(
-    col => col.type === FieldTypes.LINK
-  )
-  // we start by removing the formula field from all tables
-  for (let otherTable of tables) {
-    if (!otherTable.relatedFormula) {
-      continue
-    }
-    const index = otherTable.relatedFormula.indexOf(table._id)
-    if (index !== -1) {
-      otherTable.relatedFormula.splice(index, 1)
-    }
-  }
-  // if deleting, just remove the table IDs, don't try add
-  if (!deletion) {
-    for (let relatedCol of relatedColumns) {
-      let columns = getFormulaThatUseColumn(table, relatedCol.name)
-      if (!columns || columns.length === 0) {
-        continue
-      }
-      const relatedTable = tables.find(
-        related => related._id === relatedCol.tableId
-      )
-      // check if the table is already in the list of related formula, if it isn't, then add it
-      if (
-        relatedTable &&
-        (!relatedTable.relatedFormula ||
-          !relatedTable.relatedFormula.includes(table._id))
-      ) {
-        relatedTable.relatedFormula = relatedTable.relatedFormula
-          ? [...relatedTable.relatedFormula, table._id]
-          : [table._id]
-      }
-    }
-  }
-  // now we just need to compare all the tables and see if any need saved
-  for (let initial of initialTables) {
-    const found = tables.find(tbl => initial._id === tbl._id)
-    if (found && !isEqual(initial, found)) {
-      await db.put(found)
-    }
-  }
-}
-
-async function checkIfFormulaUpdated(table, { oldTable }) {
-  // look to see if any formula values have changed
-  const shouldUpdate = Object.values(table.schema).find(
-    column =>
-      isStaticFormula(column) &&
-      (!oldTable ||
-        !oldTable.schema[column.name] ||
-        !isEqual(oldTable.schema[column.name], column))
-  )
-  // if a static formula column has updated, then need to run the update
-  if (shouldUpdate != null) {
-    await updateAllFormulasInTable(table)
-  }
-}
-
-exports.runStaticFormulaChecks = async (table, { oldTable, deletion }) => {
-  await updateRelatedFormulaLinksOnTables(table, { deletion })
-  await checkIfFormulaNeedsCleared(table, { oldTable, deletion })
-  if (!deletion) {
-    await checkIfFormulaUpdated(table, { oldTable })
-  }
-}

package/src/api/routes/migrations.js

@@ -1,14 +0,0 @@
-const Router = require("@koa/router")
-const migrationsController = require("../controllers/migrations")
-const router = Router()
-const { internalApi } = require("@budibase/backend-core/auth")
-
-router
-  .post("/api/migrations/run", internalApi, migrationsController.migrate)
-  .get(
-    "/api/migrations/definitions",
-    internalApi,
-    migrationsController.fetchDefinitions
-  )
-
-module.exports = router

package/src/api/routes/tests/static.spec.js

@@ -1,98 +0,0 @@
-jest.mock("node-fetch")
-jest.mock("aws-sdk", () => ({
-  config: {
-    update: jest.fn(),
-  },
-  DynamoDB: {
-    DocumentClient: jest.fn(),
-  },
-  S3: jest.fn(() => ({
-    getSignedUrl: jest.fn(() => {
-      return "my-url"
-    }),
-  })),
-}))
-
-const setup = require("./utilities")
-
-describe("/attachments", () => {
-  let request = setup.getRequest()
-  let config = setup.getConfig()
-  let app
-
-  afterAll(setup.afterAll)
-
-  beforeEach(async () => {
-    app = await config.init()
-  })
-
-  describe("generateSignedUrls", () => {
-    let datasource
-
-    beforeEach(async () => {
-      datasource = await config.createDatasource({
-        datasource: {
-          type: "datasource",
-          name: "Test",
-          source: "S3",
-          config: {},
-        },
-      })
-    })
-
-    it("should be able to generate a signed upload URL", async () => {
-      const bucket = "foo"
-      const key = "bar"
-      const res = await request
-        .post(`/api/attachments/${datasource._id}/url`)
-        .send({ bucket, key })
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
-      expect(res.body.signedUrl).toEqual("my-url")
-      expect(res.body.publicUrl).toEqual(
-        `https://${bucket}.s3.eu-west-1.amazonaws.com/${key}`
-      )
-    })
-
-    it("should handle an invalid datasource ID", async () => {
-      const res = await request
-        .post(`/api/attachments/foo/url`)
-        .send({
-          bucket: "foo",
-          key: "bar",
-        })
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(400)
-      expect(res.body.message).toEqual(
-        "The specified datasource could not be found"
-      )
-    })
-
-    it("should require a bucket parameter", async () => {
-      const res = await request
-        .post(`/api/attachments/${datasource._id}/url`)
-        .send({
-          bucket: undefined,
-          key: "bar",
-        })
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(400)
-      expect(res.body.message).toEqual("bucket and key values are required")
-    })
-
-    it("should require a key parameter", async () => {
-      const res = await request
-        .post(`/api/attachments/${datasource._id}/url`)
-        .send({
-          bucket: "foo",
-        })
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(400)
-      expect(res.body.message).toEqual("bucket and key values are required")
-    })
-  })
-})