up

Author: rezwana-karim

package-lock.json

@@ -104,6 +104,7 @@
     "autoprefixer": "^10.4.20",
     "eslint": "^8.57.1",
     "eslint-config-next": "^14.2.15",
+    "jest-mock-extended": "^4.0.0",
     "jsdom": "^25.0.0",
     "postcss": "^8.5.6",
     "prettier": "^3.3.0",

package.json

@@ -351,7 +351,7 @@ export function TopProducts({
                   outerRadius={120}
                   fill="#8884d8"
                   dataKey="value"
-                  label={({ name, percent }: { name: string; percent: number }) => `${name}: ${(percent * 100).toFixed(1)}%`}
+                  label={(props: any) => `${props.name}: ${(props.percent * 100).toFixed(1)}%`}
                   labelLine={false}
                 >
                   {getPieData().map((entry, index) => (

src/components/analytics/top-products.tsx

@@ -0,0 +1,14 @@
+// Minimal useToast hook used by components in tests/dev
+// Provides a no-op toast in server/test environments and a simple wrapper in client
+
+export default function useToast() {
+  function toast({ title, description }: { title?: string; description?: string }) {
+    if (typeof window !== 'undefined' && (window as any).console) {
+      // Lightweight: log to console in dev; real app should replace with Radix toast
+      // eslint-disable-next-line no-console
+      console.info('[toast]', title, description);
+    }
+  }
+
+  return { toast };
+}

src/hooks/use-toast.ts

@@ -344,4 +344,104 @@ export default {
   getUpgradeRecommendations,
   PLAN_ENFORCEMENT_ERRORS,
   isPlanEnforcementError,
-};
+};
+
+// Compatibility implementations for legacy test/api usage
+// Legacy helpers used by older tests and route handlers
+export async function checkProductCreationLimit(request: NextRequest): Promise<null | NextResponse> {
+  try {
+    const session = await getSessionFromRequest(request);
+    if (!session) {
+      return NextResponse.json({ error: { code: 'UNAUTHORIZED', message: 'Authentication required' } }, { status: 401 });
+    }
+
+    const storeId = (session as any).storeId;
+    if (!storeId) {
+      return NextResponse.json({ error: { code: 'MISSING_STORE_ID', message: 'Store ID is required' } }, { status: 400 });
+    }
+
+    try {
+      const result = await SubscriptionService.canCreateProduct(storeId);
+      if (result && (result as any).allowed) {
+        return null;
+      }
+
+      return NextResponse.json({ error: { code: 'PLAN_LIMIT_EXCEEDED', message: 'Product creation limit exceeded for your current plan' } }, { status: 403 });
+    } catch (err) {
+      console.error('checkProductCreationLimit error', err);
+      return NextResponse.json({ error: { code: 'PLAN_CHECK_FAILED', message: 'Failed to check plan limits' } }, { status: 500 });
+    }
+  } catch (err) {
+    console.error('checkProductCreationLimit unexpected error', err);
+    return NextResponse.json({ error: { code: 'ENFORCEMENT_ERROR', message: 'Failed to check plan limits' } }, { status: 500 });
+  }
+}
+
+export async function checkOrderCreationLimit(request: NextRequest): Promise<null | NextResponse> {
+  try {
+    const session = await getSessionFromRequest(request);
+    if (!session) {
+      return NextResponse.json({ error: { code: 'UNAUTHORIZED', message: 'Authentication required' } }, { status: 401 });
+    }
+
+    const storeId = (session as any).storeId;
+    if (!storeId) {
+      return NextResponse.json({ error: { code: 'MISSING_STORE_ID', message: 'Store ID is required' } }, { status: 400 });
+    }
+
+    try {
+      const result = await SubscriptionService.canCreateOrder(storeId);
+      if (result && (result as any).allowed) {
+        return null;
+      }
+
+      return NextResponse.json({ error: { code: 'PLAN_LIMIT_EXCEEDED', message: 'Order creation limit exceeded for your current plan' } }, { status: 403 });
+    } catch (err) {
+      console.error('checkOrderCreationLimit error', err);
+      return NextResponse.json({ error: { code: 'PLAN_CHECK_FAILED', message: 'Failed to check plan limits' } }, { status: 500 });
+    }
+  } catch (err) {
+    console.error('checkOrderCreationLimit unexpected error', err);
+    return NextResponse.json({ error: { code: 'ENFORCEMENT_ERROR', message: 'Failed to check plan limits' } }, { status: 500 });
+  }
+}
+
+export async function enforcePlanLimits(
+  request: NextRequest,
+  handler: (request: NextRequest, context?: any) => Promise<NextResponse>,
+  resource: 'product' | 'order'
+): Promise<NextResponse> {
+  // Validate resource
+  if (resource !== 'product' && resource !== 'order') {
+    return NextResponse.json({ error: { code: 'INVALID_RESOURCE_TYPE', message: 'Invalid resource type for plan enforcement' } }, { status: 400 });
+  }
+
+  // Allow safe methods without enforcement
+  const method = (request && (request as any).method) || 'GET';
+  if (['GET', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
+    return await handler(request);
+  }
+
+  // Run appropriate check
+  if (resource === 'product') {
+    const check = await checkProductCreationLimit(request);
+    if (check) return check as NextResponse;
+  } else {
+    const check = await checkOrderCreationLimit(request);
+    if (check) return check as NextResponse;
+  }
+
+  // Allowed, call handler
+  return await handler(request);
+}
+
+export function withPlanLimits(
+  handler: (request: NextRequest, context?: any) => Promise<NextResponse>,
+  resource: 'product' | 'order'
+) {
+  return async (request: NextRequest, context?: any) => {
+    // Delegate to enforcePlanLimits which will call the handler when allowed
+    const result = await enforcePlanLimits(request, (req) => handler(req, context), resource);
+    return result;
+  };
+}

src/lib/plan-enforcement.ts

@@ -101,7 +101,7 @@ export function sanitizeHtml(
     ALLOW_ARIA_ATTR: true, // Allow ARIA for accessibility
     RETURN_DOM: false, // Return string (not DOM)
     RETURN_DOM_FRAGMENT: false,
-  });
+  } as any);
 }
 
 /**
@@ -126,11 +126,11 @@ export function stripHtml(html: string): string {
   }
 
   // Use DOMPurify with ALLOWED_TAGS: [] to strip everything
-  return DOMPurify.sanitize(html, {
+  return (DOMPurify.sanitize(html, {
     ALLOWED_TAGS: [], // No tags allowed
     ALLOWED_ATTR: [], // No attributes allowed
     KEEP_CONTENT: true, // Keep text content
-  }).trim();
+  } as any) as string).trim();
 }
 
 /**

src/lib/sanitize.ts

@@ -0,0 +1,7 @@
+import { createMock } from 'jest-mock-extended';
+import { PrismaClient } from '@prisma/client';
+
+// Provide a typed mocked Prisma client for tests to import
+export const mockedPrisma = createMock<PrismaClient>();
+
+export default mockedPrisma;

tests/__mocks__/mockPrisma.ts

@@ -0,0 +1,24 @@
+// Test fixtures helpers used across unit tests
+import { Session, User } from '@/types';
+
+export function buildUser(overrides?: Partial<User>): User {
+  return {
+    id: 'user_1',
+    email: 'user@example.com',
+    name: 'Test User',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  } as unknown as User;
+}
+
+export function buildSession(overrides?: Partial<Session>): Session {
+  return {
+    id: 'sess_1',
+    userId: 'user_1',
+    storeId: 'store_1',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  } as unknown as Session;
+}