kysely 0.11.3 → 0.11.4

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

@@ -9,10 +9,14 @@ class SqliteAdapter {
         return false;
     }
     async acquireMigrationLock() {
-        // Nothing to do here.
+        // 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() {
-        // Nothing to do here.
+        // 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.
     }
 }
 exports.SqliteAdapter = SqliteAdapter;

package/dist/cjs/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/cjs/parser/insert-values-parser.js

@@ -9,11 +9,11 @@ const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const generated_placeholder_js_1 = require("../util/generated-placeholder.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-function parseInsertObjectOrList(args) {
-    return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
+function parseInsertObjectOrList(ctx, args) {
+    return parseInsertColumnsAndValues(ctx, Array.isArray(args) ? args : [args]);
 }
 exports.parseInsertObjectOrList = parseInsertObjectOrList;
-function parseInsertColumnsAndValues(rows) {
+function parseInsertColumnsAndValues(ctx, rows) {
     const columns = [];
     const values = [];
     for (const row of rows) {
@@ -36,12 +36,12 @@ function parseInsertColumnsAndValues(rows) {
             values.push(primitive_value_list_node_js_1.PrimitiveValueListNode.create(rowValues));
         }
         else {
-            values.push(value_list_node_js_1.ValueListNode.create(rowValues.map(parseInsertValueExpression)));
+            values.push(value_list_node_js_1.ValueListNode.create(rowValues.map((it) => parseInsertValueExpression(ctx, it))));
         }
     }
     return [columns.map(column_node_js_1.ColumnNode.create), values];
 }
-function parseInsertValueExpression(value) {
+function parseInsertValueExpression(ctx, value) {
     if ((0, object_utils_js_1.isPrimitive)(value)) {
         return value_node_js_1.ValueNode.create(value);
     }
@@ -51,6 +51,12 @@ function parseInsertValueExpression(value) {
             return node;
         }
     }
+    else if ((0, object_utils_js_1.isFunction)(value)) {
+        const node = value(ctx.createExpressionBuilder()).toOperationNode();
+        if (!query_node_js_1.QueryNode.isMutating(node)) {
+            return node;
+        }
+    }
     throw new Error(`unsupported value for insert object ${JSON.stringify(value)}`);
 }
 exports.parseInsertValueExpression = parseInsertValueExpression;

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

@@ -1002,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/cjs/query-builder/query-builder.js

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

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

@@ -6,9 +6,13 @@ export class SqliteAdapter {
         return false;
     }
     async acquireMigrationLock() {
-        // Nothing to do here.
+        // 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() {
-        // Nothing to do here.
+        // 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/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/query-builder.d.ts

@@ -1002,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/package.json

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