@dqcai/sqlite/lib/core/database-manager.d.ts

Universal SQLite adapter for Node.js, Browser, Deno, Bun, and React Native with a unified API and query builder.

import { DatabaseSchema, ImportOptions, ImportResult, ColumnMapping } from "../types";
import { UniversalDAO } from "./universal-dao";
export type DatabaseConnections = {
    [key: string]: UniversalDAO;
};
export interface RoleConfig {
    roleName: string;
    requiredDatabases: string[];
    optionalDatabases?: string[];
    priority?: number;
}
export type RoleRegistry = {
    [roleName: string]: RoleConfig;
};
export interface DatabaseImportConfig {
    databaseKey: string;
    tableName: string;
    data: Record<string, any>[];
    options?: Partial<ImportOptions>;
    columnMappings?: ColumnMapping[];
}
export interface BulkImportResult {
    totalDatabases: number;
    successDatabases: number;
    results: Record<string, ImportResult>;
    errors: Record<string, Error>;
    executionTime: number;
}
export interface SchemaManager {
    getSchema(key: string): DatabaseSchema | undefined;
    registerSchema(key: string, schema: DatabaseSchema): void;
    getAllSchemaKeys(): string[];
    hasSchema(key: string): boolean;
}
export declare class DatabaseManager {
    private static maxConnections;
    private static connections;
    private static isInitialized;
    private static roleRegistry;
    private static currentRole;
    private static currentUserRoles;
    private static activeDatabases;
    private static isClosingConnections;
    private static schemaConfigurations;
    private static schemaManager;
    private static eventListeners;
    /**
     * Get the maximum number of allowed database connections
     */
    static getMaxConnections(): number;
    /**
     * Set the maximum number of allowed database connections
     * @param maxConnections - The maximum number of connections (must be positive)
     * @throws Error if maxConnections is not positive or if current connections exceed the new limit
     */
    static setMaxConnections(maxConnections: number): void;
    /**
     * Set a schema manager for dynamic schema handling
     */
    static setSchemaManager(manager: SchemaManager): void;
    /**
     * Register a schema configuration dynamically
     */
    static registerSchema(key: string, schema: DatabaseSchema): void;
    /**
     * Register multiple schemas at once
     */
    static registerSchemas(schemas: Record<string, DatabaseSchema>): void;
    /**
     * Get schema from internal store or external manager
     */
    private static getSchema;
    /**
     * Get all available schema keys
     */
    static getAvailableSchemas(): string[];
    /**
     * Register a role configuration
     */
    static registerRole(roleConfig: RoleConfig): void;
    /**
     * Register multiple roles
     */
    static registerRoles(roleConfigs: RoleConfig[]): void;
    /**
     * Get all registered roles
     */
    static getRegisteredRoles(): RoleRegistry;
    /**
     * Get databases for a specific role
     */
    static getRoleDatabases(roleName: string): string[];
    /**
     * Get databases for current user roles
     */
    static getCurrentUserDatabases(): string[];
    /**
     * Initialize core database connection
     */
    static initializeCoreConnection(): Promise<void>;
    /**
     * Set current user roles and initialize connections
     */
    static setCurrentUserRoles(userRoles: string[], primaryRole?: string): Promise<void>;
    /**
     * Get current user roles
     */
    static getCurrentUserRoles(): string[];
    /**
     * Get current primary role
     */
    static getCurrentRole(): string | null;
    /**
     * Initialize connections for current user roles
     */
    private static initializeUserRoleConnections;
    /**
     * Cleanup unused connections
     */
    private static cleanupUnusedConnections;
    /**
     * Check if current user has access to database
     */
    static hasAccessToDatabase(dbKey: string): boolean;
    /**
     * Get database connection
     */
    static get(key: string): UniversalDAO;
    /**
     * Register event listener for database reconnection
     */
    static onDatabaseReconnect(schemaName: string, callback: (dao: UniversalDAO) => void): void;
    /**
     * Remove event listener for database reconnection
     */
    static offDatabaseReconnect(schemaName: string, callback: (dao: UniversalDAO) => void): void;
    /**
     * Notify listeners of database reconnection
     */
    private static notifyDatabaseReconnect;
    /**
     * Close all connections
     */
    private static closeAllConnections;
    /**
     * Reopen connections
     */
    static reopenConnections(): Promise<void>;
    /**
     * Ensure database connection exists and is active
     */
    static ensureDatabaseConnection(key: string): Promise<UniversalDAO>;
    /**
     * Get all connections
     */
    static getConnections(): DatabaseConnections;
    /**
     * Open all existing databases
     */
    static openAllExisting(databaseKeys: string[]): Promise<boolean>;
    /**
     * Initialize databases lazily
     */
    static initLazySchema(databaseKeys: string[]): Promise<boolean>;
    /**
     * Initialize all available databases
     */
    static initializeAll(): Promise<void>;
    /**
     * Get database with lazy loading
     */
    static getLazyLoading(key: string): Promise<UniversalDAO>;
    /**
     * Execute cross-schema transaction
     */
    static executeCrossSchemaTransaction(schemas: string[], callback: (daos: Record<string, UniversalDAO>) => Promise<void>): Promise<void>;
    /**
     * Import data to table
     */
    static importDataToTable(databaseKey: string, tableName: string, data: Record<string, any>[], options?: Partial<ImportOptions>): Promise<ImportResult>;
    /**
     * Import data with column mapping
     */
    static importDataWithMapping(databaseKey: string, tableName: string, data: Record<string, any>[], columnMappings: ColumnMapping[], options?: Partial<ImportOptions>): Promise<ImportResult>;
    /**
     * Bulk import data
     */
    static bulkImport(importConfigs: DatabaseImportConfig[]): Promise<BulkImportResult>;
    /**
     * Import from CSV
     */
    static importFromCSV(databaseKey: string, tableName: string, csvData: string, options?: {
        delimiter?: string;
        hasHeader?: boolean;
        columnMappings?: ColumnMapping[];
    } & Partial<ImportOptions>): Promise<ImportResult>;
    /**
     * Get connection count
     */
    static getConnectionCount(): number;
    /**
     * List all active connections
     */
    static listConnections(): string[];
    /**
     * Close specific connection
     */
    static closeConnection(dbKey: string): Promise<void>;
    /**
     * Close all connections and reset state
     */
    static closeAll(): Promise<void>;
    /**
     * Logout user - close role-specific connections
     */
    static logout(): Promise<void>;
}
//# sourceMappingURL=database-manager.d.ts.map