@spfn/core 0.1.0-alpha.8 → 0.1.0-alpha.81

package/dist/postgres-errors-CY_Es8EJ.d.ts

@@ -1,1703 +0,0 @@
-import * as drizzle_orm_postgres_js from 'drizzle-orm/postgres-js';
-import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
-import { PgTable, PgColumn } from 'drizzle-orm/pg-core';
-import * as hono from 'hono';
-import { MiddlewareHandler } from 'hono';
-import * as postgres from 'postgres';
-import { Sql } from 'postgres';
-import * as drizzle_orm_pg_core_query_builders_raw from 'drizzle-orm/pg-core/query-builders/raw';
-import * as drizzle_orm from 'drizzle-orm';
-import { SQL } from 'drizzle-orm';
-
-/**
- * Database Configuration
- *
- * DB 연결 및 Connection Pool 설정
- *
- * ✅ 구현 완료:
- * - 환경별 Connection Pool 설정
- * - 재시도 설정 (Exponential Backoff)
- * - 환경변수 기반 설정
- *
- * 🔗 관련 파일:
- * - src/server/core/db/connection.ts (연결 로직)
- * - src/server/core/db/index.ts (메인 export)
- */
-/**
- * Connection Pool 설정
- */
-interface PoolConfig {
-    max: number;
-    idleTimeout: number;
-}
-/**
- * 재시도 설정
- */
-interface RetryConfig {
-    maxRetries: number;
-    initialDelay: number;
-    maxDelay: number;
-    factor: number;
-}
-
-/**
- * Database factory with automatic environment variable detection
- * Supports: Single primary, Primary + Replica
- */
-
-interface DatabaseClients {
-    /** Primary database for writes (or both read/write if no replica) */
-    write?: PostgresJsDatabase;
-    /** Replica database for reads (optional, falls back to write) */
-    read?: PostgresJsDatabase;
-    /** Raw postgres client for write operations (for cleanup) */
-    writeClient?: Sql;
-    /** Raw postgres client for read operations (for cleanup) */
-    readClient?: Sql;
-}
-/**
- * Health check configuration
- */
-interface HealthCheckConfig {
-    enabled: boolean;
-    interval: number;
-    reconnect: boolean;
-    maxRetries: number;
-    retryInterval: number;
-}
-/**
- * Query performance monitoring configuration
- */
-interface MonitoringConfig {
-    enabled: boolean;
-    slowThreshold: number;
-    logQueries: boolean;
-}
-/**
- * Database initialization options
- */
-interface DatabaseOptions {
-    /**
-     * Connection pool configuration
-     * Overrides environment variables and defaults
-     */
-    pool?: Partial<PoolConfig>;
-    /**
-     * Health check configuration
-     * Periodic checks to ensure database connection is alive
-     */
-    healthCheck?: Partial<HealthCheckConfig>;
-    /**
-     * Query performance monitoring configuration
-     * Tracks slow queries and logs performance metrics
-     */
-    monitoring?: Partial<MonitoringConfig>;
-}
-/**
- * Create database client(s) from environment variables
- *
- * Supported patterns (priority order):
- * 1. Single primary: DATABASE_URL
- * 2. Primary + Replica: DATABASE_WRITE_URL + DATABASE_READ_URL
- * 3. Legacy replica: DATABASE_URL + DATABASE_REPLICA_URL
- *
- * @param options - Optional database configuration (pool settings, etc.)
- * @returns Database client(s) or undefined if no configuration found
- *
- * @example
- * ```bash
- * # Single primary (most common)
- * DATABASE_URL=postgresql://localhost:5432/mydb
- *
- * # Primary + Replica
- * DATABASE_WRITE_URL=postgresql://primary:5432/mydb
- * DATABASE_READ_URL=postgresql://replica:5432/mydb
- *
- * # Legacy (backward compatibility)
- * DATABASE_URL=postgresql://primary:5432/mydb
- * DATABASE_REPLICA_URL=postgresql://replica:5432/mydb
- * ```
- *
- * @example
- * ```typescript
- * // Custom pool configuration
- * const db = await createDatabaseFromEnv({
- *   pool: { max: 50, idleTimeout: 60 }
- * });
- * ```
- */
-declare function createDatabaseFromEnv(options?: DatabaseOptions): Promise<DatabaseClients>;
-
-/**
- * Global Database instance manager
- * Provides singleton access to database across all modules
- * Supports Primary + Replica pattern with separate read/write instances
- */
-
-/**
- * DB connection type
- */
-type DbConnectionType = 'read' | 'write';
-/**
- * Get global database write instance
- *
- * @returns Database write instance or undefined if not initialized
- *
- * @example
- * ```typescript
- * import { getDatabase } from '@spfn/core/db';
- *
- * const db = getDatabase();
- * if (db) {
- *   const users = await db.select().from(usersTable);
- * }
- * ```
- */
-declare function getDatabase(type?: DbConnectionType): PostgresJsDatabase | undefined;
-/**
- * Set global database instances (for testing or manual configuration)
- *
- * @param write - Database write instance
- * @param read - Database read instance (optional, defaults to write)
- *
- * @example
- * ```typescript
- * import { setDatabase } from '@spfn/core/db';
- * import { drizzle } from 'drizzle-orm/postgres-js';
- * import postgres from 'postgres';
- *
- * const writeClient = postgres('postgresql://primary:5432/mydb');
- * const readClient = postgres('postgresql://replica:5432/mydb');
- * setDatabase(drizzle(writeClient), drizzle(readClient));
- * ```
- */
-declare function setDatabase(write: PostgresJsDatabase | undefined, read?: PostgresJsDatabase | undefined): void;
-/**
- * Initialize database from environment variables
- * Automatically called by server startup
- *
- * Supported environment variables:
- * - DATABASE_URL (single primary)
- * - DATABASE_WRITE_URL + DATABASE_READ_URL (primary + replica)
- * - DATABASE_URL + DATABASE_REPLICA_URL (legacy replica)
- * - DB_POOL_MAX (connection pool max size)
- * - DB_POOL_IDLE_TIMEOUT (connection idle timeout in seconds)
- * - DB_HEALTH_CHECK_ENABLED (enable health checks, default: true)
- * - DB_HEALTH_CHECK_INTERVAL (health check interval in ms, default: 60000)
- * - DB_HEALTH_CHECK_RECONNECT (enable auto-reconnect, default: true)
- * - DB_HEALTH_CHECK_MAX_RETRIES (max reconnection attempts, default: 3)
- * - DB_HEALTH_CHECK_RETRY_INTERVAL (retry interval in ms, default: 5000)
- * - DB_MONITORING_ENABLED (enable query monitoring, default: true in dev, false in prod)
- * - DB_MONITORING_SLOW_THRESHOLD (slow query threshold in ms, default: 1000)
- * - DB_MONITORING_LOG_QUERIES (log actual SQL queries, default: false)
- *
- * Configuration priority:
- * 1. options parameter (ServerConfig)
- * 2. Environment variables
- * 3. Defaults (based on NODE_ENV)
- *
- * @param options - Optional database configuration (pool settings, etc.)
- * @returns Object with write and read instances
- *
- * @example
- * ```typescript
- * import { initDatabase } from '@spfn/core/db';
- *
- * // Manual initialization (not needed if using server startup)
- * const { write, read } = await initDatabase();
- * if (write) {
- *   console.log('Database connected');
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Custom pool configuration
- * const { write, read } = await initDatabase({
- *   pool: { max: 50, idleTimeout: 60 }
- * });
- * ```
- */
-declare function initDatabase(options?: DatabaseOptions): Promise<{
-    write?: PostgresJsDatabase;
-    read?: PostgresJsDatabase;
-}>;
-/**
- * Close all database connections and cleanup
- *
- * Properly closes postgres connection pools with timeout.
- * Should be called during graceful shutdown or after tests.
- *
- * @example
- * ```typescript
- * import { closeDatabase } from '@spfn/core/db';
- *
- * // During graceful shutdown
- * process.on('SIGTERM', async () => {
- *     await closeDatabase();
- *     process.exit(0);
- * });
- *
- * // In tests
- * afterAll(async () => {
- *     await closeDatabase();
- * });
- * ```
- */
-declare function closeDatabase(): Promise<void>;
-/**
- * Get database connection info (for debugging)
- */
-declare function getDatabaseInfo(): {
-    hasWrite: boolean;
-    hasRead: boolean;
-    isReplica: boolean;
-};
-
-/**
- * Database Instance (Backward Compatibility Layer)
- *
- * PostgreSQL + Drizzle ORM connection - now using lazy initialization
- *
- * ✅ Implemented:
- * - Lazy initialization (no top-level await)
- * - Automatic environment variable loading
- * - Read Replica support (read/write separation)
- * - Singleton pattern via db-manager
- * - Backward compatibility with existing code
- *
- * ⚠️ Migration Note:
- * This file now wraps db-manager for backward compatibility.
- * New code should use:
- *   - initDatabase() from db-manager
- *   - getDatabase() from db-manager
- *
- * 🔗 Related files:
- * - src/db/db-factory.ts (Environment detection)
- * - src/db/db-manager.ts (Singleton management)
- * - src/db/db-context.ts (Transaction-aware access)
- */
-
-/**
- * Default DB instance (Primary - for writes)
- *
- * ⚠️ IMPORTANT: This is a lazy getter. On first access, it will:
- * 1. Auto-initialize database from environment variables
- * 2. Throw error if DATABASE_URL is not set
- *
- * For better error handling, use initDatabase() explicitly:
- * ```typescript
- * import { initDatabase } from '@spfn/core/db';
- * const { write } = await initDatabase();
- * if (!write) throw new Error('Database not configured');
- * ```
- *
- * @example
- * ```typescript
- * import { db } from '@spfn/core/db';
- * const users = await db.select().from(usersTable);
- * ```
- */
-declare const db: PostgresJsDatabase<Record<string, never>>;
-/**
- * Get raw Drizzle DB instance (direct use without transaction)
- *
- * ⚠️ Warning: This function bypasses AsyncLocalStorage transaction context.
- * For normal cases, use `getDb()` from './db-context.js'.
- *
- * @param type - 'read' (Replica) or 'write' (Primary)
- * @returns Raw Drizzle DB instance
- *
- * @example
- * ```typescript
- * // Read-only query (uses Replica)
- * const users = await getRawDb('read').select().from(usersTable);
- *
- * // Write query (uses Primary)
- * await getRawDb('write').insert(usersTable).values({ email: 'test@example.com' });
- * ```
- */
-declare function getRawDb(type?: DbConnectionType): PostgresJsDatabase;
-
-/**
- * Repository Filter Utilities
- *
- * Utilities for building Drizzle ORM WHERE, ORDER BY, and pagination conditions.
- * Moved from deprecated query module for Repository pattern usage.
- *
- * @module db/repository/filters
- */
-
-/**
- * Filter operators
- */
-type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'in' | 'nin' | 'is';
-/**
- * Filter value type
- */
-type FilterValue = string | number | boolean | null | (string | number)[];
-/**
- * Filter condition
- *
- * @example { email: { eq: 'john@example.com' } }
- * @example { age: { gte: 18, lte: 65 } }
- */
-type FilterCondition = {
-    [operator in FilterOperator]?: FilterValue;
-};
-/**
- * Complete filters
- *
- * @example { email: { eq: 'john@example.com' }, role: { in: ['admin', 'user'] } }
- */
-type Filters = {
-    [field: string]: FilterCondition;
-};
-/**
- * Filter builder result type
- */
-type FilterResult = SQL<unknown> | undefined;
-/**
- * Sort direction
- */
-type SortDirection = 'asc' | 'desc';
-/**
- * Sort condition
- *
- * @example [{ field: 'createdAt', direction: 'desc' }, { field: 'name', direction: 'asc' }]
- */
-type SortCondition = {
-    field: string;
-    direction: SortDirection;
-};
-/**
- * Sort builder result type
- */
-type SortResult = SQL<unknown>[];
-/**
- * Pagination parameters
- */
-type PaginationParams = {
-    page: number;
-    limit: number;
-};
-/**
- * Pagination metadata
- */
-type PaginationMeta = {
-    page: number;
-    limit: number;
-    total: number;
-    totalPages: number;
-    hasNext: boolean;
-    hasPrev: boolean;
-};
-/**
- * Drizzle table type (generic)
- */
-type DrizzleTable = PgTable<any> & Record<string, PgColumn>;
-/**
- * Convert filter conditions to Drizzle SQL WHERE conditions
- *
- * @param filters - Parsed filter object
- * @param table - Drizzle table schema
- * @returns SQL WHERE condition (undefined if no filters)
- *
- * @example
- * const filters = { email: { eq: 'john@example.com' }, age: { gte: 18 } };
- * const condition = buildFilters(filters, users);
- * const data = await db.select().from(users).where(condition);
- */
-declare function buildFilters(filters: Filters, table: DrizzleTable): FilterResult;
-/**
- * Combine conditions with OR
- *
- * @example
- * const conditions = [
- *   buildFilters({ status: { eq: 'active' } }, users),
- *   buildFilters({ role: { eq: 'admin' } }, users)
- * ];
- * const orCondition = orFilters(...conditions);
- */
-declare function orFilters(...conditions: (FilterResult)[]): FilterResult;
-/**
- * Convert sort conditions to Drizzle SQL ORDER BY conditions
- *
- * @param sortConditions - Sort condition array
- * @param table - Drizzle table schema
- * @returns SQL ORDER BY condition array
- *
- * @example
- * const sort = [
- *   { field: 'createdAt', direction: 'desc' },
- *   { field: 'name', direction: 'asc' }
- * ];
- * const orderBy = buildSort(sort, users);
- * const data = await db.select().from(users).orderBy(...orderBy);
- */
-declare function buildSort(sortConditions: SortCondition[], table: DrizzleTable): SortResult;
-/**
- * Apply pagination to Drizzle query
- *
- * @param pagination - Pagination parameters
- * @returns { offset, limit } object
- *
- * @example
- * const { offset, limit } = applyPagination({ page: 2, limit: 20 });
- * const data = await db.select().from(users).limit(limit).offset(offset);
- */
-declare function applyPagination(pagination: PaginationParams): {
-    offset: number;
-    limit: number;
-};
-/**
- * Create pagination metadata
- *
- * @param pagination - Pagination parameters
- * @param total - Total count
- * @returns Pagination metadata
- *
- * @example
- * const meta = createPaginationMeta({ page: 2, limit: 20 }, 156);
- * // { page: 2, limit: 20, total: 156, totalPages: 8, hasNext: true, hasPrev: true }
- */
-declare function createPaginationMeta(pagination: PaginationParams, total: number): PaginationMeta;
-/**
- * Count total records (count query)
- *
- * @param db - Drizzle DB instance
- * @param table - Table schema
- * @param whereCondition - WHERE condition (optional)
- * @returns Total count
- *
- * @example
- * const total = await countTotal(db, users);
- * const total = await countTotal(db, users, eq(users.status, 'active'));
- */
-declare function countTotal(db: PostgresJsDatabase<Record<string, never>>, table: DrizzleTable, whereCondition?: any): Promise<number>;
-
-/**
- * Query Builder (Fluent Interface)
- *
- * Chainable query builder for Repository pattern.
- * Provides a fluent API for building complex queries.
- *
- * @example
- * ```typescript
- * const users = await userRepo
- *     .query()
- *     .where({ status: 'active' })
- *     .where({ role: 'admin' })
- *     .orderBy('createdAt', 'desc')
- *     .limit(10)
- *     .findMany();
- * ```
- */
-
-/**
- * Query Builder class for chainable queries
- *
- * Supports method chaining for building complex queries in a fluent style.
- */
-declare class QueryBuilder<TTable extends PgTable, TSelect = TTable['$inferSelect']> {
-    private db;
-    private table;
-    private filterConditions;
-    private sortConditions;
-    private limitValue?;
-    private offsetValue?;
-    constructor(db: PostgresJsDatabase<any>, table: TTable);
-    /**
-     * Add WHERE conditions
-     *
-     * Multiple where() calls are combined with AND logic.
-     *
-     * @param filters - Filter conditions
-     * @returns QueryBuilder for chaining
-     *
-     * @example
-     * ```typescript
-     * query
-     *     .where({ status: 'active' })
-     *     .where({ role: 'admin' })  // AND condition
-     * ```
-     */
-    where(filters: Filters): this;
-    /**
-     * Add ORDER BY clause
-     *
-     * Multiple orderBy() calls create multi-column sorting.
-     *
-     * @param field - Field name to sort by
-     * @param direction - Sort direction ('asc' or 'desc')
-     * @returns QueryBuilder for chaining
-     *
-     * @example
-     * ```typescript
-     * query
-     *     .orderBy('isPremium', 'desc')
-     *     .orderBy('createdAt', 'desc')
-     * ```
-     */
-    orderBy(field: string, direction?: 'asc' | 'desc'): this;
-    /**
-     * Set LIMIT clause
-     *
-     * @param limit - Maximum number of records to return
-     * @returns QueryBuilder for chaining
-     *
-     * @example
-     * ```typescript
-     * query.limit(10)
-     * ```
-     */
-    limit(limit: number): this;
-    /**
-     * Set OFFSET clause
-     *
-     * @param offset - Number of records to skip
-     * @returns QueryBuilder for chaining
-     *
-     * @example
-     * ```typescript
-     * query.offset(20)
-     * ```
-     */
-    offset(offset: number): this;
-    /**
-     * Execute query and return multiple records
-     *
-     * @returns Array of records
-     *
-     * @example
-     * ```typescript
-     * const users = await query
-     *     .where({ status: 'active' })
-     *     .orderBy('createdAt', 'desc')
-     *     .limit(10)
-     *     .findMany();
-     * ```
-     */
-    findMany(): Promise<TSelect[]>;
-    /**
-     * Execute query and return first record
-     *
-     * @returns First matching record or null
-     *
-     * @example
-     * ```typescript
-     * const user = await query
-     *     .where({ email: 'john@example.com' })
-     *     .findOne();
-     * ```
-     */
-    findOne(): Promise<TSelect | null>;
-    /**
-     * Execute query and return count
-     *
-     * @returns Number of matching records
-     *
-     * @example
-     * ```typescript
-     * const count = await query
-     *     .where({ status: 'active' })
-     *     .count();
-     * ```
-     */
-    count(): Promise<number>;
-    /**
-     * Merge multiple filter conditions into single object
-     *
-     * Combines all where() calls into one filter object.
-     */
-    private mergeFilters;
-}
-
-/**
- * Repository Pattern (JPA Style)
- *
- * Spring JPA-inspired Repository pattern for TypeScript/Drizzle ORM
- *
- * ✅ Features:
- * - Auto Read/Write Replica routing (read methods use Replica, write methods use Primary)
- * - Type-safe CRUD operations (findById, findWhere, save, update, delete, etc.)
- * - Advanced filtering with operators (eq, gt, like, in, etc.)
- * - Pagination with metadata (findPage)
- * - Batch operations (saveMany, updateWhere, deleteWhere)
- * - Transaction-aware (automatic participation in Transactional middleware)
- */
-
-/**
- * Pageable interface (Spring Pageable style)
- */
-type Pageable = {
-    filters?: Filters;
-    sort?: SortCondition[];
-    pagination?: PaginationParams;
-};
-/**
- * Page result (Spring Page style)
- */
-type Page<T> = {
-    data: T[];
-    meta: PaginationMeta;
-};
-/**
- * Repository class
- *
- * Provides JPA Repository-style CRUD methods with automatic transaction support
- *
- * ✅ Automatic Transaction Detection:
- * - Automatically participates in active Transactional() middleware context
- * - No need to pass transaction explicitly - uses AsyncLocalStorage
- * - All operations within a transaction use the same transaction DB
- *
- * ✅ Auto Read/Write Replica routing (when NOT in transaction):
- * - Read methods (findAll, findById, findOne, findPage, count) → Uses Read Replica
- * - Write methods (save, update, delete) → Uses Primary DB
- *
- * ✅ DB Priority:
- * 1. Explicit DB (if provided in constructor)
- * 2. Transaction context (if inside Transactional middleware)
- * 3. Read Replica or Primary DB (based on operation type)
- *
- * @example
- * ```typescript
- * // Simple usage - automatically detects transaction
- * class UserService {
- *   private get repo() {
- *     return new Repository(users);  // Auto-detects transaction
- *   }
- * }
- *
- * // Route with transaction
- * app.bind(contract, Transactional(), async (c) => {
- *   const service = new UserService();
- *   await service.createUser(data);
- *   // Automatic rollback on error!
- * });
- * ```
- */
-declare class Repository<TTable extends PgTable, TSelect = TTable['$inferSelect']> {
-    protected db: PostgresJsDatabase<any>;
-    protected table: TTable;
-    protected useReplica: boolean;
-    protected explicitDb?: PostgresJsDatabase<any>;
-    protected autoUpdateField?: string;
-    constructor(dbOrTable: PostgresJsDatabase<any> | TTable, tableOrUseReplica?: TTable | boolean, useReplica?: boolean);
-    /**
-     * Detect which field (if any) should be auto-updated
-     *
-     * Checks all table columns for __autoUpdate metadata flag.
-     * Set by autoUpdateTimestamp() or timestamps({ autoUpdate: true }) helpers.
-     *
-     * @returns Field name to auto-update, or undefined if none found
-     */
-    private detectAutoUpdateField;
-    /**
-     * Inject auto-update timestamp if configured
-     *
-     * Only injects if:
-     * 1. Table has an auto-update field configured (via autoUpdateTimestamp() or timestamps({ autoUpdate: true }))
-     * 2. The field is not already explicitly provided in the data
-     *
-     * @param data - Update data object
-     * @returns Data with auto-update timestamp injected (if applicable)
-     */
-    private injectAutoUpdateTimestamp;
-    /**
-     * Get id column from table
-     *
-     * Helper method to reduce code duplication across methods that need id column.
-     *
-     * @returns The id column object
-     * @throws {QueryError} If table does not have an id column
-     */
-    private getIdColumn;
-    /**
-     * Get read-only DB
-     *
-     * Automatically detects and uses transaction context if available.
-     * When in transaction, uses transaction DB to ensure read consistency.
-     * Priority: explicitDb > transaction > replica/primary DB
-     */
-    private getReadDb;
-    /**
-     * Get write-only DB
-     *
-     * Automatically detects and uses transaction context if available.
-     * Priority: explicitDb > transaction > primary DB
-     */
-    private getWriteDb;
-    /**
-     * Execute operation with performance monitoring
-     *
-     * Wraps database operations with timing and logging for slow queries.
-     * Only logs if monitoring is enabled and query exceeds threshold.
-     *
-     * @param operation - Name of the operation (for logging)
-     * @param fn - Async function to execute
-     * @returns Result of the operation
-     */
-    private executeWithMonitoring;
-    /**
-     * Find all records (uses Replica)
-     *
-     * @example
-     * const users = await userRepo.findAll();
-     */
-    findAll(): Promise<TSelect[]>;
-    /**
-     * Find with pagination (uses Replica)
-     *
-     * @example
-     * const result = await userRepo.findPage({
-     *   filters: { email: { like: 'john' } },
-     *   sort: [{ field: 'createdAt', direction: 'desc' }],
-     *   pagination: { page: 1, limit: 20 }
-     * });
-     */
-    findPage(pageable: Pageable): Promise<Page<TSelect>>;
-    /**
-     * Find one record by ID (uses Replica)
-     *
-     * @example
-     * const user = await userRepo.findById(1);
-     */
-    findById(id: number | string): Promise<TSelect | null>;
-    /**
-     * Find one record by condition (uses Replica)
-     *
-     * @example
-     * const user = await userRepo.findOne(eq(users.email, 'john@example.com'));
-     */
-    findOne(where: SQL<unknown>): Promise<TSelect | null>;
-    /**
-     * Create a new record (uses Primary)
-     *
-     * @example
-     * const user = await userRepo.save({ email: 'john@example.com', name: 'John' });
-     */
-    save(data: any): Promise<TSelect>;
-    /**
-     * Update a record (uses Primary)
-     *
-     * Automatically injects current timestamp if table has auto-update field configured.
-     *
-     * @example
-     * const user = await userRepo.update(1, { name: 'Jane' });
-     */
-    update(id: number | string, data: any): Promise<TSelect | null>;
-    /**
-     * Delete a record (uses Primary)
-     *
-     * @example
-     * const deleted = await userRepo.delete(1);
-     */
-    delete(id: number | string): Promise<TSelect | null>;
-    /**
-     * Count records (uses Replica)
-     *
-     * @example
-     * const count = await userRepo.count();
-     */
-    count(where?: SQL<unknown>): Promise<number>;
-    /**
-     * Find records by filters (uses Replica)
-     *
-     * @example
-     * const users = await userRepo.findWhere({ email: { like: '@gmail.com' }, status: 'active' });
-     */
-    findWhere(filters: Filters): Promise<TSelect[]>;
-    /**
-     * Find one record by filters (uses Replica)
-     *
-     * @example
-     * const user = await userRepo.findOneWhere({ email: 'john@example.com' });
-     */
-    findOneWhere(filters: Filters): Promise<TSelect | null>;
-    /**
-     * Check if record exists by ID (uses Replica)
-     *
-     * @example
-     * const exists = await userRepo.exists(1);
-     */
-    exists(id: number | string): Promise<boolean>;
-    /**
-     * Check if record exists by filters (uses Replica)
-     *
-     * @example
-     * const exists = await userRepo.existsBy({ email: 'john@example.com' });
-     */
-    existsBy(filters: Filters): Promise<boolean>;
-    /**
-     * Count records by filters (uses Replica)
-     *
-     * @example
-     * const count = await userRepo.countBy({ status: 'active' });
-     */
-    countBy(filters: Filters): Promise<number>;
-    /**
-     * Create multiple records (uses Primary)
-     *
-     * @example
-     * const users = await userRepo.saveMany([
-     *   { email: 'user1@example.com', name: 'User 1' },
-     *   { email: 'user2@example.com', name: 'User 2' }
-     * ]);
-     */
-    saveMany(data: any[]): Promise<TSelect[]>;
-    /**
-     * Update multiple records by filters (uses Primary)
-     *
-     * Automatically injects current timestamp if table has auto-update field configured.
-     *
-     * @example
-     * const count = await userRepo.updateWhere({ status: 'inactive' }, { status: 'archived' });
-     */
-    updateWhere(filters: Filters, data: any): Promise<number>;
-    /**
-     * Delete multiple records by filters (uses Primary)
-     *
-     * @example
-     * const count = await userRepo.deleteWhere({ status: 'banned' });
-     */
-    deleteWhere(filters: Filters): Promise<number>;
-    /**
-     * Start a chainable query builder (uses Replica)
-     *
-     * Returns a QueryBuilder instance for building complex queries with method chaining.
-     *
-     * @returns QueryBuilder instance for chaining
-     *
-     * @example
-     * ```typescript
-     * // Simple chaining
-     * const users = await userRepo
-     *     .query()
-     *     .where({ status: 'active' })
-     *     .orderBy('createdAt', 'desc')
-     *     .limit(10)
-     *     .findMany();
-     *
-     * // Multiple conditions
-     * const admins = await userRepo
-     *     .query()
-     *     .where({ role: 'admin' })
-     *     .where({ status: 'active' })  // AND condition
-     *     .findMany();
-     *
-     * // Reusable query
-     * const activeQuery = userRepo.query().where({ status: 'active' });
-     * const users = await activeQuery.findMany();
-     * const count = await activeQuery.count();
-     * ```
-     */
-    query(): QueryBuilder<TTable, TSelect>;
-}
-
-/**
- * Repository Factory
- *
- * Provides singleton instances of Repository classes to prevent unnecessary instantiation
- * and ensure consistent instances across the application.
- *
- * ✅ Features:
- * - Singleton pattern for both base and custom Repository classes
- * - Automatic caching based on table + constructor
- * - Type-safe with full IDE autocomplete
- * - Supports multiple services accessing the same repository
- * - Memory efficient (single instance per table/class combination)
- *
- * @example
- * ```typescript
- * // Base Repository
- * const userRepo = getRepository(users);
- * await userRepo.findById(1);
- *
- * // Custom Repository
- * class UserRepository extends Repository<typeof users> {
- *   async findByEmail(email: string) {
- *     return this.findOneWhere({ email });
- *   }
- * }
- *
- * const userRepo = getRepository(users, UserRepository);
- * await userRepo.findByEmail('john@example.com');
- * ```
- */
-
-/**
- * Get or create a Repository singleton instance (Global Singleton Pattern)
- *
- * This function ensures that only one instance of each Repository is created,
- * preventing memory waste and ensuring consistency across the application.
- *
- * ✅ Supports both base Repository and custom Repository classes
- * ✅ Returns the same instance on subsequent calls
- * ✅ Type-safe with full IDE autocomplete
- * ✅ Automatically detects transaction context (via Repository internals)
- *
- * ## ⚠️ Note: Global Singleton Pattern
- *
- * This uses a **global singleton cache** that persists throughout application lifecycle.
- *
- * **Tradeoffs:**
- * - ✅ Simple API, no middleware required
- * - ✅ Maximum memory efficiency
- * - ⚠️ Requires manual `clearRepositoryCache()` in tests
- * - ⚠️ Global state (harder to isolate in testing)
- *
- * **For better test isolation**, consider using **request-scoped repositories**:
- * ```typescript
- * import { getScopedRepository, RepositoryScope } from '@spfn/core/db';
- *
- * // Add middleware (once)
- * app.use(RepositoryScope());
- *
- * // Use getScopedRepository() instead - automatic per-request caching
- * const repo = getScopedRepository(users);
- * ```
- *
- * See: `request-scope.ts` for request-scoped alternative
- *
- * ## 🔄 Transaction Handling
- *
- * Repository instances are cached globally, but they automatically detect
- * and use transaction context via AsyncLocalStorage in each method call.
- * This means:
- * - **Same repository instance** can be used both inside and outside transactions
- * - **No need to create separate repository instances** per transaction
- * - **Transaction safety is guaranteed** by AsyncLocalStorage context
- *
- * The Repository internally calls `getTransaction()` on every database operation,
- * ensuring the correct DB instance (transaction or default) is always used.
- *
- * @param table - Drizzle table definition
- * @param RepositoryClass - Optional custom Repository class extending Repository
- * @returns Repository instance (cached singleton)
- *
- * @example
- * ```typescript
- * // Base Repository - simple CRUD
- * import { getRepository } from '@spfn/core/db';
- * import { users } from './entities';
- *
- * export async function getUser(id: number) {
- *   const repo = getRepository(users);
- *   return repo.findById(id);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Custom Repository - with custom methods
- * import { Repository, getRepository } from '@spfn/core/db';
- * import { users } from './entities';
- *
- * class UserRepository extends Repository<typeof users> {
- *   async findByEmail(email: string) {
- *     return this.findOneWhere({ email });
- *   }
- *
- *   async findActiveUsers() {
- *     return this.findWhere({ status: 'active' });
- *   }
- * }
- *
- * export async function getUserByEmail(email: string) {
- *   const repo = getRepository(users, UserRepository);
- *   return repo.findByEmail(email);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Multiple services - same instance
- * // services/users.ts
- * const repo = getRepository(users, UserRepository);  // Instance A
- *
- * // services/auth.ts
- * const repo = getRepository(users, UserRepository);  // Same Instance A
- * ```
- *
- * @example
- * ```typescript
- * // Transaction handling - same instance works everywhere
- * import { getRepository, Transactional } from '@spfn/core/db';
- * import { users } from './entities';
- *
- * const userRepo = getRepository(users);
- *
- * // Outside transaction - uses default DB
- * await userRepo.findById(1);
- *
- * // Inside Transactional() middleware - uses transaction automatically
- * app.use(Transactional());
- * app.post('/', async (c) => {
- *   // Same instance, but now uses transaction DB
- *   await userRepo.save({ email: 'test@example.com' });
- *   return c.json({ success: true });
- * });
- * ```
- */
-declare function getRepository<TTable extends PgTable, TRepo extends Repository<TTable> = Repository<TTable>>(table: TTable, RepositoryClass?: new (table: TTable) => TRepo): TRepo;
-/**
- * Clear repository cache
- *
- * Removes all cached repository instances. Useful for testing scenarios
- * where you need fresh instances.
- *
- * ⚠️ Warning: Only use this in tests. In production, cached instances
- * should persist throughout the application lifecycle.
- *
- * @example
- * ```typescript
- * import { clearRepositoryCache } from '@spfn/core/db';
- *
- * beforeEach(() => {
- *   clearRepositoryCache();  // Fresh instances for each test
- * });
- * ```
- */
-declare function clearRepositoryCache(): void;
-/**
- * Get cache size (for debugging/monitoring)
- *
- * @returns Number of cached repository instances
- *
- * @example
- * ```typescript
- * const size = getRepositoryCacheSize();
- * console.log(`Cached repositories: ${size}`);
- * ```
- */
-declare function getRepositoryCacheSize(): number;
-
-/**
- * Request-Scoped Repository Pattern
- *
- * Provides request-level repository caching using AsyncLocalStorage.
- *
- * ## Benefits:
- * - ✅ **Automatic isolation**: Each request gets its own repository cache
- * - ✅ **Memory efficient**: Cache cleared automatically after request ends
- * - ✅ **Test-friendly**: No global state, tests are fully isolated
- * - ✅ **DI-compatible**: Can inject custom repositories easily
- * - ✅ **Zero overhead**: Uses existing AsyncLocalStorage infrastructure
- *
- * ## vs Global Singleton:
- *
- * | Feature | Global Singleton | Request-Scoped |
- * |---------|-----------------|----------------|
- * | Memory | Permanent cache | Request-only cache |
- * | Test isolation | Manual clearRepositoryCache() | Automatic |
- * | Thread-safety | Shared state | Isolated per request |
- * | DI support | Difficult | Easy |
- *
- * @example
- * ```typescript
- * // 1. Add middleware (routes automatically)
- * import { RepositoryScope } from '@spfn/core/db';
- *
- * app.use(RepositoryScope());
- *
- * // 2. Use in service (same request = same instance)
- * import { getScopedRepository } from '@spfn/core/db';
- *
- * export async function createPost(data) {
- *   const repo = getScopedRepository(posts, PostRepository); // First call - creates
- *   const existing = await repo.findBySlug(slug);
- *   return repo.save(data); // Same instance
- * }
- *
- * // 3. Different request = different cache (automatic)
- * ```
- */
-
-/**
- * Execute function within a repository scope
- *
- * Creates a new request-scoped cache for the duration of the function.
- * Automatically cleaned up after function completes.
- *
- * @param fn - Async function to execute within scope
- * @returns Result of the function
- *
- * @example
- * ```typescript
- * // Middleware
- * app.use(async (c, next) => {
- *   return withRepositoryScope(() => next());
- * });
- *
- * // Manual usage
- * const result = await withRepositoryScope(async () => {
- *   const repo = getScopedRepository(users);
- *   return repo.findAll();
- * });
- * ```
- */
-declare function withRepositoryScope<T>(fn: () => Promise<T>): Promise<T>;
-/**
- * Get request-scoped repository instance
- *
- * Returns cached instance within the same request, creates new instance for new requests.
- * Falls back to creating a new instance if called outside of a repository scope.
- *
- * ## Behavior:
- * - **Inside scope**: Returns cached instance (same request = same instance)
- * - **Outside scope**: Creates new instance every time (graceful degradation)
- *
- * @param table - Drizzle table definition
- * @param RepositoryClass - Optional custom Repository class
- * @returns Repository instance (cached or new)
- *
- * @example
- * ```typescript
- * // Base Repository
- * const repo = getScopedRepository(users);
- * await repo.findById(1);
- *
- * // Custom Repository
- * class UserRepository extends Repository<typeof users> {
- *   async findByEmail(email: string) {
- *     return this.findOneWhere({ email });
- *   }
- * }
- *
- * const repo = getScopedRepository(users, UserRepository);
- * await repo.findByEmail('john@example.com');
- *
- * // Within same request - returns cached instance
- * const repo2 = getScopedRepository(users, UserRepository); // Same instance!
- * ```
- */
-declare function getScopedRepository<TTable extends PgTable, TRepo extends Repository<TTable> = Repository<TTable>>(table: TTable, RepositoryClass?: new (table: TTable) => TRepo): TRepo;
-/**
- * Hono middleware for automatic repository scope management
- *
- * Wraps each request in a repository scope, ensuring automatic cache isolation.
- * All repositories accessed via getScopedRepository() within this request will be cached.
- *
- * @returns Hono middleware handler
- *
- * @example
- * ```typescript
- * // Global middleware (recommended)
- * import { createServer } from '@spfn/core';
- * import { RepositoryScope } from '@spfn/core/db';
- *
- * const app = createServer();
- * app.use(RepositoryScope());
- *
- * // Or in server.config.ts
- * export default {
- *   middlewares: [
- *     { name: 'repositoryScope', handler: RepositoryScope() }
- *   ]
- * };
- * ```
- */
-declare function RepositoryScope(): MiddlewareHandler;
-/**
- * Get current repository cache size (for debugging/monitoring)
- *
- * Returns the number of cached repository instances in the current request scope.
- * Returns 0 if called outside a scope.
- *
- * @returns Number of cached repositories in current scope
- *
- * @example
- * ```typescript
- * const size = getScopedCacheSize();
- * console.log(`Cached repositories in this request: ${size}`);
- * ```
- */
-declare function getScopedCacheSize(): number;
-/**
- * Check if currently inside a repository scope
- *
- * @returns true if inside scope, false otherwise
- *
- * @example
- * ```typescript
- * if (isInRepositoryScope()) {
- *   console.log('Using scoped cache');
- * } else {
- *   console.log('Creating new instances');
- * }
- * ```
- */
-declare function isInRepositoryScope(): boolean;
-
-/**
- * WrappedDb 클래스
- *
- * Drizzle DB를 래핑하여 추가 기능 제공
- */
-declare class WrappedDb {
-    private db;
-    constructor(db: PostgresJsDatabase<Record<string, never>>);
-    /**
-     * Repository 패턴으로 테이블 접근
-     *
-     * @example
-     * const db = getDb();
-     * const userRepo = db.for(users);
-     * const result = await userRepo.findPage(pageable);
-     */
-    for<TTable extends PgTable<any>, TSelect = any>(table: TTable): Repository<TTable, TSelect>;
-    /**
-     * Drizzle의 모든 메서드를 프록시
-     *
-     * select, insert, update, delete, transaction 등 모든 Drizzle 메서드 사용 가능
-     */
-    get select(): {
-        (): drizzle_orm_pg_core.PgSelectBuilder<undefined>;
-        <TSelection extends drizzle_orm_pg_core.SelectedFields>(fields: TSelection): drizzle_orm_pg_core.PgSelectBuilder<TSelection>;
-    };
-    get insert(): <TTable extends PgTable>(table: TTable) => drizzle_orm_pg_core.PgInsertBuilder<TTable, drizzle_orm_postgres_js.PostgresJsQueryResultHKT, false>;
-    get update(): <TTable extends PgTable>(table: TTable) => drizzle_orm_pg_core.PgUpdateBuilder<TTable, drizzle_orm_postgres_js.PostgresJsQueryResultHKT>;
-    get delete(): <TTable extends PgTable>(table: TTable) => drizzle_orm_pg_core.PgDeleteBase<TTable, drizzle_orm_postgres_js.PostgresJsQueryResultHKT, undefined, undefined, false, never>;
-    get execute(): <TRow extends Record<string, unknown> = Record<string, unknown>>(query: drizzle_orm.SQLWrapper | string) => drizzle_orm_pg_core_query_builders_raw.PgRaw<postgres.RowList<drizzle_orm.Assume<TRow, postgres.Row>[]>>;
-    get transaction(): <T>(transaction: (tx: drizzle_orm_pg_core.PgTransaction<drizzle_orm_postgres_js.PostgresJsQueryResultHKT, Record<string, never>, drizzle_orm.ExtractTablesWithRelations<Record<string, never>>>) => Promise<T>, config?: drizzle_orm_pg_core.PgTransactionConfig) => Promise<T>;
-    get query(): drizzle_orm.DrizzleTypeError<"Seems like the schema generic is missing - did you forget to add it to your DB type?">;
-    get $with(): drizzle_orm_pg_core.WithBuilder;
-    /**
-     * Raw Drizzle DB 접근 (필요시)
-     */
-    get raw(): PostgresJsDatabase;
-}
-
-/**
- * Get DB instance (WrappedDb)
- *
- * - If transaction context exists: Returns transaction DB
- * - Otherwise: Returns default DB or specified connection type
- * - Wraps with WrappedDb to provide both Repository pattern + Drizzle features
- *
- * Usage 1: Direct Drizzle use
- * ```typescript
- * export async function GET(c: RouteContext) {
- *   const db = getDb();
- *   const users = await db.select().from(users);
- *   return c.json(users);
- * }
- * ```
- *
- * Usage 2: Repository pattern
- * ```typescript
- * export async function GET(c: RouteContext) {
- *   const db = getDb();
- *   const userRepo = db.for(users);
- *   const result = await userRepo.findPage(pageable);
- *   return c.json(result);
- * }
- * ```
- *
- * Usage 3: Specify connection type
- * ```typescript
- * const readDb = getDb('read');   // Use read replica
- * const writeDb = getDb('write'); // Use primary
- * ```
- *
- * @param type - Optional connection type ('read' or 'write')
- * @returns WrappedDb instance (transaction or specified DB)
- */
-declare function getDb(type?: DbConnectionType): WrappedDb;
-
-/**
- * Drizzle Kit configuration generator
- * Automatically generates drizzle.config.ts from environment variables
- */
-interface DrizzleConfigOptions {
-    /** Database connection URL (defaults to process.env.DATABASE_URL) */
-    databaseUrl?: string;
-    /** Schema files glob pattern (defaults to './src/server/entities/*.ts') */
-    schema?: string;
-    /** Migration output directory (defaults to './drizzle/migrations') */
-    out?: string;
-    /** Database dialect (auto-detected from URL if not provided) */
-    dialect?: 'postgresql' | 'mysql' | 'sqlite';
-}
-/**
- * Detect database dialect from connection URL
- */
-declare function detectDialect(url: string): 'postgresql' | 'mysql' | 'sqlite';
-/**
- * Generate Drizzle Kit configuration
- *
- * @param options - Configuration options
- * @returns Drizzle Kit configuration object
- *
- * @example
- * ```ts
- * // Zero-config (reads from process.env.DATABASE_URL)
- * const config = getDrizzleConfig();
- *
- * // Custom config
- * const config = getDrizzleConfig({
- *   databaseUrl: 'postgresql://localhost/mydb',
- *   schema: './src/db/schema/*.ts',
- *   out: './migrations',
- * });
- * ```
- */
-declare function getDrizzleConfig(options?: DrizzleConfigOptions): {
-    schema: string;
-    out: string;
-    dialect: "postgresql" | "mysql" | "sqlite";
-    dbCredentials: {
-        url: string;
-    };
-};
-/**
- * Generate drizzle.config.ts file content
- *
- * @param options - Configuration options
- * @returns File content as string
- */
-declare function generateDrizzleConfigFile(options?: DrizzleConfigOptions): string;
-
-/**
- * Standard auto-incrementing primary key
- *
- * @returns bigserial primary key column
- *
- * @example
- * ```typescript
- * export const users = pgTable('users', {
- *     id: id(),
- *     // ...
- * });
- * ```
- */
-declare function id(): drizzle_orm.IsPrimaryKey<drizzle_orm.NotNull<drizzle_orm_pg_core.PgBigSerial53BuilderInitial<"id">>>;
-/**
- * Standard timestamp fields (createdAt, updatedAt)
- *
- * Both fields are timezone-aware, auto-set to current time on creation.
- * When autoUpdate is enabled, updatedAt will be automatically updated on record updates.
- *
- * @param options - Optional configuration
- * @param options.autoUpdate - Automatically update updatedAt on record updates (default: false)
- * @returns Object with createdAt and updatedAt columns
- *
- * @example
- * ```typescript
- * // Without auto-update
- * export const users = pgTable('users', {
- *     id: id(),
- *     email: text('email'),
- *     ...timestamps(),
- * });
- *
- * // With auto-update
- * export const posts = pgTable('posts', {
- *     id: id(),
- *     title: text('title'),
- *     ...timestamps({ autoUpdate: true }),
- * });
- * ```
- */
-declare function timestamps(options?: {
-    autoUpdate?: boolean;
-}): {
-    createdAt: drizzle_orm.NotNull<drizzle_orm.HasDefault<drizzle_orm_pg_core.PgTimestampBuilderInitial<"created_at">>>;
-    updatedAt: drizzle_orm.NotNull<drizzle_orm.HasDefault<drizzle_orm_pg_core.PgTimestampBuilderInitial<"updated_at">>>;
-};
-/**
- * Foreign key reference to another table
- *
- * Creates a bigserial column with cascade delete.
- * Type-safe: ensures the reference points to a valid PostgreSQL column.
- *
- * @param name - Column name (e.g., 'author' creates 'author_id')
- * @param reference - Reference to parent table column
- * @param options - Optional foreign key options
- *
- * @example
- * ```typescript
- * import { users } from './users';
- *
- * export const posts = pgTable('posts', {
- *     id: id(),
- *     authorId: foreignKey('author', () => users.id),
- *     ...timestamps(),
- * });
- * ```
- */
-declare function foreignKey<T extends PgColumn>(name: string, reference: () => T, options?: {
-    onDelete?: 'cascade' | 'set null' | 'restrict' | 'no action';
-}): drizzle_orm.NotNull<drizzle_orm_pg_core.PgBigSerial53BuilderInitial<`${string}_id`>>;
-/**
- * Optional foreign key reference (nullable)
- *
- * Type-safe: ensures the reference points to a valid PostgreSQL column.
- *
- * @param name - Column name (e.g., 'author' creates 'author_id')
- * @param reference - Reference to parent table column
- * @param options - Optional foreign key options
- *
- * @example
- * ```typescript
- * export const posts = pgTable('posts', {
- *     id: id(),
- *     authorId: optionalForeignKey('author', () => users.id),
- * });
- * ```
- */
-declare function optionalForeignKey<T extends PgColumn>(name: string, reference: () => T, options?: {
-    onDelete?: 'cascade' | 'set null' | 'restrict' | 'no action';
-}): drizzle_orm_pg_core.PgBigSerial53BuilderInitial<`${string}_id`>;
-
-/**
- * AsyncLocalStorage-based Transaction Context
- *
- * Uses Node.js AsyncLocalStorage to propagate transactions throughout the async call chain.
- *
- * ✅ Implemented:
- * - AsyncLocalStorage-based context management
- * - Transaction storage/retrieval functions
- * - Type-safe transaction propagation
- * - Transaction propagation across async chains
- *
- * ⚠️ Needs improvement:
- * - Nested transaction handling (currently ignores outer transaction)
- * - Transaction timeout detection
- *
- * 💡 Future considerations:
- * - Add transaction ID (for debugging/tracing)
- * - Track transaction start time (for performance monitoring)
- * - Store transaction metadata (route info, user info, etc.)
- * - Savepoint support (nested transactions)
- * - Transaction isolation level configuration
- *
- * 🔗 Related files:
- * - src/utils/transaction.ts (Transactional middleware)
- * - src/db/db-context.ts (getDb helper)
- */
-
-/**
- * Transaction database type
- * Record<string, never> represents an empty schema; actual schema is determined at runtime
- */
-type TransactionDB = PostgresJsDatabase;
-/**
- * Transaction context stored in AsyncLocalStorage
- */
-type TransactionContext = {
-    tx: TransactionDB;
-};
-/**
- * Get current transaction from AsyncLocalStorage
- *
- * @returns Transaction if available, null otherwise
- */
-declare function getTransaction(): TransactionDB | null;
-/**
- * Run a function within a transaction context
- *
- * The transaction will be available to all async operations within the callback
- * via getTransaction()
- *
- * @param tx - Drizzle transaction object
- * @param callback - Function to run within transaction context
- * @returns Result of the callback
- */
-declare function runWithTransaction<T>(tx: TransactionDB, callback: () => Promise<T>): Promise<T>;
-
-/**
- * Transaction middleware options
- */
-interface TransactionalOptions {
-    /**
-     * Slow transaction warning threshold in milliseconds
-     * @default 1000 (1 second)
-     */
-    slowThreshold?: number;
-    /**
-     * Enable transaction logging
-     * @default true
-     */
-    enableLogging?: boolean;
-    /**
-     * Transaction timeout in milliseconds
-     *
-     * If transaction exceeds this duration, it will be aborted with TransactionError.
-     *
-     * @default 30000 (30 seconds) or TRANSACTION_TIMEOUT environment variable
-     *
-     * @example
-     * ```typescript
-     * // Default timeout (30s or TRANSACTION_TIMEOUT env var)
-     * Transactional()
-     *
-     * // Custom timeout for specific route (60s)
-     * Transactional({ timeout: 60000 })
-     *
-     * // Disable timeout
-     * Transactional({ timeout: 0 })
-     * ```
-     */
-    timeout?: number;
-}
-/**
- * Transaction middleware for Hono routes
- *
- * Automatically wraps route handlers in a database transaction.
- * Commits on success, rolls back on error.
- *
- * @example
- * ```typescript
- * // In your route file
- * export const middlewares = [Transactional()];
- *
- * export async function POST(c: RouteContext) {
- *   // All DB operations run in a transaction
- *   const [user] = await db.insert(users).values(body).returning();
- *   await db.insert(profiles).values({ userId: user.id });
- *   // Auto-commits on success
- *   return c.json(user, 201);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // With custom options
- * export const middlewares = [
- *   Transactional({
- *     slowThreshold: 2000,    // Warn if transaction takes > 2s
- *     enableLogging: false,   // Disable logging
- *     timeout: 60000,         // 60 second timeout for long operations
- *   })
- * ];
- * ```
- *
- * 🔄 Transaction behavior:
- * - Success: Auto-commit
- * - Error: Auto-rollback
- * - Detects context.error to trigger rollback
- *
- * 📊 Transaction logging:
- * - Auto-logs transaction start/commit/rollback
- * - Measures and records execution time
- * - Warns about slow transactions (default: > 1s)
- */
-declare function Transactional(options?: TransactionalOptions): hono.MiddlewareHandler<any, string, {}>;
-
-/**
- * Database Error Classes
- *
- * Type-safe error handling with custom error class hierarchy
- * Mapped to HTTP status codes for API responses
- */
-/**
- * Base Database Error
- *
- * Base class for all database-related errors
- */
-declare class DatabaseError<TDetails extends Record<string, unknown> = Record<string, unknown>> extends Error {
-    readonly statusCode: number;
-    readonly details?: TDetails;
-    readonly timestamp: Date;
-    constructor(message: string, statusCode?: number, details?: TDetails);
-    /**
-     * Serialize error for API response
-     */
-    toJSON(): {
-        name: string;
-        message: string;
-        statusCode: number;
-        details: TDetails | undefined;
-        timestamp: string;
-    };
-}
-/**
- * Connection Error (503 Service Unavailable)
- *
- * Database connection failure, connection pool exhaustion, etc.
- */
-declare class ConnectionError extends DatabaseError {
-    constructor(message: string, details?: Record<string, any>);
-}
-/**
- * Query Error (500 Internal Server Error)
- *
- * SQL query execution failure, syntax errors, etc.
- */
-declare class QueryError extends DatabaseError {
-    constructor(message: string, statusCode?: number, details?: Record<string, any>);
-}
-/**
- * Not Found Error (404 Not Found)
- *
- * Requested resource does not exist
- */
-declare class NotFoundError extends QueryError {
-    constructor(resource: string, id: string | number);
-}
-/**
- * Validation Error (400 Bad Request)
- *
- * Input data validation failure
- */
-declare class ValidationError extends QueryError {
-    constructor(message: string, details?: Record<string, any>);
-}
-/**
- * Transaction Error (500 Internal Server Error)
- *
- * Transaction start/commit/rollback failure
- */
-declare class TransactionError extends DatabaseError {
-    constructor(message: string, statusCode?: number, details?: Record<string, any>);
-}
-/**
- * Deadlock Error (409 Conflict)
- *
- * Database deadlock detected
- */
-declare class DeadlockError extends TransactionError {
-    constructor(message: string, details?: Record<string, any>);
-}
-/**
- * Duplicate Entry Error (409 Conflict)
- *
- * Unique constraint violation (e.g., duplicate email)
- */
-declare class DuplicateEntryError extends QueryError {
-    constructor(field: string, value: string | number);
-}
-
-/**
- * PostgreSQL Error Conversion Utilities
- *
- * Converts PostgreSQL-specific error codes to custom error types
- * @see https://www.postgresql.org/docs/current/errcodes-appendix.html
- */
-
-/**
- * Convert PostgreSQL error to custom DatabaseError
- *
- * Maps PostgreSQL error codes to appropriate error classes with correct status codes
- *
- * @param error - PostgreSQL error object (from pg driver or Drizzle)
- * @returns Custom DatabaseError instance
- *
- * @example
- * ```typescript
- * import { fromPostgresError } from '@spfn/core/db';
- *
- * try {
- *   await db.insert(users).values(data);
- * } catch (pgError) {
- *   throw fromPostgresError(pgError);
- * }
- * ```
- */
-declare function fromPostgresError(error: any): DatabaseError;
-
-export { type SortDirection as $, timestamps as A, foreignKey as B, optionalForeignKey as C, type DbConnectionType as D, getTransaction as E, runWithTransaction as F, type TransactionContext as G, type TransactionDB as H, type TransactionalOptions as I, fromPostgresError as J, DatabaseError as K, buildFilters as L, buildSort as M, orFilters as N, applyPagination as O, type PoolConfig as P, QueryBuilder as Q, type RetryConfig as R, createPaginationMeta as S, Transactional as T, countTotal as U, type FilterOperator as V, WrappedDb as W, type FilterValue as X, type FilterCondition as Y, type Filters as Z, type FilterResult as _, getDb as a, type SortCondition as a0, type SortResult as a1, type PaginationParams as a2, type PaginationMeta as a3, type DrizzleTable as a4, ConnectionError as a5, QueryError as a6, NotFoundError as a7, ValidationError as a8, TransactionError as a9, DeadlockError as aa, DuplicateEntryError as ab, getDatabase as b, createDatabaseFromEnv as c, db as d, closeDatabase as e, getDatabaseInfo as f, getRawDb as g, type DatabaseClients as h, initDatabase as i, getDrizzleConfig as j, detectDialect as k, generateDrizzleConfigFile as l, type DrizzleConfigOptions as m, Repository as n, getRepository as o, clearRepositoryCache as p, getRepositoryCacheSize as q, getScopedRepository as r, setDatabase as s, RepositoryScope as t, getScopedCacheSize as u, isInRepositoryScope as v, withRepositoryScope as w, type Pageable as x, type Page as y, id as z };