@dizzlkheinz/ynab-mcpb 0.15.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dizzlkheinz/ynab-mcpb",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Model Context Protocol server for YNAB (You Need A Budget) integration",
   "main": "dist/index.js",
   "type": "module",

package/src/server/YNABMCPServer.ts

@@ -7,6 +7,7 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
   ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
   ListPromptsRequestSchema,
   ReadResourceRequestSchema,
   GetPromptRequestSchema,
@@ -226,6 +227,7 @@ export class YNABMCPServer {
     this.resourceManager = new ResourceManager({
       ynabAPI: this.ynabAPI,
       responseFormatter,
+      cacheManager,
     });
 
     this.promptManager = new PromptManager();
@@ -309,6 +311,11 @@ export class YNABMCPServer {
       return this.resourceManager.listResources();
     });
 
+    // Handle list resource templates requests
+    this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+      return this.resourceManager.listResourceTemplates();
+    });
+
     // Handle read resource requests
     this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
       const { uri } = request.params;

package/src/server/__tests__/resources.template.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ResourceManager } from '../resources.js';
+import type { CacheManager } from '../cacheManager.js';
+import type * as ynab from 'ynab';
+
+// Mock YNAB API
+const mockYnabAPI = {
+  budgets: {
+    getBudgets: vi.fn(),
+    getBudgetById: vi.fn(),
+  },
+  accounts: {
+    getAccounts: vi.fn(),
+    getAccountById: vi.fn(),
+  },
+  user: {
+    getUser: vi.fn(),
+  },
+} as unknown as ynab.API;
+
+// Mock Response Formatter
+const mockResponseFormatter = {
+  format: vi.fn((data) => JSON.stringify(data)),
+};
+
+const mockCacheManager = {
+  wrap: vi.fn(async (_key, { loader }) => loader()),
+} as unknown as CacheManager;
+
+describe('ResourceManager Templates', () => {
+  let resourceManager: ResourceManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resourceManager = new ResourceManager({
+      ynabAPI: mockYnabAPI,
+      responseFormatter: mockResponseFormatter,
+      cacheManager: mockCacheManager,
+    });
+  });
+
+  it('should list resource templates', () => {
+    const templates = resourceManager.listResourceTemplates();
+    expect(templates.resourceTemplates.length).toBeGreaterThan(0);
+    expect(templates.resourceTemplates).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          uriTemplate: 'ynab://budgets/{budget_id}',
+          name: 'Budget Details',
+        }),
+        expect.objectContaining({
+          uriTemplate: 'ynab://budgets/{budget_id}/accounts',
+          name: 'Budget Accounts',
+        }),
+      ]),
+    );
+  });
+
+  it('should match and handle budget details template', async () => {
+    const budgetId = 'test-budget-id';
+    const mockBudget = { id: budgetId, name: 'Test Budget' };
+
+    (mockYnabAPI.budgets.getBudgetById as any).mockResolvedValue({
+      data: { budget: mockBudget },
+    });
+
+    const uri = `ynab://budgets/${budgetId}`;
+    const result = await resourceManager.readResource(uri);
+
+    expect(mockYnabAPI.budgets.getBudgetById).toHaveBeenCalledWith(budgetId);
+    expect(result.contents).toHaveLength(1);
+    expect(result.contents[0].uri).toBe(uri);
+    expect(JSON.parse(result.contents[0].text)).toEqual(mockBudget);
+  });
+
+  it('should match and handle budget accounts template', async () => {
+    const budgetId = 'test-budget-id';
+    const mockAccounts = [{ id: 'acc1', name: 'Checking' }];
+
+    (mockYnabAPI.accounts.getAccounts as any).mockResolvedValue({
+      data: { accounts: mockAccounts },
+    });
+
+    const uri = `ynab://budgets/${budgetId}/accounts`;
+    const result = await resourceManager.readResource(uri);
+
+    expect(mockYnabAPI.accounts.getAccounts).toHaveBeenCalledWith(budgetId);
+    expect(result.contents).toHaveLength(1);
+    expect(JSON.parse(result.contents[0].text)).toEqual(mockAccounts);
+  });
+
+  it('should match and handle specific account template', async () => {
+    const budgetId = 'test-budget-id';
+    const accountId = 'test-account-id';
+    const mockAccount = { id: accountId, name: 'Savings' };
+
+    (mockYnabAPI.accounts.getAccountById as any).mockResolvedValue({
+      data: { account: mockAccount },
+    });
+
+    const uri = `ynab://budgets/${budgetId}/accounts/${accountId}`;
+    const result = await resourceManager.readResource(uri);
+
+    expect(mockYnabAPI.accounts.getAccountById).toHaveBeenCalledWith(budgetId, accountId);
+    expect(result.contents).toHaveLength(1);
+    expect(JSON.parse(result.contents[0].text)).toEqual(mockAccount);
+  });
+
+  it('should fallback to throwing error for unknown URIs', async () => {
+    const uri = 'ynab://unknown/resource';
+    await expect(resourceManager.readResource(uri)).rejects.toThrow(
+      'Unknown resource: ynab://unknown/resource',
+    );
+  });
+
+  it('should prefer static resources over templates when both match (though unlikely with current design)', async () => {
+    // Assuming 'ynab://budgets' is a static resource
+    const mockBudgetsList = [{ id: 'b1', name: 'B1' }];
+    (mockYnabAPI.budgets.getBudgets as any).mockResolvedValue({
+      data: { budgets: mockBudgetsList },
+    });
+
+    const uri = 'ynab://budgets';
+    const result = await resourceManager.readResource(uri);
+
+    // Should call getBudgets (static), not getBudgetById (template)
+    expect(mockYnabAPI.budgets.getBudgets).toHaveBeenCalled();
+    expect(mockYnabAPI.budgets.getBudgetById).not.toHaveBeenCalled();
+    expect(JSON.parse(result.contents[0].text)).toEqual({ budgets: expect.any(Array) });
+  });
+
+  // Error handling tests
+  describe('Error Handling', () => {
+    it('should handle API errors gracefully for template resources', async () => {
+      (mockYnabAPI.budgets.getBudgetById as any).mockRejectedValue(new Error('Budget not found'));
+
+      await expect(resourceManager.readResource('ynab://budgets/invalid-id')).rejects.toThrow(
+        'Failed to resolve template resource ynab://budgets/invalid-id: Failed to fetch budget invalid-id: Budget not found',
+      );
+    });
+
+    it('should handle API errors for account templates', async () => {
+      (mockYnabAPI.accounts.getAccountById as any).mockRejectedValue(
+        new Error('Account not found'),
+      );
+
+      await expect(
+        resourceManager.readResource('ynab://budgets/budget-id/accounts/invalid-account'),
+      ).rejects.toThrow(
+        'Failed to resolve template resource ynab://budgets/budget-id/accounts/invalid-account: Failed to fetch account invalid-account in budget budget-id: Account not found',
+      );
+    });
+
+    it('should reject URIs with backslash characters', async () => {
+      await expect(resourceManager.readResource('ynab://budgets/test\\bad')).rejects.toThrow(
+        'Invalid parameter value',
+      );
+    });
+
+    it('should reject URIs with double-dot sequences in parameters', async () => {
+      await expect(resourceManager.readResource('ynab://budgets/test../accounts')).rejects.toThrow(
+        'Invalid parameter value',
+      );
+    });
+  });
+
+  // Template validation tests
+  describe('Template Validation', () => {
+    it('should validate template format when registering', async () => {
+      // This test verifies that malformed templates are caught
+      const maliciousTemplate = {
+        uriTemplate: 'ynab://budgets/{budget_id}$(malicious)',
+        name: 'Malicious Template',
+        description: 'Should be rejected',
+        mimeType: 'application/json',
+        handler: async () => [],
+      };
+
+      expect(() => resourceManager.registerTemplate(maliciousTemplate)).toThrow(
+        'Invalid template format: contains unsafe characters',
+      );
+    });
+
+    it('should reject template registration with invalid parameter names', () => {
+      const invalidParamTemplate = {
+        uriTemplate: 'ynab://budgets/{Budget-Id}',
+        name: 'Invalid Param Template',
+        description: 'Should be rejected due to invalid param casing',
+        mimeType: 'application/json',
+        handler: async () => [],
+      };
+
+      expect(() => resourceManager.registerTemplate(invalidParamTemplate)).toThrow(
+        "Invalid template parameter name 'Budget-Id'",
+      );
+    });
+  });
+});

package/src/server/__tests__/resources.test.ts

@@ -7,6 +7,7 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { ResourceManager, type ResourceDependencies } from '../resources.js';
 import type * as ynab from 'ynab';
+import type { CacheManager } from '../cacheManager.js';
 
 // Mock YNAB API
 const mockYnabAPI = {
@@ -23,6 +24,10 @@ const mockResponseFormatter = {
   format: vi.fn((data) => JSON.stringify(data)),
 };
 
+const mockCacheManager = {
+  wrap: vi.fn(async (_key, { loader }) => loader()),
+} as unknown as CacheManager;
+
 describe('resources module', () => {
   let resourceManager: ResourceManager;
   let dependencies: ResourceDependencies;
@@ -33,6 +38,7 @@ describe('resources module', () => {
     dependencies = {
       ynabAPI: mockYnabAPI,
       responseFormatter: mockResponseFormatter,
+      cacheManager: mockCacheManager,
     };
 
     resourceManager = new ResourceManager(dependencies);
@@ -158,7 +164,7 @@ describe('resources module', () => {
           mockYnabAPI.budgets.getBudgets = vi.fn().mockRejectedValue(error);
 
           await expect(resourceManager.readResource('ynab://budgets')).rejects.toThrow(
-            'Failed to fetch budgets: Error: API Error',
+            'Failed to fetch budgets: API Error',
           );
         });
       });
@@ -198,7 +204,7 @@ describe('resources module', () => {
           mockYnabAPI.user.getUser = vi.fn().mockRejectedValue(error);
 
           await expect(resourceManager.readResource('ynab://user')).rejects.toThrow(
-            'Failed to fetch user info: Error: User API Error',
+            'Failed to fetch user info: User API Error',
           );
         });
       });
@@ -238,6 +244,7 @@ describe('resources module', () => {
         const customDependencies = {
           ynabAPI: customYnabAPI,
           responseFormatter: mockResponseFormatter,
+          cacheManager: mockCacheManager,
         };
 
         const customResourceManager = new ResourceManager(customDependencies);
@@ -255,6 +262,7 @@ describe('resources module', () => {
         const customDependencies = {
           ynabAPI: mockYnabAPI,
           responseFormatter: customFormatter,
+          cacheManager: mockCacheManager,
         };
 
         mockYnabAPI.budgets.getBudgets = vi.fn().mockResolvedValue({