@gravito/ripple 4.0.1 → 5.0.0

package/dist/atlas/src/orm/model/relationships.d.ts

@@ -1,207 +0,0 @@
-/**
- * Relationship Types and Base Classes
- * @description Declarative relationship definitions for ORM
- */
-import type { QueryBuilderContract } from '../../types';
-import type { Model, ModelConstructor } from './Model';
-/**
- * Relationship Type
- */
-export type RelationType = 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany' | 'morphOne' | 'morphMany' | 'morphTo';
-/**
- * Options for defining relationships between models.
- */
-export interface RelationshipOptions {
-    /**
-     * The foreign key column name.
-     * - For `HasOne`/`HasMany`: Defaults to `parent_table_id` on the related table.
-     * - For `BelongsTo`: Defaults to `related_table_id` on the local table.
-     * - For `BelongsToMany`: Defaults to `parent_table_id` on the pivot table.
-     */
-    foreignKey?: string;
-    /**
-     * The local key column name.
-     * - For `HasOne`/`HasMany`: Defaults to the primary key of the local table.
-     * - For `BelongsTo`: Defaults to the primary key of the related table.
-     */
-    localKey?: string;
-    /**
-     * The name of the pivot table for many-to-many relationships.
-     * Defaults to an alphabetical concatenation of the two table names (e.g., `roles_users`).
-     */
-    pivotTable?: string;
-    /**
-     * The related key column name in the pivot table.
-     * Defaults to `related_table_id`.
-     */
-    relatedKey?: string;
-    /**
-     * Additional columns to select from the pivot table.
-     */
-    pivotColumns?: string[];
-}
-/**
- * Relationship Metadata
- */
-export interface RelationshipMeta {
-    type: RelationType;
-    related?: () => ModelConstructor<Model> & typeof Model;
-    foreignKey?: string;
-    localKey?: string;
-    pivotTable?: string | undefined;
-    relatedKey?: string | undefined;
-    pivotColumns?: string[] | undefined;
-    morphName?: string;
-    morphTypeField?: string;
-    morphIdField?: string;
-}
-/**
- * Get relationships for a model
- */
-export declare function getRelationships(model: typeof Model): Map<string, RelationshipMeta>;
-/**
- * Define a relationship on a model
- */
-export declare function defineRelationship(model: typeof Model, name: string, meta: RelationshipMeta): void;
-/**
- * HasOne Relationship Decorator
- *
- * Defines a one-to-one relationship where the related model's table
- * contains the foreign key.
- *
- * @param related - A factory function that returns the related Model class.
- * @param options - Configuration for the relationship.
- *
- * @example
- * ```typescript
- * class User extends Model {
- *   @HasOne(() => Profile)
- *   declare profile: Profile
- * }
- * ```
- */
-export declare function HasOne(related: () => ModelConstructor<Model> & typeof Model, options?: Omit<RelationshipOptions, 'pivotTable'>): PropertyDecorator;
-/**
- * HasMany Relationship Decorator
- *
- * Defines a one-to-many relationship where the related model's table
- * contains the foreign key.
- *
- * @param related - A factory function that returns the related Model class.
- * @param options - Configuration for the relationship.
- *
- * @example
- * ```typescript
- * class User extends Model {
- *   @HasMany(() => Post)
- *   declare posts: Post[]
- * }
- * ```
- */
-export declare function HasMany(related: () => ModelConstructor<Model> & typeof Model, options?: Omit<RelationshipOptions, 'pivotTable'>): PropertyDecorator;
-/**
- * BelongsTo Relationship Decorator
- *
- * Defines an inverse relationship where the local model's table
- * contains the foreign key.
- *
- * @param related - A factory function that returns the related Model class.
- * @param options - Configuration for the relationship.
- *
- * @example
- * ```typescript
- * class Post extends Model {
- *   @BelongsTo(() => User)
- *   declare author: User
- * }
- * ```
- */
-export declare function BelongsTo(related: () => ModelConstructor<Model> & typeof Model, options?: Omit<RelationshipOptions, 'pivotTable'>): PropertyDecorator;
-/**
- * BelongsToMany Relationship Decorator
- *
- * Defines a many-to-many relationship using a pivot table.
- *
- * @param related - A factory function that returns the related Model class.
- * @param options - Configuration for the relationship, including pivot table details.
- *
- * @example
- * ```typescript
- * class User extends Model {
- *   @BelongsToMany(() => Role, { pivotTable: 'user_roles' })
- *   declare roles: Role[]
- * }
- * ```
- */
-export declare function BelongsToMany(related: () => ModelConstructor<Model> & typeof Model, options?: RelationshipOptions): PropertyDecorator;
-/**
- * MorphOne Relationship Decorator
- *
- * Defines a polymorphic one-to-one relationship.
- *
- * @param related - A factory function that returns the related Model class.
- * @param name - The name of the polymorphic relationship (e.g., 'imageable').
- * @param options - Configuration for the relationship.
- *
- * @example
- * ```typescript
- * class Post extends Model {
- *   @MorphOne(() => Image, 'imageable')
- *   declare image: Image
- * }
- * ```
- */
-export declare function MorphOne(related: () => ModelConstructor<Model> & typeof Model, name: string, options?: {
-    foreignKey?: string;
-    localKey?: string;
-}): PropertyDecorator;
-/**
- * MorphMany Relationship Decorator
- *
- * Defines a polymorphic one-to-many relationship.
- *
- * @param related - A factory function that returns the related Model class.
- * @param name - The name of the polymorphic relationship (e.g., 'commentable').
- * @param options - Configuration for the relationship.
- *
- * @example
- * ```typescript
- * class Post extends Model {
- *   @MorphMany(() => Comment, 'commentable')
- *   declare comments: Comment[]
- * }
- * ```
- */
-export declare function MorphMany(related: () => ModelConstructor<Model> & typeof Model, name: string, options?: {
-    foreignKey?: string;
-    localKey?: string;
-}): PropertyDecorator;
-/**
- * MorphTo Relationship Decorator
- *
- * Defines the inverse of a polymorphic relationship.
- *
- * @param options - Configuration for the polymorphic relationship.
- *
- * @example
- * ```typescript
- * class Comment extends Model {
- *   @MorphTo()
- *   declare commentable: Post | Video
- * }
- * ```
- */
-export declare function MorphTo(options?: {
-    name?: string;
-    typeField?: string;
-    idField?: string;
-}): PropertyDecorator;
-/**
- * Load related models for a collection of parent models
- * Uses batch queries to avoid N+1 problem
- */
-export declare function eagerLoad<T extends Model, R extends Model = Model>(parents: T[], relationName: string, callback?: (query: QueryBuilderContract<R>) => void): Promise<void>;
-/**
- * Load multiple relationships
- */
-export declare function eagerLoadMany<T extends Model, R extends Model = Model>(parents: T[], relations: string[] | Record<string, unknown> | Map<string, (query: QueryBuilderContract<R>) => void>): Promise<void>;

package/dist/atlas/src/orm/model/types.d.ts

@@ -1,12 +0,0 @@
-import type { Model } from './Model';
-export interface ModelObserver<T extends Model> {
-    creating?(model: T): void | Promise<void>;
-    created?(model: T): void | Promise<void>;
-    updating?(model: T): void | Promise<void>;
-    updated?(model: T): void | Promise<void>;
-    deleting?(model: T): void | Promise<void>;
-    deleted?(model: T): void | Promise<void>;
-    saving?(model: T): void | Promise<void>;
-    saved?(model: T): void | Promise<void>;
-    retrieved?(model: T): void | Promise<void>;
-}

package/dist/atlas/src/orm/schema/SchemaRegistry.d.ts

@@ -1,124 +0,0 @@
-/**
- * Schema Registry
- * @description Central registry for table schemas with JIT sniffing and AOT locking
- */
-import type { ColumnSchema, TableSchema } from './types';
-/**
- * Schema Registry Mode
- */
-export type SchemaMode = 'jit' | 'aot';
-/**
- * Schema Registry Options
- */
-export interface SchemaRegistryOptions {
-    /** Mode: jit (dev) or aot (prod) */
-    mode?: SchemaMode;
-    /** Path to schema lock file */
-    lockPath?: string;
-    /** Database connection name */
-    connection?: string;
-    /** Cache TTL in milliseconds (JIT mode) */
-    cacheTtl?: number;
-}
-/**
- * Schema Registry
- * Central registry for table schemas
- *
- * @example
- * ```typescript
- * // Dev mode: JIT sniffing
- * const registry = SchemaRegistry.getInstance({ mode: 'jit' })
- * const schema = await registry.get('users')
- *
- * // Prod mode: AOT from lock file
- * SchemaRegistry.init({ mode: 'aot', lockPath: '.schema-lock.json' })
- * const schema = await registry.get('users')
- * ```
- */
-export declare class SchemaRegistry {
-    private static instance;
-    private cache;
-    private pendingSniffs;
-    private sniffer;
-    private mode;
-    private lockPath;
-    private cacheTtl;
-    private _initialized;
-    private constructor();
-    /**
-     * Check if registry is initialized
-     */
-    get isInitialized(): boolean;
-    /**
-     * Initialize the registry (call once at startup)
-     */
-    static init(options?: SchemaRegistryOptions): SchemaRegistry;
-    /**
-     * Get the registry instance
-     */
-    static getInstance(): SchemaRegistry;
-    /**
-     * Reset the registry (for testing)
-     */
-    static reset(): void;
-    /**
-     * Get schema for a table
-     */
-    get(table: string, connection?: string): Promise<TableSchema>;
-    /**
-     * Check if table schema exists
-     */
-    has(table: string): boolean;
-    /**
-     * Get column schema
-     */
-    getColumn(table: string, column: string): Promise<ColumnSchema | undefined>;
-    /**
-     * Check if column exists
-     */
-    hasColumn(table: string, column: string): Promise<boolean>;
-    /**
-     * Get all cached tables
-     */
-    getTables(): string[];
-    /**
-     * Invalidate cache for a specific table
-     * Forces re-sniff on next access
-     */
-    invalidate(table: string): void;
-    /**
-     * Invalidate all cached schemas
-     */
-    invalidateAll(): void;
-    /**
-     * Force refresh schema for a table
-     * Re-sniffs even if cached (JIT mode only)
-     */
-    refresh(table: string): Promise<TableSchema>;
-    /**
-     * Wrap a database operation with self-healing
-     * Automatically re-sniffs schema on column-related errors and retries
-     *
-     * @example
-     * ```typescript
-     * const result = await registry.withSelfHealing('users', async () => {
-     *   return await connection.table('users').where('new_column', value).get()
-     * })
-     * ```
-     */
-    withSelfHealing<T>(table: string, operation: () => Promise<T>): Promise<T>;
-    /**
-     * Check if an error is schema-related
-     */
-    private isSchemaError;
-    /**
-     * Load schemas from lock file (AOT mode)
-     */
-    loadFromLock(path?: string): void;
-    /**
-     * Save schemas to lock file
-     */
-    saveToLock(tables: string[], path?: string): Promise<void>;
-    private serializeTableSchema;
-    private deserializeTableSchema;
-}

package/dist/atlas/src/orm/schema/SchemaSniffer.d.ts

@@ -1,54 +0,0 @@
-/**
- * Schema Sniffer
- * @description Introspects database schema at runtime (JIT mode)
- */
-import type { TableSchema } from './types';
-/**
- * Schema Sniffer
- * Retrieves table schema from database at runtime
- */
-export declare class SchemaSniffer {
-    private connectionName;
-    constructor(connectionName?: string);
-    /**
-     * Sniff table schema from database
-     */
-    sniff(table: string): Promise<TableSchema>;
-    /**
-     * Sniff SQLite table schema
-     */
-    private sniffSQLite;
-    /**
-     * Sniff PostgreSQL table schema
-     */
-    private sniffPostgres;
-    /**
-     * Sniff MySQL table schema
-     */
-    private sniffMySQL;
-    /**
-     * Map PostgreSQL type to ColumnType
-     */
-    private mapPostgresType;
-    /**
-     * Map MySQL type to ColumnType
-     */
-    private mapMySQLType;
-    private mapSQLiteType;
-    /**
-     * Parse default value
-     */
-    private parseDefault;
-    /**
-     * Extract length from MySQL type
-     */
-    private extractMySQLLength;
-    /**
-     * Extract enum values from MySQL type
-     */
-    private extractMySQLEnumValues;
-    /**
-     * Get driver name
-     */
-    private getDriverName;
-}

package/dist/atlas/src/orm/schema/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Schema Module Index
- */
-export { type SchemaMode, SchemaRegistry, type SchemaRegistryOptions } from './SchemaRegistry';
-export { SchemaSniffer } from './SchemaSniffer';
-export type { ColumnSchema, ColumnType, SchemaLock, SerializedColumnSchema, SerializedTableSchema, TableSchema, } from './types';

package/dist/atlas/src/orm/schema/types.d.ts

@@ -1,85 +0,0 @@
-/**
- * Schema Types
- * @description Type definitions for schema introspection
- */
-/**
- * Column data types
- */
-export type ColumnType = 'string' | 'text' | 'integer' | 'bigint' | 'smallint' | 'decimal' | 'float' | 'boolean' | 'date' | 'time' | 'datetime' | 'timestamp' | 'json' | 'jsonb' | 'uuid' | 'binary' | 'enum' | 'unknown';
-/**
- * Column schema definition
- */
-export interface ColumnSchema {
-    /** Column name */
-    name: string;
-    /** Column type */
-    type: ColumnType;
-    /** Is nullable */
-    nullable: boolean;
-    /** Default value */
-    default?: unknown;
-    /** Is primary key */
-    primary: boolean;
-    /** Is unique */
-    unique: boolean;
-    /** Is auto-increment */
-    autoIncrement: boolean;
-    /** Enum values (if type is enum) */
-    enumValues?: string[] | undefined;
-    /** Max length (for string types) */
-    maxLength?: number | undefined;
-    /** Numeric precision */
-    precision?: number | undefined;
-    /** Numeric scale */
-    scale?: number | undefined;
-}
-/**
- * Table schema definition
- */
-export interface TableSchema {
-    /** Table name */
-    table: string;
-    /** Column definitions */
-    columns: Map<string, ColumnSchema>;
-    /** Primary key column(s) */
-    primaryKey: string[];
-    /** Timestamp of schema capture */
-    capturedAt: number;
-}
-/**
- * Schema lock file format
- */
-export interface SchemaLock {
-    /** Version for compatibility */
-    version: string;
-    /** Driver used to generate */
-    driver: string;
-    /** Generation timestamp */
-    generatedAt: string;
-    /** Table schemas */
-    tables: Record<string, SerializedTableSchema>;
-}
-/**
- * Serialized table schema (for JSON storage)
- */
-export interface SerializedTableSchema {
-    table: string;
-    columns: SerializedColumnSchema[];
-    primaryKey: string[];
-}
-/**
- * Serialized column schema (for JSON storage)
- */
-export interface SerializedColumnSchema {
-    name: string;
-    type: ColumnType;
-    nullable: boolean;
-    default?: unknown;
-    primary: boolean;
-    unique: boolean;
-    autoIncrement: boolean;
-    enumValues?: string[] | undefined;
-    maxLength?: number | undefined;
-    precision?: number | undefined;
-    scale?: number | undefined;
-}

package/dist/atlas/src/pool/AdaptivePoolManager.d.ts

@@ -1,98 +0,0 @@
-/**
- * @gravito/atlas - Adaptive Pool Manager
- * @description Manages adaptive pool sizing based on strategies
- */
-import type { ConnectionManager } from '../connection/ConnectionManager';
-import type { PoolStats } from '../types';
-import type { PoolStrategy } from './PoolStrategy';
-export interface PoolStatsHistory {
-    stats: PoolStats;
-    timestamp: number;
-}
-export interface PoolAdjustmentEvent {
-    connection: string;
-    action: 'increase' | 'decrease' | 'maintain';
-    from: number;
-    to: number;
-    reason: string;
-}
-export interface AdaptivePoolConfig {
-    /**
-     * Evaluation interval (ms)
-     * @default 60000
-     */
-    evaluationInterval: number;
-    /**
-     * Minimum cooldown period (ms) before next adjustment
-     * @default 30000
-     */
-    cooldownPeriod: number;
-    /**
-     * Maximum history size
-     * @default 10
-     */
-    maxHistorySize: number;
-    /**
-     * Callback when adjustment is made
-     */
-    onAdjustment?: (event: PoolAdjustmentEvent) => void;
-}
-export declare const DEFAULT_ADAPTIVE_CONFIG: AdaptivePoolConfig;
-/**
- * Adaptive pool manager
- * Periodically evaluates pool statistics and adjusts size based on strategy
- */
-export declare class AdaptivePoolManager {
-    private connectionManager;
-    private strategy;
-    private config;
-    private intervalHandle?;
-    private statsHistory;
-    private adjustmentCooldown;
-    private lastAdjustment;
-    constructor(connectionManager: ConnectionManager, strategy: PoolStrategy, config: AdaptivePoolConfig);
-    /**
-     * Start adaptive management
-     */
-    start(): void;
-    /**
-     * Stop adaptive management
-     */
-    stop(): void;
-    /**
-     * Get last adjustment for a connection
-     */
-    getLastAdjustment(connectionName: string): PoolAdjustmentEvent | undefined;
-    /**
-     * Get history for a connection
-     */
-    getHistory(connectionName: string): PoolStatsHistory[];
-    /**
-     * Evaluate all connection pools
-     */
-    private evaluateAllPools;
-    /**
-     * Evaluate a specific pool
-     */
-    private evaluatePool;
-    /**
-     * Build strategy context from current state
-     */
-    private buildContext;
-    /**
-     * Update historical statistics
-     */
-    private updateHistory;
-    /**
-     * Check if in cooldown period
-     */
-    private isInCooldown;
-    /**
-     * Set cooldown period
-     */
-    private setCooldown;
-    /**
-     * Apply adjustment to pool
-     */
-    private applyAdjustment;
-}

package/dist/atlas/src/pool/PoolHealthChecker.d.ts

@@ -1,91 +0,0 @@
-/**
- * @gravito/atlas - Connection Pool Health Checker
- * @description Monitors connection pool health and triggers callbacks on state changes
- */
-import type { ConnectionManager } from '../connection/ConnectionManager';
-import type { PoolHealth } from '../types';
-export interface PoolHealthCheckConfig {
-    /**
-     * Interval (ms) to check pool health
-     * @default 30000 (30 seconds)
-     */
-    checkInterval: number;
-    /**
-     * Health status thresholds
-     */
-    thresholds: {
-        /**
-         * Utilization ratio (0-1) to trigger warning
-         * @default 0.7
-         */
-        warningUtilization: number;
-        /**
-         * Utilization ratio (0-1) to trigger critical
-         * @default 0.9
-         */
-        criticalUtilization: number;
-        /**
-         * Pending ratio (0-1) to trigger warning
-         * @default 0.5
-         */
-        maxPendingRatio: number;
-    };
-    /**
-     * Whether to test connection availability during health check
-     * @default true
-     */
-    enableConnectionTest: boolean;
-    /**
-     * Timeout (ms) for connection test
-     * @default 5000
-     */
-    connectionTestTimeout: number;
-    /**
-     * Callback when health status changes
-     */
-    onHealthChange?: (connectionName: string, health: PoolHealth) => void;
-    /**
-     * Callback when pool health becomes critical
-     */
-    onCritical?: (connectionName: string, health: PoolHealth) => void;
-}
-export declare const DEFAULT_HEALTH_CHECK_CONFIG: PoolHealthCheckConfig;
-/**
- * Connection pool health checker
- * Periodically monitors pool health and triggers callbacks
- */
-export declare class PoolHealthChecker {
-    private connectionManager;
-    private config;
-    private intervalHandle?;
-    private lastHealthStatus;
-    constructor(connectionManager: ConnectionManager, config: PoolHealthCheckConfig);
-    /**
-     * Start health checking
-     */
-    start(): void;
-    /**
-     * Stop health checking
-     */
-    stop(): void;
-    /**
-     * Get current health status for a specific connection
-     */
-    getHealthStatus(connectionName?: string): PoolHealth | Map<string, PoolHealth>;
-    /**
-     * Check health of all connections
-     */
-    private checkAllConnections;
-    /**
-     * Check health of a specific connection
-     */
-    private checkConnection;
-    /**
-     * Evaluate pool health based on statistics
-     */
-    private evaluateHealth;
-    /**
-     * Test connection availability
-     */
-    private testConnectionAvailability;
-}