Add tests for devSessionWatchConfig and watchedFiles behavior

Co-authored-by: Claude Code <claude-code@anthropic.com>

Author: isaacroldan

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

@@ -2070,12 +2070,9 @@ describe('load', () => {
     const app = await loadTestingApp()
 
     // Then
-    expect(app.allExtensions).toHaveLength(7)
+    expect(app.allExtensions).toHaveLength(6)
     const extensionsConfig = app.allExtensions.map((ext) => ext.configuration)
     expect(extensionsConfig).toEqual([
-      expect.objectContaining({
-        name: 'for-testing',
-      }),
       expect.objectContaining({
         name: 'for-testing',
       }),
@@ -2131,12 +2128,9 @@ describe('load', () => {
     const app = await loadTestingApp({remoteFlags: []})
 
     // Then
-    expect(app.allExtensions).toHaveLength(8)
+    expect(app.allExtensions).toHaveLength(7)
     const extensionsConfig = app.allExtensions.map((ext) => ext.configuration)
     expect(extensionsConfig).toEqual([
-      {
-        name: 'for-testing-webhooks',
-      },
       {
         name: 'for-testing-webhooks',
       },

packages/app/src/cli/models/extensions/extension-instance.test.ts

@@ -570,6 +570,36 @@ describe('draftMessages', async () => {
   })
 })
 
+describe('devSessionWatchConfig', () => {
+  test('returns undefined for extension experience (watch everything)', async () => {
+    const extensionInstance = await testUIExtension({type: 'ui_extension'})
+    expect(extensionInstance.devSessionWatchConfig).toBeUndefined()
+  })
+
+  test('returns empty paths for configuration experience (watch nothing)', async () => {
+    const extensionInstance = await testAppConfigExtensions()
+    expect(extensionInstance.devSessionWatchConfig).toEqual({paths: []})
+  })
+
+  test('delegates to specification devSessionWatchConfig when defined', async () => {
+    const config = functionConfiguration()
+    config.build = {
+      watch: 'src/**/*.rs',
+      wasm_opt: true,
+    }
+    const extensionInstance = await testFunctionExtension({config, dir: '/tmp/my-function'})
+    const watchConfig = extensionInstance.devSessionWatchConfig
+    expect(watchConfig).toBeDefined()
+    expect(watchConfig!.paths).toContain(joinPath('/tmp/my-function', 'src/**/*.rs'))
+  })
+
+  test('returns undefined for function extension without build.watch', async () => {
+    const config = functionConfiguration()
+    const extensionInstance = await testFunctionExtension({config})
+    expect(extensionInstance.devSessionWatchConfig).toBeUndefined()
+  })
+})
+
 describe('watchedFiles', async () => {
   test('returns files based on devSessionWatchPaths when defined', async () => {
     await inTemporaryDirectory(async (tmpDir) => {
@@ -607,6 +637,58 @@ describe('watchedFiles', async () => {
     })
   })
 
+  test('respects custom ignore paths from devSessionWatchConfig', async () => {
+    await inTemporaryDirectory(async (tmpDir) => {
+      // Given - create an extension with a spec that defines custom ignore paths
+      const config = functionConfiguration()
+      config.build = {
+        watch: '**/*',
+        wasm_opt: true,
+      }
+      const extensionInstance = await testFunctionExtension({
+        config,
+        dir: tmpDir,
+      })
+
+      // Override devSessionWatchConfig to include ignore paths
+      vi.spyOn(extensionInstance, 'devSessionWatchConfig', 'get').mockReturnValue({
+        paths: [joinPath(tmpDir, '**/*')],
+        ignore: ['**/ignored-dir/**'],
+      })
+
+      // Create files - one in a normal dir, one in the ignored dir
+      const srcDir = joinPath(tmpDir, 'src')
+      const ignoredDir = joinPath(tmpDir, 'ignored-dir')
+      await mkdir(srcDir)
+      await mkdir(ignoredDir)
+      await writeFile(joinPath(srcDir, 'index.js'), 'code')
+      await writeFile(joinPath(ignoredDir, 'should-be-ignored.js'), 'ignored')
+
+      // When
+      const watchedFiles = extensionInstance.watchedFiles()
+
+      // Then
+      expect(watchedFiles).toContain(joinPath(srcDir, 'index.js'))
+      expect(watchedFiles).not.toContain(joinPath(ignoredDir, 'should-be-ignored.js'))
+    })
+  })
+
+  test('returns empty watched files for configuration extensions', async () => {
+    await inTemporaryDirectory(async (tmpDir) => {
+      // Given
+      const extensionInstance = await testAppConfigExtensions(false, tmpDir)
+
+      // Create files that should not be watched
+      await writeFile(joinPath(tmpDir, 'some-file.ts'), 'code')
+
+      // When
+      const watchedFiles = extensionInstance.watchedFiles()
+
+      // Then - configuration extensions default to empty paths, so no files watched
+      expect(watchedFiles).toHaveLength(0)
+    })
+  })
+
   test('returns all files when devSessionWatchPaths is undefined', async () => {
     await inTemporaryDirectory(async (tmpDir) => {
       // Given

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

@@ -148,7 +148,7 @@ export interface ExtensionSpecification<TConfiguration extends BaseConfigType =
 export interface DevSessionWatchConfig {
   /** Absolute paths or globs to watch */
   paths: string[]
-  /** Additional glob patterns to ignore (on top of the default ignore list) */
+  /** Glob patterns to ignore. When provided, replaces the default ignore list entirely. */
   ignore?: string[]
 }
 

packages/app/src/cli/models/extensions/specifications/admin.ts

@@ -1,21 +1,23 @@
 import {createExtensionSpecification} from '../specification.js'
-import {BaseSchemaWithoutHandle} from '../schemas.js'
+import {BaseConfigType, ZodSchemaType} from '../schemas.js'
 import {zod} from '@shopify/cli-kit/node/schema'
 import {joinPath} from '@shopify/cli-kit/node/path'
 
-const AdminSchema = BaseSchemaWithoutHandle.extend({
+const AdminSchema = zod.object({
   admin: zod
     .object({
       static_root: zod.string().optional(),
     })
     .optional(),
 })
 
-const adminSpecificationSpec = createExtensionSpecification({
+type AdminConfigType = zod.infer<typeof AdminSchema> & BaseConfigType
+
+const adminSpecificationSpec = createExtensionSpecification<AdminConfigType>({
   identifier: 'admin',
   uidStrategy: 'single',
   experience: 'configuration',
-  schema: AdminSchema,
+  schema: AdminSchema as ZodSchemaType<AdminConfigType>,
   deployConfig: async (config, _) => {
     return {admin: config.admin}
   },

packages/app/src/cli/services/dev/app-events/file-watcher.test.ts

@@ -274,6 +274,7 @@ describe('file-watcher events', () => {
 
       // Then
       expect(watchSpy).toHaveBeenCalledWith([joinPath(dir, '/shopify.app.toml'), joinPath(dir, '/extensions')], {
+        ignored: ['**/node_modules/**', '**/.git/**'],
         ignoreInitial: true,
         persistent: true,
       })

packages/app/src/cli/services/dev/app-events/file-watcher.ts

@@ -118,6 +118,7 @@ export class FileWatcher {
     // Create new watcher
     const {default: chokidar} = await import('chokidar')
     this.watcher = chokidar.watch(watchPaths, {
+      ignored: ['**/node_modules/**', '**/.git/**'],
       persistent: true,
       ignoreInitial: true,
     })