kysely 0.23.5 → 0.24.1

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressionBuilder = exports.createExpressionBuilder = void 0;
+const select_query_builder_js_1 = require("../query-builder/select-query-builder.js");
+const select_query_node_js_1 = require("../operation-node/select-query-node.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
+const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugin.js");
+const query_id_js_1 = require("../util/query-id.js");
+const function_module_js_1 = require("../query-builder/function-module.js");
+const reference_parser_js_1 = require("../parser/reference-parser.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const and_node_js_1 = require("../operation-node/and-node.js");
+const or_node_js_1 = require("../operation-node/or-node.js");
+const parens_node_js_1 = require("../operation-node/parens-node.js");
+const expression_wrapper_js_1 = require("./expression-wrapper.js");
+const unary_operation_parser_js_1 = require("../parser/unary-operation-parser.js");
+const value_parser_js_1 = require("../parser/value-parser.js");
+const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_EXECUTOR) {
+    function unary(op, expr) {
+        return new expression_wrapper_js_1.ExpressionWrapper((0, unary_operation_parser_js_1.parseUnaryOperation)(op, expr));
+    }
+    return {
+        get fn() {
+            return (0, function_module_js_1.createFunctionModule)();
+        },
+        selectFrom(table) {
+            return new select_query_builder_js_1.SelectQueryBuilder({
+                queryId: (0, query_id_js_1.createQueryId)(),
+                executor: executor,
+                queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(table)),
+            });
+        },
+        ref(reference) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, reference_parser_js_1.parseStringReference)(reference));
+        },
+        val(value) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, value_parser_js_1.parseValueExpressionOrList)(value));
+        },
+        cmpr(lhs, op, rhs) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseValueBinaryOperation)(lhs, op, rhs));
+        },
+        bxp(lhs, op, rhs) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseValueBinaryOperation)(lhs, op, rhs));
+        },
+        unary,
+        not(expr) {
+            return unary('not', expr);
+        },
+        exists(expr) {
+            return unary('exists', expr);
+        },
+        neg(expr) {
+            return unary('-', expr);
+        },
+        and(exprs) {
+            if (exprs.length === 0) {
+                return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(true));
+            }
+            else if (exprs.length === 1) {
+                return new expression_wrapper_js_1.ExpressionWrapper(exprs[0].toOperationNode());
+            }
+            let node = and_node_js_1.AndNode.create(exprs[0].toOperationNode(), exprs[1].toOperationNode());
+            for (let i = 2; i < exprs.length; ++i) {
+                node = and_node_js_1.AndNode.create(node, exprs[i].toOperationNode());
+            }
+            return new expression_wrapper_js_1.ExpressionWrapper(parens_node_js_1.ParensNode.create(node));
+        },
+        or(exprs) {
+            if (exprs.length === 0) {
+                return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(false));
+            }
+            else if (exprs.length === 1) {
+                return new expression_wrapper_js_1.ExpressionWrapper(exprs[0].toOperationNode());
+            }
+            let node = or_node_js_1.OrNode.create(exprs[0].toOperationNode(), exprs[1].toOperationNode());
+            for (let i = 2; i < exprs.length; ++i) {
+                node = or_node_js_1.OrNode.create(node, exprs[i].toOperationNode());
+            }
+            return new expression_wrapper_js_1.ExpressionWrapper(parens_node_js_1.ParensNode.create(node));
+        },
+        withSchema(schema) {
+            return createExpressionBuilder(executor.withPluginAtFront(new with_schema_plugin_js_1.WithSchemaPlugin(schema)));
+        },
+    };
+}
+exports.createExpressionBuilder = createExpressionBuilder;
+function expressionBuilder(_) {
+    return createExpressionBuilder();
+}
+exports.expressionBuilder = expressionBuilder;

package/dist/cjs/expression/expression-wrapper.d.ts

@@ -0,0 +1,92 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { AliasedExpression, Expression } from './expression.js';
+export declare class ExpressionWrapper<T> implements Expression<T> {
+    #private;
+    constructor(node: OperationNode);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): T | undefined;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(eb =>
+     *     eb.cmpr('first_name', '=', 'Jennifer').as('is_jennifer')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `is_jennifer: SqlBool` field exists in the result type.
+     * console.log(result.is_jennifer)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select "first_name" = $1 as "is_jennifer"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedExpression<T, A>;
+    as<A extends string>(alias: Expression<unknown>): AliasedExpression<T, A>;
+    /**
+     * Change the output type of the raw expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `ExpressionWrapper` with a new output type.
+     */
+    $castTo<T>(): ExpressionWrapper<T>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): OperationNode;
+}
+export declare class AliasedExpressionWrapper<T, A extends string> implements AliasedExpression<T, A> {
+    #private;
+    constructor(expr: Expression<T>, alias: A | Expression<unknown>);
+    /** @private */
+    /**
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<T>;
+    /** @private */
+    /**
+     * Returns the alias.
+     */
+    get alias(): A | Expression<unknown>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     */
+    toOperationNode(): AliasNode;
+}

package/dist/cjs/expression/expression-wrapper.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasedExpressionWrapper = exports.ExpressionWrapper = void 0;
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+class ExpressionWrapper {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    as(alias) {
+        return new AliasedExpressionWrapper(this, alias);
+    }
+    /**
+     * Change the output type of the raw expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `ExpressionWrapper` with a new output type.
+     */
+    $castTo() {
+        return new ExpressionWrapper(this.#node);
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}
+exports.ExpressionWrapper = ExpressionWrapper;
+class AliasedExpressionWrapper {
+    #expr;
+    #alias;
+    constructor(expr, alias) {
+        this.#expr = expr;
+        this.#alias = alias;
+    }
+    /** @private */
+    get expression() {
+        return this.#expr;
+    }
+    /** @private */
+    get alias() {
+        return this.#alias;
+    }
+    toOperationNode() {
+        return alias_node_js_1.AliasNode.create(this.#expr.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias)
+            ? this.#alias.toOperationNode()
+            : identifier_node_js_1.IdentifierNode.create(this.#alias));
+    }
+}
+exports.AliasedExpressionWrapper = AliasedExpressionWrapper;

package/dist/cjs/expression/expression.d.ts

@@ -90,7 +90,7 @@ export interface AliasedExpression<T, A extends string> extends OperationNodeSou
     /**
      * Returns the alias.
      */
-    get alias(): A;
+    get alias(): A | Expression<unknown>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      */

package/dist/cjs/helpers/mysql.d.ts

@@ -0,0 +1,140 @@
+import { Expression } from '../expression/expression.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Simplify } from '../util/type-utils.js';
+/**
+ * A MySQL helper for aggregating a subquery (or other expression) into a JSON array.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
+ * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
+ * may not parse the nested results into arrays.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (MySQL):
+ *
+ * ```sql
+ * select `id`, (
+ *   select cast(coalesce(json_arrayagg(json_object(
+ *     'pet_id', `agg`.`pet_id`,
+ *     'name', `agg`.`name`
+ *   )), '[]') as json) from (
+ *     select `pet`.`id` as `pet_id`, `pet`.`name`
+ *     from `pet`
+ *     where `pet`.`owner_id` = `person`.`id`
+ *     order by `pet`.`name`
+ *   ) as `agg`
+ * ) as `pets`
+ * from `person`
+ * ```
+ */
+export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O>[]>;
+/**
+ * A MySQL helper for turning a subquery (or other expression) into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
+ * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (MySQL):
+ *
+ * ```sql
+ * select `id`, (
+ *   select json_object(
+ *     'pet_id', `obj`.`pet_id`,
+ *     'name', `obj`.`name`
+ *   ) from (
+ *     select `pet`.`id` as `pet_id`, `pet`.`name`
+ *     from `pet`
+ *     where `pet`.`owner_id` = `person`.`id`
+ *     and `pet`.`is_favorite` = ?
+ *   ) as obj
+ * ) as `favorite_pet`
+ * from `person`
+ * ```
+ */
+export declare function jsonObjectFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O>>;
+/**
+ * The MySQL `json_object` function.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
+ * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: eb.fn('concat', ['first_name', eb.val(' '), 'last_name'])
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (MySQL):
+ *
+ * ```sql
+ * select "id", json_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', concat(`first_name`, ?, `last_name`)
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
+    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+}>>;

package/dist/cjs/helpers/mysql.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonBuildObject = exports.jsonObjectFrom = exports.jsonArrayFrom = void 0;
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const column_node_js_1 = require("../operation-node/column-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const reference_node_js_1 = require("../operation-node/reference-node.js");
+const sql_js_1 = require("../raw-builder/sql.js");
+/**
+ * A MySQL helper for aggregating a subquery (or other expression) into a JSON array.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
+ * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
+ * may not parse the nested results into arrays.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (MySQL):
+ *
+ * ```sql
+ * select `id`, (
+ *   select cast(coalesce(json_arrayagg(json_object(
+ *     'pet_id', `agg`.`pet_id`,
+ *     'name', `agg`.`name`
+ *   )), '[]') as json) from (
+ *     select `pet`.`id` as `pet_id`, `pet`.`name`
+ *     from `pet`
+ *     where `pet`.`owner_id` = `person`.`id`
+ *     order by `pet`.`name`
+ *   ) as `agg`
+ * ) as `pets`
+ * from `person`
+ * ```
+ */
+function jsonArrayFrom(expr) {
+    return (0, sql_js_1.sql) `(select cast(coalesce(json_arrayagg(json_object(${sql_js_1.sql.join(getJsonObjectArgs(expr.toOperationNode(), 'agg'))})), '[]') as json) from ${expr} as agg)`;
+}
+exports.jsonArrayFrom = jsonArrayFrom;
+/**
+ * A MySQL helper for turning a subquery (or other expression) into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
+ * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (MySQL):
+ *
+ * ```sql
+ * select `id`, (
+ *   select json_object(
+ *     'pet_id', `obj`.`pet_id`,
+ *     'name', `obj`.`name`
+ *   ) from (
+ *     select `pet`.`id` as `pet_id`, `pet`.`name`
+ *     from `pet`
+ *     where `pet`.`owner_id` = `person`.`id`
+ *     and `pet`.`is_favorite` = ?
+ *   ) as obj
+ * ) as `favorite_pet`
+ * from `person`
+ * ```
+ */
+function jsonObjectFrom(expr) {
+    return (0, sql_js_1.sql) `(select json_object(${sql_js_1.sql.join(getJsonObjectArgs(expr.toOperationNode(), 'obj'))}) from ${expr} as obj)`;
+}
+exports.jsonObjectFrom = jsonObjectFrom;
+/**
+ * The MySQL `json_object` function.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
+ * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: eb.fn('concat', ['first_name', eb.val(' '), 'last_name'])
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (MySQL):
+ *
+ * ```sql
+ * select "id", json_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', concat(`first_name`, ?, `last_name`)
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+function jsonBuildObject(obj) {
+    return (0, sql_js_1.sql) `json_object(${sql_js_1.sql.join(Object.keys(obj).flatMap((k) => [sql_js_1.sql.lit(k), obj[k]]))})`;
+}
+exports.jsonBuildObject = jsonBuildObject;
+function getJsonObjectArgs(node, table) {
+    return node.selections.flatMap(({ selection: s }) => {
+        if (reference_node_js_1.ReferenceNode.is(s) && column_node_js_1.ColumnNode.is(s.column)) {
+            return [
+                sql_js_1.sql.lit(s.column.column.name),
+                sql_js_1.sql.id(table, s.column.column.name),
+            ];
+        }
+        else if (column_node_js_1.ColumnNode.is(s)) {
+            return [sql_js_1.sql.lit(s.column.name), sql_js_1.sql.id(table, s.column.name)];
+        }
+        else if (alias_node_js_1.AliasNode.is(s) && identifier_node_js_1.IdentifierNode.is(s.alias)) {
+            return [sql_js_1.sql.lit(s.alias.name), sql_js_1.sql.id(table, s.alias.name)];
+        }
+        else {
+            throw new Error('MySQL jsonArrayFrom and jsonObjectFrom functions can only handle explicit selections due to limitations of the json_object function. selectAll() is not allowed in the subquery.');
+        }
+    });
+}

package/dist/cjs/helpers/postgres.d.ts

@@ -0,0 +1,133 @@
+import { Expression } from '../expression/expression.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Simplify } from '../util/type-utils.js';
+/**
+ * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into arrays.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce(json_agg(agg), '[]') from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *   ) as agg
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>[]>;
+/**
+ * A postgres helper for turning a subquery (or other expression) into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select to_json(obj) from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = $1
+ *   ) as obj
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>>;
+/**
+ * The PostgreSQL `json_build_object` function.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: sql<string>`first_name || ' ' || last_name`
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", json_build_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', first_name || ' ' || last_name
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
+    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+}>>;