@stackmemoryai/stackmemory 0.5.58 → 0.5.59

package/dist/src/core/database/query-router.js

@@ -0,0 +1,430 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { logger } from "../monitoring/logger.js";
+import { DatabaseError, ErrorCode } from "../errors/index.js";
+import { EventEmitter } from "events";
+class QueryRouter extends EventEmitter {
+  tiers = /* @__PURE__ */ new Map();
+  metrics;
+  decisionCache = /* @__PURE__ */ new Map();
+  cacheExpiration = 6e4;
+  // 1 minute
+  maxCacheSize = 1e3;
+  constructor() {
+    super();
+    this.metrics = {
+      totalQueries: 0,
+      queriesByTier: /* @__PURE__ */ new Map(),
+      queriesByType: /* @__PURE__ */ new Map(),
+      averageLatency: 0,
+      latencyByTier: /* @__PURE__ */ new Map(),
+      errorsByTier: /* @__PURE__ */ new Map(),
+      cacheHitRate: 0,
+      routingDecisions: 0
+    };
+  }
+  /**
+   * Register a storage tier with the router
+   */
+  registerTier(tier) {
+    this.tiers.set(tier.name, tier);
+    logger.info(
+      `Registered storage tier: ${tier.name} (priority: ${tier.priority})`
+    );
+    this.emit("tierRegistered", tier);
+  }
+  /**
+   * Remove a storage tier from the router
+   */
+  unregisterTier(tierName) {
+    const tier = this.tiers.get(tierName);
+    if (tier) {
+      this.tiers.delete(tierName);
+      logger.info(`Unregistered storage tier: ${tierName}`);
+      this.emit("tierUnregistered", tier);
+    }
+  }
+  /**
+   * Route a query to the most appropriate storage tier
+   */
+  async route(operation, context, executor) {
+    const startTime = Date.now();
+    this.metrics.totalQueries++;
+    this.metrics.queriesByType.set(
+      context.queryType,
+      (this.metrics.queriesByType.get(context.queryType) || 0) + 1
+    );
+    try {
+      const decision = await this.makeRoutingDecision(operation, context);
+      try {
+        const result = await this.executeOnTier(decision.primaryTier, executor);
+        this.updateMetrics(decision.primaryTier.name, startTime, true);
+        return result;
+      } catch (error) {
+        logger.warn(
+          `Query failed on primary tier ${decision.primaryTier.name}:`,
+          error
+        );
+        this.updateMetrics(decision.primaryTier.name, startTime, false);
+        for (const fallbackTier of decision.fallbackTiers) {
+          try {
+            logger.info(`Attempting fallback to tier: ${fallbackTier.name}`);
+            const result = await this.executeOnTier(fallbackTier, executor);
+            this.updateMetrics(fallbackTier.name, startTime, true);
+            return result;
+          } catch (fallbackError) {
+            logger.warn(
+              `Query failed on fallback tier ${fallbackTier.name}:`,
+              fallbackError
+            );
+            this.updateMetrics(fallbackTier.name, startTime, false);
+          }
+        }
+        throw error;
+      }
+    } catch (error) {
+      logger.error("Query routing failed:", error);
+      this.emit("routingError", { operation, context, error });
+      throw error;
+    }
+  }
+  /**
+   * Make routing decision based on query context
+   */
+  async makeRoutingDecision(operation, context) {
+    const cacheKey = this.generateCacheKey(operation, context);
+    const cached = this.decisionCache.get(cacheKey);
+    if (cached && Date.now() - cached.estimatedLatency < this.cacheExpiration) {
+      this.metrics.cacheHitRate = (this.metrics.cacheHitRate * this.metrics.routingDecisions + 1) / (this.metrics.routingDecisions + 1);
+      return cached;
+    }
+    this.metrics.routingDecisions++;
+    const evaluations = [];
+    for (const tier of this.tiers.values()) {
+      const score = await this.evaluateTier(tier, operation, context);
+      const rationale = this.generateRationale(tier, operation, context, score);
+      evaluations.push({ tier, score, rationale });
+    }
+    evaluations.sort((a, b) => b.score - a.score);
+    if (evaluations.length === 0) {
+      throw new DatabaseError(
+        "No storage tiers available for routing",
+        ErrorCode.DB_CONNECTION_FAILED,
+        { query: context.query, tiersConfigured: this.tiers.length }
+      );
+    }
+    const primaryEval = evaluations[0];
+    const fallbackTiers = evaluations.slice(1).map((evaluation) => evaluation.tier);
+    const decision = {
+      primaryTier: primaryEval.tier,
+      fallbackTiers,
+      rationale: primaryEval.rationale,
+      confidence: primaryEval.score,
+      estimatedLatency: this.estimateLatency(
+        primaryEval.tier,
+        operation,
+        context
+      ),
+      cacheRecommendation: this.recommendCacheStrategy(
+        primaryEval.tier,
+        context
+      )
+    };
+    this.cacheDecision(cacheKey, decision);
+    logger.debug(
+      `Routing decision: ${decision.primaryTier.name} (confidence: ${decision.confidence.toFixed(2)})`
+    );
+    this.emit("routingDecision", { operation, context, decision });
+    return decision;
+  }
+  /**
+   * Evaluate how well a tier fits the query requirements
+   */
+  async evaluateTier(tier, operation, context) {
+    let score = 0;
+    let maxScore = 0;
+    for (const rule of tier.config.routingRules) {
+      maxScore += rule.weight;
+      if (this.evaluateRule(rule, operation, context, tier)) {
+        score += rule.weight;
+      }
+    }
+    if (tier.config.preferredOperations.includes(context.queryType)) {
+      score += 0.2;
+      maxScore += 0.2;
+    }
+    if (context.requiredFeatures) {
+      const supportedFeatures = context.requiredFeatures.filter(
+        (feature) => tier.config.supportedFeatures.includes(feature)
+      );
+      if (supportedFeatures.length === context.requiredFeatures.length) {
+        score += 0.3;
+      }
+      maxScore += 0.3;
+    }
+    const currentLoad = await this.getCurrentLoad(tier);
+    if (tier.config.maxThroughput && currentLoad < tier.config.maxThroughput * 0.8) {
+      score += 0.1;
+    }
+    maxScore += 0.1;
+    if (await this.isWithinCapacity(tier)) {
+      score += 0.1;
+    }
+    maxScore += 0.1;
+    return maxScore > 0 ? score / maxScore : 0;
+  }
+  /**
+   * Evaluate a single routing rule
+   */
+  evaluateRule(rule, _operation, context, _tier) {
+    let actualValue;
+    switch (rule.condition) {
+      case "age":
+        if (context.frames && context.frames.length > 0) {
+          const avgAge = context.frames.reduce(
+            (sum, frame) => sum + (Date.now() - frame.created_at),
+            0
+          ) / context.frames.length;
+          actualValue = avgAge;
+        } else if (context.timeRange) {
+          actualValue = Date.now() - context.timeRange.end.getTime();
+        } else {
+          return false;
+        }
+        break;
+      case "query_type":
+        actualValue = context.queryType;
+        break;
+      case "feature":
+        actualValue = context.requiredFeatures || [];
+        break;
+      case "priority":
+        actualValue = context.priority || "medium";
+        break;
+      case "size":
+        actualValue = context.frames ? context.frames.length : 0;
+        break;
+      default:
+        return false;
+    }
+    return this.compareValues(actualValue, rule.operator, rule.value);
+  }
+  /**
+   * Compare values based on operator
+   */
+  compareValues(actual, operator, expected) {
+    switch (operator) {
+      case ">":
+        return actual > expected;
+      case "<":
+        return actual < expected;
+      case "=":
+      case "==":
+        return actual === expected;
+      case "!=":
+        return actual !== expected;
+      case "in":
+        return Array.isArray(expected) && expected.includes(actual);
+      case "not_in":
+        return Array.isArray(expected) && !expected.includes(actual);
+      case "contains":
+        return Array.isArray(actual) && actual.some((item) => expected.includes(item));
+      default:
+        return false;
+    }
+  }
+  /**
+   * Execute query on specific tier
+   */
+  async executeOnTier(tier, executor) {
+    const startTime = Date.now();
+    try {
+      const result = await executor(tier.adapter);
+      const duration = Date.now() - startTime;
+      logger.debug(`Query executed on tier ${tier.name} in ${duration}ms`);
+      this.emit("queryExecuted", {
+        tierName: tier.name,
+        duration,
+        success: true
+      });
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      logger.error(
+        `Query failed on tier ${tier.name} after ${duration}ms:`,
+        error
+      );
+      this.emit("queryExecuted", {
+        tierName: tier.name,
+        duration,
+        success: false,
+        error
+      });
+      throw error;
+    }
+  }
+  /**
+   * Generate cache key for routing decisions
+   */
+  generateCacheKey(operation, context) {
+    const keyParts = [
+      operation,
+      context.queryType,
+      context.priority || "medium",
+      (context.requiredFeatures || []).sort().join(","),
+      context.timeRange ? `${context.timeRange.start.getTime()}-${context.timeRange.end.getTime()}` : ""
+    ];
+    return keyParts.join("|");
+  }
+  /**
+   * Cache routing decision
+   */
+  cacheDecision(key, decision) {
+    if (this.decisionCache.size >= this.maxCacheSize) {
+      const firstKey = this.decisionCache.keys().next().value;
+      this.decisionCache.delete(firstKey);
+    }
+    this.decisionCache.set(key, decision);
+  }
+  /**
+   * Estimate query latency for a tier
+   */
+  estimateLatency(tier, operation, context) {
+    const baseLatency = this.metrics.latencyByTier.get(tier.name) || tier.config.maxLatency || 100;
+    let multiplier = 1;
+    switch (context.queryType) {
+      case "search":
+        multiplier = 1.5;
+        break;
+      case "analytics":
+        multiplier = 2;
+        break;
+      case "bulk":
+        multiplier = 3;
+        break;
+      default:
+        multiplier = 1;
+    }
+    return baseLatency * multiplier;
+  }
+  /**
+   * Recommend cache strategy for the context
+   */
+  recommendCacheStrategy(tier, context) {
+    if (context.cacheStrategy && context.cacheStrategy !== "none") {
+      return context.cacheStrategy;
+    }
+    if (tier.name === "hot" || tier.name === "memory") {
+      return "read_write";
+    } else if (context.queryType === "read") {
+      return "read";
+    }
+    return "none";
+  }
+  /**
+   * Generate human-readable rationale for routing decision
+   */
+  generateRationale(tier, operation, context, score) {
+    const reasons = [];
+    if (tier.config.preferredOperations.includes(context.queryType)) {
+      reasons.push(`optimized for ${context.queryType} operations`);
+    }
+    if (context.requiredFeatures?.every(
+      (feature) => tier.config.supportedFeatures.includes(feature)
+    )) {
+      reasons.push(
+        `supports all required features (${context.requiredFeatures.join(", ")})`
+      );
+    }
+    if (score > 0.8) {
+      reasons.push("high confidence match");
+    } else if (score > 0.6) {
+      reasons.push("good match");
+    } else if (score > 0.4) {
+      reasons.push("acceptable match");
+    }
+    return reasons.length > 0 ? reasons.join(", ") : "default tier selection";
+  }
+  /**
+   * Get current load for a tier
+   */
+  async getCurrentLoad(tier) {
+    return this.metrics.queriesByTier.get(tier.name) || 0;
+  }
+  /**
+   * Check if tier is within capacity limits
+   */
+  async isWithinCapacity(tier) {
+    try {
+      const stats = await tier.adapter.getStats();
+      if (tier.config.maxFrames && stats.totalFrames >= tier.config.maxFrames) {
+        return false;
+      }
+      if (tier.config.maxSizeMB && stats.diskUsage >= tier.config.maxSizeMB * 1024 * 1024) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.warn(`Failed to check capacity for tier ${tier.name}:`, error);
+      return true;
+    }
+  }
+  /**
+   * Update routing metrics
+   */
+  updateMetrics(tierName, startTime, success) {
+    const duration = Date.now() - startTime;
+    this.metrics.queriesByTier.set(
+      tierName,
+      (this.metrics.queriesByTier.get(tierName) || 0) + 1
+    );
+    if (success) {
+      const currentAvg = this.metrics.latencyByTier.get(tierName) || 0;
+      const count = this.metrics.queriesByTier.get(tierName) || 1;
+      const newAvg = (currentAvg * (count - 1) + duration) / count;
+      this.metrics.latencyByTier.set(tierName, newAvg);
+      this.metrics.averageLatency = (this.metrics.averageLatency * (this.metrics.totalQueries - 1) + duration) / this.metrics.totalQueries;
+    } else {
+      this.metrics.errorsByTier.set(
+        tierName,
+        (this.metrics.errorsByTier.get(tierName) || 0) + 1
+      );
+    }
+  }
+  /**
+   * Get current routing metrics
+   */
+  getMetrics() {
+    const cacheRequests = this.metrics.routingDecisions;
+    const cacheHits = cacheRequests - this.decisionCache.size;
+    this.metrics.cacheHitRate = cacheRequests > 0 ? cacheHits / cacheRequests : 0;
+    return { ...this.metrics };
+  }
+  /**
+   * Get registered tiers
+   */
+  getTiers() {
+    return Array.from(this.tiers.values()).sort(
+      (a, b) => b.priority - a.priority
+    );
+  }
+  /**
+   * Clear routing decision cache
+   */
+  clearCache() {
+    this.decisionCache.clear();
+    logger.info("Routing decision cache cleared");
+  }
+  /**
+   * Get tier by name
+   */
+  getTier(name) {
+    return this.tiers.get(name);
+  }
+}
+export {
+  QueryRouter
+};
+//# sourceMappingURL=query-router.js.map

package/dist/src/core/database/query-router.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/database/query-router.ts"],
+  "sourcesContent": ["/**\n * Query Router for Tiered Storage\n * Routes database queries to appropriate storage tier based on data age, query type, and performance requirements\n */\n\nimport { DatabaseAdapter } from './database-adapter.js';\nimport type { Frame } from '../context/index.js';\nimport { logger } from '../monitoring/logger.js';\nimport { DatabaseError, ErrorCode } from '../errors/index.js';\nimport { EventEmitter } from 'events';\n\nexport interface StorageTier {\n  name: string;\n  adapter: DatabaseAdapter;\n  priority: number;\n  config: TierConfig;\n}\n\nexport interface TierConfig {\n  // Data age thresholds\n  maxAge?: number; // Data older than this goes to next tier (ms)\n  minAge?: number; // Data newer than this stays in this tier (ms)\n\n  // Query type preferences\n  preferredOperations: string[]; // ['read', 'write', 'search', 'analytics']\n  supportedFeatures: string[]; // ['full_text', 'vector', 'aggregation']\n\n  // Performance characteristics\n  maxLatency?: number; // Max acceptable latency for this tier (ms)\n  maxThroughput?: number; // Max queries per second this tier can handle\n\n  // Capacity limits\n  maxFrames?: number; // Max frames before promoting to next tier\n  maxSizeMB?: number; // Max storage size in MB\n\n  // Routing rules\n  routingRules: RoutingRule[];\n}\n\nexport interface RoutingRule {\n  condition: string; // 'age' | 'size' | 'query_type' | 'load' | 'feature'\n  operator: string; // '>', '<', '=', '!=', 'in', 'not_in'\n  value: any; // Comparison value\n  weight: number; // Rule weight (0-1)\n}\n\nexport interface QueryContext {\n  queryType: 'read' | 'write' | 'search' | 'analytics' | 'bulk';\n  frames?: Frame[];\n  frameIds?: string[];\n  requiredFeatures?: string[];\n  timeRange?: { start: Date; end: Date };\n  priority?: 'low' | 'medium' | 'high' | 'critical';\n  timeout?: number;\n  cacheStrategy?: 'none' | 'read' | 'write' | 'read_write';\n}\n\nexport interface RoutingDecision {\n  primaryTier: StorageTier;\n  fallbackTiers: StorageTier[];\n  rationale: string;\n  confidence: number; // 0-1 confidence in decision\n  estimatedLatency: number; // Estimated query latency (ms)\n  cacheRecommendation?: string;\n}\n\nexport interface QueryMetrics {\n  totalQueries: number;\n  queriesByTier: Map<string, number>;\n  queriesByType: Map<string, number>;\n  averageLatency: number;\n  latencyByTier: Map<string, number>;\n  errorsByTier: Map<string, number>;\n  cacheHitRate: number;\n  routingDecisions: number;\n}\n\nexport class QueryRouter extends EventEmitter {\n  private tiers: Map<string, StorageTier> = new Map();\n  private metrics: QueryMetrics;\n  private decisionCache: Map<string, RoutingDecision> = new Map();\n  private readonly cacheExpiration = 60000; // 1 minute\n  private readonly maxCacheSize = 1000;\n\n  constructor() {\n    super();\n    this.metrics = {\n      totalQueries: 0,\n      queriesByTier: new Map(),\n      queriesByType: new Map(),\n      averageLatency: 0,\n      latencyByTier: new Map(),\n      errorsByTier: new Map(),\n      cacheHitRate: 0,\n      routingDecisions: 0,\n    };\n  }\n\n  /**\n   * Register a storage tier with the router\n   */\n  registerTier(tier: StorageTier): void {\n    this.tiers.set(tier.name, tier);\n    logger.info(\n      `Registered storage tier: ${tier.name} (priority: ${tier.priority})`\n    );\n    this.emit('tierRegistered', tier);\n  }\n\n  /**\n   * Remove a storage tier from the router\n   */\n  unregisterTier(tierName: string): void {\n    const tier = this.tiers.get(tierName);\n    if (tier) {\n      this.tiers.delete(tierName);\n      logger.info(`Unregistered storage tier: ${tierName}`);\n      this.emit('tierUnregistered', tier);\n    }\n  }\n\n  /**\n   * Route a query to the most appropriate storage tier\n   */\n  async route<T>(\n    operation: string,\n    context: QueryContext,\n    executor: (adapter: DatabaseAdapter) => Promise<T>\n  ): Promise<T> {\n    const startTime = Date.now();\n    this.metrics.totalQueries++;\n    this.metrics.queriesByType.set(\n      context.queryType,\n      (this.metrics.queriesByType.get(context.queryType) || 0) + 1\n    );\n\n    try {\n      // Get routing decision\n      const decision = await this.makeRoutingDecision(operation, context);\n\n      // Try primary tier first\n      try {\n        const result = await this.executeOnTier(decision.primaryTier, executor);\n        this.updateMetrics(decision.primaryTier.name, startTime, true);\n        return result;\n      } catch (error: unknown) {\n        logger.warn(\n          `Query failed on primary tier ${decision.primaryTier.name}:`,\n          error\n        );\n        this.updateMetrics(decision.primaryTier.name, startTime, false);\n\n        // Try fallback tiers\n        for (const fallbackTier of decision.fallbackTiers) {\n          try {\n            logger.info(`Attempting fallback to tier: ${fallbackTier.name}`);\n            const result = await this.executeOnTier(fallbackTier, executor);\n            this.updateMetrics(fallbackTier.name, startTime, true);\n            return result;\n          } catch (fallbackError: unknown) {\n            logger.warn(\n              `Query failed on fallback tier ${fallbackTier.name}:`,\n              fallbackError\n            );\n            this.updateMetrics(fallbackTier.name, startTime, false);\n          }\n        }\n\n        // If all tiers failed, throw the original error\n        throw error;\n      }\n    } catch (error: unknown) {\n      logger.error('Query routing failed:', error);\n      this.emit('routingError', { operation, context, error });\n      throw error;\n    }\n  }\n\n  /**\n   * Make routing decision based on query context\n   */\n  private async makeRoutingDecision(\n    operation: string,\n    context: QueryContext\n  ): Promise<RoutingDecision> {\n    // Check cache first\n    const cacheKey = this.generateCacheKey(operation, context);\n    const cached = this.decisionCache.get(cacheKey);\n    if (cached && Date.now() - cached.estimatedLatency < this.cacheExpiration) {\n      this.metrics.cacheHitRate =\n        (this.metrics.cacheHitRate * this.metrics.routingDecisions + 1) /\n        (this.metrics.routingDecisions + 1);\n      return cached;\n    }\n\n    this.metrics.routingDecisions++;\n\n    // Evaluate each tier\n    const evaluations: Array<{\n      tier: StorageTier;\n      score: number;\n      rationale: string;\n    }> = [];\n\n    for (const tier of this.tiers.values()) {\n      const score = await this.evaluateTier(tier, operation, context);\n      const rationale = this.generateRationale(tier, operation, context, score);\n      evaluations.push({ tier, score, rationale });\n    }\n\n    // Sort by score (highest first)\n    evaluations.sort((a, b) => b.score - a.score);\n\n    if (evaluations.length === 0) {\n      throw new DatabaseError(\n        'No storage tiers available for routing',\n        ErrorCode.DB_CONNECTION_FAILED,\n        { query: context.query, tiersConfigured: this.tiers.length }\n      );\n    }\n\n    const primaryEval = evaluations[0];\n    const fallbackTiers = evaluations\n      .slice(1)\n      .map((evaluation) => evaluation.tier);\n\n    const decision: RoutingDecision = {\n      primaryTier: primaryEval.tier,\n      fallbackTiers,\n      rationale: primaryEval.rationale,\n      confidence: primaryEval.score,\n      estimatedLatency: this.estimateLatency(\n        primaryEval.tier,\n        operation,\n        context\n      ),\n      cacheRecommendation: this.recommendCacheStrategy(\n        primaryEval.tier,\n        context\n      ),\n    };\n\n    // Cache decision\n    this.cacheDecision(cacheKey, decision);\n\n    logger.debug(\n      `Routing decision: ${decision.primaryTier.name} (confidence: ${decision.confidence.toFixed(2)})`\n    );\n    this.emit('routingDecision', { operation, context, decision });\n\n    return decision;\n  }\n\n  /**\n   * Evaluate how well a tier fits the query requirements\n   */\n  private async evaluateTier(\n    tier: StorageTier,\n    operation: string,\n    context: QueryContext\n  ): Promise<number> {\n    let score = 0;\n    let maxScore = 0;\n\n    // Evaluate each routing rule\n    for (const rule of tier.config.routingRules) {\n      maxScore += rule.weight;\n\n      if (this.evaluateRule(rule, operation, context, tier)) {\n        score += rule.weight;\n      }\n    }\n\n    // Check operation preference\n    if (tier.config.preferredOperations.includes(context.queryType)) {\n      score += 0.2;\n      maxScore += 0.2;\n    }\n\n    // Check feature support\n    if (context.requiredFeatures) {\n      const supportedFeatures = context.requiredFeatures.filter((feature) =>\n        tier.config.supportedFeatures.includes(feature)\n      );\n      if (supportedFeatures.length === context.requiredFeatures.length) {\n        score += 0.3;\n      }\n      maxScore += 0.3;\n    }\n\n    // Check current load\n    const currentLoad = await this.getCurrentLoad(tier);\n    if (\n      tier.config.maxThroughput &&\n      currentLoad < tier.config.maxThroughput * 0.8\n    ) {\n      score += 0.1;\n    }\n    maxScore += 0.1;\n\n    // Check capacity\n    if (await this.isWithinCapacity(tier)) {\n      score += 0.1;\n    }\n    maxScore += 0.1;\n\n    return maxScore > 0 ? score / maxScore : 0;\n  }\n\n  /**\n   * Evaluate a single routing rule\n   */\n  private evaluateRule(\n    rule: RoutingRule,\n    _operation: string,\n    context: QueryContext,\n    _tier: StorageTier\n  ): boolean {\n    let actualValue: any;\n\n    switch (rule.condition) {\n      case 'age':\n        // Check data age if frames are provided\n        if (context.frames && context.frames.length > 0) {\n          const avgAge =\n            context.frames.reduce(\n              (sum, frame) => sum + (Date.now() - frame.created_at),\n              0\n            ) / context.frames.length;\n          actualValue = avgAge;\n        } else if (context.timeRange) {\n          actualValue = Date.now() - context.timeRange.end.getTime();\n        } else {\n          return false;\n        }\n        break;\n\n      case 'query_type':\n        actualValue = context.queryType;\n        break;\n\n      case 'feature':\n        actualValue = context.requiredFeatures || [];\n        break;\n\n      case 'priority':\n        actualValue = context.priority || 'medium';\n        break;\n\n      case 'size':\n        actualValue = context.frames ? context.frames.length : 0;\n        break;\n\n      default:\n        return false;\n    }\n\n    return this.compareValues(actualValue, rule.operator, rule.value);\n  }\n\n  /**\n   * Compare values based on operator\n   */\n  private compareValues(actual: any, operator: string, expected: any): boolean {\n    switch (operator) {\n      case '>':\n        return actual > expected;\n      case '<':\n        return actual < expected;\n      case '=':\n      case '==':\n        return actual === expected;\n      case '!=':\n        return actual !== expected;\n      case 'in':\n        return Array.isArray(expected) && expected.includes(actual);\n      case 'not_in':\n        return Array.isArray(expected) && !expected.includes(actual);\n      case 'contains':\n        return (\n          Array.isArray(actual) &&\n          actual.some((item) => expected.includes(item))\n        );\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Execute query on specific tier\n   */\n  private async executeOnTier<T>(\n    tier: StorageTier,\n    executor: (adapter: DatabaseAdapter) => Promise<T>\n  ): Promise<T> {\n    const startTime = Date.now();\n\n    try {\n      const result = await executor(tier.adapter);\n      const duration = Date.now() - startTime;\n\n      logger.debug(`Query executed on tier ${tier.name} in ${duration}ms`);\n      this.emit('queryExecuted', {\n        tierName: tier.name,\n        duration,\n        success: true,\n      });\n\n      return result;\n    } catch (error: unknown) {\n      const duration = Date.now() - startTime;\n\n      logger.error(\n        `Query failed on tier ${tier.name} after ${duration}ms:`,\n        error\n      );\n      this.emit('queryExecuted', {\n        tierName: tier.name,\n        duration,\n        success: false,\n        error,\n      });\n\n      throw error;\n    }\n  }\n\n  /**\n   * Generate cache key for routing decisions\n   */\n  private generateCacheKey(operation: string, context: QueryContext): string {\n    const keyParts = [\n      operation,\n      context.queryType,\n      context.priority || 'medium',\n      (context.requiredFeatures || []).sort().join(','),\n      context.timeRange\n        ? `${context.timeRange.start.getTime()}-${context.timeRange.end.getTime()}`\n        : '',\n    ];\n\n    return keyParts.join('|');\n  }\n\n  /**\n   * Cache routing decision\n   */\n  private cacheDecision(key: string, decision: RoutingDecision): void {\n    // Implement LRU eviction if cache is full\n    if (this.decisionCache.size >= this.maxCacheSize) {\n      const firstKey = this.decisionCache.keys().next().value;\n      this.decisionCache.delete(firstKey);\n    }\n\n    this.decisionCache.set(key, decision);\n  }\n\n  /**\n   * Estimate query latency for a tier\n   */\n  private estimateLatency(\n    tier: StorageTier,\n    operation: string,\n    context: QueryContext\n  ): number {\n    const baseLatency =\n      this.metrics.latencyByTier.get(tier.name) ||\n      tier.config.maxLatency ||\n      100;\n\n    // Adjust based on operation type\n    let multiplier = 1;\n    switch (context.queryType) {\n      case 'search':\n        multiplier = 1.5;\n        break;\n      case 'analytics':\n        multiplier = 2.0;\n        break;\n      case 'bulk':\n        multiplier = 3.0;\n        break;\n      default:\n        multiplier = 1.0;\n    }\n\n    return baseLatency * multiplier;\n  }\n\n  /**\n   * Recommend cache strategy for the context\n   */\n  private recommendCacheStrategy(\n    tier: StorageTier,\n    context: QueryContext\n  ): string {\n    if (context.cacheStrategy && context.cacheStrategy !== 'none') {\n      return context.cacheStrategy;\n    }\n\n    // Default recommendations based on query type and tier\n    if (tier.name === 'hot' || tier.name === 'memory') {\n      return 'read_write';\n    } else if (context.queryType === 'read') {\n      return 'read';\n    }\n\n    return 'none';\n  }\n\n  /**\n   * Generate human-readable rationale for routing decision\n   */\n  private generateRationale(\n    tier: StorageTier,\n    operation: string,\n    context: QueryContext,\n    score: number\n  ): string {\n    const reasons = [];\n\n    if (tier.config.preferredOperations.includes(context.queryType)) {\n      reasons.push(`optimized for ${context.queryType} operations`);\n    }\n\n    if (\n      context.requiredFeatures?.every((feature) =>\n        tier.config.supportedFeatures.includes(feature)\n      )\n    ) {\n      reasons.push(\n        `supports all required features (${context.requiredFeatures.join(', ')})`\n      );\n    }\n\n    if (score > 0.8) {\n      reasons.push('high confidence match');\n    } else if (score > 0.6) {\n      reasons.push('good match');\n    } else if (score > 0.4) {\n      reasons.push('acceptable match');\n    }\n\n    return reasons.length > 0 ? reasons.join(', ') : 'default tier selection';\n  }\n\n  /**\n   * Get current load for a tier\n   */\n  private async getCurrentLoad(tier: StorageTier): Promise<number> {\n    // This would integrate with actual monitoring\n    // For now, return a placeholder based on recent queries\n    return this.metrics.queriesByTier.get(tier.name) || 0;\n  }\n\n  /**\n   * Check if tier is within capacity limits\n   */\n  private async isWithinCapacity(tier: StorageTier): Promise<boolean> {\n    try {\n      const stats = await tier.adapter.getStats();\n\n      if (tier.config.maxFrames && stats.totalFrames >= tier.config.maxFrames) {\n        return false;\n      }\n\n      if (\n        tier.config.maxSizeMB &&\n        stats.diskUsage >= tier.config.maxSizeMB * 1024 * 1024\n      ) {\n        return false;\n      }\n\n      return true;\n    } catch (error: unknown) {\n      logger.warn(`Failed to check capacity for tier ${tier.name}:`, error);\n      return true; // Assume capacity is OK if we can't check\n    }\n  }\n\n  /**\n   * Update routing metrics\n   */\n  private updateMetrics(\n    tierName: string,\n    startTime: number,\n    success: boolean\n  ): void {\n    const duration = Date.now() - startTime;\n\n    // Update tier metrics\n    this.metrics.queriesByTier.set(\n      tierName,\n      (this.metrics.queriesByTier.get(tierName) || 0) + 1\n    );\n\n    if (success) {\n      // Update latency\n      const currentAvg = this.metrics.latencyByTier.get(tierName) || 0;\n      const count = this.metrics.queriesByTier.get(tierName) || 1;\n      const newAvg = (currentAvg * (count - 1) + duration) / count;\n      this.metrics.latencyByTier.set(tierName, newAvg);\n\n      // Update overall average\n      this.metrics.averageLatency =\n        (this.metrics.averageLatency * (this.metrics.totalQueries - 1) +\n          duration) /\n        this.metrics.totalQueries;\n    } else {\n      // Update error count\n      this.metrics.errorsByTier.set(\n        tierName,\n        (this.metrics.errorsByTier.get(tierName) || 0) + 1\n      );\n    }\n  }\n\n  /**\n   * Get current routing metrics\n   */\n  getMetrics(): QueryMetrics {\n    // Update cache hit rate\n    const cacheRequests = this.metrics.routingDecisions;\n    const cacheHits = cacheRequests - this.decisionCache.size; // Approximation\n    this.metrics.cacheHitRate =\n      cacheRequests > 0 ? cacheHits / cacheRequests : 0;\n\n    return { ...this.metrics };\n  }\n\n  /**\n   * Get registered tiers\n   */\n  getTiers(): StorageTier[] {\n    return Array.from(this.tiers.values()).sort(\n      (a, b) => b.priority - a.priority\n    );\n  }\n\n  /**\n   * Clear routing decision cache\n   */\n  clearCache(): void {\n    this.decisionCache.clear();\n    logger.info('Routing decision cache cleared');\n  }\n\n  /**\n   * Get tier by name\n   */\n  getTier(name: string): StorageTier | undefined {\n    return this.tiers.get(name);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}