fix: re-implement definition override and add tests (#30)

Author: HugoRCD

packages/nuxt-mcp-toolkit/src/runtime/server/mcp/loaders/utils.ts

@@ -78,6 +78,19 @@ export function createFilePatterns(paths: string[], extensions = ['ts', 'js', 'm
   )
 }
 
+/**
+ * Create file patterns for a specific layer
+ */
+export function createLayerFilePatterns(
+  layerServer: string,
+  paths: string[],
+  extensions = ['ts', 'js', 'mts', 'mjs'],
+): string[] {
+  return paths.flatMap(pathPattern =>
+    extensions.map(ext => resolvePath(layerServer, `${pathPattern}/*.${ext}`)),
+  )
+}
+
 export function createExcludePatterns(paths: string[], subdirs: string[]): string[] {
   const layerDirectories = getLayerDirectories()
   return layerDirectories.flatMap(layer =>
@@ -134,24 +147,35 @@ export async function loadDefinitionFiles(
     return { count: 0, files: [], overriddenCount: 0 }
   }
 
-  const patterns = createFilePatterns(paths)
-  const files = await glob(patterns, {
-    absolute: true,
-    onlyFiles: true,
-    ignore: options.excludePatterns,
-  })
+  // Get layer directories and reverse the order so that:
+  // - Extended layers are processed first
+  // - The main app (first in getLayerDirectories) is processed last
+  // This allows the app to override definitions from extended layers
+  const layerDirectories = getLayerDirectories()
+  const reversedLayers = [...layerDirectories].reverse()
 
   const definitionsMap = new Map<string, string>()
-  const filteredFiles = options.filter ? files.filter(options.filter) : files
   let overriddenCount = 0
 
-  for (const filePath of filteredFiles) {
-    const filename = filePath.split('/').pop()!
-    const identifier = toIdentifier(filename)
-    if (definitionsMap.has(identifier)) {
-      overriddenCount++
+  // Process each layer separately to ensure correct override order
+  for (const layer of reversedLayers) {
+    const layerPatterns = createLayerFilePatterns(layer.server, paths)
+    const layerFiles = await glob(layerPatterns, {
+      absolute: true,
+      onlyFiles: true,
+      ignore: options.excludePatterns,
+    })
+
+    const filteredFiles = options.filter ? layerFiles.filter(options.filter) : layerFiles
+
+    for (const filePath of filteredFiles) {
+      const filename = filePath.split('/').pop()!
+      const identifier = toIdentifier(filename)
+      if (definitionsMap.has(identifier)) {
+        overriddenCount++
+      }
+      definitionsMap.set(identifier, filePath)
     }
-    definitionsMap.set(identifier, filePath)
   }
 
   const total = definitionsMap.size

packages/nuxt-mcp-toolkit/test/fixtures/override/app.vue

@@ -0,0 +1,3 @@
+<template>
+  <div>override</div>
+</template>

packages/nuxt-mcp-toolkit/test/fixtures/override/layers/override-layer/nuxt.config.ts

@@ -0,0 +1 @@
+export default defineNuxtConfig({})

packages/nuxt-mcp-toolkit/test/fixtures/override/layers/override-layer/server/mcp/tools/override-tool.ts

@@ -0,0 +1,21 @@
+import { defineMcpTool } from '../../../../../../../../src/runtime/server/types'
+import { z } from 'zod'
+
+export default defineMcpTool({
+  name: 'override_tool',
+  title: 'Overridden Tool',
+  description: 'This tool overrides the base tool',
+  inputSchema: {
+    input: z.string().describe('Test input string'),
+  },
+  handler: async ({ input }) => {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Overridden result: ${input}`,
+        },
+      ],
+    }
+  },
+})

packages/nuxt-mcp-toolkit/test/fixtures/override/nuxt.config.ts

@@ -0,0 +1,8 @@
+import MyModule from '../../../src/module'
+
+export default defineNuxtConfig({
+  extends: ['./layers/override-layer'],
+  modules: [
+    MyModule,
+  ],
+})

packages/nuxt-mcp-toolkit/test/fixtures/override/package.json

@@ -0,0 +1,5 @@
+{
+  "private": true,
+  "name": "override",
+  "type": "module"
+}

packages/nuxt-mcp-toolkit/test/fixtures/override/server/mcp/tools/override-tool.ts

@@ -0,0 +1,21 @@
+import { defineMcpTool } from '../../../../../../src/runtime/server/types'
+import { z } from 'zod'
+
+export default defineMcpTool({
+  name: 'override_tool',
+  title: 'Override Tool',
+  description: 'A tool that will be overridden by the layer',
+  inputSchema: {
+    input: z.string().describe('Test input string'),
+  },
+  handler: async ({ input }) => {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Base result: ${input}`,
+        },
+      ],
+    }
+  },
+})

packages/nuxt-mcp-toolkit/test/override.test.ts

@@ -0,0 +1,73 @@
+import { fileURLToPath } from 'node:url'
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { setup, url } from '@nuxt/test-utils/e2e'
+import { setupMcpClient, cleanupMcpTests, getMcpClient } from './helpers/mcp-setup.js'
+
+/**
+ * Test for MCP definition override behavior
+ *
+ * When multiple files with the same name exist across different layers,
+ * only one should be loaded (no duplicates).
+ *
+ * Expected behavior: The app's definition overrides the layer's definition
+ * because the app is processed last and has priority over extended layers.
+ */
+describe('Override', async () => {
+  await setup({
+    rootDir: fileURLToPath(new URL('./fixtures/override', import.meta.url)),
+  })
+
+  beforeAll(async () => {
+    const baseUrl = url('/')
+    const baseUrlObj = new URL(baseUrl)
+    const origin = `${baseUrlObj.protocol}//${baseUrlObj.host}`
+    const mcpUrl = new URL('/mcp', origin)
+    await setupMcpClient(mcpUrl)
+  })
+
+  afterAll(async () => {
+    await cleanupMcpTests()
+  })
+
+  it('should have only one override_tool (not duplicated)', async () => {
+    const client = getMcpClient()
+    if (!client) {
+      return
+    }
+
+    const tools = await client.listTools()
+    const overrideTools = tools.tools.filter(tool => tool.name === 'override_tool')
+
+    expect(overrideTools.length, 'There should be exactly one override_tool').toBe(1)
+  })
+
+  it('should use the app tool that overrides the layer tool (app has priority)', async () => {
+    const client = getMcpClient()
+    if (!client) {
+      return
+    }
+
+    const inputValue = 'test input'
+
+    const result = await client.callTool({
+      name: 'override_tool',
+      arguments: {
+        input: inputValue,
+      },
+    })
+
+    expect(result, 'Tool call should return a result').toBeDefined()
+    expect(result.content, 'Result content should be an array').toBeInstanceOf(Array)
+    const content = result.content as Array<{ type: string, text?: string }>
+
+    const textContent = content.find(c => c.type === 'text')
+    expect(textContent, 'Result should contain text content').toBeDefined()
+
+    // The app's tool overrides the layer's tool (app is processed last)
+    // So we expect "Base result" (from the app) NOT "Overridden result" (from the layer)
+    expect(
+      textContent?.text,
+      `Expected the app tool to override the layer tool. Got: ${textContent?.text}`,
+    ).toContain('Base result')
+  })
+})