Merge branch 'ai-fixes' of github.com:Budibase/budibase into ai-fixes

lerna.json

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

packages/backend-core/src/sql/sql.ts

@@ -529,7 +529,7 @@ class InternalBuilder {
         if (!matchesTableName) {
           updatedKey = filterKey.replace(
             new RegExp(`^${relationship.column}.`),
-            `${aliases![relationship.tableName]}.`
+            `${aliases?.[relationship.tableName] || relationship.tableName}.`
           )
         } else {
           updatedKey = filterKey
@@ -1579,7 +1579,7 @@ class InternalBuilder {
     query = this.addFilters(query, filters, { relationship: true })
 
     // handle relationships with a CTE for all others
-    if (relationships?.length) {
+    if (relationships?.length && aggregations.length === 0) {
       const mainTable =
         this.query.tableAliases?.[this.query.endpoint.entityId] ||
         this.query.endpoint.entityId
@@ -1594,10 +1594,8 @@ class InternalBuilder {
       // add JSON aggregations attached to the CTE
       return this.addJsonRelationships(cte, tableName, relationships)
     }
-    // no relationships found - return query
+
-    else {
+    return query
-      return query
-    }
   }
 
   update(opts: QueryOptions): Knex.QueryBuilder {

packages/builder/src/pages/builder/portal/users/users/index.svelte

@@ -406,7 +406,7 @@
     allowSelectRows={!readonly}
     {customRenderers}
     loading={!$fetch.loaded || !groupsLoaded}
-    defaultSortColumn={"__selectable"}
+    defaultSortColumn={"access"}
   />
 
   <div class="pagination">

packages/server/nodemon.json

@@ -8,6 +8,6 @@
     "../string-templates"
   ],
   "ext": "js,ts,json,svelte",
-  "ignore": ["**/*.spec.ts", "**/*.spec.js", "../*/dist/**/*"],
+  "ignore": ["**/*.spec.ts", "**/*.spec.js", "../*/dist/**/*", "client/**/*", "builder/**/*"],
   "exec": "yarn build && node --no-node-snapshot ./dist/index.js"
 }

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

@@ -682,7 +682,19 @@ export class ExternalRequest<T extends Operation> {
     filters = this.prepareFilters(id, filters || {}, table)
     const relationships = buildExternalRelationships(table, this.tables)
 
+    let aggregations: Aggregation[] = []
+    if (sdk.views.isView(this.source)) {
+      const calculationFields = helpers.views.calculationFields(this.source)
+      for (const [key, field] of Object.entries(calculationFields)) {
+        aggregations.push({
+          ...field,
+          name: key,
+        })
+      }
+    }
+
     const incRelationships =
+      aggregations.length === 0 &&
       config.includeSqlRelationships === IncludeRelationship.INCLUDE
 
     // clean up row on ingress using schema
@@ -709,17 +721,6 @@ export class ExternalRequest<T extends Operation> {
       throw "Deletion must be filtered"
     }
 
-    let aggregations: Aggregation[] = []
-    if (sdk.views.isView(this.source)) {
-      const calculationFields = helpers.views.calculationFields(this.source)
-      for (const [key, field] of Object.entries(calculationFields)) {
-        aggregations.push({
-          ...field,
-          name: key,
-        })
-      }
-    }
-
     let json: QueryJson = {
       endpoint: {
         datasourceId: this.datasource._id!,

packages/server/src/api/controllers/static/index.ts

@@ -145,6 +145,16 @@ const requiresMigration = async (ctx: Ctx) => {
 }
 
 export const serveApp = async function (ctx: UserCtx) {
+  if (ctx.url.includes("apple-touch-icon.png")) {
+    ctx.redirect("/builder/bblogo.png")
+    return
+  }
+  // no app ID found, cannot serve - return message instead
+  if (!context.getAppId()) {
+    ctx.body = "No content found - requires app ID"
+    return
+  }
+
   const needMigrations = await requiresMigration(ctx)
 
   const bbHeaderEmbed =

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

@@ -152,4 +152,22 @@ describe("/static", () => {
       expect(res.body.builderPreview).toBe(true)
     })
   })
+
+  describe("/", () => {
+    it("should move permanently from base call (public call)", async () => {
+      const res = await request.get(`/`)
+      expect(res.status).toEqual(301)
+      expect(res.text).toEqual(
+        `Redirecting to <a href="/builder">/builder</a>.`
+      )
+    })
+
+    it("should not error when trying to get 'apple-touch-icon.png' (public call)", async () => {
+      const res = await request.get(`/apple-touch-icon.png`)
+      expect(res.status).toEqual(302)
+      expect(res.text).toEqual(
+        `Redirecting to <a href="/builder/bblogo.png">/builder/bblogo.png</a>.`
+      )
+    })
+  })
 })

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

@@ -3659,6 +3659,108 @@ describe.each([
               )
             })
 
+            it("should be able to filter on relationships", async () => {
+              const companies = await config.api.table.save(
+                saveTableRequest({
+                  schema: {
+                    name: {
+                      name: "name",
+                      type: FieldType.STRING,
+                    },
+                  },
+                })
+              )
+
+              const employees = await config.api.table.save(
+                saveTableRequest({
+                  schema: {
+                    age: {
+                      type: FieldType.NUMBER,
+                      name: "age",
+                    },
+                    name: {
+                      type: FieldType.STRING,
+                      name: "name",
+                    },
+                    company: {
+                      type: FieldType.LINK,
+                      name: "company",
+                      tableId: companies._id!,
+                      relationshipType: RelationshipType.ONE_TO_MANY,
+                      fieldName: "company",
+                    },
+                  },
+                })
+              )
+
+              const view = await config.api.viewV2.create({
+                tableId: employees._id!,
+                name: generator.guid(),
+                type: ViewV2Type.CALCULATION,
+                queryUI: {
+                  groups: [
+                    {
+                      filters: [
+                        {
+                          operator: BasicOperator.EQUAL,
+                          field: "company.name",
+                          value: "Aperture Science Laboratories",
+                        },
+                      ],
+                    },
+                  ],
+                },
+                schema: {
+                  sum: {
+                    visible: true,
+                    calculationType: CalculationType.SUM,
+                    field: "age",
+                  },
+                },
+              })
+
+              const apertureScience = await config.api.row.save(
+                companies._id!,
+                {
+                  name: "Aperture Science Laboratories",
+                }
+              )
+
+              const blackMesa = await config.api.row.save(companies._id!, {
+                name: "Black Mesa",
+              })
+
+              await Promise.all([
+                config.api.row.save(employees._id!, {
+                  name: "Alice",
+                  age: 25,
+                  company: apertureScience._id,
+                }),
+                config.api.row.save(employees._id!, {
+                  name: "Bob",
+                  age: 30,
+                  company: apertureScience._id,
+                }),
+                config.api.row.save(employees._id!, {
+                  name: "Charly",
+                  age: 27,
+                  company: blackMesa._id,
+                }),
+                config.api.row.save(employees._id!, {
+                  name: "Danny",
+                  age: 15,
+                  company: blackMesa._id,
+                }),
+              ])
+
+              const { rows } = await config.api.viewV2.search(view.id, {
+                query: {},
+              })
+
+              expect(rows).toHaveLength(1)
+              expect(rows[0].sum).toEqual(55)
+            })
+
             it("should be able to filter rows on the view itself", async () => {
               const table = await config.api.table.save(
                 saveTableRequest({

packages/server/src/sdk/app/applications/applications.ts

@@ -25,10 +25,12 @@ export async function fetch(status: AppStatus, user: ContextUser) {
   const all = status === AppStatus.ALL
   let apps = (await dbCore.getAllApps({ dev, all })) as App[]
 
-  const enrichedUser = await groups.enrichUserRolesFromGroups({
+  // need to type this correctly - add roles back in to convert from ContextUser to User
+  const completeUser: User = {
     ...user,
-    roles: user.roles || {},
+    roles: user?.roles || {},
-  })
+  }
+  const enrichedUser = await groups.enrichUserRolesFromGroups(completeUser)
   apps = filterAppList(enrichedUser, apps)
 
   const appIds = apps

packages/worker/src/api/controllers/global/users.ts

@@ -312,16 +312,21 @@ export const tenantUserLookup = async (ctx: any) => {
  * So the account holder may not be found until further pagination has occurred
  */
 export const accountHolderLookup = async (ctx: Ctx) => {
-  const users = await userSdk.core.getAllUsers()
+  try {
-  const response = await userSdk.core.getExistingAccounts(
+    const users = await userSdk.core.getAllUsers()
-    users.map(u => u.email)
+    const response = await userSdk.core.getExistingAccounts(
-  )
+      users.map(u => u.email)
-  const holder = response[0]
+    )
-  if (!holder) {
+    const holder = response[0]
-    return
+    if (!holder) {
+      ctx.body = null
+      return
+    }
+    holder._id = users.find(u => u.email === holder.email)?._id
+    ctx.body = holder
+  } catch (e) {
+    ctx.body = null
   }
-  holder._id = users.find(u => u.email === holder.email)?._id
-  ctx.body = holder
 }
 
 /*