@objectstack/service-analytics 4.0.4 → 4.1.0

package/src/__tests__/analytics-service.test.ts

@@ -1,469 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { Cube } from '@objectstack/spec/data';
-import type { AnalyticsQuery, AnalyticsResult, IAnalyticsService } from '@objectstack/spec/contracts';
-import { AnalyticsService } from '../analytics-service.js';
-import { CubeRegistry } from '../cube-registry.js';
-import { NativeSQLStrategy } from '../strategies/native-sql-strategy.js';
-import { ObjectQLStrategy } from '../strategies/objectql-strategy.js';
-import type { DriverCapabilities } from '../strategies/types.js';
-
-// ─────────────────────────────────────────────────────────────────
-// Test fixtures
-// ─────────────────────────────────────────────────────────────────
-
-const ordersCube: Cube = {
-  name: 'orders',
-  title: 'Orders',
-  sql: 'orders',
-  measures: {
-    count: { name: 'count', label: 'Count', type: 'count', sql: '*' },
-    total_amount: { name: 'total_amount', label: 'Total Amount', type: 'sum', sql: 'amount' },
-    avg_amount: { name: 'avg_amount', label: 'Avg Amount', type: 'avg', sql: 'amount' },
-  },
-  dimensions: {
-    status: { name: 'status', label: 'Status', type: 'string', sql: 'status' },
-    created_at: {
-      name: 'created_at',
-      label: 'Created At',
-      type: 'time',
-      sql: 'created_at',
-      granularities: ['day', 'week', 'month'],
-    },
-  },
-  public: false,
-};
-
-const baseQuery: AnalyticsQuery = {
-  cube: 'orders',
-  measures: ['orders.count', 'orders.total_amount'],
-  dimensions: ['orders.status'],
-};
-
-// Suppress logger output in tests
-const silentLogger = {
-  info: vi.fn(),
-  debug: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-  child: vi.fn().mockReturnThis(),
-} as any;
-
-// ─────────────────────────────────────────────────────────────────
-// CubeRegistry
-// ─────────────────────────────────────────────────────────────────
-
-describe('CubeRegistry', () => {
-  let registry: CubeRegistry;
-
-  beforeEach(() => {
-    registry = new CubeRegistry();
-  });
-
-  it('should register and retrieve a cube', () => {
-    registry.register(ordersCube);
-    expect(registry.get('orders')).toEqual(ordersCube);
-    expect(registry.has('orders')).toBe(true);
-    expect(registry.size).toBe(1);
-  });
-
-  it('should register multiple cubes at once', () => {
-    const cube2: Cube = { ...ordersCube, name: 'products', sql: 'products' };
-    registry.registerAll([ordersCube, cube2]);
-    expect(registry.size).toBe(2);
-    expect(registry.names()).toEqual(['orders', 'products']);
-  });
-
-  it('should return undefined for unknown cube', () => {
-    expect(registry.get('nonexistent')).toBeUndefined();
-    expect(registry.has('nonexistent')).toBe(false);
-  });
-
-  it('should clear all cubes', () => {
-    registry.register(ordersCube);
-    registry.clear();
-    expect(registry.size).toBe(0);
-  });
-
-  it('should infer a cube from object fields', () => {
-    const cube = registry.inferFromObject('tasks', [
-      { name: 'title', type: 'text', label: 'Title' },
-      { name: 'hours', type: 'number', label: 'Hours' },
-      { name: 'due_date', type: 'date', label: 'Due Date' },
-      { name: 'active', type: 'boolean', label: 'Active' },
-    ]);
-
-    expect(cube.name).toBe('tasks');
-    expect(cube.measures.count).toBeDefined();
-    expect(cube.measures.hours_sum).toBeDefined();
-    expect(cube.measures.hours_avg).toBeDefined();
-    expect(cube.dimensions.title.type).toBe('string');
-    expect(cube.dimensions.hours.type).toBe('number');
-    expect(cube.dimensions.due_date.type).toBe('time');
-    expect(cube.dimensions.active.type).toBe('boolean');
-
-    // Should also be registered automatically
-    expect(registry.get('tasks')).toBe(cube);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// NativeSQLStrategy
-// ─────────────────────────────────────────────────────────────────
-
-describe('NativeSQLStrategy', () => {
-  const strategy = new NativeSQLStrategy();
-
-  it('should have correct name and priority', () => {
-    expect(strategy.name).toBe('NativeSQLStrategy');
-    expect(strategy.priority).toBe(10);
-  });
-
-  it('should handle when nativeSql capability is true', () => {
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: true, objectqlAggregate: false, inMemory: false }),
-      executeRawSql: vi.fn(),
-    };
-    expect(strategy.canHandle(baseQuery, ctx)).toBe(true);
-  });
-
-  it('should not handle when nativeSql is false', () => {
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: false, objectqlAggregate: true, inMemory: false }),
-    };
-    expect(strategy.canHandle(baseQuery, ctx)).toBe(false);
-  });
-
-  it('should not handle when cube is missing', () => {
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: true, objectqlAggregate: false, inMemory: false }),
-      executeRawSql: vi.fn(),
-    };
-    expect(strategy.canHandle({ measures: ['count'] }, ctx)).toBe(false);
-  });
-
-  it('should generate SQL with dimensions, measures, and filters', async () => {
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: true, objectqlAggregate: false, inMemory: false }),
-      executeRawSql: vi.fn(),
-    };
-
-    const query: AnalyticsQuery = {
-      cube: 'orders',
-      measures: ['orders.count', 'orders.total_amount'],
-      dimensions: ['orders.status'],
-      filters: [{ member: 'orders.status', operator: 'equals', values: ['completed'] }],
-      limit: 10,
-    };
-
-    const { sql, params } = await strategy.generateSql(query, ctx);
-
-    expect(sql).toContain('SELECT');
-    expect(sql).toContain('COUNT(*)');
-    expect(sql).toContain('SUM(amount)');
-    expect(sql).toContain('GROUP BY');
-    expect(sql).toContain('LIMIT 10');
-    expect(params).toContain('completed');
-  });
-
-  it('should execute query and return structured result', async () => {
-    const mockRows = [
-      { 'orders.status': 'completed', 'orders.count': 5, 'orders.total_amount': 500 },
-    ];
-    const executeRawSql = vi.fn().mockResolvedValue(mockRows);
-
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: true, objectqlAggregate: false, inMemory: false }),
-      executeRawSql,
-    };
-
-    const result = await strategy.execute(baseQuery, ctx);
-
-    expect(executeRawSql).toHaveBeenCalled();
-    expect(result.rows).toEqual(mockRows);
-    expect(result.fields).toHaveLength(3); // 1 dimension + 2 measures
-    expect(result.sql).toBeDefined();
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// ObjectQLStrategy
-// ─────────────────────────────────────────────────────────────────
-
-describe('ObjectQLStrategy', () => {
-  const strategy = new ObjectQLStrategy();
-
-  it('should have correct name and priority', () => {
-    expect(strategy.name).toBe('ObjectQLStrategy');
-    expect(strategy.priority).toBe(20);
-  });
-
-  it('should handle when objectqlAggregate capability is true', () => {
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: false, objectqlAggregate: true, inMemory: false }),
-      executeAggregate: vi.fn(),
-    };
-    expect(strategy.canHandle(baseQuery, ctx)).toBe(true);
-  });
-
-  it('should not handle without executeAggregate', () => {
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: false, objectqlAggregate: true, inMemory: false }),
-    };
-    expect(strategy.canHandle(baseQuery, ctx)).toBe(false);
-  });
-
-  it('should execute an aggregate query', async () => {
-    const mockRows = [
-      { status: 'pending', 'orders.count': 3, 'orders.total_amount': 150 },
-    ];
-    const executeAggregate = vi.fn().mockResolvedValue(mockRows);
-
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: false, objectqlAggregate: true, inMemory: false }),
-      executeAggregate,
-    };
-
-    const result = await strategy.execute(baseQuery, ctx);
-
-    expect(executeAggregate).toHaveBeenCalledWith('orders', expect.objectContaining({
-      groupBy: ['status'],
-      aggregations: expect.arrayContaining([
-        expect.objectContaining({ method: 'count' }),
-        expect.objectContaining({ method: 'sum' }),
-      ]),
-    }));
-    expect(result.rows).toHaveLength(1);
-    expect(result.fields).toHaveLength(3);
-  });
-
-  it('should generate representative SQL', async () => {
-    const ctx = {
-      getCube: () => ordersCube,
-      queryCapabilities: () => ({ nativeSql: false, objectqlAggregate: true, inMemory: false }),
-      executeAggregate: vi.fn(),
-    };
-
-    const { sql } = await strategy.generateSql(baseQuery, ctx);
-    expect(sql).toContain('SELECT');
-    expect(sql).toContain('COUNT(*)');
-    expect(sql).toContain('GROUP BY');
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// FallbackDelegateStrategy (internal, tested via AnalyticsService)
-// ─────────────────────────────────────────────────────────────────
-
-describe('FallbackDelegateStrategy (via AnalyticsService)', () => {
-  it('should auto-add FallbackDelegateStrategy when fallbackService is configured', async () => {
-    const mockResult: AnalyticsResult = { rows: [{ count: 10 }], fields: [{ name: 'count', type: 'number' }] };
-    const fallback: IAnalyticsService = {
-      query: vi.fn().mockResolvedValue(mockResult),
-      getMeta: vi.fn().mockResolvedValue([]),
-    };
-
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      fallbackService: fallback,
-    });
-
-    const result = await service.query(baseQuery);
-    expect(fallback.query).toHaveBeenCalledWith(baseQuery);
-    expect(result).toEqual(mockResult);
-  });
-
-  it('should NOT add FallbackDelegateStrategy when no fallbackService', async () => {
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      queryCapabilities: () => ({ nativeSql: false, objectqlAggregate: false, inMemory: false }),
-    });
-
-    await expect(service.query(baseQuery)).rejects.toThrow('No strategy can handle');
-  });
-
-  it('should delegate generateSql to fallback service', async () => {
-    const fallback: IAnalyticsService = {
-      query: vi.fn(),
-      getMeta: vi.fn(),
-      generateSql: vi.fn().mockResolvedValue({ sql: 'SELECT 1', params: [] }),
-    };
-
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      fallbackService: fallback,
-    });
-
-    const { sql } = await service.generateSql(baseQuery);
-    expect(sql).toBe('SELECT 1');
-  });
-
-  it('should return placeholder SQL when fallback has no generateSql', async () => {
-    const fallback: IAnalyticsService = {
-      query: vi.fn().mockResolvedValue({ rows: [], fields: [] }),
-      getMeta: vi.fn(),
-    };
-
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      fallbackService: fallback,
-    });
-
-    const { sql } = await service.generateSql(baseQuery);
-    expect(sql).toContain('FallbackDelegateStrategy');
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// AnalyticsService (Orchestrator)
-// ─────────────────────────────────────────────────────────────────
-
-describe('AnalyticsService', () => {
-  it('should use NativeSQLStrategy when driver supports native SQL', async () => {
-    const mockRows = [{ count: 42 }];
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      queryCapabilities: () => ({ nativeSql: true, objectqlAggregate: true, inMemory: false }),
-      executeRawSql: vi.fn().mockResolvedValue(mockRows),
-    });
-
-    const result = await service.query(baseQuery);
-    expect(result.rows).toEqual(mockRows);
-    expect(result.sql).toBeDefined(); // NativeSQL always includes sql
-  });
-
-  it('should fall back to ObjectQLStrategy when nativeSql is false', async () => {
-    const mockRows = [{ status: 'pending', 'orders.count': 3, 'orders.total_amount': 100 }];
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      queryCapabilities: () => ({ nativeSql: false, objectqlAggregate: true, inMemory: false }),
-      executeAggregate: vi.fn().mockResolvedValue(mockRows),
-    });
-
-    const result = await service.query(baseQuery);
-    expect(result.rows).toHaveLength(1);
-  });
-
-  it('should fall back to FallbackDelegateStrategy with fallback service', async () => {
-    const mockResult: AnalyticsResult = {
-      rows: [{ count: 100 }],
-      fields: [{ name: 'count', type: 'number' }],
-    };
-    const fallback: IAnalyticsService = {
-      query: vi.fn().mockResolvedValue(mockResult),
-      getMeta: vi.fn().mockResolvedValue([]),
-    };
-
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      fallbackService: fallback,
-    });
-
-    const result = await service.query(baseQuery);
-    expect(result).toEqual(mockResult);
-    expect(fallback.query).toHaveBeenCalled();
-  });
-
-  it('should throw when no strategy can handle the query', async () => {
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      queryCapabilities: () => ({ nativeSql: false, objectqlAggregate: false, inMemory: false }),
-    });
-
-    await expect(service.query(baseQuery)).rejects.toThrow('No strategy can handle');
-  });
-
-  it('should throw when cube name is missing', async () => {
-    const service = new AnalyticsService({ logger: silentLogger });
-    await expect(service.query({ measures: ['count'] })).rejects.toThrow('Cube name is required');
-  });
-
-  it('should return cube metadata via getMeta()', async () => {
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-    });
-
-    const meta = await service.getMeta();
-    expect(meta).toHaveLength(1);
-    expect(meta[0].name).toBe('orders');
-    expect(meta[0].measures.length).toBeGreaterThan(0);
-    expect(meta[0].dimensions.length).toBeGreaterThan(0);
-  });
-
-  it('should filter getMeta() by cube name', async () => {
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-    });
-
-    const meta = await service.getMeta('orders');
-    expect(meta).toHaveLength(1);
-    expect(meta[0].name).toBe('orders');
-
-    const empty = await service.getMeta('nonexistent');
-    expect(empty).toHaveLength(0);
-  });
-
-  it('should generate SQL via generateSql()', async () => {
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      queryCapabilities: () => ({ nativeSql: true, objectqlAggregate: false, inMemory: false }),
-      executeRawSql: vi.fn(),
-    });
-
-    const { sql } = await service.generateSql(baseQuery);
-    expect(sql).toContain('SELECT');
-    expect(sql).toContain('COUNT(*)');
-  });
-
-  it('should expose cubeRegistry for external cube registration', () => {
-    const service = new AnalyticsService({ logger: silentLogger });
-    expect(service.cubeRegistry).toBeInstanceOf(CubeRegistry);
-    expect(service.cubeRegistry.size).toBe(0);
-
-    service.cubeRegistry.register(ordersCube);
-    expect(service.cubeRegistry.size).toBe(1);
-  });
-
-  it('should support strategy priority ordering', async () => {
-    // Custom strategy at priority 5 (before NativeSQL at 10)
-    const customStrategy = {
-      name: 'CustomStrategy',
-      priority: 5,
-      canHandle: () => true,
-      execute: vi.fn().mockResolvedValue({ rows: [{ custom: true }], fields: [] }),
-      generateSql: vi.fn().mockResolvedValue({ sql: 'CUSTOM', params: [] }),
-    };
-
-    const service = new AnalyticsService({
-      cubes: [ordersCube],
-      logger: silentLogger,
-      strategies: [customStrategy],
-      queryCapabilities: () => ({ nativeSql: true, objectqlAggregate: true, inMemory: false }),
-      executeRawSql: vi.fn(),
-    });
-
-    const result = await service.query(baseQuery);
-    expect(customStrategy.execute).toHaveBeenCalled();
-    expect(result.rows[0]).toEqual({ custom: true });
-  });
-});

package/src/analytics-service.ts

@@ -1,231 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type {
-  IAnalyticsService,
-  AnalyticsQuery,
-  AnalyticsResult,
-  CubeMeta,
-} from '@objectstack/spec/contracts';
-import type { Cube } from '@objectstack/spec/data';
-import type { Logger } from '@objectstack/spec/contracts';
-import { createLogger } from '@objectstack/core';
-import { CubeRegistry } from './cube-registry.js';
-import type { AnalyticsStrategy, DriverCapabilities, StrategyContext } from './strategies/types.js';
-import { NativeSQLStrategy } from './strategies/native-sql-strategy.js';
-import { ObjectQLStrategy } from './strategies/objectql-strategy.js';
-
-/**
- * Configuration for AnalyticsService.
- */
-export interface AnalyticsServiceConfig {
-  /** Pre-defined cube definitions (from manifest). */
-  cubes?: Cube[];
-  /** Logger instance. */
-  logger?: Logger;
-  /**
-   * Probe driver capabilities for the object that backs a cube.
-   * The service calls this function to decide which strategy can handle a query.
-   */
-  queryCapabilities?: (cubeName: string) => DriverCapabilities;
-  /**
-   * Execute raw SQL on the driver for a given object.
-   * Required for NativeSQLStrategy.
-   */
-  executeRawSql?: (objectName: string, sql: string, params: unknown[]) => Promise<Record<string, unknown>[]>;
-  /**
-   * Execute an ObjectQL aggregate query.
-   * Required for ObjectQLStrategy.
-   */
-  executeAggregate?: (objectName: string, options: {
-    groupBy?: string[];
-    aggregations?: Array<{ field: string; method: string; alias: string }>;
-    filter?: Record<string, unknown>;
-  }) => Promise<Record<string, unknown>[]>;
-  /**
-   * Fallback IAnalyticsService (e.g. MemoryAnalyticsService).
-   * Used by InMemoryStrategy.
-   */
-  fallbackService?: IAnalyticsService;
-  /**
-   * Custom strategies to add/replace the defaults.
-   * They are merged with the built-in strategies and sorted by priority.
-   */
-  strategies?: AnalyticsStrategy[];
-}
-
-/**
- * Default capabilities when probing is not configured — assumes in-memory only.
- */
-const DEFAULT_CAPABILITIES: DriverCapabilities = {
-  nativeSql: false,
-  objectqlAggregate: false,
-  inMemory: true,
-};
-
-/**
- * AnalyticsService — Multi-driver analytics orchestrator.
- *
- * Implements `IAnalyticsService` by delegating to a priority-ordered
- * strategy chain:
- *
- * | Priority | Strategy | Condition |
- * |:---:|:---|:---|
- * | P1 (10) | NativeSQLStrategy | Driver supports raw SQL |
- * | P2 (20) | ObjectQLStrategy | Driver supports aggregate AST |
- * | P3 (30) | (custom / InMemoryStrategy from driver-memory) | Injected by user |
- *
- * When `fallbackService` is configured, an internal delegate strategy
- * is automatically appended at priority 30 as a safety net.
- *
- * The service also owns a `CubeRegistry` for metadata discovery and
- * auto-inference from object schemas.
- */
-export class AnalyticsService implements IAnalyticsService {
-  private readonly strategies: AnalyticsStrategy[];
-  private readonly strategyCtx: StrategyContext;
-  readonly cubeRegistry: CubeRegistry;
-  private readonly logger: Logger;
-
-  constructor(config: AnalyticsServiceConfig = {}) {
-    this.logger = config.logger || createLogger({ level: 'info', format: 'pretty' });
-    this.cubeRegistry = new CubeRegistry();
-
-    // Register pre-defined cubes
-    if (config.cubes) {
-      this.cubeRegistry.registerAll(config.cubes);
-    }
-
-    // Build strategy context
-    this.strategyCtx = {
-      getCube: (name) => this.cubeRegistry.get(name),
-      queryCapabilities: config.queryCapabilities || (() => DEFAULT_CAPABILITIES),
-      executeRawSql: config.executeRawSql,
-      executeAggregate: config.executeAggregate,
-      fallbackService: config.fallbackService,
-    };
-
-    // Build strategy chain (built-in + custom, sorted by priority)
-    // InMemoryStrategy is NOT built-in — it lives in @objectstack/driver-memory
-    // and should be passed via config.strategies when needed.
-    // When fallbackService is configured, an internal delegate is added at P3.
-    const builtIn: AnalyticsStrategy[] = [
-      new NativeSQLStrategy(),
-      new ObjectQLStrategy(),
-    ];
-
-    // Auto-add fallback delegate when fallbackService is provided
-    if (config.fallbackService) {
-      builtIn.push(new FallbackDelegateStrategy());
-    }
-
-    const custom = config.strategies || [];
-    this.strategies = [...builtIn, ...custom].sort((a, b) => a.priority - b.priority);
-
-    this.logger.info(
-      `[Analytics] Initialized with ${this.cubeRegistry.size} cubes, ` +
-      `${this.strategies.length} strategies: ${this.strategies.map(s => s.name).join(' → ')}`,
-    );
-  }
-
-  /**
-   * Execute an analytical query by delegating to the first capable strategy.
-   */
-  async query(query: AnalyticsQuery): Promise<AnalyticsResult> {
-    if (!query.cube) {
-      throw new Error('Cube name is required in analytics query');
-    }
-
-    const strategy = this.resolveStrategy(query);
-    this.logger.debug(`[Analytics] Query on cube "${query.cube}" → ${strategy.name}`);
-
-    return strategy.execute(query, this.strategyCtx);
-  }
-
-  /**
-   * Get cube metadata for discovery.
-   */
-  async getMeta(cubeName?: string): Promise<CubeMeta[]> {
-    // If a fallback service is configured, merge its metadata with the registry
-    const cubes = cubeName
-      ? [this.cubeRegistry.get(cubeName)].filter(Boolean) as Cube[]
-      : this.cubeRegistry.getAll();
-
-    return cubes.map(cube => ({
-      name: cube.name,
-      title: cube.title,
-      measures: Object.entries(cube.measures).map(([key, measure]) => ({
-        name: `${cube.name}.${key}`,
-        type: measure.type,
-        title: measure.label,
-      })),
-      dimensions: Object.entries(cube.dimensions).map(([key, dimension]) => ({
-        name: `${cube.name}.${key}`,
-        type: dimension.type,
-        title: dimension.label,
-      })),
-    }));
-  }
-
-  /**
-   * Generate SQL for a query without executing it (dry-run).
-   */
-  async generateSql(query: AnalyticsQuery): Promise<{ sql: string; params: unknown[] }> {
-    if (!query.cube) {
-      throw new Error('Cube name is required for SQL generation');
-    }
-
-    const strategy = this.resolveStrategy(query);
-    this.logger.debug(`[Analytics] generateSql on cube "${query.cube}" → ${strategy.name}`);
-
-    return strategy.generateSql(query, this.strategyCtx);
-  }
-
-  // ── Internal ─────────────────────────────────────────────────────
-
-  /**
-   * Walk the strategy chain and return the first strategy that can handle the query.
-   */
-  private resolveStrategy(query: AnalyticsQuery): AnalyticsStrategy {
-    for (const strategy of this.strategies) {
-      if (strategy.canHandle(query, this.strategyCtx)) {
-        return strategy;
-      }
-    }
-    throw new Error(
-      `[Analytics] No strategy can handle query for cube "${query.cube}". ` +
-      `Checked: ${this.strategies.map(s => s.name).join(', ')}. ` +
-      'Ensure a compatible driver is configured or a fallback service is registered.',
-    );
-  }
-}
-
-/**
- * FallbackDelegateStrategy — Internal strategy for fallback service delegation.
- *
- * Automatically added to the strategy chain when `fallbackService` is configured.
- * Not exported — consumers who need explicit in-memory support should use
- * `InMemoryStrategy` from `@objectstack/driver-memory`.
- */
-class FallbackDelegateStrategy implements AnalyticsStrategy {
-  readonly name = 'FallbackDelegateStrategy';
-  readonly priority = 30;
-
-  canHandle(query: AnalyticsQuery, ctx: StrategyContext): boolean {
-    if (!query.cube) return false;
-    return !!ctx.fallbackService;
-  }
-
-  async execute(query: AnalyticsQuery, ctx: StrategyContext): Promise<AnalyticsResult> {
-    return ctx.fallbackService!.query(query);
-  }
-
-  async generateSql(query: AnalyticsQuery, ctx: StrategyContext): Promise<{ sql: string; params: unknown[] }> {
-    if (ctx.fallbackService?.generateSql) {
-      return ctx.fallbackService.generateSql(query);
-    }
-    return {
-      sql: `-- FallbackDelegateStrategy: SQL generation not supported for cube "${query.cube}"`,
-      params: [],
-    };
-  }
-}