Typing field schemas

packages/server/src/api/controllers/row/ExternalRequest.ts

@@ -5,8 +5,11 @@ import {
   FieldType,
   FilterType,
   IncludeRelationship,
+  ManyToManyRelationshipFieldMetadata,
+  OneToManyRelationshipFieldMetadata,
   Operation,
   PaginationJson,
+  RelationshipFieldMetadata,
   RelationshipsJson,
   RelationshipType,
   Row,
@@ -254,12 +257,20 @@ function fixArrayTypes(row: Row, table: Table) {
   return row
 }
 
-function isOneSide(field: FieldSchema) {
+function isOneSide(
+  field: RelationshipFieldMetadata
+): field is OneToManyRelationshipFieldMetadata {
   return (
     field.relationshipType && field.relationshipType.split("-")[0] === "one"
   )
 }
 
+function isManyToMany(
+  field: RelationshipFieldMetadata
+): field is ManyToManyRelationshipFieldMetadata {
+  return !!(field as ManyToManyRelationshipFieldMetadata).through
+}
+
 function isEditableColumn(column: FieldSchema) {
   const isExternalAutoColumn =
     column.autocolumn &&
@@ -352,11 +363,11 @@ export class ExternalRequest<T extends Operation> {
         }
       }
       // many to many
-      else if (field.through) {
+      else if (isManyToMany(field)) {
         // we're not inserting a doc, will be a bunch of update calls
         const otherKey: string = field.throughFrom || linkTablePrimary
         const thisKey: string = field.throughTo || tablePrimary
-        row[key].forEach((relationship: any) => {
+        for (const relationship of row[key]) {
           manyRelationships.push({
             tableId: field.through || field.tableId,
             isUpdate: false,
@@ -365,14 +376,14 @@ export class ExternalRequest<T extends Operation> {
             // leave the ID for enrichment later
             [thisKey]: `{{ literal ${tablePrimary} }}`,
           })
-        })
+        }
       }
       // many to one
       else {
         const thisKey: string = "id"
         // @ts-ignore
         const otherKey: string = field.fieldName
-        row[key].forEach((relationship: any) => {
+        for (const relationship of row[key]) {
           manyRelationships.push({
             tableId: field.tableId,
             isUpdate: true,
@@ -381,7 +392,7 @@ export class ExternalRequest<T extends Operation> {
             // leave the ID for enrichment later
             [otherKey]: `{{ literal ${tablePrimary} }}`,
           })
-        })
+        }
       }
     }
     // we return the relationships that may need to be created in the through table
@@ -549,15 +560,12 @@ export class ExternalRequest<T extends Operation> {
       if (!table.primary || !linkTable.primary) {
         continue
       }
-      const definition: any = {
-        // if no foreign key specified then use the name of the field in other table
-        from: field.foreignKey || table.primary[0],
-        to: field.fieldName,
+      const definition: RelationshipsJson = {
         tableName: linkTableName,
         // need to specify where to put this back into
         column: fieldName,
       }
-      if (field.through) {
+      if (isManyToMany(field)) {
         const { tableName: throughTableName } = breakExternalTableId(
           field.through
         )
@@ -567,6 +575,10 @@ export class ExternalRequest<T extends Operation> {
         definition.to = field.throughFrom || linkTable.primary[0]
         definition.fromPrimary = table.primary[0]
         definition.toPrimary = linkTable.primary[0]
+      } else {
+        // if no foreign key specified then use the name of the field in other table
+        definition.from = field.foreignKey || table.primary[0]
+        definition.to = field.fieldName
       }
       relationships.push(definition)
     }
@@ -588,7 +600,7 @@ export class ExternalRequest<T extends Operation> {
     const primaryKey = table.primary[0]
     // make a new request to get the row with all its relationships
     // we need this to work out if any relationships need removed
-    for (let field of Object.values(table.schema)) {
+    for (const field of Object.values(table.schema)) {
       if (
         field.type !== FieldTypes.LINK ||
         !field.fieldName ||
@@ -601,9 +613,9 @@ export class ExternalRequest<T extends Operation> {
       const { tableName: relatedTableName } = breakExternalTableId(tableId)
       // @ts-ignore
       const linkPrimaryKey = this.tables[relatedTableName].primary[0]
-      const manyKey = field.throughTo || primaryKey
+
       const lookupField = isMany ? primaryKey : field.foreignKey
-      const fieldName = isMany ? manyKey : field.fieldName
+      const fieldName = isMany ? field.throughTo || primaryKey : field.fieldName
       if (!lookupField || !row[lookupField]) {
         continue
       }

packages/server/src/api/controllers/row/utils.ts

@@ -4,6 +4,8 @@ import { context } from "@budibase/backend-core"
 import {
   Ctx,
   FieldType,
+  ManyToOneRelationshipFieldMetadata,
+  OneToManyRelationshipFieldMetadata,
   Row,
   SearchFilters,
   Table,
@@ -19,7 +21,14 @@ function isForeignKey(key: string, table: Table) {
   const relationships = Object.values(table.schema).filter(
     column => column.type === FieldType.LINK
   )
-  return relationships.some(relationship => relationship.foreignKey === key)
+  return relationships.some(
+    relationship =>
+      (
+        relationship as
+          | OneToManyRelationshipFieldMetadata
+          | ManyToOneRelationshipFieldMetadata
+      ).foreignKey === key
+  )
 }
 
 validateJs.extend(validateJs.validators.datetime, {

packages/server/src/api/controllers/table/bulkFormula.ts

@@ -1,17 +1,25 @@
-import { FieldTypes, FormulaTypes } from "../../../constants"
+import { FormulaTypes } from "../../../constants"
 import { clearColumns } from "./utils"
 import { doesContainStrings } from "@budibase/string-templates"
 import { cloneDeep } from "lodash/fp"
 import isEqual from "lodash/isEqual"
 import uniq from "lodash/uniq"
 import { updateAllFormulasInTable } from "../row/staticFormula"
 import { context } from "@budibase/backend-core"
-import { FieldSchema, Table } from "@budibase/types"
+import {
+  FieldSchema,
+  FieldType,
+  FormulaFieldMetadata,
+  Table,
+} from "@budibase/types"
 import sdk from "../../../sdk"
+import { isRelationshipColumn } from "../../../db/utils"
 
-function isStaticFormula(column: FieldSchema) {
+function isStaticFormula(
+  column: FieldSchema
+): column is FormulaFieldMetadata & { formulaType: FormulaTypes.STATIC } {
   return (
-    column.type === FieldTypes.FORMULA &&
+    column.type === FieldType.FORMULA &&
     column.formulaType === FormulaTypes.STATIC
   )
 }
@@ -56,8 +64,9 @@ async function checkIfFormulaNeedsCleared(
   for (let removed of removedColumns) {
     let tableToUse: Table | undefined = table
     // if relationship, get the related table
-    if (removed.type === FieldTypes.LINK) {
-      tableToUse = tables.find(table => table._id === removed.tableId)
+    if (removed.type === FieldType.LINK) {
+      const removedTableId = removed.tableId
+      tableToUse = tables.find(table => table._id === removedTableId)
     }
     if (!tableToUse) {
       continue
@@ -73,17 +82,18 @@ async function checkIfFormulaNeedsCleared(
     }
     for (let relatedTableId of table.relatedFormula) {
       const relatedColumns = Object.values(table.schema).filter(
-        column => column.tableId === relatedTableId
+        column =>
+          column.type === FieldType.LINK && 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) {
+      if (relatedTable && relatedColumns && removed.type !== FieldType.LINK) {
         let relatedFormulaToRemove: string[] = []
         for (let column of relatedColumns) {
           relatedFormulaToRemove = relatedFormulaToRemove.concat(
             getFormulaThatUseColumn(relatedTable, [
-              column.fieldName!,
+              (column as any).fieldName!,
               removed.name,
             ])
           )
@@ -116,7 +126,7 @@ async function updateRelatedFormulaLinksOnTables(
   const initialTables = cloneDeep(tables)
   // first find the related column names
   const relatedColumns = Object.values(table.schema).filter(
-    col => col.type === FieldTypes.LINK
+    isRelationshipColumn
   )
   // we start by removing the formula field from all tables
   for (let otherTable of tables) {
@@ -135,6 +145,7 @@ async function updateRelatedFormulaLinksOnTables(
       if (!columns || columns.length === 0) {
         continue
       }
+
       const relatedTable = tables.find(
         related => related._id === relatedCol.tableId
       )

packages/server/src/api/controllers/table/external.ts

@@ -15,11 +15,14 @@ import { handleRequest } from "../row/external"
 import { context, events } from "@budibase/backend-core"
 import { isRows, isSchema, parse } from "../../../utilities/schema"
 import {
-  AutoReason,
   Datasource,
   FieldSchema,
+  ManyToManyRelationshipFieldMetadata,
+  ManyToOneRelationshipFieldMetadata,
+  OneToManyRelationshipFieldMetadata,
   Operation,
   QueryJson,
+  RelationshipFieldMetadata,
   RelationshipType,
   RenameColumn,
   SaveTableRequest,
@@ -74,10 +77,13 @@ function cleanupRelationships(
       schema.type === FieldTypes.LINK &&
       (!oldTable || table.schema[key] == null)
     ) {
+      const schemaTableId = schema.tableId
       const relatedTable = Object.values(tables).find(
-        table => table._id === schema.tableId
+        table => table._id === schemaTableId
       )
-      const foreignKey = schema.foreignKey
+      const foreignKey =
+        schema.relationshipType !== RelationshipType.MANY_TO_MANY &&
+        schema.foreignKey
       if (!relatedTable || !foreignKey) {
         continue
       }
@@ -116,7 +122,7 @@ function otherRelationshipType(type?: string) {
 
 function generateManyLinkSchema(
   datasource: Datasource,
-  column: FieldSchema,
+  column: ManyToManyRelationshipFieldMetadata,
   table: Table,
   relatedTable: Table
 ): Table {
@@ -151,10 +157,12 @@ function generateManyLinkSchema(
 }
 
 function generateLinkSchema(
-  column: FieldSchema,
+  column:
+    | OneToManyRelationshipFieldMetadata
+    | ManyToOneRelationshipFieldMetadata,
   table: Table,
   relatedTable: Table,
-  type: RelationshipType
+  type: RelationshipType.ONE_TO_MANY | RelationshipType.MANY_TO_ONE
 ) {
   if (!table.primary || !relatedTable.primary) {
     throw new Error("Unable to generate link schema, no primary keys")
@@ -170,20 +178,22 @@ function generateLinkSchema(
 }
 
 function generateRelatedSchema(
-  linkColumn: FieldSchema,
+  linkColumn: RelationshipFieldMetadata,
   table: Table,
   relatedTable: Table,
   columnName: string
 ) {
   // generate column for other table
   const relatedSchema = cloneDeep(linkColumn)
+  const isMany2Many =
+    linkColumn.relationshipType === RelationshipType.MANY_TO_MANY
   // swap them from the main link
-  if (linkColumn.foreignKey) {
+  if (!isMany2Many && linkColumn.foreignKey) {
     relatedSchema.fieldName = linkColumn.foreignKey
     relatedSchema.foreignKey = linkColumn.fieldName
   }
   // is many to many
-  else {
+  else if (isMany2Many) {
     // don't need to copy through, already got it
     relatedSchema.fieldName = linkColumn.throughTo
     relatedSchema.throughTo = linkColumn.throughFrom
@@ -197,8 +207,8 @@ function generateRelatedSchema(
   table.schema[columnName] = relatedSchema
 }
 
-function isRelationshipSetup(column: FieldSchema) {
-  return column.foreignKey || column.through
+function isRelationshipSetup(column: RelationshipFieldMetadata) {
+  return (column as any).foreignKey || (column as any).through
 }
 
 export async function save(ctx: UserCtx<SaveTableRequest, SaveTableResponse>) {
@@ -257,14 +267,15 @@ export async function save(ctx: UserCtx<SaveTableRequest, SaveTableResponse>) {
     if (schema.type !== FieldTypes.LINK || isRelationshipSetup(schema)) {
       continue
     }
+    const schemaTableId = schema.tableId
     const relatedTable = Object.values(tables).find(
-      table => table._id === schema.tableId
+      table => table._id === schemaTableId
     )
     if (!relatedTable) {
       continue
     }
     const relatedColumnName = schema.fieldName!
-    const relationType = schema.relationshipType!
+    const relationType = schema.relationshipType
     if (relationType === RelationshipType.MANY_TO_MANY) {
       const junctionTable = generateManyLinkSchema(
         datasource,

packages/server/src/api/controllers/table/internal.ts

@@ -10,6 +10,7 @@ import {
 } from "../../../utilities/rowProcessor"
 import { runStaticFormulaChecks } from "./bulkFormula"
 import {
+  AutoColumnFieldMetadata,
   RenameColumn,
   SaveTableRequest,
   SaveTableResponse,
@@ -78,10 +79,10 @@ export async function save(ctx: UserCtx<SaveTableRequest, SaveTableResponse>) {
   // make sure that types don't change of a column, have to remove
   // the column if you want to change the type
   if (oldTable && oldTable.schema) {
-    for (let propKey of Object.keys(tableToSave.schema)) {
+    for (const propKey of Object.keys(tableToSave.schema)) {
       let oldColumn = oldTable.schema[propKey]
       if (oldColumn && oldColumn.type === FieldTypes.INTERNAL) {
-        oldColumn.type = FieldTypes.AUTO
+        oldTable.schema[propKey].type = FieldTypes.AUTO
       }
     }
   }