// Hides the Try it API Playground Buttons for APIs that do not support them
// Code must be updated if the parrot-api url is modified
function hideTryItButtons() {
    if (window.location.href.includes("parrot-api")) return;
  
    document.querySelectorAll("button").forEach(button => {
      const span = button.querySelector("span");
      const label = span?.textContent?.trim().toLowerCase();
  
      if (label === "try it") {
        button.style.display = "none";
        console.log("Hid a Try it button");
      }
    });
  }
  
  hideTryItButtons();
  
  const observer = new MutationObserver(() => {
    hideTryItButtons();
  });
  
  observer.observe(document.body, {
    childList: true,
    subtree: true,
  });

module.exports = {
  testEnvironment: 'node',
  collectCoverage: true,
  coverageDirectory: '../coverage',
  coverageReporters: ['text', 'lcov', 'html'],
  rootDir: '..',
  testMatch: [
    '<rootDir>/tests/**/*.test.js'
  ],
  collectCoverageFrom: [
    '<rootDir>/src/**/*.js',
    '!<rootDir>/src/**/*.test.js'
  ],
  verbose: true
}; 

/**
 * Parse the changelog.mdx file and extract update information
 * @param {string} content - The content of the changelog.mdx file
 * @returns {Array} Array of update objects with date, title, and description
 */
function parseChangelog(content) {
  const updates = [];
  
  // Split content by <Update> tags
  const updateRegex = /<Update\s+label="([^"]+)"[^>]*>(.*?)<\/Update>/gs;
  let match;

  while ((match = updateRegex.exec(content)) !== null) {
    const date = match[1];
    const updateContent = match[2];

    // Extract features from this update
    const features = extractFeaturesFromUpdate(updateContent);
    
    // Add each feature as a separate update entry
    features.forEach(feature => {
      updates.push({
        date,
        title: feature.title,
        description: feature.description
      });
    });
  }

  return updates;
}

/**
 * Extract individual features from an update block
 * @param {string} updateContent - Content inside an <Update> tag
 * @returns {Array} Array of feature objects
 */
function extractFeaturesFromUpdate(updateContent) {
  const features = [];
  
  // Split by # or ## headings to get individual features, but ignore ### and deeper
  const featureBlocks = updateContent.split(/(?=^#{1,2}\s[^#])/gm).filter(block => block.trim());

  featureBlocks.forEach(block => {
    const lines = block.trim().split('\n');
    
    // Find the title line (starts with # or ## but not ###)
    const titleLine = lines.find(line => {
      const trimmed = line.trim();
      return (trimmed.startsWith('# ') || trimmed.startsWith('## ')) && !trimmed.startsWith('### ');
    });
    
    if (!titleLine) return;

    const title = titleLine.replace(/^#{1,2}\s*/, '').trim();
    
    // Get the first paragraph after the title
    const description = extractFirstParagraph(lines.slice(lines.indexOf(titleLine) + 1));

    if (title && description) {
      features.push({
        title,
        description
      });
    }
  });

  return features;
}

/**
 * Convert relative links to absolute URLs using the Pagos docs domain
 * @param {string} text - Text containing potential relative links
 * @returns {string} Text with relative links converted to absolute URLs
 */
function convertRelativeLinksToAbsolute(text) {
  // Regex to match Markdown links: [text](url)
  const linkRegex = /\[([^\]]+)\]$([^)]+)$/g;
  
  return text.replace(linkRegex, (match, linkText, url) => {
    // Only convert relative links (those starting with /)
    if (url.startsWith('/')) {
      const absoluteUrl = `https://docs.pagos.ai${url}`;
      return `[${linkText}](${absoluteUrl})`;
    }
    // Return unchanged for absolute URLs
    return match;
  });
}

/**
 * Extract the first paragraph of text, ignoring empty lines and special elements
 * @param {Array} lines - Array of lines to process
 * @returns {string} The first paragraph with relative links converted to absolute URLs
 */
function extractFirstParagraph(lines) {
  const textLines = [];
  
  for (const line of lines) {
    const trimmed = line.trim();
    
    // Skip empty lines
    if (!trimmed) {
      if (textLines.length > 0) break; // End of paragraph
      continue;
    }
    
    // Skip special elements (tips, code blocks, nested headers, etc.)
    if (trimmed.startsWith('<') || 
        trimmed.startsWith('```') || 
        trimmed.startsWith('*') ||
        trimmed.startsWith('-') ||
        trimmed.startsWith('#')) {  // Skip any header (including ###)
      if (textLines.length > 0) break; // End of paragraph
      continue;
    }
    
    textLines.push(trimmed);
  }
  
  const paragraph = textLines.join(' ').trim();
  
  // Convert relative links to absolute URLs
  return convertRelativeLinksToAbsolute(paragraph);
}

/**
 * Extract release information from git tag
 * @param {string} tag - Git tag in format: changelog/YYYYMMDD/title
 * @returns {Object} Release info object
 */
function extractReleaseInfo(tag) {
  const tagRegex = /^changelog\/(\d{8})\/(.+)$/;
  const match = tag.match(tagRegex);
  
  if (!match) {
    throw new Error(`Invalid tag format: ${tag}. Expected format: changelog/YYYYMMDD/title`);
  }
  
  const [, dateStr, titleSlug] = match;
  
  // Parse date
  const year = dateStr.substring(0, 4);
  const month = dateStr.substring(4, 6);
  const day = dateStr.substring(6, 8);
  const releaseDate = `${year}-${month}-${day}`;
  
  // Convert title slug to readable title
  const title = titleSlug
    .split('_')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');
  
  return {
    releaseName: title,
    releaseDate,
    tag
  };
}

module.exports = {
  parseChangelog,
  extractFeaturesFromUpdate,
  extractFirstParagraph,
  extractReleaseInfo,
  convertRelativeLinksToAbsolute
}; 

const { Novu } = require('@novu/node');

async function main() {
  try {
    console.log('Starting Novu notification...');

    const apiKey = process.env.NOVU_API_KEY;
    const workflowId = process.env.NOVU_WORKFLOW_ID;
    const releaseDataStr = process.env.RELEASE_DATA;

    if (!apiKey) {
      throw new Error('NOVU_API_KEY environment variable is required');
    }
    if (!workflowId) {
      throw new Error('NOVU_WORKFLOW_ID environment variable is required');
    }
    if (!releaseDataStr) {
      throw new Error('RELEASE_DATA environment variable is required');
    }

    const releaseData = JSON.parse(releaseDataStr);
    console.log('Parsed release data:', releaseData);

    // Initialize Novu
    const novu = new Novu(apiKey);

    // Prepare payload for Novu
    const payload = {
      releaseName: releaseData.releaseName,
      releaseDate: releaseData.releaseDate,
      featuresCount: releaseData.features.length,
      features: releaseData.features,
      // You can add more custom fields as needed for your email template
      changeLogUrl: `https://docs.pagos.ai/changelog`, 
    };

    console.log('Sending broadcast notification with payload:', JSON.stringify(payload, null, 2));

    // Trigger the broadcast notification to all subscribers
    await novu.broadcast(workflowId, {
      payload: payload,
      transactionId: releaseData.tag, // This is idempotent header, so if the notification is already sent, it will not be sent again
    });

    console.log('Broadcast notification sent successfully:');

    // Also log individual features for debugging
    console.log('\n--- Features Summary ---');
    releaseData.features.forEach((feature, index) => {
      console.log(`${index + 1}. ${feature.name} (${feature.date})`);
      console.log(`   ${feature.description.substring(0, 100)}...`);
    });

  } catch (error) {
    console.error('Error sending notification:', error);
    process.exit(1);
  }
}

if (require.main === module) {
  main();
}

module.exports = {
  main
}; 

const { 
  parseChangelog, 
  extractFeaturesFromUpdate, 
  extractFirstParagraph,
  extractReleaseInfo 
} = require('../src/changelog-parser');

describe('changelog-parser', () => {
  describe('extractReleaseInfo', () => {
    it('should extract release info from valid tag', () => {
      const tag = 'changelog/20250529/new_cool_features_check_this_out';
      const result = extractReleaseInfo(tag);
      
      expect(result).toEqual({
        releaseName: 'New Cool Features Check This Out',
        releaseDate: '2025-05-29',
        tag: 'changelog/20250529/new_cool_features_check_this_out'
      });
    });

    it('should throw error for invalid tag format', () => {
      const invalidTag = 'invalid-tag-format';
      expect(() => extractReleaseInfo(invalidTag)).toThrow('Invalid tag format');
    });

    it('should handle single word titles', () => {
      const tag = 'changelog/20250101/notifications';
      const result = extractReleaseInfo(tag);
      
      expect(result.releaseName).toBe('Notifications');
    });
  });

  describe('extractFirstParagraph', () => {
    it('should extract first paragraph and ignore special elements', () => {
      const lines = [
        '',
        'This is the first paragraph of text.',
        'It continues on this line.',
        '',
        'This is the second paragraph.',
        '<Tip>',
        'This is a tip.',
        '</Tip>'
      ];
      
      const result = extractFirstParagraph(lines);
      expect(result).toBe('This is the first paragraph of text. It continues on this line.');
    });

    it('should ignore bullet points and code blocks', () => {
      const lines = [
        '* Bullet point 1',
        '* Bullet point 2',
        '',
        'This is the actual first paragraph.',
        '',
        '```javascript',
        'code block',
        '```'
      ];
      
      const result = extractFirstParagraph(lines);
      expect(result).toBe('This is the actual first paragraph.');
    });

    it('should ignore nested headers (###)', () => {
      const lines = [
        'This is the first paragraph of text.',
        '',
        '### This is a nested header',
        'This should be ignored.',
      ];
      
      const result = extractFirstParagraph(lines);
      expect(result).toBe('This is the first paragraph of text.');
    });

    it('should handle empty input', () => {
      const result = extractFirstParagraph([]);
      expect(result).toBe('');
    });
  });

  describe('extractFeaturesFromUpdate', () => {
    it('should extract multiple features from update content', () => {
      const updateContent = `
## Updated L2/L3 Opportunity Breakdown
We've improved the way we display Enhanced Data savings opportunities.

## Metrics to Charts
We've introduced a method for navigating seamlessly between Metrics and Charts.

Some additional text here.
`;
      
      const result = extractFeaturesFromUpdate(updateContent);
      
      expect(result).toHaveLength(2);
      expect(result[0]).toEqual({
        title: 'Updated L2/L3 Opportunity Breakdown',
        description: 'We\'ve improved the way we display Enhanced Data savings opportunities.'
      });
      expect(result[1]).toEqual({
        title: 'Metrics to Charts',
        description: 'We\'ve introduced a method for navigating seamlessly between Metrics and Charts.'
      });
    });

    it('should extract features from actual changelog example with mixed headers', () => {
      const updateContent = `
## New Fee Filtering
We've added an **Only New Fees** toggle to the **Fees by Category**, **Fees by Subcategory**, and **Interchange & Assessments** pages within the Costs section of Visualizations. Use this toggle to filter the entire page to only show data for the newest fees you've faced. Learn more in our [Costs](/visualizations/costs#new-fee-filtering) guide.

## Events
We've added a new section to the Pagos Service Panel titled [Events](/data-platform/events). You now have access to a unified view of every transaction—across every processor—fully harmonized and organized in one place. Take your payments analysis to the next level by digging down to the transaction-level.
`;
      
      const result = extractFeaturesFromUpdate(updateContent);
      
      expect(result).toHaveLength(2);
      expect(result[0]).toEqual({
        title: 'New Fee Filtering',
        description: 'We\'ve added an **Only New Fees** toggle to the **Fees by Category**, **Fees by Subcategory**, and **Interchange & Assessments** pages within the Costs section of Visualizations. Use this toggle to filter the entire page to only show data for the newest fees you\'ve faced. Learn more in our [Costs](https://docs.pagos.ai/visualizations/costs#new-fee-filtering) guide.'
      });
      expect(result[1]).toEqual({
        title: 'Events',
        description: 'We\'ve added a new section to the Pagos Service Panel titled [Events](https://docs.pagos.ai/data-platform/events). You now have access to a unified view of every transaction—across every processor—fully harmonized and organized in one place. Take your payments analysis to the next level by digging down to the transaction-level.'
      });
    });

    it('should support both # and ## headers', () => {
      const updateContent = `
# First Feature with Single Hash
This is the first feature description.

## Second Feature with Double Hash
This is the second feature description.
`;
      
      const result = extractFeaturesFromUpdate(updateContent);
      
      expect(result).toHaveLength(2);
      expect(result[0]).toEqual({
        title: 'First Feature with Single Hash',
        description: 'This is the first feature description.'
      });
      expect(result[1]).toEqual({
        title: 'Second Feature with Double Hash',
        description: 'This is the second feature description.'
      });
    });

    it('should ignore ### nested headers', () => {
      const updateContent = `
## Main Feature
This is the main feature description.

### This is a nested section
This content should be ignored.

### Another nested section
This should also be ignored.
`;
      
      const result = extractFeaturesFromUpdate(updateContent);
      
      expect(result).toHaveLength(1);
      expect(result[0]).toEqual({
        title: 'Main Feature',
        description: 'This is the main feature description.'
      });
    });

    it('should handle features without descriptions', () => {
      const updateContent = `
## Some Feature Title
## Another Feature
This has a description.
`;
      
      const result = extractFeaturesFromUpdate(updateContent);
      
      expect(result).toHaveLength(1);
      expect(result[0]).toEqual({
        title: 'Another Feature',
        description: 'This has a description.'
      });
    });
  });

  describe('parseChangelog', () => {
    it('should parse changelog with multiple updates', () => {
      const changelog = `---
title: 'Changelog'
---
<Update label="2025-05-28">
## Updated L2/L3 Opportunity Breakdown
We've improved the way we display Enhanced Data savings opportunities.
</Update>

<Update label="2025-05-27">
## Metrics to Charts
We've introduced a method for navigating between Metrics and Charts.

## Notifications
We've added notification capabilities to the Pagos Service Panel.
</Update>`;

      const result = parseChangelog(changelog);
      
      expect(result).toHaveLength(3);
      expect(result[0]).toEqual({
        date: '2025-05-28',
        title: 'Updated L2/L3 Opportunity Breakdown',
        description: 'We\'ve improved the way we display Enhanced Data savings opportunities.'
      });
      expect(result[1]).toEqual({
        date: '2025-05-27',
        title: 'Metrics to Charts',
        description: 'We\'ve introduced a method for navigating between Metrics and Charts.'
      });
      expect(result[2]).toEqual({
        date: '2025-05-27',
        title: 'Notifications',
        description: 'We\'ve added notification capabilities to the Pagos Service Panel.'
      });
    });

    it('should handle changelog with no updates', () => {
      const changelog = `---
title: 'Changelog'
---
No updates here.`;

      const result = parseChangelog(changelog);
      expect(result).toHaveLength(0);
    });

    it('should handle malformed update tags', () => {
      const changelog = `---
title: 'Changelog'
---
<Update label="2025-05-28">
## Valid Feature
This is a valid feature.
</Update>

<Update>
## Invalid Update
This update has no label.
</Update>`;

      const result = parseChangelog(changelog);
      expect(result).toHaveLength(1);
      expect(result[0].date).toBe('2025-05-28');
    });
  });
}); 

const { findNewUpdates, getPreviousChangelogTag } = require('../src/parse-changelog');

describe('parse-changelog', () => {
  describe('findNewUpdates', () => {
    it('should find new updates based on date comparison', () => {
      const currentUpdates = [
        { date: '2025-05-28', title: 'New Feature A', description: 'Description A' },
        { date: '2025-05-27', title: 'New Feature B', description: 'Description B' },
        { date: '2025-05-26', title: 'Old Feature', description: 'Description C' }
      ];

      const previousUpdates = [
        { date: '2025-05-26', title: 'Old Feature', description: 'Description C' },
        { date: '2025-05-25', title: 'Older Feature', description: 'Description D' }
      ];

      const result = findNewUpdates(currentUpdates, previousUpdates);

      expect(result).toHaveLength(2);
      expect(result[0]).toEqual({
        date: '2025-05-28',
        title: 'New Feature A',
        description: 'Description A'
      });
      expect(result[1]).toEqual({
        date: '2025-05-27',
        title: 'New Feature B',
        description: 'Description B'
      });
    });

    it('should return empty array when no new updates', () => {
      const currentUpdates = [
        { date: '2025-05-26', title: 'Feature A', description: 'Description A' }
      ];

      const previousUpdates = [
        { date: '2025-05-26', title: 'Feature A', description: 'Description A' }
      ];

      const result = findNewUpdates(currentUpdates, previousUpdates);
      expect(result).toHaveLength(0);
    });

    it('should handle empty previous updates', () => {
      const currentUpdates = [
        { date: '2025-05-28', title: 'New Feature', description: 'Description' }
      ];

      const previousUpdates = [];

      const result = findNewUpdates(currentUpdates, previousUpdates);
      expect(result).toEqual(currentUpdates);
    });

    it('should handle duplicate dates with different features', () => {
      const currentUpdates = [
        { date: '2025-05-28', title: 'Feature A', description: 'Description A' },
        { date: '2025-05-28', title: 'Feature B', description: 'Description B' },
        { date: '2025-05-27', title: 'Feature C', description: 'Description C' }
      ];

      const previousUpdates = [
        { date: '2025-05-27', title: 'Feature C', description: 'Description C' }
      ];

      const result = findNewUpdates(currentUpdates, previousUpdates);
      
      // Should include both features from the new date
      expect(result).toHaveLength(2);
      expect(result.map(u => u.title)).toContain('Feature A');
      expect(result.map(u => u.title)).toContain('Feature B');
    });
  });

  describe('getPreviousChangelogTag', () => {
    it('should filter and sort changelog tags correctly', async () => {
      // Mock git object
      const mockGit = {
        tags: jest.fn().mockResolvedValue({
          all: [
            'v1.0.0',
            'changelog/20250528/latest_release',
            'changelog/20250527/previous_release',
            'changelog/20250526/older_release',
            'other-tag'
          ]
        })
      };

      const currentTag = 'changelog/20250528/latest_release';
      const result = await getPreviousChangelogTag(mockGit, currentTag);

      expect(result).toBe('changelog/20250527/previous_release');
      expect(mockGit.tags).toHaveBeenCalledWith(['--sort=-version:refname']);
    });

    it('should return null when no previous changelog tags exist', async () => {
      const mockGit = {
        tags: jest.fn().mockResolvedValue({
          all: ['v1.0.0', 'other-tag']
        })
      };

      const currentTag = 'changelog/20250528/first_release';
      const result = await getPreviousChangelogTag(mockGit, currentTag);

      expect(result).toBeNull();
    });

    it('should exclude current tag from results', async () => {
      const mockGit = {
        tags: jest.fn().mockResolvedValue({
          all: [
            'changelog/20250528/current_release',
            'changelog/20250527/previous_release'
          ]
        })
      };

      const currentTag = 'changelog/20250528/current_release';
      const result = await getPreviousChangelogTag(mockGit, currentTag);

      expect(result).toBe('changelog/20250527/previous_release');
    });

    it('should handle git errors gracefully', async () => {
      const mockGit = {
        tags: jest.fn().mockRejectedValue(new Error('Git error'))
      };

      const currentTag = 'changelog/20250528/current_release';
      const result = await getPreviousChangelogTag(mockGit, currentTag);

      expect(result).toBeNull();
    });
  });
}); 

#!/usr/bin/env node

/**
 * E2E Test Runner for Changelog Release Workflow
 * 
 * This script runs the end-to-end test for the changelog release system.
 * It can be used locally or in CI/CD environments like GitHub Actions.
 * 
 * Usage:
 *   node run-e2e-test.js
 *   npm run test:e2e
 */

const { execSync } = require('child_process');
const path = require('path');

function runE2ETest() {
  console.log('🚀 Starting E2E Changelog Release Test...\n');
  
  try {
    // Change to the scripts directory
    const scriptsDir = path.join(__dirname, '..');
    process.chdir(scriptsDir);
    
    // Run the specific E2E test
    console.log('📦 Running E2E test with Jest...\n');
    
    const testCommand = 'npx jest tests/e2e-changelog-release.test.js --verbose --no-coverage';
    
    execSync(testCommand, { 
      stdio: 'inherit',
      env: { ...process.env, NODE_ENV: 'test' }
    });
    
    console.log('\n✅ E2E test completed successfully!');
    
  } catch (error) {
    console.error('\n❌ E2E test failed:');
    console.error(error.message);
    process.exit(1);
  }
}

// Self-executing function if run directly
if (require.main === module) {
  runE2ETest();
}

module.exports = { runE2ETest }; 

#!/usr/bin/env node

/**
 * Test Monthly Scheduler Tag Generation
 * 
 * This script tests the tag generation logic used by the monthly scheduler
 * to ensure it creates the correct format tags.
 */

function generateMonthlyTag(monthOffset = 0) {
  const targetDate = new Date();
  targetDate.setMonth(targetDate.getMonth() + monthOffset);
  
  const year = targetDate.getFullYear();
  const monthNum = String(targetDate.getMonth() + 1).padStart(2, '0');
  const monthName = targetDate.toLocaleString('default', { month: 'long' });
  const day = '01';
  
  const dateString = `${year}${monthNum}${day}`;
  const titleSlug = `pagos_changelog_${monthName.toLowerCase()}_${year}`;
  const tagName = `changelog/${dateString}/${titleSlug}`;
  const releaseTitle = `Pagos Changelog ${monthName} ${year}`;
  
  return {
    tagName,
    releaseTitle,
    dateString,
    monthName,
    year,
    monthNum
  };
}

function testMonthlyScheduler() {
  console.log('🧪 Testing Monthly Scheduler Tag Generation\n');
  
  // Test current month
  console.log('📅 Current Month:');
  const current = generateMonthlyTag(0);
  console.log(`   Tag: ${current.tagName}`);
  console.log(`   Title: ${current.releaseTitle}`);
  console.log(`   Date String: ${current.dateString}`);
  console.log();
  
  // Test next month
  console.log('📅 Next Month:');
  const next = generateMonthlyTag(1);
  console.log(`   Tag: ${next.tagName}`);
  console.log(`   Title: ${next.releaseTitle}`);
  console.log(`   Date String: ${next.dateString}`);
  console.log();
  
  // Test previous month
  console.log('📅 Previous Month:');
  const prev = generateMonthlyTag(-1);
  console.log(`   Tag: ${prev.tagName}`);
  console.log(`   Title: ${prev.releaseTitle}`);
  console.log(`   Date String: ${prev.dateString}`);
  console.log();
  
  // Test several months ahead to show the pattern
  console.log('📅 Sample Future Months:');
  for (let i = 2; i <= 4; i++) {
    const future = generateMonthlyTag(i);
    console.log(`   ${future.monthName} ${future.year}: ${future.tagName}`);
  }
  console.log();
  
  // Verify tag format matches expected pattern
  console.log('✅ Tag Format Validation:');
  const tagRegex = /^changelog\/(\d{8})\/pagos_changelog_([a-z]+)_(\d{4})$/;
  const match = current.tagName.match(tagRegex);
  
  if (match) {
    console.log('   ✅ Tag format is valid');
    console.log(`   📝 Pattern: changelog/YYYYMMDD/pagos_changelog_month_year`);
    console.log(`   📝 Example: ${current.tagName}`);
  } else {
    console.log('   ❌ Tag format is invalid');
  }
  
  // Test with extractReleaseInfo to ensure compatibility
  console.log('\n🔧 Testing compatibility with existing parser:');
  try {
    const { extractReleaseInfo } = require('../src/changelog-parser');
    const parsed = extractReleaseInfo(current.tagName);
    console.log('   ✅ Compatible with existing parser');
    console.log(`   📋 Parsed result:`);
    console.log(`      Release Name: ${parsed.releaseName}`);
    console.log(`      Release Date: ${parsed.releaseDate}`);
    console.log(`      Tag: ${parsed.tag}`);
  } catch (error) {
    console.log(`   ❌ Error with parser: ${error.message}`);
  }
}

// Run tests if called directly
if (require.main === module) {
  testMonthlyScheduler();
}

module.exports = { generateMonthlyTag, testMonthlyScheduler }; 

#!/usr/bin/env node

/**
 * Manual test runner for changelog parsing
 * Usage: node utils/test-runner.js
 */

const fs = require('fs');
const path = require('path');
const { parseChangelog, extractReleaseInfo } = require('../src/changelog-parser');

console.log('🚀 Manual Changelog Testing Tool');
console.log('==================================');

// Test parsing the current changelog
console.log('📖 Test 1: Parsing current changelog.mdx');
const changelogPath = path.join(__dirname, '../../../../changelog.mdx');

if (fs.existsSync(changelogPath)) {
  try {
    const changelogContent = fs.readFileSync(changelogPath, 'utf8');
    const features = parseChangelog(changelogContent);
    
    console.log(`✅ Found ${features.length} features in changelog`);
    
    if (features.length > 0) {
      console.log('\n📋 Latest features:');
      features.slice(0, 5).forEach((feature, index) => {
        console.log(`  ${index + 1}. ${feature.title} (${feature.date})`);
        console.log(`     ${feature.description.substring(0, 100)}...`);
      });
    }
  } catch (error) {
    console.log('❌ Error parsing changelog:', error.message);
  }
} else {
  console.log('❌ changelog.mdx not found');
}

console.log('\n---\n');

// Test 2: Extract release info from sample tags
console.log('🏷️  Test 2: Extracting release info from tags');
const sampleTags = [
  'changelog/20250529/new_cool_features_check_this_out',
  'changelog/20250101/notifications',
  'changelog/20241225/holiday_updates_and_fixes'
];

sampleTags.forEach(tag => {
  try {
    const releaseInfo = extractReleaseInfo(tag);
    console.log(`✅ ${tag}`);
    console.log(`   Release Name: ${releaseInfo.releaseName}`);
    console.log(`   Release Date: ${releaseInfo.releaseDate}`);
  } catch (error) {
    console.log(`❌ ${tag}: ${error.message}`);
  }
});

console.log('\n---\n');

// Test 3: Simulate finding new updates
console.log('🔍 Test 3: Simulating update comparison');

const currentUpdates = [
  { date: '2025-05-28', title: 'New Feature A', description: 'Description A' },
  { date: '2025-05-27', title: 'New Feature B', description: 'Description B' },
  { date: '2025-05-26', title: 'Old Feature', description: 'Description C' }
];

const previousUpdates = [
  { date: '2025-05-26', title: 'Old Feature', description: 'Description C' }
];

const newUpdates = currentUpdates.filter(current => 
  !previousUpdates.some(prev => prev.date === current.date)
);

console.log(`✅ Found ${newUpdates.length} new updates:`);
newUpdates.forEach((update, index) => {
  console.log(`   ${index + 1}. ${update.title} (${update.date})`);
});

console.log('\n🎉 All tests completed successfully!');

// Test 4: Create sample output JSON
function createSampleOutput() {
  console.log('\n📄 Sample Output JSON:');
  
  const sampleReleaseData = {
    releaseName: 'New Cool Features Check This Out',
    releaseDate: '2025-05-29',
    tag: 'changelog/20250529/new_cool_features_check_this_out',
    features: [
      {
        date: '2025-05-28',
        name: 'Updated L2/L3 Opportunity Breakdown',
        description: 'We\'ve improved the way we display Enhanced Data savings opportunities to provide a more accurate estimate of potential savings.'
      },
      {
        date: '2025-05-27',
        name: 'Metrics to Charts',
        description: 'We\'ve introduced a method for navigating seamlessly between Metrics and Charts.'
      }
    ]
  };

  console.log(JSON.stringify(sampleReleaseData, null, 2));
}

if (require.main === module) {
  createSampleOutput();
}

module.exports = {
  createSampleOutput
}; 

Check Status of an Inquiry

Pagos

Pagos provides the data platform and tools you need to build, monitor, and optimize your payments processing. Turn your payments data into a strategic asset for identifying opportunities to increase revenue, decrease costs, fight fraud, and delight customers.

Getting Started with Pagos

Domains & IP Addresses

Pagos Domains and IP Addresses

Managing Your Account

Managing Your Pagos Account

Manage the accounts you connect to Pagos for payments data importing. See our **Connecting Your PSPs** guides for the step-by-step setup instructions specific to each processor.

Managing Data Connections

Data Ingestion Services

The Pagos Data Ingestion Services

Request detailed bank and market data for the payment cards your customers transact with.

The BIN Data API

Getting Started with the BIN Data API

BIN Data Batch

Getting Started with BIN Data Batch

If you subscribe to Peacock, you can access the **Visualizations** portion of the Pagos Service Panel. This data aggregation and visualization platform provides you with the self-service business intelligence you need to track the health of your payments ecosystem.

Getting Started

Getting Started With Pagos Visualizations

The Snapshots section of Visualizations is a dashboard of charts and graphs, designed by our team of payments experts to give you immediate insight into your day-to-day processing capacity and efficiency.

Snapshots

The Charts section of Visualizations grants you the flexibility to build custom data visualizations.

Charts

The Opportunities page under Visualizations estimates actionable cost-saving opportunities in your payments stack.

Opportunities

The Risks section of Visualizations helps you monitor data relevant to risk management. 

Risks

The Costs section of Visualizations demonstrates your payments costs over time, helping you identify the sources of the biggest drains on your revenue.

Costs

Use built-in filters to refine your aggregated payments data by properties like processor, card brand, currency, and more. You can combine filters to view specific segments of data.

Data Filters

Visualizations Data Filters

Alerts is the first page under the **Observability** section of your Pagos Service Panel. It provides you with a daily health check for your payment processing strategy—no manual setup required.

Alerts

Identify the top BINs associated with payment cards you've processed, and use this information to gain valuable context on your customers and their preferred payment methods.

BIN Data

View aggregated metrics on Metadata and Soft Descriptors you’ve passed with your transactions.

Custom Data

Monitor and manage the Network Tokenization API.

Network Tokens

Monitor and manage the Account Updater API (batch and real-time).

Account Updater

Events provides your business with a unified view of every transaction—across all your processors—fully harmonized and delivered in one place. Payments, refunds, chargebacks, disputes: all your data, cleaned, structured, and ready for analysis. 

Events

Access a single, clean source of your aggregated payments data with no manual work required! Download this data to use however you need: build out custom workflows, support your data teams, support adjacent business analyses, or facilitate business development with third parties. Your data, your way.

Data & Response Codes

Data Ingestion

Pagos MCP Server

BIN Database

Account Updater

Network Tokenization

Check Status of an Inquiry

Path Parameters

Response