@ktmcp-cli/nordigen 1.0.0

package/src/lib/config.js

@@ -0,0 +1,145 @@
+/**
+ * Configuration Management
+ *
+ * @fileoverview Manages CLI configuration and credentials storage
+ * @module lib/config
+ */
+
+import Conf from 'conf';
+import { homedir } from 'os';
+import { join } from 'path';
+
+/**
+ * Configuration schema
+ */
+const schema = {
+  auth: {
+    type: 'object',
+    properties: {
+      secret_id: { type: 'string' },
+      secret_key: { type: 'string' },
+      access_token: { type: 'string' },
+      refresh_token: { type: 'string' },
+      access_expires: { type: 'number' },
+      refresh_expires: { type: 'number' },
+    },
+  },
+  defaults: {
+    type: 'object',
+    properties: {
+      country: { type: 'string' },
+      institution_id: { type: 'string' },
+    },
+  },
+};
+
+let configInstance = null;
+
+/**
+ * Get or create config instance
+ *
+ * @returns {Conf}
+ */
+export function getConfig() {
+  if (!configInstance) {
+    configInstance = new Conf({
+      projectName: 'nordigen-cli',
+      schema,
+      configFileMode: 0o600, // Read/write for owner only
+    });
+  }
+  return configInstance;
+}
+
+/**
+ * Get configuration value
+ *
+ * @param {string} key - Configuration key (dot notation supported)
+ * @param {*} [defaultValue] - Default value if key doesn't exist
+ * @returns {*}
+ */
+export function get(key, defaultValue) {
+  return getConfig().get(key, defaultValue);
+}
+
+/**
+ * Set configuration value
+ *
+ * @param {string} key - Configuration key (dot notation supported)
+ * @param {*} value - Value to set
+ */
+export function set(key, value) {
+  getConfig().set(key, value);
+}
+
+/**
+ * Delete configuration value
+ *
+ * @param {string} key - Configuration key
+ */
+export function del(key) {
+  getConfig().delete(key);
+}
+
+/**
+ * Clear all configuration
+ */
+export function clear() {
+  getConfig().clear();
+}
+
+/**
+ * Get all configuration
+ *
+ * @returns {Object}
+ */
+export function getAll() {
+  return getConfig().store;
+}
+
+/**
+ * Check if access token is valid (not expired)
+ *
+ * @returns {boolean}
+ */
+export function isAccessTokenValid() {
+  const config = getConfig();
+  const token = config.get('auth.access_token');
+  const expires = config.get('auth.access_expires');
+
+  if (!token || !expires) {
+    return false;
+  }
+
+  // Check if token expires in more than 60 seconds
+  const now = Math.floor(Date.now() / 1000);
+  return expires > (now + 60);
+}
+
+/**
+ * Check if refresh token is valid (not expired)
+ *
+ * @returns {boolean}
+ */
+export function isRefreshTokenValid() {
+  const config = getConfig();
+  const token = config.get('auth.refresh_token');
+  const expires = config.get('auth.refresh_expires');
+
+  if (!token || !expires) {
+    return false;
+  }
+
+  // Check if token expires in more than 60 seconds
+  const now = Math.floor(Date.now() / 1000);
+  return expires > (now + 60);
+}
+
+/**
+ * Get config file path
+ *
+ * @returns {string}
+ */
+export function getConfigPath() {
+  return getConfig().path;
+}

package/src/lib/output.js

@@ -0,0 +1,255 @@
+/**
+ * Output Formatting
+ *
+ * @fileoverview Utilities for formatting and displaying CLI output
+ * @module lib/output
+ */
+
+import chalk from 'chalk';
+import { format as formatDate } from 'date-fns';
+
+/**
+ * Output formats
+ */
+export const OutputFormat = {
+  JSON: 'json',
+  TABLE: 'table',
+  LIST: 'list',
+};
+
+/**
+ * Print JSON output
+ *
+ * @param {*} data - Data to output
+ * @param {boolean} [pretty=true] - Pretty print
+ */
+export function printJSON(data, pretty = true) {
+  if (pretty) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(JSON.stringify(data));
+  }
+}
+
+/**
+ * Print success message
+ *
+ * @param {string} message - Success message
+ */
+export function printSuccess(message) {
+  console.log(chalk.green('✓'), message);
+}
+
+/**
+ * Print error message
+ *
+ * @param {string} message - Error message
+ * @param {Error} [error] - Error object
+ */
+export function printError(message, error = null) {
+  console.error(chalk.red('✗'), message);
+  if (error && process.env.DEBUG) {
+    console.error(chalk.gray(error.stack));
+  }
+}
+
+/**
+ * Print warning message
+ *
+ * @param {string} message - Warning message
+ */
+export function printWarning(message) {
+  console.log(chalk.yellow('⚠'), message);
+}
+
+/**
+ * Print info message
+ *
+ * @param {string} message - Info message
+ */
+export function printInfo(message) {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+/**
+ * Print table row
+ *
+ * @param {string} label - Row label
+ * @param {string} value - Row value
+ * @param {number} [labelWidth=20] - Label column width
+ */
+export function printRow(label, value, labelWidth = 20) {
+  const paddedLabel = label.padEnd(labelWidth);
+  console.log(`${chalk.cyan(paddedLabel)} ${value}`);
+}
+
+/**
+ * Print section header
+ *
+ * @param {string} title - Section title
+ */
+export function printSection(title) {
+  console.log();
+  console.log(chalk.bold.underline(title));
+  console.log();
+}
+
+/**
+ * Format currency amount
+ *
+ * @param {number|string} amount - Amount
+ * @param {string} [currency='EUR'] - Currency code
+ * @returns {string}
+ */
+export function formatCurrency(amount, currency = 'EUR') {
+  const num = typeof amount === 'string' ? parseFloat(amount) : amount;
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: currency,
+  }).format(num);
+}
+
+/**
+ * Format date
+ *
+ * @param {string|Date} date - Date to format
+ * @param {string} [format='yyyy-MM-dd'] - Date format
+ * @returns {string}
+ */
+export function formatDateString(date, format = 'yyyy-MM-dd') {
+  if (!date) return 'N/A';
+  const d = typeof date === 'string' ? new Date(date) : date;
+  return formatDate(d, format);
+}
+
+/**
+ * Format relative time
+ *
+ * @param {string|Date} date - Date to format
+ * @returns {string}
+ */
+export function formatRelativeTime(date) {
+  if (!date) return 'N/A';
+
+  const d = typeof date === 'string' ? new Date(date) : date;
+  const now = new Date();
+  const diffMs = now - d;
+  const diffSec = Math.floor(diffMs / 1000);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHour = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHour / 24);
+
+  if (diffSec < 60) return 'just now';
+  if (diffMin < 60) return `${diffMin} minute${diffMin > 1 ? 's' : ''} ago`;
+  if (diffHour < 24) return `${diffHour} hour${diffHour > 1 ? 's' : ''} ago`;
+  if (diffDay < 7) return `${diffDay} day${diffDay > 1 ? 's' : ''} ago`;
+
+  return formatDate(d, 'yyyy-MM-dd');
+}
+
+/**
+ * Format seconds to human-readable duration
+ *
+ * @param {number} seconds - Duration in seconds
+ * @returns {string}
+ */
+export function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds} second${seconds !== 1 ? 's' : ''}`;
+  if (seconds < 3600) {
+    const mins = Math.floor(seconds / 60);
+    return `${mins} minute${mins !== 1 ? 's' : ''}`;
+  }
+  if (seconds < 86400) {
+    const hours = Math.floor(seconds / 3600);
+    return `${hours} hour${hours !== 1 ? 's' : ''}`;
+  }
+  const days = Math.floor(seconds / 86400);
+  return `${days} day${days !== 1 ? 's' : ''}`;
+}
+
+/**
+ * Print account summary
+ *
+ * @param {Object} account - Account data
+ */
+export function printAccountSummary(account) {
+  printSection('Account Details');
+  printRow('Account ID', account.id);
+  printRow('IBAN', account.iban || 'N/A');
+  printRow('Status', formatStatus(account.status));
+  printRow('Created', formatDateString(account.created));
+  printRow('Last Accessed', formatRelativeTime(account.last_accessed));
+  if (account.institution_id) {
+    printRow('Institution ID', account.institution_id);
+  }
+}
+
+/**
+ * Format status with color
+ *
+ * @param {string} status - Status string
+ * @returns {string}
+ */
+export function formatStatus(status) {
+  switch (status?.toUpperCase()) {
+    case 'READY':
+    case 'ACTIVE':
+    case 'COMPLETED':
+      return chalk.green(status);
+    case 'PROCESSING':
+    case 'PENDING':
+      return chalk.yellow(status);
+    case 'ERROR':
+    case 'SUSPENDED':
+    case 'EXPIRED':
+      return chalk.red(status);
+    default:
+      return status || 'N/A';
+  }
+}
+
+/**
+ * Print transaction
+ *
+ * @param {Object} transaction - Transaction data
+ */
+export function printTransaction(transaction) {
+  const amount = transaction.transactionAmount || {};
+  const date = transaction.bookingDate || transaction.valueDate;
+
+  console.log(
+    chalk.cyan(formatDateString(date)),
+    formatCurrency(amount.amount, amount.currency),
+    transaction.remittanceInformationUnstructured || transaction.debtorName || 'N/A'
+  );
+}
+
+/**
+ * Print list of items
+ *
+ * @param {Array} items - Items to print
+ * @param {Function} formatter - Function to format each item
+ */
+export function printList(items, formatter) {
+  if (!items || items.length === 0) {
+    printWarning('No items found');
+    return;
+  }
+
+  items.forEach((item, index) => {
+    formatter(item, index);
+  });
+}
+
+/**
+ * Truncate string
+ *
+ * @param {string} str - String to truncate
+ * @param {number} [maxLength=50] - Maximum length
+ * @returns {string}
+ */
+export function truncate(str, maxLength = 50) {
+  if (!str) return '';
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength - 3) + '...';
+}

package/test/api.test.js

@@ -0,0 +1,88 @@
+/**
+ * API Client Tests
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { NordigenAPI } from '../src/lib/api.js';
+
+test('NordigenAPI - initialization', () => {
+  const api = new NordigenAPI();
+  assert.ok(api);
+  assert.equal(api.baseURL, 'https://ob.nordigen.com');
+});
+
+test('NordigenAPI - request URL building', async () => {
+  const api = new NordigenAPI('test-token');
+
+  // Mock fetch for testing
+  const originalFetch = global.fetch;
+  global.fetch = async (url) => {
+    assert.ok(url.includes('/api/v2/'));
+    return {
+      ok: true,
+      headers: new Map([['content-type', 'application/json']]),
+      json: async () => ({ test: 'data' })
+    };
+  };
+
+  try {
+    const result = await api.get('/api/v2/test');
+    assert.deepEqual(result, { test: 'data' });
+  } finally {
+    global.fetch = originalFetch;
+  }
+});
+
+test('NordigenAPI - query parameters', async () => {
+  const api = new NordigenAPI('test-token');
+
+  const originalFetch = global.fetch;
+  global.fetch = async (url) => {
+    assert.ok(url.includes('country=GB'));
+    assert.ok(url.includes('limit=10'));
+    return {
+      ok: true,
+      headers: new Map([['content-type', 'application/json']]),
+      json: async () => ([])
+    };
+  };
+
+  try {
+    await api.get('/api/v2/institutions/', {
+      query: { country: 'GB', limit: 10 }
+    });
+  } finally {
+    global.fetch = originalFetch;
+  }
+});
+
+test('NordigenAPI - error handling', async () => {
+  const api = new NordigenAPI('test-token');
+
+  const originalFetch = global.fetch;
+  global.fetch = async () => ({
+    ok: false,
+    status: 401,
+    statusText: 'Unauthorized',
+    headers: new Map([['content-type', 'application/json']]),
+    json: async () => ({
+      status_code: 401,
+      summary: 'Invalid token',
+      detail: 'Token is invalid or expired'
+    })
+  });
+
+  try {
+    await assert.rejects(
+      async () => await api.get('/api/v2/accounts/test'),
+      (error) => {
+        assert.equal(error.status, 401);
+        assert.ok(error.message.includes('Invalid token'));
+        return true;
+      }
+    );
+  } finally {
+    global.fetch = originalFetch;
+  }
+});