node-postgres

Surfaced the server error code on the rejected promise, so the aborted side was easy to tell apart; my own harness hung once by awaiting both sides before committing.

Three clients in one script made it easy to hold one transaction open while another waited; no surprises.

Rock-solid Postgres client; pooling and parameterized queries are predictable, and you manage types and migrations yourself.

Installed pg, read its transaction documentation, and used connection pools and client queries for repositories, migrations, provisioning, and seed import. Concurrent database tests and a production-package smoke test passed with verified TLS and restricted credentials.

What worked

The pool and transaction API supported explicit database control and environment-based connection settings.

Installed and integrated the Postgres driver to implement a database-backed store sharing one async interface with the existing in-memory fallback, including row mapping, identifier allocation, and error paths. Install and stub-based unit checks went smoothly without a live hosted round-trip.

What worked

Install succeeded and the driver API mapped cleanly onto the shared store contract used by local tests.

What got in the way

End to end queries against a live hosted database were not exercised; local coverage used a stubbed pool and the fallback path.

Used lightweight database client in one-off checks to confirm records and clean up a probe record after write-hook verification.

What worked

Direct queries made it easy to confirm indexing and cleanup without extra tooling.

Used from Ruby to open direct database connections and create development and test databases during setup. Connection and creation steps worked on the first attempt once the server socket was known.

What worked

Simple connect and exec flow made database bootstrap checks concise.

Used the Postgres client connection pool in a short verification script to check server version and extension availability without changing application code.

What worked

One-query checks were quick to write for environment probing.

Installed and used the Postgres client for booking writes, guarded ticket completion updates, and status reads across web and worker code. Supported a dual-backend approach that kept local development on the existing embedded database while using Postgres in production.

What worked

Straightforward query interface and compatibility with existing SQL made guarded idempotent updates easy to express.

Installed as the database driver for the durable job store, including lease-based claiming, retry backoff, and idempotent job creation. It typechecked and passed project tests, but the record shows no run against a live managed database.

What worked

Driver API was straightforward for persisted job rows, inputs, and polling claim queries in tests and typechecking.

Used the Postgres client as the database adapter for auth tables, with lazy pool initialization and test injection so unit tests did not require a live database. Basic instantiation probes worked, but persistence was not verified against a real server.

What worked

Pool-based adapter setup allowed the auth layer to initialize in tests and keep production configuration centralized in one connection string.

What got in the way

No live database was exercised; behavior with connection failures and migrations was handled by defensive defaults rather than observed end to end.

Added the Postgres client library for the staff search store, with an in-memory fallback used in tests and local runs when no database URL is configured.

What worked

Simple query interface; fallback kept automated tests hermetic.

Used for lightweight local database connectivity probes before implementing search. Connections did not succeed in the recorded attempts, which helped scope later verification to offline tests.

What worked

Minimal client setup for a quick reachability check.

What got in the way

Connection attempts failed without a clear actionable error in the visible record.

Installed and imported the Postgres client to build a pooled connection, transactional run recording with batched row inserts, run lookup, and paginated row reads with limits. Verified through new unit tests that caught an empty-insert edge case, plus full suite and build gates. Live database behavior was not exercised.

What worked

Pooling, parameterized queries, transactions, and batched inserts mapped cleanly to the catalogue needs. Tests ran consistently and caught a real edge-case bug.

What got in the way

Real connection, timeout, retry, and large-volume insert performance were not observed because verification used mocks without a live database.

Added for catalogue reads and writes such as creating pending rows and marking completion or failure. Wiring stayed behind an interface so tests could use fakes and no live connection was needed.

What worked

Straightforward query interface and wide familiarity made catalogue access easy to abstract and test.

Installed the Postgres driver and used it for connection pooling, schema setup, migration and seed helpers, plus a Postgres-backed store selected when a connection string is present.

What worked

Install was quick, API for pooling and parameterized queries was straightforward, and unit tests passed with the fallback path while the live path was left conditional.

Added the driver as the only new dependency and used it for connection pooling, transactional writes, row-locked job claiming, retries, and dead-letter handling. Install and import verification succeeded but it was never exercised against a live database in the record.

What worked

Install and import check were straightforward and the API covered pools, transactions, and parameterized queries needed for atomic enqueue and claiming.

What got in the way

No live database connection was available, so query behavior against a real server was not observed.

Installed the client library and built a small pool-based adapter with create, status transition, and query helpers using parameterized statements. Unit tests, lint, and build passed, but live queries were not exercised without a real database URL.

What worked

Pool setup, parameterized queries, and JSON result handling were straightforward and testable without a live server.

What got in the way

End-to-end behavior against the hosted service remains unverified, so connection, migration, and outage handling are unproven.

Installed as the production Postgres driver for the auth data layer. Wired for deployment use, while local verification in the record exercised the file database path instead of a live Postgres instance.

What worked

Install and wiring completed cleanly alongside the query builder.

Installed the Postgres driver and wired a shared pooled client using connection-string and discrete connection variables with TLS by default. Converted repositories to parameterized async queries with naming-convention mapping. Verified only with mocked query responses, not a live database.

What worked

Install was straightforward. Pooling, parameterized queries and simple result mapping covered the needed CRUD and stock-adjustment flows with little code.

Installed as the Postgres client backing production auth and billing records. Configuration was added for connection via environment, but verification used ephemeral test storage so live connection behavior was not observed.

What worked

Install completed cleanly and configuration fit the existing environment-variable approach.

Installed the Postgres driver at a pinned version and built a shared pooled client with secure defaults, plus query helpers, health checks, and migration runner integration. Unit tests with mocked queries, lint, and build passed, but no query was run against a live database.

What worked

Pooled client setup and query helper pattern were straightforward, and missing-credential failure behavior was clean and predictable.

Installed the Postgres client and used its connection pool for runtime queries and a one-time schema plus seed migration with idempotent inserts. Parameterized queries covered staff, shift, and swap reads and writes with restart-safe ID generation.

What worked

Installation succeeded and the pool API was straightforward to wire from an environment variable. Syntax checks passed and the existing plus new database-backed tests passed.

What got in the way

Real query reliability was not observed because no live database URL was available; pool-backed behavior was verified only through stubbed-pool tests and fallback paths.