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

packages/builder/src/components/backend/DatasourceNavigator/modals/UpdateDatasourceModal.svelte

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

packages/builder/src/components/backend/Datasources/CreateEditRelationshipModal.svelte

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

packages/builder/src/components/integration/RestQueryViewer.svelte

@@ -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,
         })

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

@@ -368,20 +368,22 @@
     const payload = [
       {
         email: newUserEmail,
-        builder: {
+        userInfo: {
-          global: creationRoleType === Constants.BudibaseRoles.Admin,
+          builder: {
-          creator: creationRoleType === Constants.BudibaseRoles.Creator,
+            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

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

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

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

@@ -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`
       )

packages/builder/src/stores/BudiStore.ts

@@ -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)
+    this.store = writable<T>(init)
-
-    /**
-     * Internal Svelte store
-     */
-    this.store = store
-
-    /**
-     * Exposes the svelte subscribe fn to allow $ notation access
-     * @example
-     * $navigation.selectedScreenId
-     */
     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
+  }
+}

packages/builder/src/stores/builder/app.js

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

packages/builder/src/stores/builder/builder.js

@@ -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 = {

packages/builder/src/stores/builder/components.js

@@ -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"

packages/builder/src/stores/builder/datasources.ts

@@ -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"
-
+import { DerivedBudiStore } from "stores/BudiStore"
-// 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[]
-}
 
 class TableImportError extends Error {
   errors: Record<string, string>
@@ -41,102 +37,138 @@ class TableImportError extends Error {
   }
 }
 
-interface DatasourceStore {
+// when building the internal DS - seems to represent it slightly differently to the backend typing of a DS
-  list: Datasource[]
+interface InternalDatasource extends Omit<Datasource, "entities"> {
+  entities: Table[]
+}
+
+interface BuilderDatasourceStore {
+  rawList: Datasource[]
   selectedDatasourceId: null | string
 }
 
-export function createDatasourcesStore() {
+interface DerivedDatasourceStore extends BuilderDatasourceStore {
-  const store = writable<DatasourceStore>({
+  list: (Datasource | InternalDatasource)[]
-    list: [],
+  selected?: Datasource | InternalDatasource
-    selectedDatasourceId: null,
+  hasDefaultData: boolean
-  })
+  hasData: boolean
+}
 
-  const derivedStore = derived([store, tables], ([$store, $tables]) => {
+export class DatasourceStore extends DerivedBudiStore<
-    // Set the internal datasource entities from the table list, which we're
+  BuilderDatasourceStore,
-    // able to keep updated unlike the egress generated definition of the
+  DerivedDatasourceStore
-    // internal datasource
+> {
-    let internalDS: Datasource | InternalDatasource | undefined =
+  constructor() {
-      $store.list?.find(ds => ds._id === BUDIBASE_INTERNAL_DB_ID)
+    const makeDerivedStore = (store: Writable<BuilderDatasourceStore>) => {
-    let otherDS = $store.list?.filter(ds => ds._id !== BUDIBASE_INTERNAL_DB_ID)
+      return derived([store, tables], ([$store, $tables]) => {
-    if (internalDS) {
+        // Set the internal datasource entities from the table list, which we're
-      const tables: Table[] = $tables.list?.filter((table: Table) => {
+        // able to keep updated unlike the egress generated definition of the
-        return (
+        // internal datasource
-          table.sourceId === BUDIBASE_INTERNAL_DB_ID &&
+        let internalDS: Datasource | InternalDatasource | undefined =
-          table._id !== TableNames.USERS
+          $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
+    super(
-    // Only add the internal DS if we have at least one non-users table
+      {
-    let list: (InternalDatasource | Datasource)[] = []
+        rawList: [],
-    if (internalDS?.entities?.length) {
+        selectedDatasourceId: null,
-      list.push(internalDS)
+      },
-    }
+      makeDerivedStore
-    list = list.concat(otherDS || [])
+    )
 
-    return {
+    this.fetch = this.fetch.bind(this)
-      ...$store,
+    this.init = this.fetch.bind(this)
-      list,
+    this.select = this.select.bind(this)
-      selected: list?.find(ds => ds._id === $store.selectedDatasourceId),
+    this.updateSchema = this.updateSchema.bind(this)
-      hasDefaultData: list?.some(ds => ds._id === DEFAULT_BB_DATASOURCE_ID),
+    this.create = this.create.bind(this)
-      hasData: list?.length > 0,
+    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) => {
+  async init() {
-    store.update(state => ({
+    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)
+    this.replaceDatasource(datasource._id!, datasource)
-    select(datasource._id!)
+    this.select(datasource._id!)
     return datasource
   }
 
-  const updateSchema = async (
+  async updateSchema(datasource: Datasource, tablesFilter: string[]) {
-    datasource: Datasource,
-    tablesFilter: string[]
-  ) => {
     const response = await API.buildDatasourceSchema(
       datasource?._id!,
       tablesFilter
     )
-    updateDatasource(response)
+    this.updateDatasourceInStore(response)
   }
 
-  const sourceCount = (source: string) => {
+  sourceCount(source: string) {
-    return get(store).list.filter(datasource => datasource.source === source)
+    return get(this.store).rawList.filter(
-      .length
+      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 => {
+      this.store.update(state => {
-        state.list[index] = datasource
+        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()

packages/builder/src/stores/builder/hover.js

@@ -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,

packages/builder/src/stores/builder/layouts.js

@@ -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 = {

packages/builder/src/stores/builder/navigation.js

@@ -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",

packages/builder/src/stores/builder/rowActions.js

@@ -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"

packages/builder/src/stores/builder/screens.js

@@ -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: [],

packages/builder/src/stores/builder/sortedIntegrations.ts

@@ -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 = () => {
+export class SortedIntegrationStore extends BudiStore<UIIntegration[]> {
-  return derived<typeof integrations, UIIntegration[]>(
+  constructor() {
-    integrations,
+    super([])
-    $integrations => {
-      const entries: [string, Integration][] = Object.entries($integrations)
-      const integrationsAsArray = entries.map(([name, integration]) => ({
-        name,
-        ...integration,
-      }))
 
-      return integrationsAsArray.sort((integrationA, integrationB) => {
+    const derivedStore = derived<typeof integrations, UIIntegration[]>(
-        const integrationASortOrder = getIntegrationOrder(integrationA.type)
+      integrations,
-        const integrationBSortOrder = getIntegrationOrder(integrationB.type)
+      $integrations => {
-        if (integrationASortOrder === integrationBSortOrder) {
+        const entries: [string, Integration][] = Object.entries($integrations)
-          return integrationA.friendlyName.localeCompare(
+        const integrationsAsArray = entries.map(([name, integration]) => ({
-            integrationB.friendlyName
+          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()

packages/builder/src/stores/builder/tests/sortedIntegrations.test.ts

@@ -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.returnedStore = new SortedIntegrationStore()
-
+    ctx.derivedCallback = mockedDerived.mock.calls[0]?.[1]
-    ctx.derivedCallback = derived.mock.calls[0][1]
   })
 
   it("calls derived with the correct parameters", () => {
-    expect(derived).toHaveBeenCalledTimes(1)
+    expect(mockedDerived).toHaveBeenCalledTimes(1)
-    expect(derived).toHaveBeenCalledWith(integrations, expect.toBeFunc())
+    expect(mockedDerived).toHaveBeenCalledWith(
+      integrations,
+      expect.any(Function)
+    )
   })
 
   describe("derived callback", () => {
-    it("When no integrations are loaded", ctx => {
+    it<LocalContext>("When integrations are present", ctx => {
-      expect(ctx.derivedCallback({})).toEqual([])
-    })
-
-    it("When integrations are present", ctx => {
       expect(ctx.derivedCallback(inputA)).toEqual(expectedOutput)
       expect(ctx.derivedCallback(inputB)).toEqual(expectedOutput)
     })

packages/builder/src/stores/portal/apps.ts

@@ -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 {

packages/builder/src/stores/portal/auditLogs.ts

@@ -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,

packages/builder/src/stores/portal/auth.ts

@@ -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,

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

@@ -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,

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

@@ -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,

packages/server/src/api/routes/tests/row.spec.ts

@@ -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.