Completing test cases for usage endpoint.

packages/server/src/api/controllers/screen.ts

@@ -143,7 +143,8 @@ export async function usage(ctx: UserCtx<void, UsageScreenResponse>) {
   const allScreens = await sdk.screens.fetch()
   const response: ScreenUsage[] = []
   for (let screen of allScreens) {
-    if (sharedSdk.screens.findInSettings(screen, sourceId)) {
+    const found = sharedSdk.screens.findInSettings(screen, sourceId)
+    if (found.length !== 0) {
       response.push({
         url: screen.routing.route,
         _id: screen._id!,

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

@@ -1,10 +1,24 @@
 import { checkBuilderEndpoint } from "./utilities/TestFunctions"
 import * as setup from "./utilities"
 import { events, roles } from "@budibase/backend-core"
-import { Screen, Role, BuiltinPermissionID } from "@budibase/types"
+import {
+  Screen,
+  Role,
+  BuiltinPermissionID,
+  SourceType,
+  UsageScreenResponse,
+} from "@budibase/types"
 
-const { basicScreen, tableScreen, viewScreen, queryScreen, basicTable } =
-  setup.structures
+const {
+  basicScreen,
+  tableScreen,
+  viewScreen,
+  queryScreen,
+  basicTable,
+  viewV2,
+  basicQuery,
+  basicDatasource,
+} = setup.structures
 
 describe("/screens", () => {
   let config = setup.getConfig()
@@ -189,9 +203,73 @@ describe("/screens", () => {
   })
 
   describe("usage", () => {
+    beforeEach(async () => {
+      await config.init()
+      await config.api.screen.save(basicScreen(), {
+        status: 200,
+      })
+    })
+
+    function confirmScreen(usage: UsageScreenResponse, screen: Screen) {
+      expect(usage.screens.length).toEqual(1)
+      expect(usage.screens[0].url).toEqual(screen.routing.route)
+      expect(usage.screens[0]._id).toEqual(screen._id!)
+    }
+
     it("should find table usage", async () => {
       const table = await config.api.table.save(basicTable(), { status: 200 })
-      const tableScreen = await config.api.screen.save(tableScreen())
+      const screen = await config.api.screen.save(
+        tableScreen("BudibaseDB", table),
+        { status: 200 }
+      )
+      const usage = await config.api.screen.usage(table._id!, { status: 200 })
+      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 view = await config.api.viewV2.create(
+        viewV2.createRequest(table._id!),
+        { status: 201 }
+      )
+      const screen = await config.api.screen.save(
+        viewScreen("BudibaseDB", view),
+        {
+          status: 200,
+        }
+      )
+      const usage = await config.api.screen.usage(view.id, { status: 200 })
+      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,
+        }
+      )
+      const query = await config.api.query.save(basicQuery(datasource._id!), {
+        status: 200,
+      })
+      const screen = await config.api.screen.save(
+        queryScreen(datasource._id!, query),
+        {
+          status: 200,
+        }
+      )
+      const dsUsage = await config.api.screen.usage(datasource._id!, {
+        status: 200,
+      })
+      expect(dsUsage.sourceType).toEqual(SourceType.DATASOURCE)
+      confirmScreen(dsUsage, screen)
+      const queryUsage = await config.api.screen.usage(query._id!, {
+        status: 200,
+      })
+      expect(queryUsage.sourceType).toEqual(SourceType.QUERY)
+      confirmScreen(queryUsage, screen)
     })
   })
 })

packages/server/src/tests/utilities/api/screen.ts

@@ -1,4 +1,4 @@
-import { Screen } from "@budibase/types"
+import { Screen, UsageScreenResponse } from "@budibase/types"
 import { Expectations, TestAPI } from "./base"
 
 export class ScreenAPI extends TestAPI {
@@ -28,4 +28,13 @@ export class ScreenAPI extends TestAPI {
       }
     )
   }
+
+  usage = async (
+    sourceId: string,
+    expectations?: Expectations
+  ): Promise<UsageScreenResponse> => {
+    return this._post<UsageScreenResponse>(`/api/screens/usage/${sourceId}`, {
+      expectations,
+    })
+  }
 }

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

@@ -1,24 +1,23 @@
 import { Screen } from "@budibase/types"
-import { flattenObject } from "../../utils"
 
 export function findInSettings(screen: Screen, toFind: string) {
-  const flattened = flattenObject(screen.props)
   const foundIn: { setting: string; value: string }[] = []
-  for (let key of Object.keys(flattened)) {
-    let found = false
-    if (typeof flattened[key] === "string") {
-      found = flattened[key].includes(toFind)
-    } else if (Array.isArray(flattened[key])) {
-      found = flattened[key].find(
-        (el: any) => typeof el === "string" && el.includes(toFind)
-      )
-    }
-    if (found) {
-      foundIn.push({
-        setting: key,
-        value: flattened[key],
-      })
+  function recurse(props: Record<string, any>, parentKey = "") {
+    for (let key of Object.keys(props)) {
+      if (!props[key]) {
+        continue
+      }
+      if (typeof props[key] === "string" && props[key].includes(toFind)) {
+        foundIn.push({
+          setting: parentKey ? `${parentKey}.${key}` : key,
+          value: props[key],
+        })
+      } else if (typeof props[key] === "object") {
+        recurse(props[key], key)
+      }
     }
   }
+
+  recurse(screen.props)
   return foundIn
 }

packages/shared-core/src/utils.ts

@@ -173,20 +173,3 @@ export function processSearchFilters(
     ],
   }
 }
-
-export function flattenObject(
-  obj: Record<string, any>,
-  parentKey: string = "",
-  state: Record<string, any> = {}
-) {
-  for (const key of Object.keys(obj)) {
-    const newKey = parentKey.length ? `${parentKey}.${key}` : key
-    const value = obj[key]
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      flattenObject(value, newKey, state)
-    } else {
-      state[newKey] = value
-    }
-  }
-  return state
-}