@stack-spot/portal-network 0.3.1 → 0.4.0-beta.0

package/src/client/account.ts

@@ -1,18 +1,36 @@
 import { HttpError } from '@oazapfts/runtime'
 import {
   accountDataIsAvailable,
-  bindToGroups, bindToRoles, create, createPartner,
+  addResourcesToGroup,
+  addRoleToMember,
+  bindGroupMembers,
+  bindRoleGroups,
+  bindRoles,
+  bindToGroups, bindToRoles, create, createAccountRole, createPartner,
   createUser,
   deactivateFidoCredentials,
   defaults,
+  deleteAccountRole,
   deleteMember,
-  deletePartner, enableFidoCredentials, getAccountMembers1, getAllMemberFidoCredentials, getFeatures,
+  deletePartner, deleteResourceFromGroup, deleteRole, deleteV1GroupsByGroupId, enableFidoCredentials, getAccountMembers1,
+  getAllMemberFidoCredentials, getFeatures,
+  getGroupById,
+  getGroupResources,
+  getGroups,
   getMemberById,
   getMemberGroups,
+  getMembers,
   getPartnerAccount, getPartnersSharingAllowed,
   getPersonalClientCredentials,
   getResources1,
-  getRoles1, removeRoleFromMember, resetPassword, updatePartnerAccountAdminData, updatePartnerAccountData, updateUser,
+  getResourcesAndActionsWithStatus,
+  getRoleGroups,
+  getRoleMembers,
+  getRoles,
+  getRoles1, getRoles2, removeRoleFromMember, resetPassword, save, update1, updateAccountRole, updatePartnerAccountAdminData,
+  updatePartnerAccountData,
+  updateRoleWithNewActions,
+  updateUser,
   validateNewPartnerData,
   validatePartnerAssociationLimit,
 } from '../api/account'
@@ -150,10 +168,113 @@ class AccountClient extends ReactQueryNetworkClient {
    * Disables Fido credentials for the given member.
    */
   disableFidoCredentials = this.mutation(deactivateFidoCredentials)
+  /**
+   * Gets group by id.
+   */
+  group = this.query(getGroupById)
+  /**
+   * Get all groups (paginated).
+   */
+  allGroups = this.infiniteQuery(getGroups)
+  /**
+   * Creates a group.
+   */
+  createGroup = this.mutation(save)
+  /**
+   * Updates a group.
+   */
+  updateGroup = this.mutation(update1)
+  /**
+   * Deletes a group.
+   */
+  deleteGroup = this.mutation(deleteV1GroupsByGroupId)
+  /**
+   * Gets all members in a group (paginated).
+   */
+  groupMembers = this.infiniteQuery(getMembers)
+  /**
+   * Adds several members to a group
+   */
+  addMembersToGroup = this.mutation(bindGroupMembers)
   /**
    * Removes a member from a group
    */
   removeMemberFromGroup = this.mutation(deleteMember)
+  /**
+   * Gets all roles of a group.
+   */
+  groupRoles = this.infiniteQuery(getRoles2)
+  /**
+   * Adds several roles to a group.
+   */
+  addRolesToGroup = this.mutation(bindRoles)
+  /**
+   * Removes a role from a group.
+   */
+  removeRoleFromGroup = this.mutation(deleteRole)
+  /**
+   * Gets all resources of a group (paginated).
+   */
+  groupResources = this.infiniteQuery(getGroupResources)
+  /**
+   * Adds several resources to a group.
+   */
+  addResourcesToGroup = this.mutation(addResourcesToGroup)
+  /**
+   * Removes a resource from a group.
+   */
+  removeResourceFromGroup = this.mutation(deleteResourceFromGroup)
+  /**
+   * Gets all roles in the account (paginated)
+   */
+  allRoles = this.infiniteQuery(getRoles)
+  /**
+   * Get a role by id
+   */
+  role = this.query({
+    name: 'account.role',
+    request: async (signal, { id }: { id: string }) => {
+      const roles = await getRoles({ filterBy: 'id', filterValue: id }, { signal })
+      if (!roles.length) throw new StackspotAPIError({ status: 404 })
+      return roles[0]
+    },
+  })
+  /**
+   * Gets all members with the provided role (paginated)
+   */
+  roleMembers = this.infiniteQuery(getRoleMembers)
+  /**
+   * Creates a role
+   */
+  createRole = this.mutation(createAccountRole)
+  /**
+   * Updates a role
+   */
+  updateRole = this.mutation(updateAccountRole)
+  /**
+   * Deletes a role
+   */
+  deleteRole = this.mutation(deleteAccountRole)
+  /**
+   * Adds a role to several members 
+   */
+  addRoleToMembers = this.mutation(addRoleToMember)
+  /**
+   * Gets all groups with the provided role (paginated)
+   */
+  roleGroups = this.infiniteQuery(getRoleGroups)
+  /**
+   * Adds a role to several groups
+   */
+  addRoleToGroups = this.mutation(bindRoleGroups)
+  /**
+   * Get the actions a role is allowed to perform
+   */
+  rolePermissions = this.infiniteQuery(getResourcesAndActionsWithStatus)
+  /**
+   * Updates a role with new actions
+   */
+  updateRolePermissions = this.mutation(updateRoleWithNewActions)
 }
 
 export const accountClient = new AccountClient()

package/src/client/secrets.ts

@@ -0,0 +1,56 @@
+import { HttpError } from '@oazapfts/runtime'
+
+import { createKey, defaults, deleteKey, deleteSecretValue, editKey, getAll1, getAvailability, updateSecretValue } from '../api/secrets'
+import apis from '../apis.json'
+import { DefaultAPIError } from '../error/DefaultAPIError'
+import { secretsDictionary } from '../error/dictionary/secrets'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient'
+
+class SecretClient extends ReactQueryNetworkClient {
+  constructor() {
+    super(apis.secrets.url, defaults)
+  }
+
+  protected buildStackSpotError(error: HttpError): StackspotAPIError {
+    return new DefaultAPIError(error.data, error.status, secretsDictionary, error.headers)
+  }
+
+  /**
+   * Create a key
+   */
+  createKey = this.mutation(createKey)
+  
+  /**
+   * Get all keys
+   */
+  getAllKeys = this.query(getAll1)
+
+  /**
+   * Delete a key
+   */
+  deleteKey = this.mutation(deleteKey)
+
+  /**
+   * Update a key's description
+   */
+  updateKey = this.mutation(editKey)
+
+  /**
+   * Get which secrets are defined or undefined for a user
+   */
+  getAvailability = this.query(getAvailability)
+    
+  /**
+   * Update a secret's value
+   */
+  updateSecretValue = this.mutation(updateSecretValue)
+
+  /**
+   * Delete a secret's value
+   */
+  deleteSecretValue = this.mutation(deleteSecretValue)
+
+}
+
+export const secretsClient = new SecretClient()

package/src/error/DefaultAPIError.ts

@@ -27,10 +27,10 @@ function createMessage(raw: ErrorResponse, dictionary: Dictionary, language: Lan
   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 ? `\n${detail.values.join('\n')}` : ''}` : undefined
+    const name = dict[detail.code] || detail.field || (raw.code !== detail.code && dictionary[language][detail.code]) || detail.code
+    return detail.values?.length ? `${name}${detail.values ? `\n${detail.values.join('\n')}` : ''}` : name
   })?.filter(d => !!d)
-  return `${title}\n${details?.join('\n')}`
+  return details?.length === 1 ? details[0] : `${title}\n${details?.join('\n')}`
 }
 
 /**

package/src/error/dictionary/account.ts

@@ -26,6 +26,7 @@ export const accountDictionary = {
     ACC_ACCOUNT_PARTNER_CANT_BE_INACTIVATED: 'This partner cannot be deactivated due to associated APIs or products.',
     ACC_ACCOUNT_CREATION_PARTNER_ASSOCIATION_LIMIT: 'Your account has reached the limit of associations with partner accounts.',
     ACC_INVALID_PASSWORD: "Invalid password. Please make sure it meets the requirements and hasn't been used before.",
+    ROLES_ALREADY_EXISTS: 'A role with this name already exists.',
   },
   pt: {
     ACC_BAD_REQUEST_ERROR: 'Os dados informados estão inválidos ou inconsistentes.',
@@ -52,5 +53,6 @@ export const accountDictionary = {
     ACC_ACCOUNT_PARTNER_CANT_BE_INACTIVATED: 'Este Parceiro não pode ser inativado devido a APIs ou produtos associados.',
     ACC_ACCOUNT_CREATION_PARTNER_ASSOCIATION_LIMIT: 'Sua conta atingiu o limite de associações com Contas de Parceiros.',
     ACC_INVALID_PASSWORD: 'Senha inválida. Verifique se ela atende aos requisitos e não foi usada anteriormente.',
+    ROLES_ALREADY_EXISTS: 'Já existe um papel com esse nome.',
   },
 } satisfies Dictionary

package/src/error/dictionary/secrets.ts

@@ -0,0 +1,14 @@
+import { Dictionary } from '@stack-spot/portal-translate'
+
+export const secretsDictionary = {
+  en: {
+    WSA_SECRET_KEY_ALREADY_EXISTS: 'Secret Key already exists.',
+    WSA_SECRET_KEY_NOT_FOUND: 'Secret Key not found.',
+    WSA_SECRET_VALUE_NOT_FOUND: 'Secret Value not found.',
+  },
+  pt: {
+    WSA_SECRET_KEY_ALREADY_EXISTS: 'Secret Key já existe.',
+    WSA_SECRET_KEY_NOT_FOUND: 'Secret Key não encontrada.',
+    WSA_SECRET_VALUE_NOT_FOUND: 'Valor da Secret não encontrado.',
+  },
+} satisfies Dictionary

package/src/index.ts

@@ -1,4 +1,5 @@
 export { accountClient } from './client/account'
+export { secretsClient } from './client/secrets'
 export { DefaultAPIError } from './error/DefaultAPIError'
 export { StackspotAPIError } from './error/StackspotAPIError'
 export { NetworkClient } from './network/NetworkClient'

package/src/network/AutoQuery.ts

@@ -76,6 +76,8 @@ export class AutoQuery<Variables, Result> extends AutoOperation<Variables> imple
   }
 
   getKey(variables?: Partial<Variables>)  {
-    return [this.apiName, this.fn.name, variables]
+    const key: any[] = [this.apiName, this.fn.name]
+    if (variables) key.push(variables)
+    return key
   }
 }

package/src/network/ManualInfiniteQuery.ts

@@ -12,7 +12,10 @@ export class ManualInfiniteQuery<
   PageParamName extends keyof Variables,
   Accumulator extends keyof Result | ''
 > extends ManualQuery<Variables, Result> implements InfiniteQueryObject<Variables, Result, Accumulator> {
-  constructor(config: InfiniteQueryConfig<Variables, Result, PageParamName, Accumulator> & { apiName: string }) {
+  constructor(
+    config: InfiniteQueryConfig<Variables, Result, PageParamName, Accumulator>
+      & { apiName: string, transformError: (error: any) => StackspotAPIError },
+  ) {
     super(config as FullOperationConfig<any, any>)
   }
 

package/src/network/ManualMutation.ts

@@ -22,6 +22,8 @@ export class ManualMutation<
       return await this.config.request(
         ...[abortController.signal, variables] as Variables extends void ? [AbortSignal] : [AbortSignal, Variables],
       )
+    } catch (error) {
+      throw this.config.transformError(error)
     } finally {
       this.abortMap.delete(variables)
     }

package/src/network/ManualOperation.ts

@@ -14,11 +14,19 @@ export abstract class ManualOperation<Variables extends Record<string, any> | vo
     this.config = config
   }
 
+  private async makePermissionRequest(variables: Partial<Record<string, any>> | undefined) {
+    try {
+      // @ts-ignore the following is correct. TS can't correctly infer the conditional type here =(
+      return await this.config.permission(variables)
+    } catch (error) {
+      throw this.config.transformError(error)
+    }
+  }
+
   isAllowed(...[variables]: Variables extends void ? [] : [variables?: Partial<Variables>]) {
     return queryClient.fetchQuery({
       queryKey: this.getPermissionKey(variables as Variables),
-      // @ts-ignore the following is correct. TS can't correctly infer the conditional type here =(
-      queryFn: () => this.config.permission(variables),
+      queryFn: () => this.makePermissionRequest(variables),
     })
   }
 
@@ -27,12 +35,15 @@ export abstract class ManualOperation<Variables extends Record<string, any> | vo
       ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
       : [variables?: Partial<Variables>, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
   ) {
-    const [variables, options] = args.length === 2 ? args : [undefined, args[0]]
+    /* `this.config.permission` is a function with arity 0 or 1. If it accepts variables, its arity is 1. If it doesn't accept variables,
+    its arity is zero. 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.config.permission.length === 2 ? args : [undefined, args[0]]
     const result = useQuery({
       ...options,
       queryKey: this.getPermissionKey(variables as Variables),
-      // @ts-ignore the following is correct. TS can't correctly infer the conditional type here =(
-      queryFn: () => this.config.permission(variables),
+      queryFn: () => this.makePermissionRequest(variables),
     }, queryClient) as UseQueryResult<boolean, StackspotAPIError>
     return [result.data, result.isPending, result.error, result] as const
   }

package/src/network/ManualQuery.ts

@@ -26,6 +26,8 @@ export class ManualQuery<
       return await this.config.request(
         ...[abortController.signal, variables] as Variables extends void ? [AbortSignal] : [AbortSignal, Variables],
       )
+    } catch (error) {
+      throw this.config.transformError(error)
     } finally {
       this.abortMap.delete(variables)
       this.currentRequests.delete(variables)

package/src/network/ReactQueryNetworkClient.ts

@@ -55,16 +55,6 @@ export abstract class ReactQueryNetworkClient extends NetworkClient {
     return this.buildStackSpotError(error)
   }
 
-  #withErrorTreatment = <Args extends any[], Result>(block: (...args: Args) => Promise<Result>): ((...args: Args) => Promise<Result>) => (
-    async (...args) => {
-      try {
-        return await block(...args)
-      } catch (error: any) {
-        throw this.#transformError(error)
-      }
-    }
-  )
-
   /**
    * Receives an HttpError and returns a StackspotAPIError.
    * @param error the original HttpError created by oazapfts.
@@ -120,8 +110,9 @@ export abstract class ReactQueryNetworkClient extends NetworkClient {
       : new ManualQuery({
         ...fnOrConfig,
         apiName: this.constructor.name,
-        request: this.#withErrorTreatment(fnOrConfig.request),
-        permission: fnOrConfig.permission ? this.#withErrorTreatment(fnOrConfig.permission) : undefined,
+        request: fnOrConfig.request,
+        permission: fnOrConfig.permission,
+        transformError: error => this.#transformError(error),
       })
   }
 
@@ -205,8 +196,9 @@ export abstract class ReactQueryNetworkClient extends NetworkClient {
       : new ManualInfiniteQuery({
         ...fnOrConfig,
         apiName: this.constructor.name,
-        request: this.#withErrorTreatment(fnOrConfig.request),
-        permission: fnOrConfig.permission ? this.#withErrorTreatment(fnOrConfig.permission) : undefined,
+        request: fnOrConfig.request,
+        permission: fnOrConfig.permission,
+        transformError: error => this.#transformError(error),
       })
   }
 
@@ -245,8 +237,9 @@ export abstract class ReactQueryNetworkClient extends NetworkClient {
     return new ManualMutation({
       ...fnOrConfig,
       apiName: this.constructor.name,
-      request: this.#withErrorTreatment(fnOrConfig.request),
-      permission: fnOrConfig.permission ? this.#withErrorTreatment(fnOrConfig.permission) : undefined,
+      request: fnOrConfig.request,
+      permission: fnOrConfig.permission,
+      transformError: error => this.#transformError(error),
     })
   }
 }

package/src/network/types.ts

@@ -88,6 +88,7 @@ export interface FullOperationConfig<
    * The name of the API where this operation is called: used for composing a query key.
    */
   apiName: string,
+  transformError: (error: any) => StackspotAPIError,
 }
 
 export type InfiniteQueryConfig<