fix: ensure proper cleanup of SSE events with AbortController

README.md

@@ -6,6 +6,8 @@
 
 _Programmable, real-time payment streams and recurring subscriptions._
 
+i just need to create a draft pr
+
 ## Overview
 
 FlowFi allows users to create continuous payment streams and recurring subscriptions using stablecoins on the Stellar network. By leveraging Soroban smart contracts, FlowFi enables autonomous accurate-to-the-second distribution of funds.

backend/src/controllers/stream.controller.ts

@@ -12,6 +12,10 @@ import {
   resumeStream as sorobanResumeStream,
 } from '../services/sorobanService.js';
 import type { AuthenticatedRequest } from '../types/auth.types.js';
+import { DEFAULT_EVENTS_PAGE_SIZE, MAX_EVENTS_PAGE_SIZE } from '../routes/v1/events.routes.js';
+
+const DEFAULT_STREAM_PAGE_SIZE = 20;
+const MAX_STREAM_PAGE_SIZE = 100;
 
 interface UserStreamSummary {
   address: string;
@@ -170,8 +174,8 @@ export const listStreams = async (req: Request, res: Response) => {
 
     // Validate and parse pagination parameters
     const parsedLimit = Math.min(
-      typeof limit === 'string' ? (Number.parseInt(limit, 10) || 20) : 20,
-      100
+      typeof limit === 'string' ? (Number.parseInt(limit, 10) || DEFAULT_STREAM_PAGE_SIZE) : DEFAULT_STREAM_PAGE_SIZE,
+      MAX_STREAM_PAGE_SIZE
     );
     const parsedOffset = typeof offset === 'string' ? (Number.parseInt(offset, 10) || 0) : 0;
 
@@ -285,8 +289,8 @@ export const getStreamEvents = async (req: Request, res: Response) => {
     const eventType = typeof req.query['eventType'] === 'string' ? req.query['eventType'] : undefined;
 
     const limit = Math.min(
-      rawLimit && typeof rawLimit === 'string' ? (Number.parseInt(rawLimit, 10) || 50) : 50,
-      500,
+      rawLimit && typeof rawLimit === 'string' ? (Number.parseInt(rawLimit, 10) || DEFAULT_EVENTS_PAGE_SIZE) : DEFAULT_EVENTS_PAGE_SIZE,
+      MAX_EVENTS_PAGE_SIZE,
     );
 
     let offset = 0;

backend/src/controllers/user.controller.ts

@@ -3,6 +3,7 @@ import { prisma } from '../lib/prisma.js';
 import logger from '../logger.js';
 import { registerUserSchema } from '../validators/user.validator.js';
 import type { AuthenticatedRequest } from '../types/auth.types.js';
+import { DEFAULT_EVENTS_PAGE_SIZE, MAX_EVENTS_PAGE_SIZE } from '../routes/v1/events.routes.js';
 
 /**
  * Register a new wallet public key
@@ -81,8 +82,8 @@ export const getUserEvents = async (req: Request, res: Response, next: NextFunct
         const rawOffset = req.query['offset'];
 
         const limit = Math.min(
-            rawLimit && typeof rawLimit === 'string' ? (Number.parseInt(rawLimit, 10) || 50) : 50,
-            200
+            rawLimit && typeof rawLimit === 'string' ? (Number.parseInt(rawLimit, 10) || DEFAULT_EVENTS_PAGE_SIZE) : DEFAULT_EVENTS_PAGE_SIZE,
+            MAX_EVENTS_PAGE_SIZE
         );
         const offset = rawOffset && typeof rawOffset === 'string' ? (Number.parseInt(rawOffset, 10) || 0) : 0;
 

backend/src/middleware/error.middleware.ts

@@ -1,13 +1,13 @@
 import type { Request, Response, NextFunction } from 'express';
 import { Prisma } from '../generated/prisma/index.js';
-import { ZodError } from 'zod';
+import { ZodError, type ZodIssue } from 'zod';
 import logger from '../logger.js';
 
 /**
  * Global error handler middleware
  */
 export const errorHandler = (
-    err: any,
+    err: unknown,
     req: Request,
     res: Response,
     next: NextFunction
@@ -18,7 +18,7 @@ export const errorHandler = (
     if (err instanceof ZodError) {
         return res.status(400).json({
             error: 'Validation Error',
-            details: err.issues.map((e: any) => ({
+            details: err.issues.map((e: ZodIssue) => ({
                 path: e.path.join('.'),
                 message: e.message
             }))
@@ -28,26 +28,26 @@ export const errorHandler = (
     // Handle Prisma Errors
     if (err instanceof Prisma.PrismaClientKnownRequestError) {
         // Unique constraint violation
-        if (err.code === 'P2002') {
-            const target = (err.meta?.target as string[])?.join(', ') || 'field';
+        if ((err as Prisma.PrismaClientKnownRequestError).code === 'P2002') {
+            const target = ((err as Prisma.PrismaClientKnownRequestError).meta?.target as string[])?.join(', ') || 'field';
             return res.status(409).json({
                 error: 'Conflict Error',
                 message: `Record with this ${target} already exists.`
             });
         }
 
         // Record not found
-        if (err.code === 'P2025') {
+        if ((err as Prisma.PrismaClientKnownRequestError).code === 'P2025') {
             return res.status(404).json({
                 error: 'Not Found',
-                message: err.message || 'The requested record was not found.'
+                message: (err as Prisma.PrismaClientKnownRequestError).message || 'The requested record was not found.'
             });
         }
     }
 
     // Default Error
-    const statusCode = err.status || err.statusCode || 500;
-    const message = err.message || 'Internal Server Error';
+    const statusCode = (err instanceof Error && (err as any).status) || (err instanceof Error && (err as any).statusCode) || 500;
+    const message = err instanceof Error ? err.message : 'Internal Server Error';
 
     res.status(statusCode).json({
         error: statusCode === 500 ? 'Internal Server Error' : 'Error',

backend/src/routes/v1/events.routes.ts

@@ -21,8 +21,8 @@ const EVENT_TYPES = new Set([
   'ADMIN_TRANSFERRED',
 ]);
 
-const MAX_EVENT_LIMIT = 200;
-const DEFAULT_EVENT_LIMIT = 50;
+export const MAX_EVENTS_PAGE_SIZE = 200;
+export const DEFAULT_EVENTS_PAGE_SIZE = 50;
 
 /**
  * @openapi
@@ -86,8 +86,8 @@ router.get('/', async (req: Request, res: Response, next: NextFunction) => {
 
     const parsedLimit = Number.parseInt(String(req.query.limit ?? ''), 10);
     const limit = Number.isFinite(parsedLimit) && parsedLimit > 0
-      ? Math.min(parsedLimit, MAX_EVENT_LIMIT)
-      : DEFAULT_EVENT_LIMIT;
+      ? Math.min(parsedLimit, MAX_EVENTS_PAGE_SIZE)
+      : DEFAULT_EVENTS_PAGE_SIZE;
 
     const hasOffset = req.query.offset !== undefined;
     const parsedOffset = Number.parseInt(String(req.query.offset ?? ''), 10);