Remove refreshTokens

Author: isaacroldan

packages/app/src/cli/services/app-logs/utils.ts

@@ -194,9 +194,6 @@ export const subscribeToAppLogs = async (
   variables: AppLogsSubscribeMutationVariables,
   organizationId: string,
 ): Promise<string> => {
-  // Refresh the token since it might have expired since the last subscribeToAppLogs request
-  await developerPlatformClient.refreshToken()
-
   // Now try the subscription with the fresh token
   const result = await developerPlatformClient.subscribeToAppLogs(variables, organizationId)
 

packages/app/src/cli/services/dev.test.ts

@@ -1,5 +1,4 @@
-import {developerPreviewController, warnIfScopesDifferBeforeDev} from './dev.js'
-import {fetchAppPreviewMode} from './dev/fetch.js'
+import {warnIfScopesDifferBeforeDev} from './dev.js'
 import {testAppLinked, testDeveloperPlatformClient, testOrganizationApp} from '../models/app/app.test-data.js'
 import {describe, expect, test, vi} from 'vitest'
 import {mockAndCaptureOutput} from '@shopify/cli-kit/node/testing/output'
@@ -8,37 +7,6 @@ vi.mock('./dev/fetch.js')
 vi.mock('@shopify/cli-kit/node/tcp')
 vi.mock('../utilities/mkcert.js')
 
-describe('developerPreviewController', () => {
-  test('does not refresh the tokens when they are still valid', async () => {
-    // Given
-    const developerPlatformClient = testDeveloperPlatformClient()
-    const controller = developerPreviewController('apiKey', developerPlatformClient)
-    vi.mocked(fetchAppPreviewMode).mockResolvedValueOnce(true)
-
-    // When
-    const got = await controller.fetchMode()
-
-    // Then
-    expect(got).toBe(true)
-    expect(developerPlatformClient.refreshToken).not.toHaveBeenCalled()
-  })
-  test('refreshes the tokens when they expire', async () => {
-    // Given
-    const developerPlatformClient = testDeveloperPlatformClient()
-    const controller = developerPreviewController('apiKey', developerPlatformClient)
-    vi.mocked(fetchAppPreviewMode).mockRejectedValueOnce(new Error('expired token'))
-    vi.mocked(fetchAppPreviewMode).mockResolvedValueOnce(true)
-
-    // When
-    const got = await controller.fetchMode()
-
-    // Then
-    expect(got).toBe(true)
-    expect(developerPlatformClient.refreshToken).toHaveBeenCalledOnce()
-    expect(fetchAppPreviewMode).toHaveBeenCalledTimes(2)
-  })
-})
-
 describe('warnIfScopesDifferBeforeDev', () => {
   const appsWithScopes = (local: string, remote: string) => {
     const localApp = testAppLinked({})

packages/app/src/cli/services/dev.ts

@@ -38,15 +38,14 @@ import {RemoteAwareExtensionSpecification} from '../models/extensions/specificat
 import {ports} from '../constants.js'
 import {generateCertificate} from '../utilities/mkcert.js'
 import {Config} from '@oclif/core'
-import {performActionWithRetryAfterRecovery} from '@shopify/cli-kit/common/retry'
 import {AbortController} from '@shopify/cli-kit/node/abort'
 import {checkPortAvailability, getAvailableTCPPort} from '@shopify/cli-kit/node/tcp'
 import {TunnelClient} from '@shopify/cli-kit/node/plugins/tunnel'
 import {getBackendPort} from '@shopify/cli-kit/node/environment'
 import {basename} from '@shopify/cli-kit/node/path'
 import {renderInfo, renderWarning} from '@shopify/cli-kit/node/ui'
 import {reportAnalyticsEvent} from '@shopify/cli-kit/node/analytics'
-import {OutputProcess, formatPackageManagerCommand, outputDebug} from '@shopify/cli-kit/node/output'
+import {OutputProcess, formatPackageManagerCommand} from '@shopify/cli-kit/node/output'
 import {hashString} from '@shopify/cli-kit/node/crypto'
 import {AbortError} from '@shopify/cli-kit/node/error'
 
@@ -452,45 +451,17 @@ export function developerPreviewController(
   if (developerPlatformClient.supportsDevSessions) {
     return {
       fetchMode: () => Promise.resolve(false),
-      enable: () => Promise.resolve(),
+      enable: () => Promise.resolve(false),
       disable: () => Promise.resolve(),
       update: () => Promise.resolve(false),
     }
   }
 
-  const refreshToken = async () => {
-    await developerPlatformClient.refreshToken()
-  }
-
-  const withRefreshToken = async <T>(
-    fn: (developerPlatformClient: DeveloperPlatformClient) => Promise<T>,
-  ): Promise<T> => {
-    try {
-      const result = await performActionWithRetryAfterRecovery(async () => fn(developerPlatformClient), refreshToken)
-      return result
-    } catch (err) {
-      outputDebug('Failed to refresh token')
-      throw err
-    }
-  }
-
   return {
-    fetchMode: async () =>
-      withRefreshToken(async (developerPlatformClient: DeveloperPlatformClient) =>
-        Boolean(await fetchAppPreviewMode(apiKey, developerPlatformClient)),
-      ),
-    enable: async () =>
-      withRefreshToken(async (developerPlatformClient: DeveloperPlatformClient) => {
-        await enableDeveloperPreview({apiKey, developerPlatformClient})
-      }),
-    disable: async () =>
-      withRefreshToken(async (developerPlatformClient: DeveloperPlatformClient) => {
-        await disableDeveloperPreview({apiKey, developerPlatformClient})
-      }),
-    update: async (state: boolean) =>
-      withRefreshToken(async (developerPlatformClient: DeveloperPlatformClient) =>
-        developerPreviewUpdate({apiKey, developerPlatformClient, enabled: state}),
-      ),
+    fetchMode: async () => Boolean(await fetchAppPreviewMode(apiKey, developerPlatformClient)),
+    enable: async () => enableDeveloperPreview({apiKey, developerPlatformClient}),
+    disable: async () => disableDeveloperPreview({apiKey, developerPlatformClient}),
+    update: async (state: boolean) => developerPreviewUpdate({apiKey, developerPlatformClient, enabled: state}),
   }
 }
 

packages/app/src/cli/services/dev/processes/dev-session/dev-session-process.test.ts

@@ -207,25 +207,6 @@ describe('pushUpdatesForDevSession', () => {
     contextSpy.mockRestore()
   })
 
-  test('update is retried if there is an error', async () => {
-    // Given
-    developerPlatformClient.devSessionUpdate = vi
-      .fn()
-      .mockRejectedValueOnce(new Error('Test error'))
-      .mockResolvedValueOnce({devSessionUpdate: {userErrors: []}})
-
-    // When
-    await pushUpdatesForDevSession({stderr, stdout, abortSignal: abortController.signal}, options)
-    await appWatcher.start({stdout, stderr, signal: abortController.signal})
-    await flushPromises()
-    appWatcher.emit('all', {app, extensionEvents: [{type: 'updated', extension: await testWebhookExtensions()}]})
-    await flushPromises()
-
-    // Then
-    expect(developerPlatformClient.refreshToken).toHaveBeenCalledOnce()
-    expect(developerPlatformClient.devSessionUpdate).toHaveBeenCalledTimes(2)
-  })
-
   test('updates preview URL when extension is previewable', async () => {
     // Given
     const extension = await testUIExtension({type: 'ui_extension'})

packages/app/src/cli/services/dev/processes/dev-session/dev-session.ts

@@ -7,7 +7,6 @@ import {DevSessionCreateOptions, DevSessionUpdateOptions} from '../../../../util
 import {AppManifest} from '../../../../models/app/app.js'
 import {endHRTimeInMs, startHRTime} from '@shopify/cli-kit/node/hrtime'
 import {ClientError} from 'graphql-request'
-import {performActionWithRetryAfterRecovery} from '@shopify/cli-kit/common/retry'
 import {JsonMapType} from '@shopify/cli-kit/node/toml'
 import {AbortError} from '@shopify/cli-kit/node/error'
 import {isUnitTest} from '@shopify/cli-kit/node/context/local'
@@ -378,26 +377,19 @@ export class DevSession {
    * @returns The signed URL
    */
   private async getSignedURLWithRetry() {
-    return performActionWithRetryAfterRecovery(
-      async () =>
-        getUploadURL(this.options.developerPlatformClient, {
-          apiKey: this.options.appId,
-          organizationId: this.options.organizationId,
-          id: this.options.appId,
-        }),
-      () => this.options.developerPlatformClient.refreshToken(),
-    )
+    return getUploadURL(this.options.developerPlatformClient, {
+      apiKey: this.options.appId,
+      organizationId: this.options.organizationId,
+      id: this.options.appId,
+    })
   }
 
   /**
    * Update the dev session
    * @param payload - The payload to update the dev session with
    */
   private async devSessionUpdateWithRetry(payload: DevSessionUpdateOptions): Promise<DevSessionResult> {
-    const result = await performActionWithRetryAfterRecovery(
-      async () => this.options.developerPlatformClient.devSessionUpdate(payload),
-      () => this.options.developerPlatformClient.refreshToken(),
-    )
+    const result = await this.options.developerPlatformClient.devSessionUpdate(payload)
     const errors = result.devSessionUpdate?.userErrors ?? []
     if (errors.length) return {status: 'remote-error', error: errors}
     return {status: 'updated'}
@@ -410,10 +402,7 @@ export class DevSession {
    * @param payload - The payload to create the dev session with
    */
   private async devSessionCreateWithRetry(payload: DevSessionCreateOptions): Promise<DevSessionResult> {
-    const result = await performActionWithRetryAfterRecovery(
-      async () => this.options.developerPlatformClient.devSessionCreate(payload),
-      () => this.options.developerPlatformClient.refreshToken(),
-    )
+    const result = await this.options.developerPlatformClient.devSessionCreate(payload)
     const errors = result.devSessionCreate?.userErrors ?? []
     if (errors.length) return {status: 'remote-error', error: errors}
     return {status: 'created'}

packages/app/src/cli/services/dev/processes/draftable-extension.ts

@@ -7,7 +7,6 @@ import {getAppIdentifiers} from '../../../models/app/identifiers.js'
 import {installJavy} from '../../function/build.js'
 import {DeveloperPlatformClient} from '../../../utilities/developer-platform-client.js'
 import {AppEvent, AppEventWatcher, EventType} from '../app-events/app-event-watcher.js'
-import {performActionWithRetryAfterRecovery} from '@shopify/cli-kit/common/retry'
 import {AbortError} from '@shopify/cli-kit/node/error'
 import {useConcurrentOutputContext} from '@shopify/cli-kit/node/ui/components'
 
@@ -35,10 +34,6 @@ export const pushUpdatesForDraftableExtensions: DevProcessFunction<DraftableExte
 
   const draftableExtensions = app.draftableExtensions.map((ext) => ext.handle)
 
-  async function refreshToken() {
-    await developerPlatformClient.refreshToken()
-  }
-
   const handleAppEvent = async (event: AppEvent) => {
     const extensionEvents = event.extensionEvents
       .filter((ev) => ev.type === EventType.Updated)
@@ -50,20 +45,16 @@ export const pushUpdatesForDraftableExtensions: DevProcessFunction<DraftableExte
       const registrationId = remoteExtensions[extension.localIdentifier]
       if (!registrationId) throw new AbortError(`Extension ${extension.localIdentifier} not found on remote app.`)
       await useConcurrentOutputContext({outputPrefix: extension.outputPrefix}, async () => {
-        return performActionWithRetryAfterRecovery(
-          async () =>
-            updateExtensionDraft({
-              extension,
-              developerPlatformClient,
-              apiKey,
-              registrationId,
-              stdout,
-              stderr,
-              appConfiguration: app.configuration,
-              bundlePath: appWatcher.buildOutputPath,
-            }),
-          refreshToken,
-        )
+        await updateExtensionDraft({
+          extension,
+          developerPlatformClient,
+          apiKey,
+          registrationId,
+          stdout,
+          stderr,
+          appConfiguration: app.configuration,
+          bundlePath: appWatcher.buildOutputPath,
+        })
       })
     })
     await Promise.all(promises)

packages/app/src/cli/services/dev/ui.test.tsx

@@ -15,7 +15,7 @@ vi.mock('./ui/components/DevSessionUI.js')
 
 const developerPreview = {
   fetchMode: vi.fn(async () => true),
-  enable: vi.fn(async () => {}),
+  enable: vi.fn(async () => true),
   disable: vi.fn(async () => {}),
   update: vi.fn(async (_state: boolean) => true),
 }

packages/app/src/cli/services/dev/ui/components/Dev.test.tsx

@@ -35,7 +35,7 @@ const testApp = {
 
 const developerPreview = {
   fetchMode: vi.fn(async () => true),
-  enable: vi.fn(async () => {}),
+  enable: vi.fn(async () => true),
   disable: vi.fn(async () => {}),
   update: vi.fn(async (_state: boolean) => true),
 }

packages/app/src/cli/services/dev/ui/components/Dev.tsx

@@ -16,7 +16,7 @@ import {Writable} from 'stream'
 
 export interface DeveloperPreviewController {
   fetchMode: () => Promise<boolean>
-  enable: () => Promise<void>
+  enable: () => Promise<boolean>
   disable: () => Promise<void>
   update: (state: boolean) => Promise<boolean>
 }