kysely 0.11.3 → 0.12.2

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

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertQueryBuilder = void 0;
+const select_parser_js_1 = require("../parser/select-parser.js");
+const insert_values_parser_js_1 = require("../parser/insert-values-parser.js");
+const insert_query_node_js_1 = require("../operation-node/insert-query-node.js");
+const query_node_js_1 = require("../operation-node/query-node.js");
+const update_set_parser_js_1 = require("../parser/update-set-parser.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const on_conflict_parser_js_1 = require("../parser/on-conflict-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const on_duplicate_key_node_js_1 = require("../operation-node/on-duplicate-key-node.js");
+const insert_result_js_1 = require("./insert-result.js");
+const no_result_error_js_1 = require("./no-result-error.js");
+const complex_expression_parser_js_1 = require("../parser/complex-expression-parser.js");
+const column_node_js_1 = require("../operation-node/column-node.js");
+class InsertQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    values(args) {
+        const [columns, values] = (0, insert_values_parser_js_1.parseInsertObjectOrList)(this.#props.parseContext, args);
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                columns,
+                values,
+            }),
+        });
+    }
+    /**
+     * Sets the columns to insert.
+     *
+     * The {@link values} method sets both the columns and the values and this method
+     * is not needed. But if you are using the {@link expression} method, you can use
+     * this method to set the columns to insert.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .columns(['first_name'])
+     *   .expression((eb) => eb.selectFrom('pet').select('pet.name'))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name")
+     * select "pet"."name" from "pet"
+     * ```
+     */
+    columns(columns) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                columns: (0, object_utils_js_1.freeze)(columns.map(column_node_js_1.ColumnNode.create)),
+            }),
+        });
+    }
+    /**
+     * Insert an arbitrary expression. For example the result of a select query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .columns(['first_name'])
+     *   .expression((eb) => eb.selectFrom('pet').select('pet.name'))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name")
+     * select "pet"."name" from "pet"
+     * ```
+     */
+    expression(expression) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                values: (0, complex_expression_parser_js_1.parseComplexExpression)(this.#props.parseContext, expression),
+            }),
+        });
+    }
+    onConflictDoNothing(target) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onConflict: (0, on_conflict_parser_js_1.parseOnConflictDoNothing)(target),
+            }),
+        });
+    }
+    /**
+     * Changes an `insert into` query to an `insert ignore into` query.
+     *
+     * If you use the ignore modifier, ignorable errors that occur while executing the
+     * insert statement are ignored. For example, without ignore, a row that duplicates
+     * an existing unique index or primary key value in the table causes a duplicate-key
+     * error and the statement is aborted. With ignore, the row is discarded and no error
+     * occurs.
+     *
+     * This is only supported on some dialects like MySQL. On most dialects you should
+     * use the {@link onConflictDoNothing} method.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .ignore()
+     *   .values(values)
+     *   .execute()
+     * ```
+     */
+    ignore() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                ignore: true,
+            }),
+        });
+    }
+    onConflictUpdate(target, updates) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onConflict: (0, on_conflict_parser_js_1.parseOnConflictUpdate)(this.#props.parseContext, target, updates),
+            }),
+        });
+    }
+    /**
+     * Adds `on duplicate key update` to the query.
+     *
+     * If you specify `on duplicate key update`, and a row is inserted that would cause
+     * a duplicate value in a unique index or primary key, an update of the old row occurs.
+     *
+     * This is only implemented by some dialects like MySQL. On most dialects you should
+     * use {@link onConflictUpdate} instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db
+     *   .insertInto('person')
+     *   .values(values)
+     *   .onDuplicateKeyUpdate({ species: 'hamster' })
+     * ```
+     */
+    onDuplicateKeyUpdate(updates) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onDuplicateKey: on_duplicate_key_node_js_1.OnDuplicateKeyNode.create((0, update_set_parser_js_1.parseUpdateObject)(this.#props.parseContext, updates)),
+            }),
+        });
+    }
+    returning(selection) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#props.parseContext, selection)),
+        });
+    }
+    returningAll() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)()),
+        });
+    }
+    /**
+     * Simply calls the given function passing `this` as the only argument.
+     *
+     * This method can be useful when adding optional method calls:
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .selectAll()
+     *   .call((qb) => {
+     *     if (something) {
+     *       return qb.onConflictDoNothing('something')
+     *     } else {
+     *       return qb.onConflictDoNothing('something_else')
+     *     }
+     *   })
+     *   .execute()
+     * ```
+     */
+    call(func) {
+        return func(this);
+    }
+    /**
+     * Change the output type of the query.
+     *
+     * You should only use this method as the last resort if the types
+     * don't support your use case.
+     */
+    castTo() {
+        return new InsertQueryBuilder(this.#props);
+    }
+    withPlugin(plugin) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    /**
+     * Executes the query and returns an array of rows.
+     *
+     * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
+     */
+    async execute() {
+        const compildQuery = this.compile();
+        const query = compildQuery.query;
+        const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
+        if (this.#props.parseContext.adapter.supportsReturning && query.returning) {
+            return result.rows;
+        }
+        else {
+            return [new insert_result_js_1.InsertResult(result.insertId)];
+        }
+    }
+    /**
+     * Executes the query and returns the first result or undefined if
+     * the query returned no result.
+     */
+    async executeTakeFirst() {
+        const [result] = await this.execute();
+        return result;
+    }
+    /**
+     * Executes the query and returns the first result or throws if
+     * the query returned no result.
+     *
+     * By default an instance of {@link NoResultError} is thrown, but you can
+     * provide a custom error class as the only argument to throw a different
+     * error.
+     */
+    async executeTakeFirstOrThrow(errorConstructor = no_result_error_js_1.NoResultError) {
+        const result = await this.executeTakeFirst();
+        if (result === undefined) {
+            throw new errorConstructor(this.toOperationNode());
+        }
+        return result;
+    }
+}
+exports.InsertQueryBuilder = InsertQueryBuilder;
+(0, prevent_await_js_1.preventAwait)(InsertQueryBuilder, "don't await InsertQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

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

@@ -4,10 +4,11 @@
  * If the table has an auto incrementing primary key {@link insertId} will hold
  * the generated id on dialects that support it. For example PostgreSQL doesn't
  * return the id by default and {@link insertId} is undefined. On PostgreSQL you
- * need to use {@link QueryBuilder.returning} or {@link QueryBuilder.returningAll}
+ * need to use {@link ReturningInterface.returning} or {@link ReturningInterface.returningAll}
  * to get out the inserted id.
  *
- * @example
+ * ### Examples
+ *
  * ```ts
  * const result = await db
  *   .insertInto('person')

package/dist/cjs/query-builder/insert-result.js

@@ -7,10 +7,11 @@ exports.InsertResult = void 0;
  * If the table has an auto incrementing primary key {@link insertId} will hold
  * the generated id on dialects that support it. For example PostgreSQL doesn't
  * return the id by default and {@link insertId} is undefined. On PostgreSQL you
- * need to use {@link QueryBuilder.returning} or {@link QueryBuilder.returningAll}
+ * need to use {@link ReturningInterface.returning} or {@link ReturningInterface.returningAll}
  * to get out the inserted id.
  *
- * @example
+ * ### Examples
+ *
  * ```ts
  * const result = await db
  *   .insertInto('person')

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

@@ -1,71 +1,70 @@
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { ExistsExpression, FilterOperator } from '../parser/filter-parser.js';
+import { ExistsExpression, FilterOperator, FilterValueExpressionOrList } 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);
     /**
-     * Just like {@link QueryBuilder.where} but adds an item to the join's
+     * Just like {@link WhereInterface.where} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.where} for documentation and examples.
+     * See {@link WhereInterface.where} for documentation and examples.
      */
-    on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
+    on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<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
+     * Just like {@link WhereInterface.orWhere} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.orWhere} for documentation and examples.
+     * See {@link WhereInterface.orWhere} for documentation and examples.
      */
-    orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
+    orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<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
+     * Just like {@link WhereInterface.whereRef} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.whereRef} for documentation and examples.
+     * See {@link WhereInterface.whereRef} for documentation and examples.
      */
     onRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link QueryBuilder.orWhereRef} but adds an item to the join's
+     * Just like {@link WhereInterface.orWhereRef} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.orWhereRef} for documentation and examples.
+     * See {@link WhereInterface.orWhereRef} for documentation and examples.
      */
     orOnRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link QueryBuilder.whereExists} but adds an item to the join's
+     * Just like {@link WhereInterface.whereExists} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.whereExists} for documentation and examples.
+     * See {@link WhereInterface.whereExists} for documentation and examples.
      */
     onExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link QueryBuilder.whereNotExists} but adds an item to the join's
+     * Just like {@link WhereInterface.whereNotExists} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.whereNotExists} for documentation and examples.
+     * See {@link WhereInterface.whereNotExists} for documentation and examples.
      */
     onNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link QueryBuilder.orWhereExists} but adds an item to the join's
+     * Just like {@link WhereInterface.orWhereExists} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.orWhereExists} for documentation and examples.
+     * See {@link WhereInterface.orWhereExists} for documentation and examples.
      */
     orOnExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link QueryBuilder.orWhereNotExists} but adds an item to the join's
+     * Just like {@link WhereInterface.orWhereNotExists} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.orWhereNotExists} for documentation and examples.
+     * See {@link WhereInterface.orWhereNotExists} for documentation and examples.
      */
     orOnNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     toOperationNode(): JoinNode;

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

@@ -23,10 +23,10 @@ class JoinBuilder {
         });
     }
     /**
-     * Just like {@link QueryBuilder.whereRef} but adds an item to the join's
+     * Just like {@link WhereInterface.whereRef} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.whereRef} for documentation and examples.
+     * See {@link WhereInterface.whereRef} for documentation and examples.
      */
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
@@ -35,10 +35,10 @@ class JoinBuilder {
         });
     }
     /**
-     * Just like {@link QueryBuilder.orWhereRef} but adds an item to the join's
+     * Just like {@link WhereInterface.orWhereRef} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.orWhereRef} for documentation and examples.
+     * See {@link WhereInterface.orWhereRef} for documentation and examples.
      */
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
@@ -47,10 +47,10 @@ class JoinBuilder {
         });
     }
     /**
-     * Just like {@link QueryBuilder.whereExists} but adds an item to the join's
+     * Just like {@link WhereInterface.whereExists} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.whereExists} for documentation and examples.
+     * See {@link WhereInterface.whereExists} for documentation and examples.
      */
     onExists(arg) {
         return new JoinBuilder({
@@ -59,10 +59,10 @@ class JoinBuilder {
         });
     }
     /**
-     * Just like {@link QueryBuilder.whereNotExists} but adds an item to the join's
+     * Just like {@link WhereInterface.whereNotExists} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.whereNotExists} for documentation and examples.
+     * See {@link WhereInterface.whereNotExists} for documentation and examples.
      */
     onNotExists(arg) {
         return new JoinBuilder({
@@ -71,10 +71,10 @@ class JoinBuilder {
         });
     }
     /**
-     * Just like {@link QueryBuilder.orWhereExists} but adds an item to the join's
+     * Just like {@link WhereInterface.orWhereExists} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.orWhereExists} for documentation and examples.
+     * See {@link WhereInterface.orWhereExists} for documentation and examples.
      */
     orOnExists(arg) {
         return new JoinBuilder({
@@ -83,10 +83,10 @@ class JoinBuilder {
         });
     }
     /**
-     * Just like {@link QueryBuilder.orWhereNotExists} but adds an item to the join's
+     * Just like {@link WhereInterface.orWhereNotExists} but adds an item to the join's
      * `on` clause instead.
      *
-     * See {@link QueryBuilder.orWhereNotExists} for documentation and examples.
+     * See {@link WhereInterface.orWhereNotExists} for documentation and examples.
      */
     orOnNotExists(arg) {
         return new JoinBuilder({

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

@@ -0,0 +1,130 @@
+import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
+import { FullJoinTableExpressionDatabase, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
+export interface JoinInterface<DB, TB extends keyof DB> {
+    /**
+     * Joins another table to the query using an inner join.
+     *
+     * ### Examples
+     *
+     * Simple usage by providing a table name and two columns to join:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   // `select` needs to come after the call to `innerJoin` so
+     *   // that you can select from the joined table.
+     *   .select('person.id', 'pet.name')
+     *   .execute()
+     *
+     * result[0].id
+     * result[0].name
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."id", "pet"."name"
+     * from "person"
+     * inner join "pet"
+     * on "pet"."owner_id" = "person"."id"
+     * ```
+     *
+     * You can give an alias for the joined table like this:
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin('pet as p', 'p.owner_id', 'person.id')
+     *   .where('p.name', '=', 'Doggo')
+     *   .selectAll()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * inner join "pet" as "p"
+     * on "p"."owner_id" = "person"."id"
+     * where "p".name" = $1
+     * ```
+     *
+     * You can provide a function as the second argument to get a join
+     * builder for creating more complex joins. The join builder has a
+     * bunch of `on*` methods for building the `on` clause of the join.
+     * There's basically an equivalent for every `where` method
+     * (`on`, `onRef`, `onExists` etc.). You can do all the same things
+     * with the `on` method that you can with the corresponding `where`
+     * method. See the `where` method documentation for more examples.
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin(
+     *     'pet',
+     *     (join) => join
+     *       .onRef('pet.owner_id', '=', 'person.id')
+     *       .on('pet.name', '=', 'Doggo')
+     *   )
+     *   .selectAll()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * inner join "pet"
+     * on "pet"."owner_id" = "person"."id"
+     * and "pet"."name" = $1
+     * ```
+     *
+     * You can join a subquery by providing a function as the first
+     * argument:
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin(
+     *     (qb) => qb.selectFrom('pet')
+     *       .select(['owner_id', 'name'])
+     *       .where('name', '=', 'Doggo')
+     *       .as('doggos'),
+     *     'doggos.owner_id',
+     *     'person.id',
+     *   )
+     *   .selectAll()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * inner join (
+     *   select "owner_id", "name"
+     *   from "pet"
+     *   where "name" = $1
+     * ) as "doggos"
+     * on "doggos"."owner_id" = "person"."id"
+     * ```
+     */
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
+    /**
+     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
+     */
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
+    /**
+     * Just like {@link innerJoin} but adds a right join instead of an inner join.
+     */
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
+    /**
+     * Just like {@link innerJoin} but adds a full join instead of an inner join.
+     */
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
+}

package/dist/cjs/query-builder/join-interface.js

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

package/dist/cjs/query-builder/no-result-error.d.ts

@@ -0,0 +1,9 @@
+import { QueryNode } from '../operation-node/query-node.js';
+export declare type NoResultErrorConstructor = new (node: QueryNode) => Error;
+export declare class NoResultError extends Error {
+    /**
+     * The operation node tree of the query that was executed.
+     */
+    readonly node: QueryNode;
+    constructor(node: QueryNode);
+}

package/dist/cjs/query-builder/no-result-error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoResultError = void 0;
+class NoResultError extends Error {
+    /**
+     * The operation node tree of the query that was executed.
+     */
+    node;
+    constructor(node) {
+        super('no result');
+        this.node = node;
+    }
+}
+exports.NoResultError = NoResultError;