@hypequery/clickhouse 0.0.0-canary-20260306132943

package/dist/core/tests/integration/setup.js

@@ -0,0 +1,349 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { ClickHouseConnection } from '../../connection.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { logger as hypeQueryLogger } from '../../utils/logger.js';
+// @ts-expect-error: raw JSON import for supplying fixture data
+import rawTestData from './test-data.json';
+// Disable the hypequery logger to prevent "logs after tests" errors
+// This must be done early in the setup, before any queries run
+hypeQueryLogger.configure({ enabled: false });
+// Setup a logger that respects test environment
+const logger = {
+    info: (message, ...args) => {
+        if (process.env.DEBUG === 'true') {
+            console.info(`[INFO] ${message}`, ...args);
+        }
+    },
+    error: (message, ...args) => {
+        if (process.env.DEBUG === 'true' || process.env.SUPPRESS_ERRORS !== 'true') {
+            console.error(`[ERROR] ${message}`, ...args);
+        }
+    },
+    warn: (message, ...args) => {
+        if (process.env.DEBUG === 'true') {
+            console.warn(`[WARN] ${message}`, ...args);
+        }
+    }
+};
+const execAsync = promisify(exec);
+// Create a path to the project root
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '../../../../../');
+// Connection configuration (with defaults that can be overridden by env variables)
+const CLICKHOUSE_TEST_PORT = process.env.CLICKHOUSE_TEST_PORT || '8123';
+const config = {
+    host: process.env.CLICKHOUSE_TEST_HOST || `http://localhost:${CLICKHOUSE_TEST_PORT}`,
+    user: process.env.CLICKHOUSE_TEST_USER || 'default',
+    password: process.env.CLICKHOUSE_TEST_PASSWORD || 'hypequery_test',
+    database: process.env.CLICKHOUSE_TEST_DB || 'test_db',
+};
+export const TEST_CONNECTION_CONFIG = config;
+// Initialize the ClickHouse connection
+export const initializeTestConnection = async () => {
+    logger.info('Initializing ClickHouse connection with config:', config);
+    try {
+        // Make sure ClickHouse is initialized
+        ensureConnectionInitialized();
+        // Test connection by getting client and pinging
+        const client = ClickHouseConnection.getClient();
+        await client.ping();
+        logger.info('ClickHouse connection successful');
+        // Return the query builder from the index file
+        const { createQueryBuilder } = await import('../../../index.js');
+        return createQueryBuilder({
+            host: config.host,
+            username: config.user,
+            password: config.password,
+            database: config.database,
+        });
+    }
+    catch (error) {
+        logger.error('Failed to connect to ClickHouse:', error);
+        throw error;
+    }
+};
+// Helper function to ensure connection is initialized
+export const ensureConnectionInitialized = () => {
+    // If connection hasn't been initialized yet, initialize it
+    try {
+        ClickHouseConnection.getClient();
+    }
+    catch (error) {
+        // If we get "not initialized" error, initialize the connection
+        logger.info('Initializing ClickHouse connection...');
+        ClickHouseConnection.initialize({
+            host: config.host,
+            username: config.user,
+            password: config.password,
+            database: config.database,
+        });
+    }
+    return ClickHouseConnection.getClient();
+};
+// Check if Docker is installed
+export const isDockerAvailable = async () => {
+    try {
+        await execAsync('docker --version');
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+// Check if Docker Compose is installed
+export const isDockerComposeAvailable = async () => {
+    try {
+        await execAsync('docker compose version');
+        return true;
+    }
+    catch (error) {
+        try {
+            // Try the hyphenated version for older installations
+            await execAsync('docker-compose --version');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+};
+// Check if a docker container is running
+export const isContainerRunning = async (containerName) => {
+    try {
+        const { stdout } = await execAsync(`docker ps --filter "name=${containerName}" --format "{{.Names}}"`);
+        return stdout.trim() === containerName;
+    }
+    catch (error) {
+        return false;
+    }
+};
+// Check if ClickHouse is ready
+export const isClickHouseReady = async () => {
+    try {
+        const client = ClickHouseConnection.getClient();
+        await client.ping();
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+// Start the ClickHouse container
+export const startClickHouseContainer = async () => {
+    const dockerAvailable = await isDockerAvailable();
+    if (!dockerAvailable) {
+        throw new Error('Docker is not available. Please install Docker to run integration tests.');
+    }
+    const composeAvailable = await isDockerComposeAvailable();
+    // Use Docker Compose if available
+    if (composeAvailable) {
+        logger.info('Starting ClickHouse container with Docker Compose...');
+        try {
+            // Fix the path to the docker-compose.test.yml file
+            const composePath = path.resolve(projectRoot, 'packages/clickhouse/docker-compose.test.yml');
+            logger.info(`Using Docker Compose file at: ${composePath}`);
+            // Make sure we're executing the command from the correct directory
+            await execAsync(`docker compose -f "${composePath}" up -d`);
+        }
+        catch (error) {
+            logger.error('Failed to start ClickHouse container with Docker Compose:', error);
+            throw error;
+        }
+    }
+    else {
+        // Fallback to Docker run
+        logger.info('Starting ClickHouse container with Docker...');
+        try {
+            await execAsync(`
+        docker run -d --name hypequery-test-clickhouse 
+        -p 8123:8123 -p 9000:9000
+        -e CLICKHOUSE_USER=${config.user}
+        -e CLICKHOUSE_PASSWORD=${config.password}
+        -e CLICKHOUSE_DB=${config.database}
+        --ulimit nofile=262144:262144
+        clickhouse/clickhouse-server:latest
+      `);
+        }
+        catch (error) {
+            logger.error('Failed to start ClickHouse container with Docker:', error);
+            throw error;
+        }
+    }
+};
+// Wait for ClickHouse to be ready
+export const waitForClickHouse = async (maxAttempts = 30, retryInterval = 1000) => {
+    logger.info('Waiting for ClickHouse to be ready...');
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        if (await isClickHouseReady()) {
+            logger.info('ClickHouse is ready!');
+            return;
+        }
+        logger.info(`Waiting for ClickHouse... Attempt ${attempt}/${maxAttempts}`);
+        await new Promise(resolve => setTimeout(resolve, retryInterval));
+    }
+    throw new Error(`ClickHouse failed to start after ${maxAttempts} attempts`);
+};
+// Stop the ClickHouse container
+export const stopClickHouseContainer = async () => {
+    const composeAvailable = await isDockerComposeAvailable();
+    if (composeAvailable) {
+        logger.info('Stopping ClickHouse container with Docker Compose...');
+        try {
+            // Fix the path to the docker-compose.test.yml file
+            const composePath = path.resolve(projectRoot, 'packages/clickhouse/docker-compose.test.yml');
+            logger.info(`Using Docker Compose file at: ${composePath}`);
+            // Make sure we're executing the command from the correct directory
+            await execAsync(`docker compose -f "${composePath}" down -v`);
+        }
+        catch (error) {
+            logger.error('Failed to stop ClickHouse container with Docker Compose:', error);
+            // Log the error but don't throw, so the tests can complete
+            // This allows for manual cleanup if needed
+        }
+    }
+    else {
+        logger.info('Stopping ClickHouse container with Docker...');
+        try {
+            await execAsync('docker stop hypequery-test-clickhouse && docker rm hypequery-test-clickhouse');
+        }
+        catch (error) {
+            logger.error('Failed to stop ClickHouse container with Docker:', error);
+            // Log the error but don't throw, so the tests can complete
+        }
+    }
+};
+function normalizeDateValue(value) {
+    if (!value) {
+        return value;
+    }
+    if (value.includes('T')) {
+        return value.split('T')[0];
+    }
+    if (value.includes(' ')) {
+        return value.split(' ')[0];
+    }
+    return value;
+}
+function normalizeTestData() {
+    const testTable = (rawTestData.test_table ?? []).map(row => ({
+        id: row.id,
+        name: row.name,
+        category: row.category,
+        price: row.price,
+        created_at: normalizeDateValue(row.created_at),
+        is_active: row.is_active
+    }));
+    const users = (rawTestData.users ?? []).map(row => ({
+        id: row.id,
+        user_name: row.user_name,
+        email: row.email,
+        status: row.status,
+        created_at: normalizeDateValue(row.created_at)
+    }));
+    const orders = (rawTestData.orders ?? []).map(row => ({
+        id: row.id,
+        user_id: row.user_id,
+        product_id: row.product_id,
+        quantity: row.quantity,
+        total: row.total,
+        status: row.status,
+        created_at: normalizeDateValue(row.created_at)
+    }));
+    return { test_table: testTable, users, orders };
+}
+// Test data
+export const TEST_DATA = normalizeTestData();
+let hasSetupRun = false;
+// Setup the test database
+export const setupTestDatabase = async () => {
+    if (process.env.HYPEQUERY_SKIP_TEST_DB_SETUP === 'true') {
+        logger.info('Skipping test database setup because HYPEQUERY_SKIP_TEST_DB_SETUP is true.');
+        return;
+    }
+    if (hasSetupRun) {
+        return;
+    }
+    // Make sure connection is initialized before getting client
+    const client = ensureConnectionInitialized();
+    try {
+        // Create and use database if it doesn't exist
+        await client.exec({ query: `CREATE DATABASE IF NOT EXISTS ${config.database}` });
+        await client.exec({ query: `USE ${config.database}` });
+        // Drop tables if they exist
+        await client.exec({ query: 'DROP TABLE IF EXISTS test_table' });
+        await client.exec({ query: 'DROP TABLE IF EXISTS users' });
+        await client.exec({ query: 'DROP TABLE IF EXISTS orders' });
+        // Create tables
+        await client.exec({
+            query: `
+        CREATE TABLE test_table (
+          id UInt32,
+          name String,
+          category String,
+          price Float64,
+          created_at Date,
+          is_active Boolean
+        ) ENGINE = MergeTree()
+        ORDER BY id
+      `
+        });
+        await client.exec({
+            query: `
+        CREATE TABLE users (
+          id UInt32,
+          user_name String,
+          email String,
+          status String,
+          created_at Date
+        ) ENGINE = MergeTree()
+        ORDER BY id
+      `
+        });
+        await client.exec({
+            query: `
+        CREATE TABLE orders (
+          id UInt32,
+          user_id UInt32,
+          product_id UInt32,
+          quantity UInt32,
+          total Float64,
+          status String,
+          created_at Date
+        ) ENGINE = MergeTree()
+        ORDER BY id
+      `
+        });
+        // Insert test data
+        for (const row of TEST_DATA.test_table) {
+            await client.insert({
+                table: 'test_table',
+                values: [row],
+                format: 'JSONEachRow'
+            });
+        }
+        for (const row of TEST_DATA.users) {
+            await client.insert({
+                table: 'users',
+                values: [row],
+                format: 'JSONEachRow'
+            });
+        }
+        for (const row of TEST_DATA.orders) {
+            await client.insert({
+                table: 'orders',
+                values: [row],
+                format: 'JSONEachRow'
+            });
+        }
+        hasSetupRun = true;
+        logger.info('Test database setup complete');
+    }
+    catch (error) {
+        hasSetupRun = false;
+        logger.error('Failed to set up test database:', error);
+        throw error;
+    }
+};

package/dist/core/tests/integration/test-config.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Centralized configuration for integration tests
+ * Import this in all integration test files to ensure consistent behavior
+ */
+/**
+ * Whether to skip integration tests:
+ * - Only skip when SKIP_INTEGRATION_TESTS is explicitly set to 'true'
+ *   (used locally when ClickHouse is unavailable)
+ */
+export declare const SKIP_INTEGRATION_TESTS: boolean;
+/**
+ * Default timeout for test setup (in milliseconds)
+ */
+export declare const SETUP_TIMEOUT = 30000;
+//# sourceMappingURL=test-config.d.ts.map

package/dist/core/tests/integration/test-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-config.d.ts","sourceRoot":"","sources":["../../../../src/core/tests/integration/test-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,SAAgD,CAAC;AAEpF;;GAEG;AACH,eAAO,MAAM,aAAa,QAAQ,CAAC"}

package/dist/core/tests/integration/test-config.js

@@ -0,0 +1,14 @@
+/**
+ * Centralized configuration for integration tests
+ * Import this in all integration test files to ensure consistent behavior
+ */
+/**
+ * Whether to skip integration tests:
+ * - Only skip when SKIP_INTEGRATION_TESTS is explicitly set to 'true'
+ *   (used locally when ClickHouse is unavailable)
+ */
+export const SKIP_INTEGRATION_TESTS = process.env.SKIP_INTEGRATION_TESTS === 'true';
+/**
+ * Default timeout for test setup (in milliseconds)
+ */
+export const SETUP_TIMEOUT = 30000;

package/dist/core/tests/integration/test-data.json

@@ -0,0 +1,190 @@
+{
+    "test_table": [
+        {
+            "id": 1,
+            "name": "Product A",
+            "category": "A",
+            "price": 10.5,
+            "created_at": "2023-01-01 10:00:00",
+            "is_active": true,
+            "tags": [
+                "new",
+                "sale"
+            ],
+            "attributes": {
+                "color": "red",
+                "size": "M"
+            },
+            "optional_note": "Popular item",
+            "sku": "A-100",
+            "delivery_dates": [
+                "2023-01-05",
+                "2023-01-10"
+            ]
+        },
+        {
+            "id": 2,
+            "name": "Product B",
+            "category": "B",
+            "price": 20.75,
+            "created_at": "2023-01-02 12:30:00",
+            "is_active": true,
+            "tags": [
+                "featured"
+            ],
+            "attributes": {
+                "color": "blue",
+                "size": "L"
+            },
+            "optional_note": null,
+            "sku": "B-200",
+            "delivery_dates": [
+                "2023-01-06"
+            ]
+        },
+        {
+            "id": 3,
+            "name": "Product C",
+            "category": "A",
+            "price": 15.0,
+            "created_at": "2023-01-03 09:45:00",
+            "is_active": false,
+            "tags": [],
+            "attributes": {
+                "color": "green",
+                "size": "S"
+            },
+            "optional_note": "Backordered",
+            "sku": "C-300",
+            "delivery_dates": []
+        },
+        {
+            "id": 4,
+            "name": "Product D",
+            "category": "C",
+            "price": 8.25,
+            "created_at": "2023-01-04 15:15:00",
+            "is_active": true,
+            "tags": [
+                "clearance"
+            ],
+            "attributes": {
+                "color": "yellow",
+                "size": "XL"
+            },
+            "optional_note": null,
+            "sku": "D-400",
+            "delivery_dates": [
+                "2023-01-08"
+            ]
+        },
+        {
+            "id": 5,
+            "name": "Product E",
+            "category": "B",
+            "price": 30.0,
+            "created_at": "2023-01-05 11:20:00",
+            "is_active": true,
+            "tags": [
+                "premium",
+                "gift"
+            ],
+            "attributes": {
+                "color": "black",
+                "size": "M"
+            },
+            "optional_note": "Limited stock",
+            "sku": "E-500",
+            "delivery_dates": [
+                "2023-01-07",
+                "2023-01-09"
+            ]
+        },
+        {
+            "id": 6,
+            "name": "Product F",
+            "category": "D",
+            "price": 12.5,
+            "created_at": "2023-01-06 14:40:00",
+            "is_active": false,
+            "tags": [],
+            "attributes": {
+                "color": "white",
+                "size": "M"
+            },
+            "optional_note": null,
+            "sku": "F-600",
+            "delivery_dates": []
+        }
+    ],
+    "users": [
+        {
+            "id": 1,
+            "user_name": "john_doe",
+            "email": "john@example.com",
+            "status": "active",
+            "created_at": "2023-01-01"
+        },
+        {
+            "id": 2,
+            "user_name": "jane_smith",
+            "email": "jane@example.com",
+            "status": "active",
+            "created_at": "2023-01-02"
+        },
+        {
+            "id": 3,
+            "user_name": "bob_jones",
+            "email": "bob@example.com",
+            "status": "inactive",
+            "created_at": "2023-01-03"
+        }
+    ],
+    "orders": [
+        {
+            "id": 1,
+            "user_id": 1,
+            "product_id": 1,
+            "quantity": 2,
+            "total": 21.0,
+            "status": "completed",
+            "created_at": "2023-01-10"
+        },
+        {
+            "id": 2,
+            "user_id": 1,
+            "product_id": 3,
+            "quantity": 1,
+            "total": 15.0,
+            "status": "completed",
+            "created_at": "2023-01-11"
+        },
+        {
+            "id": 3,
+            "user_id": 2,
+            "product_id": 2,
+            "quantity": 3,
+            "total": 62.25,
+            "status": "pending",
+            "created_at": "2023-01-12"
+        },
+        {
+            "id": 4,
+            "user_id": 2,
+            "product_id": 5,
+            "quantity": 1,
+            "total": 30.0,
+            "status": "completed",
+            "created_at": "2023-01-13"
+        },
+        {
+            "id": 5,
+            "user_id": 3,
+            "product_id": 4,
+            "quantity": 2,
+            "total": 16.5,
+            "status": "cancelled",
+            "created_at": "2023-01-14"
+        }
+    ]
+}

package/dist/core/tests/test-utils.d.ts

@@ -0,0 +1,44 @@
+import { SelectQB } from '../query-builder.js';
+import type { TableRecord } from '../../types/schema.js';
+export type TestTableSchema = {
+    id: 'Int32';
+    name: 'String';
+    price: 'Float64';
+    created_at: 'Date';
+    category: 'String';
+    active: 'UInt8';
+    created_by: 'Int32';
+    updated_by: 'Int32';
+    status: 'String';
+    brand: 'String';
+    total: 'Int32';
+    priority: 'String';
+    is_premium: 'Bool';
+    metadata: 'Map(String, String)';
+    tags: 'Array(String)';
+    settings: 'Map(LowCardinality(String), String)';
+    optional_name: 'Nullable(String)';
+    categories: 'Array(LowCardinality(String))';
+    feature_flags: 'Array(Map(LowCardinality(String), String))';
+    optional_tags: 'Nullable(Array(String))';
+    permissions: 'Map(String, Array(String))';
+    created_timestamp: 'DateTime64(9)';
+};
+export type UsersSchema = {
+    id: 'Int32';
+    user_name: 'String';
+    email: 'String';
+    created_at: 'Date';
+    profile: 'Map(String, String)';
+    preferences: 'Nullable(Map(LowCardinality(String), String))';
+    roles: 'Array(LowCardinality(String))';
+    is_active: 'Bool';
+};
+export interface TestSchema {
+    test_table: TestTableSchema;
+    users: UsersSchema;
+}
+export declare const TEST_SCHEMAS: TestSchema;
+export declare function setupUsersBuilder(): SelectQB<TestSchema, 'users', TableRecord<TestSchema['users']>, 'users'>;
+export declare function setupTestBuilder(): SelectQB<TestSchema, 'test_table', TableRecord<TestSchema['test_table']>, 'test_table'>;
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/core/tests/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../src/core/tests/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,QAAQ,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IAEnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,qBAAqB,CAAC;IAChC,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,qCAAqC,CAAC;IAChD,aAAa,EAAE,kBAAkB,CAAC;IAClC,UAAU,EAAE,+BAA+B,CAAC;IAC5C,aAAa,EAAE,4CAA4C,CAAC;IAC5D,aAAa,EAAE,yBAAyB,CAAC;IACzC,WAAW,EAAE,4BAA4B,CAAC;IAC1C,iBAAiB,EAAE,eAAe,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,QAAQ,CAAC;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,qBAAqB,CAAC;IAC/B,WAAW,EAAE,+CAA+C,CAAC;IAC7D,KAAK,EAAE,+BAA+B,CAAC;IACvC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,eAAe,CAAC;IAC5B,KAAK,EAAE,WAAW,CAAC;CACpB;AAED,eAAO,MAAM,YAAY,EAAE,UAmC1B,CAAC;AAoBF,wBAAgB,iBAAiB,IAAI,QAAQ,CAAC,UAAU,EAAE,OAAO,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAW5G;AAED,wBAAgB,gBAAgB,IAAI,QAAQ,CAAC,UAAU,EAAE,YAAY,EAAE,WAAW,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,EAAE,YAAY,CAAC,CAW1H"}

package/dist/core/tests/test-utils.js

@@ -0,0 +1,65 @@
+import { QueryBuilder } from '../query-builder.js';
+import { buildRuntimeContext, resolveCacheConfig } from '../cache/runtime-context.js';
+export const TEST_SCHEMAS = {
+    test_table: {
+        id: 'Int32',
+        name: 'String',
+        price: 'Float64',
+        created_at: 'Date',
+        category: 'String',
+        active: 'UInt8',
+        created_by: 'Int32',
+        updated_by: 'Int32',
+        status: 'String',
+        brand: 'String',
+        total: 'Int32',
+        priority: 'String',
+        is_premium: 'Bool',
+        metadata: 'Map(String, String)',
+        tags: 'Array(String)',
+        settings: 'Map(LowCardinality(String), String)',
+        optional_name: 'Nullable(String)',
+        categories: 'Array(LowCardinality(String))',
+        feature_flags: 'Array(Map(LowCardinality(String), String))',
+        optional_tags: 'Nullable(Array(String))',
+        permissions: 'Map(String, Array(String))',
+        created_timestamp: 'DateTime64(9)',
+    },
+    users: {
+        id: 'Int32',
+        user_name: 'String',
+        email: 'String',
+        created_at: 'Date',
+        profile: 'Map(String, String)',
+        preferences: 'Nullable(Map(LowCardinality(String), String))',
+        roles: 'Array(LowCardinality(String))',
+        is_active: 'Bool',
+    }
+};
+function createTestRuntime() {
+    return buildRuntimeContext(resolveCacheConfig(undefined, 'tests'));
+}
+export function setupUsersBuilder() {
+    const state = {
+        schema: TEST_SCHEMAS,
+        tables: 'users',
+        output: {},
+        baseTable: 'users',
+        base: TEST_SCHEMAS.users,
+        aliases: {},
+        scalars: {}
+    };
+    return new QueryBuilder('users', state, createTestRuntime());
+}
+export function setupTestBuilder() {
+    const state = {
+        schema: TEST_SCHEMAS,
+        tables: 'test_table',
+        output: {},
+        baseTable: 'test_table',
+        base: TEST_SCHEMAS.test_table,
+        aliases: {},
+        scalars: {}
+    };
+    return new QueryBuilder('test_table', state, createTestRuntime());
+}