Simplify code

Author: gonzaloriestra

packages/app/src/cli/models/app/app.ts

@@ -124,23 +124,19 @@ export function getAppVersionedSchema(
  * Get scopes from a given app.toml config file.
  * @param config - a configuration file
  */
-export function getAppScopes(config: AppConfiguration): string {
-  return (config as CurrentAppConfiguration).access_scopes?.scopes ?? ''
+export function getAppScopes(config: CurrentAppConfiguration): string {
+  return config.access_scopes?.scopes ?? ''
 }
 
 /**
  * Get scopes as an array from a given app.toml config file.
  * @param config - a configuration file
  */
-export function getAppScopesArray(config: AppConfiguration) {
+export function getAppScopesArray(config: CurrentAppConfiguration) {
   const scopes = getAppScopes(config)
   return scopes.length ? scopes.split(',').map((scope) => scope.trim()) : []
 }
 
-export function usesLegacyScopesBehavior(config: AppConfiguration) {
-  return (config as CurrentAppConfiguration).access_scopes?.use_legacy_install_flow === true
-}
-
 export function appHiddenConfigPath(appDirectory: string) {
   return joinPath(appDirectory, configurationFileNames.hiddenFolder, configurationFileNames.hiddenConfig)
 }
@@ -195,7 +191,7 @@ export interface Web {
 }
 
 export interface AppConfigurationInterface<
-  TConfig extends AppConfiguration = AppConfiguration,
+  TConfig extends CurrentAppConfiguration = CurrentAppConfiguration,
   TModuleSpec extends ExtensionSpecification = ExtensionSpecification,
 > {
   directory: string
@@ -223,7 +219,7 @@ export interface ManifestModule extends JsonMapType {
 }
 
 export interface AppInterface<
-  TConfig extends AppConfiguration = AppConfiguration,
+  TConfig extends CurrentAppConfiguration = CurrentAppConfiguration,
   TModuleSpec extends ExtensionSpecification = ExtensionSpecification,
 > extends AppConfigurationInterface<TConfig, TModuleSpec> {
   name: string
@@ -265,8 +261,8 @@ export interface AppInterface<
 }
 
 type AppConstructor<
-  TConfig extends AppConfiguration,
-  TModuleSpec extends ExtensionSpecification,
+  TConfig extends CurrentAppConfiguration = CurrentAppConfiguration,
+  TModuleSpec extends ExtensionSpecification = ExtensionSpecification,
 > = AppConfigurationInterface<TConfig, TModuleSpec> & {
   name: string
   packageManager: PackageManager
@@ -283,7 +279,7 @@ type AppConstructor<
 }
 
 export class App<
-  TConfig extends AppConfiguration = AppConfiguration,
+  TConfig extends CurrentAppConfiguration = CurrentAppConfiguration,
   TModuleSpec extends ExtensionSpecification = ExtensionSpecification,
 > implements AppInterface<TConfig, TModuleSpec>
 {
@@ -452,7 +448,7 @@ export class App<
   }
 
   get appIsEmbedded(): boolean {
-    return (this.configuration as CurrentAppConfiguration).embedded
+    return this.configuration.embedded
   }
 
   creationDefaultOptions(): CreateAppOptions {
@@ -500,20 +496,18 @@ export class App<
   }
 
   private patchAppConfiguration(devApplicationURLs: ApplicationURLs) {
-    const config = this.configuration as CurrentAppConfiguration
     this.devApplicationURLs = devApplicationURLs
-    config.application_url = devApplicationURLs.applicationUrl
+    this.configuration.application_url = devApplicationURLs.applicationUrl
     if (devApplicationURLs.appProxy) {
-      config.app_proxy = {
+      this.configuration.app_proxy = {
         url: devApplicationURLs.appProxy.proxyUrl,
         subpath: devApplicationURLs.appProxy.proxySubPath,
         prefix: devApplicationURLs.appProxy.proxySubPathPrefix,
       }
     }
-    if (config.auth?.redirect_urls) {
-      config.auth.redirect_urls = devApplicationURLs.redirectUrlWhitelist
+    if (this.configuration.auth?.redirect_urls) {
+      this.configuration.auth.redirect_urls = devApplicationURLs.redirectUrlWhitelist
     }
-    this.configuration = config as TConfig
   }
 
   /**
@@ -523,14 +517,11 @@ export class App<
    * @throws When app-specific webhooks are used with legacy install flow
    */
   private validateWebhookLegacyFlowCompatibility(): void {
-    // These fields might not exist on basic AppConfiguration but could be added by specifications
-    const config = this.configuration as CurrentAppConfiguration
-
     const hasAppSpecificWebhooks =
-      config.webhooks?.subscriptions?.some(
+      this.configuration.webhooks?.subscriptions?.some(
         (subscription: WebhookSubscription) => subscription.topics && subscription.topics.length > 0,
       ) ?? false
-    const usesLegacyInstallFlow = config.access_scopes?.use_legacy_install_flow === true
+    const usesLegacyInstallFlow = this.configuration.access_scopes?.use_legacy_install_flow === true
 
     if (hasAppSpecificWebhooks && usesLegacyInstallFlow) {
       throw new AbortError(

packages/app/src/cli/models/app/loader.test.ts

@@ -3480,7 +3480,7 @@ describe('getAppConfigurationState', () => {
           path: expect.stringMatching(/shopify.app.toml$/),
           client_id: 'abcdef',
         },
-        isTemplateForm: false,
+        isLinked: true,
       },
     ],
     [
@@ -3492,7 +3492,7 @@ describe('getAppConfigurationState', () => {
           client_id: 'abcdef',
           something_extra: 'keep',
         },
-        isTemplateForm: false,
+        isLinked: true,
       },
     ],
     [
@@ -3502,7 +3502,7 @@ describe('getAppConfigurationState', () => {
           path: expect.stringMatching(/shopify.app.toml$/),
           client_id: '',
         },
-        isTemplateForm: true,
+        isLinked: false,
       },
     ],
   ])('loads from %s', async (content, resultShouldContain) => {
@@ -3528,7 +3528,7 @@ describe('getAppConfigurationState', () => {
       const result = await getAppConfigurationState(tmpDir, undefined)
 
       expect(result.basicConfiguration.client_id).toBe('')
-      expect(result.isTemplateForm).toBe(true)
+      expect(result.isLinked).toBe(false)
     })
   })
 })

packages/app/src/cli/models/app/loader.ts

@@ -195,7 +195,7 @@ export class AppErrors {
   }
 }
 
-interface AppLoaderConstructorArgs<TConfig extends AppConfiguration, TModuleSpec extends ExtensionSpecification> {
+interface AppLoaderConstructorArgs<TConfig extends CurrentAppConfiguration, TModuleSpec extends ExtensionSpecification> {
   mode?: AppLoaderMode
   loadedConfiguration: ConfigurationLoaderResult<TConfig, TModuleSpec>
   // Used when reloading an app, to avoid some expensive steps during loading.
@@ -216,7 +216,7 @@ export async function loadConfigForAppCreation(directory: string, name: string):
   const webs = await loadWebsForAppCreation(state.appDirectory, config.web_directories)
   const isLaunchable = webs.some((web) => isWebType(web, WebType.Frontend) || isWebType(web, WebType.Backend))
 
-  const scopesArray = getAppScopesArray(config)
+  const scopesArray = getAppScopesArray(config as CurrentAppConfiguration)
 
   return {
     isLaunchable,
@@ -259,19 +259,19 @@ async function loadSingleWeb(webConfigPath: string, abortOrReport: AbortOrReport
  * If the App contains extensions not supported by the current specs and mode is strict, it will throw an error.
  */
 export async function loadApp<TModuleSpec extends ExtensionSpecification = ExtensionSpecification>(
-  options: Omit<AppLoaderConstructorArgs<AppConfiguration, ExtensionSpecification>, 'loadedConfiguration'> & {
+  options: Omit<AppLoaderConstructorArgs<CurrentAppConfiguration, ExtensionSpecification>, 'loadedConfiguration'> & {
     directory: string
     userProvidedConfigName: string | undefined
     specifications: TModuleSpec[]
     remoteFlags?: Flag[]
   },
-): Promise<AppInterface<AppConfiguration, TModuleSpec>> {
+): Promise<AppInterface<CurrentAppConfiguration, TModuleSpec>> {
   const specifications = options.specifications
 
   const state = await getAppConfigurationState(options.directory, options.userProvidedConfigName)
   const loadedConfiguration = await loadAppConfigurationFromState(state, specifications, options.remoteFlags ?? [])
 
-  const loader = new AppLoader<AppConfiguration, TModuleSpec>({
+  const loader = new AppLoader<CurrentAppConfiguration, TModuleSpec>({
     mode: options.mode,
     loadedConfiguration,
   })
@@ -288,7 +288,7 @@ export type OpaqueAppLoadResult =
   | {
       state: 'loaded-app'
       app: AppInterface
-      configuration: AppConfiguration
+      configuration: CurrentAppConfiguration
     }
   | {
       state: 'loaded-template'
@@ -374,8 +374,8 @@ export async function reloadApp(app: AppLinkedInterface): Promise<AppLinkedInter
   return loader.loaded()
 }
 
-export async function loadAppUsingConfigurationState<TConfig extends AppConfigurationState>(
-  configState: TConfig,
+export async function loadAppUsingConfigurationState(
+  configState: AppConfigurationState,
   {
     specifications,
     remoteFlags,
@@ -385,7 +385,7 @@ export async function loadAppUsingConfigurationState<TConfig extends AppConfigur
     remoteFlags?: Flag[]
     mode: AppLoaderMode
   },
-): Promise<AppInterface<LoadedAppConfigFromConfigState<typeof configState>, RemoteAwareExtensionSpecification>> {
+): Promise<AppInterface<CurrentAppConfiguration, RemoteAwareExtensionSpecification>> {
   const loadedConfiguration = await loadAppConfigurationFromState(configState, specifications, remoteFlags ?? [])
 
   const loader = new AppLoader({
@@ -395,12 +395,7 @@ export async function loadAppUsingConfigurationState<TConfig extends AppConfigur
   return loader.loaded()
 }
 
-/**
- * Given basic information about an app's configuration state, what should the validated configuration type be?
- */
-type LoadedAppConfigFromConfigState<TConfigState> = TConfigState extends AppConfigurationStateLinked
-  ? CurrentAppConfiguration
-  : never
+type LoadedAppConfigFromConfigState = CurrentAppConfiguration
 
 export function getDotEnvFileName(configurationPath: string) {
   const configurationShorthand: string | undefined = getAppConfigurationShorthand(configurationPath)
@@ -416,7 +411,7 @@ export async function loadDotEnv(appDirectory: string, configurationPath: string
   return dotEnvFile
 }
 
-class AppLoader<TConfig extends AppConfiguration, TModuleSpec extends ExtensionSpecification> {
+class AppLoader<TConfig extends CurrentAppConfiguration, TModuleSpec extends ExtensionSpecification> {
   private readonly mode: AppLoaderMode
   private readonly errors: AppErrors = new AppErrors()
   private readonly specifications: TModuleSpec[]
@@ -445,8 +440,8 @@ class AppLoader<TConfig extends AppConfiguration, TModuleSpec extends ExtensionS
 
     // These don't need to be processed again if the app is being reloaded
     // name is required by BrandingSchema, so it must be present in the configuration
-    const configName = (configuration as CurrentAppConfiguration).name
-    const configHandle: string | undefined = (configuration as CurrentAppConfiguration).handle
+    const configName = configuration.name
+    const configHandle: string | undefined = configuration.handle
     const name: string = this.previousApp?.name ?? configHandle ?? configName ?? ''
     const nodeDependencies = this.previousApp?.nodeDependencies ?? (await getDependencies(packageJSONPath))
     const packageManager = this.previousApp?.packageManager ?? (await getPackageManager(directory))
@@ -836,7 +831,7 @@ class AppLoader<TConfig extends AppConfiguration, TModuleSpec extends ExtensionS
     return generateApplicationURLs(
       previousDevUrls.applicationUrl,
       webs.map(({configuration}) => configuration.auth_callback_path).find((path) => path),
-      (currentConfiguration as CurrentAppConfiguration).app_proxy,
+      currentConfiguration.app_proxy,
     )
   }
 }
@@ -884,7 +879,7 @@ type ConfigurationLoadResultMetadata = {
 )
 
 type ConfigurationLoaderResult<
-  TConfig extends AppConfiguration,
+  TConfig extends CurrentAppConfiguration,
   TModuleSpec extends ExtensionSpecification,
 > = AppConfigurationInterface<TConfig, TModuleSpec> & {
   configurationLoadResultMetadata: ConfigurationLoadResultMetadata
@@ -897,13 +892,11 @@ interface AppConfigurationStateBasics {
   configurationFileName: AppConfigurationFileName
 }
 
-export type AppConfigurationStateLinked = AppConfigurationStateBasics & {
+export type AppConfigurationState = AppConfigurationStateBasics & {
   basicConfiguration: BasicAppConfigurationWithoutModules
-  isTemplateForm: boolean
+  isLinked: boolean
 }
 
-type AppConfigurationState = AppConfigurationStateLinked
-
 /**
  * Get the app configuration state from the file system.
  *
@@ -942,8 +935,7 @@ export async function getAppConfigurationState(
 
   const parsedConfig = await parseConfigurationFile(AppSchema, configurationPath)
 
-  // Check if the config is in template form by verifying if client_id is empty
-  const isTemplateForm = parsedConfig.client_id === ''
+  const isLinked = parsedConfig.client_id !== ''
 
   return {
     appDirectory,
@@ -954,7 +946,7 @@ export async function getAppConfigurationState(
     },
     configSource,
     configurationFileName,
-    isTemplateForm,
+    isLinked,
   }
 }
 
@@ -963,28 +955,25 @@ export async function getAppConfigurationState(
  *
  * This is typically called after getting remote-aware extension specifications. The app configuration is validated acordingly.
  */
-async function loadAppConfigurationFromState<
-  TConfig extends AppConfigurationState,
-  TModuleSpec extends ExtensionSpecification,
->(
-  configState: TConfig,
+async function loadAppConfigurationFromState<TModuleSpec extends ExtensionSpecification>(
+  configState: AppConfigurationState,
   specifications: TModuleSpec[],
   remoteFlags: Flag[],
-): Promise<ConfigurationLoaderResult<LoadedAppConfigFromConfigState<TConfig>, TModuleSpec>> {
+): Promise<ConfigurationLoaderResult<LoadedAppConfigFromConfigState, TModuleSpec>> {
   const file: JsonMapType = {
     ...configState.basicConfiguration,
   } as JsonMapType
   delete file.path
   const appVersionedSchema = getAppVersionedSchema(specifications)
-  const schemaForConfigurationFile = appVersionedSchema as SchemaForConfig<LoadedAppConfigFromConfigState<TConfig>>
+  const schemaForConfigurationFile = appVersionedSchema as SchemaForConfig<LoadedAppConfigFromConfigState>
 
   const configuration = (await parseConfigurationFile(
     schemaForConfigurationFile,
     configState.configurationPath,
     abort,
     decodeToml,
     file,
-  )) as LoadedAppConfigFromConfigState<TConfig>
+  )) as LoadedAppConfigFromConfigState
   const allClientIdsByConfigName = await getAllLinkedConfigClientIds(configState.appDirectory, {
     [configState.configurationFileName]: configuration.client_id,
   })
@@ -994,7 +983,6 @@ async function loadAppConfigurationFromState<
     allClientIdsByConfigName,
   }
 
-  // enhance metadata based on the config type
   let gitTracked = false
   try {
     gitTracked = await checkIfGitTracked(configState.appDirectory, configState.configurationPath)
@@ -1009,8 +997,7 @@ async function loadAppConfigurationFromState<
     name: configState.configurationFileName,
     gitTracked,
     source: configState.configSource,
-    usesCliManagedUrls: (configuration as LoadedAppConfigFromConfigState<AppConfigurationStateLinked>).build
-      ?.automatically_update_urls_on_dev,
+    usesCliManagedUrls: configuration.build?.automatically_update_urls_on_dev,
   }
 
   return {

packages/app/src/cli/services/app-context.test.ts

@@ -158,7 +158,7 @@ client_id="test-api-key"`
           configurationPath: `${tmp}/shopify.app.toml`,
           configSource: 'cached',
           configurationFileName: 'shopify.app.toml',
-          isTemplateForm: false,
+          isLinked: true,
           basicConfiguration: {
             client_id: 'test-api-key',
             path: normalizePath(joinPath(tmp, 'shopify.app.toml')),

packages/app/src/cli/services/app-context.ts

@@ -72,10 +72,9 @@ export async function linkedAppContext({
   let configState = await getAppConfigurationState(directory, userProvidedConfigName)
   let remoteApp: OrganizationApp | undefined
 
-  // If forceRelink is true, force a link.
-  if (forceRelink) {
-    // If forceRelink is true, we don't want to use the cached config name and instead prompt the user for a new one.
-    const result = await link({directory, apiKey: clientId, configName: undefined})
+  if (!configState.isLinked || forceRelink) {
+    const configName = forceRelink ? undefined : configState.configurationFileName
+    const result = await link({directory, apiKey: clientId, configName})
     remoteApp = result.remoteApp
     configState = result.state
   }