refactor: Remove deprecated queue events bus functionality

The queue event bus was deprecated and is no longer needed.

This completes the removal of the deprecated queue events bus system
across the entire codebase.

Author: ovr

.gitignore

@@ -24,3 +24,4 @@ rust/cubesql/profile.json
 .cubestore
 .env
 .vimspector.json
+.claude/settings.local.json

CLAUDE.md

@@ -0,0 +1,137 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Repository Overview
+
+Cube is a semantic layer for building data applications. This is a monorepo containing the complete Cube ecosystem including:
+- Cube backend server and core components
+- Client libraries for JavaScript/React/Vue/Angular
+- Database drivers for various data sources
+- Documentation site
+- Rust components (CubeSQL, CubeStore)
+
+## Development Commands
+
+**Note: This project uses Yarn as the package manager.**
+
+### Core Build Commands
+```bash
+# Build all packages
+yarn build
+
+# Run TypeScript compilation across all packages
+yarn tsc
+
+# Watch mode for TypeScript compilation
+yarn tsc:watch
+
+# Clean build artifacts
+yarn clean
+
+# Run linting across all packages
+yarn lint
+
+# Fix linting issues
+yarn lint:fix
+
+# Lint package.json files
+yarn lint:npm
+```
+
+### Testing Commands
+```bash
+# Run tests (most packages have individual test commands)
+yarn test
+
+# Test individual packages
+cd packages/cubejs-[package-name]
+yarn test
+```
+
+### Documentation Development
+The documentation is in `/docs` directory:
+```bash
+cd docs
+yarn dev    # Start development server
+yarn build  # Build for production
+```
+
+## Architecture Overview
+
+### Monorepo Structure
+- **`/packages`**: All JavaScript/TypeScript packages managed by Lerna
+  - Core packages: `cubejs-server-core`, `cubejs-schema-compiler`, `cubejs-query-orchestrator` 
+  - Client libraries: `cubejs-client-core`, `cubejs-client-react`, etc.
+  - Database drivers: `cubejs-postgres-driver`, `cubejs-bigquery-driver`, etc.
+  - API layer: `cubejs-api-gateway`
+- **`/rust`**: Rust components including CubeSQL (SQL interface) and CubeStore (distributed storage)
+- **`/docs`**: Next.js documentation site
+- **`/examples`**: Example implementations and recipes
+
+### Key Components
+1. **Schema Compiler**: Compiles data models into executable queries
+2. **Query Orchestrator**: Manages query execution, caching, and pre-aggregations
+3. **API Gateway**: Provides REST, GraphQL, and SQL APIs
+4. **CubeSQL**: Postgres-compatible SQL interface (Rust)
+5. **CubeStore**: Distributed OLAP storage engine (Rust)
+
+### Package Management
+- Uses Yarn workspaces with Lerna for package management
+- TypeScript compilation is coordinated across packages
+- Jest for unit testing with package-specific configurations
+
+## Testing Approach
+
+### Unit Tests
+- Most packages have Jest-based unit tests in `/test` directories
+- TypeScript packages use `jest.config.js` with TypeScript compilation
+- Snapshot testing for SQL compilation and query planning
+
+### Integration Tests
+- Driver-specific integration tests in `/packages/cubejs-testing-drivers`
+- End-to-end tests in `/packages/cubejs-testing`
+- Docker-based testing environments for database drivers
+
+### Test Commands
+```bash
+# Individual package testing
+cd packages/[package-name]
+yarn test
+
+# Driver integration tests (requires Docker)
+cd packages/cubejs-testing-drivers
+yarn test
+```
+
+## Development Workflow
+
+1. **Making Changes**: Work in individual packages, changes are coordinated via Lerna
+2. **Building**: Use `yarn tsc` to compile TypeScript across all packages
+3. **Testing**: Run relevant tests for modified packages
+4. **Linting**: Ensure code passes `yarn lint` before committing
+
+## Common File Patterns
+
+- `*.test.ts/js`: Jest unit tests
+- `jest.config.js`: Jest configuration per package
+- `tsconfig.json`: TypeScript configuration (inherits from root)
+- `CHANGELOG.md`: Per-package changelogs maintained by Lerna
+- `src/`: Source code directory
+- `dist/`: Compiled output (not committed)
+
+## Important Notes
+
+- This is documentation for the old Cube docs site structure (the existing `/docs/CLAUDE.md` refers to the documentation site)
+- The main Cube application development happens in `/packages`
+- For data model changes, focus on `cubejs-schema-compiler` package
+- For query execution changes, focus on `cubejs-query-orchestrator` package
+- Database connectivity is handled by individual driver packages
+
+## Key Dependencies
+
+- **Lerna**: Monorepo management and publishing
+- **TypeScript**: Primary language for most packages
+- **Jest**: Testing framework
+- **Rollup**: Bundling for client libraries
+- **Docker**: Testing environments for database drivers

packages/cubejs-api-gateway/src/SubscriptionServer.ts

@@ -12,7 +12,6 @@ const methodParams: Record<string, string[]> = {
   meta: [],
   subscribe: ['query', 'queryType'],
   unsubscribe: [],
-  'subscribe.queue.events': []
 };
 
 const calcMessageLength = (message: unknown) => Buffer.byteLength(
@@ -149,8 +148,6 @@ export class SubscriptionServer {
   }
 
   public async disconnect(connectionId: string) {
-    const authContext = await this.subscriptionStore.getAuthContext(connectionId);
-    await this.apiGateway.unSubscribeQueueEvents({ context: authContext, connectionId });
     await this.subscriptionStore.cleanupSubscriptions(connectionId);
   }
 

packages/cubejs-api-gateway/src/gateway.ts

@@ -2067,21 +2067,6 @@ class ApiGateway {
     }
   }
 
-  public async subscribeQueueEvents({ context, signedWithPlaygroundAuthSecret, connectionId, res }) {
-    if (this.enforceSecurityChecks && !signedWithPlaygroundAuthSecret) {
-      throw new CubejsHandlerError(
-        403,
-        'Forbidden',
-        'Only for signed with playground auth secret'
-      );
-    }
-    return (await this.getAdapterApi(context)).subscribeQueueEvents(connectionId, res);
-  }
-
-  public async unSubscribeQueueEvents({ context, connectionId }) {
-    return (await this.getAdapterApi(context)).unSubscribeQueueEvents(connectionId);
-  }
-
   public async subscribe({
     query, context, res, subscribe, subscriptionState, queryType, apiType
   }) {

packages/cubejs-backend-shared/src/env.ts

@@ -2090,9 +2090,6 @@ const variables: Record<string, (...args: any) => any> = {
   livePreview: () => get('CUBEJS_LIVE_PREVIEW')
     .default('true')
     .asBoolStrict(),
-  preAggregationsQueueEventsBus: () => get('CUBEJS_PRE_AGGREGATIONS_QUEUE_EVENTS_BUS')
-    .default('false')
-    .asBoolStrict(),
   externalDefault: () => get('CUBEJS_EXTERNAL_DEFAULT')
     .default('true')
     .asBoolStrict(),

packages/cubejs-base-driver/src/queue-driver.interface.ts

@@ -52,7 +52,6 @@ export interface QueueDriverOptions {
   continueWaitTimeout: number,
   orphanedTimeout: number,
   heartBeatTimeout: number,
-  getQueueEventsBus?: any,
   processUid?: string;
 }
 

packages/cubejs-query-orchestrator/CLAUDE.md

@@ -0,0 +1,131 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Package Overview
+
+The Query Orchestrator is a multi-stage querying engine that manages query execution, caching, and pre-aggregations in Cube. It receives pre-aggregation SQL queries and executes them in exact order, ensuring up-to-date data structure and freshness.
+
+## Development Commands
+
+**Note: This project uses Yarn as the package manager.**
+
+```bash
+# Build the package
+yarn build
+
+# Build with TypeScript compilation
+yarn tsc
+
+# Watch mode for development
+yarn watch
+
+# Run all tests (unit + integration)
+yarn test
+
+# Run only unit tests
+yarn unit
+
+# Run only integration tests  
+yarn integration
+
+# Run CubeStore integration tests specifically
+yarn integration:cubestore
+
+# Run linting
+yarn lint
+
+# Fix linting issues
+yarn lint:fix
+```
+
+## Architecture Overview
+
+### Core Components
+
+The Query Orchestrator consists of several interconnected components:
+
+1. **QueryOrchestrator** (`src/orchestrator/QueryOrchestrator.ts`): Main orchestration class that coordinates query execution and manages drivers
+2. **QueryCache** (`src/orchestrator/QueryCache.ts`): Handles query result caching with configurable cache drivers  
+3. **QueryQueue** (`src/orchestrator/QueryQueue.js`): Manages query queuing and background processing
+4. **PreAggregations** (`src/orchestrator/PreAggregations.ts`): Manages pre-aggregation building and loading
+5. **DriverFactory** (`src/orchestrator/DriverFactory.ts`): Creates and manages database driver instances
+
+### Cache and Queue Driver Architecture
+
+The orchestrator supports multiple backend drivers:
+- **Memory**: In-memory caching and queuing (development)
+- **CubeStore**: Distributed storage engine (production) 
+- **Redis**: External Redis-based caching (legacy, being phased out)
+
+Driver selection logic in `QueryOrchestrator.ts:detectQueueAndCacheDriver()`:
+- Explicit configuration via `cacheAndQueueDriver` option
+- Environment variables (`CUBEJS_CACHE_AND_QUEUE_DRIVER`)
+- Auto-detection: Redis if `CUBEJS_REDIS_URL` exists, CubeStore for production, Memory for development
+
+### Query Processing Flow
+
+1. **Query Submission**: Queries enter through QueryOrchestrator
+2. **Cache Check**: QueryCache checks for existing results
+3. **Queue Management**: QueryQueue handles background execution
+4. **Pre-aggregation Processing**: PreAggregations component manages rollup tables
+5. **Result Caching**: Results stored via cache driver for future requests
+
+### Pre-aggregation System
+
+The pre-aggregation system includes:
+- **PreAggregationLoader**: Loads pre-aggregation definitions
+- **PreAggregationPartitionRangeLoader**: Handles partition range loading
+- **PreAggregationLoadCache**: Manages loading cache for pre-aggregations
+
+## Testing Structure
+
+### Unit Tests (`test/unit/`)
+- `QueryCache.test.ts`: Query caching functionality
+- `QueryQueue.test.ts`: Queue management and processing
+- `QueryOrchestrator.test.js`: Main orchestrator logic
+- `PreAggregations.test.js`: Pre-aggregation management
+
+### Integration Tests (`test/integration/`)
+- `cubestore/`: CubeStore-specific integration tests
+- Tests real database interactions and queue processing
+
+### Test Abstractions
+- `QueryCache.abstract.ts`: Shared test suite for cache implementations
+- `QueryQueue.abstract.ts`: Shared test suite for queue implementations
+
+## Key Design Patterns
+
+### Queue Processing Architecture
+The DEVELOPMENT.md file contains detailed sequence diagrams showing:
+- Queue interaction with CubeStore via specific queue commands (`QUEUE ADD`, `QUEUE RETRIEVE`, etc.)
+- Background query processing with heartbeat management
+- Result handling and cleanup
+
+### Driver Factory Pattern
+- `DriverFactory` type enables pluggable database drivers
+- `DriverFactoryByDataSource` supports multi-tenant scenarios
+- Separation between external (user data) and internal (cache/queue) drivers
+
+### Error Handling
+- `ContinueWaitError`: Signals when queries should continue waiting
+- `TimeoutError`: Handles query timeout scenarios
+- Proper cleanup and resource management across all components
+
+## Configuration
+
+Key configuration options in `QueryOrchestratorOptions`:
+- `externalDriverFactory`: Database driver for user data
+- `cacheAndQueueDriver`: Backend for caching and queuing
+- `queryCacheOptions`: Cache-specific settings
+- `preAggregationsOptions`: Pre-aggregation configuration
+- `rollupOnlyMode`: When enabled, only serves pre-aggregated data
+- `continueWaitTimeout`: Timeout for waiting operations
+
+## Development Notes
+
+- Uses TypeScript with relaxed strict settings (`tsconfig.json`)
+- Inherits linting rules from `@cubejs-backend/linter`
+- Jest configuration extends base repository config
+- Docker Compose setup for integration testing
+- Coverage reports generated in `coverage/` directory