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 } 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: {
        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;
}>;
/**
 * Format standard Cube.js API response
 */
export declare function formatCubeResponse(query: SemanticQuery, result: {
    data: any[];
    annotation?: any;
}, semanticLayer: SemanticLayerCompiler): {
    queryType: string;
    results: {
        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">;
    };
    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;
};