ts-prorm-orm 1.1.0 → 1.2.1

package/dist/transaction.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Transaction Support
+ * Provides transaction management with commit and rollback functionality
+ */
+import { TransactionOptions, IsolationLevelString } from './types';
+/**
+ * Transaction states
+ */
+export declare enum TransactionState {
+    /** Transaction has not started yet */
+    STARTED = "started",
+    /** Transaction is currently active */
+    ACTIVE = "active",
+    /** Transaction has been committed */
+    COMMITTED = "committed",
+    /** Transaction has been rolled back */
+    ROLLED_BACK = "rolled_back"
+}
+/**
+ * Transaction isolation levels with their SQL representations
+ */
+export declare const IsolationLevels: Record<IsolationLevelString, string>;
+/**
+ * Default transaction options
+ */
+export declare const defaultTransactionOptions: Required<TransactionOptions>;
+/**
+ * Transaction class for managing database transactions
+ * Supports savepoints, commit, rollback, and isolation levels
+ */
+export declare class Transaction {
+    /** Unique identifier for the transaction */
+    id: string;
+    /** Current state of the transaction */
+    state: TransactionState;
+    /** Transaction options */
+    readonly options: Required<TransactionOptions>;
+    /** Parent transaction (for nested transactions/savepoints) */
+    parent: Transaction | null;
+    /** Child transactions/savepoints */
+    children: Transaction[];
+    /** Savepoint name for this transaction */
+    readonly savepointName: string;
+    /** Whether this transaction is a savepoint */
+    isSavepoint: boolean;
+    /** Timestamp when the transaction started */
+    readonly startedAt: Date;
+    /** Timestamp when the transaction was committed/rolled back */
+    finishedAt?: Date;
+    /** Depth level in nested transactions */
+    depth: number;
+    /**
+     * Create a new transaction
+     * @param options - Transaction configuration options
+     */
+    constructor(options?: TransactionOptions);
+    /**
+     * Private constructor for creating savepoints
+     */
+    private static createSavepoint;
+    /**
+     * Check if the transaction is active
+     */
+    get isActive(): boolean;
+    /**
+     * Check if the transaction is finished (committed or rolled back)
+     */
+    get isFinished(): boolean;
+    /**
+     * Check if the transaction was committed
+     */
+    get isCommitted(): boolean;
+    /**
+     * Check if the transaction was rolled back
+     */
+    get isRolledBack(): boolean;
+    /**
+     * Get the isolation level SQL
+     */
+    getIsolationLevelSql(): string;
+    /**
+     * Get the transaction type SQL
+     */
+    getTransactionTypeSql(): string;
+    /**
+     * Create a savepoint within the transaction
+     * @param options - Savepoint options
+     */
+    createSavepoint(options?: TransactionOptions): Transaction;
+    /**
+     * Create a named savepoint and return its name
+     * @param name - Optional custom savepoint name
+     * @returns The savepoint name
+     */
+    savepoint(name?: string): string;
+    /**
+     * Release a savepoint
+     * @param name - The savepoint name to release
+     */
+    releaseSavepoint(name: string): Promise<void>;
+    /**
+     * Rollback to a savepoint
+     * @param name - The savepoint name to rollback to
+     */
+    rollbackToSavepoint(name: string): Promise<void>;
+    /**
+     * Mark the transaction as started
+     */
+    start(): void;
+    /**
+     * Commit the transaction
+     * @throws Error if transaction is not active
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollback the transaction
+     * @param savepoint - Optional savepoint to rollback to
+     * @throws Error if transaction is not active
+     */
+    rollback(savepoint?: Transaction): Promise<void>;
+    /**
+     * Get the duration of the transaction
+     */
+    getDuration(): number;
+    /**
+     * Convert to a plain object for serialization
+     */
+    toJSON(): object;
+}
+/**
+ * Transaction manager for handling multiple transactions
+ */
+export declare class TransactionManager {
+    private currentTransaction;
+    private transactionCount;
+    /**
+     * Get the current active transaction
+     */
+    getActiveTransaction(): Transaction | null;
+    /**
+     * Check if there's an active transaction
+     */
+    hasActiveTransaction(): boolean;
+    /**
+     * Start a new transaction
+     * @param options - Transaction options
+     */
+    startTransaction(options?: TransactionOptions): Transaction;
+    /**
+     * Commit the current transaction
+     */
+    commitTransaction(): Promise<void>;
+    /**
+     * Rollback the current transaction
+     * @param savepoint - Optional savepoint to rollback to
+     */
+    rollbackTransaction(savepoint?: Transaction): Promise<void>;
+    /**
+     * Get transaction count
+     */
+    getTransactionCount(): number;
+    /**
+     * Run a function within a transaction
+     * Automatically commits on success, rolls back on error
+     * @param fn - Function to run within the transaction
+     * @param options - Transaction options
+     */
+    runInTransaction<T>(fn: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    /**
+     * Run a function within a savepoint
+     * @param fn - Function to run within the savepoint
+     * @param options - Savepoint options
+     */
+    runInSavepoint<T>(fn: (savepoint: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+/**
+ * Transaction wrapper for automatic cleanup
+ * Ensures transaction is properly committed or rolled back
+ */
+export declare class TransactionWrapper {
+    private transaction;
+    private committed;
+    /**
+     * Create a transaction wrapper
+     * @param transaction - The transaction to wrap
+     */
+    constructor(transaction: Transaction);
+    /**
+     * Get the wrapped transaction
+     */
+    getTransaction(): Transaction | null;
+    /**
+     * Commit the transaction
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollback the transaction
+     */
+    rollback(): Promise<void>;
+    /**
+     * Ensure the transaction is properly cleaned up
+     * Call this in a finally block or use the static helper
+     */
+    ensureCleanup(): Promise<void>;
+    /**
+     * Static helper to run a function with automatic cleanup
+     * @param transaction - The transaction to wrap
+     * @param fn - Function to run
+     */
+    static withCleanup<T>(transaction: Transaction, fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Create a new transaction
+ * @param options - Transaction options
+ */
+export declare function createTransaction(options?: TransactionOptions): Transaction;
+/**
+ * Create a new transaction manager
+ */
+export declare function createTransactionManager(): TransactionManager;
+export default Transaction;