more 25 api added Done

Author: backendwithvishal

docker-compose.yml

@@ -27,6 +27,10 @@ services:
       ANALYSIS_QUEUE: ${ANALYSIS_QUEUE}
       ALERT_QUEUE: ${ALERT_QUEUE}
       DLX_EXCHANGE: ${DLX_EXCHANGE}
+      NOTIFICATION_QUEUE: ${NOTIFICATION_QUEUE:-lexai.notification.queue}
+      ANALYTICS_EVENTS_QUEUE: ${ANALYTICS_EVENTS_QUEUE:-lexai.analytics.queue}
+      ORDER_QUEUE: ${ORDER_QUEUE:-lexai.order.queue}
+      REVIEW_QUEUE: ${REVIEW_QUEUE:-lexai.review.queue}
 
       # ── PASETO ──
       PASETO_LOCAL_SECRET: ${PASETO_LOCAL_SECRET}
@@ -113,6 +117,10 @@ services:
       ANALYSIS_QUEUE: ${ANALYSIS_QUEUE}
       ALERT_QUEUE: ${ALERT_QUEUE}
       DLX_EXCHANGE: ${DLX_EXCHANGE}
+      NOTIFICATION_QUEUE: ${NOTIFICATION_QUEUE:-lexai.notification.queue}
+      ANALYTICS_EVENTS_QUEUE: ${ANALYTICS_EVENTS_QUEUE:-lexai.analytics.queue}
+      ORDER_QUEUE: ${ORDER_QUEUE:-lexai.order.queue}
+      REVIEW_QUEUE: ${REVIEW_QUEUE:-lexai.review.queue}
 
       # ── OpenRouter AI ──
       OPENROUTER_API_KEY: ${OPENROUTER_API_KEY}

src/config/env.js

@@ -45,6 +45,10 @@ const envSchema = z.object({
   ANALYSIS_QUEUE: z.string().default('lexai.analysis.queue'),
   ALERT_QUEUE: z.string().default('lexai.alert.queue'),
   DLX_EXCHANGE: z.string().default('lexai.dlx'),
+  NOTIFICATION_QUEUE: z.string().default('lexai.notification.queue'),
+  ANALYTICS_EVENTS_QUEUE: z.string().default('lexai.analytics.queue'),
+  ORDER_QUEUE: z.string().default('lexai.order.queue'),
+  REVIEW_QUEUE: z.string().default('lexai.review.queue'),
 
   // ─── PASETO ───────────────────────────────────────────────
   PASETO_LOCAL_SECRET: z.string().min(32, 'PASETO_LOCAL_SECRET must be at least 32 characters'),

src/config/rabbitmq.js

@@ -80,6 +80,23 @@ export async function connectRabbitMQ(url) {
         const alertQueue = process.env.ALERT_QUEUE || 'lexai.alert.queue';
         await channel.assertQueue(alertQueue, { durable: true });
 
+        // ─── New Module Queues ──────────────────────────────────────
+        // Notification consumer queue — processes order/review events
+        const notificationQueue = process.env.NOTIFICATION_QUEUE || 'lexai.notification.queue';
+        await channel.assertQueue(notificationQueue, { durable: true });
+
+        // Analytics event consumer queue — async aggregation
+        const analyticsEventsQueue = process.env.ANALYTICS_EVENTS_QUEUE || 'lexai.analytics.queue';
+        await channel.assertQueue(analyticsEventsQueue, { durable: true });
+
+        // Order event queue
+        const orderQueue = process.env.ORDER_QUEUE || 'lexai.order.queue';
+        await channel.assertQueue(orderQueue, { durable: true });
+
+        // Review event queue
+        const reviewQueue = process.env.REVIEW_QUEUE || 'lexai.review.queue';
+        await channel.assertQueue(reviewQueue, { durable: true });
+
         logger.info('RabbitMQ queues and exchanges asserted');
     } catch (err) {
         logger.error('RabbitMQ connection failed:', err.message);

src/constants/queues.js

@@ -12,6 +12,12 @@ export const QUEUES = Object.freeze({
     ALERT: 'lexai.alert.queue',            // Contract expiry alert job queue
     DLX_EXCHANGE: 'lexai.dlx',             // Dead Letter Exchange for failed jobs
     DLQ_ANALYSIS: 'lexai.analysis.dlq',    // Dead Letter Queue — holds permanently failed analysis jobs
+
+    // ─── New Module Queues ──────────────────────────────────
+    NOTIFICATION: 'lexai.notification.queue',  // Notification consumer queue
+    ANALYTICS_EVENTS: 'lexai.analytics.queue', // Analytics aggregation consumer queue
+    ORDER: 'lexai.order.queue',                // Order event queue
+    REVIEW: 'lexai.review.queue',              // Review event queue
 });
 
 // Redis Pub/Sub channel used by workers to push real-time events

src/controllers/analytics.controller.js

@@ -0,0 +1,40 @@
+/**
+ * Analytics Controller
+ *
+ * Thin HTTP layer for analytics endpoints.
+ * All aggregation logic lives in analytics.service.js.
+ * Admin-only — requires authorize('admin') middleware.
+ */
+
+import * as analyticsService from '../services/analytics.service.js';
+import { sendSuccess } from '../utils/apiResponse.js';
+
+/** GET /analytics/sales — Sales analytics */
+export async function getSalesAnalytics(req, res) {
+    const data = await analyticsService.getSalesAnalytics(req.query);
+    sendSuccess(res, { data });
+}
+
+/** GET /analytics/products — Product performance analytics */
+export async function getProductAnalytics(req, res) {
+    const data = await analyticsService.getProductAnalytics(req.query);
+    sendSuccess(res, { data });
+}
+
+/** GET /analytics/users — User activity analytics */
+export async function getUserActivityAnalytics(req, res) {
+    const data = await analyticsService.getUserActivityAnalytics(req.query);
+    sendSuccess(res, { data });
+}
+
+/** GET /analytics/revenue — Revenue trend analytics */
+export async function getRevenueAnalytics(req, res) {
+    const data = await analyticsService.getRevenueAnalytics(req.query);
+    sendSuccess(res, { data });
+}
+
+/** GET /analytics/top-products — Top products by sales */
+export async function getTopProducts(req, res) {
+    const data = await analyticsService.getTopProducts(req.query);
+    sendSuccess(res, { data });
+}

src/controllers/notification.controller.js

@@ -3,9 +3,11 @@
  *
  * Handles CRUD operations for in-app notifications:
  *   - List org notifications with pagination
+ *   - List user-specific notifications with pagination
  *   - Mark individual notification as read
  *   - Mark all notifications as read (bulk)
  *   - Get unread count for badge display
+ *   - Delete a notification
  */
 
 import Notification from '../models/Notification.model.js';
@@ -95,3 +97,56 @@ export async function markAllAsRead(req, res) {
 
     sendSuccess(res, { message: 'All notifications marked as read.', data: { modifiedCount: result.modifiedCount } });
 }
+
+/**
+ * GET /notifications/user
+ * List notifications for the authenticated user (user-scoped, not org-scoped).
+ */
+export async function getUserNotifications(req, res) {
+    const { userId } = req.user;
+    const { page = 1, limit = 20, read, type } = req.query;
+
+    const filter = { userId };
+
+    if (read !== undefined) {
+        filter.read = read === 'true';
+    }
+    if (type) {
+        filter.type = type;
+    }
+
+    const skip = (page - 1) * limit;
+
+    const [notifications, total] = await Promise.all([
+        Notification.find(filter)
+            .sort({ createdAt: -1 })
+            .skip(skip)
+            .limit(parseInt(limit))
+            .lean(),
+        Notification.countDocuments(filter),
+    ]);
+
+    const meta = buildPaginationMeta(total, parseInt(page), parseInt(limit));
+
+    sendSuccess(res, { data: { notifications, meta } });
+}
+
+/**
+ * DELETE /notifications/:id
+ * Delete a notification.
+ */
+export async function deleteNotification(req, res) {
+    const { userId } = req.user;
+    const { id } = req.params;
+
+    const notification = await Notification.findOneAndDelete({ _id: id, userId });
+
+    if (!notification) {
+        return res.status(HTTP.NOT_FOUND).json({
+            success: false,
+            error: { code: 'NOT_FOUND', message: 'Notification not found.' },
+        });
+    }
+
+    sendSuccess(res, { message: 'Notification deleted.' });
+}

src/controllers/order.controller.js

@@ -0,0 +1,58 @@
+/**
+ * Order Controller
+ *
+ * Thin HTTP layer for order operations.
+ * All business logic (stock validation, status transitions) lives in order.service.js.
+ */
+
+import * as orderService from '../services/order.service.js';
+import { sendSuccess } from '../utils/apiResponse.js';
+import HTTP from '../constants/httpStatus.js';
+
+/** POST /orders — Create a new order */
+export async function createOrder(req, res) {
+    const order = await orderService.createOrder(req.user.userId, req.body);
+    sendSuccess(res, {
+        statusCode: HTTP.CREATED,
+        message: 'Order placed successfully.',
+        data: { order },
+    });
+}
+
+/** GET /orders — List user orders with pagination */
+export async function listOrders(req, res) {
+    const { orders, meta } = await orderService.listUserOrders(req.user.userId, req.query);
+    sendSuccess(res, { data: { orders, meta } });
+}
+
+/** GET /orders/stats — Get order stats for user */
+export async function getOrderStats(req, res) {
+    const stats = await orderService.getOrderStats(req.user.userId);
+    sendSuccess(res, { data: { stats } });
+}
+
+/** GET /orders/:id — Get order by ID */
+export async function getOrder(req, res) {
+    const order = await orderService.getOrderById(req.params.id, req.user.userId);
+    sendSuccess(res, { data: { order } });
+}
+
+/** PATCH /orders/:id/status — Update order status */
+export async function updateOrderStatus(req, res) {
+    const order = await orderService.updateOrderStatus(
+        req.params.id,
+        req.user.userId,
+        req.body.status
+    );
+    sendSuccess(res, { message: 'Order status updated.', data: { order } });
+}
+
+/** PATCH /orders/:id/cancel — Cancel an order */
+export async function cancelOrder(req, res) {
+    const order = await orderService.cancelOrder(
+        req.params.id,
+        req.user.userId,
+        req.body.reason
+    );
+    sendSuccess(res, { message: 'Order cancelled successfully.', data: { order } });
+}

src/controllers/product.controller.js

@@ -0,0 +1,50 @@
+/**
+ * Product Controller
+ *
+ * Thin HTTP layer for product CRUD, search, and listing.
+ * All business logic lives in product.service.js.
+ */
+
+import * as productService from '../services/product.service.js';
+import { sendSuccess } from '../utils/apiResponse.js';
+import HTTP from '../constants/httpStatus.js';
+
+/** POST /products — Create a new product */
+export async function createProduct(req, res) {
+    const product = await productService.createProduct(req.user.userId, req.body);
+    sendSuccess(res, {
+        statusCode: HTTP.CREATED,
+        message: 'Product created successfully.',
+        data: { product },
+    });
+}
+
+/** GET /products — List products with pagination, filtering, sorting */
+export async function listProducts(req, res) {
+    const { products, meta } = await productService.listProducts(req.query);
+    sendSuccess(res, { data: { products, meta } });
+}
+
+/** GET /products/search — Full-text search products */
+export async function searchProducts(req, res) {
+    const { products, meta } = await productService.searchProducts(req.query);
+    sendSuccess(res, { data: { products, meta } });
+}
+
+/** GET /products/:id — Get product by ID */
+export async function getProduct(req, res) {
+    const product = await productService.getProductById(req.params.id);
+    sendSuccess(res, { data: { product } });
+}
+
+/** PATCH /products/:id — Update product (owner only) */
+export async function updateProduct(req, res) {
+    const product = await productService.updateProduct(req.params.id, req.user.userId, req.body);
+    sendSuccess(res, { message: 'Product updated successfully.', data: { product } });
+}
+
+/** DELETE /products/:id — Delete product (owner only) */
+export async function deleteProduct(req, res) {
+    await productService.deleteProduct(req.params.id, req.user.userId);
+    sendSuccess(res, { message: 'Product deleted successfully.' });
+}

src/controllers/review.controller.js

@@ -0,0 +1,41 @@
+/**
+ * Review Controller
+ *
+ * Thin HTTP layer for review CRUD.
+ * All business logic (rating recalculation, duplicate detection) lives in review.service.js.
+ */
+
+import * as reviewService from '../services/review.service.js';
+import { sendSuccess } from '../utils/apiResponse.js';
+import HTTP from '../constants/httpStatus.js';
+
+/** POST /reviews — Add a review */
+export async function addReview(req, res) {
+    const review = await reviewService.addReview(req.user.userId, req.body);
+    sendSuccess(res, {
+        statusCode: HTTP.CREATED,
+        message: 'Review added successfully.',
+        data: { review },
+    });
+}
+
+/** GET /reviews/product/:productId — Get product reviews */
+export async function getProductReviews(req, res) {
+    const { reviews, meta } = await reviewService.getProductReviews(
+        req.params.productId,
+        req.query
+    );
+    sendSuccess(res, { data: { reviews, meta } });
+}
+
+/** GET /reviews/my — Get authenticated user's reviews */
+export async function getMyReviews(req, res) {
+    const { reviews, meta } = await reviewService.getUserReviews(req.user.userId, req.query);
+    sendSuccess(res, { data: { reviews, meta } });
+}
+
+/** DELETE /reviews/:id — Delete a review (author only) */
+export async function deleteReview(req, res) {
+    await reviewService.deleteReview(req.params.id, req.user.userId);
+    sendSuccess(res, { message: 'Review deleted successfully.' });
+}

src/models/Notification.model.js

@@ -25,7 +25,7 @@ const notificationSchema = new mongoose.Schema(
         },
         type: {
             type: String,
-            enum: ['analysis_complete', 'analysis_failed', 'contract_expiring', 'quota_warning', 'invitation'],
+            enum: ['analysis_complete', 'analysis_failed', 'contract_expiring', 'quota_warning', 'invitation', 'order_created', 'order_updated', 'review_added'],
             required: true,
         },
         channel: {