@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
133 lines • 16.9 kB
JavaScript
/**
* AggregationService - Server-side count and group_by aggregation for elements
*
* Provides lightweight aggregation queries that return counts and groupings
* without fetching full paginated item lists. This saves ~98% of tokens
* compared to listing all items when only counts are needed.
*
* Issue #309: Token-efficient aggregation
*
* DESIGN:
* - Uses FilterService.filter() directly (not full query pipeline) for efficiency
* - Deduplicates array values in group_by to prevent double-counting
* - Validates group_by fields against a whitelist to prevent internal field exposure
* - Stateless and safe for concurrent use
*
* @module services/query/AggregationService
*/
import { getMetadataField } from './types.js';
import { FilterService } from './FilterService.js';
import { logger } from '../../utils/logger.js';
/**
* Metadata fields allowed for group_by aggregation.
*
* Only these fields can be used with group_by to prevent:
* - Exposure of internal/sensitive metadata fields
* - Arbitrary property enumeration attacks
* - Grouping on fields that produce meaningless results (e.g., timestamps)
*/
const ALLOWED_GROUP_BY_FIELDS = new Set([
'category',
'author',
'tags',
'status',
'version',
]);
/**
* Aggregate elements with optional filtering and grouping.
*
* Uses FilterService.filter() directly for efficiency — skips the sort and
* paginate steps that the full query pipeline would apply, since aggregation
* only needs to count elements, not order or slice them.
*
* @param elements - Full element array to aggregate over
* @param elementType - Element type string for the result
* @param options - Aggregation options (count, group_by)
* @param filters - Optional filter criteria to apply before aggregating
* @returns Aggregation result with count and optional groups
*
* @example
* ```typescript
* // Count all personas
* const result = aggregateElements(personas, 'persona', { count: true });
* // → { count: 42, element_type: 'persona' }
*
* // Count personas grouped by category
* const grouped = aggregateElements(personas, 'persona',
* { count: true, group_by: 'category' });
* // → { count: 42, element_type: 'persona', groups: { assistant: 15, creative: 27 } }
*
* // Count with filters
* const filtered = aggregateElements(personas, 'persona',
* { count: true, group_by: 'tags' },
* { status: 'active' });
* // → { count: 10, element_type: 'persona', groups: { typescript: 5, python: 3, rust: 2 } }
* ```
*/
export function aggregateElements(elements, elementType, options, filters) {
// Apply filters directly via FilterService (no sort/paginate needed)
const filterService = new FilterService();
const filtered = filters ? filterService.filter(elements, filters) : elements;
logger.debug('AggregationService.aggregate', {
inputCount: elements.length,
filteredCount: filtered.length,
hasGroupBy: !!options.group_by,
elementType,
});
const result = {
count: filtered.length,
element_type: elementType,
};
// group_by support with field validation and array deduplication
if (options.group_by) {
const field = options.group_by;
// Validate field against whitelist
if (!ALLOWED_GROUP_BY_FIELDS.has(field)) {
const allowed = [...ALLOWED_GROUP_BY_FIELDS].sort((a, b) => a.localeCompare(b)).join(', ');
throw new Error(`Invalid group_by field '${field}'. Allowed fields: ${allowed}`);
}
const groups = {};
for (const el of filtered) {
const value = getMetadataField(el, field);
if (Array.isArray(value)) {
// Deduplicate array values to prevent double-counting
// e.g., tags: ['a', 'a', 'b'] → counts 'a' once, 'b' once for this element
const unique = [...new Set(value.map(String))];
for (const v of unique) {
groups[v] = (groups[v] || 0) + 1;
}
}
else {
const key = value != null ? String(value) : 'unknown';
groups[key] = (groups[key] || 0) + 1;
}
}
result.groups = groups;
}
return result;
}
/**
* Validate aggregation options before execution.
*
* @param options - Aggregation options to validate
* @returns null if valid, error message string if invalid
*/
export function validateAggregationOptions(options) {
if (options.group_by) {
if (typeof options.group_by !== 'string') {
return 'aggregate.group_by must be a string';
}
if (!ALLOWED_GROUP_BY_FIELDS.has(options.group_by)) {
const allowed = [...ALLOWED_GROUP_BY_FIELDS].sort((a, b) => a.localeCompare(b)).join(', ');
return `Invalid group_by field '${options.group_by}'. Allowed fields: ${allowed}`;
}
}
return null;
}
/**
* Get the set of allowed group_by fields (for introspection/documentation).
*/
export function getAllowedGroupByFields() {
return [...ALLOWED_GROUP_BY_FIELDS].sort((a, b) => a.localeCompare(b));
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AggregationService.js","sourceRoot":"","sources":["../../../src/services/query/AggregationService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AggregationService - Server-side count and group_by aggregation for elements\n *\n * Provides lightweight aggregation queries that return counts and groupings\n * without fetching full paginated item lists. This saves ~98% of tokens\n * compared to listing all items when only counts are needed.\n *\n * Issue #309: Token-efficient aggregation\n *\n * DESIGN:\n * - Uses FilterService.filter() directly (not full query pipeline) for efficiency\n * - Deduplicates array values in group_by to prevent double-counting\n * - Validates group_by fields against a whitelist to prevent internal field exposure\n * - Stateless and safe for concurrent use\n *\n * @module services/query/AggregationService\n */\n\nimport { IElement } from '../../types/elements/IElement.js';\nimport { FilterCriteria, AggregationOptions, getMetadataField } from './types.js';\nimport { FilterService } from './FilterService.js';\nimport { logger } from '../../utils/logger.js';\n\n/**\n * Result of an aggregation query.\n *\n * @example\n * ```typescript\n * // Count only:\n * { count: 42, element_type: 'persona' }\n *\n * // Count with group_by:\n * { count: 42, element_type: 'persona', groups: { 'assistant': 15, 'creative': 12, 'technical': 15 } }\n * ```\n */\nexport interface AggregationResult {\n  /** Total number of elements matching filters (or all elements if no filters) */\n  count: number;\n  /** Element type that was aggregated */\n  element_type: string;\n  /** Group counts when group_by is specified. Maps field values to occurrence counts. */\n  groups?: Record<string, number>;\n}\n\n/**\n * Metadata fields allowed for group_by aggregation.\n *\n * Only these fields can be used with group_by to prevent:\n * - Exposure of internal/sensitive metadata fields\n * - Arbitrary property enumeration attacks\n * - Grouping on fields that produce meaningless results (e.g., timestamps)\n */\nconst ALLOWED_GROUP_BY_FIELDS = new Set([\n  'category',\n  'author',\n  'tags',\n  'status',\n  'version',\n]);\n\n/**\n * Aggregate elements with optional filtering and grouping.\n *\n * Uses FilterService.filter() directly for efficiency — skips the sort and\n * paginate steps that the full query pipeline would apply, since aggregation\n * only needs to count elements, not order or slice them.\n *\n * @param elements - Full element array to aggregate over\n * @param elementType - Element type string for the result\n * @param options - Aggregation options (count, group_by)\n * @param filters - Optional filter criteria to apply before aggregating\n * @returns Aggregation result with count and optional groups\n *\n * @example\n * ```typescript\n * // Count all personas\n * const result = aggregateElements(personas, 'persona', { count: true });\n * // → { count: 42, element_type: 'persona' }\n *\n * // Count personas grouped by category\n * const grouped = aggregateElements(personas, 'persona',\n *   { count: true, group_by: 'category' });\n * // → { count: 42, element_type: 'persona', groups: { assistant: 15, creative: 27 } }\n *\n * // Count with filters\n * const filtered = aggregateElements(personas, 'persona',\n *   { count: true, group_by: 'tags' },\n *   { status: 'active' });\n * // → { count: 10, element_type: 'persona', groups: { typescript: 5, python: 3, rust: 2 } }\n * ```\n */\nexport function aggregateElements(\n  elements: IElement[],\n  elementType: string,\n  options: AggregationOptions,\n  filters?: FilterCriteria\n): AggregationResult {\n  // Apply filters directly via FilterService (no sort/paginate needed)\n  const filterService = new FilterService<IElement>();\n  const filtered = filters ? filterService.filter(elements, filters) : elements;\n\n  logger.debug('AggregationService.aggregate', {\n    inputCount: elements.length,\n    filteredCount: filtered.length,\n    hasGroupBy: !!options.group_by,\n    elementType,\n  });\n\n  const result: AggregationResult = {\n    count: filtered.length,\n    element_type: elementType,\n  };\n\n  // group_by support with field validation and array deduplication\n  if (options.group_by) {\n    const field = options.group_by;\n\n    // Validate field against whitelist\n    if (!ALLOWED_GROUP_BY_FIELDS.has(field)) {\n      const allowed = [...ALLOWED_GROUP_BY_FIELDS].sort((a, b) => a.localeCompare(b)).join(', ');\n      throw new Error(\n        `Invalid group_by field '${field}'. Allowed fields: ${allowed}`\n      );\n    }\n\n    const groups: Record<string, number> = {};\n\n    for (const el of filtered) {\n      const value = getMetadataField(el, field);\n\n      if (Array.isArray(value)) {\n        // Deduplicate array values to prevent double-counting\n        // e.g., tags: ['a', 'a', 'b'] → counts 'a' once, 'b' once for this element\n        const unique = [...new Set(value.map(String))];\n        for (const v of unique) {\n          groups[v] = (groups[v] || 0) + 1;\n        }\n      } else {\n        const key = value != null ? String(value) : 'unknown';\n        groups[key] = (groups[key] || 0) + 1;\n      }\n    }\n\n    result.groups = groups;\n  }\n\n  return result;\n}\n\n/**\n * Validate aggregation options before execution.\n *\n * @param options - Aggregation options to validate\n * @returns null if valid, error message string if invalid\n */\nexport function validateAggregationOptions(options: AggregationOptions): string | null {\n  if (options.group_by) {\n    if (typeof options.group_by !== 'string') {\n      return 'aggregate.group_by must be a string';\n    }\n    if (!ALLOWED_GROUP_BY_FIELDS.has(options.group_by)) {\n      const allowed = [...ALLOWED_GROUP_BY_FIELDS].sort((a, b) => a.localeCompare(b)).join(', ');\n      return `Invalid group_by field '${options.group_by}'. Allowed fields: ${allowed}`;\n    }\n  }\n  return null;\n}\n\n/**\n * Get the set of allowed group_by fields (for introspection/documentation).\n */\nexport function getAllowedGroupByFields(): string[] {\n  return [...ALLOWED_GROUP_BY_FIELDS].sort((a, b) => a.localeCompare(b));\n}\n"]}