kysely 0.26.2 → 0.27.0

package/dist/esm/dialect/mssql/mssql-introspector.js

@@ -0,0 +1,94 @@
+/// <reference types="./mssql-introspector.d.ts" />
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { freeze } from '../../util/object-utils.js';
+export class MssqlIntrospector {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async getSchemas() {
+        return await this.#db.selectFrom('sys.schemas').select('name').execute();
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        const rawColumns = await this.#db
+            .selectFrom('sys.tables as tables')
+            .leftJoin('sys.schemas as table_schemas', 'table_schemas.schema_id', 'tables.schema_id')
+            .innerJoin('sys.columns as columns', 'columns.object_id', 'tables.object_id')
+            .innerJoin('sys.types as types', 'types.system_type_id', 'columns.system_type_id')
+            .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
+            .$if(!options.withInternalKyselyTables, (qb) => qb
+            .where('tables.name', '!=', DEFAULT_MIGRATION_TABLE)
+            .where('tables.name', '!=', DEFAULT_MIGRATION_LOCK_TABLE))
+            .select([
+            'tables.name as table_name',
+            (eb) => eb
+                .ref('tables.type')
+                .$castTo()
+                .as('table_type'),
+            'table_schemas.name as table_schema_name',
+            'columns.default_object_id as column_default_object_id',
+            'columns.generated_always_type_desc as column_generated_always_type',
+            'columns.is_computed as column_is_computed',
+            'columns.is_identity as column_is_identity',
+            'columns.is_nullable as column_is_nullable',
+            'columns.is_rowguidcol as column_is_rowguidcol',
+            'columns.name as column_name',
+            'types.is_nullable as type_is_nullable',
+            'types.name as type_name',
+            'type_schemas.name as type_schema_name',
+        ])
+            .unionAll(this.#db
+            .selectFrom('sys.views as views')
+            .leftJoin('sys.schemas as view_schemas', 'view_schemas.schema_id', 'views.schema_id')
+            .innerJoin('sys.columns as columns', 'columns.object_id', 'views.object_id')
+            .innerJoin('sys.types as types', 'types.system_type_id', 'columns.system_type_id')
+            .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
+            .select([
+            'views.name as table_name',
+            'views.type as table_type',
+            'view_schemas.name as table_schema_name',
+            'columns.default_object_id as column_default_object_id',
+            'columns.generated_always_type_desc as column_generated_always_type',
+            'columns.is_computed as column_is_computed',
+            'columns.is_identity as column_is_identity',
+            'columns.is_nullable as column_is_nullable',
+            'columns.is_rowguidcol as column_is_rowguidcol',
+            'columns.name as column_name',
+            'types.is_nullable as type_is_nullable',
+            'types.name as type_name',
+            'type_schemas.name as type_schema_name',
+        ]))
+            .orderBy('table_schema_name')
+            .orderBy('table_name')
+            .orderBy('column_name')
+            .execute();
+        const tableDictionary = {};
+        for (const rawColumn of rawColumns) {
+            const key = `${rawColumn.table_schema_name}.${rawColumn.table_name}`;
+            const table = (tableDictionary[key] ||= freeze({
+                columns: [],
+                isView: rawColumn.table_type === 'V ',
+                name: rawColumn.table_name,
+                schema: rawColumn.table_schema_name ?? undefined,
+            }));
+            table.columns.push(freeze({
+                dataType: rawColumn.type_name,
+                dataTypeSchema: rawColumn.type_schema_name ?? undefined,
+                hasDefaultValue: rawColumn.column_default_object_id > 0 ||
+                    rawColumn.column_generated_always_type !== 'NOT_APPLICABLE' ||
+                    rawColumn.column_is_identity ||
+                    rawColumn.column_is_computed ||
+                    rawColumn.column_is_rowguidcol,
+                isAutoIncrementing: rawColumn.column_is_identity,
+                isNullable: rawColumn.column_is_nullable && rawColumn.type_is_nullable,
+                name: rawColumn.column_name,
+            }));
+        }
+        return Object.values(tableDictionary);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+}

package/dist/esm/dialect/mssql/mssql-query-compiler.d.ts

@@ -0,0 +1,11 @@
+import { AddColumnNode } from '../../operation-node/add-column-node.js';
+import { AlterTableColumnAlterationNode } from '../../operation-node/alter-table-node.js';
+import { DropColumnNode } from '../../operation-node/drop-column-node.js';
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export declare class MssqlQueryCompiler extends DefaultQueryCompiler {
+    protected getCurrentParameterPlaceholder(): string;
+    protected compileColumnAlterations(columnAlterations: readonly AlterTableColumnAlterationNode[]): void;
+    protected visitAddColumn(node: AddColumnNode): void;
+    protected visitDropColumn(node: DropColumnNode): void;
+    protected announcesNewColumnDataType(): boolean;
+}

package/dist/esm/dialect/mssql/mssql-query-compiler.js

@@ -0,0 +1,61 @@
+/// <reference types="./mssql-query-compiler.d.ts" />
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export class MssqlQueryCompiler extends DefaultQueryCompiler {
+    getCurrentParameterPlaceholder() {
+        return `@${this.numParameters}`;
+    }
+    // mssql allows multi-column alterations in a single statement,
+    // but you can only use the command keyword/s once.
+    // it also doesn't support multiple kinds of commands in the same
+    // alter table statement, but we compile that anyway for the sake
+    // of WYSIWYG.
+    compileColumnAlterations(columnAlterations) {
+        const nodesByKind = {};
+        for (const columnAlteration of columnAlterations) {
+            if (!nodesByKind[columnAlteration.kind]) {
+                nodesByKind[columnAlteration.kind] = [];
+            }
+            nodesByKind[columnAlteration.kind].push(columnAlteration);
+        }
+        let first = true;
+        if (nodesByKind.AddColumnNode) {
+            this.append('add ');
+            this.compileList(nodesByKind.AddColumnNode);
+            first = false;
+        }
+        // multiple of these are not really supported by mssql,
+        // but for the sake of WYSIWYG.
+        if (nodesByKind.AlterColumnNode) {
+            if (!first)
+                this.append(', ');
+            this.compileList(nodesByKind.AlterColumnNode);
+        }
+        if (nodesByKind.DropColumnNode) {
+            if (!first)
+                this.append(', ');
+            this.append('drop column ');
+            this.compileList(nodesByKind.DropColumnNode);
+        }
+        // not really supported by mssql, but for the sake of WYSIWYG.
+        if (nodesByKind.ModifyColumnNode) {
+            if (!first)
+                this.append(', ');
+            this.compileList(nodesByKind.ModifyColumnNode);
+        }
+        // not really supported by mssql, but for the sake of WYSIWYG.
+        if (nodesByKind.RenameColumnNode) {
+            if (!first)
+                this.append(', ');
+            this.compileList(nodesByKind.RenameColumnNode);
+        }
+    }
+    visitAddColumn(node) {
+        this.visitNode(node.column);
+    }
+    visitDropColumn(node) {
+        this.visitNode(node.column);
+    }
+    announcesNewColumnDataType() {
+        return false;
+    }
+}

package/dist/esm/dialect/mysql/mysql-query-compiler.d.ts

@@ -1,3 +1,4 @@
+import { CreateIndexNode } from '../../operation-node/create-index-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
     protected getCurrentParameterPlaceholder(): string;
@@ -8,4 +9,5 @@ export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected sanitizeIdentifier(identifier: string): string;
+    protected visitCreateIndex(node: CreateIndexNode): void;
 }

package/dist/esm/dialect/mysql/mysql-query-compiler.js

@@ -26,4 +26,32 @@ export class MysqlQueryCompiler extends DefaultQueryCompiler {
     sanitizeIdentifier(identifier) {
         return identifier.replace(ID_WRAP_REGEX, '``');
     }
+    visitCreateIndex(node) {
+        this.append('create ');
+        if (node.unique) {
+            this.append('unique ');
+        }
+        this.append('index ');
+        if (node.ifNotExists) {
+            this.append('if not exists ');
+        }
+        this.visitNode(node.name);
+        if (node.using) {
+            this.append(' using ');
+            this.visitNode(node.using);
+        }
+        if (node.table) {
+            this.append(' on ');
+            this.visitNode(node.table);
+        }
+        if (node.columns) {
+            this.append(' (');
+            this.compileList(node.columns);
+            this.append(')');
+        }
+        if (node.where) {
+            this.append(' ');
+            this.visitNode(node.where);
+        }
+    }
 }

package/dist/esm/dialect/postgres/postgres-driver.js

@@ -26,7 +26,7 @@ export class PostgresDriver {
             // The driver must take care of calling `onCreateConnection` when a new
             // connection is created. The `pg` module doesn't provide an async hook
             // for the connection creation. We need to call the method explicitly.
-            if (this.#config?.onCreateConnection) {
+            if (this.#config.onCreateConnection) {
                 await this.#config.onCreateConnection(connection);
             }
         }

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

@@ -1,7 +1,7 @@
 import { Kysely } from '../../kysely.js';
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
 import { MigrationLockOptions } from '../dialect-adapter.js';
-export declare class SqliteAdapter implements DialectAdapterBase {
+export declare class SqliteAdapter extends DialectAdapterBase {
     /**
      * Whether or not this dialect supports transactional DDL.
      *

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

@@ -1,5 +1,6 @@
 /// <reference types="./sqlite-adapter.d.ts" />
-export class SqliteAdapter {
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export class SqliteAdapter extends DialectAdapterBase {
     get supportsTransactionalDdl() {
         return false;
     }

package/dist/esm/dialect/sqlite/sqlite-dialect-config.d.ts

@@ -37,4 +37,5 @@ export interface SqliteStatement {
         changes: number | bigint;
         lastInsertRowid: number | bigint;
     };
+    iterate(parameters: ReadonlyArray<unknown>): IterableIterator<unknown>;
 }

package/dist/esm/dialect/sqlite/sqlite-driver.js

@@ -1,4 +1,5 @@
 /// <reference types="./sqlite-driver.d.ts" />
+import { SelectQueryNode } from '../../operation-node/select-query-node.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { freeze, isFunction } from '../../util/object-utils.js';
 export class SqliteDriver {
@@ -67,8 +68,20 @@ class SqliteConnection {
             });
         }
     }
-    async *streamQuery() {
-        throw new Error("Sqlite driver doesn't support streaming");
+    async *streamQuery(compiledQuery, _chunkSize) {
+        const { sql, parameters, query } = compiledQuery;
+        const stmt = this.#db.prepare(sql);
+        if (SelectQueryNode.is(query)) {
+            const iter = stmt.iterate(parameters);
+            for (const row of iter) {
+                yield {
+                    rows: [row],
+                };
+            }
+        }
+        else {
+            throw new Error('Sqlite driver only supports streaming of select queries');
+        }
     }
 }
 class ConnectionMutex {

package/dist/esm/driver/driver.d.ts

@@ -40,5 +40,5 @@ export interface Driver {
 export interface TransactionSettings {
     readonly isolationLevel?: IsolationLevel;
 }
-export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable"];
+export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable", "snapshot"];
 export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;

package/dist/esm/driver/driver.js

@@ -4,4 +4,5 @@ export const TRANSACTION_ISOLATION_LEVELS = [
     'read committed',
     'repeatable read',
     'serializable',
+    'snapshot',
 ];

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

@@ -84,16 +84,20 @@ export class RuntimeDriver {
     #addLogging(connection) {
         const executeQuery = connection.executeQuery;
         connection.executeQuery = async (compiledQuery) => {
+            let caughtError;
             const startTime = performanceNow();
             try {
                 return await executeQuery.call(connection, compiledQuery);
             }
             catch (error) {
+                caughtError = error;
                 await this.#logError(error, compiledQuery, startTime);
                 throw error;
             }
             finally {
-                await this.#logQuery(compiledQuery, startTime);
+                if (!caughtError) {
+                    await this.#logQuery(compiledQuery, startTime);
+                }
             }
         };
     }

package/dist/esm/driver/single-connection-provider.js

@@ -1,4 +1,5 @@
 /// <reference types="./single-connection-provider.d.ts" />
+const ignoreError = () => { };
 export class SingleConnectionProvider {
     #connection;
     #runningPromise;
@@ -7,17 +8,15 @@ export class SingleConnectionProvider {
     }
     async provideConnection(consumer) {
         while (this.#runningPromise) {
-            await this.#runningPromise;
+            await this.#runningPromise.catch(ignoreError);
         }
-        const promise = this.#run(consumer);
-        this.#runningPromise = promise
-            .then(() => {
-            this.#runningPromise = undefined;
-        })
-            .catch(() => {
+        // `#runningPromise` must be set to undefined before it's
+        // resolved or rejected. Otherwise the while loop above
+        // will misbehave.
+        this.#runningPromise = this.#run(consumer).finally(() => {
             this.#runningPromise = undefined;
         });
-        return promise;
+        return this.#runningPromise;
     }
     // Run the runner in an async function to make sure it doesn't
     // throw synchronous errors.

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

@@ -3,17 +3,18 @@ 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, FilterObject, OperandValueExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { BinaryOperatorExpression, 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 { IsNever, SqlBool } from '../util/type-utils.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';
+import { Selectable } from '../util/column-type.js';
+import { KyselyTypeError } from '../util/type-error.js';
 export interface ExpressionBuilder<DB, TB extends keyof DB> {
     /**
      * Creates a binary expression.
@@ -89,7 +90,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      *   ))
      * ```
      */
-    <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>>;
+    <RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: OP, rhs: VE): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
     /**
      * Returns a copy of `this` expression builder, for destructuring purposes.
      *
@@ -195,16 +196,6 @@ 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.
      *
@@ -258,13 +249,14 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      */
     case(): CaseBuilder<DB, TB>;
     case<C extends SimpleReferenceExpression<DB, TB>>(column: C): CaseBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>;
-    case<O>(expression: Expression<O>): CaseBuilder<DB, TB, O>;
+    case<E extends Expression<any>>(expression: E): CaseBuilder<DB, TB, ExtractTypeFromValueExpression<E>>;
     /**
      * This method can be used to reference columns within the query's context. For
      * a non-type-safe version of this method see {@link sql}'s version.
      *
      * Additionally, this method can be used to reference nested JSON properties or
-     * array elements. See {@link JSONPathBuilder} for more information.
+     * array elements. See {@link JSONPathBuilder} for more information. For regular
+     * JSON path expressions you can use {@link jsonPath}.
      *
      * ### Examples
      *
@@ -342,6 +334,57 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      */
     ref<RE extends StringReference<DB, TB>>(reference: RE): ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
     ref<RE extends StringReference<DB, TB>>(reference: RE, op: JSONOperatorWith$): JSONPathBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    /**
+     * Creates a JSON path expression with provided column as root document (the $).
+     *
+     * For a JSON reference expression, see {@link ref}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .set('experience', (eb) => eb.fn('json_set', [
+     *     'experience',
+     *     eb.jsonPath<'experience'>().at('last').key('title'),
+     *     eb.val('CEO')
+     *   ]))
+     *   .where('id', '=', id)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * update `person`
+     * set `experience` = json_set(`experience`, '$[last].title', ?)
+     * where `id` = ?
+     * ```
+     */
+    jsonPath<$ extends StringReference<DB, TB> = never>(): IsNever<$> extends true ? KyselyTypeError<"You must provide a column reference as this method's $ generic"> : JSONPathBuilder<ExtractTypeFromReferenceExpression<DB, TB, $>>;
+    /**
+     * Creates a table reference.
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select(eb => [
+     *     'person.id',
+     *     sql<Pet[]>`jsonb_agg(${eb.table('pet')})`.as('pets')
+     *   ])
+     *   .groupBy('person.id')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."id", jsonb_agg("pet") as "pets"
+     * from "person"
+     * inner join "pet" on "pet"."owner_id" = "person"."id"
+     * group by "person"."id"
+     * ```
+     */
+    table<T extends TB & string>(table: T): ExpressionWrapper<DB, TB, Selectable<DB[T]>>;
     /**
      * Returns a value expression.
      *
@@ -502,56 +545,6 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * ```
      */
     lit<VE extends number | boolean | null>(literal: VE): ExpressionWrapper<DB, TB, VE>;
-    /**
-     * @deprecated Use the expression builder as a function instead.
-     *
-     * Before:
-     *
-     * ```ts
-     * where((eb) => eb.cmpr('first_name', '=', 'Jennifer'))
-     * ```
-     *
-     * After:
-     *
-     * ```ts
-     * where((eb) => eb('first_name', '=', 'Jennifer'))
-     * ```
-     *
-     * or
-     *
-     * ```ts
-     * where(({ eb }) => eb('first_name', '=', 'Jennifer'))
-     * ```
-     */
-    cmpr<O extends SqlBool = SqlBool, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): ExpressionWrapper<DB, TB, O>;
-    /**
-     * @deprecated Use the expression builder as a function instead.
-     *
-     * Before:
-     *
-     * ```ts
-     * set((eb) => ({
-     *   age: eb.bxp('age', '+', 10)
-     * }))
-     * ```
-     *
-     * After:
-     *
-     * ```ts
-     * set((eb) => ({
-     *   age: eb('age', '+', 10)
-     * }))
-     * ```
-     *
-     * or
-     *
-     * ```ts
-     * set(({ eb }) => ({
-     *   age: eb('age', '+', 10)
-     * }))
-     * ```
-     */
-    bxp<RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression>(lhs: RE, op: OP, rhs: OperandValueExpression<DB, TB, RE>): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
     /**
      * Creates an unary expression.
      *
@@ -619,7 +612,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * 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>;
+    between<RE extends ReferenceExpression<DB, TB>, SE extends OperandValueExpression<DB, TB, RE>, EE extends OperandValueExpression<DB, TB, RE>>(expr: RE, start: SE, end: EE): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Creates a `between symmetric` expression.
      *
@@ -637,7 +630,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * 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>;
+    betweenSymmetric<RE extends ReferenceExpression<DB, TB>, SE extends OperandValueExpression<DB, TB, RE>, EE extends OperandValueExpression<DB, TB, RE>>(expr: RE, start: SE, end: EE): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Combines two or more expressions using the logical `and` operator.
      *
@@ -696,8 +689,8 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * )
      * ```
      */
-    and(exprs: ReadonlyArray<OperandExpression<SqlBool>>): ExpressionWrapper<DB, TB, SqlBool>;
-    and(exprs: Readonly<FilterObject<DB, TB>>): ExpressionWrapper<DB, TB, SqlBool>;
+    and<E extends OperandExpression<SqlBool>>(exprs: ReadonlyArray<E>): ExpressionWrapper<DB, TB, SqlBool>;
+    and<E extends Readonly<FilterObject<DB, TB>>>(exprs: E): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Combines two or more expressions using the logical `or` operator.
      *
@@ -756,8 +749,8 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * )
      * ```
      */
-    or(exprs: ReadonlyArray<OperandExpression<SqlBool>>): ExpressionWrapper<DB, TB, SqlBool>;
-    or(exprs: Readonly<FilterObject<DB, TB>>): ExpressionWrapper<DB, TB, SqlBool>;
+    or<E extends OperandExpression<SqlBool>>(exprs: ReadonlyArray<E>): ExpressionWrapper<DB, TB, SqlBool>;
+    or<E extends Readonly<FilterObject<DB, TB>>>(exprs: E): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Wraps the expression in parentheses.
      *
@@ -797,7 +790,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * where ("age" = $1 or "age" = $2) and ("first_name" = $3 or "first_name" = $4)
      * ```
      */
-    parens<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>>;
+    parens<RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: OP, rhs: VE): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
     parens<T>(expr: Expression<T>): ExpressionWrapper<DB, TB, T>;
     /**
      * See {@link QueryCreator.withSchema}

package/dist/esm/expression/expression-builder.js

@@ -1,7 +1,7 @@
 /// <reference types="./expression-builder.d.ts" />
 import { createSelectQueryBuilder, } from '../query-builder/select-query-builder.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { parseTableExpressionOrList, } from '../parser/table-parser.js';
+import { parseTableExpressionOrList, parseTable, } from '../parser/table-parser.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { createQueryId } from '../util/query-id.js';
 import { createFunctionModule, } from '../query-builder/function-module.js';
@@ -11,7 +11,7 @@ import { ParensNode } from '../operation-node/parens-node.js';
 import { ExpressionWrapper } from './expression-wrapper.js';
 import { OperatorNode, } from '../operation-node/operator-node.js';
 import { parseUnaryOperation } from '../parser/unary-operation-parser.js';
-import { parseSafeImmediateValue, parseValueExpression, parseValueExpressionOrList, } from '../parser/value-parser.js';
+import { parseSafeImmediateValue, parseValueExpression, } from '../parser/value-parser.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
 import { CaseBuilder } from '../query-builder/case-builder.js';
 import { CaseNode } from '../operation-node/case-node.js';
@@ -19,8 +19,8 @@ import { isReadonlyArray, isUndefined } from '../util/object-utils.js';
 import { JSONPathBuilder } from '../query-builder/json-path-builder.js';
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
 import { AndNode } from '../operation-node/and-node.js';
-import { parseSelectArg, } from '../parser/select-parser.js';
 import { TupleNode } from '../operation-node/tuple-node.js';
+import { JSONPathNode } from '../operation-node/json-path-node.js';
 export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
     function binary(lhs, op, rhs) {
         return new ExpressionWrapper(parseValueBinaryOperation(lhs, op, rhs));
@@ -38,13 +38,6 @@ export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
                 queryNode: SelectQueryNode.createFrom(parseTableExpressionOrList(table)),
             });
         },
-        selectNoFrom(selection) {
-            return createSelectQueryBuilder({
-                queryId: createQueryId(),
-                executor,
-                queryNode: SelectQueryNode.cloneWithSelections(SelectQueryNode.create(), parseSelectArg(selection)),
-            });
-        },
         case(reference) {
             return new CaseBuilder({
                 node: CaseNode.create(isUndefined(reference)
@@ -58,8 +51,14 @@ export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
             }
             return new JSONPathBuilder(parseJSONReference(reference, op));
         },
+        jsonPath() {
+            return new JSONPathBuilder(JSONPathNode.create());
+        },
+        table(table) {
+            return new ExpressionWrapper(parseTable(table));
+        },
         val(value) {
-            return new ExpressionWrapper(parseValueExpressionOrList(value));
+            return new ExpressionWrapper(parseValueExpression(value));
         },
         refTuple(...values) {
             return new ExpressionWrapper(TupleNode.create(values.map(parseReferenceExpression)));
@@ -70,14 +69,6 @@ export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
         lit(value) {
             return new ExpressionWrapper(parseSafeImmediateValue(value));
         },
-        // @deprecated
-        cmpr(lhs, op, rhs) {
-            return new ExpressionWrapper(parseValueBinaryOperation(lhs, op, rhs));
-        },
-        // @deprecated
-        bxp(lhs, op, rhs) {
-            return new ExpressionWrapper(parseValueBinaryOperation(lhs, op, rhs));
-        },
         unary,
         not(expr) {
             return unary('not', expr);