MirrorSave
/
budibase
mirror of https://github.com/Budibase/budibase.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into fix/sql-many-relationships

This commit is contained in:
Michael Drury 2024-09-09 16:07:16 +01:00 committed by GitHub
parent aac1d7699e 0f8df77ded
commit e2c6893aa3
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
69 changed files with 1995 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.github/workflows/pr-labeler.yml vendored
View File

@ -21,6 +21,7 @@ jobs:
l_max_size: "1000"
fail_if_xl: "false"
files_to_ignore: "yarn.lock"
message_if_xl: ""
team-labeler:
runs-on: ubuntu-latest

2
README.md
View File

@ -65,7 +65,7 @@ Budibase is open-source - licensed as GPL v3. This should fill you with confiden
<br /><br />
### Load data or start from scratch
Budibase pulls data from multiple sources, including MongoDB, CouchDB, PostgreSQL, MySQL, Airtable, S3, DynamoDB, or a REST API. And unlike other platforms, with Budibase you can start from scratch and create business apps with no data sources. [Request new datasources](https://github.com/Budibase/budibase/discussions?discussions_q=category%3AIdeas).
Budibase pulls data from multiple sources, including MongoDB, CouchDB, PostgreSQL, MariaDB, MySQL, Airtable, S3, DynamoDB, or a REST API. And unlike other platforms, with Budibase you can start from scratch and create business apps with no data sources. [Request new datasources](https://github.com/Budibase/budibase/discussions?discussions_q=category%3AIdeas).
<p align="center">
<img alt="Budibase data" src="https://res.cloudinary.com/daog6scxm/image/upload/v1680281798/ui/data_klbuna.png">

2
lerna.json
View File

@ -1,6 +1,6 @@
{
"$schema": "node_modules/lerna/schemas/lerna-schema.json",
"version": "2.31.4",
"version": "2.31.8",
"npmClient": "yarn",
"packages": [
"packages/*",

4
packages/backend-core/src/features/index.ts
View File

@ -1,7 +1,7 @@
import env from "../environment"
import * as context from "../context"
import { PostHog, PostHogOptions } from "posthog-node"
import { IdentityType, UserCtx } from "@budibase/types"
import { FeatureFlag, IdentityType, UserCtx } from "@budibase/types"
import tracer from "dd-trace"
let posthog: PostHog | undefined
@ -267,5 +267,7 @@ export class FlagSet<V extends Flag<any>, T extends { [key: string]: V }> {
// default values set correctly and their types flow through the system.
export const flags = new FlagSet({
DEFAULT_VALUES: Flag.boolean(env.isDev()),
AUTOMATION_BRANCHING: Flag.boolean(env.isDev()),
SQS: Flag.boolean(env.isDev()),
[FeatureFlag.ENRICHED_RELATIONSHIPS]: Flag.boolean(false),
})

3
packages/builder/src/components/backend/DataTable/ViewV2DataTable.svelte
View File

@ -6,6 +6,8 @@
import GridCreateEditRowModal from "components/backend/DataTable/modals/grid/GridCreateEditRowModal.svelte"
import GridFilterButton from "components/backend/DataTable/buttons/grid/GridFilterButton.svelte"
import GridManageAccessButton from "components/backend/DataTable/buttons/grid/GridManageAccessButton.svelte"
import { isEnabled } from "helpers/featureFlags"
import { FeatureFlag } from "@budibase/types"
$: id = $viewsV2.selected?.id
$: datasource = {
@ -29,6 +31,7 @@
on:updatedatasource={handleGridViewUpdate}
isCloud={$admin.cloud}
allowViewReadonlyColumns={$licensing.isViewReadonlyColumnsEnabled}
canSetRelationshipSchemas={isEnabled(FeatureFlag.ENRICHED_RELATIONSHIPS)}
>
<svelte:fragment slot="filter">
<GridFilterButton />

4
packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
View File

@ -84,7 +84,7 @@
}
let relationshipOpts1 = Object.values(PrettyRelationshipDefinitions)
let relationshipOpts2 = Object.values(PrettyRelationshipDefinitions)
let relationshipMap = {
const relationshipMap = {
[RelationshipType.ONE_TO_MANY]: {
part1: PrettyRelationshipDefinitions.MANY,
part2: PrettyRelationshipDefinitions.ONE,
@ -98,7 +98,7 @@
part2: PrettyRelationshipDefinitions.MANY,
},
}
let autoColumnInfo = getAutoColumnInformation()
const autoColumnInfo = getAutoColumnInformation()
let optionsValid = true
$: rowGoldenSample = RowUtils.generateGoldenSample($rows)

25
packages/builder/src/pages/builder/portal/_components/LockedFeature.svelte
View File

@ -1,10 +1,12 @@
<script>
import {
AbsTooltip,
Layout,
Heading,
Body,
Button,
Divider,
Icon,
Tags,
Tag,
} from "@budibase/bbui"
@ -15,6 +17,8 @@
export let description
export let enabled
export let upgradeButtonClick
$: upgradeDisabled = !$auth.accountPortalAccess && $admin.cloud
</script>
<Layout noPadding>
@ -36,8 +40,9 @@
{:else}
<div class="buttons">
<Button
primary
disabled={!$auth.accountPortalAccess && $admin.cloud}
primary={!upgradeDisabled}
secondary={upgradeDisabled}
disabled={upgradeDisabled}
on:click={async () => upgradeButtonClick()}
>
Upgrade
@ -51,6 +56,16 @@
>
View Plans
</Button>
{#if upgradeDisabled}
<AbsTooltip
text={"Please contact the account holder to upgrade"}
position={"right"}
>
<div class="icon" on:focus>
<Icon name="InfoOutline" size="L" disabled hoverable />
</div>
</AbsTooltip>
{/if}
</div>
{/if}
</Layout>
@ -67,7 +82,11 @@
justify-content: flex-start;
gap: var(--spacing-m);
}
.icon {
position: relative;
display: flex;
justify-content: center;
}
.buttons {
display: flex;
flex-direction: row;

7
packages/builder/src/pages/builder/portal/users/users/index.svelte
View File

@ -127,7 +127,10 @@
name: user.firstName ? user.firstName + " " + user.lastName : "",
userGroups,
__selectable:
role.value === Constants.BudibaseRoles.Owner ? false : undefined,
role.value === Constants.BudibaseRoles.Owner ||
$auth.user?.email === user.email
? false
: true,
apps: [...new Set(Object.keys(user.roles))],
access: role.sortOrder,
}
@ -392,7 +395,7 @@
allowSelectRows={!readonly}
{customRenderers}
loading={!$fetch.loaded || !groupsLoaded}
defaultSortColumn={"access"}
defaultSortColumn={"__selectable"}
/>
<div class="pagination">

23
packages/client/src/components/Component.svelte
View File

@ -153,7 +153,7 @@
$: builderInteractive =
$builderStore.inBuilder && insideScreenslot && !isBlock && !instance.static
$: devToolsInteractive = $devToolsStore.allowSelection && !isBlock
$: interactive = !isRoot && (builderInteractive || devToolsInteractive)
$: interactive = builderInteractive || devToolsInteractive
$: editing = editable && selected && $builderStore.editMode
$: draggable =
!inDragPath &&
@ -189,12 +189,6 @@
// Scroll the selected element into view
$: selected && scrollIntoView()
// When dragging and dropping, pad components to allow dropping between
// nested layers. Only reset this when dragging stops.
let pad = false
$: pad = pad || (interactive && hasChildren && inDndPath)
$: $dndIsDragging, (pad = false)
// Themes
$: currentTheme = $context?.device?.theme
$: darkMode = !currentTheme?.includes("light")
@ -206,8 +200,10 @@
}
// Metadata to pass into grid action to apply CSS
const insideGrid =
parent?._component.endsWith("/container") && parent?.layout === "grid"
const checkGrid = x =>
x?._component?.endsWith("/container") && x?.layout === "grid"
$: insideGrid = checkGrid(parent)
$: isGrid = checkGrid(instance)
$: gridMetadata = {
insideGrid,
ignoresLayout: definition?.ignoresLayout === true,
@ -219,6 +215,12 @@
errored: errorState,
}
// When dragging and dropping, pad components to allow dropping between
// nested layers. Only reset this when dragging stops.
let pad = false
$: pad = pad || (!isGrid && interactive && hasChildren && inDndPath)
$: $dndIsDragging, (pad = false)
// Update component context
$: store.set({
id,
@ -231,12 +233,14 @@
empty: emptyState,
selected,
interactive,
isRoot,
draggable,
editable,
isBlock,
},
empty: emptyState,
selected,
isRoot,
inSelectedPath,
name,
editing,
@ -672,6 +676,7 @@
class:parent={hasChildren}
class:block={isBlock}
class:error={errorState}
class:root={isRoot}
data-id={id}
data-name={name}
data-icon={icon}

7
packages/client/src/components/Screen.svelte
View File

@ -14,7 +14,6 @@
// Get the screen definition for the current route
$: screen = $screenStore.activeScreen
$: screenDefinition = { ...screen?.props, addEmptyRows: true }
$: onLoadActions.set(screen?.onLoad)
$: runOnLoadActions($onLoadActions, params)
@ -42,10 +41,10 @@
</script>
<!-- Ensure to fully remount when screen changes -->
{#if $routeStore.routerLoaded}
{#key screenDefinition?._id}
{#if $routeStore.routerLoaded && screen?.props}
{#key screen.props._id}
<Provider key="url" data={params}>
<Component isRoot instance={screenDefinition} />
<Component isRoot instance={screen.props} />
</Provider>
{/key}
{/if}

4
packages/client/src/components/app/EmptyPlaceholder.svelte
View File

@ -18,9 +18,11 @@
display: flex;
flex-direction: row;
justify-content: flex-start;
align-items: center;
align-items: flex-start;
color: var(--spectrum-global-color-gray-600);
font-size: var(--font-size-s);
gap: var(--spacing-s);
grid-column: 1 / -1;
grid-row: 1 / -1;
}
</style>

2
packages/client/src/components/app/ScreenPlaceholder.svelte
View File

@ -23,6 +23,8 @@
align-items: center;
gap: var(--spacing-s);
flex: 1 1 auto;
grid-column: 1 / -1;
grid-row: 1 / -1;
}
.placeholder :global(.spectrum-Button) {
margin-top: var(--spacing-m);

15
packages/client/src/components/app/container/GridContainer.svelte
View File

@ -4,8 +4,6 @@
import { GridRowHeight, GridColumns } from "constants"
import { memo } from "@budibase/frontend-core"
export let addEmptyRows = false
const component = getContext("component")
const { styleable, builderStore } = getContext("sdk")
const context = getContext("context")
@ -18,16 +16,12 @@
let styles = memo({})
$: inBuilder = $builderStore.inBuilder
$: requiredRows = calculateRequiredRows(
$children,
mobile,
addEmptyRows && inBuilder
)
$: addEmptyRows = $component.isRoot && inBuilder
$: requiredRows = calculateRequiredRows($children, mobile, addEmptyRows)
$: requiredHeight = requiredRows * GridRowHeight
$: availableRows = Math.floor(height / GridRowHeight)
$: rows = Math.max(requiredRows, availableRows)
$: mobile = $context.device.mobile
$: empty = $component.empty
$: colSize = width / GridColumns
$: styles.set({
...$component.styles,
@ -40,7 +34,6 @@
"--col-size": colSize,
"--row-size": GridRowHeight,
},
empty: false,
})
// Calculates the minimum number of rows required to render all child
@ -145,9 +138,7 @@
{/each}
</div>
{/if}
<!-- Only render the slot if not empty, as we don't want the placeholder -->
{#if !empty && mounted}
{#if mounted}
<slot />
{/if}
</div>

7
packages/client/src/components/preview/DNDPlaceholderOverlay.svelte
View File

@ -6,8 +6,11 @@
let left, top, height, width
const updatePosition = () => {
const node =
document.getElementsByClassName(DNDPlaceholderID)[0]?.childNodes[0]
let node = document.getElementsByClassName(DNDPlaceholderID)[0]
const insideGrid = node?.dataset.insideGrid === "true"
if (!insideGrid) {
node = document.getElementsByClassName(`${DNDPlaceholderID}-dom`)[0]
}
if (!node) {
height = 0
width = 0

2
packages/client/src/components/preview/HoverIndicator.svelte
View File

@ -19,7 +19,7 @@
newId = e.target.dataset.id
} else {
// Handle normal components
const element = e.target.closest(".interactive.component")
const element = e.target.closest(".interactive.component:not(.root)")
newId = element?.dataset?.id
}

12
packages/client/src/stores/dnd.js
View File

@ -1,5 +1,5 @@
import { writable } from "svelte/store"
import { computed } from "../utils/computed.js"
import { derivedMemo } from "@budibase/frontend-core"
const createDndStore = () => {
const initialState = {
@ -78,11 +78,11 @@ export const dndStore = createDndStore()
// performance by deriving any state that needs to be externally observed.
// By doing this and using primitives, we can avoid invalidating other stores
// or components which depend on DND state unless values actually change.
export const dndParent = computed(dndStore, x => x.drop?.parent)
export const dndIndex = computed(dndStore, x => x.drop?.index)
export const dndBounds = computed(dndStore, x => x.source?.bounds)
export const dndIsDragging = computed(dndStore, x => !!x.source)
export const dndIsNewComponent = computed(
export const dndParent = derivedMemo(dndStore, x => x.drop?.parent)
export const dndIndex = derivedMemo(dndStore, x => x.drop?.index)
export const dndBounds = derivedMemo(dndStore, x => x.source?.bounds)
export const dndIsDragging = derivedMemo(dndStore, x => !!x.source)
export const dndIsNewComponent = derivedMemo(
dndStore,
x => x.source?.newComponentType != null
)

2
packages/client/src/stores/screens.js
View File

@ -92,6 +92,8 @@ const createScreenStore = () => {
width: `${$dndBounds?.width || 400}px`,
height: `${$dndBounds?.height || 200}px`,
opacity: 0,
"--default-width": $dndBounds?.width || 400,
"--default-height": $dndBounds?.height || 200,
},
},
static: true,

38
packages/client/src/utils/computed.js
View File

@ -1,38 +0,0 @@
import { writable } from "svelte/store"
/**
* Extension of Svelte's built in "derived" stores, which the addition of deep
* comparison of non-primitives. Falls back to using shallow comparison for
* primitive types to avoid performance penalties.
* Useful for instances where a deep comparison is cheaper than an additional
* store invalidation.
* @param store the store to observer
* @param deriveValue the derivation function
* @returns {Writable<*>} a derived svelte store containing just the derived value
*/
export const computed = (store, deriveValue) => {
const initialValue = deriveValue(store)
const computedStore = writable(initialValue)
let lastKey = getKey(initialValue)
store.subscribe(state => {
const value = deriveValue(state)
const key = getKey(value)
if (key !== lastKey) {
lastKey = key
computedStore.set(value)
}
})
return computedStore
}
// Helper function to serialise any value into a primitive which can be cheaply
// and shallowly compared
const getKey = value => {
if (value == null || typeof value !== "object") {
return value
} else {
return JSON.stringify(value)
}
}

8
packages/client/src/utils/grid.js
View File

@ -92,8 +92,12 @@ export const gridLayout = (node, metadata) => {
}
// Determine default width and height of component
let width = errored ? 500 : definition?.size?.width || 200
let height = errored ? 60 : definition?.size?.height || 200
let width = styles["--default-width"] ?? definition?.size?.width ?? 200
let height = styles["--default-height"] ?? definition?.size?.height ?? 200
if (errored) {
width = 500
height = 60
}
width += 2 * GridSpacing
height += 2 * GridSpacing
let vars = {

2
packages/client/src/utils/styleable.js
View File

@ -93,7 +93,7 @@ export const styleable = (node, styles = {}) => {
node.addEventListener("mouseout", applyNormalStyles)
// Add builder preview click listener
if (newStyles.interactive) {
if (newStyles.interactive && !newStyles.isRoot) {
node.addEventListener("click", selectComponent, false)
node.addEventListener("dblclick", editComponent, false)
}

84
packages/frontend-core/src/components/grid/cells/RelationshipCell.svelte
View File

@ -29,6 +29,7 @@
let searching = false
let container
let anchor
let relationshipFields
$: fieldValue = parseValue(value)
$: oneRowOnly = schema?.relationshipType === "one-to-many"
@ -41,6 +42,26 @@
}
}
$: relationFields = fieldValue?.reduce((acc, f) => {
const fields = {}
for (const [column] of Object.entries(schema?.columns || {}).filter(
([key, column]) =>
column.visible !== false && f[key] !== null && f[key] !== undefined
)) {
fields[column] = f[column]
}
if (Object.keys(fields).length) {
acc[f._id] = fields
}
return acc
}, {})
$: showRelationshipFields =
relationshipFields &&
Object.keys(relationshipFields).length &&
focused &&
!isOpen
const parseValue = value => {
if (Array.isArray(value) && value.every(x => x?._id)) {
return value
@ -221,6 +242,14 @@
return value
}
const displayRelationshipFields = relationship => {
relationshipFields = relationFields[relationship._id]
}
const hideRelationshipFields = () => {
relationshipFields = undefined
}
onMount(() => {
api = {
focus: open,
@ -244,11 +273,18 @@
<div
class="values"
class:wrap={editable || contentLines > 1}
class:disabled={!focused}
on:wheel={e => (focused ? e.stopPropagation() : null)}
>
{#each fieldValue || [] as relationship}
{#if relationship[primaryDisplay] || relationship.primaryDisplay}
<div class="badge">
<div
class="badge"
class:extra-info={!!relationFields[relationship._id]}
on:mouseover={() => displayRelationshipFields(relationship)}
on:focus={() => {}}
on:mouseleave={() => hideRelationshipFields()}
>
<span>
{readable(
relationship[primaryDisplay] || relationship.primaryDisplay
@ -322,6 +358,21 @@
</GridPopover>
{/if}
{#if showRelationshipFields}
<GridPopover {anchor} minWidth={300} maxWidth={400}>
<div class="relationship-fields">
{#each Object.entries(relationshipFields) as [fieldName, fieldValue]}
<div class="relationship-field-name">
{fieldName}
</div>
<div class="relationship-field-value">
{fieldValue}
</div>
{/each}
</div>
</GridPopover>
{/if}
<style>
.wrapper {
flex: 1 1 auto;
@ -376,6 +427,9 @@
padding: var(--cell-padding);
flex-wrap: nowrap;
}
.values.disabled {
pointer-events: none;
}
.values.wrap {
flex-wrap: wrap;
}
@ -407,6 +461,13 @@
height: 20px;
max-width: 100%;
}
.values.wrap .badge:hover {
filter: brightness(1.25);
}
.values.wrap .badge.extra-info {
cursor: pointer;
}
.badge span {
overflow: hidden;
white-space: nowrap;
@ -478,4 +539,25 @@
.search :global(.spectrum-Form-item) {
flex: 1 1 auto;
}
.relationship-fields {
margin: var(--spacing-m) var(--spacing-l);
display: grid;
grid-template-columns: minmax(auto, 50%) auto;
grid-row-gap: var(--spacing-m);
grid-column-gap: var(--spacing-m);
}
.relationship-field-name {
text-transform: uppercase;
color: var(--spectrum-global-color-gray-600);
font-size: var(--font-size-xs);
}
.relationship-field-value {
overflow: hidden;
display: -webkit-box;
-webkit-box-orient: vertical;
-webkit-line-clamp: 3;
line-clamp: 3;
}
</style>

21
packages/frontend-core/src/components/grid/controls/ColumnsSettingButton.svelte
View File

@ -2,16 +2,29 @@
import { getContext } from "svelte"
import { ActionButton, Popover } from "@budibase/bbui"
import ColumnsSettingContent from "./ColumnsSettingContent.svelte"
import { FieldPermissions } from "../../../constants"
export let allowViewReadonlyColumns = false
const { columns } = getContext("grid")
const { columns, datasource } = getContext("grid")
let open = false
let anchor
$: anyRestricted = $columns.filter(col => !col.visible || col.readonly).length
$: text = anyRestricted ? `Columns (${anyRestricted} restricted)` : "Columns"
$: permissions =
$datasource.type === "viewV2"
? [
FieldPermissions.WRITABLE,
FieldPermissions.READONLY,
FieldPermissions.HIDDEN,
]
: [FieldPermissions.WRITABLE, FieldPermissions.HIDDEN]
$: disabledPermissions = allowViewReadonlyColumns
? []
: [FieldPermissions.READONLY]
</script>
<div bind:this={anchor}>
@ -28,5 +41,9 @@
</div>
<Popover bind:open {anchor} align="left">
<ColumnsSettingContent columns={$columns} {allowViewReadonlyColumns} />
<ColumnsSettingContent
columns={$columns}
{permissions}
{disabledPermissions}
/>
</Popover>

266
packages/frontend-core/src/components/grid/controls/ColumnsSettingContent.svelte
View File

@ -1,22 +1,162 @@
<script>
import { getContext } from "svelte"
import { Icon, notifications } from "@budibase/bbui"
import { Icon, notifications, ActionButton, Popover } from "@budibase/bbui"
import { getColumnIcon } from "../lib/utils"
import ToggleActionButtonGroup from "./ToggleActionButtonGroup.svelte"
import { helpers } from "@budibase/shared-core"
import { FieldType } from "@budibase/types"
import { FieldPermissions } from "../../../constants"
export let allowViewReadonlyColumns = false
export let permissions = [FieldPermissions.WRITABLE, FieldPermissions.HIDDEN]
export let disabledPermissions = []
export let columns
export let fromRelationshipField
const { columns, datasource, dispatch } = getContext("grid")
const { datasource, dispatch, cache, config } = getContext("grid")
const toggleColumn = async (column, permission) => {
const visible = permission !== PERMISSION_OPTIONS.HIDDEN
const readonly = permission === PERMISSION_OPTIONS.READONLY
$: canSetRelationshipSchemas = $config.canSetRelationshipSchemas
await datasource.actions.addSchemaMutation(column.name, {
visible,
readonly,
let relationshipPanelAnchor
let relationshipFieldName
$: relationshipField = columns.find(
c => c.name === relationshipFieldName
)?.schema
$: permissionsObj = permissions.reduce(
(acc, c) => ({
...acc,
[c]: {
disabled: disabledPermissions.includes(c),
},
}),
{}
)
$: displayColumns = columns.map(c => {
const isRequired =
c.primaryDisplay || helpers.schema.isRequired(c.schema.constraints)
const defaultPermission = permissions[0]
const requiredTooltips = {
[FieldPermissions.WRITABLE]: (() => {
if (defaultPermission === FieldPermissions.WRITABLE) {
if (c.primaryDisplay) {
return "Display column must be writable"
}
if (isRequired) {
return "Required columns must be writable"
}
}
})(),
[FieldPermissions.READONLY]: (() => {
if (defaultPermission === FieldPermissions.WRITABLE) {
if (c.primaryDisplay) {
return "Display column cannot be read-only"
}
if (isRequired) {
return "Required columns cannot be read-only"
}
}
if (defaultPermission === FieldPermissions.READONLY) {
if (c.primaryDisplay) {
return "Display column must be read-only"
}
if (isRequired) {
return "Required columns must be read-only"
}
}
})(),
[FieldPermissions.HIDDEN]: (() => {
if (c.primaryDisplay) {
return "Display column cannot be hidden"
}
if (isRequired) {
return "Required columns cannot be hidden"
}
})(),
}
const options = []
let permission
if ((permission = permissionsObj[FieldPermissions.WRITABLE])) {
const tooltip = requiredTooltips[FieldPermissions.WRITABLE] || "Writable"
options.push({
icon: "Edit",
value: FieldPermissions.WRITABLE,
tooltip,
disabled: isRequired || permission.disabled,
})
}
if ((permission = permissionsObj[FieldPermissions.READONLY])) {
const tooltip =
(requiredTooltips[FieldPermissions.READONLY] || "Read-only") +
(permission.disabled ? " (premium feature)" : "")
options.push({
icon: "Visibility",
value: FieldPermissions.READONLY,
tooltip,
disabled: permission.disabled || isRequired,
})
}
if ((permission = permissionsObj[FieldPermissions.HIDDEN])) {
const tooltip = requiredTooltips[FieldPermissions.HIDDEN] || "Hidden"
options.push({
icon: "VisibilityOff",
value: FieldPermissions.HIDDEN,
disabled: permission.disabled || isRequired,
tooltip,
})
}
return { ...c, options }
})
let relationshipPanelColumns = []
async function fetchRelationshipPanelColumns(relationshipField) {
relationshipPanelColumns = []
if (!relationshipField) {
return
}
const table = await cache.actions.getTable(relationshipField.tableId)
relationshipPanelColumns = Object.entries(
relationshipField?.columns || {}
).map(([name, column]) => {
return {
name: name,
label: name,
schema: {
type: table.schema[name].type,
visible: column.visible,
readonly: column.readonly,
},
}
})
}
$: fetchRelationshipPanelColumns(relationshipField)
async function toggleColumn(column, permission) {
const visible = permission !== FieldPermissions.HIDDEN
const readonly = permission === FieldPermissions.READONLY
if (!fromRelationshipField) {
await datasource.actions.addSchemaMutation(column.name, {
visible,
readonly,
})
} else {
await datasource.actions.addSubSchemaMutation(
column.name,
fromRelationshipField.name,
{
visible,
readonly,
}
)
}
try {
await datasource.actions.saveSchemaMutations()
} catch (e) {
@ -28,60 +168,16 @@
dispatch(visible ? "show-column" : "hide-column")
}
const PERMISSION_OPTIONS = {
WRITABLE: "writable",
READONLY: "readonly",
HIDDEN: "hidden",
}
$: displayColumns = $columns.map(c => {
const isRequired = helpers.schema.isRequired(c.schema.constraints)
const requiredTooltip = isRequired && "Required columns must be writable"
const editEnabled =
!isRequired ||
columnToPermissionOptions(c) !== PERMISSION_OPTIONS.WRITABLE
const options = [
{
icon: "Edit",
value: PERMISSION_OPTIONS.WRITABLE,
tooltip: (!editEnabled && requiredTooltip) || "Writable",
disabled: !editEnabled,
},
]
if ($datasource.type === "viewV2") {
options.push({
icon: "Visibility",
value: PERMISSION_OPTIONS.READONLY,
tooltip: allowViewReadonlyColumns
? requiredTooltip || "Read only"
: "Read only (premium feature)",
disabled: !allowViewReadonlyColumns || isRequired,
})
}
options.push({
icon: "VisibilityOff",
value: PERMISSION_OPTIONS.HIDDEN,
disabled: c.primaryDisplay || isRequired,
tooltip:
(c.primaryDisplay && "Display column cannot be hidden") ||
requiredTooltip ||
"Hidden",
})
return { ...c, options }
})
function columnToPermissionOptions(column) {
if (column.schema.visible === false) {
return PERMISSION_OPTIONS.HIDDEN
return FieldPermissions.HIDDEN
}
if (column.schema.readonly) {
return PERMISSION_OPTIONS.READONLY
return FieldPermissions.READONLY
}
return PERMISSION_OPTIONS.WRITABLE
return FieldPermissions.WRITABLE
}
</script>
@ -94,16 +190,56 @@
{column.label}
</div>
</div>
<ToggleActionButtonGroup
on:click={e => toggleColumn(column, e.detail)}
value={columnToPermissionOptions(column)}
options={column.options}
/>
<div class="column-options">
<ToggleActionButtonGroup
on:click={e => toggleColumn(column, e.detail)}
value={columnToPermissionOptions(column)}
options={column.options}
/>
{#if canSetRelationshipSchemas && column.schema.type === FieldType.LINK && columnToPermissionOptions(column) !== FieldPermissions.HIDDEN}
<div class="relationship-columns">
<ActionButton
on:click={e => {
relationshipFieldName = column.name
relationshipPanelAnchor = e.currentTarget
}}
size="S"
icon="ChevronRight"
quiet
/>
</div>
{/if}
</div>
{/each}
</div>
</div>
{#if canSetRelationshipSchemas}
<Popover
on:close={() => (relationshipFieldName = null)}
open={relationshipFieldName}
anchor={relationshipPanelAnchor}
align="left"
>
{#if relationshipPanelColumns.length}
<div class="relationship-header">
{relationshipFieldName} columns
</div>
{/if}
<svelte:self
columns={relationshipPanelColumns}
permissions={[FieldPermissions.READONLY, FieldPermissions.HIDDEN]}
fromRelationshipField={relationshipField}
/>
</Popover>
{/if}
<style>
.relationship-columns :global(.spectrum-ActionButton) {
width: 28px;
height: 28px;
}
.content {
padding: 12px 12px;
display: flex;
@ -131,4 +267,12 @@
white-space: nowrap;
overflow: hidden;
}
.column-options {
display: flex;
gap: var(--spacing-xs);
}
.relationship-header {
color: var(--spectrum-global-color-gray-600);
padding: 12px 12px 0 12px;
}
</style>

2
packages/frontend-core/src/components/grid/layout/Grid.svelte
View File

@ -43,6 +43,7 @@
export let canDeleteRows = true
export let canEditColumns = true
export let canSaveSchema = true
export let canSetRelationshipSchemas = false
export let stripeRows = false
export let quiet = false
export let collaboration = true
@ -99,6 +100,7 @@
canDeleteRows,
canEditColumns,
canSaveSchema,
canSetRelationshipSchemas,
stripeRows,
quiet,
collaboration,

1
packages/frontend-core/src/components/grid/overlays/GridPopover.svelte
View File

@ -44,6 +44,7 @@
{wrap}
portalTarget="#{gridID} .grid-popover-container"
offset={0}
clickOutsideOverride
>
<div
class="grid-popover-contents"

37
packages/frontend-core/src/components/grid/stores/cache.js
View File

@ -4,35 +4,40 @@ export const createActions = context => {
// Cache for the primary display columns of different tables.
// If we ever need to cache table definitions for other purposes then we can
// expand this to be a more generic cache.
let primaryDisplayCache = {}
let tableCache = {}
const resetPrimaryDisplayCache = () => {
primaryDisplayCache = {}
const resetCache = () => {
tableCache = {}
}
const getPrimaryDisplayForTableId = async tableId => {
const fetchTable = async tableId => {
// If we've never encountered this tableId before then store a promise that
// resolves to the primary display so that subsequent invocations before the
// promise completes can reuse this promise
if (!primaryDisplayCache[tableId]) {
primaryDisplayCache[tableId] = new Promise(resolve => {
API.fetchTableDefinition(tableId).then(def => {
const display = def?.primaryDisplay || def?.schema?.[0]?.name
primaryDisplayCache[tableId] = display
resolve(display)
})
})
if (!tableCache[tableId]) {
tableCache[tableId] = API.fetchTableDefinition(tableId)
}
// We await the result so that we account for both promises and primitives
return await primaryDisplayCache[tableId]
return await tableCache[tableId]
}
const getPrimaryDisplayForTableId = async tableId => {
const table = await fetchTable(tableId)
const display = table?.primaryDisplay || table?.schema?.[0]?.name
return display
}
const getTable = async tableId => {
const table = await fetchTable(tableId)
return table
}
return {
cache: {
actions: {
getPrimaryDisplayForTableId,
resetPrimaryDisplayCache,
getTable,
resetCache,
},
},
}
@ -43,5 +48,5 @@ export const initialise = context => {
// Wipe the caches whenever the datasource changes to ensure we aren't
// storing any stale information
datasource.subscribe(cache.actions.resetPrimaryDisplayCache)
datasource.subscribe(cache.actions.resetCache)
}

62
packages/frontend-core/src/components/grid/stores/datasource.js
View File

@ -5,16 +5,24 @@ import { memo } from "../../../utils"
export const createStores = () => {
const definition = memo(null)
const schemaMutations = memo({})
const subSchemaMutations = memo({})
return {
definition,
schemaMutations,
subSchemaMutations,
}
}
export const deriveStores = context => {
const { API, definition, schemaOverrides, datasource, schemaMutations } =
context
const {
API,
definition,
schemaOverrides,
datasource,
schemaMutations,
subSchemaMutations,
} = context
const schema = derived(definition, $definition => {
let schema = getDatasourceSchema({
@ -40,8 +48,8 @@ export const deriveStores = context => {
// Derives the total enriched schema, made up of the saved schema and any
// prop and user overrides
const enrichedSchema = derived(
[schema, schemaOverrides, schemaMutations],
([$schema, $schemaOverrides, $schemaMutations]) => {
[schema, schemaOverrides, schemaMutations, subSchemaMutations],
([$schema, $schemaOverrides, $schemaMutations, $subSchemaMutations]) => {
if (!$schema) {
return null
}
@ -52,6 +60,18 @@ export const deriveStores = context => {
...$schemaOverrides?.[field],
...$schemaMutations[field],
}
if ($subSchemaMutations[field]) {
enrichedSchema[field].columns ??= {}
for (const [fieldName, mutation] of Object.entries(
$subSchemaMutations[field]
)) {
enrichedSchema[field].columns[fieldName] = {
...enrichedSchema[field].columns[fieldName],
...mutation,
}
}
}
})
return enrichedSchema
}
@ -83,6 +103,7 @@ export const createActions = context => {
viewV2,
nonPlus,
schemaMutations,
subSchemaMutations,
schema,
notifications,
} = context
@ -162,6 +183,25 @@ export const createActions = context => {
})
}
// Adds a nested schema mutation for a single field
const addSubSchemaMutation = (field, fromField, mutation) => {
if (!field || !fromField || !mutation) {
return
}
subSchemaMutations.update($subSchemaMutations => {
return {
...$subSchemaMutations,
[fromField]: {
...$subSchemaMutations[fromField],
[field]: {
...($subSchemaMutations[fromField] || {})[field],
...mutation,
},
},
}
})
}
// Adds schema mutations for multiple fields at once
const addSchemaMutations = mutations => {
const fields = Object.keys(mutations || {})
@ -188,6 +228,7 @@ export const createActions = context => {
}
const $definition = get(definition)
const $schemaMutations = get(schemaMutations)
const $subSchemaMutations = get(subSchemaMutations)
const $schema = get(schema)
let newSchema = {}
@ -197,6 +238,17 @@ export const createActions = context => {
...$schema[column],
...$schemaMutations[column],
}
if ($subSchemaMutations[column]) {
newSchema[column].columns ??= {}
for (const [fieldName, mutation] of Object.entries(
$subSchemaMutations[column]
)) {
newSchema[column].columns[fieldName] = {
...newSchema[column].columns[fieldName],
...mutation,
}
}
}
})
// Save the changes, then reset our local mutations
@ -209,6 +261,7 @@ export const createActions = context => {
const resetSchemaMutations = () => {
schemaMutations.set({})
subSchemaMutations.set({})
}
// Adds a row to the datasource
@ -255,6 +308,7 @@ export const createActions = context => {
canUseColumn,
changePrimaryDisplay,
addSchemaMutation,
addSubSchemaMutation,
addSchemaMutations,
saveSchemaMutations,
resetSchemaMutations,

10
packages/frontend-core/src/constants.js
View File

@ -76,7 +76,9 @@ export const ExtendedBudibaseRoleOptions = [
value: BudibaseRoles.Owner,
sortOrder: 0,
},
].concat(BudibaseRoleOptions)
]
.concat(BudibaseRoleOptions)
.concat(BudibaseRoleOptionsOld)
export const PlanType = {
FREE: "free",
@ -172,3 +174,9 @@ export const TypeIconMap = {
export const OptionColours = [...new Array(12).keys()].map(idx => {
return `hsla(${((idx + 1) * 222) % 360}, 90%, 75%, 0.3)`
})
export const FieldPermissions = {
WRITABLE: "writable",
READONLY: "readonly",
HIDDEN: "hidden",
}

15
packages/server/src/api/controllers/row/external.ts
View File

@ -38,7 +38,7 @@ export async function handleRequest<T extends Operation>(
}
export async function patch(ctx: UserCtx<PatchRowRequest, PatchRowResponse>) {
const { tableId } = utils.getSourceId(ctx)
const { tableId, viewId } = utils.getSourceId(ctx)
const { _id, ...rowData } = ctx.request.body
const table = await sdk.tables.getTable(tableId)
@ -77,6 +77,7 @@ export async function patch(ctx: UserCtx<PatchRowRequest, PatchRowResponse>) {
outputProcessing(table, row, {
squash: true,
preserveLinks: true,
fromViewId: viewId,
}),
outputProcessing(table, beforeRow, {
squash: true,
@ -163,14 +164,10 @@ export async function fetchEnrichedRow(ctx: UserCtx) {
},
includeSqlRelationships: IncludeRelationship.INCLUDE,
})
row[fieldName] = await outputProcessing<Row[]>(
linkedTable,
relatedRows.rows,
{
squash: true,
preserveLinks: true,
}
)
row[fieldName] = await outputProcessing(linkedTable, relatedRows.rows, {
squash: true,
preserveLinks: true,
})
}
return row
}

14
packages/server/src/api/controllers/row/index.ts
View File

@ -71,8 +71,10 @@ export async function patch(
}
export const save = async (ctx: UserCtx<Row, Row>) => {
const { tableId, viewId } = utils.getSourceId(ctx)
const sourceId = viewId || tableId
const appId = ctx.appId
const { tableId } = utils.getSourceId(ctx)
const body = ctx.request.body
// user metadata doesn't exist yet - don't allow creation
@ -85,9 +87,9 @@ export const save = async (ctx: UserCtx<Row, Row>) => {
return patch(ctx as UserCtx<PatchRowRequest, PatchRowResponse>)
}
const { row, table, squashed } = tableId.includes("datasource_plus")
? await sdk.rows.save(tableId, ctx.request.body, ctx.user?._id)
? await sdk.rows.save(sourceId, ctx.request.body, ctx.user?._id)
: await quotas.addRow(() =>
sdk.rows.save(tableId, ctx.request.body, ctx.user?._id)
sdk.rows.save(sourceId, ctx.request.body, ctx.user?._id)
)
ctx.status = 200
ctx.eventEmitter && ctx.eventEmitter.emitRow(`row:save`, appId, row, table)
@ -115,10 +117,12 @@ export async function fetch(ctx: any) {
}
export async function find(ctx: UserCtx<void, GetRowResponse>) {
const { tableId } = utils.getSourceId(ctx)
const { tableId, viewId } = utils.getSourceId(ctx)
const sourceId = viewId || tableId
const rowId = ctx.params.rowId
ctx.body = await sdk.rows.find(tableId, rowId)
const response = await sdk.rows.find(sourceId, rowId)
ctx.body = response
}
function isDeleteRows(input: any): input is DeleteRows {

3
packages/server/src/api/controllers/row/internal.ts
View File

@ -23,7 +23,7 @@ import { getLinkedTableIDs } from "../../../db/linkedRows/linkUtils"
import { flatten } from "lodash"
export async function patch(ctx: UserCtx<PatchRowRequest, PatchRowResponse>) {
const { tableId } = utils.getSourceId(ctx)
const { tableId, viewId } = utils.getSourceId(ctx)
const inputs = ctx.request.body
const isUserTable = tableId === InternalTables.USER_METADATA
let oldRow
@ -90,6 +90,7 @@ export async function patch(ctx: UserCtx<PatchRowRequest, PatchRowResponse>) {
const result = await finaliseRow(table, row, {
oldTable: dbTable,
updateFormula: true,
fromViewId: viewId,
})
return { ...result, oldRow }

13
packages/server/src/api/controllers/row/staticFormula.ts
View File

@ -123,7 +123,11 @@ export async function updateAllFormulasInTable(table: Table) {
export async function finaliseRow(
table: Table,
row: Row,
{ oldTable, updateFormula }: { oldTable?: Table; updateFormula: boolean } = {
{
oldTable,
updateFormula,
fromViewId,
}: { oldTable?: Table; updateFormula: boolean; fromViewId?: string } = {
updateFormula: true,
}
) {
@ -154,9 +158,8 @@ export async function finaliseRow(
if (updateFormula) {
await updateRelatedFormula(table, enrichedRow)
}
const squashed = await linkRows.squashLinksToPrimaryDisplay(
table,
enrichedRow
)
const squashed = await linkRows.squashLinks(table, enrichedRow, {
fromViewId,
})
return { row: enrichedRow, squashed, table }
}

5
packages/server/src/api/controllers/row/views.ts
View File

@ -75,8 +75,11 @@ export async function searchView(
})
const searchOptions: RequiredKeys<SearchViewRowRequest> &
RequiredKeys<Pick<RowSearchParams, "tableId" | "query" | "fields">> = {
RequiredKeys<
Pick<RowSearchParams, "tableId" | "viewId" | "query" | "fields">
> = {
tableId: view.tableId,
viewId: view.id,
query: enrichedQuery,
fields: viewFields,
...getSortOptions(body, view),

14
packages/server/src/api/controllers/table/index.ts
View File

@ -85,14 +85,19 @@ export async function fetch(ctx: UserCtx<void, FetchTablesResponse>) {
}
})
ctx.body = [...internal, ...external].map(sdk.tables.enrichViewSchemas)
const result: FetchTablesResponse = []
for (const table of [...internal, ...external]) {
result.push(await sdk.tables.enrichViewSchemas(table))
}
ctx.body = result
}
export async function find(ctx: UserCtx<void, TableResponse>) {
const tableId = ctx.params.tableId
const table = await sdk.tables.getTable(tableId)
ctx.body = sdk.tables.enrichViewSchemas(table)
const result = await sdk.tables.enrichViewSchemas(table)
ctx.body = result
}
export async function save(ctx: UserCtx<SaveTableRequest, SaveTableResponse>) {
@ -106,11 +111,14 @@ export async function save(ctx: UserCtx<SaveTableRequest, SaveTableResponse>) {
const api = pickApi({ table })
let savedTable = await api.save(ctx, renaming)
if (!table._id) {
savedTable = sdk.tables.enrichViewSchemas(savedTable)
savedTable = await sdk.tables.enrichViewSchemas(savedTable)
await events.table.created(savedTable)
} else {
await events.table.updated(savedTable)
}
if (renaming) {
await sdk.views.renameLinkedViews(savedTable, renaming)
}
if (isImport) {
await events.table.imported(savedTable)
}

29
packages/server/src/api/controllers/view/viewsV2.ts
View File

@ -3,11 +3,12 @@ import {
CreateViewRequest,
Ctx,
RequiredKeys,
ViewUIFieldMetadata,
UpdateViewRequest,
ViewResponse,
ViewResponseEnriched,
ViewV2,
ViewFieldMetadata,
RelationSchemaField,
} from "@budibase/types"
import { builderSocket, gridSocket } from "../../../websockets"
@ -18,21 +19,41 @@ async function parseSchema(view: CreateViewRequest) {
const finalViewSchema =
view.schema &&
Object.entries(view.schema).reduce((p, [fieldName, schemaValue]) => {
const fieldSchema: RequiredKeys<ViewUIFieldMetadata> = {
let fieldRelatedSchema:
| Record<string, RequiredKeys<RelationSchemaField>>
| undefined
if (schemaValue.columns) {
fieldRelatedSchema = Object.entries(schemaValue.columns).reduce<
NonNullable<typeof fieldRelatedSchema>
>((acc, [key, fieldSchema]) => {
acc[key] = {
visible: fieldSchema.visible,
readonly: fieldSchema.readonly,
}
return acc
}, {})
}
const fieldSchema: RequiredKeys<
ViewFieldMetadata & {
columns: typeof fieldRelatedSchema
}
> = {
order: schemaValue.order,
width: schemaValue.width,
visible: schemaValue.visible,
readonly: schemaValue.readonly,
icon: schemaValue.icon,
columns: fieldRelatedSchema,
}
Object.entries(fieldSchema)
.filter(([, val]) => val === undefined)
.forEach(([key]) => {
delete fieldSchema[key as keyof ViewUIFieldMetadata]
delete fieldSchema[key as keyof ViewFieldMetadata]
})
p[fieldName] = fieldSchema
return p
}, {} as Record<string, RequiredKeys<ViewUIFieldMetadata>>)
}, {} as Record<string, RequiredKeys<ViewFieldMetadata>>)
return finalViewSchema
}

99
packages/server/src/api/routes/tests/automation.spec.ts
View File

@ -15,6 +15,7 @@ import { Automation, FieldType, Table } from "@budibase/types"
import { mocks } from "@budibase/backend-core/tests"
import { FilterConditions } from "../../../automations/steps/filter"
import { removeDeprecated } from "../../../automations/utils"
import { createAutomationBuilder } from "../../../automations/tests/utilities/AutomationTestBuilder"
const MAX_RETRIES = 4
let {
@ -121,6 +122,104 @@ describe("/automations", () => {
expect(events.automation.stepCreated).toHaveBeenCalledTimes(2)
})
it("Should ensure you can't have a branch as not a last step", async () => {
const automation = createAutomationBuilder({
name: "String Equality Branching",
appId: config.getAppId(),
})
.appAction({ fields: { status: "active" } })
.branch({
activeBranch: {
steps: stepBuilder =>
stepBuilder.serverLog({ text: "Active user" }),
condition: {
equal: { "trigger.fields.status": "active" },
},
},
})
.serverLog({ text: "Inactive user" })
.build()
await config.api.automation.post(automation, {
status: 400,
body: {
message:
"Invalid body - Branch steps are only allowed as the last step",
},
})
})
it("Should check validation on an automation that has a branch step with no children", async () => {
const automation = createAutomationBuilder({
name: "String Equality Branching",
appId: config.getAppId(),
})
.appAction({ fields: { status: "active" } })
.branch({})
.serverLog({ text: "Inactive user" })
.build()
await config.api.automation.post(automation, {
status: 400,
body: {
message:
'Invalid body - "definition.steps[0].inputs.branches" must contain at least 1 items',
},
})
})
it("Should check validation on a branch step with empty conditions", async () => {
const automation = createAutomationBuilder({
name: "String Equality Branching",
appId: config.getAppId(),
})
.appAction({ fields: { status: "active" } })
.branch({
activeBranch: {
steps: stepBuilder =>
stepBuilder.serverLog({ text: "Active user" }),
condition: {},
},
})
.build()
await config.api.automation.post(automation, {
status: 400,
body: {
message:
'Invalid body - "definition.steps[0].inputs.branches[0].condition" must have at least 1 key',
},
})
})
it("Should check validation on an branch that has a condition that is not valid", async () => {
const automation = createAutomationBuilder({
name: "String Equality Branching",
appId: config.getAppId(),
})
.appAction({ fields: { status: "active" } })
.branch({
activeBranch: {
steps: stepBuilder =>
stepBuilder.serverLog({ text: "Active user" }),
condition: {
//@ts-ignore
INCORRECT: { "trigger.fields.status": "active" },
},
},
})
.serverLog({ text: "Inactive user" })
.build()
await config.api.automation.post(automation, {
status: 400,
body: {
message:
'Invalid body - "definition.steps[0].inputs.branches[0].condition.INCORRECT" is not allowed',
},
})
})
it("should apply authorization to endpoint", async () => {
const automation = newAutomation()
await checkBuilderEndpoint({

374
packages/server/src/api/routes/tests/row.spec.ts
View File

@ -40,6 +40,8 @@ import {
TableSchema,
JsonFieldSubType,
RowExportFormat,
FeatureFlag,
RelationSchemaField,
} from "@budibase/types"
import { generator, mocks } from "@budibase/backend-core/tests"
import _, { merge } from "lodash"
@ -1231,7 +1233,7 @@ describe.each([
})
it.each([{ not: "valid" }, { rows: 123 }, "invalid"])(
"Should ignore malformed/invalid delete request: %s",
"should ignore malformed/invalid delete request: %s",
async (request: any) => {
const rowUsage = await getRowUsage()
@ -2426,6 +2428,376 @@ describe.each([
})
})
// Upserting isn't yet supported in MSSQL or Oracle, see:
// https://github.com/knex/knex/pull/6050
!isMSSQL &&
!isOracle &&
describe("relationships", () => {
let tableId: string
let viewId: string
let auxData: Row[] = []
let flagCleanup: (() => void) | undefined
beforeAll(async () => {
flagCleanup = setCoreEnv({
TENANT_FEATURE_FLAGS: `*:${FeatureFlag.ENRICHED_RELATIONSHIPS}`,
})
const aux2Table = await config.api.table.save(saveTableRequest())
const aux2Data = await config.api.row.save(aux2Table._id!, {})
const auxTable = await config.api.table.save(
saveTableRequest({
primaryDisplay: "name",
schema: {
name: {
name: "name",
type: FieldType.STRING,
constraints: { presence: true },
},
age: {
name: "age",
type: FieldType.NUMBER,
constraints: { presence: true },
},
address: {
name: "address",
type: FieldType.STRING,
constraints: { presence: true },
visible: false,
},
link: {
name: "link",
type: FieldType.LINK,
tableId: aux2Table._id!,
relationshipType: RelationshipType.MANY_TO_MANY,
fieldName: "fk_aux",
constraints: { presence: true },
},
formula: {
name: "formula",
type: FieldType.FORMULA,
formula: "{{ any }}",
constraints: { presence: true },
},
},
})
)
const auxTableId = auxTable._id!
for (const name of generator.unique(() => generator.name(), 10)) {
auxData.push(
await config.api.row.save(auxTableId, {
name,
age: generator.age(),
address: generator.address(),
link: [aux2Data],
})
)
}
const table = await config.api.table.save(
saveTableRequest({
schema: {
title: {
name: "title",
type: FieldType.STRING,
constraints: { presence: true },
},
relWithNoSchema: {
name: "relWithNoSchema",
relationshipType: RelationshipType.ONE_TO_MANY,
type: FieldType.LINK,
tableId: auxTableId,
fieldName: "fk_relWithNoSchema",
constraints: { presence: true },
},
relWithEmptySchema: {
name: "relWithEmptySchema",
relationshipType: RelationshipType.ONE_TO_MANY,
type: FieldType.LINK,
tableId: auxTableId,
fieldName: "fk_relWithEmptySchema",
constraints: { presence: true },
},
relWithFullSchema: {
name: "relWithFullSchema",
relationshipType: RelationshipType.ONE_TO_MANY,
type: FieldType.LINK,
tableId: auxTableId,
fieldName: "fk_relWithFullSchema",
constraints: { presence: true },
},
relWithHalfSchema: {
name: "relWithHalfSchema",
relationshipType: RelationshipType.ONE_TO_MANY,
type: FieldType.LINK,
tableId: auxTableId,
fieldName: "fk_relWithHalfSchema",
constraints: { presence: true },
},
relWithIllegalSchema: {
name: "relWithIllegalSchema",
relationshipType: RelationshipType.ONE_TO_MANY,
type: FieldType.LINK,
tableId: auxTableId,
fieldName: "fk_relWithIllegalSchema",
constraints: { presence: true },
},
},
})
)
tableId = table._id!
const view = await config.api.viewV2.create({
name: generator.guid(),
tableId,
schema: {
title: {
visible: true,
},
relWithNoSchema: {
visible: true,
},
relWithEmptySchema: {
visible: true,
columns: {},
},
relWithFullSchema: {
visible: true,
columns: Object.keys(auxTable.schema).reduce<
Record<string, RelationSchemaField>
>((acc, c) => ({ ...acc, [c]: { visible: true } }), {}),
},
relWithHalfSchema: {
visible: true,
columns: {
name: { visible: true },
age: { visible: false, readonly: true },
},
},
relWithIllegalSchema: {
visible: true,
columns: {
name: { visible: true },
address: { visible: true },
unexisting: { visible: true },
},
},
},
})
viewId = view.id
})
afterAll(() => {
flagCleanup?.()
})
const testScenarios: [string, (row: Row) => Promise<Row> | Row][] = [
["get row", (row: Row) => config.api.row.get(viewId, row._id!)],
[
"from view search",
async (row: Row) => {
const { rows } = await config.api.viewV2.search(viewId)
return rows.find(r => r._id === row._id!)
},
],
["from original saved row", (row: Row) => row],
["from updated row", (row: Row) => config.api.row.save(viewId, row)],
]
it.each(testScenarios)(
"can retrieve rows with populated relationships (via %s)",
async (__, retrieveDelegate) => {
const otherRows = _.sampleSize(auxData, 5)
const row = await config.api.row.save(viewId, {
title: generator.word(),
relWithNoSchema: [otherRows[0]],
relWithEmptySchema: [otherRows[1]],
relWithFullSchema: [otherRows[2]],
relWithHalfSchema: [otherRows[3]],
relWithIllegalSchema: [otherRows[4]],
})
const retrieved = await retrieveDelegate(row)
expect(retrieved).toEqual(
expect.objectContaining({
title: row.title,
relWithNoSchema: [
{
_id: otherRows[0]._id,
primaryDisplay: otherRows[0].name,
},
],
relWithEmptySchema: [
{
_id: otherRows[1]._id,
primaryDisplay: otherRows[1].name,
},
],
relWithFullSchema: [
{
_id: otherRows[2]._id,
primaryDisplay: otherRows[2].name,
name: otherRows[2].name,
age: otherRows[2].age,
id: otherRows[2].id,
},
],
relWithHalfSchema: [
{
_id: otherRows[3]._id,
primaryDisplay: otherRows[3].name,
name: otherRows[3].name,
},
],
relWithIllegalSchema: [
{
_id: otherRows[4]._id,
primaryDisplay: otherRows[4].name,
name: otherRows[4].name,
},
],
})
)
}
)
it.each(testScenarios)(
"does not enrich relationships when not enabled (via %s)",
async (__, retrieveDelegate) => {
await withCoreEnv(
{
TENANT_FEATURE_FLAGS: ``,
},
async () => {
const otherRows = _.sampleSize(auxData, 5)
const row = await config.api.row.save(viewId, {
title: generator.word(),
relWithNoSchema: [otherRows[0]],
relWithEmptySchema: [otherRows[1]],
relWithFullSchema: [otherRows[2]],
relWithHalfSchema: [otherRows[3]],
relWithIllegalSchema: [otherRows[4]],
})
const retrieved = await retrieveDelegate(row)
expect(retrieved).toEqual(
expect.objectContaining({
title: row.title,
relWithNoSchema: [
{
_id: otherRows[0]._id,
primaryDisplay: otherRows[0].name,
},
],
relWithEmptySchema: [
{
_id: otherRows[1]._id,
primaryDisplay: otherRows[1].name,
},
],
relWithFullSchema: [
{
_id: otherRows[2]._id,
primaryDisplay: otherRows[2].name,
},
],
relWithHalfSchema: [
{
_id: otherRows[3]._id,
primaryDisplay: otherRows[3].name,
},
],
relWithIllegalSchema: [
{
_id: otherRows[4]._id,
primaryDisplay: otherRows[4].name,
},
],
})
)
}
)
}
)
it.each([
[
"from table fetch",
async (row: Row) => {
const rows = await config.api.row.fetch(tableId)
return rows.find(r => r._id === row._id!)
},
],
[
"from table search",
async (row: Row) => {
const { rows } = await config.api.row.search(tableId)
return rows.find(r => r._id === row._id!)
},
],
])(
"does not enrich when fetching from the table (via %s)",
async (__, retrieveDelegate) => {
const otherRows = _.sampleSize(auxData, 5)
const row = await config.api.row.save(viewId, {
title: generator.word(),
relWithNoSchema: [otherRows[0]],
relWithEmptySchema: [otherRows[1]],
relWithFullSchema: [otherRows[2]],
relWithHalfSchema: [otherRows[3]],
relWithIllegalSchema: [otherRows[4]],
})
const retrieved = await retrieveDelegate(row)
expect(retrieved).toEqual(
expect.objectContaining({
title: row.title,
relWithNoSchema: [
{
_id: otherRows[0]._id,
primaryDisplay: otherRows[0].name,
},
],
relWithEmptySchema: [
{
_id: otherRows[1]._id,
primaryDisplay: otherRows[1].name,
},
],
relWithFullSchema: [
{
_id: otherRows[2]._id,
primaryDisplay: otherRows[2].name,
},
],
relWithHalfSchema: [
{
_id: otherRows[3]._id,
primaryDisplay: otherRows[3].name,
},
],
relWithIllegalSchema: [
{
_id: otherRows[4]._id,
primaryDisplay: otherRows[4].name,
},
],
})
)
}
)
})
describe("Formula fields", () => {
let table: Table
let otherTable: Table

218
packages/server/src/api/routes/tests/rowAction.spec.ts
View File

@ -5,11 +5,10 @@ import {
CreateRowActionRequest,
DocumentType,
PermissionLevel,
Row,
RowActionResponse,
} from "@budibase/types"
import * as setup from "./utilities"
import { generator } from "@budibase/backend-core/tests"
import { generator, mocks } from "@budibase/backend-core/tests"
import { Expectations } from "../../../tests/utilities/api/base"
import { roles } from "@budibase/backend-core"
import { automations } from "@budibase/pro"
@ -651,13 +650,27 @@ describe("/rowsActions", () => {
})
describe("trigger", () => {
let row: Row
let viewId: string
let rowId: string
let rowAction: RowActionResponse
beforeEach(async () => {
row = await config.api.row.save(tableId, {})
const row = await config.api.row.save(tableId, {})
rowId = row._id!
rowAction = await createRowAction(tableId, createRowActionRequest())
viewId = (
await config.api.viewV2.create(
setup.structures.viewV2.createRequest(tableId)
)
).id
await config.api.rowAction.setViewPermission(
tableId,
viewId,
rowAction.id
)
await config.publish()
tk.travel(Date.now() + 100)
})
@ -672,21 +685,29 @@ describe("/rowsActions", () => {
}
it("can trigger an automation given valid data", async () => {
await config.api.rowAction.trigger(tableId, rowAction.id, {
rowId: row._id!,
})
expect(await getAutomationLogs()).toBeEmpty()
await config.api.rowAction.trigger(viewId, rowAction.id, { rowId })
const automationLogs = await getAutomationLogs()
expect(automationLogs).toEqual([
expect.objectContaining({
automationId: rowAction.automationId,
trigger: expect.objectContaining({
trigger: {
id: "trigger",
stepId: "ROW_ACTION",
inputs: null,
outputs: {
fields: {},
row: await config.api.row.get(tableId, row._id!),
table: await config.api.table.get(tableId),
row: await config.api.row.get(tableId, rowId),
table: {
...(await config.api.table.get(tableId)),
views: expect.anything(),
},
automation: expect.objectContaining({
_id: rowAction.automationId,
}),
},
}),
},
}),
])
})
@ -702,9 +723,7 @@ describe("/rowsActions", () => {
await config.api.rowAction.trigger(
viewId,
rowAction.id,
{
rowId: row._id!,
},
{ rowId },
{
status: 403,
body: {
@ -731,9 +750,9 @@ describe("/rowsActions", () => {
)
await config.publish()
await config.api.rowAction.trigger(viewId, rowAction.id, {
rowId: row._id!,
})
expect(await getAutomationLogs()).toBeEmpty()
await config.api.rowAction.trigger(viewId, rowAction.id, { rowId })
const automationLogs = await getAutomationLogs()
expect(automationLogs).toEqual([
@ -742,5 +761,170 @@ describe("/rowsActions", () => {
}),
])
})
describe("role permission checks", () => {
beforeAll(() => {
mocks.licenses.useViewPermissions()
})
afterAll(() => {
mocks.licenses.useCloudFree()
})
function createUser(role: string) {
return config.createUser({
admin: { global: false },
builder: {},
roles: { [config.getProdAppId()]: role },
})
}
const allowedRoleConfig = (() => {
function getRolesLowerThan(role: string) {
const result = Object.values(roles.BUILTIN_ROLE_IDS).filter(
r => r !== role && roles.lowerBuiltinRoleID(r, role) === r
)
return result
}
return Object.values(roles.BUILTIN_ROLE_IDS).flatMap(r =>
[r, ...getRolesLowerThan(r)].map(p => [r, p])
)
})()
const disallowedRoleConfig = (() => {
function getRolesHigherThan(role: string) {
const result = Object.values(roles.BUILTIN_ROLE_IDS).filter(
r => r !== role && roles.lowerBuiltinRoleID(r, role) === role
)
return result
}
return Object.values(roles.BUILTIN_ROLE_IDS).flatMap(r =>
getRolesHigherThan(r).map(p => [r, p])
)
})()
describe.each([
[
"view (with implicit views)",
async () => {
const viewId = (
await config.api.viewV2.create(
setup.structures.viewV2.createRequest(tableId)
)
).id
await config.api.rowAction.setViewPermission(
tableId,
viewId,
rowAction.id
)
return { permissionResource: viewId, triggerResouce: viewId }
},
],
[
"view (without implicit views)",
async () => {
const viewId = (
await config.api.viewV2.create(
setup.structures.viewV2.createRequest(tableId)
)
).id
await config.api.rowAction.setViewPermission(
tableId,
viewId,
rowAction.id
)
return { permissionResource: tableId, triggerResouce: viewId }
},
],
])("checks for %s", (_, getResources) => {
it.each(allowedRoleConfig)(
"allows triggering if the user has read permission (user %s, table %s)",
async (userRole, resourcePermission) => {
const { permissionResource, triggerResouce } = await getResources()
await config.api.permission.add({
level: PermissionLevel.READ,
resourceId: permissionResource,
roleId: resourcePermission,
})
const normalUser = await createUser(userRole)
await config.withUser(normalUser, async () => {
await config.publish()
await config.api.rowAction.trigger(
triggerResouce,
rowAction.id,
{ rowId },
{ status: 200 }
)
})
}
)
it.each(disallowedRoleConfig)(
"rejects if the user does not have table read permission (user %s, table %s)",
async (userRole, resourcePermission) => {
const { permissionResource, triggerResouce } = await getResources()
await config.api.permission.add({
level: PermissionLevel.READ,
resourceId: permissionResource,
roleId: resourcePermission,
})
const normalUser = await createUser(userRole)
await config.withUser(normalUser, async () => {
await config.publish()
await config.api.rowAction.trigger(
triggerResouce,
rowAction.id,
{ rowId },
{
status: 403,
body: { message: "User does not have permission" },
}
)
const automationLogs = await getAutomationLogs()
expect(automationLogs).toBeEmpty()
})
}
)
})
it.each(allowedRoleConfig)(
"does not allow running row actions for tables by default even",
async (userRole, resourcePermission) => {
await config.api.permission.add({
level: PermissionLevel.READ,
resourceId: tableId,
roleId: resourcePermission,
})
const normalUser = await createUser(userRole)
await config.withUser(normalUser, async () => {
await config.publish()
await config.api.rowAction.trigger(
tableId,
rowAction.id,
{ rowId },
{
status: 403,
body: {
message: `Row action '${rowAction.id}' is not enabled for table '${tableId}'`,
},
}
)
const automationLogs = await getAutomationLogs()
expect(automationLogs).toBeEmpty()
})
}
)
})
})
})

261
packages/server/src/api/routes/tests/viewV2.spec.ts
View File

@ -18,6 +18,10 @@ import {
ViewV2,
SearchResponse,
BasicOperator,
RelationshipType,
TableSchema,
ViewFieldMetadata,
RenameColumn,
} from "@budibase/types"
import { generator, mocks } from "@budibase/backend-core/tests"
import { DatabaseName, getDatasource } from "../../../integrations/tests/utils"
@ -1177,6 +1181,263 @@ describe.each([
)
})
})
describe("foreign relationship columns", () => {
const createAuxTable = () =>
config.api.table.save(
saveTableRequest({
primaryDisplay: "name",
schema: {
name: { name: "name", type: FieldType.STRING },
age: { name: "age", type: FieldType.NUMBER },
},
})
)
const createMainTable = async (
links: {
name: string
tableId: string
fk: string
}[]
) => {
const table = await config.api.table.save(
saveTableRequest({
schema: {},
})
)
await config.api.table.save({
...table,
schema: {
...table.schema,
...links.reduce<TableSchema>((acc, c) => {
acc[c.name] = {
name: c.name,
relationshipType: RelationshipType.ONE_TO_MANY,
type: FieldType.LINK,
tableId: c.tableId,
fieldName: c.fk,
constraints: { type: "array" },
}
return acc
}, {}),
},
})
return table
}
const createView = async (
tableId: string,
schema: Record<string, ViewFieldMetadata>
) =>
await config.api.viewV2.create({
name: generator.guid(),
tableId,
schema,
})
const renameColumn = async (table: Table, renaming: RenameColumn) => {
const newSchema = { ...table.schema }
newSchema[renaming.updated] = {
...table.schema[renaming.old],
name: renaming.updated,
}
delete newSchema[renaming.old]
await config.api.table.save({
...table,
schema: newSchema,
_rename: renaming,
})
}
it("updating a column will update link columns configuration", async () => {
let auxTable = await createAuxTable()
const table = await createMainTable([
{ name: "aux", tableId: auxTable._id!, fk: "fk_aux" },
])
// Refetch auxTable
auxTable = await config.api.table.get(auxTable._id!)
const view = await createView(table._id!, {
aux: {
visible: true,
columns: {
name: { visible: true, readonly: true },
age: { visible: true, readonly: true },
},
},
})
await renameColumn(auxTable, { old: "age", updated: "dob" })
const updatedView = await config.api.viewV2.get(view.id)
expect(updatedView).toEqual(
expect.objectContaining({
schema: expect.objectContaining({
aux: expect.objectContaining({
columns: {
id: { visible: false, readonly: false },
name: { visible: true, readonly: true },
dob: { visible: true, readonly: true },
},
}),
}),
})
)
})
it("handles multiple fields using the same table", async () => {
let auxTable = await createAuxTable()
const table = await createMainTable([
{ name: "aux", tableId: auxTable._id!, fk: "fk_aux" },
{ name: "aux2", tableId: auxTable._id!, fk: "fk_aux2" },
])
// Refetch auxTable
auxTable = await config.api.table.get(auxTable._id!)
const view = await createView(table._id!, {
aux: {
visible: true,
columns: {
name: { visible: true, readonly: true },
age: { visible: true, readonly: true },
},
},
aux2: {
visible: true,
columns: {
name: { visible: true, readonly: true },
age: { visible: true, readonly: true },
},
},
})
await renameColumn(auxTable, { old: "age", updated: "dob" })
const updatedView = await config.api.viewV2.get(view.id)
expect(updatedView).toEqual(
expect.objectContaining({
schema: expect.objectContaining({
aux: expect.objectContaining({
columns: {
id: { visible: false, readonly: false },
name: { visible: true, readonly: true },
dob: { visible: true, readonly: true },
},
}),
aux2: expect.objectContaining({
columns: {
id: { visible: false, readonly: false },
name: { visible: true, readonly: true },
dob: { visible: true, readonly: true },
},
}),
}),
})
)
})
it("does not rename columns with the same name but from other tables", async () => {
let auxTable = await createAuxTable()
let aux2Table = await createAuxTable()
const table = await createMainTable([
{ name: "aux", tableId: auxTable._id!, fk: "fk_aux" },
{ name: "aux2", tableId: aux2Table._id!, fk: "fk_aux2" },
])
// Refetch auxTable
auxTable = await config.api.table.get(auxTable._id!)
const view = await createView(table._id!, {
aux: {
visible: true,
columns: {
name: { visible: true, readonly: true },
},
},
aux2: {
visible: true,
columns: {
name: { visible: true, readonly: true },
},
},
})
await renameColumn(auxTable, { old: "name", updated: "fullName" })
const updatedView = await config.api.viewV2.get(view.id)
expect(updatedView).toEqual(
expect.objectContaining({
schema: expect.objectContaining({
aux: expect.objectContaining({
columns: {
id: { visible: false, readonly: false },
fullName: { visible: true, readonly: true },
age: { visible: false, readonly: false },
},
}),
aux2: expect.objectContaining({
columns: {
id: { visible: false, readonly: false },
name: { visible: true, readonly: true },
age: { visible: false, readonly: false },
},
}),
}),
})
)
})
it("updates all views references", async () => {
let auxTable = await createAuxTable()
const table1 = await createMainTable([
{ name: "aux", tableId: auxTable._id!, fk: "fk_aux_table1" },
])
const table2 = await createMainTable([
{ name: "aux", tableId: auxTable._id!, fk: "fk_aux_table2" },
])
// Refetch auxTable
auxTable = await config.api.table.get(auxTable._id!)
const viewSchema = {
aux: {
visible: true,
columns: {
name: { visible: true, readonly: true },
age: { visible: true, readonly: true },
},
},
}
const view1 = await createView(table1._id!, viewSchema)
const view2 = await createView(table1._id!, viewSchema)
const view3 = await createView(table2._id!, viewSchema)
await renameColumn(auxTable, { old: "age", updated: "dob" })
for (const view of [view1, view2, view3]) {
const updatedView = await config.api.viewV2.get(view.id)
expect(updatedView).toEqual(
expect.objectContaining({
schema: expect.objectContaining({
aux: expect.objectContaining({
columns: {
id: { visible: false, readonly: false },
name: { visible: true, readonly: true },
dob: { visible: true, readonly: true },
},
}),
}),
})
)
}
})
})
})
})

54
packages/server/src/api/routes/utils/validators.ts
View File

@ -1,6 +1,9 @@
import { auth, permissions } from "@budibase/backend-core"
import { DataSourceOperation } from "../../../constants"
import {
AutomationActionStepId,
AutomationStep,
AutomationStepType,
EmptyFilterOption,
SearchFilters,
Table,
@ -88,7 +91,8 @@ export function datasourceValidator() {
)
}
function filterObject() {
function filterObject(opts?: { unknown: boolean }) {
const { unknown = true } = opts || {}
const conditionalFilteringObject = () =>
Joi.object({
conditions: Joi.array().items(Joi.link("#schema")).required(),
@ -115,7 +119,7 @@ function filterObject() {
fuzzyOr: Joi.forbidden(),
documentType: Joi.forbidden(),
}
return Joi.object(filtersValidators).unknown(true).id("schema")
return Joi.object(filtersValidators).unknown(unknown).id("schema")
}
export function internalSearchValidator() {
@ -259,6 +263,11 @@ export function screenValidator() {
}
function generateStepSchema(allowStepTypes: string[]) {
const branchSchema = Joi.object({
name: Joi.string().required(),
condition: filterObject({ unknown: false }).required().min(1),
})
return Joi.object({
stepId: Joi.string().required(),
id: Joi.string().required(),
@ -267,11 +276,35 @@ function generateStepSchema(allowStepTypes: string[]) {
tagline: Joi.string().required(),
icon: Joi.string().required(),
params: Joi.object(),
inputs: Joi.when("stepId", {
is: AutomationActionStepId.BRANCH,
then: Joi.object({
branches: Joi.array().items(branchSchema).min(1).required(),
children: Joi.object()
.pattern(Joi.string(), Joi.array().items(Joi.link("#step")))
.required(),
}).required(),
otherwise: Joi.object(),
}),
args: Joi.object(),
type: Joi.string()
.required()
.valid(...allowStepTypes),
}).unknown(true)
})
.unknown(true)
.id("step")
}
const validateStepsArray = (
steps: AutomationStep[],
helpers: Joi.CustomHelpers
) => {
for (const step of steps.slice(0, -1)) {
if (step.stepId === AutomationActionStepId.BRANCH) {
return helpers.error("branchStepPosition")
}
}
}
export function automationValidator(existing = false) {
@ -284,9 +317,20 @@ export function automationValidator(existing = false) {
definition: Joi.object({
steps: Joi.array()
.required()
.items(generateStepSchema(["ACTION", "LOGIC"])),
trigger: generateStepSchema(["TRIGGER"]).allow(null),
.items(
generateStepSchema([
AutomationStepType.ACTION,
AutomationStepType.LOGIC,
])
)
.custom(validateStepsArray)
.messages({
branchStepPosition:
"Branch steps are only allowed as the last step",
}),
trigger: generateStepSchema([AutomationStepType.TRIGGER]).allow(null),
})
.required()
.unknown(true),
}).unknown(true)

5
packages/server/src/automations/actions.ts
View File

@ -16,6 +16,7 @@ import * as delay from "./steps/delay"
import * as queryRow from "./steps/queryRows"
import * as loop from "./steps/loop"
import * as collect from "./steps/collect"
import * as branch from "./steps/branch"
import * as triggerAutomationRun from "./steps/triggerAutomationRun"
import env from "../environment"
import {
@ -28,6 +29,7 @@ import {
} from "@budibase/types"
import sdk from "../sdk"
import { getAutomationPlugin } from "../utilities/fileSystem"
import { features } from "@budibase/backend-core"
type ActionImplType = ActionImplementations<
typeof env.SELF_HOSTED extends "true" ? Hosting.SELF : Hosting.CLOUD
@ -98,6 +100,9 @@ if (env.SELF_HOSTED) {
}
export async function getActionDefinitions() {
if (await features.flags.isEnabled("AUTOMATION_BRANCHING")) {
BUILTIN_ACTION_DEFINITIONS["BRANCH"] = branch.definition
}
const actionDefinitions = BUILTIN_ACTION_DEFINITIONS
if (env.SELF_HOSTED) {
const plugins = await sdk.plugins.fetch(PluginType.AUTOMATION)

40
packages/server/src/automations/tests/scenarios/scenarios.spec.ts
View File

@ -63,8 +63,8 @@ describe("Automation Scenarios", () => {
},
})
.run()
expect(results.steps[2].outputs.message).toContain("Branch 1.1")
expect(results.steps[3].outputs.status).toContain("branch1 branch taken")
expect(results.steps[4].outputs.message).toContain("Branch 1.1")
})
it("should execute correct branch based on string equality", async () => {
@ -91,8 +91,10 @@ describe("Automation Scenarios", () => {
},
})
.run()
expect(results.steps[0].outputs.message).toContain("Active user")
expect(results.steps[0].outputs.status).toContain(
"activeBranch branch taken"
)
expect(results.steps[1].outputs.message).toContain("Active user")
})
it("should handle multiple conditions with AND operator", async () => {
@ -124,7 +126,7 @@ describe("Automation Scenarios", () => {
})
.run()
expect(results.steps[0].outputs.message).toContain("Active admin user")
expect(results.steps[1].outputs.message).toContain("Active admin user")
})
it("should handle multiple conditions with OR operator", async () => {
@ -162,7 +164,7 @@ describe("Automation Scenarios", () => {
})
.run()
expect(results.steps[0].outputs.message).toContain("Special user")
expect(results.steps[1].outputs.message).toContain("Special user")
})
})
@ -362,6 +364,32 @@ describe("Automation Scenarios", () => {
}
)
})
it("should run an automation where a loop is used twice to ensure context correctness further down the tree", async () => {
const builder = createAutomationBuilder({
name: "Test Trigger with Loop and Create Row",
})
const results = await builder
.appAction({ fields: {} })
.loop({
option: LoopStepType.ARRAY,
binding: [1, 2, 3],
})
.serverLog({ text: "Message {{loop.currentItem}}" })
.serverLog({ text: "{{steps.1.iterations}}" })
.loop({
option: LoopStepType.ARRAY,
binding: [1, 2, 3],
})
.serverLog({ text: "{{loop.currentItem}}" })
.serverLog({ text: "{{steps.3.iterations}}" })
.run()
// We want to ensure that bindings are corr
expect(results.steps[1].outputs.message).toContain("- 3")
expect(results.steps[3].outputs.message).toContain("- 3")
})
})
describe("Row Automations", () => {

24
packages/server/src/automations/tests/utilities/AutomationTestBuilder.ts
View File

@ -179,7 +179,7 @@ class AutomationBuilder extends BaseStepBuilder {
private triggerOutputs: any
private triggerSet: boolean = false
constructor(options: { name?: string } = {}) {
constructor(options: { name?: string; appId?: string } = {}) {
super()
this.automationConfig = {
name: options.name || `Test Automation ${uuidv4()}`,
@ -188,7 +188,7 @@ class AutomationBuilder extends BaseStepBuilder {
trigger: {} as AutomationTrigger,
},
type: "automation",
appId: setup.getConfig().getAppId(),
appId: options.appId ?? setup.getConfig().getAppId(),
}
this.config = setup.getConfig()
}
@ -261,13 +261,14 @@ class AutomationBuilder extends BaseStepBuilder {
return this
}
branch(branchConfig: BranchConfig): {
run: () => Promise<AutomationResults>
} {
branch(branchConfig: BranchConfig): this {
this.addBranchStep(branchConfig)
return {
run: () => this.run(),
}
return this
}
build(): Automation {
this.automationConfig.definition.steps = this.steps
return this.automationConfig
}
async run() {
@ -275,7 +276,7 @@ class AutomationBuilder extends BaseStepBuilder {
throw new Error("Please add a trigger to this automation test")
}
this.automationConfig.definition.steps = this.steps
const automation = await this.config.createAutomation(this.automationConfig)
const automation = await this.config.createAutomation(this.build())
const results = await testAutomation(
this.config,
automation,
@ -295,6 +296,9 @@ class AutomationBuilder extends BaseStepBuilder {
}
}
export function createAutomationBuilder(options?: { name?: string }) {
export function createAutomationBuilder(options?: {
name?: string
appId?: string
}) {
return new AutomationBuilder(options)
}

63
packages/server/src/db/linkedRows/index.ts
View File

@ -11,14 +11,17 @@ import { USER_METDATA_PREFIX } from "../utils"
import partition from "lodash/partition"
import { getGlobalUsersFromMetadata } from "../../utilities/global"
import { processFormulas } from "../../utilities/rowProcessor"
import { context } from "@budibase/backend-core"
import { context, features } from "@budibase/backend-core"
import {
ContextUser,
FeatureFlag,
FieldType,
LinkDocumentValue,
Row,
Table,
TableSchema,
ViewFieldMetadata,
ViewV2,
} from "@budibase/types"
import sdk from "../../sdk"
@ -241,34 +244,78 @@ function getPrimaryDisplayValue(row: Row, table?: Table) {
}
}
export type SquashTableFields = Record<string, { visibleFieldNames: string[] }>
/**
* This function will take the given enriched rows and squash the links to only contain the primary display field.
* @param table The table from which the rows originated.
* @param enriched The pre-enriched rows (full docs) which are to be squashed.
* @param squashFields Per link column (key) define which columns are allowed while squashing.
* @returns The rows after having their links squashed to only contain the ID and primary display.
*/
export async function squashLinksToPrimaryDisplay(
export async function squashLinks<T = Row[] | Row>(
table: Table,
enriched: Row[] | Row
) {
enriched: T,
options?: {
fromViewId?: string
}
): Promise<T> {
const allowRelationshipSchemas = await features.flags.isEnabled(
FeatureFlag.ENRICHED_RELATIONSHIPS
)
let viewSchema: Record<string, ViewFieldMetadata> = {}
if (options?.fromViewId && allowRelationshipSchemas) {
const view = Object.values(table.views || {}).find(
(v): v is ViewV2 => sdk.views.isV2(v) && v.id === options?.fromViewId
)
viewSchema = view?.schema || {}
}
// will populate this as we find them
const linkedTables = [table]
const isArray = Array.isArray(enriched)
let enrichedArray = !isArray ? [enriched] : enriched
for (let row of enrichedArray) {
const enrichedArray = !isArray ? [enriched] : enriched
for (const row of enrichedArray) {
// 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 || {})) {
for (let [column, schema] of Object.entries(rowTable.schema)) {
if (schema.type !== FieldType.LINK || !Array.isArray(row[column])) {
continue
}
const newLinks = []
for (let link of row[column]) {
for (const link of row[column]) {
const linkTblId =
link.tableId || getRelatedTableForField(table.schema, column)
const linkedTable = await getLinkedTable(linkTblId!, linkedTables)
const obj: any = { _id: link._id }
obj.primaryDisplay = getPrimaryDisplayValue(link, linkedTable)
if (viewSchema[column]?.columns) {
const squashFields = Object.entries(viewSchema[column].columns)
.filter(([columnName, viewColumnConfig]) => {
const tableColumn = linkedTable.schema[columnName]
if (!tableColumn) {
return false
}
if (
[FieldType.LINK, FieldType.FORMULA].includes(tableColumn.type)
) {
return false
}
return (
tableColumn.visible !== false &&
viewColumnConfig.visible !== false
)
})
.map(([columnName]) => columnName)
for (const relField of squashFields) {
obj[relField] = link[relField]
}
}
newLinks.push(obj)
}
row[column] = newLinks

2
packages/server/src/middleware/authorized.ts
View File

@ -88,7 +88,7 @@ const authorized =
opts = { schema: false },
resourcePath?: string
) =>
async (ctx: any, next: any) => {
async (ctx: UserCtx, next: any) => {
// webhooks don't need authentication, each webhook unique
// also internal requests (between services) don't need authorized
if (isWebhookEndpoint(ctx) || ctx.internal) {

48
packages/server/src/middleware/triggerRowActionAuthorised.ts
View File

@ -1,40 +1,52 @@
import { Next } from "koa"
import { Ctx } from "@budibase/types"
import { paramSubResource } from "./resourceId"
import { PermissionLevel, PermissionType, UserCtx } from "@budibase/types"
import { docIds } from "@budibase/backend-core"
import * as utils from "../db/utils"
import sdk from "../sdk"
import { authorizedResource } from "./authorized"
export function triggerRowActionAuthorised(
sourcePath: string,
actionPath: string
) {
return async (ctx: Ctx, next: Next) => {
// Reusing the existing middleware to extract the value
paramSubResource(sourcePath, actionPath)(ctx, () => {})
const { resourceId: sourceId, subResourceId: rowActionId } = ctx
return async (ctx: UserCtx, next: Next) => {
async function getResourceIds() {
const sourceId: string = ctx.params[sourcePath]
const rowActionId: string = ctx.params[actionPath]
const isTableId = docIds.isTableId(sourceId)
const isViewId = utils.isViewID(sourceId)
if (!isTableId && !isViewId) {
ctx.throw(400, `'${sourceId}' is not a valid source id`)
const isTableId = docIds.isTableId(sourceId)
const isViewId = utils.isViewID(sourceId)
if (!isTableId && !isViewId) {
ctx.throw(400, `'${sourceId}' is not a valid source id`)
}
const tableId = isTableId
? sourceId
: utils.extractViewInfoFromID(sourceId).tableId
const viewId = isTableId ? undefined : sourceId
return { tableId, viewId, rowActionId }
}
const tableId = isTableId
? sourceId
: utils.extractViewInfoFromID(sourceId).tableId
const { tableId, viewId, rowActionId } = await getResourceIds()
// Check if the user has permissions to the table/view
await authorizedResource(
!viewId ? PermissionType.TABLE : PermissionType.VIEW,
PermissionLevel.READ,
sourcePath
)(ctx, () => {})
// Check is the row action can run for the given view/table
const rowAction = await sdk.rowActions.get(tableId, rowActionId)
if (isTableId && !rowAction.permissions.table.runAllowed) {
if (!viewId && !rowAction.permissions.table.runAllowed) {
ctx.throw(
403,
`Row action '${rowActionId}' is not enabled for table '${sourceId}'`
`Row action '${rowActionId}' is not enabled for table '${tableId}'`
)
} else if (isViewId && !rowAction.permissions.views[sourceId]?.runAllowed) {
} else if (viewId && !rowAction.permissions.views[viewId]?.runAllowed) {
ctx.throw(
403,
`Row action '${rowActionId}' is not enabled for view '${sourceId}'`
`Row action '${rowActionId}' is not enabled for view '${viewId}'`
)
}

2
packages/server/src/middleware/trimViewRowInfo.ts
View File

@ -28,7 +28,7 @@ export default async (ctx: Ctx<Row, Row>, next: Next) => {
}
// have to mutate the koa context, can't return
export async function trimNonViewFields(
async function trimNonViewFields(
row: Row,
view: ViewV2,
permission: "WRITE" | "READ"

18
packages/server/src/sdk/app/rowActions.ts
View File

@ -75,7 +75,7 @@ export async function create(tableId: string, rowAction: { name: string }) {
name: action.name,
automationId: automation._id!,
permissions: {
table: { runAllowed: true },
table: { runAllowed: false },
views: {},
},
}
@ -216,11 +216,15 @@ export async function run(tableId: any, rowActionId: any, rowId: string) {
const automation = await sdk.automations.get(rowAction.automationId)
const row = await sdk.rows.find(tableId, rowId)
await triggers.externalTrigger(automation, {
fields: {
row,
table,
await triggers.externalTrigger(
automation,
{
fields: {
row,
table,
},
appId: context.getAppId(),
},
appId: context.getAppId(),
})
{ getResponses: true }
)
}

10
packages/server/src/sdk/app/rows/external.ts
View File

@ -9,6 +9,7 @@ import {
} from "../../../utilities/rowProcessor"
import cloneDeep from "lodash/fp/cloneDeep"
import isEqual from "lodash/fp/isEqual"
import { tryExtractingTableAndViewId } from "./utils"
export async function getRow(
tableId: string,
@ -26,10 +27,11 @@ export async function getRow(
}
export async function save(
tableId: string,
tableOrViewId: string,
inputs: Row,
userId: string | undefined
) {
const { tableId, viewId } = tryExtractingTableAndViewId(tableOrViewId)
const table = await sdk.tables.getTable(tableId)
const { table: updatedTable, row } = await inputProcessing(
userId,
@ -63,6 +65,7 @@ export async function save(
row: await outputProcessing(table, row, {
preserveLinks: true,
squash: true,
fromViewId: viewId,
}),
}
} else {
@ -70,7 +73,9 @@ export async function save(
}
}
export async function find(tableId: string, rowId: string): Promise<Row> {
export async function find(tableOrViewId: string, rowId: string): Promise<Row> {
const { tableId, viewId } = tryExtractingTableAndViewId(tableOrViewId)
const row = await getRow(tableId, rowId, {
relationships: true,
})
@ -84,5 +89,6 @@ export async function find(tableId: string, rowId: string): Promise<Row> {
return await outputProcessing(table, row, {
squash: true,
preserveLinks: true,
fromViewId: viewId,
})
}

11
packages/server/src/sdk/app/rows/internal.ts
View File

@ -10,12 +10,14 @@ import {
import * as linkRows from "../../../db/linkedRows"
import { InternalTables } from "../../../db/utils"
import { getFullUser } from "../../../utilities/users"
import { tryExtractingTableAndViewId } from "./utils"
export async function save(
tableId: string,
tableOrViewId: string,
inputs: Row,
userId: string | undefined
) {
const { tableId, viewId } = tryExtractingTableAndViewId(tableOrViewId)
inputs.tableId = tableId
if (!inputs._rev && !inputs._id) {
@ -50,14 +52,17 @@ export async function save(
return finaliseRow(table, row, {
oldTable: dbTable,
updateFormula: true,
fromViewId: viewId,
})
}
export async function find(tableId: string, rowId: string): Promise<Row> {
export async function find(tableOrViewId: string, rowId: string): Promise<Row> {
const { tableId, viewId } = tryExtractingTableAndViewId(tableOrViewId)
const table = await sdk.tables.getTable(tableId)
let row = await findRow(tableId, rowId)
row = await outputProcessing(table, row)
row = await outputProcessing(table, row, { squash: true, fromViewId: viewId })
return row
}

21
packages/server/src/sdk/app/rows/rows.ts
View File

@ -1,6 +1,10 @@
import { db as dbCore, context } from "@budibase/backend-core"
import { Database, Row } from "@budibase/types"
import { getRowParams } from "../../../db/utils"
import {
extractViewInfoFromID,
getRowParams,
isViewID,
} from "../../../db/utils"
import { isExternalTableID } from "../../../integrations/utils"
import * as internal from "./internal"
import * as external from "./external"
@ -20,7 +24,12 @@ export async function getAllInternalRows(appId?: string) {
return response.rows.map(row => row.doc) as Row[]
}
function pickApi(tableId: any) {
function pickApi(tableOrViewId: string) {
let tableId = tableOrViewId
if (isViewID(tableOrViewId)) {
tableId = extractViewInfoFromID(tableOrViewId).tableId
}
if (isExternalTableID(tableId)) {
return external
}
@ -28,13 +37,13 @@ function pickApi(tableId: any) {
}
export async function save(
tableId: string,
tableOrViewId: string,
row: Row,
userId: string | undefined
) {
return pickApi(tableId).save(tableId, row, userId)
return pickApi(tableOrViewId).save(tableOrViewId, row, userId)
}
export async function find(tableId: string, rowId: string) {
return pickApi(tableId).find(tableId, rowId)
export async function find(tableOrViewId: string, rowId: string) {
return pickApi(tableOrViewId).find(tableOrViewId, rowId)
}

5
packages/server/src/sdk/app/rows/search/external.ts
View File

@ -112,9 +112,10 @@ export async function search(
: Promise.resolve(undefined),
])
let processed = await outputProcessing<Row[]>(table, rows, {
let processed = await outputProcessing(table, rows, {
preserveLinks: true,
squash: true,
fromViewId: options.viewId,
})
let hasNextPage = false
@ -260,7 +261,7 @@ export async function fetch(tableId: string): Promise<Row[]> {
includeSqlRelationships: IncludeRelationship.INCLUDE,
})
const table = await sdk.tables.getTable(tableId)
return await outputProcessing<Row[]>(table, response.rows, {
return await outputProcessing(table, response.rows, {
preserveLinks: true,
squash: true,
})

2
packages/server/src/sdk/app/rows/search/internal/internal.ts
View File

@ -61,7 +61,7 @@ export async function exportRows(
})
).rows.map(row => row.doc!)
result = await outputProcessing<Row[]>(table, response)
result = await outputProcessing(table, response)
} else if (query) {
let searchResponse = await sdk.rows.search({
tableId,

5
packages/server/src/sdk/app/rows/search/internal/lucene.ts
View File

@ -59,7 +59,10 @@ export async function search(
response.rows = response.rows.map((r: any) => pick(r, fields))
}
response.rows = await outputProcessing(table, response.rows)
response.rows = await outputProcessing(table, response.rows, {
squash: true,
fromViewId: options.viewId,
})
}
return response

3
packages/server/src/sdk/app/rows/search/internal/sqs.ts
View File

@ -390,9 +390,10 @@ export async function search(
}
// get the rows
let finalRows = await outputProcessing<Row[]>(table, processed, {
let finalRows = await outputProcessing(table, processed, {
preserveLinks: true,
squash: true,
fromViewId: options.viewId,
})
// check if we need to pick specific rows out

17
packages/server/src/sdk/app/rows/utils.ts
View File

@ -17,7 +17,11 @@ import {
import { makeExternalQuery } from "../../../integrations/base/query"
import { Format } from "../../../api/controllers/view/exporters"
import sdk from "../.."
import { isRelationshipColumn } from "../../../db/utils"
import {
extractViewInfoFromID,
isRelationshipColumn,
isViewID,
} from "../../../db/utils"
import { isSQL } from "../../../integrations/utils"
const SQL_CLIENT_SOURCE_MAP: Record<SourceName, SqlClient | undefined> = {
@ -317,3 +321,14 @@ function validateTimeOnlyField(
export function isArrayFilter(operator: any): operator is ArrayOperator {
return Object.values(ArrayOperator).includes(operator)
}
export function tryExtractingTableAndViewId(tableOrViewId: string) {
if (isViewID(tableOrViewId)) {
return {
tableId: extractViewInfoFromID(tableOrViewId).tableId,
viewId: tableOrViewId,
}
}
return { tableId: tableOrViewId }
}

21
packages/server/src/sdk/app/tables/getters.ts
View File

@ -143,16 +143,19 @@ export async function getTables(tableIds: string[]): Promise<Table[]> {
return await processTables(tables)
}
export function enrichViewSchemas(table: Table): TableResponse {
export async function enrichViewSchemas(table: Table): Promise<TableResponse> {
const views = []
for (const view of Object.values(table.views ?? [])) {
if (sdk.views.isV2(view)) {
views.push(await sdk.views.enrichSchema(view, table.schema))
} else views.push(view)
}
return {
...table,
views: Object.values(table.views ?? [])
.map(v =>
sdk.views.isV2(v) ? sdk.views.enrichSchema(v, table.schema) : v
)
.reduce((p, v) => {
p[v.name!] = v
return p
}, {} as TableViewsResponse),
views: views.reduce((p, v) => {
p[v.name!] = v
return p
}, {} as TableViewsResponse),
}
}

2
packages/server/src/sdk/app/tables/tests/tables.spec.ts
View File

@ -75,7 +75,7 @@ describe("table sdk", () => {
const view1 = getTable()
const view2 = getTable()
const view3 = getTable()
const res = sdk.tables.enrichViewSchemas({
const res = await sdk.tables.enrichViewSchemas({
...basicTable,
views: {
[view1.name]: view1,

2
packages/server/src/sdk/app/views/external.ts
View File

@ -33,7 +33,7 @@ export async function getEnriched(viewId: string): Promise<ViewV2Enriched> {
if (!found) {
throw new Error("No view found")
}
return enrichSchema(found, table.schema)
return await enrichSchema(found, table.schema)
}
export async function create(

108
packages/server/src/sdk/app/views/index.ts
View File

@ -1,8 +1,11 @@
import {
FieldType,
RelationSchemaField,
RenameColumn,
Table,
TableSchema,
View,
ViewUIFieldMetadata,
ViewFieldMetadata,
ViewV2,
ViewV2Enriched,
} from "@budibase/types"
@ -57,7 +60,7 @@ async function guardViewSchema(
if (viewSchema[field].readonly) {
if (
!(await features.isViewReadonlyColumnsEnabled()) &&
!(tableSchemaField as ViewUIFieldMetadata).readonly
!(tableSchemaField as ViewFieldMetadata).readonly
) {
throw new HTTPError(`Readonly fields are not enabled`, 400)
}
@ -158,24 +161,64 @@ export function allowedFields(
]
}
export function enrichSchema(
export async function enrichSchema(
view: ViewV2,
tableSchema: TableSchema
): ViewV2Enriched {
let schema: TableSchema = {}
const anyViewOrder = Object.values(view.schema || {}).some(
ui => ui.order != null
)
): Promise<ViewV2Enriched> {
const tableCache: Record<string, Table> = {}
async function populateRelTableSchema(
tableId: string,
viewFields: Record<string, RelationSchemaField>
) {
if (!tableCache[tableId]) {
tableCache[tableId] = await sdk.tables.getTable(tableId)
}
const relTable = tableCache[tableId]
const result: Record<string, RelationSchemaField> = {}
for (const relTableFieldName of Object.keys(relTable.schema)) {
const relTableField = relTable.schema[relTableFieldName]
if ([FieldType.LINK, FieldType.FORMULA].includes(relTableField.type)) {
continue
}
if (relTableField.visible === false) {
continue
}
const isVisible = !!viewFields[relTableFieldName]?.visible
const isReadonly = !!viewFields[relTableFieldName]?.readonly
result[relTableFieldName] = {
visible: isVisible,
readonly: isReadonly,
}
}
return result
}
let schema: ViewV2Enriched["schema"] = {}
const viewSchema = view.schema || {}
const anyViewOrder = Object.values(viewSchema).some(ui => ui.order != null)
for (const key of Object.keys(tableSchema).filter(
key => tableSchema[key].visible !== false
k => tableSchema[k].visible !== false
)) {
// if nothing specified in view, then it is not visible
const ui = view.schema?.[key] || { visible: false }
const ui = viewSchema[key] || { visible: false }
schema[key] = {
...tableSchema[key],
...ui,
order: anyViewOrder ? ui?.order ?? undefined : tableSchema[key].order,
}
if (schema[key].type === FieldType.LINK) {
schema[key].columns = await populateRelTableSchema(
schema[key].tableId,
viewSchema[key]?.columns || {}
)
}
}
return {
@ -209,3 +252,48 @@ export function syncSchema(
return view
}
export async function renameLinkedViews(table: Table, renaming: RenameColumn) {
const relatedTables: Record<string, Table> = {}
for (const field of Object.values(table.schema)) {
if (field.type !== FieldType.LINK) {
continue
}
relatedTables[field.tableId] ??= await sdk.tables.getTable(field.tableId)
}
for (const relatedTable of Object.values(relatedTables)) {
let toSave = false
const viewsV2 = Object.values(relatedTable.views || {}).filter(
sdk.views.isV2
)
if (!viewsV2) {
continue
}
for (const view of viewsV2) {
for (const relField of Object.keys(view.schema || {}).filter(f => {
const tableField = relatedTable.schema[f]
if (!tableField || tableField.type !== FieldType.LINK) {
return false
}
return tableField.tableId === table._id
})) {
const columns = view.schema?.[relField]?.columns
if (columns && columns[renaming.old]) {
columns[renaming.updated] = columns[renaming.old]
delete columns[renaming.old]
toSave = true
}
}
}
if (toSave) {
await sdk.tables.saveTable(relatedTable)
}
}
}

2
packages/server/src/sdk/app/views/internal.ts
View File

@ -24,7 +24,7 @@ export async function getEnriched(viewId: string): Promise<ViewV2Enriched> {
if (!found) {
throw new Error("No view found")
}
return enrichSchema(found, table.schema)
return await enrichSchema(found, table.schema)
}
export async function create(

100
packages/server/src/sdk/app/views/tests/views.spec.ts
View File

@ -3,6 +3,7 @@ import {
FieldSchema,
FieldType,
INTERNAL_TABLE_SOURCE_ID,
RelationshipType,
Table,
TableSchema,
TableSourceType,
@ -10,6 +11,7 @@ import {
} from "@budibase/types"
import { generator } from "@budibase/backend-core/tests"
import { enrichSchema, syncSchema } from ".."
import sdk from "../../../../sdk"
describe("table sdk", () => {
const basicTable: Table = {
@ -58,7 +60,7 @@ describe("table sdk", () => {
},
}
describe("enrichViewSchemas", () => {
describe("enrichSchema", () => {
it("should fetch the default schema if not overridden", async () => {
const tableId = basicTable._id!
const view: ViewV2 = {
@ -68,7 +70,7 @@ describe("table sdk", () => {
tableId,
}
const res = enrichSchema(view, basicTable.schema)
const res = await enrichSchema(view, basicTable.schema)
expect(res).toEqual({
...view,
@ -118,7 +120,7 @@ describe("table sdk", () => {
},
}
const res = enrichSchema(view, basicTable.schema)
const res = await enrichSchema(view, basicTable.schema)
expect(res).toEqual({
...view,
@ -152,7 +154,7 @@ describe("table sdk", () => {
},
}
const res = enrichSchema(view, basicTable.schema)
const res = await enrichSchema(view, basicTable.schema)
expect(res).toEqual({
...view,
@ -187,7 +189,7 @@ describe("table sdk", () => {
},
}
const res = enrichSchema(view, basicTable.schema)
const res = await enrichSchema(view, basicTable.schema)
expect(res).toEqual(
expect.objectContaining({
@ -241,7 +243,7 @@ describe("table sdk", () => {
},
}
const res = enrichSchema(view, basicTable.schema)
const res = await enrichSchema(view, basicTable.schema)
expect(res).toEqual(
expect.objectContaining({
@ -280,6 +282,92 @@ describe("table sdk", () => {
})
)
})
it("should include related fields", async () => {
const table: Table = {
...basicTable,
schema: {
name: {
name: "name",
type: FieldType.STRING,
},
other: {
name: "other",
type: FieldType.LINK,
relationshipType: RelationshipType.ONE_TO_MANY,
fieldName: "table",
tableId: "otherTableId",
},
},
}
const otherTable: Table = {
...basicTable,
primaryDisplay: "title",
schema: {
title: {
name: "title",
type: FieldType.STRING,
},
age: {
name: "age",
type: FieldType.NUMBER,
},
},
}
const tableId = table._id!
const getTableSpy = jest.spyOn(sdk.tables, "getTable")
getTableSpy.mockResolvedValueOnce(otherTable)
const view: ViewV2 = {
version: 2,
id: generator.guid(),
name: generator.guid(),
tableId,
schema: {
name: { visible: true },
other: {
visible: true,
columns: {
title: {
visible: true,
readonly: true,
},
},
},
},
}
const res = await enrichSchema(view, table.schema)
expect(res).toEqual(
expect.objectContaining({
...view,
schema: {
name: {
...table.schema.name,
visible: true,
},
other: {
...table.schema.other,
visible: true,
columns: {
title: {
visible: true,
readonly: true,
},
age: {
visible: false,
readonly: false,
},
},
},
},
})
)
})
})
describe("syncSchema", () => {

10
packages/server/src/tests/utilities/api/automation.ts
View File

@ -14,4 +14,14 @@ export class AutomationAPI extends TestAPI {
)
return result
}
post = async (
body: Automation,
expectations?: Expectations
): Promise<Automation> => {
const result = await this._post<Automation>(`/api/automations`, {
body,
expectations,
})
return result
}
}

21
packages/server/src/threads/automation.ts
View File

@ -449,7 +449,11 @@ class Orchestrator {
outputs: tempOutput,
inputs: steps[stepToLoopIndex].inputs,
})
this.context.steps[currentIndex + 1] = tempOutput
this.context.steps[this.context.steps.length] = tempOutput
this.context.steps = this.context.steps.filter(
item => !item.hasOwnProperty.call(item, "currentItem")
)
this.loopStepOutputs = []
}
@ -461,6 +465,19 @@ class Orchestrator {
for (const branch of branches) {
const condition = await this.evaluateBranchCondition(branch.condition)
if (condition) {
let branchStatus = {
status: `${branch.name} branch taken`,
success: true,
}
this.updateExecutionOutput(
branchStep.id,
branchStep.stepId,
branchStep.inputs,
branchStatus
)
this.context.steps[this.context.steps.length] = branchStatus
const branchSteps = children?.[branch.name] || []
await this.executeSteps(branchSteps)
break
@ -569,8 +586,8 @@ class Orchestrator {
this.loopStepOutputs.push(outputs)
} else {
this.updateExecutionOutput(step.id, step.stepId, step.inputs, outputs)
this.context.steps[this.context.steps.length] = outputs
}
this.context.steps[this.context.steps.length] = outputs
}
}

8
packages/server/src/utilities/rowProcessor/index.ts
View File

@ -247,6 +247,7 @@ export async function outputProcessing<T extends Row[] | Row>(
preserveLinks?: boolean
fromRow?: Row
skipBBReferences?: boolean
fromViewId?: string
} = {
squash: true,
preserveLinks: false,
@ -350,10 +351,9 @@ export async function outputProcessing<T extends Row[] | Row>(
enriched = await processFormulas(table, enriched, { dynamic: true })
if (opts.squash) {
enriched = (await linkRows.squashLinksToPrimaryDisplay(
table,
enriched
)) as Row[]
enriched = await linkRows.squashLinks(table, enriched, {
fromViewId: opts?.fromViewId,
})
}
// remove null properties to match internal API
const isExternal = isExternalTableID(table._id!)

12
packages/types/src/documents/app/view.ts
View File

@ -33,7 +33,13 @@ export interface View {
groupBy?: string
}
export type ViewUIFieldMetadata = UIFieldMetadata & {
export type ViewFieldMetadata = UIFieldMetadata & {
readonly?: boolean
columns?: Record<string, RelationSchemaField>
}
export type RelationSchemaField = {
visible?: boolean
readonly?: boolean
}
@ -45,7 +51,7 @@ export enum CalculationType {
MAX = "max",
}
export type ViewCalculationFieldMetadata = ViewUIFieldMetadata & {
export type ViewCalculationFieldMetadata = ViewFieldMetadata & {
calculationType: CalculationType
field: string
}
@ -62,7 +68,7 @@ export interface ViewV2 {
order?: SortOrder
type?: SortType
}
schema?: Record<string, ViewUIFieldMetadata | ViewCalculationFieldMetadata>
schema?: Record<string, ViewFieldMetadata | ViewCalculationFieldMetadata>
}
export type ViewSchema = ViewCountOrSumSchema | ViewStatisticsSchema

1
packages/types/src/sdk/featureFlag.ts
View File

@ -1,6 +1,7 @@
export enum FeatureFlag {
PER_CREATOR_PER_USER_PRICE = "PER_CREATOR_PER_USER_PRICE",
PER_CREATOR_PER_USER_PRICE_ALERT = "PER_CREATOR_PER_USER_PRICE_ALERT",
ENRICHED_RELATIONSHIPS = "ENRICHED_RELATIONSHIPS",
}
export interface TenantFeatureFlags {

1
packages/types/src/sdk/row.ts
View File

@ -5,6 +5,7 @@ import { WithRequired } from "../shared"
export interface SearchParams {
tableId?: string
viewId?: string
query?: SearchFilters
paginate?: boolean
bookmark?: string | number

8
packages/types/src/sdk/view.ts
View File

@ -1,5 +1,9 @@
import { TableSchema, ViewV2 } from "../documents"
import { FieldSchema, RelationSchemaField, ViewV2 } from "../documents"
export interface ViewV2Enriched extends ViewV2 {
schema?: TableSchema
schema?: {
[key: string]: FieldSchema & {
columns?: Record<string, RelationSchemaField>
}
}
}