drizzle-cube/dist/adapters/utils.d.ts

Drizzle ORM-first semantic layer with Cube.js compatibility. Type-safe analytics and dashboards with SQL injection protection.

import { SemanticLayerCompiler, SemanticQuery, SecurityContext, QueryAnalysis } from '../server';
/**
 * Calculate query complexity based on query structure
 */
export declare function calculateQueryComplexity(query: SemanticQuery): string;
/**
 * Generate a unique request ID
 */
export declare function generateRequestId(): string;
/**
 * Build transformed query metadata for Cube.js compatibility
 */
export declare function buildTransformedQuery(query: SemanticQuery): any;
/**
 * Get database type from semantic layer
 */
export declare function getDatabaseType(semanticLayer: SemanticLayerCompiler): string;
/**
 * Helper function to handle dry-run logic for all adapters
 */
export declare function handleDryRun(query: SemanticQuery, securityContext: SecurityContext, semanticLayer: SemanticLayerCompiler): Promise<{
    queryType: string;
    normalizedQueries: never[];
    queryOrder: string[];
    transformedQueries: never[];
    pivotQuery: {
        query: SemanticQuery;
        cubes: string[];
    };
    sql: {
        sql: string[];
        params: any[];
    };
    complexity: string;
    valid: boolean;
    cubesUsed: string[];
    joinType: string;
    query: SemanticQuery;
    funnel: {
        stepCount: number;
        steps: {
            index: number;
            name: string;
            timeToConvert: string | undefined;
            cube: string | undefined;
        }[];
        bindingKey: string | import('../server').FunnelBindingKeyMapping[];
        timeDimension: string | import('../server').FunnelTimeDimensionMapping[];
        includeTimeMetrics: boolean | undefined;
        globalTimeWindow: string | undefined;
    };
} | {
    queryType: string;
    normalizedQueries: never[];
    queryOrder: string[];
    transformedQueries: never[];
    pivotQuery: {
        measures: never[];
        dimensions: never[];
        timeDimensions: never[];
        order: {};
        filters: never[];
        queryType: string;
        joinType: string;
        query: SemanticQuery;
        flow: {
            stepsBefore: number;
            stepsAfter: number;
            bindingKey: string | {
                cube: string;
                dimension: string;
            }[];
            timeDimension: string | {
                cube: string;
                dimension: string;
            }[];
            eventDimension: string;
            startingStep: {
                name: string;
                filter?: import('../server').Filter | import('../server').Filter[];
            };
        };
    };
    sql: {
        sql: string;
        params: any[];
    };
} | {
    queryType: string;
    normalizedQueries: {
        cube: string;
        query: {
            measures: string[];
            dimensions: string[];
            filters: import('../server').Filter[];
            timeDimensions: import('../server').TimeDimension[];
            order: Record<string, "asc" | "desc">;
            limit: number | undefined;
            offset: number | undefined;
        };
    }[];
    queryOrder: string[];
    transformedQueries: {
        cube: string;
        query: {
            measures: string[];
            dimensions: string[];
            filters: import('../server').Filter[];
            timeDimensions: import('../server').TimeDimension[];
            order: Record<string, "asc" | "desc">;
            limit: number | undefined;
            offset: number | undefined;
        };
    }[];
    pivotQuery: {
        query: SemanticQuery;
        cubes: string[];
    };
    sql: {
        sql: string[];
        params: any[];
    };
    complexity: string;
    valid: boolean;
    cubesUsed: string[];
    joinType: string;
    query: SemanticQuery;
    analysis: QueryAnalysis | undefined;
}>;
/**
 * Format standard Cube.js API response
 */
export declare function formatCubeResponse(query: SemanticQuery, result: {
    data: any[];
    annotation?: any;
    cache?: {
        hit: boolean;
        cachedAt?: string;
        ttlMs?: number;
        ttlRemainingMs?: number;
    };
}, semanticLayer: SemanticLayerCompiler): {
    queryType: string;
    results: {
        cache?: {
            hit: boolean;
            cachedAt?: string;
            ttlMs?: number;
            ttlRemainingMs?: number;
        } | undefined;
        query: SemanticQuery;
        lastRefreshTime: string;
        usedPreAggregations: {};
        transformedQuery: any;
        requestId: string;
        annotation: any;
        dataSource: string;
        dbType: string;
        extDbType: string;
        external: boolean;
        slowQuery: boolean;
        data: any[];
    }[];
    pivotQuery: {
        queryType: string;
        measures?: string[];
        dimensions?: string[];
        filters?: Array<import('../server').Filter>;
        timeDimensions?: Array<import('../server').TimeDimension>;
        limit?: number;
        offset?: number;
        order?: Record<string, "asc" | "desc">;
        fillMissingDatesValue?: number | null;
        funnel?: import('../server').FunnelQueryConfig;
        flow?: import('../server/types/flow').FlowQueryConfig;
    };
    slowQuery: boolean;
};
/**
 * Format SQL string using sql-formatter with appropriate dialect
 */
export declare function formatSqlString(sqlString: string, engineType: 'postgres' | 'mysql' | 'sqlite' | 'singlestore'): string;
/**
 * Format SQL generation response
 */
export declare function formatSqlResponse(query: SemanticQuery, sqlResult: {
    sql: string;
    params?: any[];
}): {
    sql: string;
    params: any[];
    query: SemanticQuery;
};
/**
 * Format metadata response
 */
export declare function formatMetaResponse(metadata: any): {
    cubes: any;
};
/**
 * Standard error response format
 */
export declare function formatErrorResponse(error: string | Error, status?: number): {
    error: string;
    status: number;
};
/**
 * Handle batch query requests - wrapper around existing single query execution
 * Executes multiple queries in parallel and returns partial success results
 *
 * @param queries - Array of semantic queries to execute
 * @param securityContext - Security context (extracted once, shared across all queries)
 * @param semanticLayer - Semantic layer compiler instance
 * @returns Array of results matching input query order (successful or error results)
 */
export declare function handleBatchRequest(queries: SemanticQuery[], securityContext: SecurityContext, semanticLayer: SemanticLayerCompiler): Promise<{
    results: ({
        queryType: string;
        results: {
            cache?: {
                hit: boolean;
                cachedAt?: string;
                ttlMs?: number;
                ttlRemainingMs?: number;
            } | undefined;
            query: SemanticQuery;
            lastRefreshTime: string;
            usedPreAggregations: {};
            transformedQuery: any;
            requestId: string;
            annotation: any;
            dataSource: string;
            dbType: string;
            extDbType: string;
            external: boolean;
            slowQuery: boolean;
            data: any[];
        }[];
        pivotQuery: {
            queryType: string;
            measures?: string[];
            dimensions?: string[];
            filters?: Array<import('../server').Filter>;
            timeDimensions?: Array<import('../server').TimeDimension>;
            limit?: number;
            offset?: number;
            order?: Record<string, "asc" | "desc">;
            fillMissingDatesValue?: number | null;
            funnel?: import('../server').FunnelQueryConfig;
            flow?: import('../server/types/flow').FlowQueryConfig;
        };
        slowQuery: boolean;
        success: boolean;
        error?: undefined;
        query?: undefined;
    } | {
        success: boolean;
        error: string;
        query: SemanticQuery;
    })[];
}>;