ll-callmobile-backend/dist/dynamic-querying/DynamicQuery.d.ts

VoIP Mobile Communications Backend with Supabase, Drizzle ORM, and Dynamic Querying - Deployable as Cloudflare Worker

import { Database } from './types';
import { SimpleFilter, QueryOptions, QueryResult, TableName, DynamicQueryConfig, SortDirection } from './types';
/**
 * DynamicQuery - A simple and powerful query builder for your database
 *
 * @example
 * ```typescript
 * import { DynamicQuery } from 'll-callmobile-backend';
 *
 * const query = new DynamicQuery(db);
 *
 * // Simple filtering
 * const activeTests = await query.findByFilters('test_cases', { status: 'active' });
 *
 * // Complex queries
 * const results = await query.query('test_cases', {
 *   where: [{ field: 'status', operator: 'eq', value: 'active' }],
 *   orderBy: [{ field: 'created_on', direction: 'desc' }],
 *   pagination: { limit: 10, offset: 0 }
 * });
 * ```
 */
export declare class DynamicQuery {
    private db;
    private config;
    private tableMap;
    constructor(db: Database, config?: Partial<DynamicQueryConfig>);
    /**
     * Find records using simple key-value filters
     *
     * @param tableName - The table to query
     * @param filters - Simple object with field-value pairs
     * @param options - Optional pagination and sorting
     *
     * @example
     * ```typescript
     * // Find all active test cases
     * const activeTests = await query.findByFilters('test_cases', { status: 'active' });
     *
     * // Find with pagination
     * const recentTests = await query.findByFilters('test_cases',
     *   { status: 'active' },
     *   { limit: 10, offset: 0 }
     * );
     *
     * // Find with sorting
     * const sortedTests = await query.findByFilters('test_cases',
     *   { status: 'active' },
     *   {
     *     limit: 10,
     *     orderBy: [{ field: 'created_on', direction: 'desc' }]
     *   }
     * );
     * ```
     */
    findByFilters<T = any>(tableName: TableName, filters: SimpleFilter, options?: {
        limit?: number;
        offset?: number;
        orderBy?: {
            field: string;
            direction: SortDirection;
        }[];
    }): Promise<T[]>;
    /**
     * Execute complex queries with advanced filtering, sorting, and pagination
     *
     * @param tableName - The table to query
     * @param options - Complete query options
     *
     * @example
     * ```typescript
     * // Complex filtering with multiple conditions
     * const results = await query.query('test_cases', {
     *   where: [
     *     { field: 'status', operator: 'eq', value: 'active' },
     *     { field: 'created_on', operator: 'gte', value: '2024-01-01' },
     *     { field: 'description', operator: 'like', value: '%test%' }
     *   ],
     *   orderBy: [
     *     { field: 'created_on', direction: 'desc' },
     *     { field: 'id', direction: 'asc' }
     *   ],
     *   pagination: { limit: 20, offset: 0 }
     * });
     *
     * // Select specific fields only
     * const results = await query.query('test_cases', {
     *   select: ['id', 'description', 'status'],
     *   where: [{ field: 'status', operator: 'eq', value: 'active' }]
     * });
     * ```
     */
    query<T = any>(tableName: TableName, options: QueryOptions): Promise<QueryResult<T>>;
    /**
     * Execute raw SQL queries (when enabled)
     *
     * @param sql - Raw SQL query
     * @param params - Query parameters
     *
     * @example
     * ```typescript
     * // Only available if enableRawQueries is true
     * const results = await query.executeRaw(
     *   'SELECT * FROM test_cases WHERE status = $1 AND created_on > $2',
     *   ['active', '2024-01-01']
     * );
     * ```
     */
    executeRaw<T = any>(sql: string, params?: any[]): Promise<T[]>;
    /**
     * Get a single record by ID
     *
     * @param tableName - The table to query
     * @param id - Record ID
     *
     * @example
     * ```typescript
     * const testCase = await query.findById('test_cases', 123);
     * ```
     */
    findById<T = any>(tableName: TableName, id: string | number): Promise<T | null>;
    /**
     * Count records with optional filters
     *
     * @param tableName - The table to count
     * @param filters - Optional filters
     *
     * @example
     * ```typescript
     * const totalTests = await query.count('test_cases');
     * const activeTests = await query.count('test_cases', { status: 'active' });
     * ```
     */
    count(tableName: TableName, filters?: SimpleFilter): Promise<number>;
    private isAdvancedFilter;
    private buildWhereClause;
    private normalizePagination;
}
//# sourceMappingURL=DynamicQuery.d.ts.map