kysely 0.11.0 → 0.11.4

package/dist/esm/kysely.d.ts

@@ -10,7 +10,7 @@ import { DatabaseIntrospector } from './introspection/database-introspector.js';
 import { Driver, IsolationLevel } from './driver/driver.js';
 import { ParseContext } from './parser/parse-context.js';
 import { FunctionBuilder } from './query-builder/function-builder.js';
-import { LogLevel } from './util/log.js';
+import { LogConfig } from './util/log.js';
 /**
  * The main Kysely class.
  *
@@ -235,17 +235,33 @@ export interface KyselyConfig {
     readonly dialect: Dialect;
     readonly plugins?: KyselyPlugin[];
     /**
-     * A list of log levels to log.
+     * A list of log levels to log or a custom logger function.
      *
      * Currently there's only two levels: `query` and `error`.
      * This will be expanded based on user feedback later.
      *
-     * Log levels:
+     * @example
+     * ```ts
+     * const db = new Kysely<Database>({
+     *   dialect: new PostgresDialect(postgresConfig),
+     *   log: ['query', 'error']
+     * })
+     * ```
      *
-     *  - query: Log each query's SQL and duration using console.log
-     *  - error: Log all query errors using console.error
+     * @example
+     * ```ts
+     * const db = new Kysely<Database>({
+     *   dialect: new PostgresDialect(postgresConfig),
+     *   log(event): void {
+     *     if (event.level === 'query') {
+     *       console.log(event.query.sql)
+     *       console.log(event.query.parameters)
+     *     }
+     *   }
+     * })
+     * ```
      */
-    readonly log?: ReadonlyArray<LogLevel>;
+    readonly log?: LogConfig;
 }
 export declare class ConnectionBuilder<DB> {
     #private;

package/dist/esm/operation-node/alias-node.d.ts

@@ -5,7 +5,7 @@ import { RawNode } from './raw-node.js';
 import { ReferenceNode } from './reference-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { TableNode } from './table-node.js';
-export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | RawNode | SelectQueryNode;
+export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | SelectQueryNode | RawNode;
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
     readonly node: AliasNodeChild;

package/dist/esm/operation-node/operation-node-utils.d.ts

@@ -14,4 +14,4 @@ import { ValueNode } from './value-node.js';
 export declare type ReferenceExpressionNode = ColumnNode | ReferenceNode | SelectQueryNode | RawNode;
 export declare type ValueExpressionNode = ValueNode | ValueListNode | PrimitiveValueListNode | ReferenceExpressionNode;
 export declare type TableExpressionNode = TableNode | AliasNode;
-export declare type FilterExpressionNode = FilterNode | AndNode | OrNode | ParensNode;
+export declare type FilterExpressionNode = FilterNode | AndNode | OrNode | ParensNode | RawNode;

package/dist/esm/parser/filter-parser.d.ts

@@ -12,3 +12,4 @@ export declare function parseOnFilter(ctx: ParseContext, args: any[]): FilterExp
 export declare function parseReferenceFilter(ctx: ParseContext, lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
 export declare function parseExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
 export declare function parseNotExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
+export declare function parseFilter(ctx: ParseContext, type: 'where' | 'having' | 'on', args: any[]): FilterExpressionNode;

package/dist/esm/parser/filter-parser.js

@@ -1,5 +1,5 @@
 import { FilterNode } from '../operation-node/filter-node.js';
-import { isBoolean, isFunction, isNull, isString, } from '../util/object-utils.js';
+import { freeze, isBoolean, isFunction, isNull, isString, } from '../util/object-utils.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { OperatorNode, OPERATORS, } from '../operation-node/operator-node.js';
@@ -9,37 +9,13 @@ import { parseValueExpressionOrList, } from './value-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
 export function parseWhereFilter(ctx, args) {
-    if (args.length === 3) {
-        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
-    }
-    else if (args.length === 1 && isFunction(args[0])) {
-        return parseWhereGroup(ctx, args[0]);
-    }
-    else {
-        throw new Error(`invalid arguments passed to a where method ${JSON.stringify(args)}`);
-    }
+    return parseFilter(ctx, 'where', args);
 }
 export function parseHavingFilter(ctx, args) {
-    if (args.length === 3) {
-        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
-    }
-    else if (args.length === 1 && isFunction(args[0])) {
-        return parseHavingGroup(ctx, args[0]);
-    }
-    else {
-        throw new Error(`invalid arguments passed to a having method ${JSON.stringify(args)}`);
-    }
+    return parseFilter(ctx, 'having', args);
 }
 export function parseOnFilter(ctx, args) {
-    if (args.length === 3) {
-        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
-    }
-    else if (args.length === 1 && isFunction(args[0])) {
-        return parseOnGroup(ctx, args[0]);
-    }
-    else {
-        throw new Error(`invalid arguments passed to an on method ${JSON.stringify(args)}`);
-    }
+    return parseFilter(ctx, 'on', args);
 }
 export function parseReferenceFilter(ctx, lhs, op, rhs) {
     return FilterNode.create(parseReferenceExpression(ctx, lhs), parseFilterOperator(op), parseReferenceExpression(ctx, rhs));
@@ -50,6 +26,24 @@ export function parseExistFilter(ctx, arg) {
 export function parseNotExistFilter(ctx, arg) {
     return parseExistExpression(ctx, 'not exists', arg);
 }
+export function parseFilter(ctx, type, args) {
+    if (args.length === 3) {
+        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
+    }
+    else if (args.length === 1) {
+        const arg = args[0];
+        if (isFunction(arg)) {
+            return GROUP_PARSERS[type](ctx, arg);
+        }
+        else if (isOperationNodeSource(arg)) {
+            const node = arg.toOperationNode();
+            if (RawNode.is(node)) {
+                return node;
+            }
+        }
+    }
+    throw new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
+}
 function parseThreeArgFilter(ctx, left, op, right) {
     if ((op === 'is' || op === 'is not') && (isNull(right) || isBoolean(right))) {
         return parseIsFilter(ctx, left, op, right);
@@ -70,30 +64,6 @@ function parseFilterOperator(op) {
     }
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
-function parseWhereGroup(ctx, callback) {
-    const query = callback(ctx.createSelectQueryBuilder([]));
-    const queryNode = query.toOperationNode();
-    if (!queryNode.where) {
-        throw new Error('no `where*` methods called insided a group callback');
-    }
-    return ParensNode.create(queryNode.where.where);
-}
-function parseHavingGroup(ctx, callback) {
-    const query = callback(ctx.createSelectQueryBuilder([]));
-    const queryNode = query.toOperationNode();
-    if (!queryNode.having) {
-        throw new Error('no `having*` methods called insided a group callback');
-    }
-    return ParensNode.create(queryNode.having.having);
-}
-function parseOnGroup(ctx, callback) {
-    const joinBuilder = callback(ctx.createJoinBuilder('InnerJoin', 'table'));
-    const joinNode = joinBuilder.toOperationNode();
-    if (!joinNode.on) {
-        throw new Error('no `on*` methods called insided a group callback');
-    }
-    return ParensNode.create(joinNode.on.on);
-}
 function parseExistExpression(ctx, type, arg) {
     const node = isFunction(arg)
         ? arg(ctx.createExpressionBuilder()).toOperationNode()
@@ -103,3 +73,29 @@ function parseExistExpression(ctx, type, arg) {
     }
     return FilterNode.create(undefined, OperatorNode.create(type), node);
 }
+const GROUP_PARSERS = freeze({
+    where(ctx, callback) {
+        const query = callback(ctx.createSelectQueryBuilder([]));
+        const queryNode = query.toOperationNode();
+        if (!queryNode.where) {
+            throw new Error('no `where` methods called insided a group callback');
+        }
+        return ParensNode.create(queryNode.where.where);
+    },
+    having(ctx, callback) {
+        const query = callback(ctx.createSelectQueryBuilder([]));
+        const queryNode = query.toOperationNode();
+        if (!queryNode.having) {
+            throw new Error('no `having` methods called insided a group callback');
+        }
+        return ParensNode.create(queryNode.having.having);
+    },
+    on(ctx, callback) {
+        const joinBuilder = callback(ctx.createJoinBuilder('InnerJoin', 'table'));
+        const joinNode = joinBuilder.toOperationNode();
+        if (!joinNode.on) {
+            throw new Error('no `on` methods called insided a group callback');
+        }
+        return ParensNode.create(joinNode.on.on);
+    },
+});

package/dist/esm/parser/insert-values-parser.d.ts

@@ -3,13 +3,14 @@ import { InsertValuesNode } from '../operation-node/insert-query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { AnyQueryBuilder, AnyRawBuilder, GeneratedPlaceholder } from '../util/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, GeneratedPlaceholder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
 import { PrimitiveValue } from '../util/object-utils.js';
+import { ParseContext } from './parse-context.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
-    [C in keyof DB[TB]]: InsertValueExpression<DB[TB][C]>;
+    [C in keyof DB[TB]]: InsertValueExpression<DB, TB, DB[TB][C]>;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-declare type InsertValueExpression<T> = T | AnyQueryBuilder | AnyRawBuilder | GeneratedPlaceholder;
-export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
-export declare function parseInsertValueExpression(value: InsertValueExpression<PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;
+declare type InsertValueExpression<DB, TB extends keyof DB, T> = T | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | GeneratedPlaceholder;
+export declare function parseInsertObjectOrList(ctx: ParseContext, args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
+export declare function parseInsertValueExpression(ctx: ParseContext, value: InsertValueExpression<any, any, PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;
 export {};

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

@@ -5,11 +5,11 @@ import { QueryNode } from '../operation-node/query-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
 import { isGeneratedPlaceholder } from '../util/generated-placeholder.js';
-import { isPrimitive } from '../util/object-utils.js';
-export function parseInsertObjectOrList(args) {
-    return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
+import { isFunction, isPrimitive, } from '../util/object-utils.js';
+export function parseInsertObjectOrList(ctx, args) {
+    return parseInsertColumnsAndValues(ctx, Array.isArray(args) ? args : [args]);
 }
-function parseInsertColumnsAndValues(rows) {
+function parseInsertColumnsAndValues(ctx, rows) {
     const columns = [];
     const values = [];
     for (const row of rows) {
@@ -32,12 +32,12 @@ function parseInsertColumnsAndValues(rows) {
             values.push(PrimitiveValueListNode.create(rowValues));
         }
         else {
-            values.push(ValueListNode.create(rowValues.map(parseInsertValueExpression)));
+            values.push(ValueListNode.create(rowValues.map((it) => parseInsertValueExpression(ctx, it))));
         }
     }
     return [columns.map(ColumnNode.create), values];
 }
-export function parseInsertValueExpression(value) {
+export function parseInsertValueExpression(ctx, value) {
     if (isPrimitive(value)) {
         return ValueNode.create(value);
     }
@@ -47,5 +47,11 @@ export function parseInsertValueExpression(value) {
             return node;
         }
     }
+    else if (isFunction(value)) {
+        const node = value(ctx.createExpressionBuilder()).toOperationNode();
+        if (!QueryNode.isMutating(node)) {
+            return node;
+        }
+    }
     throw new Error(`unsupported value for insert object ${JSON.stringify(value)}`);
 }

package/dist/esm/query-builder/join-builder.d.ts

@@ -4,6 +4,7 @@ import { ExistsExpression, FilterOperator } from '../parser/filter-parser.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ValueExpressionOrList } from '../parser/value-parser.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;
     constructor(props: JoinBuilderProps);
@@ -15,6 +16,7 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      */
     on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     on(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
+    on(raw: AnyRawBuilder): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.orWhere} but adds an item to the join's
      * `on` clause instead.
@@ -23,6 +25,7 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      */
     orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     orOn(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
+    orOn(raw: AnyRawBuilder): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.whereRef} but adds an item to the join's
      * `on` clause instead.

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

@@ -10,7 +10,7 @@ import { QueryBuilderWithReturning } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ValueExpressionOrList } from '../parser/value-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { AnyColumn, SingleResultType } from '../util/type-utils.js';
+import { AnyColumn, AnyRawBuilder, SingleResultType } from '../util/type-utils.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
@@ -220,6 +220,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): QueryBuilder<DB, TB, O>;
     where(grouper: (qb: QueryBuilder<DB, TB, O>) => QueryBuilder<DB, TB, O>): QueryBuilder<DB, TB, O>;
+    where(raw: AnyRawBuilder): QueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -339,6 +340,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      */
     orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): QueryBuilder<DB, TB, O>;
     orWhere(grouper: (qb: QueryBuilder<DB, TB, O>) => QueryBuilder<DB, TB, O>): QueryBuilder<DB, TB, O>;
+    orWhere(raw: AnyRawBuilder): QueryBuilder<DB, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like
      * {@link QueryBuilder.whereRef | whereRef}.
@@ -424,6 +426,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      */
     having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): QueryBuilder<DB, TB, O>;
     having(grouper: (qb: QueryBuilder<DB, TB, O>) => QueryBuilder<DB, TB, O>): QueryBuilder<DB, TB, O>;
+    having(raw: AnyRawBuilder): QueryBuilder<DB, TB, O>;
     /**
      * Just like {@link QueryBuilder.whereRef | whereRef} but adds a `having` statement
      * instead of a `where` statement.
@@ -435,6 +438,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      */
     orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): QueryBuilder<DB, TB, O>;
     orHaving(grouper: (qb: QueryBuilder<DB, TB, O>) => QueryBuilder<DB, TB, O>): QueryBuilder<DB, TB, O>;
+    orHaving(raw: AnyRawBuilder): QueryBuilder<DB, TB, O>;
     /**
      * Just like {@link QueryBuilder.orWhereRef | orWhereRef} but adds a `having` statement
      * instead of a `where` statement.
@@ -998,6 +1002,23 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * insert into "person" ("first_name", "last_name", "age")
      * values ($1, $2 || $3, (select avg(age) from "person"))
      * ```
+     *
+     * @example
+     * You can also use the callback version of subqueries or raw expressions:
+     *
+     * ```ts
+     * db.with('jennifer', (db) => db
+     *   .selectFrom('person')
+     *   .where('first_name', '=', 'Jennifer')
+     *   .select(['id', 'first_name', 'gender'])
+     *   .limit(1)
+     * ).insertInto('pet').values({
+     *   id: db.generated,
+     *   owner_id: (eb) => eb.subQuery('jennifer').select('id'),
+     *   name: (eb) => eb.subQuery('jennifer').select('first_name'),
+     *   species: 'cat',
+     * })
+     * ```
      */
     values(row: InsertObject<DB, TB>): QueryBuilder<DB, TB, O>;
     values(row: ReadonlyArray<InsertObject<DB, TB>>): QueryBuilder<DB, TB, O>;

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

@@ -437,7 +437,7 @@ export class QueryBuilder {
     }
     values(args) {
         assertCanHaveInsertValues(this.#props.queryNode);
-        const [columns, values] = parseInsertObjectOrList(args);
+        const [columns, values] = parseInsertObjectOrList(this.#props.parseContext, args);
         return new QueryBuilder({
             ...this.#props,
             queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {

package/dist/esm/util/dynamic-import.js

@@ -1,7 +1,7 @@
 import { isFunction, isObject } from './object-utils.js';
 export async function importFunction(modulePath) {
     const module = await import(modulePath);
-    const errorMessage = `module "${modulePath}" doesn export a function`;
+    const errorMessage = `module "${modulePath}" doesn't export a function`;
     if (isFunction(module)) {
         return module;
     }

package/dist/esm/util/log.d.ts

@@ -1,19 +1,21 @@
+import { CompiledQuery } from '../index.js';
 import { ArrayItemType } from './type-utils.js';
 export declare const LOG_LEVELS: readonly ["query", "error"];
 export declare type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
-export declare class Log {
-    #private;
-    constructor(levels: ReadonlyArray<LogLevel>);
-    query(getEvent: () => QueryLogEvent): void;
-    error(getEvent: () => ErrorLogEvent): void;
-}
-export declare type LogEvent = QueryLogEvent | ErrorLogEvent;
 export interface QueryLogEvent {
     readonly level: 'query';
-    readonly sql: string;
+    readonly query: CompiledQuery;
     readonly queryDurationMillis: number;
 }
 export interface ErrorLogEvent {
     readonly level: 'error';
     readonly error: unknown;
 }
+export declare type LogEvent = QueryLogEvent | ErrorLogEvent;
+export declare type LogConfig = ReadonlyArray<LogLevel> | ((event: LogEvent) => void);
+export declare class Log {
+    #private;
+    constructor(config: LogConfig);
+    query(getEvent: () => QueryLogEvent): void;
+    error(getEvent: () => ErrorLogEvent): void;
+}

package/dist/esm/util/log.js

@@ -1,25 +1,45 @@
-import { freeze } from './object-utils.js';
-export const LOG_LEVELS = ['query', 'error'];
+import { freeze, isFunction } from './object-utils.js';
+export const LOG_LEVELS = freeze(['query', 'error']);
 export class Log {
     #levels;
-    constructor(levels) {
-        this.#levels = freeze({
-            query: levels.includes('query'),
-            error: levels.includes('error'),
-        });
+    #logger;
+    constructor(config) {
+        if (isFunction(config)) {
+            this.#logger = config;
+            this.#levels = freeze({
+                query: true,
+                error: true,
+            });
+        }
+        else {
+            this.#levels = freeze({
+                query: config.includes('query'),
+                error: config.includes('error'),
+            });
+        }
     }
     query(getEvent) {
         if (this.#levels.query) {
-            this.#defaultQuery(getEvent());
+            if (this.#logger) {
+                this.#logger(getEvent());
+            }
+            else {
+                this.#defaultQuery(getEvent());
+            }
         }
     }
     error(getEvent) {
         if (this.#levels.error) {
-            this.#defaultError(getEvent());
+            if (this.#logger) {
+                this.#logger(getEvent());
+            }
+            else {
+                this.#defaultError(getEvent());
+            }
         }
     }
     #defaultQuery(event) {
-        console.log(`kysely:query: ${event.sql}`);
+        console.log(`kysely:query: ${event.query.sql}`);
         console.log(`kysely:query: duration: ${event.queryDurationMillis.toFixed(1)}ms`);
     }
     #defaultError(event) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.11.0",
+  "version": "0.11.4",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",