Merge pull request #15668 from Budibase/BUDI-9077/main-relationship-permissions-conflict

Remove unnecessary sortType on api definition

packages/frontend-core/src/fetch/DataFetch.ts

@@ -8,7 +8,6 @@ import {
   Row,
   SearchFilters,
   SortOrder,
-  SortType,
   TableSchema,
 } from "@budibase/types"
 import { APIClient } from "../api/types"
@@ -72,8 +71,6 @@ export default abstract class BaseDataFetch<
   options: DataFetchOptions<TQuery> & {
     datasource: TDatasource
 
-    sortType: SortType | null
-
     // Client side feature customisation
     clientSideSearching: boolean
     clientSideSorting: boolean
@@ -106,7 +103,6 @@ export default abstract class BaseDataFetch<
       // Sorting config
       sortColumn: null,
       sortOrder: SortOrder.ASCENDING,
-      sortType: null,
 
       // Pagination config
       paginate: true,
@@ -227,31 +223,12 @@ export default abstract class BaseDataFetch<
       this.options.sortColumn = this.getDefaultSortColumn(definition, schema)
     }
 
-    // If we don't have a sort column specified then just ensure we don't set
-    // any sorting params
-    if (!this.options.sortColumn) {
-      this.options.sortOrder = SortOrder.ASCENDING
-      this.options.sortType = null
-    } else {
-      // Otherwise determine what sort type to use base on sort column
-      this.options.sortType = SortType.STRING
-      const fieldSchema = schema?.[this.options.sortColumn]
-      if (
-        fieldSchema?.type === FieldType.NUMBER ||
-        fieldSchema?.type === FieldType.BIGINT ||
-        ("calculationType" in fieldSchema && fieldSchema?.calculationType)
-      ) {
-        this.options.sortType = SortType.NUMBER
-      }
-
     // If no sort order, default to ascending
     if (!this.options.sortOrder) {
       this.options.sortOrder = SortOrder.ASCENDING
     } else {
       // Ensure sortOrder matches the enum
-        this.options.sortOrder =
+      this.options.sortOrder = this.options.sortOrder.toLowerCase() as SortOrder
-          this.options.sortOrder.toLowerCase() as SortOrder
-      }
     }
 
     // Build the query
@@ -294,7 +271,6 @@ export default abstract class BaseDataFetch<
     const {
       sortColumn,
       sortOrder,
-      sortType,
       limit,
       clientSideSearching,
       clientSideSorting,
@@ -311,8 +287,8 @@ export default abstract class BaseDataFetch<
     }
 
     // If we don't support sorting, do a client-side sort
-    if (!this.features.supportsSort && clientSideSorting && sortType) {
+    if (!this.features.supportsSort && clientSideSorting && sortColumn) {
-      rows = sort(rows, sortColumn as any, sortOrder, sortType)
+      rows = sort(rows, sortColumn, sortOrder)
     }
 
     // If we don't support pagination, do a client-side limit

packages/frontend-core/src/fetch/TableFetch.ts

@@ -29,8 +29,7 @@ export default class TableFetch extends BaseDataFetch<TableDatasource, Table> {
   }
 
   async getData() {
-    const { datasource, limit, sortColumn, sortOrder, sortType, paginate } =
+    const { datasource, limit, sortColumn, sortOrder, paginate } = this.options
-      this.options
     const { tableId } = datasource
     const { cursor, query } = get(this.store)
 
@@ -41,7 +40,6 @@ export default class TableFetch extends BaseDataFetch<TableDatasource, Table> {
         limit,
         sort: sortColumn,
         sortOrder: sortOrder ?? SortOrder.ASCENDING,
-        sortType,
         paginate,
         bookmark: cursor,
       })

packages/frontend-core/src/fetch/ViewV2Fetch.ts

@@ -1,4 +1,5 @@
 import {
+  SearchViewRowRequest,
   SortOrder,
   ViewDatasource,
   ViewV2Enriched,
@@ -40,8 +41,7 @@ export default class ViewV2Fetch extends BaseDataFetch<
   }
 
   async getData() {
-    const { datasource, limit, sortColumn, sortOrder, sortType, paginate } =
+    const { datasource, limit, sortColumn, sortOrder, paginate } = this.options
-      this.options
     const { cursor, query, definition } = get(this.store)
 
     // If this is a calculation view and we have no calculations, return nothing
@@ -68,14 +68,13 @@ export default class ViewV2Fetch extends BaseDataFetch<
     }
 
     try {
-      const request = {
+      const request: SearchViewRowRequest = {
         query,
         paginate,
         limit,
         bookmark: cursor,
         sort: sortColumn,
         sortOrder: sortOrder,
-        sortType,
       }
       if (paginate) {
         const res = await this.API.viewV2.fetch(datasource.id, {

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

@@ -263,7 +263,6 @@ export async function search(ctx: Ctx<SearchRowRequest, SearchRowResponse>) {
     limit: searchRequest.limit,
     sort: searchRequest.sort ?? undefined,
     sortOrder: searchRequest.sortOrder,
-    sortType: searchRequest.sortType ?? undefined,
     countRows: searchRequest.countRows,
     version: searchRequest.version,
     disableEscaping: searchRequest.disableEscaping,

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

@@ -63,14 +63,12 @@ function getSortOptions(request: SearchViewRowRequest, view: ViewV2) {
     return {
       sort: request.sort,
       sortOrder: request.sortOrder,
-      sortType: request.sortType ?? undefined,
     }
   }
   if (view.sort) {
     return {
       sort: view.sort.field,
       sortOrder: view.sort.order,
-      sortType: view.sort.type,
     }
   }
 

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

@@ -38,7 +38,7 @@ import {
 import _ from "lodash"
 import tk from "timekeeper"
 import { encodeJSBinding } from "@budibase/string-templates"
-import { dataFilters } from "@budibase/shared-core"
+import { dataFilters, InMemorySearchQuery } from "@budibase/shared-core"
 import { Knex } from "knex"
 import { generator, structures, mocks } from "@budibase/backend-core/tests"
 import { DEFAULT_EMPLOYEE_TABLE_SCHEMA } from "../../../db/defaultData/datasource_bb_default"
@@ -200,31 +200,26 @@ if (descriptions.length) {
             const isView = sourceType === "view"
 
             class SearchAssertion {
-              constructor(private readonly query: SearchRowRequest) {}
+              constructor(
+                private readonly query: SearchRowRequest & {
+                  sortType?: SortType
+                }
+              ) {}
 
               private async performSearch(): Promise<SearchResponse<Row>> {
                 if (isInMemory) {
-                  const inMemoryQuery: RequiredKeys<
+                  const inMemoryQuery: RequiredKeys<InMemorySearchQuery> = {
-                    Omit<RowSearchParams, "tableId">
-                  > = {
                     sort: this.query.sort ?? undefined,
                     query: { ...this.query.query },
-                    paginate: this.query.paginate,
-                    bookmark: this.query.bookmark ?? undefined,
                     limit: this.query.limit,
                     sortOrder: this.query.sortOrder,
                     sortType: this.query.sortType ?? undefined,
-                    version: this.query.version,
-                    disableEscaping: this.query.disableEscaping,
                     countRows: this.query.countRows,
-                    viewId: undefined,
-                    fields: undefined,
-                    indexer: undefined,
-                    rows: undefined,
                   }
                   return dataFilters.search(_.cloneDeep(rows), inMemoryQuery)
                 } else {
-                  return config.api.row.search(tableOrViewId, this.query)
+                  const { sortType, ...query } = this.query
+                  return config.api.row.search(tableOrViewId, query)
                 }
               }
 
@@ -400,7 +395,9 @@ if (descriptions.length) {
               }
             }
 
-            function expectSearch(query: SearchRowRequest) {
+            function expectSearch(
+              query: SearchRowRequest & { sortType?: SortType }
+            ) {
               return new SearchAssertion(query)
             }
 
@@ -1119,6 +1116,7 @@ if (descriptions.length) {
                   }).toMatchExactly([{ name: "foo" }, { name: "bar" }])
                 })
 
+                isInMemory &&
                   describe("sortType STRING", () => {
                     it("sorts ascending", async () => {
                       await expectSearch({
@@ -1319,6 +1317,7 @@ if (descriptions.length) {
                 })
               })
 
+              isInMemory &&
                 describe("sortType NUMBER", () => {
                   it("sorts ascending", async () => {
                     await expectSearch({
@@ -1473,6 +1472,7 @@ if (descriptions.length) {
                   }).toMatchExactly([{ dob: JAN_10TH }, { dob: JAN_1ST }])
                 })
 
+                isInMemory &&
                   describe("sortType STRING", () => {
                     it("sorts ascending", async () => {
                       await expectSearch({
@@ -1639,6 +1639,7 @@ if (descriptions.length) {
                     ])
                   })
 
+                  isInMemory &&
                     describe("sortType STRING", () => {
                       it("sorts ascending", async () => {
                         await expectSearch({
@@ -1675,6 +1676,7 @@ if (descriptions.length) {
                 })
               })
 
+            !isInMemory &&
               describe("datetime - date only", () => {
                 describe.each([true, false])(
                   "saved with timestamp: %s",
@@ -1847,6 +1849,7 @@ if (descriptions.length) {
                             ])
                           })
 
+                          isInMemory &&
                             describe("sortType STRING", () => {
                               it("sorts ascending", async () => {
                                 await expectSearch({

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

@@ -24,7 +24,6 @@ import {
   SearchResponse,
   SearchViewRowRequest,
   SortOrder,
-  SortType,
   StaticQuotaName,
   Table,
   TableSchema,
@@ -154,7 +153,6 @@ if (descriptions.length) {
                 sort: {
                   field: "fieldToSort",
                   order: SortOrder.DESCENDING,
-                  type: SortType.STRING,
                 },
                 schema: {
                   id: { visible: true },
@@ -217,7 +215,6 @@ if (descriptions.length) {
               sort: {
                 field: "fieldToSort",
                 order: SortOrder.DESCENDING,
-                type: SortType.STRING,
               },
               schema: {
                 id: { visible: true },
@@ -1147,7 +1144,6 @@ if (descriptions.length) {
               sort: {
                 field: generator.word(),
                 order: SortOrder.DESCENDING,
-                type: SortType.STRING,
               },
               schema: {
                 id: { visible: true },
@@ -3153,7 +3149,6 @@ if (descriptions.length) {
             {
               field: string
               order?: SortOrder
-              type?: SortType
             },
             string[]
           ][] = [
@@ -3161,7 +3156,6 @@ if (descriptions.length) {
               {
                 field: "name",
                 order: SortOrder.ASCENDING,
-                type: SortType.STRING,
               },
               ["Alice", "Bob", "Charly", "Danny"],
             ],
@@ -3178,22 +3172,6 @@ if (descriptions.length) {
               },
               ["Danny", "Charly", "Bob", "Alice"],
             ],
-            [
-              {
-                field: "name",
-                order: SortOrder.DESCENDING,
-                type: SortType.STRING,
-              },
-              ["Danny", "Charly", "Bob", "Alice"],
-            ],
-            [
-              {
-                field: "age",
-                order: SortOrder.ASCENDING,
-                type: SortType.NUMBER,
-              },
-              ["Danny", "Alice", "Charly", "Bob"],
-            ],
             [
               {
                 field: "age",
@@ -3204,15 +3182,13 @@ if (descriptions.length) {
             [
               {
                 field: "age",
-                order: SortOrder.DESCENDING,
               },
-              ["Bob", "Charly", "Alice", "Danny"],
+              ["Danny", "Alice", "Charly", "Bob"],
             ],
             [
               {
                 field: "age",
                 order: SortOrder.DESCENDING,
-                type: SortType.NUMBER,
               },
               ["Bob", "Charly", "Alice", "Danny"],
             ],
@@ -3299,7 +3275,6 @@ if (descriptions.length) {
                   sort: {
                     field: "name",
                     order: SortOrder.ASCENDING,
-                    type: SortType.STRING,
                   },
                   schema: viewSchema,
                 })
@@ -3307,7 +3282,6 @@ if (descriptions.length) {
                 const response = await config.api.viewV2.search(view.id, {
                   sort: sortParams.field,
                   sortOrder: sortParams.order,
-                  sortType: sortParams.type,
                   query: {},
                 })
 

packages/server/src/sdk/app/rows/search.ts

@@ -46,7 +46,6 @@ export async function search(
       query: options.query,
       sort: options.sort,
       sortOrder: options.sortOrder,
-      sortType: options.sortType,
       limit: options.limit,
       bookmark: options.bookmark,
       paginate: options.paginate,

packages/server/src/sdk/app/rows/search/internal/sqs.ts

@@ -1,5 +1,6 @@
 import {
   Aggregation,
+  AutoFieldSubType,
   CalculationType,
   DocumentType,
   EnrichedQueryJson,
@@ -420,7 +421,11 @@ export async function search(
       }
     } else if (sortField) {
       const sortType =
-        sortField.type === FieldType.NUMBER ? SortType.NUMBER : SortType.STRING
+        sortField.type === FieldType.NUMBER ||
+        (sortField.type === FieldType.AUTO &&
+          sortField.subtype === AutoFieldSubType.AUTO_ID)
+          ? SortType.NUMBER
+          : SortType.STRING
       request.sort = {
         [mapToUserColumn(sortField.name)]: {
           direction: params.sortOrder || SortOrder.ASCENDING,

packages/shared-core/src/filters.ts

@@ -11,7 +11,6 @@ import {
   SortType,
   FieldConstraints,
   SortOrder,
-  RowSearchParams,
   EmptyFilterOption,
   SearchResponse,
   Table,
@@ -25,6 +24,8 @@ import {
   isArraySearchOperator,
   isRangeSearchOperator,
   SearchFilter,
+  WithRequired,
+  SearchParams,
 } from "@budibase/types"
 import dayjs from "dayjs"
 import { OperatorOptions, SqlNumberTypeRangeMap } from "./constants"
@@ -521,9 +522,19 @@ export function fixupFilterArrays(filters: SearchFilters) {
   return filters
 }
 
+type SearchQuery = WithRequired<
+  Pick<
+    SearchParams,
+    "query" | "sort" | "sortOrder" | "sortType" | "limit" | "countRows"
+  >,
+  "query"
+>
+
+export type InMemorySearchQuery = SearchQuery
+
 export function search<T extends Record<string, any>>(
   docs: T[],
-  query: Omit<RowSearchParams, "tableId">
+  query: SearchQuery
 ): SearchResponse<T> {
   let result = runQuery(docs, query.query)
   if (query.sort) {

packages/shared-core/src/index.ts

@@ -1,5 +1,6 @@
 export * from "./constants"
 export * as dataFilters from "./filters"
+export type * from "./filters"
 export * as helpers from "./helpers"
 export * as utils from "./utils"
 export * as sdk from "./sdk"

packages/types/src/api/web/app/rows/search.ts

@@ -8,11 +8,7 @@ import {
   SearchFilterKey,
 } from "../../../../sdk"
 import { Row } from "../../../../documents"
-import {
+import { PaginationResponse, SortOrder } from "../../../../api/web/pagination"
-  PaginationResponse,
-  SortOrder,
-  SortType,
-} from "../../../../api/web/pagination"
 import { z } from "zod"
 
 const fieldKey = z
@@ -70,7 +66,6 @@ const searchRowRequest = z.object({
   limit: z.number().optional(),
   sort: z.string().nullish(),
   sortOrder: z.nativeEnum(SortOrder).optional(),
-  sortType: z.nativeEnum(SortType).nullish(),
   version: z.string().optional(),
   disableEscaping: z.boolean().optional(),
   countRows: z.boolean().optional(),
@@ -83,7 +78,6 @@ export type SearchViewRowRequest = Pick<
   SearchRowRequest,
   | "sort"
   | "sortOrder"
-  | "sortType"
   | "limit"
   | "bookmark"
   | "paginate"

packages/types/src/sdk/row.ts

@@ -50,7 +50,7 @@ export interface SearchParams {
 
 // when searching for rows we want a more extensive search type that requires certain properties
 export interface RowSearchParams
-  extends WithRequired<SearchParams, "tableId" | "query"> {}
+  extends WithRequired<Omit<SearchParams, "sortType">, "tableId" | "query"> {}
 
 export interface SearchResponse<T> {
   rows: T[]