- {#each $tables.list.filter(table => table.sourceId === sourceId) as table, idx}
+ {#each sortedTables as table, idx}
0}
@@ -46,7 +51,7 @@
{/if}
- {#each Object.keys(table.views || {}) as viewName, idx (idx)}
+ {#each [...Object.keys(table.views || {})].sort() as viewName, idx (idx)}
+ import { RelationshipTypes } from "constants/backend"
+ import { Button, Input, ModalContent, Select, Detail } from "@budibase/bbui"
+ import { tables } from "stores/backend"
+ import { uuid } from "builderStore/uuid"
+
+ export let save
+ export let datasource
+ export let plusTables = []
+ export let fromRelationship = {}
+ export let toRelationship = {}
+ export let close
+
+ let originalFromName = fromRelationship.name,
+ originalToName = toRelationship.name
+
+ function isValid(relationship) {
+ if (
+ relationship.relationshipType === RelationshipTypes.MANY_TO_MANY &&
+ !relationship.through
+ ) {
+ return false
+ }
+ return (
+ relationship.name && relationship.tableId && relationship.relationshipType
+ )
+ }
+
+ $: tableOptions = plusTables.map(table => ({
+ label: table.name,
+ value: table._id,
+ }))
+ $: fromTable = plusTables.find(table => table._id === toRelationship?.tableId)
+ $: toTable = plusTables.find(table => table._id === fromRelationship?.tableId)
+ $: through = plusTables.find(table => table._id === fromRelationship?.through)
+ $: valid = toTable && fromTable && isValid(fromRelationship)
+ $: linkTable = through || toTable
+ $: relationshipTypes = [
+ {
+ label: "Many",
+ value: RelationshipTypes.MANY_TO_MANY,
+ },
+ {
+ label: "One",
+ value: RelationshipTypes.MANY_TO_ONE,
+ },
+ ]
+ $: updateRelationshipType(fromRelationship?.relationshipType)
+
+ function updateRelationshipType(fromType) {
+ if (fromType === RelationshipTypes.MANY_TO_MANY) {
+ toRelationship.relationshipType = RelationshipTypes.MANY_TO_MANY
+ } else {
+ toRelationship.relationshipType = RelationshipTypes.MANY_TO_ONE
+ }
+ }
+
+ function buildRelationships() {
+ // if any to many only need to check from
+ const manyToMany =
+ fromRelationship.relationshipType === RelationshipTypes.MANY_TO_MANY
+ // main is simply used to know this is the side the user configured it from
+ const id = uuid()
+ if (!manyToMany) {
+ delete fromRelationship.through
+ delete toRelationship.through
+ }
+ let relateFrom = {
+ ...fromRelationship,
+ type: "link",
+ main: true,
+ _id: id,
+ }
+ let relateTo = {
+ ...toRelationship,
+ type: "link",
+ _id: id,
+ }
+
+ // [0] is because we don't support composite keys for relationships right now
+ if (manyToMany) {
+ relateFrom = {
+ ...relateFrom,
+ through: through._id,
+ fieldName: toTable.primary[0],
+ }
+ relateTo = {
+ ...relateTo,
+ through: through._id,
+ fieldName: fromTable.primary[0],
+ }
+ } else {
+ relateFrom = {
+ ...relateFrom,
+ foreignKey: relateFrom.fieldName,
+ fieldName: fromTable.primary[0],
+ }
+ relateTo = {
+ ...relateTo,
+ relationshipType: RelationshipTypes.ONE_TO_MANY,
+ foreignKey: relateFrom.fieldName,
+ fieldName: fromTable.primary[0],
+ }
+ }
+
+ fromRelationship = relateFrom
+ toRelationship = relateTo
+ }
+
+ // save the relationship on to the datasource
+ async function saveRelationship() {
+ buildRelationships()
+ // source of relationship
+ datasource.entities[fromTable.name].schema[fromRelationship.name] =
+ fromRelationship
+ // save other side of relationship in the other schema
+ datasource.entities[toTable.name].schema[toRelationship.name] =
+ toRelationship
+
+ // If relationship has been renamed
+ if (originalFromName !== fromRelationship.name) {
+ delete datasource.entities[fromTable.name].schema[originalFromName]
+ }
+ if (originalToName !== toRelationship.name) {
+ delete datasource.entities[toTable.name].schema[originalToName]
+ }
+
+ await save()
+ await tables.fetch()
+ }
+
+ async function deleteRelationship() {
+ delete datasource.entities[fromTable.name].schema[fromRelationship.name]
+ delete datasource.entities[toTable.name].schema[toRelationship.name]
+ await save()
+ await tables.fetch()
+ close()
+ }
+
+
+
+
+
+ Tables
+
+
+
+ {#if fromRelationship?.relationshipType === RelationshipTypes.MANY_TO_MANY}
+
+ {:else if toTable}
+
+ {/if}
+
+ Column names
+
+
+
+
+ {#if originalFromName != null}
+
+ {/if}
+
+
+
+
diff --git a/packages/builder/src/pages/builder/app/[application]/data/datasource/[selectedDatasource]/CreateEditRelationship/TableSelect.svelte b/packages/builder/src/pages/builder/app/[application]/data/datasource/[selectedDatasource]/CreateEditRelationship/TableSelect.svelte
new file mode 100644
index 0000000000..5595d5d3ab
--- /dev/null
+++ b/packages/builder/src/pages/builder/app/[application]/data/datasource/[selectedDatasource]/CreateEditRelationship/TableSelect.svelte
@@ -0,0 +1,21 @@
+
+
+
diff --git a/packages/builder/src/pages/builder/app/[application]/data/datasource/[selectedDatasource]/index.svelte b/packages/builder/src/pages/builder/app/[application]/data/datasource/[selectedDatasource]/index.svelte
index 5d8e2ca100..b0377d2f27 100644
--- a/packages/builder/src/pages/builder/app/[application]/data/datasource/[selectedDatasource]/index.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/data/datasource/[selectedDatasource]/index.svelte
@@ -1,16 +1,70 @@
+
+
+
+
+
+
+
+
{#if datasource && integration}
@@ -92,9 +171,18 @@
This datasource can determine tables automatically. Budibase can fetch
@@ -102,18 +190,44 @@
having to write any queries at all.
- {#if datasource.entities}
- {#each Object.keys(datasource.entities) as entity}
-
onClickTable(datasource.entities[entity])}
- >
-
{entity}
-
Primary Key: {datasource.entities[entity].primary}
-
β
-
- {/each}
- {/if}
+ {#each plusTables as table}
+
onClickTable(table)}>
+
{table.name}
+
Primary Key: {table.primary}
+
β
+
+ {/each}
+
+ {#each Object.values(relationships) as relationship}
+
+ openRelationshipModal(relationship.from, relationship.to)}
+ >
+
+ {buildRelationshipDisplayString(
+ relationship.from,
+ relationship.to
+ )}
+
+
{relationship.from?.name} to {relationship.to?.name}
+
β
+
+ {/each}
