Pass in handleClientError method from the strategy

packages/shopify-app-remix/src/server/authenticate/admin/authenticate.ts

@@ -82,10 +82,9 @@ export function authStrategyFactory<
       | EmbeddedAdminContext<ConfigArg, Resources>
       | NonEmbeddedAdminContext<ConfigArg, Resources> = {
       admin: createAdminApiContext<Resources>(
-        request,
         session,
         params,
-        authStrategy,
+        authStrategy.handleClientError(request),
       ),
       billing: {
         require: requireBillingFactory(params, request, session),

packages/shopify-app-remix/src/server/authenticate/admin/helpers/create-admin-api-context.ts

@@ -1,25 +1,22 @@
 import {Session, ShopifyRestResources} from '@shopify/shopify-api';
 
 import type {BasicParams} from '../../../types';
-import {AdminApiContext, adminClientFactory} from '../../../clients/admin';
-import {AuthorizationStrategy} from '../strategies/types';
-
-import {handleClientErrorFactory} from './handle-client-error';
+import {
+  AdminApiContext,
+  HandleAdminClientError,
+  adminClientFactory,
+} from '../../../clients/admin';
 
 export function createAdminApiContext<
   Resources extends ShopifyRestResources = ShopifyRestResources,
 >(
-  request: Request,
   session: Session,
   params: BasicParams,
-  authStrategy?: AuthorizationStrategy,
+  handleClientError: HandleAdminClientError,
 ): AdminApiContext<Resources> {
   return adminClientFactory<Resources>({
     session,
     params,
-    handleClientError: handleClientErrorFactory({
-      request,
-      authStrategy,
-    }),
+    handleClientError,
   });
 }

packages/shopify-app-remix/src/server/authenticate/admin/helpers/handle-client-error.ts

@@ -5,7 +5,7 @@ import {HandleClientErrorOptions} from '../strategies/types';
 
 export function handleClientErrorFactory({
   request,
-  authStrategy,
+  onError,
 }: HandleClientErrorOptions): HandleAdminClientError {
   return async function handleClientError({
     error,
@@ -28,12 +28,8 @@ export function handleClientErrorFactory({
       },
     );
 
-    if (error.response.code === 401 && authStrategy) {
-      await authStrategy.handleInvalidAccessTokenError({
-        request,
-        session,
-        error,
-      });
+    if (onError) {
+      await onError({request, session, error});
     }
 
     // forward a minimal copy of the upstream HTTP response instead of an Error:

packages/shopify-app-remix/src/server/authenticate/admin/helpers/trigger-after-auth-hook.ts

@@ -19,10 +19,9 @@ export async function triggerAfterAuthHook<
     await config.hooks.afterAuth({
       session,
       admin: createAdminApiContext<Resources>(
-        request,
         session,
         params,
-        authStrategy,
+        authStrategy.handleClientError(request),
       ),
     });
   }

packages/shopify-app-remix/src/server/authenticate/admin/strategies/auth-code-flow.ts

@@ -12,6 +12,7 @@ import {
 import type {BasicParams} from '../../../types';
 import {
   beginAuth,
+  handleClientErrorFactory,
   redirectToAuthPage,
   redirectToShopifyOrAppRoot,
   redirectWithExitIframe,
@@ -20,12 +21,9 @@ import {
 } from '../helpers';
 import {AppConfig} from '../../../config-types';
 import {getSessionTokenHeader} from '../../helpers';
+import {HandleAdminClientError} from '../../../clients';
 
-import {
-  AuthorizationStrategy,
-  HandleInvalidAccessTokenOptions,
-  SessionContext,
-} from './types';
+import {AuthorizationStrategy, SessionContext, OnErrorOptions} from './types';
 
 export class AuthCodeFlowStrategy<
   Resources extends ShopifyRestResources = ShopifyRestResources,
@@ -91,16 +89,20 @@ export class AuthCodeFlowStrategy<
     return session!;
   }
 
-  public async handleInvalidAccessTokenError({
-    request,
-    session,
-  }: HandleInvalidAccessTokenOptions): Promise<never> {
+  public handleClientError(request: Request): HandleAdminClientError {
     const {api, config, logger} = this;
-    throw await redirectToAuthPage(
-      {api, config, logger},
+    return handleClientErrorFactory({
       request,
-      session.shop,
-    );
+      onError: async ({session, error}: OnErrorOptions) => {
+        if (error.response.code === 401) {
+          throw await redirectToAuthPage(
+            {api, config, logger},
+            request,
+            session.shop,
+          );
+        }
+      },
+    });
   }
 
   private async ensureInstalledOnShop(request: Request) {

packages/shopify-app-remix/src/server/authenticate/admin/strategies/token-exchange.ts

@@ -9,13 +9,10 @@ import {AppConfig, AppConfigArg} from 'src/server/config-types';
 import {BasicParams, ApiConfigWithFutureFlags} from 'src/server/types';
 
 import {respondToInvalidSessionToken} from '../../helpers';
-import {triggerAfterAuthHook} from '../helpers';
+import {handleClientErrorFactory, triggerAfterAuthHook} from '../helpers';
+import {HandleAdminClientError} from '../../../clients';
 
-import {
-  AuthorizationStrategy,
-  HandleInvalidAccessTokenOptions,
-  SessionContext,
-} from './types';
+import {AuthorizationStrategy, SessionContext, OnErrorOptions} from './types';
 
 export class TokenExchangeStrategy<Config extends AppConfigArg>
   implements AuthorizationStrategy
@@ -88,17 +85,20 @@ export class TokenExchangeStrategy<Config extends AppConfigArg>
     return session!;
   }
 
-  public async handleInvalidAccessTokenError({
-    request,
-    session,
-  }: HandleInvalidAccessTokenOptions): Promise<void> {
-    const {config, api, logger} = this;
-
-    config.sessionStorage.deleteSession(session.id);
-
-    respondToInvalidSessionToken({
-      params: {config, api, logger},
+  public handleClientError(request: Request): HandleAdminClientError {
+    const {api, config, logger} = this;
+    return handleClientErrorFactory({
       request,
+      onError: async ({session, error}: OnErrorOptions) => {
+        if (error.response.code === 401) {
+          config.sessionStorage.deleteSession(session.id);
+
+          respondToInvalidSessionToken({
+            params: {config, api, logger},
+            request,
+          });
+        }
+      },
     });
   }
 

packages/shopify-app-remix/src/server/authenticate/admin/strategies/types.ts

@@ -1,29 +1,29 @@
-import {Session} from '@shopify/shopify-api';
+import {HttpResponseError, Session} from '@shopify/shopify-api';
+
+import {HandleAdminClientError} from '../../../clients';
 
 export interface SessionContext {
   shop: string;
   session?: Session;
   sessionToken?: string;
 }
 
-export interface HandleClientErrorOptions {
+export interface OnErrorOptions {
   request: Request;
-  authStrategy?: AuthorizationStrategy;
+  session: Session;
+  error: HttpResponseError;
 }
 
-export interface HandleInvalidAccessTokenOptions {
+export interface HandleClientErrorOptions {
   request: Request;
-  session: Session;
-  error: any;
+  onError?: ({session, error}: OnErrorOptions) => Promise<void | never>;
 }
+
 export interface AuthorizationStrategy {
   respondToOAuthRequests: (request: Request) => Promise<void | never>;
   authenticate: (
     request: Request,
     sessionContext: SessionContext,
   ) => Promise<Session | never>;
-  handleInvalidAccessTokenError: ({
-    request,
-    session,
-  }: HandleInvalidAccessTokenOptions) => Promise<void | never>;
+  handleClientError: (request: Request) => HandleAdminClientError;
 }