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

Merge branch 'master' of github.com:Budibase/budibase into dependabot/npm_and_yarn/examples/nextjs-api-sales/next-14.2.15

This commit is contained in:
mike12345567 2024-12-18 17:52:09 +00:00
parent 75a18e13a4 b9c6f27b3b
commit 480308d52d
24 changed files with 299 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
packages/builder/src/components/backend/DatasourceNavigator/modals/UpdateDatasourceModal.svelte
View File

@ -33,7 +33,7 @@
...datasource,
name,
}
await datasources.update({
await datasources.save({
datasource: updatedDatasource,
integration: integrationForDatasource(get(integrations), datasource),
})

2
packages/builder/src/components/backend/Datasources/CreateEditRelationshipModal.svelte
View File

@ -41,7 +41,7 @@
get(integrations),
datasource
)
await datasources.update({ datasource, integration })
await datasources.save({ datasource, integration })
await afterSave({ datasource, action })
} catch (err) {

2
packages/builder/src/components/integration/RestQueryViewer.svelte
View File

@ -176,7 +176,7 @@
notifications.success(`Request saved successfully`)
if (dynamicVariables) {
datasource.config.dynamicVariables = rebuildVariables(saveId)
datasource = await datasources.update({
datasource = await datasources.save({
integration: integrationInfo,
datasource,
})

14
packages/builder/src/pages/builder/app/[application]/_components/BuilderSidePanel.svelte
View File

@ -368,20 +368,22 @@
const payload = [
{
email: newUserEmail,
builder: {
global: creationRoleType === Constants.BudibaseRoles.Admin,
creator: creationRoleType === Constants.BudibaseRoles.Creator,
userInfo: {
builder: {
global: creationRoleType === Constants.BudibaseRoles.Admin,
creator: creationRoleType === Constants.BudibaseRoles.Creator,
},
admin: { global: creationRoleType === Constants.BudibaseRoles.Admin },
},
admin: { global: creationRoleType === Constants.BudibaseRoles.Admin },
},
]
const notCreatingAdmin = creationRoleType !== Constants.BudibaseRoles.Admin
const isCreator = creationAccessType === Constants.Roles.CREATOR
if (notCreatingAdmin && isCreator) {
payload[0].builder.apps = [prodAppId]
payload[0].userInfo.builder.apps = [prodAppId]
} else if (notCreatingAdmin && !isCreator) {
payload[0].apps = { [prodAppId]: creationAccessType }
payload[0].userInfo.apps = { [prodAppId]: creationAccessType }
}
let userInviteResponse

2
packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/_components/EditDatasourceConfig.svelte
View File

@ -13,7 +13,7 @@
async function saveDatasource({ config, name }) {
try {
await datasources.update({
await datasources.save({
integration,
datasource: { ...datasource, config, name },
})

2
packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/_components/panels/SaveDatasourceButton.svelte
View File

@ -16,7 +16,7 @@
get(integrations),
updatedDatasource
)
await datasources.update({ datasource: updatedDatasource, integration })
await datasources.save({ datasource: updatedDatasource, integration })
notifications.success(
`Datasource ${updatedDatasource.name} updated successfully`
)

41
packages/builder/src/stores/BudiStore.ts
View File

@ -1,40 +1,22 @@
import { writable, Writable } from "svelte/store"
import { writable, Writable, Readable } from "svelte/store"
interface BudiStoreOpts {
debug?: boolean
}
export default class BudiStore<T> implements Writable<T> {
export class BudiStore<T> {
store: Writable<T>
subscribe: Writable<T>["subscribe"]
update: Writable<T>["update"]
set: Writable<T>["set"]
constructor(init: T, opts?: BudiStoreOpts) {
const store = writable<T>(init)
/**
* Internal Svelte store
*/
this.store = store
/**
* Exposes the svelte subscribe fn to allow $ notation access
* @example
* $navigation.selectedScreenId
*/
this.store = writable<T>(init)
this.subscribe = this.store.subscribe
/**
* Exposes the svelte update fn.
* *Store modification should be kept to a minimum
*/
this.update = this.store.update
this.set = this.store.set
/**
* Optional debug mode to output the store updates to console
*/
// Optional debug mode to output the store updates to console
if (opts?.debug) {
this.subscribe(state => {
console.warn(`${this.constructor.name}`, state)
@ -42,3 +24,18 @@ export default class BudiStore<T> implements Writable<T> {
}
}
}
export class DerivedBudiStore<T, DerivedT extends T> extends BudiStore<T> {
derivedStore: Readable<DerivedT>
subscribe: Readable<DerivedT>["subscribe"]
constructor(
init: T,
makeDerivedStore: (store: Writable<T>) => Readable<DerivedT>,
opts?: BudiStoreOpts
) {
super(init, opts)
this.derivedStore = makeDerivedStore(this.store)
this.subscribe = this.derivedStore.subscribe
}
}

2
packages/builder/src/stores/builder/app.js
View File

@ -1,5 +1,5 @@
import { API } from "api"
import BudiStore from "../BudiStore"
import { BudiStore } from "../BudiStore"
export const INITIAL_APP_META_STATE = {
appId: "",

2
packages/builder/src/stores/builder/builder.js
View File

@ -1,7 +1,7 @@
import { get } from "svelte/store"
import { createBuilderWebsocket } from "./websocket.js"
import { BuilderSocketEvent } from "@budibase/shared-core"
import BudiStore from "../BudiStore.js"
import { BudiStore } from "../BudiStore.js"
import { TOUR_KEYS } from "components/portal/onboarding/tours.js"
export const INITIAL_BUILDER_STATE = {

2
packages/builder/src/stores/builder/components.js
View File

@ -28,7 +28,7 @@ import {
DB_TYPE_INTERNAL,
DB_TYPE_EXTERNAL,
} from "constants/backend"
import BudiStore from "../BudiStore"
import { BudiStore } from "../BudiStore"
import { Utils } from "@budibase/frontend-core"
import { FieldType } from "@budibase/types"
import { utils } from "@budibase/shared-core"

219
packages/builder/src/stores/builder/datasources.ts
View File

@ -1,4 +1,4 @@
import { writable, derived, get } from "svelte/store"
import { derived, get, Writable } from "svelte/store"
import {
IntegrationTypes,
DEFAULT_BB_DATASOURCE_ID,
@ -17,11 +17,7 @@ import {
} from "@budibase/types"
// @ts-ignore
import { TableNames } from "constants"
// when building the internal DS - seems to represent it slightly differently to the backend typing of a DS
interface InternalDatasource extends Omit<Datasource, "entities"> {
entities: Table[]
}
import { DerivedBudiStore } from "stores/BudiStore"
class TableImportError extends Error {
errors: Record<string, string>
@ -41,102 +37,138 @@ class TableImportError extends Error {
}
}
interface DatasourceStore {
list: Datasource[]
// when building the internal DS - seems to represent it slightly differently to the backend typing of a DS
interface InternalDatasource extends Omit<Datasource, "entities"> {
entities: Table[]
}
interface BuilderDatasourceStore {
rawList: Datasource[]
selectedDatasourceId: null | string
}
export function createDatasourcesStore() {
const store = writable<DatasourceStore>({
list: [],
selectedDatasourceId: null,
})
interface DerivedDatasourceStore extends BuilderDatasourceStore {
list: (Datasource | InternalDatasource)[]
selected?: Datasource | InternalDatasource
hasDefaultData: boolean
hasData: boolean
}
const derivedStore = derived([store, tables], ([$store, $tables]) => {
// Set the internal datasource entities from the table list, which we're
// able to keep updated unlike the egress generated definition of the
// internal datasource
let internalDS: Datasource | InternalDatasource | undefined =
$store.list?.find(ds => ds._id === BUDIBASE_INTERNAL_DB_ID)
let otherDS = $store.list?.filter(ds => ds._id !== BUDIBASE_INTERNAL_DB_ID)
if (internalDS) {
const tables: Table[] = $tables.list?.filter((table: Table) => {
return (
table.sourceId === BUDIBASE_INTERNAL_DB_ID &&
table._id !== TableNames.USERS
export class DatasourceStore extends DerivedBudiStore<
BuilderDatasourceStore,
DerivedDatasourceStore
> {
constructor() {
const makeDerivedStore = (store: Writable<BuilderDatasourceStore>) => {
return derived([store, tables], ([$store, $tables]) => {
// Set the internal datasource entities from the table list, which we're
// able to keep updated unlike the egress generated definition of the
// internal datasource
let internalDS: Datasource | InternalDatasource | undefined =
$store.rawList?.find(ds => ds._id === BUDIBASE_INTERNAL_DB_ID)
let otherDS = $store.rawList?.filter(
ds => ds._id !== BUDIBASE_INTERNAL_DB_ID
)
if (internalDS) {
const tables: Table[] = $tables.list?.filter((table: Table) => {
return (
table.sourceId === BUDIBASE_INTERNAL_DB_ID &&
table._id !== TableNames.USERS
)
})
internalDS = {
...internalDS,
entities: tables,
}
}
// Build up enriched DS list
// Only add the internal DS if we have at least one non-users table
let list: (InternalDatasource | Datasource)[] = []
if (internalDS?.entities?.length) {
list.push(internalDS)
}
list = list.concat(otherDS || [])
return {
...$store,
list,
selected: list?.find(ds => ds._id === $store.selectedDatasourceId),
hasDefaultData: list?.some(ds => ds._id === DEFAULT_BB_DATASOURCE_ID),
hasData: list?.length > 0,
}
})
internalDS = {
...internalDS,
entities: tables,
}
}
// Build up enriched DS list
// Only add the internal DS if we have at least one non-users table
let list: (InternalDatasource | Datasource)[] = []
if (internalDS?.entities?.length) {
list.push(internalDS)
}
list = list.concat(otherDS || [])
super(
{
rawList: [],
selectedDatasourceId: null,
},
makeDerivedStore
)
return {
...$store,
list,
selected: list?.find(ds => ds._id === $store.selectedDatasourceId),
hasDefaultData: list?.some(ds => ds._id === DEFAULT_BB_DATASOURCE_ID),
hasData: list?.length > 0,
}
})
this.fetch = this.fetch.bind(this)
this.init = this.fetch.bind(this)
this.select = this.select.bind(this)
this.updateSchema = this.updateSchema.bind(this)
this.create = this.create.bind(this)
this.delete = this.deleteDatasource.bind(this)
this.save = this.save.bind(this)
this.replaceDatasource = this.replaceDatasource.bind(this)
this.getTableNames = this.getTableNames.bind(this)
}
const fetch = async () => {
async fetch() {
const datasources = await API.getDatasources()
store.update(state => ({
this.store.update(state => ({
...state,
list: datasources,
rawList: datasources,
}))
}
const select = (id: string) => {
store.update(state => ({
async init() {
return this.fetch()
}
select(id: string) {
this.store.update(state => ({
...state,
selectedDatasourceId: id,
}))
}
const updateDatasource = (
private updateDatasourceInStore(
response: { datasource: Datasource; errors?: Record<string, string> },
{ ignoreErrors }: { ignoreErrors?: boolean } = {}
) => {
) {
const { datasource, errors } = response
if (!ignoreErrors && errors && Object.keys(errors).length > 0) {
throw new TableImportError(errors)
}
replaceDatasource(datasource._id!, datasource)
select(datasource._id!)
this.replaceDatasource(datasource._id!, datasource)
this.select(datasource._id!)
return datasource
}
const updateSchema = async (
datasource: Datasource,
tablesFilter: string[]
) => {
async updateSchema(datasource: Datasource, tablesFilter: string[]) {
const response = await API.buildDatasourceSchema(
datasource?._id!,
tablesFilter
)
updateDatasource(response)
this.updateDatasourceInStore(response)
}
const sourceCount = (source: string) => {
return get(store).list.filter(datasource => datasource.source === source)
.length
sourceCount(source: string) {
return get(this.store).rawList.filter(
datasource => datasource.source === source
).length
}
const checkDatasourceValidity = async (
async checkDatasourceValidity(
integration: Integration,
datasource: Datasource
): Promise<{ valid: boolean; error?: string }> => {
): Promise<{ valid: boolean; error?: string }> {
if (integration.features?.[DatasourceFeature.CONNECTION_CHECKING]) {
const { connected, error } = await API.validateDatasource(datasource)
if (connected) {
@ -148,14 +180,14 @@ export function createDatasourcesStore() {
return { valid: true }
}
const create = async ({
async create({
integration,
config,
}: {
integration: UIIntegration
config: Record<string, any>
}) => {
const count = sourceCount(integration.name)
}) {
const count = this.sourceCount(integration.name)
const nameModifier = count === 0 ? "" : ` ${count + 1}`
const datasource: Datasource = {
@ -167,7 +199,7 @@ export function createDatasourcesStore() {
isSQL: integration.isSQL,
}
const { valid, error } = await checkDatasourceValidity(
const { valid, error } = await this.checkDatasourceValidity(
integration,
datasource
)
@ -180,43 +212,47 @@ export function createDatasourcesStore() {
fetchSchema: integration.plus,
})
return updateDatasource(response, { ignoreErrors: true })
return this.updateDatasourceInStore(response, { ignoreErrors: true })
}
const update = async ({
async save({
integration,
datasource,
}: {
integration: Integration
datasource: Datasource
}) => {
if (await checkDatasourceValidity(integration, datasource)) {
}) {
if (!(await this.checkDatasourceValidity(integration, datasource)).valid) {
throw new Error("Unable to connect")
}
const response = await API.updateDatasource(datasource)
return updateDatasource(response)
return this.updateDatasourceInStore(response)
}
const deleteDatasource = async (datasource: Datasource) => {
async deleteDatasource(datasource: Datasource) {
if (!datasource?._id || !datasource?._rev) {
return
}
await API.deleteDatasource(datasource._id, datasource._rev)
replaceDatasource(datasource._id)
this.replaceDatasource(datasource._id)
}
const replaceDatasource = (datasourceId: string, datasource?: Datasource) => {
async delete(datasource: Datasource) {
return this.deleteDatasource(datasource)
}
replaceDatasource(datasourceId: string, datasource?: Datasource) {
if (!datasourceId) {
return
}
// Handle deletion
if (!datasource) {
store.update(state => ({
this.store.update(state => ({
...state,
list: state.list.filter(x => x._id !== datasourceId),
rawList: state.rawList.filter(x => x._id !== datasourceId),
}))
tables.removeDatasourceTables(datasourceId)
queries.removeDatasourceQueries(datasourceId)
@ -224,11 +260,13 @@ export function createDatasourcesStore() {
}
// Add new datasource
const index = get(store).list.findIndex(x => x._id === datasource._id)
const index = get(this.store).rawList.findIndex(
x => x._id === datasource._id
)
if (index === -1) {
store.update(state => ({
this.store.update(state => ({
...state,
list: [...state.list, datasource],
rawList: [...state.rawList, datasource],
}))
// If this is a new datasource then we should refresh the tables list,
@ -238,30 +276,17 @@ export function createDatasourcesStore() {
// Update existing datasource
else if (datasource) {
store.update(state => {
state.list[index] = datasource
this.store.update(state => {
state.rawList[index] = datasource
return state
})
}
}
const getTableNames = async (datasource: Datasource) => {
async getTableNames(datasource: Datasource) {
const info = await API.fetchInfoForDatasource(datasource)
return info.tableNames || []
}
return {
subscribe: derivedStore.subscribe,
fetch,
init: fetch,
select,
updateSchema,
create,
update,
delete: deleteDatasource,
replaceDatasource,
getTableNames,
}
}
export const datasources = createDatasourcesStore()
export const datasources = new DatasourceStore()

2
packages/builder/src/stores/builder/hover.js
View File

@ -1,6 +1,6 @@
import { get } from "svelte/store"
import { previewStore } from "stores/builder"
import BudiStore from "../BudiStore"
import { BudiStore } from "../BudiStore"
export const INITIAL_HOVER_STATE = {
componentId: null,

2
packages/builder/src/stores/builder/layouts.js
View File

@ -1,6 +1,6 @@
import { derived, get } from "svelte/store"
import { componentStore } from "stores/builder"
import BudiStore from "../BudiStore"
import { BudiStore } from "../BudiStore"
import { API } from "api"
export const INITIAL_LAYOUT_STATE = {

2
packages/builder/src/stores/builder/navigation.js
View File

@ -1,7 +1,7 @@
import { get } from "svelte/store"
import { API } from "api"
import { appStore } from "stores/builder"
import BudiStore from "../BudiStore"
import { BudiStore } from "../BudiStore"
export const INITIAL_NAVIGATION_STATE = {
navigation: "Top",

2
packages/builder/src/stores/builder/rowActions.js
View File

@ -1,5 +1,5 @@
import { get, derived } from "svelte/store"
import BudiStore from "stores/BudiStore"
import { BudiStore } from "stores/BudiStore"
import { tables } from "./tables"
import { viewsV2 } from "./viewsV2"
import { automationStore } from "./automations"

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

@ -12,7 +12,7 @@ import {
} from "stores/builder"
import { createHistoryStore } from "stores/builder/history"
import { API } from "api"
import BudiStore from "../BudiStore"
import { BudiStore } from "../BudiStore"
export const INITIAL_SCREENS_STATE = {
screens: [],

51
packages/builder/src/stores/builder/sortedIntegrations.ts
View File

@ -3,6 +3,7 @@ import { derived } from "svelte/store"
import { DatasourceTypes } from "constants/backend"
import { UIIntegration, Integration } from "@budibase/types"
import { BudiStore } from "stores/BudiStore"
const getIntegrationOrder = (type: string | undefined) => {
// if type is not known, sort to end
@ -18,29 +19,35 @@ const getIntegrationOrder = (type: string | undefined) => {
return type.charCodeAt(0) + 4
}
export const createSortedIntegrationsStore = () => {
return derived<typeof integrations, UIIntegration[]>(
integrations,
$integrations => {
const entries: [string, Integration][] = Object.entries($integrations)
const integrationsAsArray = entries.map(([name, integration]) => ({
name,
...integration,
}))
export class SortedIntegrationStore extends BudiStore<UIIntegration[]> {
constructor() {
super([])
return integrationsAsArray.sort((integrationA, integrationB) => {
const integrationASortOrder = getIntegrationOrder(integrationA.type)
const integrationBSortOrder = getIntegrationOrder(integrationB.type)
if (integrationASortOrder === integrationBSortOrder) {
return integrationA.friendlyName.localeCompare(
integrationB.friendlyName
)
}
const derivedStore = derived<typeof integrations, UIIntegration[]>(
integrations,
$integrations => {
const entries: [string, Integration][] = Object.entries($integrations)
const integrationsAsArray = entries.map(([name, integration]) => ({
name,
...integration,
}))
return integrationASortOrder < integrationBSortOrder ? -1 : 1
})
}
)
return integrationsAsArray.sort((integrationA, integrationB) => {
const integrationASortOrder = getIntegrationOrder(integrationA.type)
const integrationBSortOrder = getIntegrationOrder(integrationB.type)
if (integrationASortOrder === integrationBSortOrder) {
return integrationA.friendlyName.localeCompare(
integrationB.friendlyName
)
}
return integrationASortOrder < integrationBSortOrder ? -1 : 1
})
}
)
this.subscribe = derivedStore.subscribe
}
}
export const sortedIntegrations = createSortedIntegrationsStore()
export const sortedIntegrations = new SortedIntegrationStore()

33
packages/builder/src/stores/builder/tests/sortedIntegrations.test.js → packages/builder/src/stores/builder/tests/sortedIntegrations.test.ts
View File

@ -1,12 +1,14 @@
import { it, expect, describe, beforeEach, vi } from "vitest"
import { createSortedIntegrationsStore } from "stores/builder/sortedIntegrations"
import { SortedIntegrationStore } from "stores/builder/sortedIntegrations"
import { DatasourceTypes } from "constants/backend"
import { derived } from "svelte/store"
import { integrations } from "stores/builder/integrations"
vi.mock("svelte/store", () => ({
derived: vi.fn(),
derived: vi.fn(() => ({
subscribe: vi.fn(),
})),
writable: vi.fn(() => ({
subscribe: vi.fn(),
})),
@ -14,6 +16,8 @@ vi.mock("svelte/store", () => ({
vi.mock("stores/builder/integrations", () => ({ integrations: vi.fn() }))
const mockedDerived = vi.mocked(derived)
const inputA = {
nonRelationalA: {
friendlyName: "non-relational A",
@ -104,25 +108,28 @@ const expectedOutput = [
]
describe("sorted integrations store", () => {
beforeEach(ctx => {
interface LocalContext {
returnedStore: SortedIntegrationStore
derivedCallback: any
}
beforeEach<LocalContext>(ctx => {
vi.clearAllMocks()
ctx.returnedStore = createSortedIntegrationsStore()
ctx.derivedCallback = derived.mock.calls[0][1]
ctx.returnedStore = new SortedIntegrationStore()
ctx.derivedCallback = mockedDerived.mock.calls[0]?.[1]
})
it("calls derived with the correct parameters", () => {
expect(derived).toHaveBeenCalledTimes(1)
expect(derived).toHaveBeenCalledWith(integrations, expect.toBeFunc())
expect(mockedDerived).toHaveBeenCalledTimes(1)
expect(mockedDerived).toHaveBeenCalledWith(
integrations,
expect.any(Function)
)
})
describe("derived callback", () => {
it("When no integrations are loaded", ctx => {
expect(ctx.derivedCallback({})).toEqual([])
})
it("When integrations are present", ctx => {
it<LocalContext>("When integrations are present", ctx => {
expect(ctx.derivedCallback(inputA)).toEqual(expectedOutput)
expect(ctx.derivedCallback(inputB)).toEqual(expectedOutput)
})

2
packages/builder/src/stores/portal/apps.ts
View File

@ -3,7 +3,7 @@ import { derived } from "svelte/store"
import { AppStatus } from "constants"
import { API } from "api"
import { auth } from "./auth"
import BudiStore from "../BudiStore"
import { BudiStore } from "../BudiStore"
import { App, UpdateAppRequest } from "@budibase/types"
interface AppIdentifierMetadata {

2
packages/builder/src/stores/portal/auditLogs.ts
View File

@ -1,7 +1,7 @@
import { get } from "svelte/store"
import { API } from "api"
import { licensing } from "./licensing"
import BudiStore from "../BudiStore"
import { BudiStore } from "../BudiStore"
import {
DownloadAuditLogsRequest,
SearchAuditLogsRequest,

2
packages/builder/src/stores/portal/auth.ts
View File

@ -2,7 +2,7 @@ import { get } from "svelte/store"
import { API } from "api"
import { admin } from "stores/portal"
import analytics from "analytics"
import BudiStore from "stores/BudiStore"
import { BudiStore } from "stores/BudiStore"
import {
isSSOUser,
SetInitInfoRequest,

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

@ -52,10 +52,22 @@ export async function patch(ctx: UserCtx<PatchRowRequest, PatchRowResponse>) {
const table = await utils.getTableFromSource(source)
const { _id, ...rowData } = ctx.request.body
const dataToUpdate = await inputProcessing(
const beforeRow = await sdk.rows.external.getRow(table._id!, _id, {
relationships: true,
})
let dataToUpdate = cloneDeep(beforeRow)
const allowedField = utils.getSourceFields(source)
for (const key of Object.keys(rowData)) {
if (!allowedField.includes(key)) continue
dataToUpdate[key] = rowData[key]
}
dataToUpdate = await inputProcessing(
ctx.user?._id,
cloneDeep(source),
rowData
dataToUpdate
)
const validateResult = await sdk.rows.utils.validate({
@ -66,10 +78,6 @@ export async function patch(ctx: UserCtx<PatchRowRequest, PatchRowResponse>) {
throw { validation: validateResult.errors }
}
const beforeRow = await sdk.rows.external.getRow(table._id!, _id, {
relationships: true,
})
const response = await handleRequest(Operation.UPDATE, source, {
id: breakRowIdField(_id),
row: dataToUpdate,

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

@ -110,6 +110,21 @@ function fixBooleanFields(row: Row, table: Table) {
return row
}
export function getSourceFields(source: Table | ViewV2): string[] {
const isView = sdk.views.isView(source)
if (isView) {
const fields = Object.keys(
helpers.views.basicFields(source, { visible: true })
)
return fields
}
const fields = Object.entries(source.schema)
.filter(([_, field]) => field.visible !== false)
.map(([columnName]) => columnName)
return fields
}
export async function sqlOutputProcessing(
rows: DatasourcePlusQueryResponse,
source: Table | ViewV2,

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

@ -1333,6 +1333,62 @@ if (descriptions.length) {
expect(resp.relationship.length).toBe(1)
})
it("should be able to keep linked data when updating from views that trims links from the main table", async () => {
let row = await config.api.row.save(table._id!, {
name: "main",
description: "main description",
})
const row2 = await config.api.row.save(otherTable._id!, {
name: "link",
description: "link description",
relationship: [row._id],
})
const view = await config.api.viewV2.create({
tableId: table._id!,
name: "view",
schema: {
name: { visible: true },
},
})
const resp = await config.api.row.patch(view.id, {
_id: row._id!,
_rev: row._rev!,
tableId: row.tableId!,
name: "test2",
relationship: [row2._id],
})
expect(resp.relationship).toBeUndefined()
const updatedRow = await config.api.row.get(table._id!, row._id!)
expect(updatedRow.relationship.length).toBe(1)
})
it("should be able to keep linked data when updating from views that trims links from the foreign table", async () => {
let row = await config.api.row.save(table._id!, {
name: "main",
description: "main description",
})
const row2 = await config.api.row.save(otherTable._id!, {
name: "link",
description: "link description",
relationship: [row._id],
})
const view = await config.api.viewV2.create({
tableId: otherTable._id!,
name: "view",
})
await config.api.row.patch(view.id, {
_id: row2._id!,
_rev: row2._rev!,
tableId: row2.tableId!,
})
const updatedRow = await config.api.row.get(table._id!, row._id!)
expect(updatedRow.relationship.length).toBe(1)
})
!isInternal &&
// MSSQL needs a setting called IDENTITY_INSERT to be set to ON to allow writing
// to identity columns. This is not something Budibase does currently.