@budibase/frontend-core 3.2.37 → 3.2.39

package/src/fetch/{QueryFetch.js → QueryFetch.ts}

@@ -1,9 +1,25 @@
-import DataFetch from "./DataFetch.js"
+import DataFetch from "./DataFetch"
 import { Helpers } from "@budibase/bbui"
+import { ExecuteQueryRequest, Query } from "@budibase/types"
 import { get } from "svelte/store"
 
-export default class QueryFetch extends DataFetch {
-  determineFeatureFlags(definition) {
+interface QueryDatasource {
+  type: "query"
+  _id: string
+  fields: Record<string, any> & {
+    pagination?: {
+      type: string
+      location: string
+      pageParam: string
+    }
+  }
+  queryParams?: Record<string, string>
+  parameters: { name: string; default: string }[]
+}
+
+export default class QueryFetch extends DataFetch<QueryDatasource, Query> {
+  async determineFeatureFlags() {
+    const definition = await this.getDefinition()
     const supportsPagination =
       !!definition?.fields?.pagination?.type &&
       !!definition?.fields?.pagination?.location &&
@@ -11,7 +27,9 @@ export default class QueryFetch extends DataFetch {
     return { supportsPagination }
   }
 
-  async getDefinition(datasource) {
+  async getDefinition() {
+    const { datasource } = this.options
+
     if (!datasource?._id) {
       return null
     }
@@ -40,17 +58,17 @@ export default class QueryFetch extends DataFetch {
     const type = definition?.fields?.pagination?.type
 
     // Set the default query params
-    let parameters = Helpers.cloneDeep(datasource?.queryParams || {})
-    for (let param of datasource?.parameters || {}) {
+    const parameters = Helpers.cloneDeep(datasource.queryParams || {})
+    for (const param of datasource?.parameters || []) {
       if (!parameters[param.name]) {
         parameters[param.name] = param.default
       }
     }
 
     // Add pagination to query if supported
-    let queryPayload = { parameters }
+    const queryPayload: ExecuteQueryRequest = { parameters }
     if (paginate && supportsPagination) {
-      const requestCursor = type === "page" ? parseInt(cursor || 1) : cursor
+      const requestCursor = type === "page" ? parseInt(cursor || "1") : cursor
       queryPayload.pagination = { page: requestCursor, limit }
     }
 
@@ -65,7 +83,7 @@ export default class QueryFetch extends DataFetch {
       if (paginate && supportsPagination) {
         if (type === "page") {
           // For "page number" pagination, increment the existing page number
-          nextCursor = queryPayload.pagination.page + 1
+          nextCursor = queryPayload.pagination!.page! + 1
           hasNextPage = data?.length === limit && limit > 0
         } else {
           // For "cursor" pagination, the cursor should be in the response

package/src/fetch/RelationshipFetch.ts

@@ -0,0 +1,49 @@
+import { Table } from "@budibase/types"
+import DataFetch from "./DataFetch"
+
+interface RelationshipDatasource {
+  type: "link"
+  tableId: string
+  rowId: string
+  rowTableId: string
+  fieldName: string
+}
+
+export default class RelationshipFetch extends DataFetch<
+  RelationshipDatasource,
+  Table
+> {
+  async getDefinition() {
+    const { datasource } = this.options
+
+    if (!datasource?.tableId) {
+      return null
+    }
+    try {
+      return await this.API.fetchTableDefinition(datasource.tableId)
+    } catch (error: any) {
+      this.store.update(state => ({
+        ...state,
+        error,
+      }))
+      return null
+    }
+  }
+
+  async getData() {
+    const { datasource } = this.options
+    if (!datasource?.rowId || !datasource?.rowTableId) {
+      return { rows: [] }
+    }
+    try {
+      const res = await this.API.fetchRelationshipData(
+        datasource.rowTableId,
+        datasource.rowId,
+        datasource.fieldName
+      )
+      return { rows: res }
+    } catch (error) {
+      return { rows: [] }
+    }
+  }
+}

package/src/fetch/{TableFetch.js → TableFetch.ts}

@@ -1,9 +1,14 @@
 import { get } from "svelte/store"
-import DataFetch from "./DataFetch.js"
-import { SortOrder } from "@budibase/types"
+import DataFetch from "./DataFetch"
+import { SortOrder, Table } from "@budibase/types"
 
-export default class TableFetch extends DataFetch {
-  determineFeatureFlags() {
+interface TableDatasource {
+  type: "table"
+  tableId: string
+}
+
+export default class TableFetch extends DataFetch<TableDatasource, Table> {
+  async determineFeatureFlags() {
     return {
       supportsSearch: true,
       supportsSort: true,
@@ -11,6 +16,23 @@ export default class TableFetch extends DataFetch {
     }
   }
 
+  async getDefinition() {
+    const { datasource } = this.options
+
+    if (!datasource?.tableId) {
+      return null
+    }
+    try {
+      return await this.API.fetchTableDefinition(datasource.tableId)
+    } catch (error: any) {
+      this.store.update(state => ({
+        ...state,
+        error,
+      }))
+      return null
+    }
+  }
+
   async getData() {
     const { datasource, limit, sortColumn, sortOrder, sortType, paginate } =
       this.options
@@ -23,7 +45,7 @@ export default class TableFetch extends DataFetch {
         query,
         limit,
         sort: sortColumn,
-        sortOrder: sortOrder?.toLowerCase() ?? SortOrder.ASCENDING,
+        sortOrder: sortOrder ?? SortOrder.ASCENDING,
         sortType,
         paginate,
         bookmark: cursor,

package/src/fetch/{UserFetch.js → UserFetch.ts}

@@ -1,19 +1,37 @@
 import { get } from "svelte/store"
-import DataFetch from "./DataFetch.js"
+import DataFetch, { DataFetchParams } from "./DataFetch"
 import { TableNames } from "../constants"
 import { utils } from "@budibase/shared-core"
+import { SearchFilters, SearchUsersRequest } from "@budibase/types"
 
-export default class UserFetch extends DataFetch {
-  constructor(opts) {
+interface UserFetchQuery {
+  appId: string
+  paginated: boolean
+}
+
+interface UserDatasource {
+  type: "user"
+  tableId: TableNames.USERS
+}
+
+interface UserDefinition {}
+
+export default class UserFetch extends DataFetch<
+  UserDatasource,
+  UserDefinition,
+  UserFetchQuery
+> {
+  constructor(opts: DataFetchParams<UserDatasource, UserFetchQuery>) {
     super({
       ...opts,
       datasource: {
+        type: "user",
         tableId: TableNames.USERS,
       },
     })
   }
 
-  determineFeatureFlags() {
+  async determineFeatureFlags() {
     return {
       supportsSearch: true,
       supportsSort: false,
@@ -22,9 +40,7 @@ export default class UserFetch extends DataFetch {
   }
 
   async getDefinition() {
-    return {
-      schema: {},
-    }
+    return { schema: {} }
   }
 
   async getData() {
@@ -32,15 +48,16 @@ export default class UserFetch extends DataFetch {
     const { cursor, query } = get(this.store)
 
     // Convert old format to new one - we now allow use of the lucene format
-    const { appId, paginated, ...rest } = query || {}
-    const finalQuery = utils.isSupportedUserSearch(rest)
-      ? query
-      : { string: { email: null } }
+    const { appId, paginated, ...rest } = query
+
+    const finalQuery: SearchFilters = utils.isSupportedUserSearch(rest)
+      ? rest
+      : {}
 
     try {
-      const opts = {
-        bookmark: cursor,
-        query: finalQuery,
+      const opts: SearchUsersRequest = {
+        bookmark: cursor ?? undefined,
+        query: finalQuery ?? undefined,
         appId: appId,
         paginate: paginated || paginate,
         limit,

package/src/fetch/ViewFetch.ts

@@ -0,0 +1,51 @@
+import { Table } from "@budibase/types"
+import DataFetch from "./DataFetch"
+
+type ViewV1Datasource = {
+  type: "view"
+  name: string
+  tableId: string
+  calculation: string
+  field: string
+  groupBy: string
+}
+
+export default class ViewFetch extends DataFetch<ViewV1Datasource, Table> {
+  async getDefinition() {
+    const { datasource } = this.options
+
+    if (!datasource?.tableId) {
+      return null
+    }
+    try {
+      return await this.API.fetchTableDefinition(datasource.tableId)
+    } catch (error: any) {
+      this.store.update(state => ({
+        ...state,
+        error,
+      }))
+      return null
+    }
+  }
+
+  getSchema(definition: Table) {
+    const { datasource } = this.options
+    return definition?.views?.[datasource.name]?.schema
+  }
+
+  async getData() {
+    const { datasource } = this.options
+    try {
+      const res = await this.API.fetchViewData(datasource.name, {
+        calculation: datasource.calculation,
+        field: datasource.field,
+        groupBy: datasource.groupBy,
+        tableId: datasource.tableId,
+      })
+      return { rows: res || [] }
+    } catch (error) {
+      console.error(error, { datasource })
+      return { rows: [] }
+    }
+  }
+}

package/src/fetch/{ViewV2Fetch.js → ViewV2Fetch.ts}

@@ -1,9 +1,18 @@
-import { ViewV2Type } from "@budibase/types"
-import DataFetch from "./DataFetch.js"
+import { SortOrder, ViewV2Enriched, ViewV2Type } from "@budibase/types"
+import DataFetch from "./DataFetch"
 import { get } from "svelte/store"
+import { helpers } from "@budibase/shared-core"
 
-export default class ViewV2Fetch extends DataFetch {
-  determineFeatureFlags() {
+interface ViewDatasource {
+  type: "viewV2"
+  id: string
+}
+
+export default class ViewV2Fetch extends DataFetch<
+  ViewDatasource,
+  ViewV2Enriched
+> {
+  async determineFeatureFlags() {
     return {
       supportsSearch: true,
       supportsSort: true,
@@ -11,18 +20,13 @@ export default class ViewV2Fetch extends DataFetch {
     }
   }
 
-  getSchema(datasource, definition) {
-    return definition?.schema
-  }
+  async getDefinition() {
+    const { datasource } = this.options
 
-  async getDefinition(datasource) {
-    if (!datasource?.id) {
-      return null
-    }
     try {
       const res = await this.API.viewV2.fetchDefinition(datasource.id)
       return res?.data
-    } catch (error) {
+    } catch (error: any) {
       this.store.update(state => ({
         ...state,
         error,
@@ -42,8 +46,10 @@ export default class ViewV2Fetch extends DataFetch {
 
     // If this is a calculation view and we have no calculations, return nothing
     if (
-      definition.type === ViewV2Type.CALCULATION &&
-      !Object.values(definition.schema || {}).some(x => x.calculationType)
+      definition?.type === ViewV2Type.CALCULATION &&
+      !Object.values(definition.schema || {}).some(
+        helpers.views.isCalculationField
+      )
     ) {
       return {
         rows: [],
@@ -56,25 +62,41 @@ export default class ViewV2Fetch extends DataFetch {
     // If sort/filter params are not defined, update options to store the
     // params built in to this view. This ensures that we can accurately
     // compare old and new params and skip a redundant API call.
-    if (!sortColumn && definition.sort?.field) {
+    if (!sortColumn && definition?.sort?.field) {
       this.options.sortColumn = definition.sort.field
-      this.options.sortOrder = definition.sort.order
+      this.options.sortOrder = definition.sort.order || SortOrder.ASCENDING
     }
 
     try {
-      const res = await this.API.viewV2.fetch(datasource.id, {
-        ...(query ? { query } : {}),
+      const request = {
+        query,
         paginate,
         limit,
         bookmark: cursor,
         sort: sortColumn,
-        sortOrder: sortOrder?.toLowerCase(),
+        sortOrder: sortOrder,
         sortType,
-      })
-      return {
-        rows: res?.rows || [],
-        hasNextPage: res?.hasNextPage || false,
-        cursor: res?.bookmark || null,
+      }
+      if (paginate) {
+        const res = await this.API.viewV2.fetch(datasource.id, {
+          ...request,
+          paginate,
+        })
+        return {
+          rows: res?.rows || [],
+          hasNextPage: res?.hasNextPage || false,
+          cursor: res?.bookmark || null,
+        }
+      } else {
+        const res = await this.API.viewV2.fetch(datasource.id, {
+          ...request,
+          paginate,
+        })
+        return {
+          rows: res?.rows || [],
+          hasNextPage: false,
+          cursor: null,
+        }
       }
     } catch (error) {
       return {

package/src/fetch/index.ts

@@ -0,0 +1,93 @@
+import TableFetch from "./TableFetch"
+import ViewFetch from "./ViewFetch"
+import ViewV2Fetch from "./ViewV2Fetch"
+import QueryFetch from "./QueryFetch"
+import RelationshipFetch from "./RelationshipFetch"
+import NestedProviderFetch from "./NestedProviderFetch"
+import FieldFetch from "./FieldFetch"
+import JSONArrayFetch from "./JSONArrayFetch"
+import UserFetch from "./UserFetch"
+import GroupUserFetch from "./GroupUserFetch"
+import CustomFetch from "./CustomFetch"
+import QueryArrayFetch from "./QueryArrayFetch"
+import { APIClient } from "../api/types"
+
+export type DataFetchType = keyof typeof DataFetchMap
+
+export const DataFetchMap = {
+  table: TableFetch,
+  view: ViewFetch,
+  viewV2: ViewV2Fetch,
+  query: QueryFetch,
+  link: RelationshipFetch,
+  user: UserFetch,
+  groupUser: GroupUserFetch,
+  custom: CustomFetch,
+
+  // Client specific datasource types
+  provider: NestedProviderFetch,
+  field: FieldFetch<"field">,
+  jsonarray: JSONArrayFetch,
+  queryarray: QueryArrayFetch,
+}
+
+// Constructs a new fetch model for a certain datasource
+export const fetchData = ({ API, datasource, options }: any) => {
+  const Fetch = DataFetchMap[datasource?.type as DataFetchType] || TableFetch
+  const fetch = new Fetch({ API, datasource, ...options })
+
+  // Initially fetch data but don't bother waiting for the result
+  fetch.getInitialData()
+
+  return fetch
+}
+
+// Creates an empty fetch instance with no datasource configured, so no data
+// will initially be loaded
+const createEmptyFetchInstance = <TDatasource extends { type: DataFetchType }>({
+  API,
+  datasource,
+}: {
+  API: APIClient
+  datasource: TDatasource
+}) => {
+  const handler = DataFetchMap[datasource?.type as DataFetchType]
+  if (!handler) {
+    return null
+  }
+  return new handler({
+    API,
+    datasource: null as never,
+    query: null as any,
+  })
+}
+
+// Fetches the definition of any type of datasource
+export const getDatasourceDefinition = async <
+  TDatasource extends { type: DataFetchType }
+>({
+  API,
+  datasource,
+}: {
+  API: APIClient
+  datasource: TDatasource
+}) => {
+  const instance = createEmptyFetchInstance({ API, datasource })
+  return await instance?.getDefinition()
+}
+
+// Fetches the schema of any type of datasource
+export const getDatasourceSchema = <
+  TDatasource extends { type: DataFetchType }
+>({
+  API,
+  datasource,
+  definition,
+}: {
+  API: APIClient
+  datasource: TDatasource
+  definition?: any
+}) => {
+  const instance = createEmptyFetchInstance({ API, datasource })
+  return instance?.getSchema(definition)
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 export { createAPIClient } from "./api"
-export { fetchData } from "./fetch"
+export { fetchData, DataFetchMap } from "./fetch"
+export type { DataFetchType } from "./fetch"
 export * as Constants from "./constants"
 export * from "./stores"
 export * from "./utils"

package/src/utils/json.d.ts

@@ -0,0 +1,23 @@
+import { JsonFieldMetadata, QuerySchema } from "@budibase/types"
+
+type Schema = Record<string, QuerySchema | string>
+
+declare module "./json" {
+  export const getJSONArrayDatasourceSchema: (
+    tableSchema: Schema,
+    datasource: any
+  ) => Record<string, { type: string; name: string; prefixKeys: string }>
+
+  export const generateQueryArraySchemas: (
+    schema: Schema,
+    nestedSchemaFields?: Record<string, Schema>
+  ) => Schema
+
+  export const convertJSONSchemaToTableSchema: (
+    jsonSchema: JsonFieldMetadata,
+    options: {
+      squashObjects?: boolean
+      prefixKeys?: string
+    }
+  ) => Record<string, { type: string; name: string; prefixKeys: string }>
+}

package/src/utils/utils.js

@@ -209,6 +209,9 @@ export const buildFormBlockButtonConfig = props => {
     {
       "##eventHandlerType": "Close Side Panel",
     },
+    {
+      "##eventHandlerType": "Close Modal",
+    },
 
     ...(actionUrl
       ? [

package/src/components/grid/lib/utils.js

@@ -1,32 +0,0 @@
-// TODO: remove when all stores are typed
-
-import { GeneratedIDPrefix, CellIDSeparator } from "./constants"
-import { Helpers } from "@budibase/bbui"
-
-export const parseCellID = cellId => {
-  if (!cellId) {
-    return { rowId: undefined, field: undefined }
-  }
-  const parts = cellId.split(CellIDSeparator)
-  const field = parts.pop()
-  return { rowId: parts.join(CellIDSeparator), field }
-}
-
-export const getCellID = (rowId, fieldName) => {
-  return `${rowId}${CellIDSeparator}${fieldName}`
-}
-
-export const parseEventLocation = e => {
-  return {
-    x: e.clientX ?? e.touches?.[0]?.clientX,
-    y: e.clientY ?? e.touches?.[0]?.clientY,
-  }
-}
-
-export const generateRowID = () => {
-  return `${GeneratedIDPrefix}${Helpers.uuid()}`
-}
-
-export const isGeneratedRowID = id => {
-  return id?.startsWith(GeneratedIDPrefix)
-}

package/src/fetch/FieldFetch.js

@@ -1,44 +0,0 @@
-import DataFetch from "./DataFetch.js"
-
-export default class FieldFetch extends DataFetch {
-  async getDefinition(datasource) {
-    // Field sources have their schema statically defined
-    let schema
-    if (datasource.fieldType === "attachment") {
-      schema = {
-        url: {
-          type: "string",
-        },
-        name: {
-          type: "string",
-        },
-      }
-    } else if (datasource.fieldType === "array") {
-      schema = {
-        value: {
-          type: "string",
-        },
-      }
-    }
-    return { schema }
-  }
-
-  async getData() {
-    const { datasource } = this.options
-
-    // These sources will be available directly from context
-    const data = datasource?.value || []
-    let rows
-    if (Array.isArray(data) && data[0] && typeof data[0] !== "object") {
-      rows = data.map(value => ({ value }))
-    } else {
-      rows = data
-    }
-
-    return {
-      rows: rows || [],
-      hasNextPage: false,
-      cursor: null,
-    }
-  }
-}

package/src/fetch/NestedProviderFetch.js

@@ -1,21 +0,0 @@
-import DataFetch from "./DataFetch.js"
-
-export default class NestedProviderFetch extends DataFetch {
-  async getDefinition(datasource) {
-    // Nested providers should already have exposed their own schema
-    return {
-      schema: datasource?.value?.schema,
-      primaryDisplay: datasource?.value?.primaryDisplay,
-    }
-  }
-
-  async getData() {
-    const { datasource } = this.options
-    // Pull the rows from the existing data provider
-    return {
-      rows: datasource?.value?.rows || [],
-      hasNextPage: false,
-      cursor: null,
-    }
-  }
-}

package/src/fetch/RelationshipFetch.js

@@ -1,20 +0,0 @@
-import DataFetch from "./DataFetch.js"
-
-export default class RelationshipFetch extends DataFetch {
-  async getData() {
-    const { datasource } = this.options
-    if (!datasource?.rowId || !datasource?.rowTableId) {
-      return { rows: [] }
-    }
-    try {
-      const res = await this.API.fetchRelationshipData(
-        datasource.rowTableId,
-        datasource.rowId,
-        datasource.fieldName
-      )
-      return { rows: res }
-    } catch (error) {
-      return { rows: [] }
-    }
-  }
-}

package/src/fetch/ViewFetch.js

@@ -1,23 +0,0 @@
-import DataFetch from "./DataFetch.js"
-
-export default class ViewFetch extends DataFetch {
-  getSchema(datasource, definition) {
-    return definition?.views?.[datasource.name]?.schema
-  }
-
-  async getData() {
-    const { datasource } = this.options
-    try {
-      const res = await this.API.fetchViewData(datasource.name, {
-        calculation: datasource.calculation,
-        field: datasource.field,
-        groupBy: datasource.groupBy,
-        tableId: datasource.tableId,
-      })
-      return { rows: res || [] }
-    } catch (error) {
-      console.error(error)
-      return { rows: [] }
-    }
-  }
-}