iagate-querykit/dist/view-manager.d.ts

QueryKit: lightweight TypeScript query toolkit with models, views, triggers, events, scheduler and adapters (better-sqlite3).

import type { QueryBuilder } from './query-builder';
/**
 * Gerenciador de views para o QueryKit.
 * Permite criar, substituir, remover e listar views de banco de dados.
 * Suporta múltiplos dialetos SQL e agendamento de refresh automático.
 *
 * @example
 * ```typescript
 * // Dados iniciais
 * const viewManager = new ViewManager();
 * const userQuery = table('users').select('id', 'name', 'email').where('active', true);
 *
 * // Como usar
 * await viewManager.createOrReplaceView('active_users', userQuery);
 *
 * // Output: View 'active_users' criada com sucesso
 * ```
 */
export declare class ViewManager {
    /**
     * Cria ou substitui uma view baseada em um QueryBuilder.
     * Remove a view existente se houver e cria uma nova.
     *
     * @param viewName - Nome da view a ser criada
     * @param query - QueryBuilder que define o conteúdo da view
     * @returns Promise que resolve quando a view for criada
     * @throws Error se não houver executor configurado
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * const viewManager = new ViewManager();
     * const productQuery = table('products')
     *   .select('id', 'name', 'price')
     *   .where('category', 'electronics');
     *
     * // Como usar
     * await viewManager.createOrReplaceView('electronics_products', productQuery);
     *
     * // Output: View 'electronics_products' criada com produtos da categoria electronics
     * ```
     */
    createOrReplaceView(viewName: string, query: QueryBuilder<any>): Promise<void>;
    /**
     * Agenda refresh automático de uma view em intervalos regulares.
     * A view será recriada automaticamente usando a query fornecida.
     *
     * @param viewName - Nome da view para agendar refresh
     * @param query - QueryBuilder para recriar a view
     * @param intervalMs - Intervalo em milissegundos entre refreshes
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * const viewManager = new ViewManager();
     * const statsQuery = table('logs').select('date', 'count(*) as total').groupBy('date');
     *
     * // Como usar
     * viewManager.scheduleViewRefresh('daily_stats', statsQuery, 3600000); // A cada hora
     *
     * // Output: Refresh da view 'daily_stats' agendado para cada hora
     * ```
     */
    scheduleViewRefresh(viewName: string, query: QueryBuilder<any>, intervalMs: number): void;
    /**
     * Cancela o refresh automático de uma view.
     *
     * @param viewName - Nome da view para cancelar refresh
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * viewManager.scheduleViewRefresh('temp_view', query, 5000);
     *
     * // Como usar
     * viewManager.unscheduleViewRefresh('temp_view');
     *
     * // Output: Refresh automático da view 'temp_view' cancelado
     * ```
     */
    unscheduleViewRefresh(viewName: string): void;
    /**
     * Remove uma view do banco de dados.
     * Usa DROP VIEW IF EXISTS para evitar erros se a view não existir.
     *
     * @param viewName - Nome da view a ser removida
     * @returns Promise que resolve quando a view for removida
     * @throws Error se não houver executor configurado
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * const viewManager = new ViewManager();
     *
     * // Como usar
     * await viewManager.dropView('old_view');
     *
     * // Output: View 'old_view' removida com sucesso
     * ```
     */
    dropView(viewName: string): Promise<void>;
    /**
     * Lista todas as views existentes no banco de dados (síncrono).
     * Tenta diferentes queries baseado no dialeto do executor.
     *
     * @returns Array com nomes das views existentes
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * const viewManager = new ViewManager();
     *
     * // Como usar
     * const views = viewManager.listViews();
     *
     * // Output: ['active_users', 'daily_stats', 'product_summary']
     * ```
     */
    listViews(): string[];
    /**
     * Verifica se uma view específica existe (síncrono).
     *
     * @param viewName - Nome da view para verificar
     * @returns true se a view existir, false caso contrário
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * const viewManager = new ViewManager();
     *
     * // Como usar
     * const exists = viewManager.viewExists('active_users');
     *
     * // Output: true se a view 'active_users' existir
     * ```
     */
    viewExists(viewName: string): boolean;
    /**
     * Lista todas as views existentes no banco de dados (assíncrono).
     * Versão assíncrona do método listViews().
     *
     * @returns Promise que resolve com array de nomes das views
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * const viewManager = new ViewManager();
     *
     * // Como usar
     * const views = await viewManager.listViewsAsync();
     *
     * // Output: Promise resolve com ['active_users', 'daily_stats']
     * ```
     */
    listViewsAsync(): Promise<string[]>;
    /**
     * Verifica se uma view específica existe (assíncrono).
     * Versão assíncrona do método viewExists().
     *
     * @param viewName - Nome da view para verificar
     * @returns Promise que resolve com true se a view existir
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * const viewManager = new ViewManager();
     *
     * // Como usar
     * const exists = await viewManager.viewExistsAsync('active_users');
     *
     * // Output: Promise resolve com true se a view existir
     * ```
     */
    viewExistsAsync(viewName: string): Promise<boolean>;
    /**
     * Cria um QueryBuilder para uma view existente.
     * Permite fazer queries em views como se fossem tabelas normais.
     *
     * @param viewName - Nome da view
     * @returns QueryBuilder configurado para a view
     *
     * @example
     * ```typescript
     * // Dados iniciais
     * const viewManager = new ViewManager();
     *
     * // Como usar
     * const viewQuery = viewManager.view('active_users').select('*').limit(10);
     * const results = await viewQuery.execute();
     *
     * // Output: QueryBuilder configurado para a view 'active_users'
     * ```
     */
    view<T extends Record<string, any>>(viewName: string): QueryBuilder<T>;
}
//# sourceMappingURL=view-manager.d.ts.map