gajus / slonik

Slonik A battle-tested Node.js PostgreSQL client with strict types, detailed logging and assertions. > [!NOTE] > NEW! Use Slonik with to validate your SQL queries against your database schema. (The above GIF shows Slonik producing query logs. Slonik produces logs using Roarr. Logs include stack trace of the actual query invocation location and values used to execute the query.) Sponsors If you value my work and want to see Slonik and many other of my Open-Source projects to be continuously improved, then please consider becoming a patron: Principles • Promotes writing raw SQL. • Discourages ad-hoc dynamic generation of SQL. Read: Stop using Knex.js Note: Using this project does not require TypeScript. It is a regular ES6 module. Ignore the type definitions used in the documentation if you do not use a type system. Features • Runtime validation. • Assertions and type safety. • Safe connection handling. • Safe transaction handling. • Safe value interpolation. • Transaction nesting. • Transaction events. • Transaction retrying. • Query retrying. • Detailed logging. • Asynchronous stack trace resolution. • Middlewares. • Mapped errors. • ESLint plugin. Contents • Slonik • Sponsors • Principles • Features • Contents • About Slonik • Battle-Tested • Origin of the name • Repeating code patterns and type safety • Protecting against unsafe connection handling • Protecting against unsafe transaction handling • Protecting against unsafe value interpolation • Documentation • Usage • Connection URI • Create connection • End connection pool • Describing the current state of the connection pool • API • Default configuration • Checking out a client from the connection pool • Events • How are they different? • vs • vs • vs • Type parsers • Built-in type parsers • Interceptors • Interceptor methods • Community interceptors • Recipes • Inserting large number of rows • Routing queries to different connections • Building Utility Statements • Inserting vector data • Runtime validation • Motivation • Result parser interceptor • Example use of • Performance penalty • Unknown keys • Handling schema validation errors • Inferring types • Transforming results • tag • Type aliases • Typing tag • Value placeholders • Tagged template literals • Manually constructing the query • Nesting • Query building • - • - • - • - • - • - • - • - Query methods • - • - • - • - • - • - • Utilities • - • Error handling • Original error • Handling • Handling • Handling • Handling • Handling • Handling • Handling • Handling • Handling • Handling • Handling • Migrations • Types • Debugging • Logging • Capture stack trace • Syntax Highlighting • Atom Syntax Highlighting Plugin • VS Code Syntax Highlighting Extension • Development About Slonik Battle-Tested Slonik began as a collection of utilities designed for working with . It continues to use driver as it provides a robust foundation for interacting with PostgreSQL. However, what once was a collection of utilities has since grown into a framework that abstracts repeating code patterns, protects against unsafe connection handling and value interpolation, and provides a rich debugging experience. Slonik has been battle-tested with large data volumes and queries ranging from simple CRUD operations to data-warehousing needs. Origin of the name **"Słonik"** is a Polish diminutive of **"słoń,"** meaning “little elephant” or “baby elephant.” The word **"słoń"** itself comes from Proto-Slavic \*_slonъ_, which was likely borrowed from a Germanic language and may ultimately trace back to Latin. Repeating code patterns and type safety Among the primary reasons for developing Slonik, was the motivation to reduce the repeating code patterns and add a level of type safety. This is primarily achieved through the methods such as , , etc. But what is the issue? It is best illustrated with an example. Suppose the requirement is to write a method that retrieves a resource ID given values defining (what we assume to be) a unique constraint. If we did not have the aforementioned helper methods available, then it would need to be written as: method abstracts all of the above logic into: throws: • if query returns no rows • if query returns multiple rows • if query returns multiple columns In the absence of helper methods, the overhead of repeating code becomes particularly visible when writing routines where multiple queries depend on the proceeding query results. Using methods with inbuilt assertions ensures that in case of an error, the error points to the source of the problem. In contrast, unless assertions for all possible outcomes are typed out as in the previous example, the unexpected result of the query will be fed to the next operation. If you are lucky, the next operation will simply break; if you are unlucky, you are risking data corruption and hard-to-locate bugs. Furthermore, using methods that guarantee the shape of the results allows us to leverage static type checking and catch some of the errors even before executing the code, e.g. Static type check of the above example will produce a warning as the is guaranteed to be an array and binding of the last query is expecting a primitive value. Protecting against unsafe connection handling Slonik only allows to check out a connection for the duration of the promise routine supplied to the method. The primary reason for implementing _only_ this connection pooling method is because the alternative is inherently unsafe, e.g. In this example, if produces an error, then connection is never released, i.e. the connection hangs indefinitely. A fix to the above is to ensure that is always called, i.e. Slonik abstracts the latter pattern into method. Using this pattern, we guarantee that connection is always released as soon as the routine resolves or is rejected. Resetting connection state After the connection is released, Slonik resets the connection state. This is to prevent connection state from leaking between queri…