@gravito/echo 3.1.0 → 3.1.2

package/dist/atlas/src/drivers/BunSQLPreparedStatement.d.ts

@@ -1,118 +0,0 @@
-/**
- * Bun SQL Prepared Statement Manager
- * @description Manages prepared statement caching, lifecycle, and optimization
- */
-import type { BunSQLClient } from './types';
-/**
- * Configuration options for prepared statement manager
- */
-export interface PreparedStatementManagerConfig {
-    /**
-     * Maximum number of prepared statements to cache
-     * @default 100
-     */
-    maxStatements?: number;
-    /**
-     * Idle timeout in milliseconds before a statement is removed
-     * @default 60000 (1 minute)
-     */
-    idleTimeout?: number;
-}
-/**
- * Prepared Statement Manager for BunSQL
- *
- * Manages statement caching and lifecycle to optimize query performance.
- * Features:
- * - LRU (Least Recently Used) cache eviction
- * - Idle timeout cleanup
- * - Usage statistics tracking
- *
- * @example
- * ```typescript
- * const manager = new BunSQLPreparedStatementManager(client)
- *
- * // Prepare a statement
- * const stmtId = await manager.prepare('SELECT * FROM users WHERE id = ?')
- *
- * // Execute multiple times
- * const users1 = await manager.execute(stmtId, [1])
- * const users2 = await manager.execute(stmtId, [2])
- *
- * // Clean up
- * await manager.clear()
- * ```
- */
-export declare class BunSQLPreparedStatementManager {
-    private readonly client;
-    private statements;
-    private sqlToName;
-    private readonly config;
-    private cleanupTimer?;
-    constructor(client: BunSQLClient, config?: PreparedStatementManagerConfig);
-    /**
-     * Prepare a SQL statement for repeated execution
-     *
-     * @param sql - SQL query to prepare
-     * @returns Prepared statement identifier
-     */
-    prepare(sql: string): Promise<string>;
-    /**
-     * Execute a prepared statement
-     *
-     * @param name - Prepared statement identifier
-     * @param bindings - Query parameters
-     * @returns Query result rows
-     */
-    execute<T = Record<string, unknown>>(name: string, bindings?: unknown[]): Promise<T[]>;
-    /**
-     * Clear all prepared statements
-     */
-    clear(): Promise<void>;
-    /**
-     * Clean up idle statements
-     */
-    cleanup(): Promise<void>;
-    /**
-     * Get statement usage statistics
-     *
-     * @param name - Prepared statement identifier
-     * @returns Usage statistics or null if not found
-     */
-    getStats(name: string): {
-        useCount: number;
-        lastUsed: number;
-    } | null;
-    /**
-     * Get the number of cached statements
-     */
-    getSize(): number;
-    /**
-     * Destroy the manager and clean up resources
-     */
-    destroy(): Promise<void>;
-    /**
-     * Evict the least recently used statement
-     * @private
-     */
-    private evictLeastRecentlyUsed;
-    /**
-     * Generate a unique statement name
-     * @private
-     */
-    private generateStatementName;
-    /**
-     * Simple hash function for SQL strings
-     * @private
-     */
-    private simpleHash;
-    /**
-     * Start periodic cleanup timer
-     * @private
-     */
-    private startCleanupTimer;
-    /**
-     * Stop cleanup timer
-     * @private
-     */
-    private stopCleanupTimer;
-}

package/dist/atlas/src/drivers/MongoDBDriver.d.ts

@@ -1,36 +0,0 @@
-import type { ConnectionConfig, DriverContract, DriverType, ExecuteResult, QueryResult } from '../types';
-/**
- * MongoDB Driver
- * Provides a document interface via DB.connection('mongodb')
- */
-import type { MongoClient } from './types';
-export declare class MongoDBDriver implements DriverContract {
-    private config;
-    private client;
-    private db;
-    private MongoClientCtor?;
-    constructor(config: ConnectionConfig, deps?: {
-        MongoClient?: new (url: string, options?: Record<string, unknown>) => MongoClient;
-    });
-    getDriverName(): DriverType;
-    connect(): Promise<void>;
-    /**
-     * Dynamically load mongodb module
-     */
-    private loadMongoModule;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    /**
-     * Execute a query (Protocol: JSON String)
-     */
-    query<T = Record<string, unknown>>(protocolJson: string, _bindings?: unknown[]): Promise<QueryResult<T>>;
-    /**
-     * Execute a write operation (Protocol: JSON String)
-     */
-    execute(protocolJson: string, _bindings?: unknown[]): Promise<ExecuteResult>;
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    inTransaction(): boolean;
-    private mapDocument;
-}

package/dist/atlas/src/drivers/MySQLDriver.d.ts

@@ -1,66 +0,0 @@
-/**
- * MySQL/MariaDB Driver
- * @description Database driver for MySQL and MariaDB using mysql2 package
- */
-import type { ConnectionConfig, DriverContract, DriverType, ExecuteResult, QueryResult } from '../types';
-export declare class MySQLDriver implements DriverContract {
-    private readonly config;
-    private readonly driverType;
-    private pool;
-    private transactionConnection;
-    private connected;
-    private mysql;
-    constructor(config: ConnectionConfig, driverType?: 'mysql' | 'mariadb');
-    /**
-     * Get the driver name
-     */
-    getDriverName(): DriverType;
-    /**
-     * Connect to MySQL/MariaDB
-     */
-    connect(): Promise<void>;
-    /**
-     * Dynamically load mysql2 module
-     */
-    private loadMySQLModule;
-    /**
-     * Disconnect from MySQL
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Check if connected
-     */
-    isConnected(): boolean;
-    /**
-     * Execute a query
-     */
-    query<T = Record<string, unknown>>(sql: string, bindings?: unknown[]): Promise<QueryResult<T>>;
-    /**
-     * Execute a statement (INSERT/UPDATE/DELETE)
-     */
-    execute(sql: string, bindings?: unknown[]): Promise<ExecuteResult>;
-    /**
-     * Begin a transaction
-     */
-    beginTransaction(): Promise<void>;
-    /**
-     * Commit the current transaction
-     */
-    commit(): Promise<void>;
-    /**
-     * Rollback the current transaction
-     */
-    rollback(): Promise<void>;
-    /**
-     * Check if in transaction
-     */
-    inTransaction(): boolean;
-    /**
-     * Get a connection from the pool
-     */
-    private getConnection;
-    /**
-     * Normalize MySQL/MariaDB errors
-     */
-    private normalizeError;
-}

package/dist/atlas/src/drivers/PostgresDriver.d.ts

@@ -1,83 +0,0 @@
-/**
- * PostgreSQL Driver
- * @description Database driver implementation for PostgreSQL using node-pg
- */
-import type { DriverContract, DriverType, ExecuteResult, PostgresConfig, QueryResult } from '../types';
-/**
- * PostgreSQL Driver
- * Connects and executes queries against PostgreSQL databases
- */
-export declare class PostgresDriver implements DriverContract {
-    private readonly config;
-    private pool;
-    private connected;
-    private transactionActive;
-    private transactionClient;
-    private preparedStatements;
-    private statementCounter;
-    constructor(config: PostgresConfig);
-    /**
-     * Get driver name
-     */
-    getDriverName(): DriverType;
-    /**
-     * Connect to the database
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from the database
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Check if connected
-     */
-    isConnected(): boolean;
-    /**
-     * Execute a query and return results
-     */
-    query<T = Record<string, unknown>>(sql: string, bindings?: unknown[]): Promise<QueryResult<T>>;
-    /**
-     * Execute a statement (INSERT/UPDATE/DELETE)
-     */
-    execute(sql: string, bindings?: unknown[]): Promise<ExecuteResult>;
-    /**
-     * Prepare a statement for repeated execution
-     */
-    prepare(sql: string): Promise<string>;
-    /**
-     * Execute a prepared statement
-     */
-    executePrepared<T>(name: string, bindings?: unknown[]): Promise<QueryResult<T>>;
-    /**
-     * Clear all prepared statements
-     */
-    clearPreparedStatements(): Promise<void>;
-    /**
-     * Begin a transaction
-     */
-    beginTransaction(): Promise<void>;
-    /**
-     * Commit the current transaction
-     */
-    commit(): Promise<void>;
-    /**
-     * Rollback the current transaction
-     */
-    rollback(): Promise<void>;
-    /**
-     * Check if currently in a transaction
-     */
-    inTransaction(): boolean;
-    /**
-     * Get a client for executing queries
-     */
-    private getClient;
-    /**
-     * Normalize PostgreSQL errors
-     */
-    private normalizeError;
-    /**
-     * Dynamically load the pg module
-     */
-    private loadPgModule;
-}

package/dist/atlas/src/drivers/RedisDriver.d.ts

@@ -1,43 +0,0 @@
-/**
- * Redis Driver
- * @description Driver implementation for Redis using ioredis
- */
-import type { ConnectionConfig, DriverContract, DriverType, ExecuteResult, QueryResult } from '../types';
-/**
- * Redis Driver
- * Provides a key-value interface via DB.connection('redis')
- */
-import type { RedisClient } from './types';
-export declare class RedisDriver implements DriverContract {
-    private config;
-    private client;
-    private RedisCtor?;
-    constructor(config: ConnectionConfig, deps?: {
-        Redis?: new (config: Record<string, unknown>) => RedisClient;
-    });
-    getDriverName(): DriverType;
-    connect(): Promise<void>;
-    /**
-     * Dynamically load ioredis module
-     */
-    private loadRedisModule;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    /**
-     * Raw Redis command execution via pseudo-SQL or direct mapping
-     */
-    query<T = any>(_sql: string, _bindings?: unknown[]): Promise<QueryResult<T>>;
-    execute(_sql: string, _bindings?: unknown[]): Promise<ExecuteResult>;
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string | number): Promise<'OK'>;
-    setex(key: string, seconds: number, value: string | number): Promise<'OK'>;
-    del(key: string): Promise<number>;
-    /**
-     * Get the raw ioredis client for advanced operations
-     */
-    getRawClient(): RedisClient | null;
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    inTransaction(): boolean;
-}

package/dist/atlas/src/drivers/SQLiteDriver.d.ts

@@ -1,45 +0,0 @@
-/**
- * SQLite Driver
- * @description Database driver implementation for SQLite using better-sqlite3
- */
-import type { ConnectionConfig, DriverContract, DriverType, ExecuteResult, QueryResult } from '../types';
-/**
-
- * SQLite Driver
-
- */
-/**
- * SQLite driver implementation for Atlas ORM.
- *
- * Automatically detects and uses `bun:sqlite` if running in Bun,
- * otherwise falls back to `better-sqlite3`.
- *
- * @public
- * @since 3.0.0
- */
-export declare class SQLiteDriver implements DriverContract {
-    private config;
-    private client;
-    private inTransactionState;
-    constructor(config: ConnectionConfig);
-    getDriverName(): DriverType;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    query<T = Record<string, unknown>>(sql: string, bindings?: unknown[]): Promise<QueryResult<T>>;
-    execute(sql: string, bindings?: unknown[]): Promise<ExecuteResult>;
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    inTransaction(): boolean;
-    /**
-  
-  
-  
-       * Normalize SQLite errors
-  
-  
-  
-       */
-    private normalizeError;
-}

package/dist/atlas/src/drivers/types.d.ts

@@ -1,260 +0,0 @@
-/**
- * Driver Type Definitions
- * @description Type definitions for third-party database driver libraries
- */
-/**
- * MySQL/MariaDB Pool Connection
- */
-export interface MySQLPool {
-    query(sql: string, values?: unknown[]): Promise<unknown>;
-    execute(sql: string, values?: unknown[]): Promise<unknown>;
-    getConnection(): Promise<MySQLConnection>;
-    end(): Promise<void>;
-}
-/**
- * MySQL/MariaDB Connection
- */
-export interface MySQLConnection {
-    query(sql: string, values?: unknown[]): Promise<unknown>;
-    execute(sql: string, values?: unknown[]): Promise<unknown>;
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    release(): void;
-}
-/**
- * MySQL/MariaDB Module
- */
-export interface MySQLModule {
-    createPool(config: Record<string, unknown>): MySQLPool;
-    createConnection(config: Record<string, unknown>): Promise<MySQLConnection>;
-}
-/**
- * PostgreSQL Pool Client
- */
-export interface PostgresPoolClient {
-    query(sql: string, values?: unknown[]): Promise<{
-        rows: unknown[];
-        rowCount: number;
-    }>;
-    release(): void;
-}
-/**
- * PostgreSQL Pool
- */
-export interface PostgresPool {
-    connect(): Promise<PostgresPoolClient>;
-    query(sql: string, values?: unknown[]): Promise<{
-        rows: unknown[];
-        rowCount: number;
-    }>;
-    end(): Promise<void>;
-}
-/**
- * SQLite Database Client (Bun)
- */
-export interface SQLiteClient {
-    prepare(sql: string): SQLiteStatement;
-    query(sql: string, ...params: unknown[]): unknown[];
-    run(sql: string, ...params: unknown[]): {
-        changes: number;
-        lastInsertRowid: number;
-    };
-    exec?(sql: string): void;
-    pragma?(name: string, value?: unknown): unknown;
-    open?: boolean;
-    inTransaction?: boolean;
-    close(): void;
-}
-/**
- * SQLite Statement
- */
-export interface SQLiteStatement {
-    run(...params: unknown[]): {
-        changes: number;
-        lastInsertRowid: number;
-    };
-    all(...params: unknown[]): unknown[];
-    get(...params: unknown[]): unknown;
-}
-/**
- * Redis Client
- */
-export interface RedisClient {
-    connect(): Promise<void>;
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string | number): Promise<'OK'>;
-    setex(key: string, seconds: number, value: string | number): Promise<'OK'>;
-    del(key: string): Promise<number>;
-    keys(pattern: string): Promise<string[]>;
-    exists(key: string): Promise<number>;
-    expire(key: string, seconds: number): Promise<number>;
-    quit(): Promise<void>;
-    status?: string;
-}
-/**
- * MongoDB Client
- */
-export interface MongoClient {
-    connect(): Promise<void>;
-    db(name?: string): MongoDatabase;
-    close(): Promise<void>;
-}
-/**
- * MongoDB Database
- */
-export interface MongoDatabase {
-    collection(name: string): MongoCollection;
-}
-/**
- * MongoDB Collection
- */
-export interface MongoCollection {
-    find(filter?: Record<string, unknown>, options?: Record<string, unknown>): MongoCursor;
-    findOne(filter?: Record<string, unknown>): Promise<Record<string, unknown> | null>;
-    insertOne(doc: Record<string, unknown>): Promise<{
-        insertedId: unknown;
-    }>;
-    insertMany(docs: Record<string, unknown>[]): Promise<{
-        insertedIds: unknown[];
-        insertedCount: number;
-    }>;
-    countDocuments(filter?: Record<string, unknown>): Promise<number>;
-    updateOne(filter: Record<string, unknown>, update: Record<string, unknown>): Promise<{
-        modifiedCount: number;
-    }>;
-    updateMany(filter: Record<string, unknown>, update: Record<string, unknown>): Promise<{
-        modifiedCount: number;
-    }>;
-    deleteOne(filter: Record<string, unknown>): Promise<{
-        deletedCount: number;
-    }>;
-    deleteMany(filter: Record<string, unknown>): Promise<{
-        deletedCount: number;
-    }>;
-}
-/**
- * MongoDB Cursor
- */
-export interface MongoCursor {
-    toArray(): Promise<Record<string, unknown>[]>;
-    limit(n: number): MongoCursor;
-    skip(n: number): MongoCursor;
-    sort(sort: Record<string, 1 | -1>): MongoCursor;
-}
-/**
- * Bun SQL Client (Enhanced for Bun 1.3+)
- * @description Comprehensive type definitions for Bun.sql native driver
- */
-export interface BunSQLClient {
-    (strings: TemplateStringsArray, ...values: unknown[]): Promise<BunSQLResult>;
-    unsafe?(sql: string, bindings?: unknown[]): Promise<BunSQLResult>;
-    query?(sql: string, bindings?: unknown[]): Promise<BunSQLResult>;
-    all?(sql: string, bindings?: unknown[]): Promise<unknown[]>;
-    run?(sql: string, bindings?: unknown[]): Promise<BunSQLResult>;
-    simple?(strings: TemplateStringsArray, ...values: unknown[]): Promise<BunSQLResult>;
-    prepare?(sql: string): BunSQLPreparedStatement;
-    transaction?<T>(callback: (sql: BunSQLClient) => Promise<T>): Promise<T>;
-    begin?(): Promise<BunSQLTransaction>;
-    close?(): Promise<void>;
-    end?(): Promise<void>;
-    readonly connections?: {
-        idle: number;
-        pending: number;
-        active: number;
-        total: number;
-    };
-}
-/**
- * Bun SQL Query Result
- * @description Result structure returned by Bun.sql queries
- */
-export interface BunSQLResult {
-    /**
-     * Result rows (iterable)
-     */
-    rows?: unknown[];
-    /**
-     * Number of rows affected/returned
-     */
-    rowCount?: number;
-    count?: number;
-    /**
-     * Last inserted ID (for INSERT operations)
-     */
-    lastInsertRowid?: number | bigint;
-    /**
-     * Number of changed rows (for UPDATE operations)
-     */
-    changes?: number;
-    /**
-     * Iterator support for streaming
-     */
-    [Symbol.iterator](): Iterator<unknown>;
-}
-/**
- * Bun SQL Prepared Statement
- * @description Prepared statement interface for query optimization
- */
-export interface BunSQLPreparedStatement {
-    /**
-     * Execute prepared statement and return result
-     */
-    run(...params: unknown[]): Promise<BunSQLResult>;
-    /**
-     * Execute and return all rows
-     */
-    all(...params: unknown[]): Promise<unknown[]>;
-    /**
-     * Execute and return first row
-     */
-    get(...params: unknown[]): Promise<unknown | undefined>;
-    /**
-     * Finalize and release the prepared statement
-     */
-    finalize(): void;
-}
-/**
- * Bun SQL Transaction
- * @description Transaction handle for advanced transaction control
- */
-export interface BunSQLTransaction {
-    /**
-     * Commit the transaction
-     */
-    commit(): Promise<void>;
-    /**
-     * Rollback the transaction
-     */
-    rollback(): Promise<void>;
-    /**
-     * Create a savepoint
-     */
-    savepoint?(name: string): Promise<void>;
-    /**
-     * Rollback to a savepoint
-     */
-    rollbackTo?(name: string): Promise<void>;
-    /**
-     * Release a savepoint
-     */
-    release?(name: string): Promise<void>;
-}
-/**
- * Bun SQL Pool Configuration
- * @description Configuration options for connection pool
- */
-export interface BunSQLPoolConfig {
-    /**
-     * Maximum number of connections in the pool
-     */
-    max?: number;
-    /**
-     * Maximum time (ms) a connection can be idle before being released
-     */
-    idleTimeout?: number;
-    /**
-     * Maximum time (ms) to wait for a connection from the pool
-     */
-    connectionTimeout?: number;
-}

package/dist/atlas/src/errors/index.d.ts

@@ -1,45 +0,0 @@
-/**
- * Base Database Error
- */
-export declare class DatabaseError extends Error {
-    readonly originalError: unknown;
-    readonly query?: string;
-    readonly bindings?: unknown[];
-    constructor(message: string, originalError?: unknown, query?: string, bindings?: unknown[]);
-}
-/**
- * Constraint Violation Error (Base)
- */
-export declare class ConstraintViolationError extends DatabaseError {
-    constructor(message: string, originalError?: unknown, query?: string, bindings?: unknown[]);
-}
-/**
- * Unique Constraint Violation
- */
-export declare class UniqueConstraintError extends ConstraintViolationError {
-    constructor(message: string, originalError?: unknown, query?: string, bindings?: unknown[]);
-}
-/**
- * Foreign Key Constraint Violation
- */
-export declare class ForeignKeyConstraintError extends ConstraintViolationError {
-    constructor(message: string, originalError?: unknown, query?: string, bindings?: unknown[]);
-}
-/**
- * Not Null Constraint Violation
- */
-export declare class NotNullConstraintError extends ConstraintViolationError {
-    constructor(message: string, originalError?: unknown, query?: string, bindings?: unknown[]);
-}
-/**
- * Table Not Found Error
- */
-export declare class TableNotFoundError extends DatabaseError {
-    constructor(message: string, originalError?: unknown, query?: string, bindings?: unknown[]);
-}
-/**
- * Connection Error
- */
-export declare class ConnectionError extends DatabaseError {
-    constructor(message: string, originalError?: unknown);
-}