tango-app-api-audio-analytics 1.0.6 → 1.0.8

package/index.js

@@ -3,4 +3,3 @@
 import { audioAnalyticsrouter } from './src/routes/audioAnalytics.routes.js';
 
 export { audioAnalyticsrouter };
-

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audio-analytics",
-    "version": "1.0.6",
+    "version": "1.0.8",
     "description": "audioAnalytics",
     "main": "index.js",
     "type": "module",
@@ -13,11 +13,13 @@
     "author": "praveenraj",
     "license": "ISC",
     "dependencies": {
+        "@aws-sdk/client-secrets-manager": "^3.1003.0",
         "aws-sdk": "^2.1693.0",
         "body-parser": "^2.2.2",
         "cors": "^2.8.6",
         "dotenv": "^17.3.1",
         "express": "^5.2.1",
+        "json2csv": "^6.0.0-alpha.2",
         "mongodb": "^6.21.0",
         "nodemon": "^3.1.14",
         "tango-api-schema": "^2.5.62",

package/src/controllers/audioAnalytics.controller.js

@@ -224,3 +224,79 @@ export const callExternalStreamAPI = async ( req, res ) => {
     } );
   }
 };
+
+// ======================= CHAT STREAM API =======================
+
+const CHAT_STREAM_API = 'http://13.232.38.210:8000/api/chat/stream';
+
+/**
+ * Chat Stream API - Streams response from external AI chat API
+ * Accepts user data and configuration, returns streaming response
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+export async function chatStream( req, res ) {
+  try {
+    /* eslint-disable camelcase */
+    const {
+      userId,
+      sessionId,
+      sessionDate,
+      sessionTimezone,
+      message,
+      config,
+    } = req.body;
+
+    logger.info( { message: 'Received chat stream request', userId, sessionId, message } );
+
+    // Build payload for external API
+    const payload = {
+      userId,
+      sessionId,
+      sessionDate,
+      sessionTimezone,
+      message,
+      config,
+    };
+    /* eslint-enable camelcase */
+
+    logger.info( { message: 'Calling external chat stream API', payload } );
+
+    // Set SSE headers
+    res.setHeader( 'Content-Type', 'text/event-stream' );
+    res.setHeader( 'Cache-Control', 'no-cache' );
+    res.setHeader( 'Connection', 'keep-alive' );
+    res.setHeader( 'X-Accel-Buffering', 'no' );
+
+    // Make the external API call with streaming
+    const response = await fetch( CHAT_STREAM_API, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+      },
+      body: JSON.stringify( payload ),
+    } );
+
+    if ( !response.ok ) {
+      logger.error( `External Chat Stream API error: ${response.status} ${response.statusText}` );
+      res.write( `data: ${JSON.stringify( { error: `External API error: ${response.statusText}` } )}\n\n` );
+      res.end();
+      return;
+    }
+
+    // Stream the response from external API to client
+    for await ( const chunk of response.body ) {
+      const text = new TextDecoder().decode( chunk );
+      res.write( text );
+    }
+
+    res.end();
+    logger.info( { message: 'Chat stream completed successfully' } );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'chatStream' } );
+    res.write( `data: ${JSON.stringify( { error: error.message } )}\n\n` );
+    res.end();
+  }
+}
+

package/src/controllers/cohortAnalytics.controller.js

@@ -1,5 +1,66 @@
 // import { sampleCohortData } from '../models/cohortAnalysis.model.js';
 import { logger } from 'tango-app-api-middleware';
+import { getCohortAnalysisSummaryCard } from '../services/conversation.service.js';
+
+/**
+ * Get Cohort Analysis Summary Card
+ * POST /cohort-analysis-card
+ * @param {Object} req - Express request object
+ * @param {Object} req.body - Request body with analysis parameters
+ * @param {string} req.body.startDate - Start date for analysis (YYYY-MM-DD)
+ * @param {string} req.body.endDate - End date for analysis (YYYY-MM-DD)
+ * @param {string[]} req.body.storeId - Array of store IDs for filtering
+ * @param {string[]} req.body.cohortType - Array of cohort types to filter
+ * @param {string[]} req.body.clientId - Array of client IDs
+ * @param {Object} res - Express response object
+ * @return {void} Returns JSON response with cohort analysis summary card data
+ */
+export const getCohortAnalysisCard = async ( req, res ) => {
+  try {
+    const { startDate, endDate, storeId, cohortType, clientId } = req.body;
+
+    // Validation
+    if ( !startDate || !endDate || !storeId || !cohortType || !clientId ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Missing required parameters: startDate, endDate, storeId, cohortType, clientId',
+        code: 'MISSING_PARAMETERS',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    logger.info( {
+      message: 'Fetching cohort analysis summary card',
+      startDate,
+      endDate,
+      storeId,
+      cohortType,
+    } );
+
+    // Get summary card data from Lambda
+    const summaryCard = await getCohortAnalysisSummaryCard( {
+      startDate,
+      endDate,
+      storeId,
+      cohortType,
+      clientId,
+    } );
+
+    return res.status( 200 ).json( {
+      status: 'success',
+      data: summaryCard,
+      timestamp: new Date().toISOString(),
+    } );
+  } catch ( error ) {
+    logger.error( { error, message: 'Error fetching cohort analysis summary card', body: req.body } );
+    return res.status( 500 ).json( {
+      status: 'error',
+      message: error.message || 'Internal server error',
+      code: 'INTERNAL_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
 
 /**
  * Get Complete Cohort Analysis

package/src/controllers/conversationAnalytics.controller.js

@@ -1,5 +1,13 @@
 // import { sampleConversationData, sampleConversationsList } from '../models/conversationAnalysis.model.js';
 import { logger } from 'tango-app-api-middleware';
+import {
+  getConversationsListFromLambda,
+  exportConversationsFromLambda,
+  getConversationDetailsFromLambda,
+  exportConversationsToCSV,
+  filterConversationsBySearch,
+  sortConversations,
+} from '../services/conversation.service.js';
 
 /**
  * Get Conversation Analysis List
@@ -8,13 +16,31 @@ import { logger } from 'tango-app-api-middleware';
  * @param {Object} req.body - Request body with query parameters
  * @param {string} req.body.startDate - Start date for filtering
  * @param {string} req.body.endDate - End date for filtering
- * @param {string} req.body.storeId - Store ID for filtering
+ * @param {string[]} req.body.storeId - Array of store IDs for filtering
+ * @param {string[]} req.body.clientId - Optional array of client IDs
+ * @param {boolean} req.body.isAI - Filter for AI conversations
+ * @param {string} req.body.analyticsType - Type of analytics (audio, text, all)
+ * @param {string} req.body.searchValue - Search term for filtering
+ * @param {number} req.body.limit - Pagination limit
+ * @param {number} req.body.offset - Pagination offset
+ * @param {boolean} req.body.isExport - Flag to export as CSV
  * @param {Object} res - Express response object
- * @return {void} Returns JSON response with conversations list
+ * @return {void} Returns JSON response with conversations list or CSV file
  */
 export const getConversationsList = async ( req, res ) => {
   try {
-    const { startDate, endDate, storeId } = req.body;
+    const {
+      startDate,
+      endDate,
+      storeId,
+      clientId,
+      isAI,
+      analyticsType,
+      searchValue,
+      limit,
+      offset,
+      isExport,
+    } = req.body;
 
     // Validation
     if ( !startDate || !endDate || !storeId ) {
@@ -26,21 +52,101 @@ export const getConversationsList = async ( req, res ) => {
       } );
     }
 
-    logger.info( `Fetching conversations for store ${storeId} from ${startDate} to ${endDate}` );
+    logger.info( {
+      message: 'Fetching conversations list',
+      startDate,
+      endDate,
+      storeId,
+      isExport,
+    } );
+
+    let conversations;
+    let totalCount;
+
+    // If export is requested, call the export Lambda function
+    if ( isExport ) {
+      try {
+        const exportResponse = await exportConversationsFromLambda( {
+          startDate,
+          endDate,
+          storeId,
+          clientId,
+          isAI,
+          analyticsType,
+          searchValue,
+        } );
+
+        conversations = exportResponse.conversations || [];
+        totalCount = exportResponse.totalCount || conversations.length;
+
+        logger.info( {
+          message: 'Export Lambda response received',
+          recordCount: conversations.length,
+        } );
+
+        // Apply search filter if provided
+        if ( searchValue ) {
+          conversations = filterConversationsBySearch( conversations, searchValue );
+        }
+
+        // Apply sorting
+        conversations = sortConversations( conversations, 'date', 'desc' );
+
+        // Convert to CSV
+        const csv = await exportConversationsToCSV( conversations );
+        res.setHeader( 'Content-Type', 'text/csv' );
+        res.setHeader( 'Content-Disposition', 'attachment; filename=conversations.csv' );
+        return res.send( csv );
+      } catch ( error ) {
+        logger.error( { error, message: 'Error in export Lambda call', body: req.body } );
+        throw error;
+      }
+    }
+
+    // Call Lambda to get conversations (non-export)
+    const lambdaResponse = await getConversationsListFromLambda( {
+      startDate,
+      endDate,
+      storeId,
+      clientId,
+      isAI,
+      analyticsType,
+      searchValue,
+      limit,
+      offset,
+    } );
+
+    conversations = lambdaResponse.conversations || [];
+    totalCount = lambdaResponse.totalCount || conversations.length;
+
+    // Apply search filter if provided
+    if ( searchValue ) {
+      conversations = filterConversationsBySearch( conversations, searchValue );
+    }
+
+    // Apply sorting
+    conversations = sortConversations( conversations, 'date', 'desc' );
 
+    // Return paginated JSON response
     return res.status( 200 ).json( {
       status: 'success',
       data: {
-        totalConversations: 0,
-        conversations: 'sampleConversationsList',
+        totalConversations: totalCount,
+        conversations,
+        pagination: {
+          limit,
+          offset,
+          total: totalCount,
+          hasMore: ( offset + limit ) < totalCount,
+        },
       },
       timestamp: new Date().toISOString(),
     } );
   } catch ( error ) {
-    logger.error( `Error fetching conversations: ${error.message}` );
+    logger.error( { error, message: 'Error fetching conversations list', body: req.body } );
     return res.status( 500 ).json( {
       status: 'error',
-      message: 'Internal server error',
+      message: error.message || 'Internal server error',
       code: 'INTERNAL_ERROR',
       timestamp: new Date().toISOString(),
     } );
@@ -66,24 +172,43 @@ export const getConversationDetails = async ( req, res ) => {
     if ( !conversationId || !storeId ) {
       return res.status( 400 ).json( {
         status: 'error',
-        message: 'Missing required parameters',
+        message: 'Missing required parameters: conversationId, storeId',
         code: 'MISSING_PARAMETERS',
         timestamp: new Date().toISOString(),
       } );
     }
 
-    logger.info( `Fetching conversation ${conversationId}` );
+    logger.info( {
+      message: 'Fetching conversation details',
+      conversationId,
+      storeId,
+    } );
+
+    // Call Lambda to get conversation details
+    const conversationData = await getConversationDetailsFromLambda( {
+      conversationId,
+      storeId,
+    } );
+
+    if ( !conversationData ) {
+      return res.status( 404 ).json( {
+        status: 'error',
+        message: 'Conversation not found',
+        code: 'NOT_FOUND',
+        timestamp: new Date().toISOString(),
+      } );
+    }
 
     return res.status( 200 ).json( {
       status: 'success',
-      data: 'sampleConversationData',
+      data: conversationData,
       timestamp: new Date().toISOString(),
     } );
   } catch ( error ) {
-    logger.error( `Error fetching conversation: ${error.message}` );
+    logger.error( { error, message: 'Error fetching conversation details', params: req.params } );
     return res.status( 500 ).json( {
       status: 'error',
-      message: 'Internal server error',
+      message: error.message || 'Internal server error',
       code: 'INTERNAL_ERROR',
       timestamp: new Date().toISOString(),
     } );

package/src/dtos/audioAnalytics.dtos.js

@@ -497,6 +497,53 @@ export class ExternalStreamAPIRequestDTO {
   }
 }
 
+// ======================= JOI VALIDATION SCHEMAS =======================
+
+/**
+ * Cohort Analysis Card Schema
+ */
+export const cohortAnalysisCardValid = joi.object( {
+  startDate: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'Start date in YYYY-MM-DD format' ),
+  endDate: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'End date in YYYY-MM-DD format' ),
+  storeId: joi.array().items( joi.string() ).required().min( 1 ).description( 'Array of store IDs' ),
+  cohortType: joi.array().items( joi.string() ).required().min( 1 ).description( 'Array of cohort types' ),
+  clientId: joi.array().items( joi.string() ).required().min( 1 ).description( 'Array of client IDs' ),
+} ).strict();
+
+/**
+ * Conversations List Schema
+ */
+export const conversationsListValid = joi.object( {
+  startDate: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'Start date in YYYY-MM-DD format' ),
+  endDate: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'End date in YYYY-MM-DD format' ),
+  storeId: joi.array().items( joi.string() ).required().min( 1 ).description( 'Array of store IDs' ),
+  clientId: joi.array().items( joi.string() ).optional().description( 'Array of client IDs' ),
+  isAI: joi.boolean().optional().description( 'Filter for AI-generated conversations' ),
+  analyticsType: joi.string().optional().valid( 'audio', 'text', 'all' ).description( 'Type of analytics' ),
+  searchValue: joi.string().optional().description( 'Search term' ),
+  isExport: joi.boolean().optional().description( 'Flag to export as CSV' ),
+  limit: joi.number().integer().min( 1 ).max( 1000 ).optional().default( 10 ).description( 'Pagination limit' ),
+  offset: joi.number().integer().min( 0 ).optional().default( 0 ).description( 'Pagination offset' ),
+} ).strict();
+
+/**
+ * Conversation Details Schema
+ */
+export const conversationDetailsValid = joi.object( {
+  storeId: joi.string().required().description( 'Store ID' ),
+} ).strict();
+
+/**
+ * CSV Export Schema
+ */
+export const csvExportValid = joi.object( {
+  startDate: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'Start date in YYYY-MM-DD format' ),
+  endDate: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'End date in YYYY-MM-DD format' ),
+  storeId: joi.array().items( joi.string() ).required().min( 1 ).description( 'Array of store IDs' ),
+  clientId: joi.array().items( joi.string() ).optional().description( 'Array of client IDs' ),
+  columns: joi.array().items( joi.string() ).optional().description( 'Columns to include in export' ),
+} ).strict();
+
 
 const cohortContextNonNumericSchema = joi.object( {
   contextName: joi.string().required(),
@@ -586,3 +633,30 @@ const listCohortsByClientSchema = joi.object( {
 export const listCohortsByClientValid = {
   query: listCohortsByClientSchema,
 };
+
+// ======================= CHAT STREAM API SCHEMA =======================
+
+/**
+ * Chat Stream Request Schema
+ * For streaming AI chat API
+ */
+const chatStreamSchema = joi.object( {
+
+  userId: joi.string().required().description( 'User ID' ),
+  sessionId: joi.string().required().description( 'Session ID' ),
+  sessionDate: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'Session date in YYYY-MM-DD format' ),
+  sessionTimezone: joi.string().required().description( 'Session timezone (e.g., Asia/Kolkata)' ),
+  message: joi.string().required().min( 1 ).description( 'User message/prompt' ),
+  config: joi.object( {
+    selectedStores: joi.array().items( joi.string() ).required().min( 1 ).description( 'Array of selected store IDs' ),
+    dateRange: joi.object( {
+      start: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'Start date in YYYY-MM-DD format' ),
+      end: joi.string().required().pattern( /^\d{4}-\d{2}-\d{2}$/ ).description( 'End date in YYYY-MM-DD format' ),
+    } ).required().description( 'Date range object' ),
+    selectedProducts: joi.array().items( joi.string() ).required().min( 1 ).description( 'Array of selected products' ),
+  } ).required().description( 'Configuration object' ),
+} ).strict();
+
+export const chatStreamValid = {
+  body: chatStreamSchema,
+};

package/src/routes/audioAnalytics.routes.js

@@ -2,7 +2,10 @@
 import express from 'express';
 import { validate } from 'tango-app-api-middleware';
 import { createCohortValid, updateCohortValid, getCohortValid, listCohortsByClientValid } from '../dtos/audioAnalytics.dtos.js';
-import { createCohort, updateCohort, getCohort, listCohortsByClient } from '../controllers/audioAnalytics.controller.js';
+import { cohortAnalysisCardValid, conversationsListValid, conversationDetailsValid, chatStreamValid } from '../dtos/audioAnalytics.dtos.js';
+import { createCohort, updateCohort, getCohort, listCohortsByClient, chatStream } from '../controllers/audioAnalytics.controller.js';
+import { getCohortAnalysisCard } from '../controllers/cohortAnalytics.controller.js';
+import { getConversationsList, getConversationDetails } from '../controllers/conversationAnalytics.controller.js';
 
 export const audioAnalyticsrouter = express.Router(); ;
 
@@ -12,10 +15,21 @@ audioAnalyticsrouter.get( '/test', ( req, res ) => {
   return res.json( 'Hello, world!' );
 } );
 
+// Cohort Management Routes
 audioAnalyticsrouter.post( '/create-cohort', validate( createCohortValid ), createCohort );
 audioAnalyticsrouter.post( '/update-cohort', validate( updateCohortValid ), updateCohort );
 audioAnalyticsrouter.get( '/get-cohort/:cohortId', validate( getCohortValid ), getCohort );
 audioAnalyticsrouter.get( '/list-cohorts', validate( listCohortsByClientValid ), listCohortsByClient );
 
+// Cohort Analytics Routes
+audioAnalyticsrouter.post( '/cohort-analysis-card', validate( cohortAnalysisCardValid ), getCohortAnalysisCard );
+
+// Conversation Analytics Routes
+audioAnalyticsrouter.post( '/conversations/list', validate( conversationsListValid ), getConversationsList );
+audioAnalyticsrouter.post( '/conversations/:conversationId', validate( conversationDetailsValid ), getConversationDetails );
+
+// Chat Stream API Route
+audioAnalyticsrouter.post( '/chat/stream', validate( chatStreamValid ), chatStream );
+
 
 export default audioAnalyticsrouter;

package/src/services/conversation.service.js

@@ -0,0 +1,243 @@
+import { logger } from 'tango-app-api-middleware';
+import axios from 'axios';
+import { Parser } from 'json2csv';
+
+
+/**
+ * Call the Lambda function to get cohort analysis
+ * @param {Object} params - Request parameters
+ * @param {string} params.startDate - Start date (YYYY-MM-DD)
+ * @param {string} params.endDate - End date (YYYY-MM-DD)
+ * @param {string[]} params.storeId - Array of store IDs
+ * @param {string[]} params.cohortType - Array of cohort types
+ * @param {string[]} params.clientId - Array of client IDs
+ * @return {Promise<Object>} Response from Lambda
+ */
+export async function getCohortAnalysisFromLambda( params ) {
+  try {
+    const LAMBDA_ENDPOINT = JSON.parse( process.env.URL ) || 'http://lambda-api:8000';
+    logger.info( { message: 'Calling Lambda for cohort analysis', params } );
+
+    const response = await axios.post( `${LAMBDA_ENDPOINT.cohortAnalysisCard}/cohort-analysis`, {
+      startDate: params.startDate,
+      endDate: params.endDate,
+      storeId: params.storeId,
+      cohortType: params.cohortType,
+      clientId: params.clientId,
+    }, {
+      timeout: 30000,
+    } );
+
+    logger.info( { message: 'Lambda response received', data: response.data } );
+    return response.data;
+  } catch ( error ) {
+    logger.error( { error, message: 'Error calling Lambda for cohort analysis', params } );
+    throw new Error( `Failed to fetch cohort analysis: ${error.message}` );
+  }
+}
+
+/**
+ * Call Lambda to get conversations list
+ * @param {Object} params - Request parameters
+ * @param {string} params.startDate - Start date (YYYY-MM-DD)
+ * @param {string} params.endDate - End date (YYYY-MM-DD)
+ * @param {string[]} params.storeId - Array of store IDs
+ * @param {string[]} params.clientId - Array of client IDs
+ * @param {boolean} params.isAI - Filter for AI conversations
+ * @param {string} params.analyticsType - Type of analytics
+ * @param {string} params.searchValue - Search term
+ * @param {number} params.limit - Pagination limit
+ * @param {number} params.offset - Pagination offset
+ * @return {Promise<Object>} Response from Lambda
+ */
+export async function getConversationsListFromLambda( params ) {
+  try {
+    const LAMBDA_ENDPOINT = JSON.parse( process.env.URL ) || 'http://lambda-api:8000';
+    logger.info( { message: 'Calling Lambda for conversations list', params } );
+
+    const response = await axios.post( `${LAMBDA_ENDPOINT.cohortConversationList}/conversations/list`, {
+      startDate: params.startDate,
+      endDate: params.endDate,
+      storeId: params.storeId,
+      clientId: params.clientId,
+      isAI: params.isAI,
+      analyticsType: params.analyticsType,
+      searchValue: params.searchValue,
+      limit: params.limit,
+      offset: params.offset,
+    }, {
+      timeout: 30000,
+    } );
+
+    logger.info( { message: 'Lambda response received for conversations list', totalCount: response.data?.totalCount } );
+    return response.data;
+  } catch ( error ) {
+    logger.error( { error, message: 'Error calling Lambda for conversations list', params } );
+    throw new Error( `Failed to fetch conversations list: ${error.message}` );
+  }
+}
+
+/**
+ * Call Lambda to get conversations for export
+ * @param {Object} params - Request parameters
+ * @param {string} params.startDate - Start date (YYYY-MM-DD)
+ * @param {string} params.endDate - End date (YYYY-MM-DD)
+ * @param {string[]} params.storeId - Array of store IDs
+ * @param {string[]} params.clientId - Array of client IDs
+ * @param {boolean} params.isAI - Filter for AI conversations
+ * @param {string} params.analyticsType - Type of analytics
+ * @param {string} params.searchValue - Search term
+ * @return {Promise<Object>} Response from Lambda with export data
+ */
+export async function exportConversationsFromLambda( params ) {
+  try {
+    const LAMBDA_ENDPOINT = JSON.parse( process.env.URL ) || 'http://lambda-api:8000';
+    logger.info( { message: 'Calling Lambda for conversations export', params } );
+
+    const response = await axios.post( `${LAMBDA_ENDPOINT.cohortConversationExport}/conversations/export`, {
+      startDate: params.startDate,
+      endDate: params.endDate,
+      storeId: params.storeId,
+      clientId: params.clientId,
+      isAI: params.isAI,
+      analyticsType: params.analyticsType,
+      searchValue: params.searchValue,
+    }, {
+      timeout: 30000,
+    } );
+
+    logger.info( { message: 'Lambda response received for conversations export', recordCount: response.data?.recordCount } );
+    return response.data;
+  } catch ( error ) {
+    logger.error( { error, message: 'Error calling Lambda for conversations export', params } );
+    throw new Error( `Failed to export conversations: ${error.message}` );
+  }
+}
+
+/**
+ * Call Lambda to get conversation details
+ * @param {Object} params - Request parameters
+ * @param {string} params.conversationId - Conversation ID
+ * @param {string} params.storeId - Store ID
+ * @return {Promise<Object>} Response from Lambda
+ */
+export async function getConversationDetailsFromLambda( params ) {
+  try {
+    const LAMBDA_ENDPOINT = JSON.parse( process.env.URL ) || 'http://lambda-api:8000';
+    logger.info( { message: 'Calling Lambda for conversation details', params } );
+
+    const response = await axios.post( `${LAMBDA_ENDPOINT.cohortConversationDetail}/conversations/${params.conversationId}`, {
+      storeId: params.storeId,
+    }, {
+      timeout: 30000,
+    } );
+
+    logger.info( { message: 'Lambda response received for conversation details', conversationId: params.conversationId } );
+    return response.data;
+  } catch ( error ) {
+    logger.error( { error, message: 'Error calling Lambda for conversation details', params } );
+    throw new Error( `Failed to fetch conversation details: ${error.message}` );
+  }
+}
+
+/**
+ * Export conversations list to CSV
+ * @param {Array} conversations - Array of conversation objects
+ * @param {Array} columns - Columns to include in export
+ * @return {Promise<string>} CSV string
+ */
+export async function exportConversationsToCSV( conversations, columns = null ) {
+  try {
+    if ( !conversations || conversations.length === 0 ) {
+      logger.warn( 'No conversations to export' );
+      return '';
+    }
+
+    // If no columns specified, use all keys from first object
+    const fields = columns || Object.keys( conversations[0] );
+
+    const parser = new Parser( { fields } );
+    const csv = parser.parse( conversations );
+
+    logger.info( { message: 'Conversations exported to CSV', recordCount: conversations.length } );
+    return csv;
+  } catch ( error ) {
+    logger.error( { error, message: 'Error exporting conversations to CSV' } );
+    throw new Error( `Failed to export to CSV: ${error.message}` );
+  }
+}
+
+/**
+ * Get cohort analysis summary card data
+ * @param {Object} params - Request parameters
+ * @return {Promise<Object>} Summary card data from Lambda
+ */
+export async function getCohortAnalysisSummaryCard( params ) {
+  try {
+    const lambdaResponse = await getCohortAnalysisFromLambda( params );
+
+    // Process response to create summary card
+    const summaryCard = {
+      totalConversations: lambdaResponse.totalConversations || 0,
+      totalDuration: lambdaResponse.totalDuration || 0,
+      averageRating: lambdaResponse.averageRating || 0,
+      topCohorts: lambdaResponse.topCohorts || [],
+      trendData: lambdaResponse.trendData || [],
+      keyInsights: lambdaResponse.keyInsights || [],
+      timestamp: new Date().toISOString(),
+    };
+
+    return summaryCard;
+  } catch ( error ) {
+    logger.error( { error, message: 'Error getting cohort analysis summary card' } );
+    throw error;
+  }
+}
+
+/**
+ * Process and filter conversations based on search criteria
+ * @param {Array} conversations - Array of conversation objects
+ * @param {string} searchValue - Search term
+ * @return {Array} Filtered conversations
+ */
+export function filterConversationsBySearch( conversations, searchValue ) {
+  if ( !searchValue || searchValue.trim() === '' ) {
+    return conversations;
+  }
+
+  const searchLower = searchValue.toLowerCase();
+  return conversations.filter( ( conv ) => {
+    return (
+      ( conv.storeName && conv.storeName.toLowerCase().includes( searchLower ) ) ||
+      ( conv.storeId && conv.storeId.toLowerCase().includes( searchLower ) ) ||
+      ( conv.summary && conv.summary.toLowerCase().includes( searchLower ) ) ||
+      ( conv.audioDescription && conv.audioDescription.toLowerCase().includes( searchLower ) )
+    );
+  } );
+}
+
+/**
+ * Sort conversations by specified field
+ * @param {Array} conversations - Array of conversation objects
+ * @param {string} sortBy - Field to sort by
+ * @param {string} order - Sort order ('asc' or 'desc')
+ * @return {Array} Sorted conversations
+ */
+export function sortConversations( conversations, sortBy = 'date', order = 'desc' ) {
+  const sorted = [ ...conversations ];
+  sorted.sort( ( a, b ) => {
+    const aVal = a[sortBy];
+    const bVal = b[sortBy];
+
+    if ( aVal === undefined || aVal === null ) return 1;
+    if ( bVal === undefined || bVal === null ) return -1;
+
+    if ( typeof aVal === 'string' ) {
+      return order === 'desc' ? bVal.localeCompare( aVal ) : aVal.localeCompare( bVal );
+    }
+
+    return order === 'desc' ? bVal - aVal : aVal - bVal;
+  } );
+
+  return sorted;
+}

package/src/utils/csvExport.util.js

@@ -0,0 +1,160 @@
+import { Parser } from 'json2csv';
+import { logger } from 'tango-app-api-middleware';
+
+/**
+ * Convert data array to CSV format
+ * @param {Array} data - Array of objects to convert to CSV
+ * @param {Array} fields - Fields to include in CSV (if null, uses all fields from first object)
+ * @param {Object} options - Additional options for Parser
+ * @return {Promise<string>} CSV string
+ */
+export async function convertToCSV( data, fields = null, options = {} ) {
+  try {
+    if ( !data || data.length === 0 ) {
+      logger.warn( 'No data provided for CSV export' );
+      return '';
+    }
+
+    const parserOptions = {
+      fields: fields || Object.keys( data[0] ),
+      ...options,
+    };
+
+    const parser = new Parser( parserOptions );
+    const csv = parser.parse( data );
+
+    logger.info( { message: 'Data converted to CSV', recordCount: data.length } );
+    return csv;
+  } catch ( error ) {
+    logger.error( { error, message: 'Error converting data to CSV' } );
+    throw new Error( `Failed to convert to CSV: ${error.message}` );
+  }
+}
+
+/**
+ * Export conversations to CSV
+ * @param {Array} conversations - Array of conversation objects
+ * @param {Array} columns - Columns to include in export
+ * @return {Promise<string>} CSV string
+ */
+export async function exportConversationsToCSV( conversations, columns = null ) {
+  const defaultFields = columns || [
+    'conversationId',
+    'storeId',
+    'storeName',
+    'date',
+    'time',
+    'duration',
+    'audioDescription',
+    'summary',
+  ];
+
+  return convertToCSV( conversations, defaultFields, {
+    header: true,
+    flatten: false,
+  } );
+}
+
+/**
+ * Export cohort analysis data to CSV
+ * @param {Array} data - Array of cohort analysis objects
+ * @param {Array} columns - Columns to include in export
+ * @return {Promise<string>} CSV string
+ */
+export async function exportCohortAnalysisToCSV( data, columns = null ) {
+  const defaultFields = columns || [
+    'cohortId',
+    'cohortName',
+    'cohortType',
+    'storeId',
+    'totalConversations',
+    'averageRating',
+    'conversionRate',
+    'date',
+  ];
+
+  return convertToCSV( data, defaultFields, {
+    header: true,
+    flatten: false,
+  } );
+}
+
+/**
+ * Export dashboard metrics to CSV
+ * @param {Array} metrics - Array of metric objects
+ * @param {Array} columns - Columns to include in export
+ * @return {Promise<string>} CSV string
+ */
+export async function exportMetricsToCSV( metrics, columns = null ) {
+  const defaultFields = columns || [
+    'metricName',
+    'value',
+    'target',
+    'variance',
+    'status',
+    'date',
+  ];
+
+  return convertToCSV( metrics, defaultFields, {
+    header: true,
+    flatten: false,
+  } );
+}
+
+/**
+ * Generate CSV file blob
+ * @param {string} csvString - CSV string content
+ * @param {string} filename - Name of the file
+ * @return {Blob} File blob for download
+ */
+export function generateCSVBlob( csvString, filename = 'export.csv' ) {
+  const blob = new Blob( [ csvString ], { type: 'text/csv;charset=utf-8;' } );
+  const link = document.createElement( 'a' );
+  const url = URL.createObjectURL( blob );
+
+  link.setAttribute( 'href', url );
+  link.setAttribute( 'download', filename );
+  link.style.visibility = 'hidden';
+
+  document.body.appendChild( link );
+  link.click();
+  document.body.removeChild( link );
+
+  return blob;
+}
+
+/**
+ * Flatten nested objects for CSV export
+ * @param {Object} obj - Object to flatten
+ * @param {string} prefix - Prefix for flattened keys
+ * @return {Object} Flattened object
+ */
+export function flattenObject( obj, prefix = '' ) {
+  const flattened = {};
+
+  for ( const key in obj ) {
+    if ( Object.prototype.hasOwnProperty.call( obj, key ) ) {
+      const value = obj[key];
+      const newKey = prefix ? `${prefix}.${key}` : key;
+
+      if ( value !== null && typeof value === 'object' && !Array.isArray( value ) ) {
+        Object.assign( flattened, flattenObject( value, newKey ) );
+      } else if ( Array.isArray( value ) ) {
+        flattened[newKey] = JSON.stringify( value );
+      } else {
+        flattened[newKey] = value;
+      }
+    }
+  }
+
+  return flattened;
+}
+
+/**
+ * Flatten array of objects, handling nested data
+ * @param {Array} data - Array of objects to flatten
+ * @return {Array} Array of flattened objects
+ */
+export function flattenDataForCSV( data ) {
+  return data.map( ( item ) => flattenObject( item ) );
+}