merge: resolve conflict in server.ts - keep both feature and main imports

Author: wheval

wata-board-dapp/README_TESTING.md

@@ -20,13 +20,15 @@
     "dotenv": "^16.4.5",
     "express": "^4.18.2",
     "cors": "^2.8.5",
-    "helmet": "^7.0.0"
+    "helmet": "^7.0.0",
+    "ws": "^8.13.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
     "@types/node": "^20.11.0",
     "@types/express": "^4.17.17",
     "@types/cors": "^2.8.13",
+    "@types/ws": "^8.5.6",
     "@types/supertest": "^6.0.2",
     "jest": "^29.7.0",
     "supertest": "^6.3.4",

wata-board-dapp/package.json

@@ -0,0 +1,13 @@
+import { AnalyticsService } from '../services/analyticsService';
+
+describe('AnalyticsService', () => {
+  it('generates a consistent analytics report', () => {
+    const report = AnalyticsService.generateReport('demo-user');
+    expect(report.userId).toBe('demo-user');
+    expect(report.totalSpendMonthly).toBeGreaterThan(0);
+    expect(report.monthlyTrend).toHaveLength(6);
+    expect(report.yearlyTrend).toHaveLength(5);
+    expect(report.utilityUsageBreakdown).toHaveProperty('water');
+    expect(report.predictiveInsight).toContain('Spending is expected');
+  });
+});

wata-board-dapp/src/__tests__/analyticsService.test.ts

@@ -0,0 +1,25 @@
+import { handleClientError } from '../middleware/errorHandler';
+
+describe('Error Handler Middleware', () => {
+  it('returns a success response when client errors are reported', () => {
+    const req = {
+      body: {
+        message: 'Client crash',
+        stack: 'Error stack'
+      },
+      path: '/api/client-errors',
+      ip: '127.0.0.1',
+      get: jest.fn().mockReturnValue('Mozilla/5.0')
+    } as any;
+
+    const json = jest.fn();
+    const res = {
+      status: jest.fn().mockReturnValue({ json })
+    } as any;
+
+    handleClientError(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(202);
+    expect(json).toHaveBeenCalledWith({ success: true, message: 'Client error logged' });
+  });
+});

wata-board-dapp/src/__tests__/errorHandler.test.ts

@@ -0,0 +1,18 @@
+import request from 'supertest';
+import app from '../server';
+
+describe('API Integration', () => {
+  it('returns analytics report on /api/analytics/:userId', async () => {
+    const response = await request(app).get('/api/analytics/test-user');
+    expect(response.status).toBe(200);
+    expect(response.body.userId).toBe('test-user');
+    expect(response.body.totalSpendMonthly).toBeGreaterThan(0);
+  });
+
+  it('returns transaction status on /api/transaction-status/:transactionId', async () => {
+    const response = await request(app).get('/api/transaction-status/test-tx');
+    expect(response.status).toBe(200);
+    expect(response.body).toMatchObject({ success: true, transactionId: 'test-tx' });
+    expect(['pending', 'confirming', 'confirmed', 'failed']).toContain(response.body.status);
+  });
+});

wata-board-dapp/src/__tests__/server.integration.test.ts

@@ -0,0 +1,12 @@
+import { getTransactionStatus, updateTransactionStatus } from '../services/websocketService';
+
+describe('WebSocket Transaction Status Store', () => {
+  it('stores and retrieves transaction details correctly', () => {
+    updateTransactionStatus('tx-123', 'confirming');
+    expect(getTransactionStatus('tx-123')).toBe('confirming');
+  });
+
+  it('returns pending for unknown transactions', () => {
+    expect(getTransactionStatus('unknown-tx')).toBe('pending');
+  });
+});

wata-board-dapp/src/__tests__/websocketService.test.ts

@@ -0,0 +1,49 @@
+import express from 'express';
+import logger from '../utils/logger';
+
+export interface ClientErrorRequestBody {
+  message: string;
+  stack?: string;
+  componentStack?: string;
+  source?: string;
+  url?: string;
+  userAgent?: string;
+  extra?: Record<string, unknown>;
+}
+
+export const handleClientError = (req: express.Request, res: express.Response) => {
+  const payload = req.body as ClientErrorRequestBody;
+
+  logger.error('Client error reported', {
+    ...payload,
+    path: req.path,
+    ip: req.ip,
+    userAgent: req.get('user-agent')
+  });
+
+  res.status(202).json({ success: true, message: 'Client error logged' });
+};
+
+export const apiErrorHandler: express.ErrorRequestHandler = (err, req, res, next) => {
+  if (res.headersSent) {
+    return next(err);
+  }
+
+  if (err?.name === 'UnauthorizedError') {
+    return res.status(401).json({ success: false, error: 'Unauthorized' });
+  }
+
+  if (err?.message === 'Not allowed by CORS') {
+    return res.status(403).json({ success: false, error: 'CORS policy violation' });
+  }
+
+  logger.error('Unhandled server error', {
+    message: err?.message,
+    stack: err?.stack,
+    path: req.path,
+    method: req.method,
+    body: req.body
+  });
+
+  res.status(500).json({ success: false, error: 'Internal server error' });
+};

wata-board-dapp/src/middleware/errorHandler.ts

@@ -13,6 +13,9 @@ import { tieredRateLimiter } from './middleware/rateLimiter';
 import monitoringRoutes from './routes/monitoring';
 import upgradeRoutes from './routes/upgrade';
 import currencyRoutes from './routes/currency';
+import { handleClientError, apiErrorHandler } from './middleware/errorHandler';
+import { AnalyticsService } from './services/analyticsService';
+import { getTransactionStatus, startWebsocketService, updateTransactionStatus } from './services/websocketService';
 
 // Load environment variables
 dotenv.config();
@@ -96,6 +99,9 @@ app.use(cors(corsOptions));
 app.use(express.json({ limit: '10mb' }));
 app.use(express.urlencoded({ extended: true, limit: '10mb' }));
 
+// Client-side error logging endpoint
+app.post('/api/client-errors', handleClientError);
+
 // Request logging middleware
 app.use((req, res, next) => {
   logger.info('Incoming HTTP Request', { 
@@ -197,6 +203,9 @@ app.post('/api/payment', async (req, res) => {
     res.set('X-Rate-Limit-Remaining', result.rateLimitInfo?.remainingRequests?.toString() || '0');
 
     if (result.success) {
+      if (result.transactionId) {
+        updateTransactionStatus(result.transactionId, 'confirmed');
+      }
       return res.status(200).json({
         success: true,
         transactionId: result.transactionId,
@@ -206,6 +215,9 @@ app.post('/api/payment', async (req, res) => {
         }
       });
     } else {
+      if (result.transactionId) {
+        updateTransactionStatus(result.transactionId, 'failed');
+      }
       // Handle rate limit errors with appropriate status codes
       if (result.error?.includes('Rate limit exceeded')) {
         return res.status(429).json({
@@ -270,6 +282,44 @@ app.get('/api/rate-limit/:userId', (req, res) => {
   }
 });
 
+/**
+ * GET /api/analytics/:userId
+ * Provide analytics insights for a user
+ */
+app.get('/api/analytics/:userId', (req, res) => {
+  try {
+    const { userId } = req.params;
+    if (!userId) {
+      return res.status(400).json({ success: false, error: 'User ID is required' });
+    }
+
+    const analytics = AnalyticsService.generateReport(userId);
+    return res.status(200).json(analytics);
+  } catch (error) {
+    logger.error('Analytics report generation failed', { error, userId: req.params.userId });
+    return res.status(500).json({ success: false, error: 'Failed to generate analytics report' });
+  }
+});
+
+/**
+ * GET /api/transaction-status/:transactionId
+ * Return current transaction status for real-time updates.
+ */
+app.get('/api/transaction-status/:transactionId', (req, res) => {
+  try {
+    const { transactionId } = req.params;
+    if (!transactionId) {
+      return res.status(400).json({ success: false, error: 'Transaction ID is required' });
+    }
+
+    const status = getTransactionStatus(transactionId);
+    return res.status(200).json({ success: true, transactionId, status });
+  } catch (error) {
+    logger.error('Transaction status query failed', { error, transactionId: req.params.transactionId });
+    return res.status(500).json({ success: false, error: 'Unable to retrieve transaction status' });
+  }
+});
+
 /**
  * GET /api/payment/:meterId
  * Get total paid amount for a meter
@@ -316,27 +366,7 @@ app.get('/api/payment/:meterId', async (req, res) => {
 });
 
 // Error handling middleware
-app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
-  if (err.name === 'UnauthorizedError') {
-    return res.status(401).json({
-      success: false,
-      error: 'Unauthorized'
-    });
-  }
-
-  if (err.message === 'Not allowed by CORS') {
-    return res.status(403).json({
-      success: false,
-      error: 'CORS policy violation'
-    });
-  }
-  
-  logger.error('Unhandled server error', { err, method: req.method, path: req.path });
-  return res.status(500).json({
-    success: false,
-    error: 'Internal server error'
-  });
-});
+app.use(apiErrorHandler);
 
 // 404 handler
 app.use('*', (req, res) => {
@@ -424,6 +454,8 @@ function startServer() {
       });
     });
   }
+
+  startWebsocketService();
 }
 
 startServer();

wata-board-dapp/src/server.ts

@@ -0,0 +1,65 @@
+export interface AnalyticsTrendPoint {
+  label: string;
+  value: number;
+}
+
+export interface AnalyticsReport {
+  userId: string;
+  totalSpendYearly: number;
+  totalSpendMonthly: number;
+  paymentsThisMonth: number;
+  averagePayment: number;
+  utilityUsageBreakdown: Record<string, number>;
+  monthlyTrend: AnalyticsTrendPoint[];
+  yearlyTrend: AnalyticsTrendPoint[];
+  predictiveInsight: string;
+}
+
+function normalizePercentage(value: number, max: number) {
+  return Math.min(100, Math.max(0, Math.round((value / max) * 100)));
+}
+
+export class AnalyticsService {
+  static generateReport(userId: string): AnalyticsReport {
+    const base = Math.max(1, userId.length * 7);
+    const totalSpendMonthly = Number((base * 12.4).toFixed(2));
+    const totalSpendYearly = Number((totalSpendMonthly * 12).toFixed(2));
+    const paymentsThisMonth = Math.max(3, Math.round(base / 2));
+    const averagePayment = Number((totalSpendMonthly / paymentsThisMonth).toFixed(2));
+
+    const monthlyTrend = Array.from({ length: 6 }, (_, idx) => ({
+      label: `${6 - idx}m ago`,
+      value: Number((totalSpendMonthly * (0.7 + idx * 0.05)).toFixed(2))
+    })).reverse();
+
+    const yearlyTrend = Array.from({ length: 5 }, (_, idx) => ({
+      label: `${new Date().getFullYear() - (4 - idx)}`,
+      value: Number((totalSpendYearly * (0.78 + idx * 0.05)).toFixed(2))
+    }));
+
+    const usageWeights = {
+      water: normalizePercentage(base * 1.2, 20),
+      electricity: normalizePercentage(base * 1.6, 25),
+      waste: normalizePercentage(base * 0.9, 15),
+      internet: normalizePercentage(base * 0.8, 15),
+      gas: normalizePercentage(base * 1.1, 25)
+    };
+
+    const totalUsage = Object.values(usageWeights).reduce((sum, value) => sum + value, 0) || 1;
+    const utilityUsageBreakdown = Object.fromEntries(
+      Object.entries(usageWeights).map(([key, value]) => [key, Math.round((value / totalUsage) * 100)])
+    );
+
+    return {
+      userId,
+      totalSpendYearly,
+      totalSpendMonthly,
+      paymentsThisMonth,
+      averagePayment,
+      utilityUsageBreakdown,
+      monthlyTrend,
+      yearlyTrend,
+      predictiveInsight: `Spending is expected to remain ${paymentsThisMonth > 8 ? 'stable' : 'moderate'} over the next quarter with optimization opportunities on utility usage.`
+    };
+  }
+}