prisma-zod-generator/lib/utils/transactionSafety.d.ts

Prisma 2+ generator to emit Zod schemas from your Prisma schema

/**
 * Transaction Safety & Data Integrity Utilities
 *
 * Comprehensive ACID transaction support, rollback mechanisms,
 * and data integrity validation for production financial systems
 */
import type { MutexLock } from './concurrency';
export interface TransactionContext {
    id: string;
    startTime: number;
    operations: TransactionOperation[];
    rollbackHandlers: (() => Promise<void>)[];
    status: 'pending' | 'committed' | 'rolled_back' | 'failed';
    isolation_level: 'read_uncommitted' | 'read_committed' | 'repeatable_read' | 'serializable';
    serializableLock?: MutexLock;
}
export interface TransactionOperation {
    id: string;
    type: 'create' | 'update' | 'delete' | 'external_api';
    resource: string;
    data: any;
    timestamp: number;
    completed: boolean;
    rollback_data?: any;
}
export interface CompensationAction {
    operation: string;
    compensate: () => Promise<void>;
    description: string;
}
export declare class TransactionError extends Error {
    readonly transactionId: string;
    readonly operation?: string | undefined;
    readonly originalError?: Error | undefined;
    constructor(message: string, transactionId: string, operation?: string | undefined, originalError?: Error | undefined);
}
export declare class DataIntegrityError extends Error {
    readonly violationType: 'referential' | 'constraint' | 'consistency' | 'corruption';
    readonly context?: Record<string, unknown> | undefined;
    constructor(message: string, violationType: 'referential' | 'constraint' | 'consistency' | 'corruption', context?: Record<string, unknown> | undefined);
}
/**
 * Transaction Manager for ACID compliance
 */
export declare class TransactionManager {
    private transactions;
    private globalMutex;
    private auditLog;
    /**
     * Start a new ACID transaction
     */
    startTransaction(isolationLevel?: TransactionContext['isolation_level']): Promise<string>;
    /**
     * Execute operation within transaction context
     */
    executeInTransaction<T>(transactionId: string, operation: () => Promise<T>, operationInfo: {
        type: TransactionOperation['type'];
        resource: string;
        description: string;
        rollback?: () => Promise<void>;
    }): Promise<T>;
    /**
     * Commit transaction with full ACID compliance
     */
    commitTransaction(transactionId: string): Promise<void>;
    /**
     * Rollback transaction with compensation
     */
    rollbackTransaction(transactionId: string): Promise<void>;
    /**
     * Validate data integrity across related entities
     */
    validateDataIntegrity(data: {
        customers: Map<string, any>;
        subscriptions: Map<string, any>;
        licenses: Map<string, any>;
    }): Promise<{
        valid: boolean;
        violations: Array<{
            type: string;
            message: string;
            severity: 'error' | 'warning';
        }>;
    }>;
    /**
     * Saga pattern for distributed transactions
     */
    executeSaga(steps: Array<{
        execute: () => Promise<any>;
        compensate: () => Promise<void>;
        description: string;
    }>): Promise<any[]>;
    /**
     * Get transaction audit log
     */
    getAuditLog(filter?: {
        transactionId?: string;
        operation?: string;
        status?: string;
        startDate?: Date;
        endDate?: Date;
    }): Array<{
        transactionId: string;
        operation: string;
        status: string;
        timestamp: Date;
        error?: string;
    }>;
    private executeWithIsolation;
    private validateTransactionConsistency;
    private generateTransactionId;
    private generateOperationId;
}
/**
 * Global transaction manager instance
 */
export declare const transactionManager: TransactionManager;
/**
 * Decorator for transactional methods
 */
export declare function transactional(isolationLevel?: TransactionContext['isolation_level']): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;