@gravito/ripple 4.0.1 → 5.0.0

package/dist/atlas/src/schema/SchemaDiff.d.ts

@@ -1,73 +0,0 @@
-/**
- * @gravito/atlas - Schema Differ
- * @description Compares Atlas Model decorator metadata against the live database
- * schema (information_schema) and produces a structured diff.
- *
- * This powers the `db:push` and `migrate:generate` CLI commands.
- */
-import type { ConnectionContract } from '../types';
-/**
- * A single column definition from information_schema or decorator meta.
- */
-export interface ColumnDefinition {
-    name: string;
-    type: string;
-    nullable: boolean;
-    defaultValue: string | null;
-    isPrimary: boolean;
-    isUnique: boolean;
-}
-/**
- * The result of comparing two schema states.
- */
-export interface SchemaDiffResult {
-    /** Table name */
-    table: string;
-    /** Columns that exist in models but not in the DB */
-    added: ColumnDefinition[];
-    /** Columns that exist in the DB but not in models */
-    removed: ColumnDefinition[];
-    /** Columns where the type or nullability has changed */
-    modified: Array<{
-        name: string;
-        from: ColumnDefinition;
-        to: ColumnDefinition;
-    }>;
-    /** Whether any changes were detected */
-    hasChanges: boolean;
-}
-export interface SchemaDiffOptions {
-    /** Database connection to compare against */
-    connection: ConnectionContract;
-    /** Table name */
-    table: string;
-    /** Desired column definitions (from Model decorators) */
-    desired: ColumnDefinition[];
-}
-/**
- * SchemaDiff
- *
- * Compares the desired schema (from Model @Column decorators) against the
- * current live database schema and produces a structured diff result.
- *
- * @example
- * ```typescript
- * const differ = new SchemaDiff({ connection, table: 'users', desired: userColumns })
- * const diff = await differ.compare()
- * if (diff.hasChanges) console.log('Schema is out of sync!')
- * ```
- */
-export declare class SchemaDiff {
-    private readonly connection;
-    private readonly table;
-    private readonly desired;
-    constructor(options: SchemaDiffOptions);
-    /**
-     * Perform the schema comparison and return the diff result.
-     */
-    compare(): Promise<SchemaDiffResult>;
-    /**
-     * Normalize DB type strings for comparison (e.g. 'character varying' → 'varchar').
-     */
-    private normalizeType;
-}

package/dist/atlas/src/schema/TypeGenerator.d.ts

@@ -1,57 +0,0 @@
-/**
- * @gravito/atlas - Schema Type Generator
- * @description Reads @Column decorator metadata from Model classes and builds a
- * type map for generating TypeScript declaration files.
- *
- * Eliminates "Type Drift" by deriving types 100% from decorator metadata.
- */
-export declare const COLUMN_METADATA_KEY = "atlas:columns";
-/**
- * Column metadata stored by @Column decorator
- */
-export interface ColumnMeta {
-    name: string;
-    type: string;
-    nullable?: boolean;
-    primary?: boolean;
-    unique?: boolean;
-    default?: unknown;
-}
-/**
- * Generated type map for a single Model class
- */
-export interface ModelTypeMap {
-    /** Model class name (e.g. 'User') */
-    modelName: string;
-    /** Table name the model maps to */
-    tableName: string;
-    /** Column-to-TypeScript type mapping */
-    columns: Record<string, string>;
-}
-export interface TypeGeneratorOptions {
-    /** Root directory to scan for Model files */
-    modelsDir: string;
-    /** Whether to log progress */
-    verbose?: boolean;
-}
-/**
- * TypeGenerator
- *
- * Scans a directory for Atlas Model files and extracts @Column decorator
- * metadata to produce a complete type map.
- *
- * @example
- * ```typescript
- * const gen = new TypeGenerator({ modelsDir: './src/models' })
- * const result = await gen.generate()
- * ```
- */
-export declare class TypeGenerator {
-    private readonly modelsDir;
-    private readonly verbose;
-    constructor(options: TypeGeneratorOptions);
-    /**
-     * Scan models directory and extract type maps from all Model files.
-     */
-    generate(): Promise<ModelTypeMap[]>;
-}

package/dist/atlas/src/schema/TypeWriter.d.ts

@@ -1,42 +0,0 @@
-/**
- * @gravito/atlas - Type Writer
- * @description Writes TypeScript declaration files from generated Model type maps.
- *
- * Outputs interface declarations that can be merged into Model classes via
- * Declaration Merging for zero type-drift DX.
- */
-import type { ModelTypeMap } from './TypeGenerator';
-export interface TypeWriterOptions {
-    /** Output file path (e.g., '.orbit/generated.d.ts') */
-    outputPath: string;
-    /** Optional banner comment */
-    banner?: string;
-}
-/**
- * TypeWriter
- *
- * Converts a list of ModelTypeMap objects into a `.d.ts` declaration file.
- *
- * @example
- * ```typescript
- * const writer = new TypeWriter({ outputPath: '.orbit/generated.d.ts' })
- * await writer.write(typeMaps)
- * // Emits:
- * //   export interface GeneratedUser { id: number; name: string; ... }
- * ```
- */
-export declare class TypeWriter {
-    private readonly outputPath;
-    private readonly banner;
-    constructor(options: TypeWriterOptions);
-    /**
-     * Write the declaration file to disk.
-     *
-     * @param typeMaps - Array of model type maps from TypeGenerator
-     */
-    write(typeMaps: ModelTypeMap[]): Promise<void>;
-    /**
-     * Build the .d.ts file content string.
-     */
-    buildContent(typeMaps: ModelTypeMap[]): string;
-}

package/dist/atlas/src/schema/grammars/MySQLSchemaGrammar.d.ts

@@ -1,23 +0,0 @@
-/**
- * MySQL Schema Grammar
- * @description DDL generation for MySQL/MariaDB
- */
-import type { ColumnDefinition } from '../ColumnDefinition';
-import type { IndexDefinition } from '../ForeignKeyDefinition';
-import { SchemaGrammar } from './SchemaGrammar';
-/**
- * MySQL Schema Grammar
- */
-export declare class MySQLSchemaGrammar extends SchemaGrammar {
-    protected compileType(column: ColumnDefinition): string;
-    protected compileAutoIncrement(): string;
-    protected supportsUnsigned(): boolean;
-    protected compileFullTextIndex(table: string, index: IndexDefinition): string;
-    protected compileSpatialIndex(table: string, index: IndexDefinition): string;
-    compileDropIndex(table: string, name: string): string;
-    wrapTable(table: string): string;
-    wrapColumn(column: string): string;
-    compileTableExists(table: string): string;
-    compileColumnExists(table: string, column: string): string;
-    compileListTables(): string;
-}

package/dist/atlas/src/schema/grammars/PostgresSchemaGrammar.d.ts

@@ -1,26 +0,0 @@
-/**
- * PostgreSQL Schema Grammar
- * @description DDL generation for PostgreSQL
- */
-import type { Blueprint } from '../Blueprint';
-import type { ColumnDefinition } from '../ColumnDefinition';
-import type { IndexDefinition } from '../ForeignKeyDefinition';
-import { SchemaGrammar } from './SchemaGrammar';
-/**
- * PostgreSQL Schema Grammar
- */
-export declare class PostgresSchemaGrammar extends SchemaGrammar {
-    protected wrapChar: string;
-    protected compileType(column: ColumnDefinition): string;
-    protected compileAutoIncrement(): string;
-    protected compileColumn(column: ColumnDefinition, blueprint: Blueprint): string;
-    protected supportsUnsigned(): boolean;
-    protected compileFullTextIndex(table: string, index: IndexDefinition): string;
-    protected compileSpatialIndex(table: string, index: IndexDefinition): string;
-    compileDropIndex(_table: string, name: string): string;
-    wrapTable(table: string): string;
-    wrapColumn(column: string): string;
-    compileTableExists(table: string): string;
-    compileColumnExists(table: string, column: string): string;
-    compileListTables(): string;
-}

package/dist/atlas/src/schema/grammars/SQLiteSchemaGrammar.d.ts

@@ -1,28 +0,0 @@
-/**
- * SQLite Schema Grammar
- * @description DDL generation for SQLite
- */
-import type { Blueprint } from '../Blueprint';
-import type { ColumnDefinition } from '../ColumnDefinition';
-import type { IndexDefinition } from '../ForeignKeyDefinition';
-import { SchemaGrammar } from './SchemaGrammar';
-/**
- * SQLite Schema Grammar
- * Generates SQL DDL statements specifically for SQLite databases.
- * @internal
- */
-export declare class SQLiteSchemaGrammar extends SchemaGrammar {
-    protected wrapChar: string;
-    compileCreate(blueprint: Blueprint): string;
-    wrapTable(table: string): string;
-    wrapColumn(column: string): string;
-    compileTableExists(table: string): string;
-    compileColumnExists(table: string, column: string): string;
-    compileListTables(): string;
-    protected compileType(column: ColumnDefinition): string;
-    protected compileAutoIncrement(): string;
-    protected supportsUnsigned(): boolean;
-    protected compileFullTextIndex(_table: string, _index: IndexDefinition): string;
-    protected compileSpatialIndex(_table: string, _index: IndexDefinition): string;
-    compileDropIndex(_table: string, name: string): string;
-}

package/dist/atlas/src/schema/grammars/SchemaGrammar.d.ts

@@ -1,97 +0,0 @@
-/**
- * Schema Grammar
- * @description Base class for generating DDL SQL statements
- */
-import type { Blueprint } from '../Blueprint';
-import type { ColumnDefinition } from '../ColumnDefinition';
-import type { ForeignKeyDefinition, IndexDefinition } from '../ForeignKeyDefinition';
-/**
- * Schema Grammar
- * Generates DDL SQL statements from Blueprint definitions
- */
-export declare abstract class SchemaGrammar {
-    /**
-     * Compile CREATE TABLE statement
-     */
-    compileCreate(blueprint: Blueprint): string;
-    /**
-     * Compile DROP TABLE statement
-     */
-    compileDrop(table: string): string;
-    /**
-     * Compile DROP TABLE IF EXISTS statement
-     */
-    compileDropIfExists(table: string): string;
-    /**
-     * Compile ALTER TABLE statement
-     */
-    compileAlter(blueprint: Blueprint): string[];
-    /**
-     * Determine if primary key should be added at the bottom of the statement
-     */
-    protected shouldAddPrimaryAtBottom(blueprint: Blueprint): boolean;
-    /**
-     * Compile a column definition
-     */
-    protected compileColumn(column: ColumnDefinition, _blueprint: Blueprint): string;
-    /**
-     * Compile column type
-     */
-    protected abstract compileType(column: ColumnDefinition): string;
-    /**
-     * Compile auto increment syntax
-     */
-    protected abstract compileAutoIncrement(): string;
-    /**
-     * Check if database supports UNSIGNED
-     */
-    protected abstract supportsUnsigned(): boolean;
-    /**
-     * Compile default value
-     */
-    protected compileDefault(value: unknown): string;
-    /**
-     * Compile CREATE INDEX statement
-     */
-    compileIndex(table: string, index: IndexDefinition): string;
-    /**
-     * Compile fulltext index (override in subclasses)
-     */
-    protected abstract compileFullTextIndex(table: string, index: IndexDefinition): string;
-    /**
-     * Compile spatial index (override in subclasses)
-     */
-    protected abstract compileSpatialIndex(table: string, index: IndexDefinition): string;
-    /**
-     * Compile DROP INDEX statement
-     */
-    abstract compileDropIndex(table: string, name: string): string;
-    /**
-     * Compile FOREIGN KEY constraint
-     */
-    protected compileForeignKey(fk: ForeignKeyDefinition): string;
-    /**
-     * Wrap table name with quotes
-     */
-    abstract wrapTable(table: string): string;
-    /**
-     * Wrap column name with quotes
-     */
-    abstract wrapColumn(column: string): string;
-    /**
-     * Quote a string value
-     */
-    protected quoteString(value: string): string;
-    /**
-     * Compile query to check if table exists
-     */
-    abstract compileTableExists(table: string): string;
-    /**
-     * Compile query to check if column exists
-     */
-    abstract compileColumnExists(table: string, column: string): string;
-    /**
-     * Compile query to list all tables
-     */
-    abstract compileListTables(): string;
-}

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

@@ -1,7 +0,0 @@
-/**
- * Schema Grammars Index
- */
-export { MySQLSchemaGrammar } from './MySQLSchemaGrammar';
-export { PostgresSchemaGrammar } from './PostgresSchemaGrammar';
-export { SchemaGrammar } from './SchemaGrammar';
-export { SQLiteSchemaGrammar } from './SQLiteSchemaGrammar';

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

@@ -1,8 +0,0 @@
-/**
- * Schema Module Index
- */
-export { Blueprint } from './Blueprint';
-export { ColumnDefinition, type ColumnType, type ForeignKeyAction } from './ColumnDefinition';
-export type { ForeignKeyDefinition, IndexDefinition } from './ForeignKeyDefinition';
-export { MySQLSchemaGrammar, PostgresSchemaGrammar, SchemaGrammar } from './grammars';
-export { Schema } from './Schema';

package/dist/atlas/src/seed/Factory.d.ts

@@ -1,90 +0,0 @@
-import type { Model } from '../orm/model/Model';
-/**
- * Factory State
- */
-type FactoryState<T> = Partial<T>;
-/**
- * Factory Definition Function
- */
-export type FactoryDefinition<T> = () => T;
-/**
- * Factory Options
- */
-export interface FactoryOptions {
-    model?: typeof Model;
-    table?: string;
-}
-/**
- * Factory
- * Generate fake records for seeding
- *
- * @example
- * ```typescript
- * const userFactory = new Factory<User>(() => ({
- *   name: faker.person.fullName(),
- *   email: faker.internet.email(),
- *   password: 'hashed_password',
- * }), { table: 'users' })
- *
- * // Create 10 users
- * const users = await userFactory.count(10).create()
- * ```
- */
-export declare class Factory<T extends Record<string, unknown>> {
-    private definition;
-    private _count;
-    private _states;
-    private model?;
-    private tableName?;
-    constructor(definition: FactoryDefinition<T>, options?: FactoryOptions);
-    private static registry;
-    /**
-     * Define a factory for a model
-     */
-    static define<T extends Record<string, unknown>>(modelOrTable: typeof Model | string, definition: FactoryDefinition<T>): Factory<T>;
-    /**
-     * Create a factory for a specific model
-     */
-    static model<T extends Record<string, unknown>>(model: typeof Model): Factory<T>;
-    /**
-     * Create and insert multiple records
-     */
-    createMany(n: number, attributes?: FactoryState<T>): Promise<T[]>;
-    /**
-     * Set the number of records to generate
-     */
-    count(n: number): this;
-    /**
-     * Apply state overrides
-     */
-    state(state: FactoryState<T>): this;
-    /**
-     * Generate records without inserting
-     */
-    make(): T[];
-    /**
-     * Generate a single record
-     */
-    makeOne(): T;
-    /**
-     * Generate records as raw objects (alias for make)
-     */
-    raw(): T[];
-    /**
-     * Generate a single raw record
-     */
-    rawOne(): T;
-    /**
-     * Create and insert records into the database
-     */
-    create(attributes?: FactoryState<T>): Promise<T[]>;
-    /**
-     * Create a sequence generator
-     */
-    sequence<K extends keyof T>(key: K, generator: (index: number) => T[K]): this;
-}
-/**
- * Helper to create a factory
- */
-export declare function factory<T extends Record<string, unknown>>(definition: FactoryDefinition<T>, options?: FactoryOptions): Factory<T>;
-export {};

package/dist/atlas/src/seed/Seeder.d.ts

@@ -1,28 +0,0 @@
-/**
- * Seeder constructor type
- */
-export type SeederConstructor = new () => Seeder;
-/**
- * Seeder file info
- */
-export interface SeederFile {
-    /** Seeder class name */
-    name: string;
-    /** Full file path */
-    path: string;
-}
-/**
- * Base Seeder Class
- * @description All database seeders should extend this class
- */
-export declare abstract class Seeder {
-    /**
-     * Run the seeder logic
-     */
-    abstract run(): Promise<void>;
-    /**
-     * Run other seeders from within this seeder
-     * @example await this.call([UserSeeder, PostSeeder])
-     */
-    call(seeders: SeederConstructor | SeederConstructor[]): Promise<void>;
-}

package/dist/atlas/src/seed/SeederRunner.d.ts

@@ -1,74 +0,0 @@
-/**
- * Seeder Runner
- * @description Runs database seeders
- */
-/**
- * Seeder Runner Options
- */
-export interface SeederRunnerOptions {
-    /** Path to seeders directory */
-    path?: string;
-    /** Database connection name */
-    connection?: string;
-}
-/**
- * Seeder Runner
- * Discovers and runs database seeders
- *
- * @example
- * ```typescript
- * const runner = new SeederRunner({ path: './seeders' })
- *
- * // Run all seeders
- * await runner.run()
- *
- * // Run specific seeder
- * await runner.call('UserSeeder')
- * ```
- */
-export declare class SeederRunner {
-    private seedersPath;
-    private _connectionName;
-    private resolvedSeeders;
-    constructor(options?: SeederRunnerOptions);
-    /**
-     * Set seeders path
-     */
-    setPath(path: string): this;
-    /**
-     * Set database connection
-     */
-    connection(name: string): this;
-    /**
-     * Run all seeders in the directory
-     */
-    run(): Promise<string[]>;
-    /**
-     * Run a specific seeder by name
-     */
-    call(seederName: string): Promise<void>;
-    /**
-     * Run multiple specific seeders
-     */
-    callMultiple(seederNames: string[]): Promise<void>;
-    /**
-     * Check if a seeder exists
-     */
-    has(seederName: string): Promise<boolean>;
-    /**
-     * List all available seeders
-     */
-    list(): Promise<string[]>;
-    /**
-     * Get all seeder files from the seeders directory
-     */
-    private getSeederFiles;
-    /**
-     * Run a single seeder
-     */
-    private runSeeder;
-    /**
-     * Resolve seeder class from file
-     */
-    private resolveSeeder;
-}

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

@@ -1,6 +0,0 @@
-/**
- * Seed Module Index
- */
-export { Factory, type FactoryDefinition, factory } from './Factory';
-export type { Seeder, SeederConstructor, SeederFile } from './Seeder';
-export { SeederRunner, type SeederRunnerOptions } from './SeederRunner';

package/dist/atlas/src/sharding/ShardingManager.d.ts

@@ -1,59 +0,0 @@
-import type { ConnectionConfig, ConnectionContract } from '../types';
-/**
- * Sharding Configuration
- */
-export interface ShardingConfig {
-    /**
-     * Number of shards
-     */
-    shardCount: number;
-    /**
-     * List of shard connection configurations
-     */
-    shards: (ConnectionConfig & {
-        id: number;
-    })[];
-    /**
-     * Sharding algorithm (default: 'consistent-hashing')
-     */
-    algorithm?: 'consistent-hashing' | 'modulo' | 'range';
-}
-/**
- * Sharding Manager
- *
- * Manages database sharding, connection routing, and distributed queries.
- * Supports horizontal scaling by partitioning data across multiple database instances.
- */
-export declare class ShardingManager {
-    private connections;
-    private shardCount;
-    private algorithm;
-    constructor(config: ShardingConfig);
-    /**
-     * Initialize all shard connections
-     */
-    private initializeShards;
-    /**
-     * Get a shard connection by distribution key (e.g., userId, tenantId)
-     *
-     * @param key - The distribution key
-     * @returns The connection instance for the calculated shard
-     */
-    getShard(key: string | number): ConnectionContract;
-    /**
-     * Calculate Shard ID based on the key and selected algorithm
-     */
-    private calculateShardId;
-    /**
-     * Execute a query across all shards and aggregate the results.
-     * Useful for reports, analytics, or global searches.
-     *
-     * @param callback - The operation to perform on each shard
-     * @returns Aggregated results from all shards
-     */
-    mapReduce<T>(callback: (connection: ConnectionContract, shardId: number) => Promise<T[]>): Promise<T[]>;
-    /**
-     * Get all active shard connections
-     */
-    getAllShards(): Map<number, ConnectionContract>;
-}