kysely 0.7.7 → 0.8.1

package/dist/cjs/raw-builder/raw-builder.js

@@ -7,52 +7,57 @@ const raw_node_js_1 = require("../operation-node/raw-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
-const query_id_js_1 = require("../util/query-id.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class RawBuilder {
-    #queryId;
-    #sql;
-    #params;
-    #executor;
-    constructor(args) {
-        this.#queryId = (0, query_id_js_1.createQueryId)();
-        this.#sql = args.sql;
-        this.#params = args.params;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
+    /**
+     * Change the output type of the raw expression.
+     *
+     * This doesn't produce any SQL. This methods simply returns a copy
+     * of this `RawBuilder` with a new output type.
+     */
+    castTo() {
+        return new RawBuilder({
+            ...this.#props,
+        });
+    }
     toOperationNode() {
-        const bindingRegex = /(\?\??)/g;
-        const sql = this.#sql;
-        const params = this.#params ?? [];
+        const parameterPlaceholderRegex = /(\?\??)/g;
+        const sql = this.#props.sql;
+        const parameters = this.#props.parameters ?? [];
         const sqlFragments = [];
         const argNodes = [];
         let paramIdx = 0;
         let sqlIdx = 0;
         let match = null;
-        while ((match = bindingRegex.exec(sql))) {
+        while ((match = parameterPlaceholderRegex.exec(sql))) {
             const str = match[1];
-            if (paramIdx >= params.length) {
-                throw new Error(`value not provided for all bindings in string ${sql}`);
+            if (paramIdx >= parameters.length) {
+                throw new Error(`value not provided for all placeholders in string ${sql}`);
             }
             if (match.index > 0 && sql[match.index - 1] === '\\') {
                 continue;
             }
             sqlFragments.push(sql.slice(sqlIdx, match.index).replaceAll('\\?', '?'));
-            argNodes.push(parseRawArg(str, params[paramIdx]));
+            argNodes.push(parseRawArg(str, parameters[paramIdx]));
             sqlIdx = match.index + str.length;
             ++paramIdx;
         }
         sqlFragments.push(sql.slice(sqlIdx));
         const rawNode = raw_node_js_1.RawNode.create(sqlFragments, argNodes);
-        return this.#executor.transformQuery(rawNode, this.#queryId);
+        return this.#props.executor.transformQuery(rawNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        return this.#executor.executeQuery(this.compile(), this.#queryId);
+        return this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 exports.RawBuilder = RawBuilder;

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -7,7 +7,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from './column-definition-builder.js';
-import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 import { QueryId } from '../util/query-id.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';

package/dist/cjs/schema/column-definition-builder.d.ts

@@ -2,7 +2,7 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
-import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
 export interface ColumnDefinitionBuilderInterface<R> {
     /**

package/dist/cjs/util/generated-placeholder.d.ts

@@ -1,3 +1,3 @@
-import { GeneratedPlaceholder } from '../query-builder/type-utils.js';
-export declare const generatedPlaceholder: GeneratedPlaceholder;
+import { GeneratedPlaceholder } from './type-utils.js';
+export declare const GENERATED_PLACEHOLDER: GeneratedPlaceholder;
 export declare function isGeneratedPlaceholder(obj: unknown): obj is GeneratedPlaceholder;

package/dist/cjs/util/generated-placeholder.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGeneratedPlaceholder = exports.generatedPlaceholder = void 0;
+exports.isGeneratedPlaceholder = exports.GENERATED_PLACEHOLDER = void 0;
 const object_utils_js_1 = require("./object-utils.js");
-exports.generatedPlaceholder = (0, object_utils_js_1.freeze)({
+exports.GENERATED_PLACEHOLDER = (0, object_utils_js_1.freeze)({
     __isGeneratedPlaceholder__: true,
 });
 function isGeneratedPlaceholder(obj) {

package/dist/cjs/util/random-string.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomString = void 0;
 const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
 function randomString(length) {
-    let str = '';
+    let chars = new Array(length);
     for (let i = 0; i < length; ++i) {
-        str += CHARS[Math.floor(Math.random() * CHARS.length)];
+        chars[i] = CHARS[Math.floor(Math.random() * CHARS.length)];
     }
-    return str;
+    return chars.join('');
 }
 exports.randomString = randomString;

package/dist/cjs/{query-builder → util}/type-utils.d.ts

@@ -1,6 +1,9 @@
 import { AliasedRawBuilder, RawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilder, QueryBuilder } from './query-builder.js';
-import { ExpressionBuilder } from './expression-builder.js';
+import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
+import { ExpressionBuilder } from '../query-builder/expression-builder.js';
+/**
+ * Given an object type, extracts the union of all value types.
+ */
 export declare type ValueType<T> = T[keyof T];
 /**
  * Given a database type and a union of table names returns the row type
@@ -38,7 +41,7 @@ export declare type RowType<DB, TB extends keyof DB> = UnionToIntersection<DB[TB
  * Evil typescript magic to convert a union type `A | B | C` into an
  * intersection type `A & B & C`.
  */
-export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /**
  * Given a database type and a union of table names in that db, returns
  * a union type with all possible column names.
@@ -150,3 +153,8 @@ export interface GeneratedPlaceholder {
 export declare type ManyResultRowType<O> = O extends InsertResultTypeTag ? number | undefined : O extends DeleteResultTypeTag ? number : O extends UpdateResultTypeTag ? number : O;
 export declare type SingleResultRowType<O> = O extends InsertResultTypeTag ? number | undefined : O extends DeleteResultTypeTag ? number : O extends UpdateResultTypeTag ? number : O | undefined;
 export declare type NonEmptySingleResultRowType<O> = O extends InsertResultTypeTag ? number : O extends DeleteResultTypeTag ? number : O extends UpdateResultTypeTag ? number : O;
+export declare type UnknownRow = Record<string, unknown>;
+export declare type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+export {};

package/dist/esm/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/esm/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/esm/dialect/mysql/mysql-adapter.js

@@ -8,6 +8,12 @@ export 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/esm/dialect/mysql/mysql-driver.js

@@ -50,16 +50,16 @@ export 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;
@@ -127,7 +127,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/esm/dialect/postgres/postgres-driver.js

@@ -37,18 +37,18 @@ export 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;
@@ -86,7 +86,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/esm/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/esm/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/esm/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/esm/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/esm/kysely.js

@@ -3,7 +3,7 @@ import { DynamicModule } from './dynamic/dynamic.js';
 import { DefaultConnectionProvider } from './driver/default-connection-provider.js';
 import { MigrationModule } from './migration/migration.js';
 import { QueryCreator } from './query-creator.js';
-import { generatedPlaceholder } from './util/generated-placeholder.js';
+import { GENERATED_PLACEHOLDER } from './util/generated-placeholder.js';
 import { DefaultQueryExecutor } from './query-executor/default-query-executor.js';
 import { freeze, isObject } from './util/object-utils.js';
 import { RuntimeDriver } from './driver/runtime-driver.js';
@@ -11,6 +11,7 @@ import { SingleConnectionProvider } from './driver/single-connection-provider.js
 import { TRANSACTION_ISOLATION_LEVELS, } from './driver/driver.js';
 import { preventAwait } from './util/prevent-await.js';
 import { DefaultParseContext } from './parser/parse-context.js';
+import { FunctionBuilder } from './query-builder/function-builder.js';
 /**
  * The main Kysely class.
  *
@@ -128,7 +129,38 @@ export class Kysely extends QueryCreator {
      * ```
      */
     get generated() {
-        return generatedPlaceholder;
+        return 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 FunctionBuilder({ executor: this.#props.executor });
     }
     /**
      * Starts a transaction. If the callback throws the transaction is rolled back,

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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;