Slonik is a production-grade, battle-tested Node.js PostgreSQL client library that emphasizes strict typing, detailed logging, and runtime assertions. It provides a type-safe SQL query interface via tagged template literals (the `sql` tag), connection pooling with configurable lifecycle management, transaction support, and an interceptor (middleware) system for extending query execution, connection handling, and result transformation. The library is structured as a monorepo with multiple packages: core `slonik`, `@slonik/sql-tag` for SQL template construction, `@slonik/driver` and `@slonik/pg-driver` for driver abstraction, `@slonik/errors` for a comprehensive error hierarchy, `@slonik/utilities` for shared utilities, and community interceptor packages for query caching, logging, field name transformation, and DataLoader integration. It integrates with Zod for optional runtime query result validation and uses Roarr for logging. The architecture is modular, with clean separation of concerns, making it suitable for both small projects and large-scale production systems.
zombiezen/go-sqlite is a Go library providing low-level bindings to SQLite 3 using the CGo-free modernc.org/sqlite implementation. It offers direct access to SQLite features including connection management, statement execution, blob I/O streaming, online backup API, user-defined functions (scalar and aggregate), session API for changesets, virtual table support, and schema migration tools. The architecture follows a modular design with core sqlite package for basic operations, sqlitex for extended utilities (connection pooling, execution helpers), sqlitefile for blob-backed buffers, and sqlitemigration for schema migrations. The library is safe for concurrent use through connection pooling and proper error handling, with comprehensive test coverage demonstrating its reliability.
Boost.MySQL is a high-quality, production-ready C++11 client library for MySQL and MariaDB, built on top of Boost.Asio. It provides both synchronous and asynchronous database access with a modern, type-safe interface. The library features a sans-I/O architecture that separates protocol logic from transport, enabling testability and flexibility. Key capabilities include connection pooling with automatic health checks, client-side SQL formatting to prevent injection, prepared statements, pipeline batching, and a static interface using Boost.Describe or Boost.Pfr for compile-time row mapping. The codebase demonstrates strong engineering practices: extensive unit and integration tests, fuzzing, thread-safety verification, and benchmarks against native MySQL clients. It is an official Boost library, actively maintained with a large community.
redis-plus-plus is a production-grade C++ Redis client library built on hiredis, providing synchronous, asynchronous (libuv), and experimental coroutine (C++20) APIs. It covers the full Redis command surface including strings, hashes, lists, sets, sorted sets, streams, geospatial, hyperloglog, pub/sub, scripting, transactions, pipelines, and server commands. The architecture separates low-level connection management (connection pools, shard pools for clusters, sentinel discovery) from high-level facade classes (Redis, RedisCluster, AsyncRedis, AsyncRedisCluster, QueuedRedis for pipelined/transactional usage). Key entry points include the main sync header `redis++.h`, async header `async_redis++.h`, and coroutine header `co_redis++.h`. Data flows involve constructing Redis commands via `CmdArgs` and `cmd_formatter.h`, sending them through `Connection` objects (optionally pooled), and parsing replies with `reply.h`. The library depends on hiredis for raw Redis protocol, libuv for async I/O, and optionally Boost or OpenSSL for advanced features. It includes a comprehensive test suite covering all commands, multi-threading, cluster, sentinel, and distributed locking patterns (Redlock).
This repository implements a lightweight gRPC connection pool for Go applications. The library provides a thread-safe pool of gRPC client connections that can be reused across multiple goroutines, with configurable pool size, idle timeouts, and maximum connection lifetimes. It manages the full lifecycle of connections including creation, reuse, expiration, and cleanup. The implementation handles edge cases such as connection health checking, automatic replacement of stale connections, and proper error handling for timeouts and pool exhaustion. The core abstraction consists of a Pool struct that manages a channel of ClientConn wrappers, which track connection metadata and pool membership.