@budibase/frontend-core 3.2.29 → 3.2.31

package/src/api/templates.ts

@@ -0,0 +1,57 @@
+import {
+  FetchGlobalTemplateByTypeResponse,
+  FetchGlobalTemplateDefinitionResponse,
+  FetchTemplateResponse,
+  SaveGlobalTemplateRequest,
+  SaveGlobalTemplateResponse,
+} from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface TemplateEndpoints {
+  getEmailTemplates: () => Promise<FetchGlobalTemplateByTypeResponse>
+  getAppTemplates: () => Promise<FetchTemplateResponse>
+  getEmailTemplateDefinitions: () => Promise<FetchGlobalTemplateDefinitionResponse>
+  saveEmailTemplate: (
+    template: SaveGlobalTemplateRequest
+  ) => Promise<SaveGlobalTemplateResponse>
+}
+
+export const buildTemplateEndpoints = (
+  API: BaseAPIClient
+): TemplateEndpoints => ({
+  /**
+   * Gets the list of email template definitions.
+   */
+  getEmailTemplateDefinitions: async () => {
+    return await API.get({ url: "/api/global/template/definitions" })
+  },
+
+  /**
+   * Gets the list of email templates.
+   */
+  getEmailTemplates: async () => {
+    return await API.get({
+      url: "/api/global/template/email",
+    })
+  },
+
+  /**
+   * Saves an email template.
+   * @param template the template to save
+   */
+  saveEmailTemplate: async template => {
+    return await API.post({
+      url: "/api/global/template",
+      body: template,
+    })
+  },
+
+  /**
+   * Gets a list of app templates.
+   */
+  getAppTemplates: async () => {
+    return await API.get({
+      url: "/api/templates",
+    })
+  },
+})

package/src/api/types.ts

@@ -0,0 +1,136 @@
+import { AIEndpoints } from "./ai"
+import { AnalyticsEndpoints } from "./analytics"
+import { AppEndpoints } from "./app"
+import { AttachmentEndpoints } from "./attachments"
+import { AuditLogEndpoints } from "./auditLogs"
+import { AuthEndpoints } from "./auth"
+import { AutomationEndpoints } from "./automations"
+import { BackupEndpoints } from "./backups"
+import { ConfigEndpoints } from "./configs"
+import { DatasourceEndpoints } from "./datasources"
+import { EnvironmentVariableEndpoints } from "./environmentVariables"
+import { EventEndpoints } from "./events"
+import { FlagEndpoints } from "./flags"
+import { GroupEndpoints } from "./groups"
+import { LayoutEndpoints } from "./layouts"
+import { LicensingEndpoints } from "./licensing"
+import { LogEndpoints } from "./logs"
+import { MigrationEndpoints } from "./migrations"
+import { OtherEndpoints } from "./other"
+import { PermissionEndpoints } from "./permissions"
+import { PluginEndpoins } from "./plugins"
+import { QueryEndpoints } from "./queries"
+import { RelationshipEndpoints } from "./relationships"
+import { RoleEndpoints } from "./roles"
+import { RouteEndpoints } from "./routes"
+import { RowActionEndpoints } from "./rowActions"
+import { RowEndpoints } from "./rows"
+import { ScreenEndpoints } from "./screens"
+import { SelfEndpoints } from "./self"
+import { TableEndpoints } from "./tables"
+import { TemplateEndpoints } from "./templates"
+import { UserEndpoints } from "./user"
+import { ViewEndpoints } from "./views"
+import { ViewV2Endpoints } from "./viewsV2"
+
+export enum HTTPMethod {
+  POST = "POST",
+  PATCH = "PATCH",
+  GET = "GET",
+  PUT = "PUT",
+  DELETE = "DELETE",
+}
+
+export type Headers = Record<string, string>
+
+export type APIClientConfig = {
+  enableCaching?: boolean
+  attachHeaders?: (headers: Headers) => void
+  onError?: (error: any) => void
+  onMigrationDetected?: (migration: string) => void
+}
+
+export type APICallConfig<RequestT, ResponseT> = {
+  method: HTTPMethod
+  url: string
+  json: boolean
+  external: boolean
+  suppressErrors: boolean
+  cache: boolean
+  body?: RequestT
+  parseResponse?: (response: Response) => Promise<ResponseT> | ResponseT
+}
+
+export type APICallParams<
+  RequestT = null,
+  ResponseT = void
+> = RequestT extends null
+  ? Pick<APICallConfig<RequestT, ResponseT>, "url"> &
+      Partial<APICallConfig<RequestT, ResponseT>>
+  : Pick<APICallConfig<RequestT, ResponseT>, "url" | "body"> &
+      Partial<APICallConfig<RequestT, ResponseT>>
+
+export type BaseAPIClient = {
+  post: <RequestT = null, ResponseT = void>(
+    params: APICallParams<RequestT, ResponseT>
+  ) => Promise<ResponseT>
+  get: <ResponseT = void>(
+    params: APICallParams<undefined | null, ResponseT>
+  ) => Promise<ResponseT>
+  put: <RequestT = null, ResponseT = void>(
+    params: APICallParams<RequestT, ResponseT>
+  ) => Promise<ResponseT>
+  delete: <RequestT = null, ResponseT = void>(
+    params: APICallParams<RequestT, ResponseT>
+  ) => Promise<ResponseT>
+  patch: <RequestT = null, ResponseT = void>(
+    params: APICallParams<RequestT, ResponseT>
+  ) => Promise<ResponseT>
+  error: (message: string) => void
+  invalidateCache: () => void
+  getAppID: () => string
+}
+
+export type APIError = {
+  message?: string
+  url?: string
+  method?: HTTPMethod
+  json: any
+  status: number
+  handled: boolean
+  suppressErrors: boolean
+}
+
+export type APIClient = BaseAPIClient &
+  AIEndpoints &
+  AnalyticsEndpoints &
+  AppEndpoints &
+  AttachmentEndpoints &
+  AuditLogEndpoints &
+  AuthEndpoints &
+  AutomationEndpoints &
+  BackupEndpoints &
+  ConfigEndpoints &
+  DatasourceEndpoints &
+  EnvironmentVariableEndpoints &
+  EventEndpoints &
+  FlagEndpoints &
+  GroupEndpoints &
+  LayoutEndpoints &
+  LicensingEndpoints &
+  LogEndpoints &
+  MigrationEndpoints &
+  OtherEndpoints &
+  PermissionEndpoints &
+  PluginEndpoins &
+  QueryEndpoints &
+  RelationshipEndpoints &
+  RoleEndpoints &
+  RouteEndpoints &
+  RowEndpoints &
+  ScreenEndpoints &
+  SelfEndpoints &
+  TableEndpoints &
+  TemplateEndpoints &
+  UserEndpoints &
+  ViewEndpoints & { rowActions: RowActionEndpoints; viewV2: ViewV2Endpoints }

package/src/api/{user.js → user.ts}

@@ -1,4 +1,82 @@
-export const buildUserEndpoints = API => ({
+import {
+  AcceptUserInviteRequest,
+  AcceptUserInviteResponse,
+  BulkUserCreated,
+  BulkUserDeleted,
+  BulkUserRequest,
+  BulkUserResponse,
+  CheckInviteResponse,
+  CountUserResponse,
+  CreateAdminUserRequest,
+  CreateAdminUserResponse,
+  DeleteInviteUsersRequest,
+  DeleteInviteUsersResponse,
+  DeleteUserResponse,
+  FetchUsersResponse,
+  FindUserResponse,
+  GetUserInvitesResponse,
+  InviteUsersRequest,
+  InviteUsersResponse,
+  LookupAccountHolderResponse,
+  SaveUserResponse,
+  SearchUsersRequest,
+  SearchUsersResponse,
+  UpdateInviteRequest,
+  UpdateInviteResponse,
+  UpdateSelfMetadataRequest,
+  UpdateSelfMetadataResponse,
+  User,
+} from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface UserEndpoints {
+  getUsers: () => Promise<FetchUsersResponse>
+  getUser: (userId: string) => Promise<FindUserResponse>
+  updateOwnMetadata: (
+    metadata: UpdateSelfMetadataRequest
+  ) => Promise<UpdateSelfMetadataResponse>
+  createAdminUser: (
+    user: CreateAdminUserRequest
+  ) => Promise<CreateAdminUserResponse>
+  saveUser: (user: User) => Promise<SaveUserResponse>
+  deleteUser: (userId: string) => Promise<DeleteUserResponse>
+  deleteUsers: (
+    users: Array<{
+      userId: string
+      email: string
+    }>
+  ) => Promise<BulkUserDeleted | undefined>
+  onboardUsers: (data: InviteUsersRequest) => Promise<InviteUsersResponse>
+  getUserInvite: (code: string) => Promise<CheckInviteResponse>
+  getUserInvites: () => Promise<GetUserInvitesResponse>
+  inviteUsers: (users: InviteUsersRequest) => Promise<InviteUsersResponse>
+  removeUserInvites: (
+    data: DeleteInviteUsersRequest
+  ) => Promise<DeleteInviteUsersResponse>
+  acceptInvite: (
+    data: AcceptUserInviteRequest
+  ) => Promise<AcceptUserInviteResponse>
+  getUserCountByApp: (appId: string) => Promise<number>
+  getAccountHolder: () => Promise<LookupAccountHolderResponse>
+  searchUsers: (data: SearchUsersRequest) => Promise<SearchUsersResponse>
+  createUsers: (
+    users: User[],
+    groups: any[]
+  ) => Promise<BulkUserCreated | undefined>
+  updateUserInvite: (
+    code: string,
+    data: UpdateInviteRequest
+  ) => Promise<UpdateInviteResponse>
+
+  // Missing request or response types
+  addAppBuilder: (userId: string, appId: string) => Promise<{ message: string }>
+  removeAppBuilder: (
+    userId: string,
+    appId: string
+  ) => Promise<{ message: string }>
+}
+
+export const buildUserEndpoints = (API: BaseAPIClient): UserEndpoints => ({
   /**
    * Gets a list of users in the current tenant.
    */
@@ -9,33 +87,12 @@ export const buildUserEndpoints = API => ({
   },
 
   /**
-   * Gets a list of users in the current tenant.
-   * @param {string} bookmark The page to retrieve
-   * @param {object} query search filters for lookup by user (all operators not supported).
-   * @param {string} appId Facilitate app/role based user searching
-   * @param {boolean} paginate Allow the disabling of pagination
-   * @param {number} limit How many users to retrieve in a single search
+   * Searches a list of users in the current tenant.
    */
-  searchUsers: async ({ paginate, bookmark, query, appId, limit } = {}) => {
-    const opts = {}
-    if (bookmark) {
-      opts.bookmark = bookmark
-    }
-    if (query) {
-      opts.query = query
-    }
-    if (appId) {
-      opts.appId = appId
-    }
-    if (typeof paginate === "boolean") {
-      opts.paginate = paginate
-    }
-    if (limit) {
-      opts.limit = limit
-    }
+  searchUsers: async data => {
     return await API.post({
       url: `/api/global/users/search`,
-      body: opts,
+      body: data,
     })
   },
 
@@ -48,17 +105,6 @@ export const buildUserEndpoints = API => ({
     })
   },
 
-  /**
-   * Creates a user for an app.
-   * @param user the user to create
-   */
-  createAppUser: async user => {
-    return await API.post({
-      url: "/api/users/metadata",
-      body: user,
-    })
-  },
-
   /**
    * Updates the current user metadata.
    * @param metadata the metadata to save
@@ -72,12 +118,12 @@ export const buildUserEndpoints = API => ({
 
   /**
    * Creates an admin user.
-   * @param adminUser the admin user to create
+   * @param user the admin user to create
    */
-  createAdminUser: async adminUser => {
+  createAdminUser: async user => {
     return await API.post({
       url: "/api/global/users/init",
-      body: adminUser,
+      body: user,
     })
   },
 
@@ -97,8 +143,8 @@ export const buildUserEndpoints = API => ({
    * @param users the array of user objects to create
    * @param groups the array of group ids to add all users to
    */
-  createUsers: async ({ users, groups }) => {
-    const res = await API.post({
+  createUsers: async (users, groups) => {
+    const res = await API.post<BulkUserRequest, BulkUserResponse>({
       url: "/api/global/users/bulk",
       body: {
         create: {
@@ -125,7 +171,7 @@ export const buildUserEndpoints = API => ({
    * @param users the ID/email pair of the user to delete
    */
   deleteUsers: async users => {
-    const res = await API.post({
+    const res = await API.post<BulkUserRequest, BulkUserResponse>({
       url: `/api/global/users/bulk`,
       body: {
         delete: {
@@ -137,54 +183,23 @@ export const buildUserEndpoints = API => ({
   },
 
   /**
-   * Invites a user to the current tenant.
-   * @param email the email address to send the invitation to
-   * @param builder whether the user should be a global builder
-   * @param admin whether the user should be a global admin
+   * Onboards multiple users
    */
-  inviteUser: async ({ email, builder, admin, apps }) => {
-    return await API.post({
-      url: "/api/global/users/invite",
-      body: {
-        email,
-        userInfo: {
-          admin: admin?.global ? { global: true } : undefined,
-          builder: builder?.global ? { global: true } : undefined,
-          apps: apps ? apps : undefined,
-        },
-      },
-    })
-  },
-
-  onboardUsers: async payload => {
+  onboardUsers: async data => {
     return await API.post({
       url: "/api/global/users/onboard",
-      body: payload.map(invite => {
-        const { email, admin, builder, apps } = invite
-        return {
-          email,
-          userInfo: {
-            admin,
-            builder,
-            apps: apps ? apps : undefined,
-          },
-        }
-      }),
+      body: data,
     })
   },
 
   /**
    * Accepts a user invite as a body and will update the associated app roles.
    * for an existing invite
-   * @param invite the invite code sent in the email
    */
-  updateUserInvite: async invite => {
-    await API.post({
-      url: `/api/global/users/invite/update/${invite.code}`,
-      body: {
-        apps: invite.apps,
-        builder: invite.builder,
-      },
+  updateUserInvite: async (code, data) => {
+    return await API.post<UpdateInviteRequest, UpdateInviteResponse>({
+      url: `/api/global/users/invite/update/${code}`,
+      body: data,
     })
   },
 
@@ -214,72 +229,46 @@ export const buildUserEndpoints = API => ({
   inviteUsers: async users => {
     return await API.post({
       url: "/api/global/users/multi/invite",
-      body: users.map(user => {
-        let builder = undefined
-        if (user.admin || user.builder) {
-          builder = { global: true }
-        } else if (user.creator) {
-          builder = { creator: true }
-        }
-        return {
-          email: user.email,
-          userInfo: {
-            admin: user.admin ? { global: true } : undefined,
-            builder,
-            userGroups: user.groups,
-            roles: user.apps ? user.apps : undefined,
-          },
-        }
-      }),
+      body: users,
     })
   },
 
   /**
    * Removes multiple user invites from Redis cache
    */
-  removeUserInvites: async inviteCodes => {
+  removeUserInvites: async data => {
     return await API.post({
       url: "/api/global/users/multi/invite/delete",
-      body: inviteCodes,
+      body: data,
     })
   },
 
   /**
    * Accepts an invite to join the platform and creates a user.
-   * @param inviteCode the invite code sent in the email
-   * @param password the password for the newly created user
-   * @param firstName the first name of the new user
-   * @param lastName the last name of the new user
    */
-  acceptInvite: async ({ inviteCode, password, firstName, lastName }) => {
+  acceptInvite: async data => {
     return await API.post({
       url: "/api/global/users/invite/accept",
-      body: {
-        inviteCode,
-        password,
-        firstName,
-        lastName,
-      },
+      body: data,
     })
   },
 
   /**
-   * Accepts an invite to join the platform and creates a user.
-   * @param inviteCode the invite code sent in the email
-   * @param password the password for the newly created user
+   * Counts the number of users in an app
    */
-  getUserCountByApp: async ({ appId }) => {
-    return await API.get({
+  getUserCountByApp: async appId => {
+    const res = await API.get<CountUserResponse>({
       url: `/api/global/users/count/${appId}`,
     })
+    return res.userCount
   },
 
   /**
    * Adds a per app builder to the selected app
-   * @param appId the applications id
    * @param userId The id of the user to add as a builder
+   * @param appId the applications id
    */
-  addAppBuilder: async ({ userId, appId }) => {
+  addAppBuilder: async (userId, appId) => {
     return await API.post({
       url: `/api/global/users/${userId}/app/${appId}/builder`,
     })
@@ -287,15 +276,18 @@ export const buildUserEndpoints = API => ({
 
   /**
    * Removes a per app builder to the selected app
-   * @param appId the applications id
    * @param userId The id of the user to remove as a builder
+   * @param appId the applications id
    */
-  removeAppBuilder: async ({ userId, appId }) => {
+  removeAppBuilder: async (userId, appId) => {
     return await API.delete({
       url: `/api/global/users/${userId}/app/${appId}/builder`,
     })
   },
 
+  /**
+   * Gets the account holder of the current tenant
+   */
   getAccountHolder: async () => {
     return await API.get({
       url: `/api/global/users/accountholder`,

package/src/api/{views.js → views.ts}

@@ -1,4 +1,15 @@
-export const buildViewEndpoints = API => ({
+import { Row } from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface ViewEndpoints {
+  // Missing request or response types
+  fetchViewData: (name: string, opts: any) => Promise<Row[]>
+  exportView: (name: string, format: string) => Promise<any>
+  saveView: (view: any) => Promise<any>
+  deleteView: (name: string) => Promise<any>
+}
+
+export const buildViewEndpoints = (API: BaseAPIClient): ViewEndpoints => ({
   /**
    * Fetches all rows in a view
    * @param name the name of the view
@@ -6,7 +17,7 @@ export const buildViewEndpoints = API => ({
    * @param groupBy the field to group by
    * @param calculation the calculation to perform
    */
-  fetchViewData: async ({ name, field, groupBy, calculation }) => {
+  fetchViewData: async (name, { field, groupBy, calculation }) => {
     const params = new URLSearchParams()
     if (calculation) {
       params.set("field", field)
@@ -23,11 +34,11 @@ export const buildViewEndpoints = API => ({
 
   /**
    * Exports a view for download
-   * @param viewName the view to export
+   * @param name the view to export
    * @param format the format to download
    */
-  exportView: async ({ viewName, format }) => {
-    const safeViewName = encodeURIComponent(viewName)
+  exportView: async (name, format) => {
+    const safeViewName = encodeURIComponent(name)
     return await API.get({
       url: `/api/views/export?view=${safeViewName}&format=${format}`,
       parseResponse: async response => {
@@ -51,9 +62,9 @@ export const buildViewEndpoints = API => ({
    * Deletes a view.
    * @param viewName the name of the view to delete
    */
-  deleteView: async viewName => {
+  deleteView: async name => {
     return await API.delete({
-      url: `/api/views/${encodeURIComponent(viewName)}`,
+      url: `/api/views/${encodeURIComponent(name)}`,
     })
   },
 })

package/src/api/{viewsV2.js → viewsV2.ts}

@@ -1,4 +1,26 @@
-export const buildViewV2Endpoints = API => ({
+import {
+  CreateViewRequest,
+  CreateViewResponse,
+  SearchRowResponse,
+  SearchViewRowRequest,
+  UpdateViewRequest,
+  UpdateViewResponse,
+  ViewResponseEnriched,
+} from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface ViewV2Endpoints {
+  fetchDefinition: (viewId: string) => Promise<ViewResponseEnriched>
+  create: (view: CreateViewRequest) => Promise<CreateViewResponse>
+  update: (view: UpdateViewRequest) => Promise<UpdateViewResponse>
+  fetch: (
+    viewId: string,
+    opts: SearchViewRowRequest
+  ) => Promise<SearchRowResponse>
+  delete: (viewId: string) => Promise<void>
+}
+
+export const buildViewV2Endpoints = (API: BaseAPIClient): ViewV2Endpoints => ({
   /**
    * Fetches the definition of a view
    * @param viewId the ID of the view to fetch
@@ -9,6 +31,7 @@ export const buildViewV2Endpoints = API => ({
       cache: true,
     })
   },
+
   /**
    * Create a new view
    * @param view the view object
@@ -19,6 +42,7 @@ export const buildViewV2Endpoints = API => ({
       body: view,
     })
   },
+
   /**
    * Updates a view
    * @param view the view object
@@ -29,40 +53,19 @@ export const buildViewV2Endpoints = API => ({
       body: view,
     })
   },
+
   /**
    * Fetches all rows in a view
    * @param viewId the id of the view
-   * @param query the search query
-   * @param paginate whether to paginate or not
-   * @param limit page size
-   * @param bookmark pagination cursor
-   * @param sort sort column
-   * @param sortOrder sort order
-   * @param sortType sort type (text or numeric)
+   * @param opts the search options
    */
-  fetch: async ({
-    viewId,
-    query,
-    paginate,
-    limit,
-    bookmark,
-    sort,
-    sortOrder,
-    sortType,
-  }) => {
+  fetch: async (viewId, opts) => {
     return await API.post({
       url: `/api/v2/views/${encodeURIComponent(viewId)}/search`,
-      body: {
-        query,
-        paginate,
-        limit,
-        bookmark,
-        sort,
-        sortOrder,
-        sortType,
-      },
+      body: opts,
     })
   },
+
   /**
    * Delete a view
    * @param viewId the id of the view

package/src/components/grid/cells/AICell.svelte

@@ -73,6 +73,7 @@
   .value {
     display: -webkit-box;
     -webkit-line-clamp: var(--content-lines);
+    line-clamp: var(--content-lines);
     -webkit-box-orient: vertical;
     overflow: hidden;
     line-height: 20px;

package/src/components/grid/cells/LongFormCell.svelte

@@ -93,6 +93,7 @@
   .value {
     display: -webkit-box;
     -webkit-line-clamp: var(--content-lines);
+    line-clamp: var(--content-lines);
     -webkit-box-orient: vertical;
     overflow: hidden;
     line-height: 20px;

package/src/components/grid/cells/RelationshipCell.svelte

@@ -102,9 +102,8 @@
     lastSearchId = Math.random()
     searching = true
     const thisSearchId = lastSearchId
-    const results = await searchFunction({
+    const results = await searchFunction(schema.tableId, {
       paginate: false,
-      tableId: schema.tableId,
       limit: 20,
       query: {
         string: {