@gravito/echo 3.0.0 → 3.1.0

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

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

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

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

@@ -0,0 +1,90 @@
+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

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

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

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