prisma-migrations/dist/index.d.ts

A Node.js library to manage Prisma ORM migrations like other ORMs

interface Migration {
    id: string;
    name: string;
    filename: string;
    timestamp: Date;
    applied: boolean;
    appliedAt?: Date;
    rollback?: string;
}
interface MigrationConfig {
    migrationsDir: string;
    schemaPath: string;
    databaseUrl?: string;
    tableName?: string;
    createTable?: boolean;
    migrationFormat?: "sql" | "js" | "ts";
    extension?: string;
}
interface MigrationState {
    current: string[];
    pending: string[];
    applied: Migration[];
}
interface MigrationResult {
    success: boolean;
    migrations: Migration[];
    error?: string;
}
interface CreateMigrationOptions {
    name: string;
    directory?: string;
    template?: string;
}
interface RunMigrationOptions {
    to?: string;
    steps?: number;
    dryRun?: boolean;
    force?: boolean;
}
interface RollbackMigrationOptions {
    to?: string;
    steps?: number;
    dryRun?: boolean;
    force?: boolean;
}
interface MigrationTemplate {
    up: string;
    down: string;
}
interface DatabaseConnection {
    url: string;
    provider: "postgresql" | "mysql" | "sqlite" | "sqlserver" | "mongodb";
}
interface MigrationFile {
    path: string;
    content: string;
    timestamp: string;
    name: string;
    type: "sql" | "js" | "ts";
}
interface PrismaMigration {
    up(prisma: any): Promise<void>;
    down(prisma: any): Promise<void>;
}
interface FunctionMigrationTemplate {
    up: (prisma: any) => Promise<void>;
    down: (prisma: any) => Promise<void>;
}
interface MigrationContext {
    prisma: any;
    sql: (query: string, ...params: any[]) => Promise<any>;
}
interface MigrationStatus {
    id: string;
    name: string;
    status: "pending" | "applied" | "error";
    appliedAt?: Date;
    error?: string;
}
interface VersionMigrationMapping {
    version: string;
    commit?: string;
    migrations: string[];
    description?: string;
    createdAt: Date;
}
interface VersionMigrationOptions {
    fromVersion?: string;
    toVersion: string;
    dryRun?: boolean;
    force?: boolean;
}
interface VersionMigrationResult {
    success: boolean;
    fromVersion?: string;
    toVersion: string;
    migrationsRun: Migration[];
    migrationsRolledBack: Migration[];
    error?: string;
}
interface MigrationManifest {
    versions: VersionMigrationMapping[];
    currentVersion?: string;
    lastUpdated: Date;
}

declare class MigrationManager {
    private config;
    private fileManager;
    private dbAdapter;
    private versionManager;
    constructor(configPath?: string);
    private ensureConfigLoaded;
    initialize(): Promise<void>;
    destroy(): Promise<void>;
    createMigration(options: CreateMigrationOptions): Promise<MigrationFile>;
    runMigrations(options?: RunMigrationOptions): Promise<MigrationResult>;
    rollbackMigrations(options?: RollbackMigrationOptions): Promise<MigrationResult>;
    getMigrationState(): Promise<MigrationState>;
    getMigrationStatus(): Promise<MigrationStatus[]>;
    testConnection(): Promise<boolean>;
    private getMigrationsUpTo;
    private getMigrationsToRun;
    private getAllPendingMigrations;
    private getMigrationsToRollbackTo;
    registerVersion(version: string, migrations: string[], description?: string, commit?: string): void;
    deployToVersion(options: VersionMigrationOptions): Promise<VersionMigrationResult>;
    getDeploymentPlan(fromVersion: string | undefined, toVersion: string): {
        plan: Array<{
            action: "run" | "rollback";
            migration: string;
            order: number;
        }>;
        summary: string;
    };
    getAllVersions(): VersionMigrationMapping[];
    getCurrentVersion(): string | undefined;
    setCurrentVersion(version: string): void;
    validateVersionMigrations(version: string): boolean;
}

declare class ConfigManager {
    private config;
    private configPromise;
    constructor(configPath?: string);
    private getDefaultConfig;
    private loadConfig;
    private findConfigFile;
    getConfig(): MigrationConfig;
    getConfigAsync(): Promise<MigrationConfig>;
    updateConfig(updates: Partial<MigrationConfig>): void;
    getDatabaseUrl(): string;
}

declare class FileManager {
    private migrationsDir;
    private config;
    constructor(migrationsDir: string, config: MigrationConfig);
    private ensureDirectoryExists;
    createMigrationFile(name: string, template?: MigrationTemplate | FunctionMigrationTemplate): MigrationFile;
    readMigrationFiles(): MigrationFile[];
    getMigrationFile(timestamp: string): MigrationFile | null;
    parseMigrationContent(migrationFile: MigrationFile): {
        up: string;
        down: string;
    };
    private parseSqlMigrationContent;
    private parseJsMigrationContent;
    private formatSqlMigrationContent;
    private formatJsMigrationContent;
    private generatePrismaMigrationTemplate;
    private generateTimestamp;
    getLatestMigration(): MigrationFile | null;
    getMigrationByName(name: string): MigrationFile | null;
    deleteMigrationFile(timestamp: string): boolean;
}

declare class DatabaseAdapter {
    private prisma;
    private tableName;
    private isPrismaTable;
    constructor(databaseUrl: string, tableName?: string);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    private detectPrismaTable;
    ensureMigrationsTable(): Promise<void>;
    getAppliedMigrations(): Promise<Migration[]>;
    isMigrationApplied(migrationId: string): Promise<boolean>;
    recordMigration(migrationId: string, name: string): Promise<void>;
    removeMigration(migrationId: string): Promise<void>;
    executeMigration(sql: string): Promise<void>;
    executeMigrationFile(migrationFile: MigrationFile, direction: "up" | "down"): Promise<void>;
    private loadMigrationModule;
    executeInTransaction(callback: () => Promise<void>): Promise<void>;
    testConnection(): Promise<boolean>;
    getLastMigration(): Promise<Migration | null>;
    getMigrationStatus(migrationId: string): Promise<MigrationStatus | null>;
    clearMigrations(): Promise<void>;
    dropMigrationsTable(): Promise<void>;
    getDatabaseProvider(): string;
}

declare class VersionManager {
    private manifestPath;
    private manifest;
    private commitManager;
    constructor(migrationsDir: string);
    private loadManifest;
    private saveManifest;
    registerVersion(version: string, migrations: string[], description?: string, commit?: string): void;
    getMigrationsBetween(from: string | undefined, to: string, isCommit?: boolean): {
        migrationsToRun: string[];
        migrationsToRollback: string[];
    };
    private getCommitMigrations;
    getVersionData(version: string): VersionMigrationMapping | null;
    getAllVersions(): VersionMigrationMapping[];
    getCurrentVersion(): string | undefined;
    setCurrentVersion(version: string): void;
    getLatestVersion(): string | undefined;
    private compareVersions;
    validateVersionMigrations(version: string, existingMigrations: string[]): boolean;
    generateDeploymentPlan(fromVersion: string | undefined, toVersion: string): {
        plan: Array<{
            action: "run" | "rollback";
            migration: string;
            order: number;
        }>;
        summary: string;
    };
}

interface CommitInfo {
    hash: string;
    shortHash: string;
    message: string;
    author: string;
    date: Date;
    branch?: string;
}
declare class CommitManager {
    private gitDir;
    constructor(gitDir?: string);
    getCurrentCommit(): string;
    getCurrentShortCommit(): string;
    getCurrentBranch(): string;
    getCommitInfo(commitHash?: string): CommitInfo;
    isWorkingDirectoryClean(): boolean;
    getCommitsBetween(from: string, to: string): CommitInfo[];
    commitExists(commitHash: string): boolean;
    getTagsForCommit(commitHash: string): string[];
    getLatestTag(commitHash?: string): string | null;
    isGitRepository(): boolean;
    generateVersionFromGit(): string;
    private execGitCommand;
}

export { CommitManager, ConfigManager, type CreateMigrationOptions, DatabaseAdapter, type DatabaseConnection, FileManager, type FunctionMigrationTemplate, type Migration, type MigrationConfig, type MigrationContext, type MigrationFile, MigrationManager, type MigrationManifest, type MigrationResult, type MigrationState, type MigrationStatus, type MigrationTemplate, type PrismaMigration, type RollbackMigrationOptions, type RunMigrationOptions, VersionManager, type VersionMigrationMapping, type VersionMigrationOptions, type VersionMigrationResult, MigrationManager as default };