@faststore/api 3.63.1 → 3.65.0

package/src/__generated__/schema.ts

@@ -129,6 +129,200 @@ export type AvailableDeliveryWindows = {
   tax?: Maybe<Scalars['Int']>;
 };
 
+/** Commercial Authorization dimension status. */
+export type CommercialAuthorizationDimensionStatus = {
+  __typename?: 'CommercialAuthorizationDimensionStatus';
+  /** Creation date. */
+  creationDate: Scalars['String'];
+  /** Creation environment. */
+  creationEnvironment: Scalars['String'];
+  /** Creation version. */
+  creationVersion: Scalars['String'];
+  /** Dimension status ID. */
+  id: Scalars['String'];
+  /** Dimension status name. */
+  name: Scalars['String'];
+  /** Priority level. */
+  priority: Scalars['Int'];
+  /** Indicates if all rules acceptance is required. */
+  requireAllRulesAcceptance: Scalars['Boolean'];
+  /** Collection of rules for this dimension. */
+  ruleCollection: Array<CommercialAuthorizationRule>;
+  /** Dimension score. */
+  score: Scalars['Float'];
+  /** Indicates if simulation should be performed. */
+  shouldSimulate: Scalars['Boolean'];
+  /** Current status of the dimension. */
+  status: CommercialAuthorizationStatus;
+  /** Unit ID, if applicable. */
+  unitId?: Maybe<Scalars['String']>;
+};
+
+/** Commercial Authorization item. */
+export type CommercialAuthorizationItem = {
+  __typename?: 'CommercialAuthorizationItem';
+  /** Additional information as key-value pairs. */
+  additionalInfo: Scalars['JSONObject'];
+  /** Item ID. */
+  id: Scalars['String'];
+  /** Item price. */
+  price: Scalars['Float'];
+  /** Item quantity. */
+  quantity: Scalars['Int'];
+  /** Item SKU. */
+  sku: Scalars['String'];
+  /** Total manual discount applied. */
+  totalManualDiscount: Scalars['Float'];
+  /** Total system discount applied. */
+  totalSystemDiscount: Scalars['Float'];
+};
+
+/** Commercial Authorization response. */
+export type CommercialAuthorizationResponse = {
+  __typename?: 'CommercialAuthorizationResponse';
+  /** Additional information as key-value pairs. */
+  additionalInfo: Scalars['JSONObject'];
+  /** Callback endpoint URL. */
+  callbackEndpoint: Scalars['String'];
+  /** Creation environment. */
+  creationEnvironment: Scalars['String'];
+  /** Creation version. */
+  creationVersion: Scalars['String'];
+  /** Dimension status information. */
+  dimensionStatus: Array<CommercialAuthorizationDimensionStatus>;
+  /** Commercial Authorization ID. */
+  id: Scalars['String'];
+  /** Collection of items in the commercial authorization. */
+  itemCollection: Array<CommercialAuthorizationItem>;
+  /** Marketplace payment value. */
+  marketPlacePaymentValue: Scalars['Float'];
+  /** Order ID associated with the commercial authorization. */
+  orderId: Scalars['String'];
+  /** Current status of the commercial authorization. */
+  status: CommercialAuthorizationStatus;
+  /** Total order value desired by the seller. */
+  totalOrderValueDesiredBySeller: Scalars['Float'];
+  /** List of units. */
+  units: Array<Scalars['String']>;
+  /** User profile ID. */
+  userProfileId: Scalars['String'];
+  /** Workflow instance ID. */
+  workflowInstanceId: Scalars['String'];
+};
+
+/** Commercial Authorization rule. */
+export type CommercialAuthorizationRule = {
+  __typename?: 'CommercialAuthorizationRule';
+  /** Authorization data, if available. */
+  authorizationData?: Maybe<CommercialAuthorizationRuleAuthorizationData>;
+  /** List of authorized email addresses. */
+  authorizedEmails: Array<Scalars['String']>;
+  /** DO ID, if applicable. */
+  doId?: Maybe<Scalars['String']>;
+  /** Rule ID. */
+  id: Scalars['String'];
+  /**
+   * Indicates that the user is listed as one of the possible approvers,
+   * but does not necessarily mean that he or she is the next in the chain to approve.
+   */
+  isUserAuthorized: Scalars['Boolean'];
+  /**
+   * Indicates that the user is next in the approval chain.
+   * This means that they must take an approval or rejection action.
+   */
+  isUserNextAuthorizer: Scalars['Boolean'];
+  /** Rule name. */
+  name: Scalars['String'];
+  /** Indicates if notification is enabled. */
+  notification: Scalars['Boolean'];
+  /** Rule priority. */
+  priority: Scalars['Int'];
+  /** Score interval configuration. */
+  scoreInterval: CommercialAuthorizationRuleScoreInterval;
+  /** Current status of the rule. */
+  status: CommercialAuthorizationStatus;
+  /** Timeout value. */
+  timeout: Scalars['Int'];
+  /** Rule trigger configuration. */
+  trigger: CommercialAuthorizationRuleTrigger;
+};
+
+/** Commercial Authorization rule authorization data. */
+export type CommercialAuthorizationRuleAuthorizationData = {
+  __typename?: 'CommercialAuthorizationRuleAuthorizationData';
+  /** List of authorizers. */
+  authorizers: Array<CommercialAuthorizationRuleAuthorizer>;
+  /** Indicates if all approvals are required. */
+  requireAllApprovals: Scalars['Boolean'];
+};
+
+/** Commercial Authorization rule authorizer. */
+export type CommercialAuthorizationRuleAuthorizer = {
+  __typename?: 'CommercialAuthorizationRuleAuthorizer';
+  /** Authorization date. */
+  authorizationDate?: Maybe<Scalars['String']>;
+  /** Authorizer email. */
+  email?: Maybe<Scalars['String']>;
+  /** Authorizer ID. */
+  id: Scalars['String'];
+  /** Authorizer type. */
+  type: Scalars['String'];
+};
+
+/** Commercial Authorization rule score interval. */
+export type CommercialAuthorizationRuleScoreInterval = {
+  __typename?: 'CommercialAuthorizationRuleScoreInterval';
+  /** Accept score threshold. */
+  accept: Scalars['Float'];
+  /** Deny score threshold. */
+  deny: Scalars['Float'];
+};
+
+/** Commercial Authorization rule trigger. */
+export type CommercialAuthorizationRuleTrigger = {
+  __typename?: 'CommercialAuthorizationRuleTrigger';
+  /** Trigger condition. */
+  condition: CommercialAuthorizationRuleTriggerCondition;
+  /** Trigger effect. */
+  effect: CommercialAuthorizationRuleTriggerEffect;
+};
+
+/** Commercial Authorization rule trigger condition. */
+export type CommercialAuthorizationRuleTriggerCondition = {
+  __typename?: 'CommercialAuthorizationRuleTriggerCondition';
+  /** Condition type. */
+  conditionType: Scalars['Int'];
+  /** Condition description. */
+  description?: Maybe<Scalars['String']>;
+  /** Condition expression. */
+  expression?: Maybe<Scalars['String']>;
+  /** Greater than value. */
+  greatherThan?: Maybe<Scalars['Float']>;
+  /** Less than value. */
+  lessThan?: Maybe<Scalars['Float']>;
+};
+
+/** Commercial Authorization rule trigger effect. */
+export type CommercialAuthorizationRuleTriggerEffect = {
+  __typename?: 'CommercialAuthorizationRuleTriggerEffect';
+  /** Effect description. */
+  description?: Maybe<Scalars['String']>;
+  /** Effect type. */
+  effectType: Scalars['Int'];
+  /** Function path. */
+  funcPath?: Maybe<Scalars['String']>;
+};
+
+/** Commercial Authorization status. */
+export const enum CommercialAuthorizationStatus {
+  /** Authorization has been accepted. */
+  Accepted = 'accepted',
+  /** Authorization has been denied. */
+  Denied = 'denied',
+  /** Authorization is pending. */
+  Pending = 'pending'
+};
+
 export type DeliveryIds = {
   __typename?: 'DeliveryIds';
   /** DeliveryIds courier id */
@@ -143,6 +337,12 @@ export type DeliveryIds = {
   warehouseId?: Maybe<Scalars['String']>;
 };
 
+/** Input to get commercial authorizations by order ID. */
+export type ICommercialAuthorizationByOrderId = {
+  /** Order ID to get commercial authorizations for. */
+  orderId: Scalars['String'];
+};
+
 export type IGeoCoordinates = {
   /** The latitude of the geographic coordinates. */
   latitude: Scalars['Float'];
@@ -158,6 +358,18 @@ export type IPersonNewsletter = {
   name: Scalars['String'];
 };
 
+/** Input to process order authorization (approve or reject). */
+export type IProcessOrderAuthorization = {
+  /** Whether the authorization is approved (true) or rejected (false). */
+  approved: Scalars['Boolean'];
+  /** Dimension ID associated with the authorization. */
+  dimensionId: Scalars['String'];
+  /** Order authorization ID. */
+  orderAuthorizationId: Scalars['String'];
+  /** Rule ID associated with the authorization. */
+  ruleId: Scalars['String'];
+};
+
 /** Shipping Simulation item input. */
 export type IShippingItem = {
   /** ShippingItem ID / Sku. */
@@ -413,6 +625,8 @@ export type Mutation = {
   __typename?: 'Mutation';
   /** Cancels user order */
   cancelOrder?: Maybe<UserOrderCancel>;
+  /** Process Order Authorization */
+  processOrderAuthorization?: Maybe<ProcessOrderAuthorizationResponse>;
   /** Subscribes a new person to the newsletter list. */
   subscribeToNewsletter?: Maybe<PersonNewsletter>;
   /** Checks for changes between the cart presented in the UI and the cart stored in the ecommerce platform. If changes are detected, it returns the cart stored on the platform. Otherwise, it returns `null`. */
@@ -427,6 +641,11 @@ export type MutationCancelOrderArgs = {
 };
 
 
+export type MutationProcessOrderAuthorizationArgs = {
+  data: IProcessOrderAuthorization;
+};
+
+
 export type MutationSubscribeToNewsletterArgs = {
   data: IPersonNewsletter;
 };
@@ -494,6 +713,26 @@ export type PickupStoreInfo = {
   isPickupStore?: Maybe<Scalars['Boolean']>;
 };
 
+/** Process Order Authorization response. */
+export type ProcessOrderAuthorizationResponse = {
+  __typename?: 'ProcessOrderAuthorizationResponse';
+  /** Indicates if authorization is pending for other authorizers. */
+  isPendingForOtherAuthorizer: Scalars['Boolean'];
+  /** The updated rule for authorization, if any. */
+  ruleForAuthorization?: Maybe<ProcessOrderAuthorizationRule>;
+};
+
+/** Extended Commercial Authorization rule with additional process context. */
+export type ProcessOrderAuthorizationRule = {
+  __typename?: 'ProcessOrderAuthorizationRule';
+  /** Dimension ID. */
+  dimensionId: Scalars['String'];
+  /** Order authorization ID. */
+  orderAuthorizationId: Scalars['String'];
+  /** Base rule information. */
+  rule: CommercialAuthorizationRule;
+};
+
 export type ProductCountResult = {
   __typename?: 'ProductCountResult';
   /** Total product count. */
@@ -540,6 +779,8 @@ export type Query = {
   __typename?: 'Query';
   /** Returns the account name of the current user or the B2B contract name if applicable. */
   accountName?: Maybe<Scalars['String']>;
+  /** Returns the account profile information for the current authenticated user (b2b or b2c user). */
+  accountProfile: StoreAccountProfile;
   /** Returns information about all collections. */
   allCollections: StoreCollectionConnection;
   /** Returns information about all products. */
@@ -562,6 +803,8 @@ export type Query = {
   sellers?: Maybe<SellersData>;
   /** Returns information about shipping simulation. */
   shipping?: Maybe<ShippingData>;
+  /** Returns information about the current user details. */
+  userDetails: StoreUserDetails;
   /** Returns information about the Details of an User Order. */
   userOrder?: Maybe<UserOrderResult>;
   /** Returns information about the user validation. */
@@ -763,6 +1006,14 @@ export type SkuVariantsSlugsMapArgs = {
   dominantVariantName?: Maybe<Scalars['String']>;
 };
 
+/** Account profile information. */
+export type StoreAccountProfile = {
+  __typename?: 'StoreAccountProfile';
+  email?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['String']>;
+  name?: Maybe<Scalars['String']>;
+};
+
 /** Aggregate offer information, for a given SKU that is available to be fulfilled by multiple sellers. */
 export type StoreAggregateOffer = {
   __typename?: 'StoreAggregateOffer';
@@ -1336,6 +1587,19 @@ export type StoreSuggestions = {
   terms: Array<StoreSuggestionTerm>;
 };
 
+/** User details information. */
+export type StoreUserDetails = {
+  __typename?: 'StoreUserDetails';
+  /** User's email. */
+  email?: Maybe<Scalars['String']>;
+  /** User's name. */
+  name?: Maybe<Scalars['String']>;
+  /** User's organizational unit. */
+  orgUnit?: Maybe<Scalars['String']>;
+  /** User's role. */
+  role?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+
 export type UserOrder = {
   __typename?: 'UserOrder';
   affiliateId?: Maybe<Scalars['String']>;
@@ -1343,6 +1607,7 @@ export type UserOrder = {
   allowEdition?: Maybe<Scalars['Boolean']>;
   authorizedDate?: Maybe<Scalars['String']>;
   callCenterOperatorData?: Maybe<Scalars['String']>;
+  canProcessOrderAuthorization?: Maybe<Scalars['Boolean']>;
   cancelReason?: Maybe<Scalars['String']>;
   cancellationData?: Maybe<UserOrderCancellationData>;
   cancellationRequests?: Maybe<Array<Maybe<UserOrderCancellationRequest>>>;
@@ -1381,6 +1646,7 @@ export type UserOrder = {
   paymentData?: Maybe<UserOrderPaymentData>;
   ratesAndBenefitsData?: Maybe<UserOrderRatesAndBenefitsData>;
   roundingError?: Maybe<Scalars['Int']>;
+  ruleForAuthorization?: Maybe<ProcessOrderAuthorizationRule>;
   salesChannel?: Maybe<Scalars['String']>;
   sellerOrderId?: Maybe<Scalars['String']>;
   sellers?: Maybe<Array<Maybe<UserOrderStoreSellers>>>;
@@ -1630,6 +1896,7 @@ export type UserOrderDeliveryOptionsItems = {
   quantity?: Maybe<Scalars['Int']>;
   tax?: Maybe<Scalars['Float']>;
   total?: Maybe<Scalars['Float']>;
+  uniqueId?: Maybe<Scalars['String']>;
 };
 
 export type UserOrderDeliveryWindow = {
@@ -2050,6 +2317,7 @@ export type UserOrderRestitutions = {
 export type UserOrderResult = {
   __typename?: 'UserOrderResult';
   allowCancellation?: Maybe<Scalars['Boolean']>;
+  canProcessOrderAuthorization?: Maybe<Scalars['Boolean']>;
   clientProfileData?: Maybe<UserOrderClientProfileData>;
   customData?: Maybe<UserOrderCustomData>;
   customFields?: Maybe<Array<Maybe<UserOrderCustomFieldsGrouped>>>;
@@ -2057,6 +2325,7 @@ export type UserOrderResult = {
   items?: Maybe<Array<Maybe<UserOrderItems>>>;
   orderId?: Maybe<Scalars['String']>;
   paymentData?: Maybe<UserOrderPaymentData>;
+  ruleForAuthorization?: Maybe<ProcessOrderAuthorizationRule>;
   shippingData?: Maybe<UserOrderShippingData>;
   status?: Maybe<Scalars['String']>;
   statusDescription?: Maybe<Scalars['String']>;

package/src/platforms/vtex/clients/commerce/index.ts

@@ -3,6 +3,9 @@ import type { FACET_CROSS_SELLING_MAP } from '../../utils/facets'
 import { fetchAPI } from '../fetch'
 
 import type {
+  CommercialAuthorizationResponse,
+  ICommercialAuthorizationByOrderId,
+  IProcessOrderAuthorization,
   IUserOrderCancel,
   QueryListUserOrdersArgs,
   StoreMarketingData,
@@ -441,10 +444,7 @@ export const VtexCommerce = (
     },
     oms: {
       userOrder: ({ orderId }: { orderId: string }): Promise<UserOrder> => {
-        const headers: HeadersInit = withCookie({
-          'content-type': 'application/json',
-          'X-FORWARDED-HOST': forwardedHost,
-        })
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
 
         return fetchAPI(
           `${base}/api/oms/user/orders/${orderId}`,
@@ -520,6 +520,49 @@ export const VtexCommerce = (
           { storeCookies }
         )
       },
+      getCommercialAuthorizationsByOrderId: ({
+        orderId,
+      }: ICommercialAuthorizationByOrderId): Promise<CommercialAuthorizationResponse> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/${account}/commercial-authorizations/order/${orderId}`,
+          {
+            method: 'GET',
+            headers,
+          },
+          { storeCookies }
+        )
+      },
+      processOrderAuthorization: async ({
+        orderAuthorizationId,
+        dimensionId,
+        ruleId,
+        approved,
+      }: IProcessOrderAuthorization): Promise<CommercialAuthorizationResponse> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        const APPROVAL_SCORE = 100
+        const REJECTION_SCORE = 0
+
+        const body = {
+          params: {
+            ruleId,
+            dimensionId,
+            score: approved ? APPROVAL_SCORE : REJECTION_SCORE,
+          },
+        }
+
+        return fetchAPI(
+          `${base}/${account}/commercial-authorizations/${orderAuthorizationId}/callback`,
+          {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+          },
+          { storeCookies }
+        )
+      },
     },
     units: {
       getUnitByUserId: ({
@@ -584,6 +627,24 @@ export const VtexCommerce = (
           {}
         )
       },
+      getUserByEmail: ({
+        email,
+      }: { email: string }): Promise<{
+        id: string
+        name: string
+        email: string
+      }> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/api/license-manager/pvt/users/${email}`,
+          {
+            method: 'GET',
+            headers,
+          },
+          {}
+        )
+      },
     },
     masterData: {
       getContractById: ({

package/src/platforms/vtex/resolvers/mutation.ts

@@ -1,4 +1,5 @@
 import { cancelOrder } from './cancelOrder'
+import { processOrderAuthorization } from './processOrderAuthorization'
 import { subscribeToNewsletter } from './subscribeToNewsletter'
 import { validateCart } from './validateCart'
 import { validateSession } from './validateSession'
@@ -8,4 +9,5 @@ export const Mutation = {
   validateSession,
   subscribeToNewsletter,
   cancelOrder,
+  processOrderAuthorization,
 }

package/src/platforms/vtex/resolvers/processOrderAuthorization.ts

@@ -0,0 +1,30 @@
+import type { Context } from '..'
+import type {
+  ProcessOrderAuthorizationResponse,
+  IProcessOrderAuthorization,
+} from '../../../__generated__/schema'
+import {
+  extractRuleForAuthorization,
+  isPendingForOtherAuthorizer,
+} from '../utils/commercialAuth'
+
+export const processOrderAuthorization = async (
+  _: any,
+  { data }: { data: IProcessOrderAuthorization },
+  { clients: { commerce } }: Context
+): Promise<ProcessOrderAuthorizationResponse | null> => {
+  // Process the authorization
+  const commercialAuth = await commerce.oms.processOrderAuthorization(data)
+
+  // Extract pending authorization for current user
+  const ruleForAuthorization = extractRuleForAuthorization(commercialAuth)
+
+  // Check if there are pending authorizations for other users
+  const isPendingForOther =
+    !ruleForAuthorization && isPendingForOtherAuthorizer(commercialAuth)
+
+  return {
+    isPendingForOtherAuthorizer: isPendingForOther,
+    ruleForAuthorization,
+  }
+}

package/src/platforms/vtex/resolvers/query.ts

@@ -1,4 +1,5 @@
 import type {
+  ProcessOrderAuthorizationRule,
   QueryAllCollectionsArgs,
   QueryAllProductsArgs,
   QueryCollectionArgs,
@@ -32,6 +33,7 @@ import {
 import { isValidSkuId, pickBestSku } from '../utils/sku'
 import { SORT_MAP } from '../utils/sort'
 import { FACET_CROSS_SELLING_MAP } from './../utils/facets'
+import { extractRuleForAuthorization } from '../utils/commercialAuth'
 import { StoreCollection } from './collection'
 
 export const Query = {
@@ -400,6 +402,20 @@ export const Query = {
         throw new NotFoundError(`No order found for id ${orderId}`)
       }
 
+      let ruleForAuthorization: ProcessOrderAuthorizationRule | null = null
+
+      try {
+        /**
+         * This endpoint could return a 404 error if has not an authorization
+         * for the order, so we catch the error and return null
+         * instead of throwing an error.
+         */
+        const commercialAuth =
+          await commerce.oms.getCommercialAuthorizationsByOrderId({ orderId })
+
+        ruleForAuthorization = extractRuleForAuthorization(commercialAuth)
+      } catch (err: any) {}
+
       return {
         orderId: order.orderId,
         totals: order.totals,
@@ -412,6 +428,11 @@ export const Query = {
         allowCancellation: order.allowCancellation,
         storePreferencesData: order.storePreferencesData,
         clientProfileData: order.clientProfileData,
+        canProcessOrderAuthorization:
+          (order.status === 'waiting-for-confirmation' ||
+            order.status === 'waiting-for-authorization') &&
+          !!ruleForAuthorization,
+        ruleForAuthorization,
       }
     } catch (error) {
       const result = JSON.parse((error as Error).message).error as {
@@ -514,4 +535,70 @@ export const Query = {
       throw new ForbiddenError('You are not allowed to access this resource')
     }
   },
+  // only b2b users
+  userDetails: async (_: unknown, __: unknown, ctx: Context) => {
+    const {
+      clients: { commerce },
+    } = ctx
+
+    // const params = new URLSearchParams()
+    const sessionData = await commerce.session('').catch(() => null)
+
+    const shopper = sessionData?.namespaces.shopper ?? null
+    const authentication = sessionData?.namespaces.authentication ?? null
+
+    return {
+      name: shopper?.firstName?.value ?? '',
+      email: authentication?.storeUserEmail.value ?? '',
+      role: ['Admin'], // TODO change when implemented roles,
+      orgUnit: authentication?.unitName?.value ?? '',
+    }
+  },
+  // If isRepresentative, return b2b information.
+  // If not, return b2c user information
+  accountProfile: async (_: unknown, __: unknown, ctx: Context) => {
+    const {
+      account,
+      headers,
+      clients: { commerce },
+    } = ctx
+
+    const jwt = parseJwt(getAuthCookie(headers?.cookie ?? '', account))
+
+    if (!jwt?.userId) {
+      return null
+    }
+
+    if (jwt?.isRepresentative) {
+      const sessionData = await commerce.session('').catch(() => null)
+
+      if (!sessionData) {
+        return null
+      }
+
+      const profile = sessionData.namespaces.profile ?? null
+
+      return {
+        name:
+          `${(profile?.firstName?.value ?? '').trim()} ${(profile?.lastName?.value ?? '').trim()}`.trim() ||
+          '',
+        email: profile?.email?.value || '',
+        id: profile?.id?.value || '',
+        // createdAt: '',
+      }
+    }
+
+    const user = await commerce.licenseManager
+      .getUserById({
+        userId: jwt?.userId,
+      })
+      .catch(() => null)
+
+    return {
+      name: user?.name || '',
+      email: user?.email || '',
+      id: user?.id || '',
+      // createdAt: '',
+    }
+  },
 }

package/src/platforms/vtex/resolvers/userOrder.ts

@@ -86,6 +86,7 @@ export const UserOrderResult: Record<string, Resolver<Root>> = {
         if (acc[groupKey]) {
           acc[groupKey].items?.push({
             id: item?.id || '',
+            uniqueId: item?.uniqueId || '',
             name: item?.name || '',
             quantity: item?.quantity || 0,
             price: item?.price || 0,

package/src/platforms/vtex/utils/commercialAuth.ts

@@ -0,0 +1,55 @@
+import type {
+  CommercialAuthorizationResponse,
+  ProcessOrderAuthorizationRule,
+} from '../../../__generated__/schema'
+
+/**
+ * Extracts the first pending rule for authorization where the user is the next authorizer.
+ * Returns null if no such rule exists or if the commercial authorization is not pending.
+ */
+export function extractRuleForAuthorization(
+  commercialAuth: CommercialAuthorizationResponse | null | undefined
+): ProcessOrderAuthorizationRule | null {
+  if (!commercialAuth || commercialAuth.status !== 'pending') {
+    return null
+  }
+
+  for (const dimension of commercialAuth.dimensionStatus) {
+    if (dimension.status !== 'pending') {
+      continue
+    }
+
+    const pendingRule = dimension.ruleCollection.find(
+      (rule) => rule.status === 'pending' && rule.isUserNextAuthorizer
+    )
+
+    if (pendingRule) {
+      return {
+        rule: pendingRule,
+        orderAuthorizationId: commercialAuth.id,
+        dimensionId: dimension.id,
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Checks if there are pending rules for other authorizers in the commercial authorization.
+ * Returns true if all pending rules are not for the current user (i.e., the user is not the next authorizer).
+ */
+export function isPendingForOtherAuthorizer(
+  commercialAuth: CommercialAuthorizationResponse | null | undefined
+): boolean {
+  if (!commercialAuth || commercialAuth.status !== 'pending') return false
+
+  const pendingRules = commercialAuth.dimensionStatus
+    .filter((dimension) => dimension.status === 'pending')
+    .flatMap((dimension) => dimension.ruleCollection)
+    .filter((rule) => rule.status === 'pending')
+
+  if (pendingRules.length === 0) return false
+
+  return pendingRules.every((rule) => !rule.isUserNextAuthorizer)
+}