refactor(workflow): enhance daily balance snapshot orchestration

- Updated endpoint to use parameters instead of body
- Introduced a step to install script dependencies before running the snapshot orchestration.
- Updated the orchestration command to use `npm start` instead of directly executing the script.
- Improved failure notification logic to handle cases where the Discord webhook URL is not configured.

Author: Andre-Diamond

.github/workflows/daily-balance-snapshots.yml

@@ -13,6 +13,7 @@ on:
 jobs:
   snapshot-balances:
     runs-on: ubuntu-latest
+    timeout-minutes: 300  # 5 hours timeout (GitHub Actions max is 6 hours)
 
     steps:
       - name: Checkout repository
@@ -27,8 +28,15 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Install script dependencies
+        run: |
+          cd scripts
+          npm ci
+        
       - name: Run batch snapshot orchestration
-        run: node scripts/batch-snapshot-orchestrator.js
+        run: |
+          cd scripts
+          npm start
         env:
           API_BASE_URL: "https://multisig.meshjs.dev"
           SNAPSHOT_AUTH_TOKEN: ${{ secrets.SNAPSHOT_AUTH_TOKEN }}
@@ -41,6 +49,10 @@ jobs:
         # Send failure notification
         run: |
           echo "❌ Daily balance snapshot job failed"
-          curl -X POST -H 'Content-type: application/json' \
-            --data "{\"text\":\"❌ Daily balance snapshots failed. Check the GitHub Actions logs.\"}" \
-            ${{ secrets.SNAPSHOT_ERROR_DISCORD_WEBHOOK_URL }}
+          if [ -n "${{ secrets.SNAPSHOT_ERROR_DISCORD_WEBHOOK_URL }}" ]; then
+            curl -X POST -H 'Content-type: application/json' \
+              --data "{\"text\":\"❌ Daily balance snapshots failed. Check the GitHub Actions logs.\"}" \
+              ${{ secrets.SNAPSHOT_ERROR_DISCORD_WEBHOOK_URL }} || echo "Failed to send Discord notification"
+          else
+            echo "SNAPSHOT_ERROR_DISCORD_WEBHOOK_URL not configured, skipping notification"
+          fi

scripts/batch-snapshot-orchestrator.js scripts/batch-snapshot-orchestrator.tsscripts/batch-snapshot-orchestrator.js renamed to scripts/batch-snapshot-orchestrator.ts

@@ -8,8 +8,8 @@
  * It handles timeout issues by processing wallets in small batches.
  * 
  * Usage:
- *   node scripts/batch-snapshot-orchestrator.js
- *   SNAPSHOT_AUTH_TOKEN=your_token node scripts/batch-snapshot-orchestrator.js
+ *   npx tsx scripts/batch-snapshot-orchestrator.ts
+ *   SNAPSHOT_AUTH_TOKEN=your_token npx tsx scripts/batch-snapshot-orchestrator.ts
  * 
  * Environment Variables:
  *   - API_BASE_URL: Base URL for the API (default: http://localhost:3000)
@@ -19,7 +19,49 @@
  *   - MAX_RETRIES: Maximum retries for failed batches (default: 3)
  */
 
+interface BatchProgress {
+  processedInBatch: number;
+  walletsInBatch: number;
+  failedInBatch: number;
+  snapshotsStored: number;
+  totalAdaBalance: number;
+  totalBatches: number;
+}
+
+interface BatchResponse {
+  success: boolean;
+  message?: string;
+  progress: BatchProgress;
+}
+
+interface BatchResults {
+  totalBatches: number;
+  completedBatches: number;
+  failedBatches: number;
+  totalWalletsProcessed: number;
+  totalWalletsFailed: number;
+  totalAdaBalance: number;
+  totalSnapshotsStored: number;
+  executionTime: number;
+}
+
+interface BatchConfig {
+  apiBaseUrl: string;
+  authToken: string;
+  batchSize: number;
+  delayBetweenBatches: number;
+  maxRetries: number;
+}
+
+interface ApiResponse<T> {
+  data: T;
+  status: number;
+}
+
 class BatchSnapshotOrchestrator {
+  private config: BatchConfig;
+  private results: BatchResults;
+
   constructor() {
     this.config = this.loadConfig();
     this.results = {
@@ -34,7 +76,7 @@ class BatchSnapshotOrchestrator {
     };
   }
 
-  loadConfig() {
+  private loadConfig(): BatchConfig {
     const apiBaseUrl = process.env.API_BASE_URL || 'http://localhost:3000';
     const authToken = process.env.SNAPSHOT_AUTH_TOKEN;
 
@@ -51,48 +93,55 @@ class BatchSnapshotOrchestrator {
     };
   }
 
-  async makeRequest(/** @type {string} */ url, /** @type {RequestInit} */ options = {}) {
+  private async makeRequest<T>(url: string, options: RequestInit = {}): Promise<ApiResponse<T>> {
     try {
+      // Add timeout to prevent hanging requests
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
+      
       const response = await fetch(url, {
         ...options,
+        signal: controller.signal,
         headers: {
           'Authorization': `Bearer ${this.config.authToken}`,
           'Content-Type': 'application/json',
           ...(options.headers || {}),
         },
       });
+      
+      clearTimeout(timeoutId);
 
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
 
-      const data = await response.json();
+      const data = await response.json() as T;
       return { data, status: response.status };
     } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Request timeout after 30 seconds');
+      }
       throw error;
     }
   }
 
-  async delay(/** @type {number} */ seconds) {
+  private async delay(seconds: number): Promise<void> {
     return new Promise(resolve => setTimeout(resolve, seconds * 1000));
   }
 
-  async processBatch(/** @type {number} */ batchNumber, /** @type {string} */ batchId) {
+  private async processBatch(batchNumber: number, batchId: string): Promise<BatchProgress | null> {
     console.log(`📦 Processing batch ${batchNumber}...`);
 
     for (let attempt = 1; attempt <= this.config.maxRetries; attempt++) {
       try {
-        const { data } = await this.makeRequest(
-          `${this.config.apiBaseUrl}/api/v1/stats/run-snapshots-batch`,
-          {
-            method: 'POST',
-            body: JSON.stringify({
-              batchId,
-              batchNumber,
-              batchSize: this.config.batchSize,
-            }),
-          }
-        );
+        const url = new URL(`${this.config.apiBaseUrl}/api/v1/stats/run-snapshots-batch`);
+        url.searchParams.set('batchId', batchId);
+        url.searchParams.set('batchNumber', batchNumber.toString());
+        url.searchParams.set('batchSize', this.config.batchSize.toString());
+
+        const { data } = await this.makeRequest<BatchResponse>(url.toString(), {
+          method: 'POST',
+        });
 
         if (data.success) {
           console.log(`✅ Batch ${batchNumber} completed successfully`);
@@ -124,7 +173,7 @@ class BatchSnapshotOrchestrator {
     return null;
   }
 
-  async run() {
+  public async run(): Promise<BatchResults> {
     const startTime = Date.now();
     const batchId = `snapshot-${Date.now()}`;
 
@@ -152,10 +201,8 @@ class BatchSnapshotOrchestrator {
       // Process remaining batches
       for (let batchNumber = 2; batchNumber <= this.results.totalBatches; batchNumber++) {
         // Delay between batches to prevent overwhelming the server
-        if (batchNumber > 2) {
-          console.log(`⏳ Waiting ${this.config.delayBetweenBatches}s before next batch...`);
-          await this.delay(this.config.delayBetweenBatches);
-        }
+        console.log(`⏳ Waiting ${this.config.delayBetweenBatches}s before next batch...`);
+        await this.delay(this.config.delayBetweenBatches);
 
         const batchProgress = await this.processBatch(batchNumber, batchId);
 
@@ -204,7 +251,7 @@ class BatchSnapshotOrchestrator {
 }
 
 // Main execution
-async function main() {
+async function main(): Promise<void> {
   try {
     const orchestrator = new BatchSnapshotOrchestrator();
     await orchestrator.run();
@@ -217,7 +264,7 @@ async function main() {
 }
 
 // Export for use in other modules
-export { BatchSnapshotOrchestrator };
+export { BatchSnapshotOrchestrator, type BatchResults, type BatchProgress, type BatchConfig };
 
 // Run if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {

scripts/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "batch-snapshot-orchestrator",
+  "version": "1.0.0",
+  "description": "Batch snapshot orchestrator for wallet balance snapshots",
+  "type": "module",
+  "scripts": {
+    "start": "tsx batch-snapshot-orchestrator.ts"
+  },
+  "dependencies": {
+    "tsx": "^4.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

src/pages/api/v1/stats/run-snapshots-batch.ts

@@ -75,24 +75,28 @@ export default async function handler(
     return res.status(401).json({ error: "Unauthorized" });
   }
 
-  const { batchId, batchNumber, batchSize = 10 } = req.body;
+  const { batchId, batchNumber, batchSize } = req.query;
   const startTime = new Date().toISOString();
 
+  // Convert string parameters to numbers
+  const parsedBatchNumber = batchNumber ? parseInt(batchNumber as string, 10) : 1;
+  const parsedBatchSize = batchSize ? parseInt(batchSize as string, 10) : 10;
+
   try {
-    console.log(`🔄 Starting batch ${batchNumber || 1} of balance snapshots...`);
+    console.log(`🔄 Starting batch ${parsedBatchNumber} of balance snapshots...`);
 
     // Step 1: Get total wallet count and calculate batches
     const totalWallets = await db.wallet.count();
-    const totalBatches = Math.ceil(totalWallets / batchSize);
-    const currentBatch = batchNumber || 1;
-    const offset = (currentBatch - 1) * batchSize;
+    const totalBatches = Math.ceil(totalWallets / parsedBatchSize);
+    const currentBatch = parsedBatchNumber;
+    const offset = (currentBatch - 1) * parsedBatchSize;
 
-    console.log(`📊 Processing batch ${currentBatch}/${totalBatches} (${batchSize} wallets per batch)`);
+    console.log(`📊 Processing batch ${currentBatch}/${totalBatches} (${parsedBatchSize} wallets per batch)`);
 
     // Step 2: Fetch wallets for this batch
     const wallets: DbWallet[] = await db.wallet.findMany({
       skip: offset,
-      take: batchSize,
+      take: parsedBatchSize,
       orderBy: { id: 'asc' }, // Consistent ordering
     });
 
@@ -101,7 +105,7 @@ export default async function handler(
         success: true,
         message: "No wallets found in this batch",
         progress: {
-          batchId: batchId || `batch-${currentBatch}`,
+          batchId: (batchId as string) || `batch-${currentBatch}`,
           totalBatches,
           currentBatch,
           walletsInBatch: 0,
@@ -281,8 +285,8 @@ export default async function handler(
 
     // Step 5: Calculate progress
     const isComplete = currentBatch >= totalBatches;
-    const totalProcessed = (currentBatch - 1) * batchSize + processedInBatch;
-    const totalFailed = (currentBatch - 1) * batchSize + failedInBatch;
+    const totalProcessed = (currentBatch - 1) * parsedBatchSize + processedInBatch;
+    const totalFailed = (currentBatch - 1) * parsedBatchSize + failedInBatch;
 
     console.log(`📊 Batch ${currentBatch}/${totalBatches} completed:`);
     console.log(`   • Processed: ${processedInBatch}/${wallets.length}`);
@@ -292,7 +296,7 @@ export default async function handler(
     console.log(`   • Overall progress: ${totalProcessed}/${totalWallets} wallets`);
 
     const progress: BatchProgress = {
-      batchId: batchId || `batch-${currentBatch}`,
+      batchId: (batchId as string) || `batch-${currentBatch}`,
       totalBatches,
       currentBatch,
       walletsInBatch: wallets.length,
@@ -326,9 +330,9 @@ export default async function handler(
       success: false,
       message: `Batch snapshot process failed: ${errorMessage}`,
       progress: {
-        batchId: batchId || `batch-${batchNumber || 1}`,
+        batchId: (batchId as string) || `batch-${parsedBatchNumber}`,
         totalBatches: 0,
-        currentBatch: batchNumber || 1,
+        currentBatch: parsedBatchNumber,
         walletsInBatch: 0,
         processedInBatch: 0,
         failedInBatch: 0,