@dizzlkheinz/ynab-mcpb 0.18.4 → 0.19.0

package/src/tools/__tests__/exportTransactions.test.ts

@@ -1,213 +1,218 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as ynab from 'ynab';
-import { handleExportTransactions, ExportTransactionsSchema } from '../exportTransactions.js';
-import { writeFileSync } from 'fs';
+import { writeFileSync } from "node:fs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type * as ynab from "ynab";
+import {
+	ExportTransactionsSchema,
+	handleExportTransactions,
+} from "../exportTransactions.js";
 
 // Mock filesystem functions
-vi.mock('fs', () => ({
-  writeFileSync: vi.fn(),
-  mkdirSync: vi.fn(),
+vi.mock("fs", () => ({
+	writeFileSync: vi.fn(),
+	mkdirSync: vi.fn(),
 }));
 
-vi.mock('path', async () => {
-  const actual = await vi.importActual('path');
-  return actual;
+vi.mock("path", async () => {
+	const actual = await vi.importActual("path");
+	return actual;
 });
 
-vi.mock('os', () => ({
-  homedir: vi.fn(() => '/home/user'),
+vi.mock("os", () => ({
+	homedir: vi.fn(() => "/home/user"),
 }));
 
 // Mock the YNAB API
 const mockYnabAPI = {
-  transactions: {
-    getTransactions: vi.fn(),
-    getTransactionsByAccount: vi.fn(),
-    getTransactionsByCategory: vi.fn(),
-  },
+	transactions: {
+		getTransactions: vi.fn(),
+		getTransactionsByAccount: vi.fn(),
+		getTransactionsByCategory: vi.fn(),
+	},
 } as unknown as ynab.API;
 
-describe('exportTransactions', () => {
-  const mockTransactions = [
-    {
-      id: 'txn-1',
-      date: '2024-01-01',
-      amount: 1000,
-      payee_name: 'Test Payee 1',
-      cleared: 'cleared',
-      memo: 'Test memo 1',
-      approved: true,
-      flag_color: null,
-      account_id: 'acc-1',
-      payee_id: 'pay-1',
-      category_id: 'cat-1',
-      transfer_account_id: null,
-      transfer_transaction_id: null,
-      matched_transaction_id: null,
-      import_id: null,
-      deleted: false,
-      account_name: 'Test Account',
-      category_name: 'Test Category',
-    },
-    {
-      id: 'txn-2',
-      date: '2024-01-02',
-      amount: -2000,
-      payee_name: 'Test Payee 2',
-      cleared: 'uncleared',
-      memo: 'Test memo 2',
-      approved: false,
-      flag_color: 'red',
-      account_id: 'acc-2',
-      payee_id: 'pay-2',
-      category_id: 'cat-2',
-      transfer_account_id: null,
-      transfer_transaction_id: null,
-      matched_transaction_id: null,
-      import_id: null,
-      deleted: false,
-      account_name: 'Test Account 2',
-      category_name: 'Test Category 2',
-    },
-  ];
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Set up successful API response
-    (mockYnabAPI.transactions.getTransactions as any).mockResolvedValue({
-      data: { transactions: mockTransactions },
-    });
-  });
-
-  afterEach(() => {
-    // Clean up test files
-    vi.restoreAllMocks();
-  });
-
-  describe('ExportTransactionsSchema', () => {
-    it('should default minimal to true when not provided', () => {
-      const params = { budget_id: 'test-budget' };
-      const parsed = ExportTransactionsSchema.parse(params);
-      expect(parsed.minimal).toBe(true);
-    });
-
-    it('should preserve minimal: false when explicitly set', () => {
-      const params = { budget_id: 'test-budget', minimal: false };
-      const parsed = ExportTransactionsSchema.parse(params);
-      expect(parsed.minimal).toBe(false);
-    });
-
-    it('should preserve minimal: true when explicitly set', () => {
-      const params = { budget_id: 'test-budget', minimal: true };
-      const parsed = ExportTransactionsSchema.parse(params);
-      expect(parsed.minimal).toBe(true);
-    });
-  });
-
-  describe('handleExportTransactions', () => {
-    it('should export minimal fields by default', async () => {
-      const params = { budget_id: 'test-budget' };
-
-      const result = await handleExportTransactions(mockYnabAPI, params);
-
-      expect(writeFileSync).toHaveBeenCalledTimes(1);
-      const [, fileContent] = (writeFileSync as any).mock.calls[0];
-      const exportData = JSON.parse(fileContent);
-
-      // Check that export_info shows minimal mode
-      expect(exportData.export_info.minimal).toBe(true);
-
-      // Check that transactions only have minimal fields
-      expect(exportData.transactions).toHaveLength(2);
-
-      const firstTransaction = exportData.transactions[0];
-      expect(Object.keys(firstTransaction)).toEqual([
-        'id',
-        'date',
-        'amount',
-        'payee_name',
-        'cleared',
-      ]);
-
-      expect(firstTransaction).toEqual({
-        id: 'txn-1',
-        date: '2024-01-01',
-        amount: 1000,
-        payee_name: 'Test Payee 1',
-        cleared: 'cleared',
-      });
-
-      // Verify response message indicates minimal export
-      const responseText = result.content[0].text;
-      expect(responseText).toContain('(minimal fields)');
-      const responseJson = JSON.parse(responseText);
-      expect(responseJson.export_mode).toBe('minimal');
-      expect(responseJson.minimal_fields).toBe('id, date, amount, payee_name, cleared');
-    });
-
-    it('should export all fields when minimal is false', async () => {
-      const params = { budget_id: 'test-budget', minimal: false };
-
-      const result = await handleExportTransactions(mockYnabAPI, params);
-
-      expect(writeFileSync).toHaveBeenCalledTimes(1);
-      const [, fileContent] = (writeFileSync as any).mock.calls[0];
-      const exportData = JSON.parse(fileContent);
-
-      // Check that export_info shows full mode
-      expect(exportData.export_info.minimal).toBe(false);
-
-      // Check that transactions have all fields
-      expect(exportData.transactions).toHaveLength(2);
-
-      const firstTransaction = exportData.transactions[0];
-      expect(Object.keys(firstTransaction)).toEqual([
-        'id',
-        'date',
-        'amount',
-        'memo',
-        'cleared',
-        'approved',
-        'flag_color',
-        'account_id',
-        'payee_id',
-        'category_id',
-        'transfer_account_id',
-        'transfer_transaction_id',
-        'matched_transaction_id',
-        'import_id',
-        'deleted',
-        'account_name',
-        'payee_name',
-        'category_name',
-      ]);
-
-      // Verify response message indicates full export
-      const responseText = result.content[0].text;
-      expect(responseText).toContain('(full fields)');
-      const responseJson = JSON.parse(responseText);
-      expect(responseJson.export_mode).toBe('full');
-      expect(responseJson.minimal_fields).toBeNull();
-    });
-
-    it('should include "minimal" in filename by default', async () => {
-      const params = { budget_id: 'test-budget' };
-
-      await handleExportTransactions(mockYnabAPI, params);
-
-      expect(writeFileSync).toHaveBeenCalledTimes(1);
-      const [filePath] = (writeFileSync as any).mock.calls[0];
-      expect(filePath).toContain('minimal');
-    });
-
-    it('should not include "minimal" in filename when minimal is false', async () => {
-      const params = { budget_id: 'test-budget', minimal: false };
-
-      await handleExportTransactions(mockYnabAPI, params);
-
-      expect(writeFileSync).toHaveBeenCalledTimes(1);
-      const [filePath] = (writeFileSync as any).mock.calls[0];
-      expect(filePath).not.toContain('minimal');
-    });
-  });
+describe("exportTransactions", () => {
+	const mockTransactions = [
+		{
+			id: "txn-1",
+			date: "2024-01-01",
+			amount: 1000,
+			payee_name: "Test Payee 1",
+			cleared: "cleared",
+			memo: "Test memo 1",
+			approved: true,
+			flag_color: null,
+			account_id: "acc-1",
+			payee_id: "pay-1",
+			category_id: "cat-1",
+			transfer_account_id: null,
+			transfer_transaction_id: null,
+			matched_transaction_id: null,
+			import_id: null,
+			deleted: false,
+			account_name: "Test Account",
+			category_name: "Test Category",
+		},
+		{
+			id: "txn-2",
+			date: "2024-01-02",
+			amount: -2000,
+			payee_name: "Test Payee 2",
+			cleared: "uncleared",
+			memo: "Test memo 2",
+			approved: false,
+			flag_color: "red",
+			account_id: "acc-2",
+			payee_id: "pay-2",
+			category_id: "cat-2",
+			transfer_account_id: null,
+			transfer_transaction_id: null,
+			matched_transaction_id: null,
+			import_id: null,
+			deleted: false,
+			account_name: "Test Account 2",
+			category_name: "Test Category 2",
+		},
+	];
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		// Set up successful API response
+		(mockYnabAPI.transactions.getTransactions as any).mockResolvedValue({
+			data: { transactions: mockTransactions },
+		});
+	});
+
+	afterEach(() => {
+		// Clean up test files
+		vi.restoreAllMocks();
+	});
+
+	describe("ExportTransactionsSchema", () => {
+		it("should default minimal to true when not provided", () => {
+			const params = { budget_id: "test-budget" };
+			const parsed = ExportTransactionsSchema.parse(params);
+			expect(parsed.minimal).toBe(true);
+		});
+
+		it("should preserve minimal: false when explicitly set", () => {
+			const params = { budget_id: "test-budget", minimal: false };
+			const parsed = ExportTransactionsSchema.parse(params);
+			expect(parsed.minimal).toBe(false);
+		});
+
+		it("should preserve minimal: true when explicitly set", () => {
+			const params = { budget_id: "test-budget", minimal: true };
+			const parsed = ExportTransactionsSchema.parse(params);
+			expect(parsed.minimal).toBe(true);
+		});
+	});
+
+	describe("handleExportTransactions", () => {
+		it("should export minimal fields by default", async () => {
+			const params = { budget_id: "test-budget" };
+
+			const result = await handleExportTransactions(mockYnabAPI, params);
+
+			expect(writeFileSync).toHaveBeenCalledTimes(1);
+			const [, fileContent] = (writeFileSync as any).mock.calls[0];
+			const exportData = JSON.parse(fileContent);
+
+			// Check that export_info shows minimal mode
+			expect(exportData.export_info.minimal).toBe(true);
+
+			// Check that transactions only have minimal fields
+			expect(exportData.transactions).toHaveLength(2);
+
+			const firstTransaction = exportData.transactions[0];
+			expect(Object.keys(firstTransaction)).toEqual([
+				"id",
+				"date",
+				"amount",
+				"payee_name",
+				"cleared",
+			]);
+
+			expect(firstTransaction).toEqual({
+				id: "txn-1",
+				date: "2024-01-01",
+				amount: 1000,
+				payee_name: "Test Payee 1",
+				cleared: "cleared",
+			});
+
+			// Verify response message indicates minimal export
+			const responseText = result.content[0].text;
+			expect(responseText).toContain("(minimal fields)");
+			const responseJson = JSON.parse(responseText);
+			expect(responseJson.export_mode).toBe("minimal");
+			expect(responseJson.minimal_fields).toBe(
+				"id, date, amount, payee_name, cleared",
+			);
+		});
+
+		it("should export all fields when minimal is false", async () => {
+			const params = { budget_id: "test-budget", minimal: false };
+
+			const result = await handleExportTransactions(mockYnabAPI, params);
+
+			expect(writeFileSync).toHaveBeenCalledTimes(1);
+			const [, fileContent] = (writeFileSync as any).mock.calls[0];
+			const exportData = JSON.parse(fileContent);
+
+			// Check that export_info shows full mode
+			expect(exportData.export_info.minimal).toBe(false);
+
+			// Check that transactions have all fields
+			expect(exportData.transactions).toHaveLength(2);
+
+			const firstTransaction = exportData.transactions[0];
+			expect(Object.keys(firstTransaction)).toEqual([
+				"id",
+				"date",
+				"amount",
+				"memo",
+				"cleared",
+				"approved",
+				"flag_color",
+				"account_id",
+				"payee_id",
+				"category_id",
+				"transfer_account_id",
+				"transfer_transaction_id",
+				"matched_transaction_id",
+				"import_id",
+				"deleted",
+				"account_name",
+				"payee_name",
+				"category_name",
+			]);
+
+			// Verify response message indicates full export
+			const responseText = result.content[0].text;
+			expect(responseText).toContain("(full fields)");
+			const responseJson = JSON.parse(responseText);
+			expect(responseJson.export_mode).toBe("full");
+			expect(responseJson.minimal_fields).toBeNull();
+		});
+
+		it('should include "minimal" in filename by default', async () => {
+			const params = { budget_id: "test-budget" };
+
+			await handleExportTransactions(mockYnabAPI, params);
+
+			expect(writeFileSync).toHaveBeenCalledTimes(1);
+			const [filePath] = (writeFileSync as any).mock.calls[0];
+			expect(filePath).toContain("minimal");
+		});
+
+		it('should not include "minimal" in filename when minimal is false', async () => {
+			const params = { budget_id: "test-budget", minimal: false };
+
+			await handleExportTransactions(mockYnabAPI, params);
+
+			expect(writeFileSync).toHaveBeenCalledTimes(1);
+			const [filePath] = (writeFileSync as any).mock.calls[0];
+			expect(filePath).not.toContain("minimal");
+		});
+	});
 });

package/src/tools/__tests__/monthTools.delta.integration.test.ts

@@ -1,80 +1,80 @@
-import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
-import * as ynab from 'ynab';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { handleListMonths } from '../monthTools.js';
-import { CacheManager } from '../../server/cacheManager.js';
-import { ServerKnowledgeStore } from '../../server/serverKnowledgeStore.js';
-import { DeltaCache } from '../../server/deltaCache.js';
-import { DeltaFetcher } from '../deltaFetcher.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import * as ynab from "ynab";
+import { CacheManager } from "../../server/cacheManager.js";
+import { DeltaCache } from "../../server/deltaCache.js";
+import { ServerKnowledgeStore } from "../../server/serverKnowledgeStore.js";
+import { DeltaFetcher } from "../deltaFetcher.js";
+import { handleListMonths } from "../monthTools.js";
 
-const shouldSkip = ['true', '1', 'yes', 'y', 'on'].includes(
-  (process.env['SKIP_E2E_TESTS'] || '').toLowerCase().trim(),
+const shouldSkip = ["true", "1", "yes", "y", "on"].includes(
+	(process.env.SKIP_E2E_TESTS || "").toLowerCase().trim(),
 );
-const hasToken = !!process.env['YNAB_ACCESS_TOKEN'];
+const hasToken = !!process.env.YNAB_ACCESS_TOKEN;
 const skipTests = shouldSkip || !hasToken;
 const describeIntegration = skipTests ? describe.skip : describe;
 
-describeIntegration('Delta-backed month tool handler', () => {
-  let ynabAPI: ynab.API;
-  let testBudgetId: string;
-  let deltaFetcher: DeltaFetcher;
-  let previousNodeEnv: string | undefined;
+describeIntegration("Delta-backed month tool handler", () => {
+	let ynabAPI: ynab.API;
+	let testBudgetId: string;
+	let deltaFetcher: DeltaFetcher;
+	let previousNodeEnv: string | undefined;
 
-  beforeAll(async () => {
-    const accessToken = process.env['YNAB_ACCESS_TOKEN']!;
-    ynabAPI = new ynab.API(accessToken);
-    const budgetsResponse = await ynabAPI.budgets.getBudgets();
-    const budget = budgetsResponse.data.budgets[0];
-    if (!budget) {
-      throw new Error('No budgets available for delta integration tests.');
-    }
-    testBudgetId = budget.id;
-  });
+	beforeAll(async () => {
+		const accessToken = process.env.YNAB_ACCESS_TOKEN!;
+		ynabAPI = new ynab.API(accessToken);
+		const budgetsResponse = await ynabAPI.budgets.getBudgets();
+		const budget = budgetsResponse.data.budgets[0];
+		if (!budget) {
+			throw new Error("No budgets available for delta integration tests.");
+		}
+		testBudgetId = budget.id;
+	});
 
-  beforeEach(() => {
-    previousNodeEnv = process.env['NODE_ENV'];
-    process.env['NODE_ENV'] = 'integration';
-    const cacheManager = new CacheManager();
-    const knowledgeStore = new ServerKnowledgeStore();
-    const deltaCache = new DeltaCache(cacheManager, knowledgeStore);
-    deltaFetcher = new DeltaFetcher(ynabAPI, deltaCache);
-    process.env['YNAB_MCP_ENABLE_DELTA'] = 'true';
-  });
+	beforeEach(() => {
+		previousNodeEnv = process.env.NODE_ENV;
+		process.env.NODE_ENV = "integration";
+		const cacheManager = new CacheManager();
+		const knowledgeStore = new ServerKnowledgeStore();
+		const deltaCache = new DeltaCache(cacheManager, knowledgeStore);
+		deltaFetcher = new DeltaFetcher(ynabAPI, deltaCache);
+		process.env.YNAB_MCP_ENABLE_DELTA = "true";
+	});
 
-  afterEach(() => {
-    delete process.env['YNAB_MCP_ENABLE_DELTA'];
-    if (previousNodeEnv === undefined) {
-      delete process.env['NODE_ENV'];
-    } else {
-      process.env['NODE_ENV'] = previousNodeEnv;
-    }
-    previousNodeEnv = undefined;
-  });
+	afterEach(() => {
+		process.env.YNAB_MCP_ENABLE_DELTA = undefined;
+		if (previousNodeEnv === undefined) {
+			process.env.NODE_ENV = undefined;
+		} else {
+			process.env.NODE_ENV = previousNodeEnv;
+		}
+		previousNodeEnv = undefined;
+	});
 
-  const parseResponse = (result: CallToolResult) => {
-    const content = result.content?.[0];
-    if (!content || content.type !== 'text') {
-      throw new Error('Unexpected tool response format');
-    }
-    return JSON.parse(content.text);
-  };
-  const expectCacheHit = (payload: { cached: boolean; cache_info: string }) => {
-    expect(payload.cached).toBe(true);
-    expect(payload.cache_info).toMatch(/cache/i);
-  };
+	const parseResponse = (result: CallToolResult) => {
+		const content = result.content?.[0];
+		if (!content || content.type !== "text") {
+			throw new Error("Unexpected tool response format");
+		}
+		return JSON.parse(content.text);
+	};
+	const expectCacheHit = (payload: { cached: boolean; cache_info: string }) => {
+		expect(payload.cached).toBe(true);
+		expect(payload.cache_info).toMatch(/cache/i);
+	};
 
-  it(
-    'serves cached month summaries on the second invocation',
-    { meta: { tier: 'domain', domain: 'delta' } },
-    async () => {
-      const params = { budget_id: testBudgetId };
-      const firstCall = await handleListMonths(ynabAPI, deltaFetcher, params);
-      const firstPayload = parseResponse(firstCall);
-      expect(firstPayload.cached).toBe(false);
+	it(
+		"serves cached month summaries on the second invocation",
+		{ meta: { tier: "domain", domain: "delta" } },
+		async () => {
+			const params = { budget_id: testBudgetId };
+			const firstCall = await handleListMonths(ynabAPI, deltaFetcher, params);
+			const firstPayload = parseResponse(firstCall);
+			expect(firstPayload.cached).toBe(false);
 
-      const secondCall = await handleListMonths(ynabAPI, deltaFetcher, params);
-      const secondPayload = parseResponse(secondCall);
-      expectCacheHit(secondPayload);
-    },
-  );
+			const secondCall = await handleListMonths(ynabAPI, deltaFetcher, params);
+			const secondPayload = parseResponse(secondCall);
+			expectCacheHit(secondPayload);
+		},
+	);
 });