Data section resource deletion warning

packages/builder/src/components/backend/modals/DeleteDataConfirmationModal.svelte

@@ -10,6 +10,7 @@
     viewsV2,
   } from "@/stores/builder"
   import ConfirmDialog from "@/components/common/ConfirmDialog.svelte"
+  import { helpers } from "@budibase/shared-core"
   import { SourceType } from "@budibase/types"
   import { goto, params } from "@roxi/routify"
   import { DB_TYPE_EXTERNAL } from "@/constants/backend"
@@ -85,7 +86,7 @@
 
   async function deleteView(view: ViewV2 | View) {
     try {
-      if ("version" in view && view.version === 2) {
+      if ("version" in view && helpers.views.isCalculationView(view)) {
         await viewsV2.delete(view as ViewV2)
       } else {
         await views.delete(view as View)
@@ -99,10 +100,10 @@
 
   async function deleteDatasource(datasource: Datasource) {
     try {
-      const isSelected =
-        get(datasources).selectedDatasourceId === datasource._id
       await datasources.delete(datasource)
       notifications.success("Datasource deleted")
+      const isSelected =
+        get(datasources).selectedDatasourceId === datasource._id
       if (isSelected) {
         $goto("./datasource")
       }

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

@@ -11,9 +11,9 @@ import {
 
 const {
   basicScreen,
-  tableScreen,
-  viewScreen,
-  queryScreen,
+  createTableScreen,
+  createViewScreen,
+  createQueryScreen,
   basicTable,
   viewV2,
   basicQuery,
@@ -33,7 +33,7 @@ describe("/screens", () => {
 
   describe("fetch", () => {
     it("should be able to create a layout", async () => {
-      const screens = await config.api.screen.list({ status: 200 })
+      const screens = await config.api.screen.list()
       expect(screens.length).toEqual(1)
       expect(screens.some(s => s._id === screen._id)).toEqual(true)
     })
@@ -67,39 +67,30 @@ describe("/screens", () => {
         inherits: [role1._id!, role2._id!],
         permissionId: BuiltinPermissionID.WRITE,
       })
-      screen1 = await config.api.screen.save(
-        {
-          ...basicScreen(),
-          routing: {
-            roleId: role1._id!,
-            route: "/foo",
-            homeScreen: false,
-          },
+      screen1 = await config.api.screen.save({
+        ...basicScreen(),
+        routing: {
+          roleId: role1._id!,
+          route: "/foo",
+          homeScreen: false,
         },
-        { status: 200 }
-      )
-      screen2 = await config.api.screen.save(
-        {
-          ...basicScreen(),
-          routing: {
-            roleId: role2._id!,
-            route: "/bar",
-            homeScreen: false,
-          },
+      })
+      screen2 = await config.api.screen.save({
+        ...basicScreen(),
+        routing: {
+          roleId: role2._id!,
+          route: "/bar",
+          homeScreen: false,
         },
-        { status: 200 }
-      )
+      })
       // get into prod app
       await config.publish()
     })
 
     async function checkScreens(roleId: string, screenIds: string[]) {
       await config.loginAsRole(roleId, async () => {
         const res = await config.api.application.getDefinition(
-          config.prodAppId!,
-          {
-            status: 200,
-          }
+          config.prodAppId!
         )
         expect(res.screens.length).toEqual(screenIds.length)
         expect(res.screens.map(s => s._id).sort()).toEqual(screenIds.sort())
@@ -129,10 +120,7 @@ describe("/screens", () => {
         },
         async () => {
           const res = await config.api.application.getDefinition(
-            config.prodAppId!,
-            {
-              status: 200,
-            }
+            config.prodAppId!
           )
           const screenIds = [screen._id!, screen1._id!]
           expect(res.screens.length).toEqual(screenIds.length)
@@ -149,9 +137,7 @@ describe("/screens", () => {
 
     it("should be able to create a screen", async () => {
       const screen = basicScreen()
-      const responseScreen = await config.api.screen.save(screen, {
-        status: 200,
-      })
+      const responseScreen = await config.api.screen.save(screen)
 
       expect(responseScreen._rev).toBeDefined()
       expect(responseScreen.name).toEqual(screen.name)
@@ -160,13 +146,13 @@ describe("/screens", () => {
 
     it("should be able to update a screen", async () => {
       const screen = basicScreen()
-      let responseScreen = await config.api.screen.save(screen, { status: 200 })
+      let responseScreen = await config.api.screen.save(screen)
       screen._id = responseScreen._id
       screen._rev = responseScreen._rev
       screen.name = "edit"
       jest.clearAllMocks()
 
-      responseScreen = await config.api.screen.save(screen, { status: 200 })
+      responseScreen = await config.api.screen.save(screen)
 
       expect(responseScreen._rev).toBeDefined()
       expect(responseScreen.name).toEqual(screen.name)
@@ -186,8 +172,7 @@ describe("/screens", () => {
     it("should be able to delete the screen", async () => {
       const response = await config.api.screen.destroy(
         screen._id!,
-        screen._rev!,
-        { status: 200 }
+        screen._rev!
       )
       expect(response.message).toBeDefined()
       expect(events.screen.deleted).toHaveBeenCalledTimes(1)
@@ -205,9 +190,7 @@ describe("/screens", () => {
   describe("usage", () => {
     beforeEach(async () => {
       await config.init()
-      await config.api.screen.save(basicScreen(), {
-        status: 200,
-      })
+      await config.api.screen.save(basicScreen())
     })
 
     function confirmScreen(usage: UsageOfScreensResponse, screen: Screen) {
@@ -217,57 +200,41 @@ describe("/screens", () => {
     }
 
     it("should find table usage", async () => {
-      const table = await config.api.table.save(basicTable(), { status: 200 })
+      const table = await config.api.table.save(basicTable())
       const screen = await config.api.screen.save(
-        tableScreen("BudibaseDB", table),
-        { status: 200 }
+        createTableScreen("BudibaseDB", table)
       )
-      const usage = await config.api.screen.usage(table._id!, { status: 200 })
+      const usage = await config.api.screen.usage(table._id!)
       expect(usage.sourceType).toEqual(SourceType.TABLE)
       confirmScreen(usage, screen)
     })
 
     it("should find view usage", async () => {
-      const table = await config.api.table.save(basicTable(), { status: 200 })
+      const table = await config.api.table.save(basicTable())
       const view = await config.api.viewV2.create(
         viewV2.createRequest(table._id!),
         { status: 201 }
       )
       const screen = await config.api.screen.save(
-        viewScreen("BudibaseDB", view),
-        {
-          status: 200,
-        }
+        createViewScreen("BudibaseDB", view)
       )
-      const usage = await config.api.screen.usage(view.id, { status: 200 })
+      const usage = await config.api.screen.usage(view.id)
       expect(usage.sourceType).toEqual(SourceType.VIEW)
       confirmScreen(usage, screen)
     })
 
     it("should find datasource/query usage", async () => {
       const datasource = await config.api.datasource.create(
-        basicDatasource().datasource,
-        {
-          status: 200,
-        }
+        basicDatasource().datasource
       )
-      const query = await config.api.query.save(basicQuery(datasource._id!), {
-        status: 200,
-      })
+      const query = await config.api.query.save(basicQuery(datasource._id!))
       const screen = await config.api.screen.save(
-        queryScreen(datasource._id!, query),
-        {
-          status: 200,
-        }
+        createQueryScreen(datasource._id!, query)
       )
-      const dsUsage = await config.api.screen.usage(datasource._id!, {
-        status: 200,
-      })
+      const dsUsage = await config.api.screen.usage(datasource._id!)
       expect(dsUsage.sourceType).toEqual(SourceType.DATASOURCE)
       confirmScreen(dsUsage, screen)
-      const queryUsage = await config.api.screen.usage(query._id!, {
-        status: 200,
-      })
+      const queryUsage = await config.api.screen.usage(query._id!)
       expect(queryUsage.sourceType).toEqual(SourceType.QUERY)
       confirmScreen(queryUsage, screen)
     })

packages/server/src/constants/screens.ts

@@ -1,6 +1,6 @@
 import { roles } from "@budibase/backend-core"
 import { BASE_LAYOUT_PROP_IDS } from "./layouts"
-import { Screen, Table, Query, ViewV2 } from "@budibase/types"
+import { Screen, Table, Query, ViewV2, Component } from "@budibase/types"
 
 export function createHomeScreen(
   config: {
@@ -54,7 +54,7 @@ export function createHomeScreen(
   }
 }
 
-function heading(text: string) {
+function heading(text: string): Component {
   return {
     _id: "c1bff24cd821e41d18c894ac77a80ef99",
     _component: "@budibase/standard-components/heading",

packages/server/src/sdk/app/common/utils.ts

@@ -11,5 +11,5 @@ export function getSourceType(sourceId: string): SourceType {
   } else if (docIds.isQueryId(sourceId)) {
     return SourceType.QUERY
   }
-  throw new Error("Unknown source type - cannot find document type")
+  throw new Error(`Unknown source type for source "${sourceId}"`)
 }

packages/server/src/tests/utilities/structures.ts

@@ -1,10 +1,5 @@
 import { roles, utils } from "@budibase/backend-core"
-import {
-  createHomeScreen,
-  createTableScreen,
-  createQueryScreen,
-  createViewScreen,
-} from "../../constants/screens"
+import { createHomeScreen } from "../../constants/screens"
 import { EMPTY_LAYOUT } from "../../constants/layouts"
 import { cloneDeep } from "lodash/fp"
 import {
@@ -40,11 +35,15 @@ import {
   WebhookActionType,
   BuiltinPermissionID,
   DeepPartial,
-  ViewV2,
 } from "@budibase/types"
 import { LoopInput } from "../../definitions/automations"
 import { merge } from "lodash"
 import { generator } from "@budibase/backend-core/tests"
+export {
+  createTableScreen,
+  createQueryScreen,
+  createViewScreen,
+} from "../../constants/screens"
 
 const { BUILTIN_ROLE_IDS } = roles
 
@@ -521,18 +520,6 @@ export function basicScreen(route = "/") {
   })
 }
 
-export function tableScreen(datasourceName: string, table: Table) {
-  return createTableScreen(datasourceName, table)
-}
-
-export function viewScreen(datasourceName: string, view: ViewV2) {
-  return createViewScreen(datasourceName, view)
-}
-
-export function queryScreen(datasourceId: string, query: Query) {
-  return createQueryScreen(datasourceId, query)
-}
-
 export function powerScreen(route = "/") {
   return createHomeScreen({
     roleId: BUILTIN_ROLE_IDS.POWER,

packages/shared-core/src/sdk/documents/screens.ts

@@ -3,17 +3,17 @@ import { Screen } from "@budibase/types"
 export function findInSettings(screen: Screen, toFind: string) {
   const foundIn: { setting: string; value: string }[] = []
   function recurse(props: Record<string, any>, parentKey = "") {
-    for (let key of Object.keys(props)) {
-      if (!props[key]) {
+    for (const [key, value] of Object.entries(props)) {
+      if (!value) {
         continue
       }
-      if (typeof props[key] === "string" && props[key].includes(toFind)) {
+      if (typeof value === "string" && value.includes(toFind)) {
         foundIn.push({
           setting: parentKey ? `${parentKey}.${key}` : key,
-          value: props[key],
+          value: value,
         })
-      } else if (typeof props[key] === "object") {
-        recurse(props[key], key)
+      } else if (typeof value === "object") {
+        recurse(value, key)
       }
     }
   }