tango-app-api-audio-analytics 1.0.0

package/src/services/cohort.service.js

@@ -0,0 +1,332 @@
+/**
+ * Cohort Service
+ * Handles all OpenSearch operations for cohort data
+ */
+
+import { insertWithId, searchOpenSearchData, updateOpenSearchData } from 'tango-app-api-middleware';
+import { logger } from 'tango-app-api-middleware';
+import { v4 as uuidv4 } from 'uuid';
+
+const OPENSEARCH_INDEX = 'tango-audio-cohort';
+
+/**
+ * Create a new cohort in OpenSearch
+ * @param {Object} cohortData - Cohort data to insert
+ * @return {Promise<Object>} - Created cohort with ID
+ */
+export const createCohort = async ( cohortData ) => {
+  try {
+    logger.info( `Creating cohort: ${cohortData.cohortId}` );
+
+    // Generate unique document ID
+    const documentId = uuidv4();
+
+    // Prepare cohort document
+    const cohortDocument = {
+      ...cohortData,
+      documentId,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      isActive: true,
+      version: '1.0',
+    };
+
+    // Insert into OpenSearch using the insert function with id
+    const result = await insertWithId(
+        OPENSEARCH_INDEX,
+        documentId,
+        cohortDocument,
+    );
+
+    logger.info( `Cohort created successfully: ${cohortData.cohortId}`, {
+      documentId,
+      cohortId: cohortData.cohortId,
+      result,
+    } );
+
+    return {
+      success: true,
+      data: {
+        documentId,
+        ...cohortDocument,
+      },
+      message: 'Cohort created successfully',
+    };
+  } catch ( error ) {
+    logger.error( `Error creating cohort: ${error.message}`, error );
+    return {
+      code: 'COHORT_CREATE_ERROR',
+      message: 'Failed to create cohort',
+      details: error.message,
+    };
+  }
+};
+
+/**
+ * Get cohort by ID
+ * @param {string} cohortId - Cohort ID to retrieve
+ * @return {Promise<Object>} - Cohort data
+ */
+export const getCohortById = async ( cohortId ) => {
+  try {
+    logger.info( `Fetching cohort: ${cohortId}` );
+
+    const query = {
+      query: {
+        match: {
+          cohortId: cohortId,
+        },
+      },
+    };
+
+    const result = await searchOpenSearchData( OPENSEARCH_INDEX, query );
+
+    if ( !result || result.hits.hits.length === 0 ) {
+      return new Error( `Cohort not found: ${cohortId}` );
+    }
+
+    const cohort = result.hits.hits[0]._source;
+    cohort.documentId = result.hits.hits[0]._id;
+
+    return cohort;
+  } catch ( error ) {
+    logger.error( `Error fetching cohort: ${error.message}`, error );
+    return {
+      code: 'COHORT_FETCH_ERROR',
+      message: 'Failed to fetch cohort',
+      details: error.message,
+    };
+  }
+};
+
+/**
+ * Get cohorts by client ID
+ * @param {string} clientId - Client ID to filter by
+ * @param {number} limit - Results limit
+ * @param {number} offset - Pagination offset
+ * @return {Promise<Object>} - Cohorts and pagination
+ */
+export const getCohortsByClientId = async ( clientId, limit = 10, offset = 0 ) => {
+  try {
+    logger.info( `Fetching cohorts for client: ${clientId}` );
+
+    const query = {
+      query: {
+        match: {
+          clientId: clientId,
+        },
+      },
+      size: limit,
+      from: offset,
+      sort: [ { createdAt: { order: 'desc' } } ],
+    };
+
+    const result = await search( OPENSEARCH_INDEX, query );
+
+    const cohorts = result.hits.hits.map( ( hit ) => ( {
+      documentId: hit._id,
+      ...hit._source,
+    } ) );
+
+    return {
+      cohorts,
+      pagination: {
+        total: result.hits.total.value,
+        limit,
+        offset,
+        hasMore: offset + limit < result.hits.total.value,
+      },
+    };
+  } catch ( error ) {
+    logger.error( `Error fetching cohorts by client: ${error.message}`, error );
+    return {
+      code: 'COHORT_SEARCH_ERROR',
+      message: 'Failed to fetch cohorts',
+      details: error.message,
+    };
+  }
+};
+
+/**
+ * Update cohort
+ * @param {string} documentId - Document ID in OpenSearch
+ * @param {Object} updateData - Data to update
+ * @return {Promise<Object>} - Updated cohort
+ */
+export const updateCohort = async ( documentId, updateData ) => {
+  try {
+    logger.info( `Updating cohort document: ${documentId}` );
+
+    const updateDocument = {
+      ...updateData,
+      updatedAt: new Date().toISOString(),
+    };
+
+    const result = await updateOpenSearchData( OPENSEARCH_INDEX, documentId, updateDocument );
+
+    logger.info( `Cohort updated successfully: ${documentId}`, result );
+
+    return {
+      success: true,
+      data: {
+        documentId,
+        ...updateDocument,
+      },
+      message: 'Cohort updated successfully',
+    };
+  } catch ( error ) {
+    logger.error( `Error updating cohort: ${error.message}`, error );
+    return {
+      code: 'COHORT_UPDATE_ERROR',
+      message: 'Failed to update cohort',
+      details: error.message,
+    };
+  }
+};
+
+/**
+ * Delete cohort
+ * @param {string} documentId - Document ID in OpenSearch
+ * @return {Promise<Object>} - Deletion result
+ */
+export const deleteCohort = async ( documentId ) => {
+  try {
+    logger.info( `Deleting cohort document: ${documentId}` );
+
+    // const result = await deleteDoc( OPENSEARCH_INDEX, documentId );
+
+    logger.info( `Cohort deleted successfully: ${documentId}` );
+
+    return {
+      success: true,
+      message: 'Cohort deleted successfully',
+    };
+  } catch ( error ) {
+    logger.error( `Error deleting cohort: ${error.message}`, error );
+    return {
+      code: 'COHORT_DELETE_ERROR',
+      message: 'Failed to delete cohort',
+      details: error.message,
+    };
+  }
+};
+
+/**
+ * Search cohorts by criteria
+ * @param {Object} searchCriteria - Search criteria (clientId, cohortName, etc.)
+ * @param {number} limit - Results limit
+ * @param {number} offset - Pagination offset
+ * @return {Promise<Object>} - Search results
+ */
+export const searchCohorts = async ( searchCriteria, limit = 10, offset = 0 ) => {
+  try {
+    logger.info( `Searching cohorts with criteria:`, searchCriteria );
+
+    const mustClauses = [];
+
+    if ( searchCriteria.clientId ) {
+      mustClauses.push( { match: { clientId: searchCriteria.clientId } } );
+    }
+    if ( searchCriteria.cohortId ) {
+      mustClauses.push( { match: { cohortId: searchCriteria.cohortId } } );
+    }
+    if ( searchCriteria.cohortName ) {
+      mustClauses.push( {
+        match: {
+          cohortName: {
+            query: searchCriteria.cohortName,
+            fuzziness: 'AUTO',
+          },
+        },
+      } );
+    }
+
+    const query = {
+      query: {
+        bool: {
+          must: mustClauses.length > 0 ? mustClauses : [ { match_all: {} } ],
+        },
+      },
+      size: limit,
+      from: offset,
+      sort: [ { createdAt: { order: 'desc' } } ],
+    };
+
+    const result = await search( OPENSEARCH_INDEX, query );
+
+    const cohorts = result.hits.hits.map( ( hit ) => ( {
+      documentId: hit._id,
+      ...hit._source,
+    } ) );
+
+    return {
+      cohorts,
+      pagination: {
+        total: result.hits.total.value,
+        limit,
+        offset,
+        hasMore: offset + limit < result.hits.total.value,
+      },
+    };
+  } catch ( error ) {
+    logger.error( `Error searching cohorts: ${error.message}`, error );
+    return {
+      code: 'COHORT_SEARCH_ERROR',
+      message: 'Failed to search cohorts',
+      details: error.message,
+    };
+  }
+};
+
+/**
+ * Get cohort analytics/metrics summary
+ * @param {string} cohortId - Cohort ID
+ * @return {Promise<Object>} - Cohort with metrics summary
+ */
+export const getCohortAnalytics = async ( cohortId ) => {
+  try {
+    logger.info( `Fetching analytics for cohort: ${cohortId}` );
+
+    const cohort = await getCohortById( cohortId );
+
+    // Build metrics summary
+    const metricsSummary = cohort.metrics.map( ( metric ) => ( {
+      metricId: metric.metricId,
+      metricName: metric.metricName,
+      isNumneric: metric.isNumneric,
+      contextCount: metric.contexts ? metric.contexts.length : 0,
+      contexts: metric.contexts || [],
+    } ) );
+
+    return {
+      cohortId: cohort.cohortId,
+      cohortName: cohort.cohortName,
+      clientId: cohort.clientId,
+      totalMetrics: cohort.metrics.length,
+      metrics: metricsSummary,
+      createdAt: cohort.createdAt,
+      updatedAt: cohort.updatedAt,
+    };
+  } catch ( error ) {
+    logger.error( `Error fetching cohort analytics: ${error.message}`, error );
+    return {
+      code: 'COHORT_ANALYTICS_ERROR',
+      message: 'Failed to fetch cohort analytics',
+      details: error.message,
+    };
+  }
+};
+
+/**
+ * Check if cohort exists
+ * @param {string} cohortId - Cohort ID to check
+ * @return {Promise<boolean>} - True if exists, false otherwise
+ */
+export const cohortExists = async ( cohortId ) => {
+  try {
+    await getCohortById( cohortId );
+    return true;
+  } catch ( error ) {
+    return false;
+  }
+};

package/src/validations/cohort.validation.js

@@ -0,0 +1,113 @@
+/**
+ * Cohort Validation Schema using Joi
+ * Validates cohort creation requests according to the schema
+ */
+
+import Joi from 'joi';
+
+/**
+ * Context validation schema (for metrics)
+ */
+const contextSchema = Joi.object( {
+  contextName: Joi.string().required().description( 'Name of the context' ),
+  priority: Joi.number().min( 0 ).max( 2 ).required().description( 'Priority level 0-2' ),
+  description: Joi.string().required().description( 'Description of the context' ),
+  minValue: Joi.number().optional().description( 'Minimum value for numeric contexts' ),
+  maxValue: Joi.number().optional().description( 'Maximum value for numeric contexts' ),
+} );
+
+/**
+ * Metric validation schema
+ */
+const metricSchema = Joi.object( {
+  metricId: Joi.string().required().description( 'Unique metric identifier' ),
+  metricName: Joi.string().required().description( 'Human-readable metric name' ),
+  metricDescription: Joi.string().required().description( 'Detailed metric description' ),
+  hasContext: Joi.boolean().required().description( 'Whether metric has context values' ),
+  isNumneric: Joi.boolean().required().description( 'Whether metric is numeric' ),
+  contexts: Joi.when( 'hasContext', {
+    is: true,
+    then: Joi.array().items( contextSchema ).required().min( 1 ),
+    otherwise: Joi.forbidden(),
+  } ).description( 'Array of context options for this metric' ),
+} );
+
+/**
+ * Main Cohort Creation Schema
+ */
+export const cohortCreationSchema = Joi.object( {
+  clientId: Joi.string().required().description( 'Client identifier' ),
+  cohortId: Joi.string().required().pattern( /^[a-z0-9_-]+$/ ).description( 'Unique cohort identifier' ),
+  cohortName: Joi.string().required().min( 3 ).max( 100 ).description( 'Name of the cohort' ),
+  cohortDescription: Joi.string().required().min( 10 ).max( 500 ).description( 'Detailed cohort description' ),
+  metrics: Joi.array()
+      .items( metricSchema )
+      .required()
+      .min( 1 )
+      .max( 50 )
+      .description( 'Array of metrics defining the cohort' ),
+} ).strict();
+
+/**
+ * Cohort Update Schema (optional fields)
+ */
+export const cohortUpdateSchema = Joi.object( {
+  cohortName: Joi.string().min( 3 ).max( 100 ).optional(),
+  cohortDescription: Joi.string().min( 10 ).max( 500 ).optional(),
+  metrics: Joi.array().items( metricSchema ).min( 1 ).max( 50 ).optional(),
+} ).strict();
+
+/**
+ * Cohort Query Schema
+ */
+export const cohortQuerySchema = Joi.object( {
+  cohortId: Joi.string().optional(),
+  clientId: Joi.string().optional(),
+  cohortName: Joi.string().optional(),
+  limit: Joi.number().integer().min( 1 ).max( 100 ).default( 10 ),
+  offset: Joi.number().integer().min( 0 ).default( 0 ),
+} ).strict();
+
+/**
+ * Validate cohort data using Joi
+ * @param {Object} data - Data to validate
+ * @param {Joi.Schema} schema - Joi schema to validate against
+ * @return {Promise<{error: null, value: Object} | {error: Error, value: null}>}
+ */
+export const validateCohortData = async ( data, schema ) => {
+  try {
+    const { error, value } = schema.validate( data, {
+      abortEarly: false,
+      stripUnknown: true,
+      convert: true,
+    } );
+
+    if ( error ) {
+      const details = error.details.map( ( detail ) => ( {
+        field: detail.path.join( '.' ),
+        message: detail.message,
+        type: detail.type,
+      } ) );
+      return {
+        error: {
+          message: 'Validation failed',
+          details,
+        },
+        value: null,
+      };
+    }
+
+    return {
+      error: null,
+      value,
+    };
+  } catch ( err ) {
+    return {
+      error: {
+        message: 'Validation error',
+        details: [ { message: err.message } ],
+      },
+      value: null,
+    };
+  }
+};