kysely 0.26.1 → 0.26.2

package/README.md

@@ -1,7 +1,7 @@
 [![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://stand-with-ukraine.pp.ua)
 
 [![Discord](https://img.shields.io/discord/890118421587578920?logo=discord&style=flat)](https://discord.gg/xyBJ3GwvAm)
-[![Tests](https://github.com/koskimas/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/koskimas/kysely)
+[![Tests](https://github.com/kysely-org/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/kysely-org/kysely)
 [![License](https://img.shields.io/github/license/kysely-org/kysely?style=flat)](https://github.com/kysely-org/kysely/blob/master/LICENSE)
 [![Issues](https://img.shields.io/github/issues-closed/kysely-org/kysely?logo=github)](https://github.com/kysely-org/kysely/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)
 [![Pull Requests](https://img.shields.io/github/issues-pr-closed/kysely-org/kysely?label=PRs&logo=github&style=flat)](https://github.com/kysely-org/kysely/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc)
@@ -16,7 +16,7 @@ Kysely (pronounce “Key-Seh-Lee”) is a type-safe and autocompletion-friendly
 Inspired by [knex](http://knexjs.org/). Mainly developed for [node.js](https://nodejs.org/en/) but also 
 runs on all other javascript environments like [deno](https://deno.land/).
 
-![](https://github.com/koskimas/kysely/blob/master/assets/demo.gif)
+![](https://github.com/kysely-org/kysely/blob/master/assets/demo.gif)
 
 Kysely makes sure you only refer to tables and columns that are visible to the part of the query
 you're writing. The result type only has the selected columns with correct types and aliases. As an
@@ -28,11 +28,11 @@ column names, aliases and types from selected subqueries, joined subqueries, `wi
 much anything you can think of.
 
 Of course there are cases where things cannot be typed at compile time, and Kysely offers escape
-hatches for these situations. See the [sql template tag](https://kysely-org.github.io/kysely/interfaces/Sql.html) 
-and the [DynamicModule](https://kysely-org.github.io/kysely/classes/DynamicModule.html#ref) for more info.
+hatches for these situations. See the [sql template tag](https://kysely-org.github.io/kysely-apidoc/interfaces/Sql.html)
+and the [DynamicModule](https://kysely-org.github.io/kysely-apidoc/classes/DynamicModule.html#ref) for more info.
 
 All API documentation is written in the typing files and you can simply hover over the module, class
-or method you're using to see it in your IDE. The same documentation is also hosted [here](https://github.com/koskimas/kysely).
+or method you're using to see it in your IDE. The same documentation is also hosted [here](https://github.com/kysely-org/kysely).
 
 If you start using Kysely and can't find something you'd want to use, please open an issue or join our
 [discord server](https://discord.gg/xyBJ3GwvAm).
@@ -40,7 +40,7 @@ If you start using Kysely and can't find something you'd want to use, please ope
 # Getting started
 
 Please visit our documentation site [kysely.dev](https://kysely.dev) to get started. We also have a comprehensive
-API documentation hosted [here](https://kysely-org.github.io/kysely/) but you can access the same
+API documentation hosted [here](https://kysely-org.github.io/kysely-apidoc/) but you can access the same
 documentation in your IDE by hovering over a class/method/property/whatever.
 
 # Contributors

package/dist/cjs/dialect/dialect-adapter-base.d.ts

@@ -1,5 +1,5 @@
 import { Kysely } from '../kysely.js';
-import { DialectAdapter } from './dialect-adapter.js';
+import { DialectAdapter, MigrationLockOptions } from './dialect-adapter.js';
 /**
  * A basic implementation of `DialectAdapter` with sensible default values.
  * 3rd party dialects can extend this instead of implementing the `DialectAdapter`
@@ -63,7 +63,7 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * `db` is a single connection (session) that will be used to execute the
      * migrations.
      */
-    abstract acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    abstract acquireMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
      *
@@ -72,5 +72,5 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * is a single connection (session) that was used to execute the migrations
      * and the `acquireMigrationLock` call.
      */
-    abstract releaseMigrationLock(db: Kysely<any>): Promise<void>;
+    abstract releaseMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
 }

package/dist/cjs/dialect/mysql/mysql-adapter.d.ts

@@ -1,5 +1,6 @@
 import { Kysely } from '../../kysely.js';
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
+import { MigrationLockOptions } from '../dialect-adapter.js';
 export declare class MysqlAdapter extends DialectAdapterBase {
     /**
      * Whether or not this dialect supports transactional DDL.
@@ -57,7 +58,7 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      * `db` is a single connection (session) that will be used to execute the
      * migrations.
      */
-    acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    acquireMigrationLock(db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
      *
@@ -66,5 +67,5 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      * is a single connection (session) that was used to execute the migrations
      * and the `acquireMigrationLock` call.
      */
-    releaseMigrationLock(db: Kysely<any>): Promise<void>;
+    releaseMigrationLock(db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
 }

package/dist/cjs/dialect/mysql/mysql-adapter.js

@@ -12,7 +12,7 @@ class MysqlAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
     get supportsReturning() {
         return false;
     }
-    async acquireMigrationLock(db) {
+    async acquireMigrationLock(db, _opt) {
         // Kysely uses a single connection to run the migrations. Because of that, we
         // can take a lock using `get_lock`. Locks acquired using `get_lock` get
         // released when the connection is destroyed (session ends) or when the lock
@@ -21,7 +21,7 @@ class MysqlAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
         // MySQL if the process gets killed for some reason.
         await (0, sql_js_1.sql) `select get_lock(${sql_js_1.sql.lit(LOCK_ID)}, ${sql_js_1.sql.lit(LOCK_TIMEOUT_SECONDS)})`.execute(db);
     }
-    async releaseMigrationLock(db) {
+    async releaseMigrationLock(db, _opt) {
         await (0, sql_js_1.sql) `select release_lock(${sql_js_1.sql.lit(LOCK_ID)})`.execute(db);
     }
 }

package/dist/cjs/dialect/postgres/postgres-adapter.d.ts

@@ -1,5 +1,6 @@
 import { Kysely } from '../../kysely.js';
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
+import { MigrationLockOptions } from '../dialect-adapter.js';
 export declare class PostgresAdapter extends DialectAdapterBase {
     /**
      * Whether or not this dialect supports transactional DDL.
@@ -57,7 +58,7 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      * `db` is a single connection (session) that will be used to execute the
      * migrations.
      */
-    acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    acquireMigrationLock(db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
      *
@@ -66,5 +67,5 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      * is a single connection (session) that was used to execute the migrations
      * and the `acquireMigrationLock` call.
      */
-    releaseMigrationLock(): Promise<void>;
+    releaseMigrationLock(_db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
 }

package/dist/cjs/dialect/postgres/postgres-adapter.js

@@ -12,11 +12,11 @@ class PostgresAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
     get supportsReturning() {
         return true;
     }
-    async acquireMigrationLock(db) {
+    async acquireMigrationLock(db, _opt) {
         // Acquire a transaction level advisory lock.
         await (0, sql_js_1.sql) `select pg_advisory_xact_lock(${sql_js_1.sql.lit(LOCK_ID)})`.execute(db);
     }
-    async releaseMigrationLock() {
+    async releaseMigrationLock(_db, _opt) {
         // Nothing to do here. `pg_advisory_xact_lock` is automatically released at the
         // end of the transaction and since `supportsTransactionalDdl` true, we know
         // the `db` instance passed to acquireMigrationLock is actually a transaction.

package/dist/cjs/dialect/postgres/postgres-dialect-config.d.ts

@@ -8,7 +8,7 @@ export interface PostgresDialectConfig {
      *
      * If a function is provided, it's called once when the first query is executed.
      *
-     * https://node-postgres.com/api/pool
+     * https://node-postgres.com/apis/pool
      */
     pool: PostgresPool | (() => Promise<PostgresPool>);
     /**
@@ -35,7 +35,7 @@ export interface PostgresDialectConfig {
  *
  * We don't use the type from `pg` here to not have a dependency to it.
  *
- * https://node-postgres.com/api/pool
+ * https://node-postgres.com/apis/pool
  */
 export interface PostgresPool {
     connect(): Promise<PostgresPoolClient>;

package/dist/cjs/dialect/sqlite/sqlite-adapter.d.ts

@@ -1,4 +1,6 @@
+import { Kysely } from '../../kysely.js';
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
+import { MigrationLockOptions } from '../dialect-adapter.js';
 export declare class SqliteAdapter implements DialectAdapterBase {
     /**
      * Whether or not this dialect supports transactional DDL.
@@ -56,7 +58,7 @@ export declare class SqliteAdapter implements DialectAdapterBase {
      * `db` is a single connection (session) that will be used to execute the
      * migrations.
      */
-    acquireMigrationLock(): Promise<void>;
+    acquireMigrationLock(_db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
      *
@@ -65,5 +67,5 @@ export declare class SqliteAdapter implements DialectAdapterBase {
      * is a single connection (session) that was used to execute the migrations
      * and the `acquireMigrationLock` call.
      */
-    releaseMigrationLock(): Promise<void>;
+    releaseMigrationLock(_db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
 }

package/dist/cjs/dialect/sqlite/sqlite-adapter.js

@@ -8,12 +8,12 @@ class SqliteAdapter {
     get supportsReturning() {
         return true;
     }
-    async acquireMigrationLock() {
+    async acquireMigrationLock(_db, _opt) {
         // SQLite only has one connection that's reserved by the migration system
         // for the whole time between acquireMigrationLock and releaseMigrationLock.
         // We don't need to do anything here.
     }
-    async releaseMigrationLock() {
+    async releaseMigrationLock(_db, _opt) {
         // SQLite only has one connection that's reserved by the migration system
         // for the whole time between acquireMigrationLock and releaseMigrationLock.
         // We don't need to do anything here.

package/dist/cjs/driver/runtime-driver.js

@@ -11,15 +11,25 @@ class RuntimeDriver {
     #driver;
     #log;
     #initPromise;
+    #initDone;
     #destroyPromise;
     #connections = new WeakSet();
     constructor(driver, log) {
+        this.#initDone = false;
         this.#driver = driver;
         this.#log = log;
     }
     async init() {
+        if (this.#destroyPromise) {
+            throw new Error('driver has already been destroyed');
+        }
         if (!this.#initPromise) {
-            this.#initPromise = this.#driver.init().catch((err) => {
+            this.#initPromise = this.#driver
+                .init()
+                .then(() => {
+                this.#initDone = true;
+            })
+                .catch((err) => {
                 this.#initPromise = undefined;
                 return Promise.reject(err);
             });
@@ -27,7 +37,12 @@ class RuntimeDriver {
         await this.#initPromise;
     }
     async acquireConnection() {
-        await this.init();
+        if (this.#destroyPromise) {
+            throw new Error('driver has already been destroyed');
+        }
+        if (!this.#initDone) {
+            await this.init();
+        }
         const connection = await this.#driver.acquireConnection();
         if (!this.#connections.has(connection)) {
             if (this.#needsLogging()) {

package/dist/cjs/expression/expression-builder.d.ts

@@ -3,14 +3,17 @@ import { TableExpression, From, FromTables, ExtractTableAlias, AnyAliasedTable,
 import { FunctionModule } from '../query-builder/function-module.js';
 import { ExtractTypeFromReferenceExpression, ReferenceExpression, SimpleReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
-import { BinaryOperatorExpression, ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { BinaryOperatorExpression, ComparisonOperatorExpression, FilterObject, OperandValueExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { Expression } from './expression.js';
 import { ExpressionWrapper } from './expression-wrapper.js';
 import { ComparisonOperator, JSONOperatorWith$, UnaryOperator } from '../operation-node/operator-node.js';
 import { SqlBool } from '../util/type-utils.js';
-import { ExtractTypeFromValueExpressionOrList } from '../parser/value-parser.js';
+import { ExtractTypeFromValueExpression } from '../parser/value-parser.js';
 import { CaseBuilder } from '../query-builder/case-builder.js';
 import { JSONPathBuilder } from '../query-builder/json-path-builder.js';
+import { OperandExpression } from '../parser/expression-parser.js';
+import { SelectArg, SelectExpression, Selection } from '../parser/select-parser.js';
+import { RefTuple2, RefTuple3, RefTuple4, RefTuple5, ValTuple2, ValTuple3, ValTuple4, ValTuple5 } from '../parser/tuple-parser.js';
 export interface ExpressionBuilder<DB, TB extends keyof DB> {
     /**
      * Creates a binary expression.
@@ -20,31 +23,45 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      *
      * ### Examples
      *
-     * In the following example `eb` is used to increment an integer column:
+     * A simple comparison:
      *
      * ```ts
-     * db.updateTable('person')
-     *   .set((eb) => ({
-     *     age: eb('age', '+', 1)
-     *   }))
-     *   .where('id', '=', id)
+     * eb.selectFrom('person')
+     *   .selectAll()
+     *   .where((eb) => eb('first_name', '=', 'Jennifer'))
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * update "person"
-     * set "age" = "age" + $1
-     * where "id" = $2
+     * select *
+     * from "person"
+     * where "first_name" = $1
+     * ```
+     *
+     * By default the third argument is interpreted as a value. To pass in
+     * a column reference, you can use {@link ref}:
+     *
+     * ```ts
+     * eb.selectFrom('person')
+     *   .selectAll()
+     *   .where((eb) => eb('first_name', '=', eb.ref('last_name')))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where "first_name" = "last_name"
      * ```
      *
-     * By default the third argument is a value. {@link ref} can be used to
-     * pass in a column reference instead:
+     * In the following example `eb` is used to increment an integer column:
      *
      * ```ts
      * db.updateTable('person')
      *   .set((eb) => ({
-     *     age: eb('age', '+', eb.ref('age'))
+     *     age: eb('age', '+', 1)
      *   }))
      *   .where('id', '=', id)
      * ```
@@ -53,8 +70,23 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      *
      * ```sql
      * update "person"
-     * set "age" = "age" + "age"
-     * where "id" = $1
+     * set "age" = "age" + $1
+     * where "id" = $2
+     * ```
+     *
+     * As always, expressions can be nested. Both the first and the third argument
+     * can be any expression:
+     *
+     * ```ts
+     * eb.selectFrom('person')
+     *   .selectAll()
+     *   .where((eb) => eb(
+     *     eb.fn('lower', ['first_name']),
+     *     'in',
+     *     eb.selectFrom('pet')
+     *       .select('pet.name')
+     *       .where('pet.species', '=', 'cat')
+     *   ))
      * ```
      */
     <RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression>(lhs: RE, op: OP, rhs: OperandValueExpressionOrList<DB, TB, RE>): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
@@ -81,7 +113,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * )
      * ```
      */
-    eb: ExpressionBuilder<DB, TB>;
+    get eb(): ExpressionBuilder<DB, TB>;
     /**
      * Returns a {@link FunctionModule} that can be used to write type safe function
      * calls.
@@ -163,6 +195,16 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
     selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, TB | ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+    /**
+     * Creates a `select` expression without a `from` clause.
+     *
+     * If you want to create a `select from` query, use the `selectFrom` method instead.
+     * This one can be used to create a plain `select` statement without a `from` clause.
+     *
+     * This method accepts the same inputs as {@link SelectQueryBuilder.select}. See its
+     * documentation for examples.
+     */
+    selectNoFrom<SE extends SelectExpression<DB, TB>>(selection: SelectArg<DB, TB, SE>): SelectQueryBuilder<DB, TB, Selection<DB, TB, SE>>;
     /**
      * Creates a `case` statement/operator.
      *
@@ -322,7 +364,144 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * $1 = "age"
      * ```
      */
-    val<VE>(value: VE): ExpressionWrapper<DB, TB, ExtractTypeFromValueExpressionOrList<VE>>;
+    val<VE>(value: VE): ExpressionWrapper<DB, TB, ExtractTypeFromValueExpression<VE>>;
+    /**
+     * Creates a tuple expression.
+     *
+     * This creates a tuple using column references by default. See {@link tuple}
+     * if you need to create value tuples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where(({ eb, refTuple, tuple }) => eb(
+     *     refTuple('first_name', 'last_name'),
+     *     'in',
+     *     [
+     *       tuple('Jennifer', 'Aniston'),
+     *       tuple('Sylvester', 'Stallone')
+     *     ]
+     *   ))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   "person".*
+     * from
+     *   "person"
+     * where
+     *   ("first_name", "last_name")
+     *   in
+     *   (
+     *     ($1, $2),
+     *     ($3, $4)
+     *   )
+     * ```
+     *
+     * In the next example a reference tuple is compared to a subquery. Note that
+     * in this case you need to use the {@link @SelectQueryBuilder.$asTuple | $asTuple}
+     * function:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where(({ eb, refTuple, selectFrom }) => eb(
+     *     refTuple('first_name', 'last_name'),
+     *     'in',
+     *     selectFrom('pet')
+     *       .select(['name', 'species'])
+     *       .where('species', '!=', 'cat')
+     *       .$asTuple('name', 'species')
+     *   ))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   "person".*
+     * from
+     *   "person"
+     * where
+     *   ("first_name", "last_name")
+     *   in
+     *   (
+     *     select "name", "species"
+     *     from "pet"
+     *     where "species" != $1
+     *   )
+     * ```
+     */
+    refTuple<R1 extends ReferenceExpression<DB, TB>, R2 extends ReferenceExpression<DB, TB>>(value1: R1, value2: R2): ExpressionWrapper<DB, TB, RefTuple2<DB, TB, R1, R2>>;
+    refTuple<R1 extends ReferenceExpression<DB, TB>, R2 extends ReferenceExpression<DB, TB>, R3 extends ReferenceExpression<DB, TB>>(value1: R1, value2: R2, value3: R3): ExpressionWrapper<DB, TB, RefTuple3<DB, TB, R1, R2, R3>>;
+    refTuple<R1 extends ReferenceExpression<DB, TB>, R2 extends ReferenceExpression<DB, TB>, R3 extends ReferenceExpression<DB, TB>, R4 extends ReferenceExpression<DB, TB>>(value1: R1, value2: R2, value3: R3, value4: R4): ExpressionWrapper<DB, TB, RefTuple4<DB, TB, R1, R2, R3, R4>>;
+    refTuple<R1 extends ReferenceExpression<DB, TB>, R2 extends ReferenceExpression<DB, TB>, R3 extends ReferenceExpression<DB, TB>, R4 extends ReferenceExpression<DB, TB>, R5 extends ReferenceExpression<DB, TB>>(value1: R1, value2: R2, value3: R3, value4: R4, value5: R5): ExpressionWrapper<DB, TB, RefTuple5<DB, TB, R1, R2, R3, R4, R5>>;
+    /**
+     * Creates a value tuple expression.
+     *
+     * This creates a tuple using values by default. See {@link refTuple} if you need to create
+     * tuples using column references.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where(({ eb, refTuple, tuple }) => eb(
+     *     refTuple('first_name', 'last_name'),
+     *     'in',
+     *     [
+     *       tuple('Jennifer', 'Aniston'),
+     *       tuple('Sylvester', 'Stallone')
+     *     ]
+     *   ))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   "person".*
+     * from
+     *   "person"
+     * where
+     *   ("first_name", "last_name")
+     *   in
+     *   (
+     *     ($1, $2),
+     *     ($3, $4)
+     *   )
+     * ```
+     */
+    tuple<V1, V2>(value1: V1, value2: V2): ExpressionWrapper<DB, TB, ValTuple2<V1, V2>>;
+    tuple<V1, V2, V3>(value1: V1, value2: V2, value3: V3): ExpressionWrapper<DB, TB, ValTuple3<V1, V2, V3>>;
+    tuple<V1, V2, V3, V4>(value1: V1, value2: V2, value3: V3, value4: V4): ExpressionWrapper<DB, TB, ValTuple4<V1, V2, V3, V4>>;
+    tuple<V1, V2, V3, V4, V5>(value1: V1, value2: V2, value3: V3, value4: V4, value5: V5): ExpressionWrapper<DB, TB, ValTuple5<V1, V2, V3, V4, V5>>;
+    /**
+     * Returns a literal value expression.
+     *
+     * Just like `val` but creates a literal value that gets merged in the SQL.
+     * To prevent SQL injections, only `boolean`, `number` and `null` values
+     * are accepted. If you need `string` or other literals, use `sql.lit` instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select((eb) => eb.lit(1).as('one'))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select 1 as "one" from "person"
+     * ```
+     */
+    lit<VE extends number | boolean | null>(literal: VE): ExpressionWrapper<DB, TB, VE>;
     /**
      * @deprecated Use the expression builder as a function instead.
      *
@@ -423,9 +602,47 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * @see {@link unary}
      */
     neg<RE extends ReferenceExpression<DB, TB>>(expr: RE): ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    /**
+     * Creates a `between` expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where((eb) => eb.between('age', 40, 60))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "age" between $1 and $2
+     * ```
+     */
+    between<RE extends ReferenceExpression<DB, TB>>(expr: RE, start: OperandValueExpression<DB, TB, RE>, end: OperandValueExpression<DB, TB, RE>): ExpressionWrapper<DB, TB, SqlBool>;
+    /**
+     * Creates a `between symmetric` expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where((eb) => eb.betweenSymmetric('age', 40, 60))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "age" between symmetric $1 and $2
+     * ```
+     */
+    betweenSymmetric<RE extends ReferenceExpression<DB, TB>>(expr: RE, start: OperandValueExpression<DB, TB, RE>, end: OperandValueExpression<DB, TB, RE>): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Combines two or more expressions using the logical `and` operator.
      *
+     * An empty array produces a `true` expression.
+     *
      * This function returns an {@link Expression} and can be used pretty much anywhere.
      * See the examples for a couple of possible use cases.
      *
@@ -449,15 +666,43 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * ```sql
      * select "person".*
      * from "person"
-     * where "first_name" = $1
-     * and "first_name" = $2
-     * and "first_name" = $3
+     * where (
+     *   "first_name" = $1
+     *   and "first_name" = $2
+     *   and "first_name" = $3
+     * )
+     * ```
+     *
+     * Optionally you can use the simpler object notation if you only need
+     * equality comparisons:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where((eb) => eb.and({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   }))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and "last_name" = $2
+     * )
      * ```
      */
-    and(exprs: ReadonlyArray<Expression<SqlBool>>): ExpressionWrapper<DB, TB, SqlBool>;
+    and(exprs: ReadonlyArray<OperandExpression<SqlBool>>): ExpressionWrapper<DB, TB, SqlBool>;
+    and(exprs: Readonly<FilterObject<DB, TB>>): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Combines two or more expressions using the logical `or` operator.
      *
+     * An empty array produces a `false` expression.
+     *
      * This function returns an {@link Expression} and can be used pretty much anywhere.
      * See the examples for a couple of possible use cases.
      *
@@ -469,7 +714,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * ```ts
      * db.selectFrom('person')
      *   .selectAll('person')
-     *   .where((eb) => or([
+     *   .where((eb) => eb.or([
      *     eb('first_name', '=', 'Jennifer'),
      *     eb('fist_name', '=', 'Arnold'),
      *     eb('fist_name', '=', 'Sylvester')
@@ -481,12 +726,38 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * ```sql
      * select "person".*
      * from "person"
-     * where "first_name" = $1
-     * or "first_name" = $2
-     * or "first_name" = $3
+     * where (
+     *   "first_name" = $1
+     *   or "first_name" = $2
+     *   or "first_name" = $3
+     * )
+     * ```
+     *
+     * Optionally you can use the simpler object notation if you only need
+     * equality comparisons:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where((eb) => eb.or({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   }))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   or "last_name" = $2
+     * )
      * ```
      */
-    or(exprs: ReadonlyArray<Expression<SqlBool>>): ExpressionWrapper<DB, TB, SqlBool>;
+    or(exprs: ReadonlyArray<OperandExpression<SqlBool>>): ExpressionWrapper<DB, TB, SqlBool>;
+    or(exprs: Readonly<FilterObject<DB, TB>>): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Wraps the expression in parentheses.
      *