tango-app-api-audio-analytics 1.0.0

package/src/middlewares/validation.middleware.js

@@ -0,0 +1,624 @@
+/**
+ * Validation Middleware for Audio Analytics API
+ * Validates request data using DTOs before reaching controllers
+ */
+
+import {
+  CohortAnalysisRequestDTO,
+  ConversationsListRequestDTO,
+  ConversationDetailsRequestDTO,
+  ConversationMetricsRequestDTO,
+  AIInsightsRequestDTO,
+  ConversationTranscriptionRequestDTO,
+  DashboardFilterRequestDTO,
+  ExportDataRequestDTO,
+
+  ExternalStreamAPIRequestDTO,
+} from '../dtos/audioAnalytics.dtos.js';
+import {
+  cohortCreationSchema,
+  cohortUpdateSchema,
+  cohortQuerySchema,
+  validateCohortData,
+} from '../validations/cohort.validation.js';
+import { logger } from 'tango-app-api-middleware';
+
+/**
+ * Generic validation error handler
+ * @param {Object} res - Express response object
+ * @param {Error} error - Error object to handle
+ * @param {string} [code='VALIDATION_ERROR'] - Error code to return
+ * @return {void} Sends error response to client
+ */
+const handleValidationError = ( res, error, code = 'VALIDATION_ERROR' ) => {
+  logger.error( `Validation error: ${error.message}` );
+  res.status( 400 ).json( {
+    status: 'error',
+    message: error.message,
+    code,
+    timestamp: new Date().toISOString(),
+  } );
+};
+
+/**
+ * Validate Cohort Analysis Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateCohortAnalysis = ( req, res, next ) => {
+  try {
+    const { startDate, endDate, storeId, cohortType, clientId } = req.body;
+
+    const cohortDTO = new CohortAnalysisRequestDTO(
+        startDate,
+        endDate,
+        storeId,
+        cohortType,
+        clientId,
+    );
+
+    cohortDTO.validate();
+    req.validatedData = cohortDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'MISSING_PARAMETERS' );
+  }
+};
+
+/**
+ * Validate Conversations List Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateConversationsList = ( req, res, next ) => {
+  try {
+    const conversationsDTO = new ConversationsListRequestDTO( req.body );
+    conversationsDTO.validate();
+    req.validatedData = conversationsDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'MISSING_PARAMETERS' );
+  }
+};
+
+/**
+ * Validate Conversation Details Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateConversationDetails = ( req, res, next ) => {
+  try {
+    const { conversationId } = req.params;
+    const { storeId } = req.body;
+
+    const detailsDTO = new ConversationDetailsRequestDTO( conversationId, storeId );
+    detailsDTO.validate();
+    req.validatedData = detailsDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'MISSING_PARAMETERS' );
+  }
+};
+
+/**
+ * Validate Conversation Metrics Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateConversationMetrics = ( req, res, next ) => {
+  try {
+    const { conversationId } = req.params;
+    const { storeId, includeBreakdown } = req.body;
+
+    const metricsDTO = new ConversationMetricsRequestDTO(
+        conversationId,
+        storeId,
+        includeBreakdown,
+    );
+    metricsDTO.validate();
+    req.validatedData = metricsDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'MISSING_PARAMETERS' );
+  }
+};
+
+/**
+ * Validate AI Insights Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateAIInsights = ( req, res, next ) => {
+  try {
+    const { conversationId } = req.params;
+    const requestData = {
+      conversationId,
+      ...req.body,
+    };
+
+    const insightsDTO = new AIInsightsRequestDTO( requestData );
+    insightsDTO.validate();
+    req.validatedData = insightsDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error );
+  }
+};
+
+/**
+ * Validate Conversation Transcription Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateConversationTranscription = ( req, res, next ) => {
+  try {
+    const { conversationId } = req.params;
+    const { storeId, includeTimestamps, highlightKeyPhases } = req.body;
+
+    const transcriptionDTO = new ConversationTranscriptionRequestDTO(
+        conversationId,
+        storeId,
+        includeTimestamps,
+        highlightKeyPhases,
+    );
+    transcriptionDTO.validate();
+    req.validatedData = transcriptionDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'MISSING_PARAMETERS' );
+  }
+};
+
+/**
+ * Validate Dashboard Filter Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateDashboardFilter = ( req, res, next ) => {
+  try {
+    const dashboardDTO = new DashboardFilterRequestDTO( req.body );
+    dashboardDTO.validate();
+    req.validatedData = dashboardDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error );
+  }
+};
+
+/**
+ * Validate Export Data Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateExportData = ( req, res, next ) => {
+  try {
+    const exportDTO = new ExportDataRequestDTO( req.body );
+    exportDTO.validate();
+    req.validatedData = exportDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error );
+  }
+};
+
+/**
+ * Validate Date Format (YYYY-MM-DD)
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateDateFormat = ( req, res, next ) => {
+  try {
+    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+    let hasDateError = false;
+
+    // Check startDate and endDate in body
+    if ( req.body?.startDate && !dateRegex.test( req.body.startDate ) ) {
+      hasDateError = true;
+    }
+    if ( req.body?.endDate && !dateRegex.test( req.body.endDate ) ) {
+      hasDateError = true;
+    }
+
+    // Check dateRange in body
+    if ( req.body?.dateRange ) {
+      if ( !dateRegex.test( req.body.dateRange.startDate ) ) {
+        hasDateError = true;
+      }
+      if ( !dateRegex.test( req.body.dateRange.endDate ) ) {
+        hasDateError = true;
+      }
+    }
+
+    if ( hasDateError ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Invalid date format. Please use YYYY-MM-DD format',
+        code: 'INVALID_DATE_FORMAT',
+        expectedFormat: 'YYYY-MM-DD',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'DATE_VALIDATION_ERROR' );
+  }
+};
+
+/**
+ * Validate Required Fields
+ * @param {Array<{name: string, location: string}>} requiredFields - Array of required field definitions
+ * @return {Function} Middleware function that validates required fields
+ */
+export const validateRequiredFields = ( requiredFields ) => {
+  return ( req, res, next ) => {
+    const missingFields = [];
+
+    requiredFields.forEach( ( field ) => {
+      if ( field.location === 'body' && !req.body?.[field.name] ) {
+        missingFields.push( field.name );
+      } else if ( field.location === 'params' && !req.params?.[field.name] ) {
+        missingFields.push( field.name );
+      }
+    } );
+
+    if ( missingFields.length > 0 ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: `Missing required parameters: ${missingFields.join( ', ' )}`,
+        code: 'MISSING_PARAMETERS',
+        missingFields,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    next();
+  };
+};
+
+/**
+ * Validate Pagination Parameters
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validatePagination = ( req, res, next ) => {
+  try {
+    const { limit = 10, offset = 0 } = req.body;
+
+    if ( typeof limit !== 'number' || limit < 1 || limit > 1000 ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Invalid limit. Must be a number between 1 and 1000',
+        code: 'INVALID_PAGINATION',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    if ( typeof offset !== 'number' || offset < 0 ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Invalid offset. Must be a non-negative number',
+        code: 'INVALID_PAGINATION',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'PAGINATION_ERROR' );
+  }
+};
+
+/**
+ * Validate Array Parameters
+ * @param {string} paramName - Name of parameter to validate
+ * @return {Function} Middleware function that validates array parameter
+ */
+export const validateArrayParameter = ( paramName ) => {
+  return ( req, res, next ) => {
+    try {
+      const value = req.body[paramName];
+
+      if ( value && !Array.isArray( value ) ) {
+        return res.status( 400 ).json( {
+          status: 'error',
+          message: `${paramName} must be an array`,
+          code: 'INVALID_PARAMETER_TYPE',
+          parameter: paramName,
+          receivedType: typeof value,
+          timestamp: new Date().toISOString(),
+        } );
+      }
+
+      next();
+    } catch ( error ) {
+      handleValidationError( res, error, 'VALIDATION_ERROR' );
+    }
+  };
+};
+
+/**
+ * Validate Product Module IDs
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateProductModules = ( req, res, next ) => {
+  try {
+    const validModules = [ 'LKST121', 'LKST122', 'LKST123', 'LKST124', 'LKST125' ];
+    const modules = req.body?.productModules || [];
+
+    if ( Array.isArray( modules ) ) {
+      const invalidModules = modules.filter( ( m ) => !validModules.includes( m ) );
+
+      if ( invalidModules.length > 0 ) {
+        return res.status( 400 ).json( {
+          status: 'error',
+          message: 'Invalid product module selected',
+          code: 'INVALID_FILTER_VALUE',
+          invalidValues: invalidModules,
+          validOptions: validModules,
+          timestamp: new Date().toISOString(),
+        } );
+      }
+    }
+
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'VALIDATION_ERROR' );
+  }
+};
+
+/**
+ * Validate Country Selection
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateCountry = ( req, res, next ) => {
+  try {
+    const validCountries = [ 'USA', 'Canada', 'UK', 'Australia', 'Other' ];
+    const country = req.body?.country;
+
+    if ( country && !validCountries.includes( country ) ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Invalid country selected',
+        code: 'INVALID_FILTER_VALUE',
+        invalidValue: country,
+        validOptions: validCountries,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'VALIDATION_ERROR' );
+  }
+};
+
+/**
+ * Validate Export Format
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateExportFormat = ( req, res, next ) => {
+  try {
+    const validFormats = [ 'csv', 'json', 'xlsx' ];
+    const format = req.body?.exportFormat;
+
+    if ( format && !validFormats.includes( format ) ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Invalid export format',
+        code: 'INVALID_EXPORT_FORMAT',
+        invalidValue: format,
+        validOptions: validFormats,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'VALIDATION_ERROR' );
+  }
+};
+
+/**
+ * Validate Date Range (startDate should be before endDate)
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateDateRange = ( req, res, next ) => {
+  try {
+    let startDate; let endDate;
+
+    if ( req.body?.startDate && req.body?.endDate ) {
+      startDate = new Date( req.body.startDate );
+      endDate = new Date( req.body.endDate );
+    } else if ( req.body?.dateRange ) {
+      startDate = new Date( req.body.dateRange.startDate );
+      endDate = new Date( req.body.dateRange.endDate );
+    }
+
+    if ( startDate && endDate && startDate > endDate ) {
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: 'Start date must be before end date',
+        code: 'INVALID_DATE_RANGE',
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'DATE_VALIDATION_ERROR' );
+  }
+};
+
+// ==================== Cohort Validation Middleware ====================
+
+/**
+ * Validate Cohort Creation Request using Joi
+ * Uses cohortCreationSchema for validation
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateCohortCreation = async ( req, res, next ) => {
+  try {
+    logger.info( 'Validating cohort creation request' );
+
+    const { error, value: validatedData } = await validateCohortData(
+        req.body,
+        cohortCreationSchema,
+    );
+
+    if ( error ) {
+      logger.warn( 'Cohort validation failed', error );
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: error.message,
+        code: 'VALIDATION_ERROR',
+        details: error.details,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    req.validatedData = validatedData;
+    next();
+  } catch ( error ) {
+    logger.error( `Validation error: ${error.message}` );
+    res.status( 400 ).json( {
+      status: 'error',
+      message: 'Validation error',
+      code: 'VALIDATION_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Validate Cohort Update Request using Joi
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateCohortUpdate = async ( req, res, next ) => {
+  try {
+    logger.info( 'Validating cohort update request' );
+
+    const { error, value: validatedData } = await validateCohortData(
+        req.body,
+        cohortUpdateSchema,
+    );
+
+    if ( error ) {
+      logger.warn( 'Cohort update validation failed', error );
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: error.message,
+        code: 'VALIDATION_ERROR',
+        details: error.details,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    req.validatedData = validatedData;
+    next();
+  } catch ( error ) {
+    logger.error( `Validation error: ${error.message}` );
+    res.status( 400 ).json( {
+      status: 'error',
+      message: 'Validation error',
+      code: 'VALIDATION_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Validate Cohort Query/Search Request using Joi
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateCohortQuery = async ( req, res, next ) => {
+  try {
+    logger.info( 'Validating cohort query request' );
+
+    const { error, value: validatedData } = await validateCohortData(
+        req.body,
+        cohortQuerySchema,
+    );
+
+    if ( error ) {
+      logger.warn( 'Cohort query validation failed', error );
+      return res.status( 400 ).json( {
+        status: 'error',
+        message: error.message,
+        code: 'VALIDATION_ERROR',
+        details: error.details,
+        timestamp: new Date().toISOString(),
+      } );
+    }
+
+    req.validatedData = validatedData;
+    next();
+  } catch ( error ) {
+    logger.error( `Validation error: ${error.message}` );
+    res.status( 400 ).json( {
+      status: 'error',
+      message: 'Validation error',
+      code: 'VALIDATION_ERROR',
+      timestamp: new Date().toISOString(),
+    } );
+  }
+};
+
+/**
+ * Validate External Stream API Request
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ * @param {Function} next - Express next middleware function
+ * @return {void} Calls next() if valid or sends error response
+ */
+export const validateExternalStreamAPIRequest = ( req, res, next ) => {
+  try {
+    const streamDTO = new ExternalStreamAPIRequestDTO( req.body );
+    streamDTO.validate();
+    req.validatedData = streamDTO;
+    next();
+  } catch ( error ) {
+    handleValidationError( res, error, 'INVALID_STREAM_REQUEST' );
+  }
+};

package/src/routes/audioAnalytics.routes.js

@@ -0,0 +1,18 @@
+
+import express from 'express';
+import { validate } from 'tango-app-api-middleware';
+import { createCohortValid } from '../dtos/audioAnalytics.dtos.js';
+import { createCohort } from '../controllers/audioAnalytics.controller.js';
+
+export const audioAnalyticsrouter = express.Router(); ;
+
+
+// Health check
+audioAnalyticsrouter.get( '/test', ( req, res ) => {
+  return res.json( 'Hello, world!' );
+} );
+
+audioAnalyticsrouter.post( '/create-cohort', validate( createCohortValid ), createCohort );
+
+
+export default audioAnalyticsrouter;