@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.
369 lines • 36.5 kB
JavaScript
/**
* ElementQueryService - Orchestrator for element querying
*
* Coordinates pagination, filtering, and sorting services to provide
* a unified query interface for element collections.
*
* DESIGN PRINCIPLES:
* 1. Composition over inheritance - orchestrates independent services
* 2. Correct operation order: filter → sort → paginate
* 3. Complete metadata - returns all query context for debugging
* 4. Stateless - safe for concurrent use and DI injection
* 5. Validation - validates all inputs before processing
*
* OPERATION ORDER:
* The order of operations is critical for correctness and performance:
* 1. Filter: Reduce dataset to matching items only
* 2. Sort: Order the filtered results
* 3. Paginate: Extract requested page from sorted results
*
* This ensures that:
* - Pagination operates on complete filtered+sorted dataset
* - Sort operates on filtered dataset (more efficient)
* - Results are deterministic and reproducible
*
* CONCURRENT MODIFICATION BEHAVIOR:
* This service operates on element snapshots passed via the items parameter.
* It does not read from disk or track file system changes. If elements are
* modified on disk between fetch and query, results may be inconsistent with
* the current file system state. This is expected behavior - the service is
* stateless and designed for performance. For real-time consistency, callers
* should re-fetch elements before each query operation.
*
* @module ElementQueryService
*/
import { logger } from '../../utils/logger.js';
import { PaginationService } from './PaginationService.js';
import { FilterService } from './FilterService.js';
import { SortService } from './SortService.js';
/**
* ElementQueryService implementation
*
* Orchestrates three independent services to provide complete query capabilities:
* - FilterService: Applies filter criteria to element arrays
* - SortService: Sorts elements by specified fields
* - PaginationService: Paginates sorted results
*
* All services are injected via constructor for testability and flexibility.
*
* @template T - Element type extending IElement
*
* @example
* ```typescript
* // Using factory (recommended)
* const queryService = createElementQueryService<MyElement>();
*
* // Query with all options
* const result = queryService.query(elements, {
* filters: { tags: ['typescript'], status: 'active' },
* sort: { sortBy: 'modified', sortOrder: 'desc' },
* pagination: { page: 2, pageSize: 25 }
* });
*
* console.log(result.items); // Paginated items
* console.log(result.pagination); // Pagination metadata
* console.log(result.sorting); // Applied sorting
* console.log(result.filters.applied); // Applied filters
* ```
*/
export class ElementQueryService {
paginationService;
filterService;
sortService;
/**
* Create a new ElementQueryService with injected dependencies
*
* DEPENDENCY INJECTION:
* All services are provided via constructor to enable:
* - Easy testing with mocks
* - Service customization
* - Container-based DI integration
*
* @param paginationService - Service for pagination operations
* @param filterService - Service for filtering operations
* @param sortService - Service for sorting operations
*/
constructor(paginationService, filterService, sortService) {
this.paginationService = paginationService;
this.filterService = filterService;
this.sortService = sortService;
}
/**
* Execute a complete query operation with full metadata
*
* OPERATION ORDER:
* 1. Validate all query options
* 2. Filter items based on criteria
* 3. Sort filtered items
* 4. Paginate sorted items
* 5. Build complete result with metadata
*
* The returned QueryResult includes:
* - items: The paginated subset of matching items
* - pagination: Complete pagination metadata
* - sorting: Applied sorting configuration
* - filters: Summary of applied filters
*
* SNAPSHOT SEMANTICS:
* This method operates on the items array passed to it at the time of the call.
* It does not re-read elements from disk or track file system changes. If elements
* are modified on disk between when they are fetched and when this method is called,
* the results will reflect the state at fetch time, not the current file system state.
* This is expected behavior for a stateless query service. For real-time consistency,
* callers should re-fetch elements immediately before calling this method.
*
* @param items - Array of elements to query (snapshot at time of call)
* @param options - Complete query configuration
* @returns Query result with items and complete metadata
* @throws {Error} If query options are invalid
*
* @example
* ```typescript
* const result = queryService.query(allPersonas, {
* filters: {
* nameContains: 'code',
* tags: ['typescript'],
* status: 'active'
* },
* sort: {
* sortBy: 'modified',
* sortOrder: 'desc'
* },
* pagination: {
* page: 1,
* pageSize: 10
* }
* });
*
* // Use result
* console.log(`Showing ${result.items.length} of ${result.pagination.totalItems} items`);
* console.log(`Sorted by ${result.sorting.sortBy} (${result.sorting.sortOrder})`);
* console.log(`Applied ${result.filters.applied.count} filters`);
* ```
*/
query(items, options) {
// Step 1: Validate all options
this.validateOptions(options);
// Step 2: Apply filters
const filteredItems = this.filterService.filter(items, options?.filters);
const appliedFilters = this.filterService.summarizeFilters(options?.filters);
// Step 3: Sort filtered items
const sortedItems = this.sortService.sort(filteredItems, options?.sort);
const appliedSorting = {
sortBy: options?.sort?.sortBy ?? this.sortService.getDefaultSorting().sortBy,
sortOrder: options?.sort?.sortOrder ?? this.sortService.getDefaultSorting().sortOrder,
};
// Step 4: Paginate sorted items
const paginatedResult = this.paginationService.paginate(sortedItems, options?.pagination);
// Step 5: Build complete query result
const result = {
items: paginatedResult.items,
pagination: paginatedResult.pagination,
sorting: appliedSorting,
filters: {
applied: appliedFilters,
},
};
return result;
}
/**
* Execute query and return only the items (no metadata)
*
* Convenience method for cases where you only need the items
* and don't care about pagination metadata, applied filters, etc.
*
* This is equivalent to calling query() and extracting result.items,
* but may be more convenient for simple use cases.
*
* @param items - Array of elements to query
* @param options - Complete query configuration
* @returns Array of items matching query (paginated)
* @throws {Error} If query options are invalid
*
* @example
* ```typescript
* // Get just the items, ignore metadata
* const items = queryService.queryItems(allPersonas, {
* filters: { status: 'active' },
* sort: { sortBy: 'name' }
* });
*
* // Use items directly
* items.forEach(item => console.log(item.metadata.name));
* ```
*/
queryItems(items, options) {
const result = this.query(items, options);
return result.items;
}
/**
* Get the default query options
*
* Returns a complete QueryOptions object with all defaults filled in.
* Useful for:
* - Understanding what defaults are used
* - Building option objects incrementally
* - Testing and documentation
*
* @returns Default query configuration with all fields specified
*
* @example
* ```typescript
* const defaults = queryService.getDefaultOptions();
* console.log(defaults);
* // {
* // pagination: { page: 1, pageSize: 25 },
* // filters: {},
* // sort: { sortBy: 'name', sortOrder: 'asc' }
* // }
*
* // Use as base for custom options
* const customOptions = {
* ...defaults,
* filters: { status: 'active' }
* };
* ```
*/
getDefaultOptions() {
const defaultSorting = this.sortService.getDefaultSorting();
return {
pagination: {
page: 1,
pageSize: 20,
},
filters: {},
sort: {
sortBy: defaultSorting.sortBy,
sortOrder: defaultSorting.sortOrder,
},
aggregate: {},
};
}
/**
* Validate query options without executing query
*
* Validates all three option types:
* - Pagination options via PaginationService
* - Filter criteria via FilterService
* - Sort options via SortService
*
* Use this to validate user input before executing a query,
* or to test option validity during development.
*
* @param options - Query options to validate
* @returns True if all options are valid
* @throws {Error} If any options are invalid with descriptive message
*
* @example
* ```typescript
* try {
* queryService.validateOptions(userOptions);
* // Options are valid, proceed with query
* const result = queryService.query(items, userOptions);
* } catch (error) {
* // Options are invalid, show error to user
* console.error('Invalid query options:', error.message);
* }
* ```
*/
validateOptions(options) {
if (!options) {
return true; // No options is valid (use defaults)
}
try {
// Validate filter criteria
if (options.filters) {
this.filterService.validateCriteria(options.filters);
}
// Validate sort options
if (options.sort) {
this.sortService.validateOptions(options.sort);
}
// Validate pagination options
// PaginationService validates in paginate(), but we can validate structure here
if (options.pagination) {
this.validatePaginationStructure(options.pagination);
}
return true;
}
catch (error) {
logger.error('ElementQueryService.validateOptions failed', {
error: error instanceof Error ? error.message : String(error),
});
throw error;
}
}
/**
* Validate pagination options structure
*
* Performs basic type and range validation for pagination options.
* The PaginationService will perform additional validation during
* actual pagination, but this catches obvious errors early.
*
* @param pagination - Pagination options to validate
* @throws {Error} If pagination options are invalid
*
* @private
*/
validatePaginationStructure(pagination) {
if (pagination.page !== undefined) {
if (!Number.isInteger(pagination.page) || pagination.page < 1) {
throw new Error('Pagination page must be a positive integer');
}
}
if (pagination.pageSize !== undefined) {
if (!Number.isInteger(pagination.pageSize) || pagination.pageSize < 1) {
throw new Error('Pagination pageSize must be a positive integer');
}
}
}
}
/**
* Factory function to create a new ElementQueryService instance
*
* Creates a complete ElementQueryService with all dependencies instantiated.
* This is the recommended way to create a query service for most use cases.
*
* For custom dependency injection or testing, you can construct
* ElementQueryService directly with mock services.
*
* @template T - Element type extending IElement
* @returns New ElementQueryService instance with all dependencies
*
* @example
* ```typescript
* // Create service for a specific element type
* const personaQueryService = createElementQueryService<Persona>();
* const skillQueryService = createElementQueryService<Skill>();
*
* // Use immediately
* const results = personaQueryService.query(personas, {
* filters: { status: 'active' },
* sort: { sortBy: 'name' },
* pagination: { page: 1, pageSize: 10 }
* });
* ```
*/
export function createElementQueryService() {
const paginationService = new PaginationService();
const filterService = new FilterService();
const sortService = new SortService();
return new ElementQueryService(paginationService, filterService, sortService);
}
/**
* Singleton instance for convenience
*
* Provides a ready-to-use query service for cases where DI is not needed
* or when sharing a single instance across the application is acceptable.
*
* Since the service is stateless, sharing is safe for concurrent use.
*
* @example
* ```typescript
* import { elementQueryService } from './ElementQueryService.js';
*
* const result = elementQueryService.query(items, options);
* ```
*/
export const elementQueryService = createElementQueryService();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ElementQueryService.js","sourceRoot":"","sources":["../../../src/services/query/ElementQueryService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ElementQueryService - Orchestrator for element querying\n *\n * Coordinates pagination, filtering, and sorting services to provide\n * a unified query interface for element collections.\n *\n * DESIGN PRINCIPLES:\n * 1. Composition over inheritance - orchestrates independent services\n * 2. Correct operation order: filter → sort → paginate\n * 3. Complete metadata - returns all query context for debugging\n * 4. Stateless - safe for concurrent use and DI injection\n * 5. Validation - validates all inputs before processing\n *\n * OPERATION ORDER:\n * The order of operations is critical for correctness and performance:\n * 1. Filter: Reduce dataset to matching items only\n * 2. Sort: Order the filtered results\n * 3. Paginate: Extract requested page from sorted results\n *\n * This ensures that:\n * - Pagination operates on complete filtered+sorted dataset\n * - Sort operates on filtered dataset (more efficient)\n * - Results are deterministic and reproducible\n *\n * CONCURRENT MODIFICATION BEHAVIOR:\n * This service operates on element snapshots passed via the items parameter.\n * It does not read from disk or track file system changes. If elements are\n * modified on disk between fetch and query, results may be inconsistent with\n * the current file system state. This is expected behavior - the service is\n * stateless and designed for performance. For real-time consistency, callers\n * should re-fetch elements before each query operation.\n *\n * @module ElementQueryService\n */\n\nimport { IElement } from '../../types/elements/IElement.js';\nimport { logger } from '../../utils/logger.js';\nimport {\n  IElementQueryService,\n  IPaginationService,\n  IFilterService,\n  ISortService,\n  QueryOptions,\n  QueryResult,\n  PaginationOptions,\n} from './types.js';\nimport { PaginationService } from './PaginationService.js';\nimport { FilterService } from './FilterService.js';\nimport { SortService } from './SortService.js';\n\n/**\n * ElementQueryService implementation\n *\n * Orchestrates three independent services to provide complete query capabilities:\n * - FilterService: Applies filter criteria to element arrays\n * - SortService: Sorts elements by specified fields\n * - PaginationService: Paginates sorted results\n *\n * All services are injected via constructor for testability and flexibility.\n *\n * @template T - Element type extending IElement\n *\n * @example\n * ```typescript\n * // Using factory (recommended)\n * const queryService = createElementQueryService<MyElement>();\n *\n * // Query with all options\n * const result = queryService.query(elements, {\n *   filters: { tags: ['typescript'], status: 'active' },\n *   sort: { sortBy: 'modified', sortOrder: 'desc' },\n *   pagination: { page: 2, pageSize: 25 }\n * });\n *\n * console.log(result.items);           // Paginated items\n * console.log(result.pagination);      // Pagination metadata\n * console.log(result.sorting);         // Applied sorting\n * console.log(result.filters.applied); // Applied filters\n * ```\n */\nexport class ElementQueryService<T extends IElement = IElement> implements IElementQueryService<T> {\n  /**\n   * Create a new ElementQueryService with injected dependencies\n   *\n   * DEPENDENCY INJECTION:\n   * All services are provided via constructor to enable:\n   * - Easy testing with mocks\n   * - Service customization\n   * - Container-based DI integration\n   *\n   * @param paginationService - Service for pagination operations\n   * @param filterService - Service for filtering operations\n   * @param sortService - Service for sorting operations\n   */\n  constructor(\n    private readonly paginationService: IPaginationService<T>,\n    private readonly filterService: IFilterService<T>,\n    private readonly sortService: ISortService<T>\n  ) {}\n\n  /**\n   * Execute a complete query operation with full metadata\n   *\n   * OPERATION ORDER:\n   * 1. Validate all query options\n   * 2. Filter items based on criteria\n   * 3. Sort filtered items\n   * 4. Paginate sorted items\n   * 5. Build complete result with metadata\n   *\n   * The returned QueryResult includes:\n   * - items: The paginated subset of matching items\n   * - pagination: Complete pagination metadata\n   * - sorting: Applied sorting configuration\n   * - filters: Summary of applied filters\n   *\n   * SNAPSHOT SEMANTICS:\n   * This method operates on the items array passed to it at the time of the call.\n   * It does not re-read elements from disk or track file system changes. If elements\n   * are modified on disk between when they are fetched and when this method is called,\n   * the results will reflect the state at fetch time, not the current file system state.\n   * This is expected behavior for a stateless query service. For real-time consistency,\n   * callers should re-fetch elements immediately before calling this method.\n   *\n   * @param items - Array of elements to query (snapshot at time of call)\n   * @param options - Complete query configuration\n   * @returns Query result with items and complete metadata\n   * @throws {Error} If query options are invalid\n   *\n   * @example\n   * ```typescript\n   * const result = queryService.query(allPersonas, {\n   *   filters: {\n   *     nameContains: 'code',\n   *     tags: ['typescript'],\n   *     status: 'active'\n   *   },\n   *   sort: {\n   *     sortBy: 'modified',\n   *     sortOrder: 'desc'\n   *   },\n   *   pagination: {\n   *     page: 1,\n   *     pageSize: 10\n   *   }\n   * });\n   *\n   * // Use result\n   * console.log(`Showing ${result.items.length} of ${result.pagination.totalItems} items`);\n   * console.log(`Sorted by ${result.sorting.sortBy} (${result.sorting.sortOrder})`);\n   * console.log(`Applied ${result.filters.applied.count} filters`);\n   * ```\n   */\n  public query(items: T[], options?: QueryOptions): QueryResult<T> {\n    // Step 1: Validate all options\n    this.validateOptions(options);\n\n    // Step 2: Apply filters\n    const filteredItems = this.filterService.filter(items, options?.filters);\n    const appliedFilters = this.filterService.summarizeFilters(options?.filters);\n\n    // Step 3: Sort filtered items\n    const sortedItems = this.sortService.sort(filteredItems, options?.sort);\n    const appliedSorting = {\n      sortBy: options?.sort?.sortBy ?? this.sortService.getDefaultSorting().sortBy,\n      sortOrder: options?.sort?.sortOrder ?? this.sortService.getDefaultSorting().sortOrder,\n    };\n\n    // Step 4: Paginate sorted items\n    const paginatedResult = this.paginationService.paginate(sortedItems, options?.pagination);\n\n    // Step 5: Build complete query result\n    const result: QueryResult<T> = {\n      items: paginatedResult.items,\n      pagination: paginatedResult.pagination,\n      sorting: appliedSorting,\n      filters: {\n        applied: appliedFilters,\n      },\n    };\n\n    return result;\n  }\n\n  /**\n   * Execute query and return only the items (no metadata)\n   *\n   * Convenience method for cases where you only need the items\n   * and don't care about pagination metadata, applied filters, etc.\n   *\n   * This is equivalent to calling query() and extracting result.items,\n   * but may be more convenient for simple use cases.\n   *\n   * @param items - Array of elements to query\n   * @param options - Complete query configuration\n   * @returns Array of items matching query (paginated)\n   * @throws {Error} If query options are invalid\n   *\n   * @example\n   * ```typescript\n   * // Get just the items, ignore metadata\n   * const items = queryService.queryItems(allPersonas, {\n   *   filters: { status: 'active' },\n   *   sort: { sortBy: 'name' }\n   * });\n   *\n   * // Use items directly\n   * items.forEach(item => console.log(item.metadata.name));\n   * ```\n   */\n  public queryItems(items: T[], options?: QueryOptions): T[] {\n    const result = this.query(items, options);\n    return result.items;\n  }\n\n  /**\n   * Get the default query options\n   *\n   * Returns a complete QueryOptions object with all defaults filled in.\n   * Useful for:\n   * - Understanding what defaults are used\n   * - Building option objects incrementally\n   * - Testing and documentation\n   *\n   * @returns Default query configuration with all fields specified\n   *\n   * @example\n   * ```typescript\n   * const defaults = queryService.getDefaultOptions();\n   * console.log(defaults);\n   * // {\n   * //   pagination: { page: 1, pageSize: 25 },\n   * //   filters: {},\n   * //   sort: { sortBy: 'name', sortOrder: 'asc' }\n   * // }\n   *\n   * // Use as base for custom options\n   * const customOptions = {\n   *   ...defaults,\n   *   filters: { status: 'active' }\n   * };\n   * ```\n   */\n  public getDefaultOptions(): Required<QueryOptions> {\n    const defaultSorting = this.sortService.getDefaultSorting();\n\n    return {\n      pagination: {\n        page: 1,\n        pageSize: 20,\n      },\n      filters: {},\n      sort: {\n        sortBy: defaultSorting.sortBy,\n        sortOrder: defaultSorting.sortOrder,\n      },\n      aggregate: {},\n    };\n  }\n\n  /**\n   * Validate query options without executing query\n   *\n   * Validates all three option types:\n   * - Pagination options via PaginationService\n   * - Filter criteria via FilterService\n   * - Sort options via SortService\n   *\n   * Use this to validate user input before executing a query,\n   * or to test option validity during development.\n   *\n   * @param options - Query options to validate\n   * @returns True if all options are valid\n   * @throws {Error} If any options are invalid with descriptive message\n   *\n   * @example\n   * ```typescript\n   * try {\n   *   queryService.validateOptions(userOptions);\n   *   // Options are valid, proceed with query\n   *   const result = queryService.query(items, userOptions);\n   * } catch (error) {\n   *   // Options are invalid, show error to user\n   *   console.error('Invalid query options:', error.message);\n   * }\n   * ```\n   */\n  public validateOptions(options?: QueryOptions): boolean {\n    if (!options) {\n      return true; // No options is valid (use defaults)\n    }\n\n    try {\n      // Validate filter criteria\n      if (options.filters) {\n        this.filterService.validateCriteria(options.filters);\n      }\n\n      // Validate sort options\n      if (options.sort) {\n        this.sortService.validateOptions(options.sort);\n      }\n\n      // Validate pagination options\n      // PaginationService validates in paginate(), but we can validate structure here\n      if (options.pagination) {\n        this.validatePaginationStructure(options.pagination);\n      }\n\n      return true;\n    } catch (error) {\n      logger.error('ElementQueryService.validateOptions failed', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n      throw error;\n    }\n  }\n\n  /**\n   * Validate pagination options structure\n   *\n   * Performs basic type and range validation for pagination options.\n   * The PaginationService will perform additional validation during\n   * actual pagination, but this catches obvious errors early.\n   *\n   * @param pagination - Pagination options to validate\n   * @throws {Error} If pagination options are invalid\n   *\n   * @private\n   */\n  private validatePaginationStructure(pagination: PaginationOptions): void {\n    if (pagination.page !== undefined) {\n      if (!Number.isInteger(pagination.page) || pagination.page < 1) {\n        throw new Error('Pagination page must be a positive integer');\n      }\n    }\n\n    if (pagination.pageSize !== undefined) {\n      if (!Number.isInteger(pagination.pageSize) || pagination.pageSize < 1) {\n        throw new Error('Pagination pageSize must be a positive integer');\n      }\n    }\n  }\n}\n\n/**\n * Factory function to create a new ElementQueryService instance\n *\n * Creates a complete ElementQueryService with all dependencies instantiated.\n * This is the recommended way to create a query service for most use cases.\n *\n * For custom dependency injection or testing, you can construct\n * ElementQueryService directly with mock services.\n *\n * @template T - Element type extending IElement\n * @returns New ElementQueryService instance with all dependencies\n *\n * @example\n * ```typescript\n * // Create service for a specific element type\n * const personaQueryService = createElementQueryService<Persona>();\n * const skillQueryService = createElementQueryService<Skill>();\n *\n * // Use immediately\n * const results = personaQueryService.query(personas, {\n *   filters: { status: 'active' },\n *   sort: { sortBy: 'name' },\n *   pagination: { page: 1, pageSize: 10 }\n * });\n * ```\n */\nexport function createElementQueryService<T extends IElement>(): IElementQueryService<T> {\n  const paginationService = new PaginationService<T>();\n  const filterService = new FilterService<T>();\n  const sortService = new SortService<T>();\n\n  return new ElementQueryService<T>(paginationService, filterService, sortService);\n}\n\n/**\n * Singleton instance for convenience\n *\n * Provides a ready-to-use query service for cases where DI is not needed\n * or when sharing a single instance across the application is acceptable.\n *\n * Since the service is stateless, sharing is safe for concurrent use.\n *\n * @example\n * ```typescript\n * import { elementQueryService } from './ElementQueryService.js';\n *\n * const result = elementQueryService.query(items, options);\n * ```\n */\nexport const elementQueryService = createElementQueryService<IElement>();\n"]}