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

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

import { SQLiteAdapter, DatabaseSchema, DbFactoryOptions } from "../types";
import { UniversalDAO } from "./universal-dao";
/**
 * Universal DatabaseFactory - A powerful utility class designed to create and manage
 * UniversalDAO instances from JSON schema across all operating systems and frameworks
 * using TypeScript and JavaScript. It provides methods for creating new, opening existing
 * databases, checking integrity, and managing database lifecycle.
 */
export declare class DatabaseFactory {
    private static adapters;
    /**
     * Register a SQLite adapter for use by the factory
     * @param adapter The SQLite adapter to register
     */
    static registerAdapter(adapter: SQLiteAdapter): void;
    /**
     * Get information about the current runtime environment
     * @returns A string describing the current environment
     */
    static getEnvironmentInfo(): string;
    /**
     * Detect the best available SQLite adapter for the current environment
     * @returns The best available SQLite adapter
     * @throws Error if no supported adapter is found
     */
    private static detectBestAdapter;
    /**
     * Validate schema version compatibility between database and config
     * @param dao The UniversalDAO instance
     * @param schema The database schema configuration
     */
    private static validateSchemaVersion;
    /**
     * Validate the provided schema object to ensure it has minimum required properties
     * @param schema The schema object to validate
     * @returns True if the schema is valid, otherwise throws an error
     */
    private static validateSchema;
    /**
     * Create a new UniversalDAO instance (equivalent to SQLiteDAO)
     * @param dbPath Path to the database file
     * @param options Configuration options
     * @returns A new UniversalDAO instance
     */
    static createDAO(dbPath: string, options?: {
        adapter?: SQLiteAdapter;
        createIfNotExists?: boolean;
        forceRecreate?: boolean;
    }): UniversalDAO;
    /**
     * Opens an existing database without initializing its schema.
     * Includes integrity check to detect corrupted files.
     * @param dbName The name of the database (e.g., 'core.db' or 'core').
     * @param options Additional options for database connection.
     * @returns A promise that resolves to a connected UniversalDAO instance.
     */
    static openExisting(dbName: string, options?: Omit<DbFactoryOptions, "config" | "configAsset" | "configPath">): Promise<UniversalDAO>;
    /**
     * Internal method to create or open database with various options
     * @param options Configuration options
     * @param isForceInit Allow re-initialization of existing database
     * @param isForceDelete Force delete and recreate database
     * @returns Promise that resolves to initialized UniversalDAO
     */
    private static createOrOpenInternal;
    /**
     * Create a new database (DANGEROUS - will delete existing database)
     * Only use this for migrations or development, not in production
     * @param options Configuration options
     * @returns Promise that resolves to initialized UniversalDAO
     */
    static create(options: DbFactoryOptions): Promise<UniversalDAO>;
    /**
     * Smart method to create or open database
     * Only creates new tables if they don't exist and initializes file initially
     * Will check if file exists and is valid before deciding to create new or open existing
     * @param options Database configuration options
     * @param isForceInit Force re-initialization of tables even if they exist (default: false)
     * @returns Promise that resolves to initialized UniversalDAO
     */
    static createOrOpen(options: DbFactoryOptions, isForceInit?: boolean): Promise<UniversalDAO>;
    /**
     * Convenience method to create a database from a JSON asset
     * @param configAsset The imported/required JSON configuration
     * @param options Additional options for database creation
     * @returns Promise that resolves to initialized UniversalDAO
     */
    static createFromAsset(configAsset: DatabaseSchema, options?: Omit<DbFactoryOptions, "config" | "configAsset" | "configPath">): Promise<UniversalDAO>;
    /**
     * Convenience method to create a database from a configuration object
     * @param config The database schema configuration object
     * @param options Additional options for database creation
     * @returns Promise that resolves to initialized UniversalDAO
     */
    static createFromConfig(config: DatabaseSchema, options?: Omit<DbFactoryOptions, "config" | "configAsset" | "configPath">): Promise<UniversalDAO>;
}
export default DatabaseFactory;
//# sourceMappingURL=database-factory.d.ts.map