kysely 0.16.1 → 0.16.5

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

@@ -1,13 +1,10 @@
-/// <reference types="node" />
-import * as stream from 'stream';
-import { ConnectionOptions } from 'tls';
 import { Driver } from '../../driver/driver.js';
 import { Kysely } from '../../kysely.js';
 import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
-import { DatabaseConnection } from '../../driver/database-connection.js';
+import { PostgresDialectConfig } from './postgres-dialect-config.js';
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
@@ -42,102 +39,3 @@ export declare class PostgresDialect implements Dialect {
      */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
-/**
- * Config for the PostgreSQL dialect.
- *
- * This interface is equal to `pg` library's `Pool` config:
- *
- * https://node-postgres.com/api/pool
- * https://node-postgres.com/api/client
- */
-export interface PostgresDialectConfig {
-    /**
-     * defaults process.env.PGUSER || process.env.USER.
-     */
-    user?: string;
-    /**
-     * default process.env.PGDATABASE || process.env.USER
-     */
-    database?: string;
-    /**
-     * default process.env.PGPASSWORD
-     */
-    password?: string | (() => string | Promise<string>);
-    /**
-     * default process.env.PGPORT
-     */
-    port?: number;
-    /**
-     * default process.env.PGHOST
-     */
-    host?: string;
-    /**
-     * e.g. postgres:*user:password@host:5432/database
-     */
-    connectionString?: string;
-    /**
-     * passed directly to node.TLSSocket, supports all tls.connect options
-     */
-    ssl?: boolean | ConnectionOptions;
-    /**
-     * Number of milliseconds to wait before timing out when connecting a new client
-     * by default this is 0 which means no timeout.
-     */
-    connectionTimeoutMillis?: number;
-    /**
-     * Maximum number of clients the pool should contain. by default this is set to 10.
-     */
-    max?: number;
-    /**
-     * Minimum number of clients the pool should contain
-     */
-    min?: number;
-    /**
-     * Number of milliseconds a client must sit idle in the pool and not be checked out
-     * before it is disconnected from the backend and discarded.
-     *
-     * default is 10000 (10 seconds) - set to 0 to disable auto-disconnection of idle clients.
-     */
-    idleTimeoutMillis?: number;
-    /**
-     * Default behavior is the pool will keep clients open & connected to the backend
-     * until idleTimeoutMillis expire for each client and node will maintain a ref
-     * to the socket on the client, keeping the event loop alive until all clients are closed
-     * after being idle or the pool is manually shutdown with `pool.end()`.
-     *
-     * Setting `allowExitOnIdle: true` in the config will allow the node event loop to exit
-     * as soon as all clients in the pool are idle, even if their socket is still open
-     * to the PostgreSQL server.  This can be handy in scripts & tests
-     * where you don't want to wait for your clients to go idle before your process exits.
-     */
-    allowExitOnIdle?: boolean;
-    log?: (...messages: any[]) => void;
-    /**
-     * Number of milliseconds before a statement in query will time out, default is no timeout.
-     */
-    statement_timeout?: false | number;
-    /**
-     * Number of milliseconds before terminating any session with an open idle transaction.
-     * Default is no timeout.
-     */
-    idle_in_transaction_session_timeout?: number;
-    /**
-     * Number of milliseconds before a query call will timeout, default is no timeout.
-     */
-    query_timeout?: number;
-    /**
-     * The name of the application that created this Client instance.
-     */
-    application_name?: string;
-    /**
-     * Called once for each created connection.
-     *
-     * This is a Kysely specific feature and does not come from the `pg` module.
-     */
-    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
-    keepAlive?: boolean;
-    keepAliveInitialDelayMillis?: number;
-    types?: any;
-    stream?: stream.Duplex;
-    parseInputDatesAsUTC?: boolean;
-}

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

@@ -1,6 +1,6 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
-import { PostgresDialectConfig } from './postgres-dialect.js';
+import { PostgresDialectConfig } from './postgres-dialect-config.js';
 export declare class PostgresDriver implements Driver {
     #private;
     constructor(config: PostgresDialectConfig);

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresDriver = void 0;
 const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
-const dynamic_import_js_1 = require("../../util/dynamic-import.js");
+const object_utils_js_1 = require("../../util/object-utils.js");
 const PRIVATE_RELEASE_METHOD = Symbol();
 class PostgresDriver {
     #config;
@@ -66,7 +66,16 @@ class PostgresDriver {
 exports.PostgresDriver = PostgresDriver;
 async function importPgPool() {
     try {
-        return await (0, dynamic_import_js_1.importNamedFunction)('pg', 'Pool');
+        // The imported module name must be a string literal to make
+        // some bundlers work. So don't move this code behind a helper
+        // for example.
+        const pgModule = await Promise.resolve().then(() => require('pg'));
+        if ((0, object_utils_js_1.isFunction)(pgModule.Pool)) {
+            return pgModule.Pool;
+        }
+        else {
+            return pgModule.default.Pool;
+        }
     }
     catch (error) {
         throw new Error('Postgres client not installed. Please run `npm install pg`');

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

@@ -0,0 +1,43 @@
+import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * Config for the SQLite dialect.
+ *
+ * This interface is equal to `better-sqlite3` library's `Databse` class's constructor parameters.
+ *
+ * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
+ */
+export interface SqliteDialectConfig {
+    /**
+     * The database file path.
+     *
+     * This is passed as the first argument for the [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
+     * class constructor.
+     */
+    databasePath: string;
+    /**
+     * Open the database connection in readonly mode (default: false)
+     */
+    readonly?: boolean;
+    /**
+     * If the database does not exist, an Error will be thrown instead of creating a new file.
+     * This option is ignored for in-memory, temporary, or readonly database connections
+     * (default: false)
+     */
+    fileMustExist?: boolean;
+    /**
+     * The number of milliseconds to wait when executing queries on a locked database,
+     * before throwing a SQLITE_BUSY error (default: 5000)
+     */
+    timeout?: number;
+    /**
+     * Provide a function that gets called with every SQL string executed by the database connection
+     * (default: null)
+     */
+    verbose?: (sql: string) => void;
+    /**
+     * Called once when the first query is executed.
+     *
+     * This is a Kysely specific feature and does not come from the `better-sqlite3` module.
+     */
+    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -4,7 +4,7 @@ import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
-import { DatabaseConnection } from '../../driver/database-connection.js';
+import { SqliteDialectConfig } from './sqlite-dialect-config.js';
 /**
  * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
  *
@@ -36,45 +36,3 @@ export declare class SqliteDialect implements Dialect {
      */
     createIntrospector(db: Kysely<any>): DatabaseIntrospector;
 }
-/**
- * Config for the SQLite dialect.
- *
- * This interface is equal to `better-sqlite3` library's `Databse` class's constructor parameters.
- *
- * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
- */
-export interface SqliteDialectConfig {
-    /**
-     * The database file path.
-     *
-     * This is passed as the first argument for the [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
-     * class constructor.
-     */
-    databasePath: string;
-    /**
-     * Open the database connection in readonly mode (default: false)
-     */
-    readonly?: boolean;
-    /**
-     * If the database does not exist, an Error will be thrown instead of creating a new file.
-     * This option is ignored for in-memory, temporary, or readonly database connections
-     * (default: false)
-     */
-    fileMustExist?: boolean;
-    /**
-     * The number of milliseconds to wait when executing queries on a locked database,
-     * before throwing a SQLITE_BUSY error (default: 5000)
-     */
-    timeout?: number;
-    /**
-     * Provide a function that gets called with every SQL string executed by the database connection
-     * (default: null)
-     */
-    verbose?: (sql: string) => void;
-    /**
-     * Called once when the first query is executed.
-     *
-     * This is a Kysely specific feature and does not come from the `better-sqlite3` module.
-     */
-    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
-}

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

@@ -1,6 +1,6 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
 import { Driver } from '../../driver/driver.js';
-import { SqliteDialectConfig } from './sqlite-dialect.js';
+import { SqliteDialectConfig } from './sqlite-dialect-config.js';
 export declare class SqliteDriver implements Driver {
     #private;
     constructor(config: SqliteDialectConfig);

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteDriver = void 0;
 const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
-const dynamic_import_js_1 = require("../../util/dynamic-import.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
 class SqliteDriver {
     #config;
@@ -63,7 +62,16 @@ class SqliteDriver {
 exports.SqliteDriver = SqliteDriver;
 async function importBetterSqlite3Database() {
     try {
-        return await (0, dynamic_import_js_1.importFunction)('better-sqlite3');
+        // The imported module name must be a string literal to make
+        // some bundlers work. So don't move this code behind a helper
+        // for example.
+        const sqliteModule = await Promise.resolve().then(() => require('better-sqlite3'));
+        if ((0, object_utils_js_1.isFunction)(sqliteModule)) {
+            return sqliteModule;
+        }
+        else {
+            return sqliteModule.default;
+        }
     }
     catch (error) {
         throw new Error('SQLite client not installed. Please run `npm install better-sqlite3`');

package/dist/cjs/index.d.ts

@@ -1,8 +1,11 @@
 export * from './index-nodeless.js';
 export * from './migration/file-migration-provider.js';
 export * from './dialect/sqlite/sqlite-dialect.js';
+export * from './dialect/sqlite/sqlite-dialect-config.js';
 export * from './dialect/sqlite/sqlite-driver.js';
 export * from './dialect/mysql/mysql-dialect.js';
+export * from './dialect/mysql/mysql-dialect-config.js';
 export * from './dialect/mysql/mysql-driver.js';
 export * from './dialect/postgres/postgres-driver.js';
+export * from './dialect/postgres/postgres-dialect-config.js';
 export * from './dialect/postgres/postgres-dialect.js';

package/dist/cjs/index.js

@@ -13,8 +13,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./index-nodeless.js"), exports);
 __exportStar(require("./migration/file-migration-provider.js"), exports);
 __exportStar(require("./dialect/sqlite/sqlite-dialect.js"), exports);
+__exportStar(require("./dialect/sqlite/sqlite-dialect-config.js"), exports);
 __exportStar(require("./dialect/sqlite/sqlite-driver.js"), exports);
 __exportStar(require("./dialect/mysql/mysql-dialect.js"), exports);
+__exportStar(require("./dialect/mysql/mysql-dialect-config.js"), exports);
 __exportStar(require("./dialect/mysql/mysql-driver.js"), exports);
 __exportStar(require("./dialect/postgres/postgres-driver.js"), exports);
+__exportStar(require("./dialect/postgres/postgres-dialect-config.js"), exports);
 __exportStar(require("./dialect/postgres/postgres-dialect.js"), exports);

package/dist/cjs/migration/migrator.d.ts

@@ -144,8 +144,8 @@ export interface MigratorProps {
     readonly provider: MigrationProvider;
 }
 /**
- * All migration methods ({@link MigrationModule.migrateTo | migrateTo},
- * {@link MigrationModule.migrateToLatest | migrateToLatest} etc.) never
+ * All migration methods ({@link Migrator.migrateTo | migrateTo},
+ * {@link Migrator.migrateToLatest | migrateToLatest} etc.) never
  * throw but return this object instead.
  */
 export interface MigrationResultSet {

package/dist/cjs/operation-node/primitive-value-list-node.d.ts

@@ -1,4 +1,3 @@
-import { PrimitiveValue } from '../util/object-utils.js';
 import { OperationNode } from './operation-node.js';
 /**
  * This node is basically just a performance optimization over the normal ValueListNode.
@@ -7,12 +6,12 @@ import { OperationNode } from './operation-node.js';
  */
 export interface PrimitiveValueListNode extends OperationNode {
     readonly kind: 'PrimitiveValueListNode';
-    readonly values: ReadonlyArray<PrimitiveValue>;
+    readonly values: ReadonlyArray<unknown>;
 }
 /**
  * @internal
  */
 export declare const PrimitiveValueListNode: Readonly<{
     is(node: OperationNode): node is PrimitiveValueListNode;
-    create(values: ReadonlyArray<PrimitiveValue>): PrimitiveValueListNode;
+    create(values: ReadonlyArray<unknown>): PrimitiveValueListNode;
 }>;

package/dist/cjs/operation-node/value-node.d.ts

@@ -1,8 +1,7 @@
-import { PrimitiveValue } from '../util/object-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface ValueNode extends OperationNode {
     readonly kind: 'ValueNode';
-    readonly value: PrimitiveValue;
+    readonly value: unknown;
     readonly immediate?: boolean;
 }
 /**
@@ -10,6 +9,6 @@ export interface ValueNode extends OperationNode {
  */
 export declare const ValueNode: Readonly<{
     is(node: OperationNode): node is ValueNode;
-    create(value: PrimitiveValue): ValueNode;
-    createImmediate(value: PrimitiveValue): ValueNode;
+    create(value: unknown): ValueNode;
+    createImmediate(value: unknown): ValueNode;
 }>;

package/dist/cjs/parser/complex-expression-parser.d.ts

@@ -7,3 +7,4 @@ export declare type ComplexExpression<DB, TB extends keyof DB> = AnySelectQueryB
 export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;
 export declare function parseComplexExpression(ctx: ParseContext, exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
 export declare function parseAliasedComplexExpression(ctx: ParseContext, exp: AliasedComplexExpression<any, any>): AliasNode;
+export declare function isComplexExpression(obj: unknown): obj is ComplexExpression<any, any>;

package/dist/cjs/parser/complex-expression-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAliasedComplexExpression = exports.parseComplexExpression = void 0;
+exports.isComplexExpression = exports.parseAliasedComplexExpression = exports.parseComplexExpression = void 0;
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 function parseComplexExpression(ctx, exp) {
@@ -23,3 +23,7 @@ function parseAliasedComplexExpression(ctx, exp) {
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }
 exports.parseAliasedComplexExpression = parseAliasedComplexExpression;
+function isComplexExpression(obj) {
+    return (0, operation_node_source_js_1.isOperationNodeSource)(obj) || (0, object_utils_js_1.isFunction)(obj);
+}
+exports.isComplexExpression = isComplexExpression;

package/dist/cjs/parser/default-value-parser.d.ts

@@ -1,6 +1,5 @@
 import { RawNode } from '../operation-node/raw-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
-export declare type DefaultValueExpression = PrimitiveValue | AnyRawBuilder;
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+export declare type DefaultValueExpression = unknown | RawBuilder;
 export declare function parseDefaultValueExpression(value: DefaultValueExpression): ValueNode | RawNode;

package/dist/cjs/parser/default-value-parser.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDefaultValueExpression = void 0;
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
+const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
 function parseDefaultValueExpression(value) {
-    return (0, operation_node_source_js_1.isOperationNodeSource)(value)
+    return value instanceof raw_builder_js_1.RawBuilder
         ? value.toOperationNode()
         : value_node_js_1.ValueNode.createImmediate(value);
 }

package/dist/cjs/parser/insert-values-parser.js

@@ -7,6 +7,7 @@ const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const value_parser_js_1 = require("./value-parser.js");
 const values_node_js_1 = require("../operation-node/values-node.js");
+const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 function parseInsertObjectOrList(ctx, args) {
     return parseInsertColumnsAndValues(ctx, Array.isArray(args) ? args : [args]);
 }
@@ -40,8 +41,8 @@ function parseRowValues(ctx, row, columns) {
             rowValues[columnIdx] = value;
         }
     }
-    if (rowValues.every(object_utils_js_1.isPrimitive)) {
-        return primitive_value_list_node_js_1.PrimitiveValueListNode.create(rowValues);
+    if (rowValues.some(complex_expression_parser_js_1.isComplexExpression)) {
+        return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, value_parser_js_1.parseValueExpression)(ctx, it)));
     }
-    return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, value_parser_js_1.parseValueExpression)(ctx, it)));
+    return primitive_value_list_node_js_1.PrimitiveValueListNode.create(rowValues);
 }

package/dist/cjs/parser/reference-parser.d.ts

@@ -2,7 +2,6 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
@@ -13,8 +12,8 @@ import { SelectType } from '../util/column-type.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
-declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : PrimitiveValue;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : unknown;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : unknown;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;

package/dist/cjs/parser/value-parser.d.ts

@@ -1,11 +1,10 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
-export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, PrimitiveValue>): ValueExpressionNode;
-export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, PrimitiveValue>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
+export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;

package/dist/cjs/parser/value-parser.js

@@ -16,16 +16,15 @@ function parseValueExpressionOrList(ctx, arg) {
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
 function parseValueExpression(ctx, exp) {
-    if ((0, object_utils_js_1.isPrimitive)(exp)) {
-        return value_node_js_1.ValueNode.create(exp);
+    if ((0, complex_expression_parser_js_1.isComplexExpression)(exp)) {
+        return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
     }
-    return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
+    return value_node_js_1.ValueNode.create(exp);
 }
 exports.parseValueExpression = parseValueExpression;
 function parseValueExpressionList(ctx, arg) {
-    if (arg.every(object_utils_js_1.isPrimitive)) {
-        // Optimization for large lists of primitive values.
-        return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);
+    if (arg.some(complex_expression_parser_js_1.isComplexExpression)) {
+        return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
     }
-    return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
+    return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);
 }

package/dist/cjs/plugin/camel-case/camel-case-plugin.js

@@ -111,5 +111,5 @@ class CamelCasePlugin {
 }
 exports.CamelCasePlugin = CamelCasePlugin;
 function canMap(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && !(obj instanceof Date) && !Buffer.isBuffer(obj);
+    return (0, object_utils_js_1.isObject)(obj) && !(0, object_utils_js_1.isDate)(obj) && !(0, object_utils_js_1.isBuffer)(obj);
 }

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

@@ -3,6 +3,8 @@ import { TableExpression, TableExpressionDatabase, TableExpressionTables } from
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { FunctionBuilder } from './function-builder.js';
+import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
     constructor(props: ExpressionBuilderProps);
@@ -44,6 +46,8 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * The query builder returned by this method is typed in a way that you can refer to
      * all tables of the parent query in addition to the subquery's tables.
      *
+     * This method accepts all the same inputs as {@link QueryCreator.selectFrom}.
+     *
      * ### Examples
      *
      * This example shows that you can refer to both `pet.owner_id` and `person.id`
@@ -86,6 +90,44 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * See {@link QueryCreator.withSchema}
      */
     withSchema(schema: string): ExpressionBuilder<DB, TB>;
+    /**
+     * See {@link QueryCreator.raw}.
+     */
+    raw<T = unknown>(sql: string, parameters?: unknown[]): RawBuilder<T>;
+    /**
+     * This can be used to reference columns.
+     *
+     * ### Examples
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
+     *
+     * In the next example we use `ref` in a raw expression. Unless you
+     * want to be as type-safe as possible, this is probably overkill:
+     *
+     * ```ts
+     * db.update('pet').set({
+     *   name: (eb) => eb.raw('concat(?, ?)', [
+     *     eb.ref('pet.name'),
+     *     suffix,
+     *   ])
+     * })
+     * ```
+     */
+    ref<RE extends StringReference<DB, TB>>(reference: RE): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
 }
 export interface ExpressionBuilderProps {
     readonly executor: NoopQueryExecutor;

package/dist/cjs/query-builder/expression-builder.js

@@ -8,6 +8,7 @@ const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugi
 const query_id_js_1 = require("../util/query-id.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const function_builder_js_1 = require("./function-builder.js");
+const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
 class ExpressionBuilder {
     #props;
     constructor(props) {
@@ -64,5 +65,52 @@ class ExpressionBuilder {
             executor: this.#props.executor.withPluginAtFront(new with_schema_plugin_js_1.WithSchemaPlugin(schema)),
         });
     }
+    /**
+     * See {@link QueryCreator.raw}.
+     */
+    raw(sql, parameters) {
+        return new raw_builder_js_1.RawBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#props.executor,
+            sql,
+            parameters,
+        });
+    }
+    /**
+     * This can be used to reference columns.
+     *
+     * ### Examples
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict(oc => oc
+     *     .column('id')
+     *     .doUpdateSet({
+     *       first_name: (eb) => eb.ref('excluded.first_name'),
+     *       last_name: (eb) => eb.ref('excluded.last_name')
+     *     })
+     *   )
+     * ```
+     *
+     * In the next example we use `ref` in a raw expression. Unless you
+     * want to be as type-safe as possible, this is probably overkill:
+     *
+     * ```ts
+     * db.update('pet').set({
+     *   name: (eb) => eb.raw('concat(?, ?)', [
+     *     eb.ref('pet.name'),
+     *     suffix,
+     *   ])
+     * })
+     * ```
+     */
+    ref(reference) {
+        return this.raw('??', [reference]);
+    }
 }
 exports.ExpressionBuilder = ExpressionBuilder;