@gravito/ripple 3.1.0 → 4.0.1

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

@@ -0,0 +1,96 @@
+/**
+ * PostgreSQL Driver
+ * @description Database driver implementation for PostgreSQL using node-pg
+ */
+import type { DriverContract, DriverType, ExecuteResult, PoolHealth, PoolStats, PostgresConfig, QueryResult } from '../types';
+/**
+ * PostgreSQL Driver
+ * Connects and executes queries against PostgreSQL databases
+ */
+export declare class PostgresDriver implements DriverContract {
+    private pool;
+    private connected;
+    private transactionActive;
+    private transactionClient;
+    private preparedStatements;
+    private statementCounter;
+    private poolConfig;
+    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 connection pool statistics
+     */
+    getPoolStats(): PoolStats | null;
+    /**
+     * Get connection pool health status
+     */
+    getPoolHealth(): PoolHealth;
+    /**
+     * Adjust the connection pool size
+     * Note: pg Pool doesn't support dynamic resizing, so we reconnect with new size
+     */
+    adjustPoolSize(targetSize: number): Promise<void>;
+    /**
+     * 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

@@ -0,0 +1,43 @@
+/**
+ * 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

@@ -0,0 +1,45 @@
+/**
+ * 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

@@ -0,0 +1,260 @@
+/**
+ * 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

@@ -0,0 +1,45 @@
+/**
+ * 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);
+}