@gravito/echo 3.1.0 → 3.1.2

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';