@stack-spot/portal-network 0.2.0 → 0.3.1

package/src/client/account.ts

@@ -1,10 +1,19 @@
 import { HttpError } from '@oazapfts/runtime'
 import {
-  accountDataIsAvailable, create, createPartner,
+  accountDataIsAvailable,
+  bindToGroups, bindToRoles, create, createPartner,
+  createUser,
+  deactivateFidoCredentials,
   defaults,
-  deletePartner, getAccountMembers1, getFeatures,
+  deleteMember,
+  deletePartner, enableFidoCredentials, getAccountMembers1, getAllMemberFidoCredentials, getFeatures,
+  getMemberById,
+  getMemberGroups,
   getPartnerAccount, getPartnersSharingAllowed,
-  getPersonalClientCredentials, updatePartnerAccountAdminData, updatePartnerAccountData, validateNewPartnerData,
+  getPersonalClientCredentials,
+  getResources1,
+  getRoles1, removeRoleFromMember, resetPassword, updatePartnerAccountAdminData, updatePartnerAccountData, updateUser,
+  validateNewPartnerData,
   validatePartnerAssociationLimit,
 } from '../api/account'
 import apis from '../apis.json'
@@ -23,11 +32,11 @@ class AccountClient extends ReactQueryNetworkClient {
   }
 
   /**
-   * Get credentials from personal service client (create if not exists one to the logged user).
+   * Gets credentials from personal service client (create if not exists one to the logged user).
    */
   generatePersonalClientCredentials = this.mutation(getPersonalClientCredentials)
   /**
-   * Create a Feature Flag
+   * Creates a Feature Flag
    */
   createFeatureFlag = this.mutation(create)
   /**
@@ -35,35 +44,35 @@ class AccountClient extends ReactQueryNetworkClient {
    */
   isAvailable = this.query(accountDataIsAvailable)
   /**
-   * List Feature Flags in an Account
+   * Lists all Feature Flags in an Account
    */
   featureFlags = this.query(getFeatures)
   /**
-   * Get Partners with whom it is allowed to share content.
+   * Gets Partners with whom it is allowed to share content.
    */
   partners = this.query(getPartnersSharingAllowed)
   /**
-   * Get Partner by account Id
+   * Gets Partner by account Id
    */
   partner = this.query(getPartnerAccount)
   /**
-   * Create an Account Order for Partner
+   * Creates an Account Order for Partner
    */
   createPartner = this.mutation(createPartner)
   /**
-   * Update Partner Account data.
+   * Updates Partner Account data.
    */
   updatePartner = this.mutation(updatePartnerAccountData)
   /**
-   * Update Partner Account Admin data.
+   * Updates Partner Account Admin data.
    */
   updatePartnerAdmin = this.mutation(updatePartnerAccountAdminData)
   /**
-   * Delete Partner
+   * Deletes Partner
    */
   deactivatePartner = this.mutation(deletePartner)
   /**
-   * Validate new Partner account data
+   * Validates new Partner account data
    */
   validateNewPartnerData = this.mutation(validateNewPartnerData)
   /**
@@ -86,9 +95,65 @@ class AccountClient extends ReactQueryNetworkClient {
     },
   })
   /**
-   * Get all members (paginated).
+   * Gets member by id.
+   */
+  member = this.query(getMemberById)
+  /**
+   * Gets all members (paginated).
    */
   allMembers = this.infiniteQuery(getAccountMembers1)
+  /**
+   * Gets member Groups (paginated).
+   */
+  memberGroups = this.infiniteQuery(getMemberGroups)
+  /**
+   * Gets member roles (paginated).
+   */
+  memberRoles = this.infiniteQuery(getRoles1)
+  /**
+   * Gets member resources.
+   */
+  memberResources = this.query(getResources1)
+  /**
+   * Gets All Fido credentials for the given member (paginated).
+   */
+  fidoCredentials = this.infiniteQuery(getAllMemberFidoCredentials, { accumulator: 'items' })
+  /**
+   * Creates member on current tenant.
+   */
+  createMember = this.mutation(createUser)
+  /**
+   * Updates member on current tenant.
+   */
+  updateMember = this.mutation(updateUser)
+  /**
+   * Adds a member to several groups.
+   */
+  addMemberToGroups = this.mutation(bindToGroups)
+  /**
+   * Attributes several roles to a member.
+   */
+  addRolesToMember = this.mutation(bindToRoles)
+  /**
+   * Removes a role from a member.
+   */
+  removeRoleFromMember = this.mutation(removeRoleFromMember)
+  /**
+   * Sends an e-mail to reset the password of the member with the provided e-mail address.
+   */
+  resetMemberPassword = this.mutation(resetPassword)
+  /**
+   * Enables Fido credentials for the given member.
+   */
+  enableFidoCredentials = this.mutation(enableFidoCredentials)
+  /**
+   * Disables Fido credentials for the given member.
+   */
+  disableFidoCredentials = this.mutation(deactivateFidoCredentials)
+  /**
+   * Removes a member from a group
+   */
+  removeMemberFromGroup = this.mutation(deleteMember)
 }
 
 export const accountClient = new AccountClient()

package/src/error/DefaultAPIError.ts

@@ -1,5 +1,4 @@
 import { Dictionary, Language } from '@stack-spot/portal-translate'
-import { every, isEmpty, isString } from 'lodash'
 import { ErrorResponse } from '../api/account'
 import { StackspotAPIError } from './StackspotAPIError'
 import { baseDictionary } from './dictionary/base'
@@ -24,12 +23,12 @@ function getTitle(raw: ErrorResponse, dictionary: Dictionary, language: Language
 
 function createMessage(raw: ErrorResponse, dictionary: Dictionary, language: Language) {
   const title = getTitle(raw, dictionary, language)
-  if (isEmpty(raw.validationDetails)) return title
+  if (!raw.validationDetails?.length) return title
   const api = raw.code?.split(/[-_]/)[0]
   const details = raw.validationDetails?.map((detail) => {
     const dict: Record<string, string> = (fieldDictionary[api?.toLowerCase() as keyof typeof fieldDictionary] ?? {})[language] ?? {}
     const name = dict[detail.code] || detail.field || (raw.code !== detail.code && dictionary[language][detail.code]) || ''
-    return name ? `${name}${detail.values && every(detail.values, isString) ? `\n${detail.values.join('\n')}` : ''}` : undefined
+    return name ? `${name}${detail.values ? `\n${detail.values.join('\n')}` : ''}` : undefined
   })?.filter(d => !!d)
   return `${title}\n${details?.join('\n')}`
 }

package/src/error/StackspotAPIError.ts

@@ -58,6 +58,6 @@ export class StackspotAPIError extends Error {
    */
   translate(language: Language = getLanguage()) {
     const unknown = language === 'en' ? 'unknown error' : 'erro desconhecido'
-    return this.intl?.(language) ?? this.message ?? this.code ?? this.status === 0 ? unknown : `${this.status}`
+    return this.intl?.(language) ?? this.message ?? this.code ?? (this.status === 0 ? unknown : `${this.status}`)
   }
 }

package/src/index.ts

@@ -3,3 +3,4 @@ export { DefaultAPIError } from './error/DefaultAPIError'
 export { StackspotAPIError } from './error/StackspotAPIError'
 export { NetworkClient } from './network/NetworkClient'
 export { queryClient } from './network/react-query-client'
+export { useExtendedList } from './utils/use-extended-list'

package/src/network/AutoInfiniteQuery.ts

@@ -94,4 +94,11 @@ export class AutoInfiniteQuery<Variables, Result, PageParamName extends keyof Va
       result,
     ]
   }
+
+  async invalidate(variables?: Partial<Variables> | undefined): Promise<void> {
+    await Promise.all([
+      super.invalidate(variables),
+      queryClient.invalidateQueries({ queryKey: ['infinite', ...this.getKey(variables)] }),
+    ])
+  }
 }

package/src/network/AutoOperation.ts

@@ -61,7 +61,13 @@ export abstract class AutoOperation<Variables> implements OperationObject<Variab
       ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
       : [variables?: Partial<Variables>, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
   ) {
-    const [variables, options] = args.length === 2 ? args : [undefined, args[0]]
+    /* `this.fn` is a oazapfts function, i.e. it has arity 1 or 2. If it accepts variables, its arity is 2: the 1st parameter is the
+    variables and the 2nd is the RequestOpts. If it doesn't accept variables, its arity is one: it accepts only the RequestOpts.
+    We can use this information to determine what the type of `args` actually is at runtime. If variables are accepted, than the 1st
+    argument is the variables and the 2nd is the query options, otherwise, it has a single argument, which is the query options. */
+    const [variables, options] = this.fn.length > 1
+      ? args as [Variables, Omit<UseQueryOptions, 'queryFn' | 'queryKey'> | undefined]
+      : [undefined, args[0] as Omit<UseQueryOptions, 'queryFn' | 'queryKey'> | undefined]
     const result = useQuery({
       ...options,
       queryKey: this.getPermissionKey(variables as Variables),

package/src/network/ManualInfiniteQuery.ts

@@ -85,4 +85,11 @@ export class ManualInfiniteQuery<
       result,
     ]
   }
+
+  async invalidate(variables?: Partial<Variables> | undefined): Promise<void> {
+    await Promise.all([
+      super.invalidate(variables),
+      queryClient.invalidateQueries({ queryKey: ['infinite', ...this.getKey(variables)] }),
+    ])
+  }
 }

package/src/network/NetworkClient.ts

@@ -1,7 +1,6 @@
-import { mergeHeaders } from '@oazapfts/runtime/headers'
 import { AuthenticationError } from '@stack-spot/auth'
 import { requestPermission } from '@stack-spot/opa'
-import { Env, HTTPMethod, RequestOptions, RequestWithBody, SessionManager } from './types'
+import { Env, HTTPMethod, SessionManager } from './types'
 
 /**
  * A set of methods for performing network requests to an API.
@@ -72,82 +71,29 @@ export abstract class NetworkClient {
     return sessionManager
   }
 
-  private sendRequest(path: string, method: HTTPMethod, request?: RequestWithBody): Promise<Response> {
+  /**
+   * Makes a request (same signature as `globalThis.fetch`). This request will prepend the base url to the url and, if there's an active
+   * session, include authentication headers.
+   * @param input the url or request object.
+   * @param init the fetch options.
+   * @returns a promise with the Response.
+   */
+  protected fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {
     const sessionManager = this.getSessionManager()
-    const url = this.resolveURL(path)
+    let inputWithBaseUrl: string | URL | Request = ''
+    if (typeof input === 'string') inputWithBaseUrl = this.resolveURL(input)
+    else if (input instanceof URL) inputWithBaseUrl = this.resolveURL(input.toString())
+    else inputWithBaseUrl = { ...input, url: this.resolveURL(input.url).toString() }
+    // some APIs throw errors if the method is lowercase, the following line prevents it
+    if (init?.method) init.method = init.method.toUpperCase()
     try {
-      if (request?.params) {
-        Object.keys(request.params).forEach((key) => {
-          const value = request?.params?.[key]
-          if (value !== undefined) url.searchParams.set(key, value)
-        })
-      }
-      const isFormData = request?.body instanceof FormData
-      const isJsonContent = (typeof request?.body === 'object') && !isFormData
-      const body = isJsonContent ? JSON.stringify(request.body) : request?.body as string | FormData
-      const defaultHeaders: Record<string, string> = isJsonContent ? { 'Content-Type': 'application/json' } : {}
-      const headers = mergeHeaders(defaultHeaders, request?.headers)
-      return (
-        sessionManager.hasSession()
-          ? sessionManager.getSession().fetch(url, { method: method.toUpperCase(), headers, body, signal: request?.signal })
-          : fetch(url, { method: method.toUpperCase(), headers, body, signal: request?.signal })
-      )
+      return sessionManager.hasSession() ? sessionManager.getSession().fetch(inputWithBaseUrl, init) : fetch(inputWithBaseUrl, init)
     } catch (error) {
       if (error instanceof AuthenticationError) sessionManager.endSession()
       throw error
     }
   }
 
-  /**
-   * Performs a GET request with the parameters provided.
-   * @param path the path to the resource.
-   * @param request the request options.
-   * @returns a promise that resolves to response's data.
-   */
-  protected get(path: string, request?: RequestOptions) {
-    return this.sendRequest(path, 'get', request)
-  }
-
-  /**
-   * Performs a POST request with the parameters provided.
-   * @param path the path to the resource.
-   * @param request the request options.
-   * @returns a promise that resolves to response's data.
-   */
-  protected post(path: string, request?: RequestWithBody) {
-    return this.sendRequest(path, 'post', request)
-  }
-
-  /**
-   * Performs a PUT request with the parameters provided.
-   * @param path the path to the resource.
-   * @param request the request options.
-   * @returns a promise that resolves to response's data.
-   */
-  protected put(path: string, request?: RequestWithBody) {
-    return this.sendRequest(path, 'put', request)
-  }
-
-  /**
-   * Performs a PATCH request with the parameters provided.
-   * @param path the path to the resource.
-   * @param request the request options.
-   * @returns a promise that resolves to response's data.
-   */
-  protected patch(path: string, request?: RequestWithBody) {
-    return this.sendRequest(path, 'patch', request)
-  }
-
-  /**
-   * Performs a DELETE request with the parameters provided.
-   * @param path the path to the resource.
-   * @param request the request options.
-   * @returns a promise that resolves to response's data.
-   */
-  protected delete(path: string, request?: RequestWithBody) {
-    return this.sendRequest(path, 'delete', request)
-  }
-
   /**
    * Checks whether or not the current account is freemium.
    * @returns true if it's a freemium account, false otherwise.

package/src/network/ReactQueryNetworkClient.ts

@@ -26,22 +26,7 @@ export abstract class ReactQueryNetworkClient extends NetworkClient {
   constructor(baseURL: Record<Env, string>, defaults: Defaults<any>) {
     super(baseURL)
     defaults.baseUrl = ''
-    defaults.fetch = (...args) => this.#onFetch(...args)
-  }
-
-  #getMappedHeaders(headers: HeadersInit | undefined) {
-    if (!headers) return undefined
-    if (headers instanceof Headers) {
-      const headersMap: Record<string, string> = {}
-      headers.forEach((value, key) => headersMap[key] = value)
-      return headersMap
-    }
-    if (Array.isArray(headers)) {
-      const headersMap: Record<string, string> = {}
-      headers.forEach(([key, value]) => headersMap[key] = value)
-      return headersMap
-    }
-    return headers
+    defaults.fetch = (...args) => this.fetch(...args)
   }
 
   #parseErrorData(error: HttpError) {
@@ -80,13 +65,6 @@ export abstract class ReactQueryNetworkClient extends NetworkClient {
     }
   )
 
-  #onFetch(input: string | URL | Request, init?: RequestInit | undefined): Promise<Response> {
-    const [path, method, body, headers] = input instanceof Request
-      ? [input.url, input.method as HTTPMethod, input.body, input.headers]
-      : [`${input}`, (init?.method?.toLowerCase() || 'get') as HTTPMethod, init?.body, init?.headers]
-    return this[method](path, { body: body as any, headers: this.#getMappedHeaders(headers), signal: init?.signal })
-  }
-
   /**
    * Receives an HttpError and returns a StackspotAPIError.
    * @param error the original HttpError created by oazapfts.
@@ -169,6 +147,20 @@ export abstract class ReactQueryNetworkClient extends NetworkClient {
   >(
     config: Omit<InfiniteQueryConfig<Variables, Result, PageParamName, Accumulator>, 'permission'>,
   ): Omit<InfiniteQueryObject<Variables, Result, Accumulator>, 'isAllowed' | 'useAllowed' | 'getPermissionKey'>
+  /**
+   * Builds a query automatically by using a function generated by oazapfts. 
+   * @param fn the oazapfts function.
+   * @param options the configuration for the infinite query.
+   */
+  protected infiniteQuery<
+    Variables extends Record<string, any>,
+    Result,
+    PageParamName extends keyof Variables,
+    Accumulator extends keyof Result,
+  >(
+    fn: (variables: Variables, opts?: RequestOpts) => Promise<Result>,
+    options: Partial<InfiniteQueryOptions<Variables, Result, PageParamName, Accumulator>>,
+  ): InfiniteQueryObject<Variables, Result, Accumulator>
   /**
    * Builds a query automatically by using a function generated by oazapfts with the variables `page` and `size`. 
    * @param fn the oazapfts function that returns an array.
@@ -184,21 +176,9 @@ export abstract class ReactQueryNetworkClient extends NetworkClient {
     fn: (variables: Variables, opts?: RequestOpts) => Promise<Result>,
     options?: Partial<InfiniteQueryOptions<Variables, Result, PageParamName, Accumulator>>,
   ): InfiniteQueryObject<Variables, Result, Accumulator>
-  /**
-   * Builds a query automatically by using a function generated by oazapfts. 
-   * @param fn the oazapfts function.
-   * @param options the configuration for the infinite query.
-   */
-  protected infiniteQuery<
-    Variables extends Record<string, any>,
-    Result,
-    PageParamName extends keyof Variables,
-    Accumulator extends keyof Result,
-  >(
-    fn: (variables: Variables, opts?: RequestOpts) => Promise<Result>,
-    options: InfiniteQueryOptions<Variables, Result, PageParamName, Accumulator>,
-  ): InfiniteQueryObject<Variables, Result, Accumulator>
-  protected infiniteQuery(fnOrConfig: any, options?: InfiniteQueryOptions<any, any, any, any>): InfiniteQueryObject<any, any, any> {
+  protected infiniteQuery(
+    fnOrConfig: any, options?: Partial<InfiniteQueryOptions<any, any, any, any>>,
+  ): InfiniteQueryObject<any, any, any> {
     return typeof fnOrConfig === 'function'
       ? new AutoInfiniteQuery(
         {

package/src/network/types.ts

@@ -9,16 +9,6 @@ export interface SessionManager {
   getSession(): Session,
 }
 
-export interface RequestOptions {
-  params?: Record<string, string | undefined>,
-  headers?: Record<string, string>,
-  signal?: AbortSignal | null,
-}
-
-export interface RequestWithBody extends RequestOptions {
-  body?: string | object | FormData,
-}
-
 export type Env = 'dev' | 'stg' | 'prd'
 
 export type HTTPMethod = 'post' | 'patch' | 'delete' | 'put' | 'get'

package/src/utils/use-extended-list.ts

@@ -0,0 +1,80 @@
+import { useEffect, useRef, useState } from 'react'
+
+type ExtensionMap<T> = Record<string, (item: T) => any>
+
+type Unpromisify<T> = T extends Promise<infer R> ? R : T
+
+type Extension<E extends ExtensionMap<any>> = { [K in keyof E]?: Unpromisify<ReturnType<E[K]>> }
+
+type ItemWithExtensions<T, E extends ExtensionMap<T>> = T & Extension<E>
+
+/**
+ * Computes the given extensions for the items in the list passed as parameter. An extension will, most of the times, return a promise,
+ * but it can return whatever you'd like.
+ * 
+ * If the extensions are promises and are still loading, the items won't have the corresponding keys.
+ * 
+ * Attention: once an extension is calculated for an item, it's never calculated again. An item is identified by the parameter "idProp"
+ * (3rd), which is "id" by default.
+ * 
+ * @example
+ * ```
+ * const [groups] = accountClient.memberGroups.useInfiniteQuery({ memberId: 'someId' })
+ * const extendedGroups = useExtendedList(groups, {
+ *   canRemoveMemberFromGroup: group => accountClient.removeMemberFromGroup.isAllowed({ groupId: group.id, memberId: 'someId' }),
+ *   title: group => `${group.name} (${group.totalUsers})`,
+ * })
+ * ```
+ * Above, each item in `extendedGroups` will have the properties `canRemoveMemberFromGroup` and `title`, once all permission have been
+ * fetched.
+ * 
+ * @param list the items to compute extensions for.
+ * @param extensions an object where the keys are the extension names and the values are functions that return the value of the extension.
+ * @param idProp the name of the property that can be used as an id. 'id' by default.
+ * @returns an array with 2 items:
+ * - [0]: the list with the permission properties.
+ * - [1]: true if waiting for a promise, false otherwise.
+ */
+export function useExtendedList<T, E extends ExtensionMap<T>>(
+  list: T[], extensions: E, idProp: keyof T,
+): [ItemWithExtensions<T, E>[], boolean]
+export function useExtendedList<T extends { id: string }, E extends ExtensionMap<T>>(
+  list: T[], extensions: E, idProp?: keyof T,
+): [ItemWithExtensions<T, E>[], boolean]
+export function useExtendedList<T, E extends ExtensionMap<T>>(
+  list: T[], extensions: E, idProp = 'id' as keyof T,
+): [ItemWithExtensions<T, E>[], boolean] {
+  const [listWithExtensions, setListWithExtensions] = useState(list as ItemWithExtensions<T, E>[])
+  const [isLoading, setLoading] = useState(true)
+  const extensionMap = useRef(new Map<any, Extension<E>>())
+  const listId = list.map(i => i[idProp]).join(';')
+
+  useEffect(() => {
+    async function update() {
+      setLoading(true)
+      const newList = await Promise.all(list.map(async (item) => {
+        const itemExtensions: Extension<E> = extensionMap.current.get(item[idProp]) ?? {}
+        if (Object.keys(itemExtensions).length === 0) {
+          await Promise.all(Object.keys(extensions).map(async (key: keyof E) => {
+            try {
+              // "await" because it might be a promise
+              itemExtensions[key] = await extensions[key](item)
+            } catch (error) {
+              // eslint-disable-next-line no-console
+              console.error(`Failed to compute extension "${String(key)}" for item with id "${item[idProp]}". It will have undefined as its value, which may cause errors ahead. Caused by the error below:`)
+              // eslint-disable-next-line no-console
+              console.error(error)
+            }
+          }))
+          extensionMap.current.set(item[idProp], itemExtensions)
+        }
+        return { ...item, ...itemExtensions }
+      }))
+      setLoading(false)
+      setListWithExtensions(newList)
+    }
+    update()
+  }, [listId])
+
+  return [listWithExtensions.length ? listWithExtensions : list as ItemWithExtensions<T, E>[], isLoading]
+}