kysely 0.7.7 → 0.8.1

package/README.md

@@ -4,7 +4,7 @@
 # [Kysely](https://koskimas.github.io/kysely/index.html)
 
 A type-safe and autocompletion-friendly typescript SQL query builder for node.js. Inspired by
-[knex](http://knexjs.org/).
+[knex](http://knexjs.org/). You can find an introduction to Kysely [here](https://www.jakso.me/blog/kysely-a-type-safe-sql-query-builder-for-typescript).
 
 ![](https://github.com/koskimas/kysely/blob/master/assets/demo.gif)
 
@@ -31,6 +31,7 @@ using Kysely and can't find something you'd want to use, please open an issue.
 
 - [Installation](#installation)
 - [Minimal example](#minimal-example)
+- [Query examples](#query-examples)
 - [Migrations](#migrations)
 - [API reference](https://koskimas.github.io/kysely/index.html)
 
@@ -49,7 +50,7 @@ npm install kysely mysql2
 More dialects will be added soon. Kysely also has a simple interface
 for [3rd party dialects](https://koskimas.github.io/kysely/interfaces/Dialect.html).
 
-3rd party dialects:
+### 3rd party dialects:
 
  - [AWS Data API](https://github.com/serverless-stack/kysely-data-api)
 
@@ -109,6 +110,32 @@ async function demo() {
 }
 ```
 
+# Query examples
+
+## Select queries
+
+You can find examples of select queries in the documentation of the 
+[select method](https://koskimas.github.io/kysely/classes/QueryBuilder.html#select) and
+the [where method](https://koskimas.github.io/kysely/classes/QueryBuilder.html#where) 
+among other places.
+
+## Update queries
+
+See the [set method](https://koskimas.github.io/kysely/classes/QueryBuilder.html#set) and the
+[updateTable method](https://koskimas.github.io/kysely/classes/Kysely.html#updateTable)
+documentation.
+
+## Insert queries
+
+See the [values method](https://koskimas.github.io/kysely/classes/QueryBuilder.html#values) and the
+[insertInto method](https://koskimas.github.io/kysely/classes/Kysely.html#insertInto)
+documentation.
+
+## Delete queries
+
+See the [deleteFrom method](https://koskimas.github.io/kysely/classes/Kysely.html#deleteFrom)
+documentation.
+
 # Migrations
 
 Migration files should look like this:

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

@@ -1,5 +1,13 @@
 import { Kysely } from '../kysely.js';
-export interface DialectSupports {
+/**
+ * A `DialectAdapter` encapsulates all differences between dialects outside
+ * of `Driver` and `QueryCompiler`.
+ *
+ * For example, some databases support transactional DDL and therefore we want
+ * to run migrations inside a transaction, while other databases don't support
+ * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
+ */
+export interface DialectAdapter {
     /**
      * Whether or not this dialect supports transactional DDL.
      *
@@ -8,19 +16,9 @@ export interface DialectSupports {
     readonly supportsTransactionalDdl: boolean;
     /**
      * Whether or not this dialect supports the `returning` in inserts
-     * upates and deletes.
+     * updates and deletes.
      */
     readonly supportsReturning: boolean;
-}
-/**
- * The `DialectAdapter` encapsulates all differences between dialects outside
- * the `Driver` and `QueryCompiler`.
- *
- * For example, some databases support transactional DDL and therefore we want
- * to run migrations inside a transaction, while other databases don't support
- * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
- */
-export interface DialectAdapter extends DialectSupports {
     /**
      * This method is used to acquire a lock for the migrations so that
      * it's not possible for two migration processes to run in parallel.
@@ -34,10 +32,19 @@ export interface DialectAdapter extends DialectSupports {
      * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
      * Kysely takes care of creating the lock table and inserting the one single
      * row to it before this method is executed.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
      */
     acquireMigrationLock(db: Kysely<any>): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations.
      */
     releaseMigrationLock(db: Kysely<any>): Promise<void>;
 }

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

@@ -4,7 +4,7 @@ import { QueryCompiler } from '../query-compiler/query-compiler.js';
 import { DatabaseIntrospector } from '../introspection/database-introspector.js';
 import { DialectAdapter } from './dialect-adapter.js';
 /**
- * A Dialect is an adapter between Kysely and the underlying database engine.
+ * A Dialect is the glue between Kysely and the underlying database engine.
  *
  * See the built-in {@link PostgresDialect} as an example of a dialect.
  * Users can implement their own dialects and use them by passing it

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

@@ -11,6 +11,12 @@ class MysqlAdapter {
         return false;
     }
     async acquireMigrationLock(db) {
+        // Kysely uses a single connection to run the migrations. Because of that, we
+        // can take a lock using `get_lock`. Locks acquired using `get_lock` get
+        // released when the connection is destroyed (session ends) or when the lock
+        // is released using `release_lock`. This way we know that the lock is either
+        // released by us after successfull or failed migrations OR it's released by
+        // mysql if the process gets killed for some reason.
         await db
             .raw(`select get_lock('${LOCK_ID}', ${LOCK_TIMEOUT_SECONDS})`)
             .execute();

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

@@ -53,16 +53,16 @@ class MysqlDriver {
             // On mysql this sets the isolation level of the next transaction.
             await connection.executeQuery({
                 sql: `set transaction isolation level ${settings.isolationLevel}`,
-                bindings: [],
+                parameters: [],
             });
         }
-        await connection.executeQuery({ sql: 'begin', bindings: [] });
+        await connection.executeQuery({ sql: 'begin', parameters: [] });
     }
     async commitTransaction(connection) {
-        await connection.executeQuery({ sql: 'commit', bindings: [] });
+        await connection.executeQuery({ sql: 'commit', parameters: [] });
     }
     async rollbackTransaction(connection) {
-        await connection.executeQuery({ sql: 'rollback', bindings: [] });
+        await connection.executeQuery({ sql: 'rollback', parameters: [] });
     }
     async releaseConnection(connection) {
         const mysqlConnection = connection;
@@ -131,7 +131,7 @@ class MysqlConnection {
     }
     #executeQuery(compiledQuery) {
         return new Promise((resolve, reject) => {
-            this.#rawConnection.query(compiledQuery.sql, compiledQuery.bindings, (err, result) => {
+            this.#rawConnection.query(compiledQuery.sql, compiledQuery.parameters, (err, result) => {
                 if (err) {
                     reject(err);
                 }

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

@@ -40,18 +40,18 @@ class PostgresDriver {
         if (settings.isolationLevel) {
             await connection.executeQuery({
                 sql: `start transaction isolation level ${settings.isolationLevel}`,
-                bindings: [],
+                parameters: [],
             });
         }
         else {
-            await connection.executeQuery({ sql: 'begin', bindings: [] });
+            await connection.executeQuery({ sql: 'begin', parameters: [] });
         }
     }
     async commitTransaction(connection) {
-        await connection.executeQuery({ sql: 'commit', bindings: [] });
+        await connection.executeQuery({ sql: 'commit', parameters: [] });
     }
     async rollbackTransaction(connection) {
-        await connection.executeQuery({ sql: 'rollback', bindings: [] });
+        await connection.executeQuery({ sql: 'rollback', parameters: [] });
     }
     async releaseConnection(connection) {
         const pgConnection = connection;
@@ -90,7 +90,7 @@ class PostgresConnection {
     }
     async executeQuery(compiledQuery) {
         const result = await this.#client.query(compiledQuery.sql, [
-            ...compiledQuery.bindings,
+            ...compiledQuery.parameters,
         ]);
         if (result.command === 'UPDATE' || result.command === 'DELETE') {
             return {

package/dist/cjs/driver/database-connection.d.ts

@@ -1,4 +1,9 @@
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
+/**
+ * A single connection to the database engine.
+ *
+ * These are created by an instance of {@link Driver}.
+ */
 export interface DatabaseConnection {
     executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
 }

package/dist/cjs/driver/driver.d.ts

@@ -1,10 +1,8 @@
-import { ArrayItemType } from '../query-builder/type-utils.js';
+import { ArrayItemType } from '../util/type-utils.js';
 import { DatabaseConnection } from './database-connection.js';
 /**
- * A Driver is responsible for abstracting away the database engine details.
- *
- * The Driver creates and releases database connections and is also responsible
- * for connection pooling.
+ * A Driver creates and releases {@link DatabaseConnection | database connections}
+ * and is also responsible for connection pooling (if the dialect supports pooling).
  */
 export interface Driver {
     /**

package/dist/cjs/index.d.ts

@@ -110,7 +110,7 @@ export * from './operation-node/operation-node-source.js';
 export * from './operation-node/order-by-node.js';
 export * from './introspection/database-introspector.js';
 export * from './util/compilable.js';
-export { AnyColumn } from './query-builder/type-utils.js';
+export { AnyColumn, UnknownRow as AnyRow } from './util/type-utils.js';
 export { SelectExpression, SelectExpressionOrList, } from './parser/select-parser.js';
 export { ReferenceExpression, ReferenceExpressionOrList, } from './parser/reference-parser.js';
 export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';

package/dist/cjs/kysely.d.ts

@@ -5,10 +5,11 @@ import { MigrationModule } from './migration/migration.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { QueryCreator } from './query-creator.js';
 import { KyselyPlugin } from './plugin/kysely-plugin.js';
-import { GeneratedPlaceholder } from './query-builder/type-utils.js';
+import { GeneratedPlaceholder } from './util/type-utils.js';
 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';
 /**
  * The main Kysely class.
  *
@@ -96,6 +97,35 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * ```
      */
     get generated(): GeneratedPlaceholder;
+    /**
+     * Returns a {@link FunctionBuilder} that can be used to write type safe function
+     * calls.
+     *
+     * ```ts
+     * const { count } = db.fn
+     *
+     * await db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select([
+     *     'person.id',
+     *     count('pet.id').as('pet_count')
+     *   ])
+     *   .groupBy('person.id')
+     *   .having(count('pet.id'), '>', 10)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (postgresql):
+     *
+     * ```sql
+     * select "person"."id", count("pet"."id") as "pet_count"
+     * from "person"
+     * inner join "pet" on "pet"."owner_id" = "person"."id"
+     * group by "person"."id"
+     * having count("pet"."id") > $1
+     * ```
+     */
+    get fn(): FunctionBuilder<DB, keyof DB>;
     /**
      * Starts a transaction. If the callback throws the transaction is rolled back,
      * otherwise it's committed.

package/dist/cjs/kysely.js

@@ -14,6 +14,7 @@ const single_connection_provider_js_1 = require("./driver/single-connection-prov
 const driver_js_1 = require("./driver/driver.js");
 const prevent_await_js_1 = require("./util/prevent-await.js");
 const parse_context_js_1 = require("./parser/parse-context.js");
+const function_builder_js_1 = require("./query-builder/function-builder.js");
 /**
  * The main Kysely class.
  *
@@ -131,7 +132,38 @@ class Kysely extends query_creator_js_1.QueryCreator {
      * ```
      */
     get generated() {
-        return generated_placeholder_js_1.generatedPlaceholder;
+        return generated_placeholder_js_1.GENERATED_PLACEHOLDER;
+    }
+    /**
+     * Returns a {@link FunctionBuilder} that can be used to write type safe function
+     * calls.
+     *
+     * ```ts
+     * const { count } = db.fn
+     *
+     * await db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select([
+     *     'person.id',
+     *     count('pet.id').as('pet_count')
+     *   ])
+     *   .groupBy('person.id')
+     *   .having(count('pet.id'), '>', 10)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (postgresql):
+     *
+     * ```sql
+     * select "person"."id", count("pet"."id") as "pet_count"
+     * from "person"
+     * inner join "pet" on "pet"."owner_id" = "person"."id"
+     * group by "person"."id"
+     * having count("pet"."id") > $1
+     * ```
+     */
+    get fn() {
+        return new function_builder_js_1.FunctionBuilder({ executor: this.#props.executor });
     }
     /**
      * Starts a transaction. If the callback throws the transaction is rolled back,

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

@@ -1,4 +1,4 @@
-import { ArrayItemType } from '../query-builder/type-utils.js';
+import { ArrayItemType } from '../util/type-utils.js';
 import { OperationNode } from './operation-node.js';
 export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists"];
 export declare type Operator = ArrayItemType<typeof OPERATORS>;

package/dist/cjs/parser/data-type-parser.d.ts

@@ -1,5 +1,5 @@
 import { ColumnDataType, DataTypeNode } from '../operation-node/data-type-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 export declare type DataTypeExpression = ColumnDataType | AnyRawBuilder;
 export declare function parseDataTypeExpression(dataType: DataTypeExpression): DataTypeNode | RawNode;

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

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

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

@@ -1,5 +1,5 @@
 import { FilterNode } from '../operation-node/filter-node.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
 import { Operator } from '../operation-node/operator-node.js';
 import { ReferenceExpression } from './reference-parser.js';
 import { FilterExpressionNode } from '../operation-node/operation-node-utils.js';

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

@@ -3,13 +3,13 @@ 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 '../query-builder/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, GeneratedPlaceholder } from '../util/type-utils.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
     [C in keyof DB[TB]]: InsertValueExpression<DB[TB][C]>;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | InsertObject<DB, TB>[];
-declare type InsertValueExpression<T extends PrimitiveValue> = T | AnyQueryBuilder | AnyRawBuilder | GeneratedPlaceholder;
+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;
 export {};

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

@@ -1,5 +1,5 @@
 import { JoinNode, JoinType } from '../operation-node/join-node.js';
-import { AnyColumn, AnyColumnWithTable } from '../query-builder/type-utils.js';
+import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
 import { ExtractAliasFromTableExpression, TableExpressionDatabaseType } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { ParseContext } from './parse-context.js';

package/dist/cjs/parser/on-conflict-parser.d.ts

@@ -1,5 +1,5 @@
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { AnyColumn } from '../query-builder/type-utils.js';
+import { AnyColumn } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 import { MutationObject } from './update-set-parser.js';
 export declare type OnConflictConstraintTarget = {

package/dist/cjs/parser/order-by-parser.d.ts

@@ -1,6 +1,6 @@
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type OrderByDirection = 'asc' | 'desc';

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

@@ -3,13 +3,14 @@ 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, AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory, RowType, ValueType } from '../query-builder/type-utils.js';
+import { AnyColumn, AnyColumnWithTable, AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory, RowType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { ParseContext } from './parse-context.js';
-export declare type ReferenceExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | 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 ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends QueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => QueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];

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

@@ -1,5 +1,5 @@
 import { QueryBuilder } from '../query-builder/query-builder.js';
-import { DeleteResultTypeTag, InsertResultTypeTag, UpdateResultTypeTag } from '../query-builder/type-utils.js';
+import { DeleteResultTypeTag, InsertResultTypeTag, UpdateResultTypeTag } from '../util/type-utils.js';
 import { Selection } from './select-parser.js';
 /**
  * `returning` method output query builder type

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

@@ -1,7 +1,7 @@
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, InsertResultTypeTag, RowType, ValueType } from '../query-builder/type-utils.js';
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, InsertResultTypeTag, RowType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ParseContext } from './parse-context.js';
 /**

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

@@ -1,6 +1,6 @@
 import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { AliasedQueryBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder } from '../query-builder/type-utils.js';
+import { AliasedQueryBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, Nullable } from '../util/type-utils.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ParseContext } from './parse-context.js';
@@ -8,14 +8,25 @@ export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB, any, any> | AnyTable<DB> | AnyAliasedRawBuilder;
 export declare type QueryBuilderWithTable<DB, TB extends keyof DB, O, TE> = QueryBuilder<TableExpressionDatabaseType<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type TableExpressionDatabaseType<DB, TE> = DB extends ExtractDatabaseTypeFromTableExpression<DB, TE> ? DB : DB & ExtractDatabaseTypeFromTableExpression<DB, TE>;
+export declare type TableExpressionDatabaseType<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+    [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
+};
+export declare type QueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<LeftJoinTableExpressionDatabaseType<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type LeftJoinTableExpressionDatabaseType<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+    [C in keyof DB | A]: C extends A ? Nullable<ExtractRowTypeFromTableExpression<DB, TE, C>> : C extends keyof DB ? DB[C] : never;
+};
+export declare type QueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<RightJoinTableExpressionDatabaseType<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type RightJoinTableExpressionDatabaseType<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+    [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? C extends TB ? Nullable<DB[C]> : DB[C] : never;
+};
+export declare type QueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<FullJoinTableExpressionDatabaseType<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type FullJoinTableExpressionDatabaseType<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+    [C in keyof DB | A]: C extends A ? Nullable<ExtractRowTypeFromTableExpression<DB, TE, C>> : C extends keyof DB ? C extends TB ? Nullable<DB[C]> : DB[C] : never;
+};
 export declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;
+declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
 declare type AnyAliasedTable<DB, TB extends keyof DB, A extends string> = TB extends string ? `${TB} as ${A}` : never;
 declare type AnyTable<DB> = keyof DB;
-declare type ExtractDatabaseTypeFromTableExpression<DB, TE> = {
-    [A in ExtractAliasFromTableExpression<DB, TE>]: ExtractRowTypeFromTableExpression<DB, TE, A>;
-};
-declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
 export declare function parseTableExpressionOrList(ctx: ParseContext, table: TableExpressionOrList<any, any>): TableExpressionNode[];
 export declare function parseTableExpression(ctx: ParseContext, table: TableExpression<any, any>): TableExpressionNode;
 export declare function parseAliasedTable(from: string): TableExpressionNode;

package/dist/cjs/parser/update-set-parser.d.ts

@@ -2,12 +2,12 @@ import { ColumnUpdateNode } from '../operation-node/column-update-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, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
     [C in keyof DB[TB]]?: MutationValueExpression<DB, TB, DB[TB][C]>;
 };
-export declare type MutationValueExpression<DB, TB extends keyof DB, T extends PrimitiveValue> = T | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+export declare type MutationValueExpression<DB, TB extends keyof DB, T> = T | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
 export declare function parseUpdateObject(ctx: ParseContext, row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;
 export declare function parseMutationValueExpression(ctx: ParseContext, value: MutationValueExpression<any, any, PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;

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

@@ -1,5 +1,5 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
 import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
 import { ParseContext } from './parse-context.js';
 export declare type ValueExpression<DB, TB extends keyof DB, RE> = ExtractTypeFromReferenceExpression<DB, TB, RE> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;

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

@@ -2,7 +2,7 @@ import { CommonTableExpressionNode } from '../operation-node/common-table-expres
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => QueryBuilder<DB, any> | AnyRawBuilder;
 export declare type QueryCreatorWithCommonTableExpression<DB, N extends string, E extends CommonTableExpression<DB>> = QueryCreator<DB & Record<N, ExtractRowTypeFromCommonTableExpression<E>>>;

package/dist/cjs/plugin/camel-case/camel-case-plugin.d.ts

@@ -1,6 +1,7 @@
 import { QueryResult } from '../../driver/database-connection.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
-import { AnyRow, KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+import { UnknownRow } from '../../util/type-utils.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
 export interface CamelCasePluginOptions {
     /**
      * If true, camelCase is transformed into upper case SNAKE_CASE.
@@ -94,8 +95,8 @@ export declare class CamelCasePlugin implements KyselyPlugin {
     #private;
     constructor(opt?: CamelCasePluginOptions);
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
-    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<AnyRow>>;
-    protected mapRow(row: AnyRow): AnyRow;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+    protected mapRow(row: UnknownRow): UnknownRow;
     protected snakeCase(str: string): string;
     protected camelCase(str: string): string;
 }

package/dist/cjs/plugin/kysely-plugin.d.ts

@@ -1,11 +1,12 @@
 import { QueryResult } from '../driver/database-connection.js';
 import { RootOperationNode } from '../query-compiler/query-compiler.js';
 import { QueryId } from '../util/query-id.js';
+import { UnknownRow } from '../util/type-utils.js';
 export interface KyselyPlugin {
     /**
      * This is called for each query before it is executed. You can modify the query by
      * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
-     * and returning the transformed tree. You'd usually  want to use an {@link OperationNodeTransformer}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
      * for this.
      *
      * If you need to pass some query-related data between this method and `transformResult` you
@@ -22,10 +23,14 @@ export interface KyselyPlugin {
      *
      *   transformResult(args: PluginTransformResultArgs): QueryResult<AnyRow> {
      *     const data = this.data.get(args.queryId)
-     *     return data.result
+     *     return args.result
      *   }
      * }
      * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
      */
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
     /**
@@ -33,14 +38,13 @@ export interface KyselyPlugin {
      * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
      * You can modify the result and return the modifier result.
      */
-    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<AnyRow>>;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }
 export interface PluginTransformQueryArgs {
     readonly queryId: QueryId;
     readonly node: RootOperationNode;
 }
-export declare type AnyRow = Record<string, unknown>;
 export interface PluginTransformResultArgs {
     readonly queryId: QueryId;
-    readonly result: QueryResult<AnyRow>;
+    readonly result: QueryResult<UnknownRow>;
 }

package/dist/cjs/plugin/with-schema/with-schema-plugin.d.ts

@@ -1,9 +1,10 @@
 import { QueryResult } from '../../driver/database-connection.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
-import { AnyRow, KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+import { UnknownRow } from '../../util/type-utils.js';
 export declare class WithSchemaPlugin implements KyselyPlugin {
     #private;
     constructor(schema: string);
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
-    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<AnyRow>>;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }