kysely 0.26.3 → 0.27.1

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

@@ -3,17 +3,18 @@ import { TableExpression, From, FromTables, ExtractTableAlias, AnyAliasedTable,
 import { FunctionModule } from '../query-builder/function-module.js';
 import { ExtractTypeFromReferenceExpression, ReferenceExpression, SimpleReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
-import { BinaryOperatorExpression, ComparisonOperatorExpression, FilterObject, OperandValueExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { BinaryOperatorExpression, FilterObject, OperandValueExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { Expression } from './expression.js';
 import { ExpressionWrapper } from './expression-wrapper.js';
 import { ComparisonOperator, JSONOperatorWith$, UnaryOperator } from '../operation-node/operator-node.js';
-import { SqlBool } from '../util/type-utils.js';
+import { IsNever, SqlBool } from '../util/type-utils.js';
 import { ExtractTypeFromValueExpression } from '../parser/value-parser.js';
 import { CaseBuilder } from '../query-builder/case-builder.js';
 import { JSONPathBuilder } from '../query-builder/json-path-builder.js';
 import { OperandExpression } from '../parser/expression-parser.js';
-import { CallbackSelection, SelectCallback, SelectExpression, Selection } from '../parser/select-parser.js';
 import { RefTuple2, RefTuple3, RefTuple4, RefTuple5, ValTuple2, ValTuple3, ValTuple4, ValTuple5 } from '../parser/tuple-parser.js';
+import { Selectable } from '../util/column-type.js';
+import { KyselyTypeError } from '../util/type-error.js';
 export interface ExpressionBuilder<DB, TB extends keyof DB> {
     /**
      * Creates a binary expression.
@@ -89,7 +90,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      *   ))
      * ```
      */
-    <RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression>(lhs: RE, op: OP, rhs: OperandValueExpressionOrList<DB, TB, RE>): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    <RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: OP, rhs: VE): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
     /**
      * Returns a copy of `this` expression builder, for destructuring purposes.
      *
@@ -195,18 +196,6 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
     selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, TB | ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
-    /**
-     * Creates a `select` expression without a `from` clause.
-     *
-     * If you want to create a `select from` query, use the `selectFrom` method instead.
-     * This one can be used to create a plain `select` statement without a `from` clause.
-     *
-     * This method accepts the same inputs as {@link SelectQueryBuilder.select}. See its
-     * documentation for examples.
-     */
-    selectNoFrom<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): SelectQueryBuilder<DB, TB, Selection<DB, TB, SE>>;
-    selectNoFrom<CB extends SelectCallback<DB, TB>>(callback: CB): SelectQueryBuilder<DB, TB, CallbackSelection<DB, TB, CB>>;
-    selectNoFrom<SE extends SelectExpression<DB, TB>>(selection: SE): SelectQueryBuilder<DB, TB, Selection<DB, TB, SE>>;
     /**
      * Creates a `case` statement/operator.
      *
@@ -260,13 +249,14 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      */
     case(): CaseBuilder<DB, TB>;
     case<C extends SimpleReferenceExpression<DB, TB>>(column: C): CaseBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>;
-    case<O>(expression: Expression<O>): CaseBuilder<DB, TB, O>;
+    case<E extends Expression<any>>(expression: E): CaseBuilder<DB, TB, ExtractTypeFromValueExpression<E>>;
     /**
      * This method can be used to reference columns within the query's context. For
      * a non-type-safe version of this method see {@link sql}'s version.
      *
      * Additionally, this method can be used to reference nested JSON properties or
-     * array elements. See {@link JSONPathBuilder} for more information.
+     * array elements. See {@link JSONPathBuilder} for more information. For regular
+     * JSON path expressions you can use {@link jsonPath}.
      *
      * ### Examples
      *
@@ -344,6 +334,57 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      */
     ref<RE extends StringReference<DB, TB>>(reference: RE): ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
     ref<RE extends StringReference<DB, TB>>(reference: RE, op: JSONOperatorWith$): JSONPathBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    /**
+     * Creates a JSON path expression with provided column as root document (the $).
+     *
+     * For a JSON reference expression, see {@link ref}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .set('experience', (eb) => eb.fn('json_set', [
+     *     'experience',
+     *     eb.jsonPath<'experience'>().at('last').key('title'),
+     *     eb.val('CEO')
+     *   ]))
+     *   .where('id', '=', id)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * update `person`
+     * set `experience` = json_set(`experience`, '$[last].title', ?)
+     * where `id` = ?
+     * ```
+     */
+    jsonPath<$ extends StringReference<DB, TB> = never>(): IsNever<$> extends true ? KyselyTypeError<"You must provide a column reference as this method's $ generic"> : JSONPathBuilder<ExtractTypeFromReferenceExpression<DB, TB, $>>;
+    /**
+     * Creates a table reference.
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select(eb => [
+     *     'person.id',
+     *     sql<Pet[]>`jsonb_agg(${eb.table('pet')})`.as('pets')
+     *   ])
+     *   .groupBy('person.id')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."id", jsonb_agg("pet") as "pets"
+     * from "person"
+     * inner join "pet" on "pet"."owner_id" = "person"."id"
+     * group by "person"."id"
+     * ```
+     */
+    table<T extends TB & string>(table: T): ExpressionWrapper<DB, TB, Selectable<DB[T]>>;
     /**
      * Returns a value expression.
      *
@@ -504,56 +545,6 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * ```
      */
     lit<VE extends number | boolean | null>(literal: VE): ExpressionWrapper<DB, TB, VE>;
-    /**
-     * @deprecated Use the expression builder as a function instead.
-     *
-     * Before:
-     *
-     * ```ts
-     * where((eb) => eb.cmpr('first_name', '=', 'Jennifer'))
-     * ```
-     *
-     * After:
-     *
-     * ```ts
-     * where((eb) => eb('first_name', '=', 'Jennifer'))
-     * ```
-     *
-     * or
-     *
-     * ```ts
-     * where(({ eb }) => eb('first_name', '=', 'Jennifer'))
-     * ```
-     */
-    cmpr<O extends SqlBool = SqlBool, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): ExpressionWrapper<DB, TB, O>;
-    /**
-     * @deprecated Use the expression builder as a function instead.
-     *
-     * Before:
-     *
-     * ```ts
-     * set((eb) => ({
-     *   age: eb.bxp('age', '+', 10)
-     * }))
-     * ```
-     *
-     * After:
-     *
-     * ```ts
-     * set((eb) => ({
-     *   age: eb('age', '+', 10)
-     * }))
-     * ```
-     *
-     * or
-     *
-     * ```ts
-     * set(({ eb }) => ({
-     *   age: eb('age', '+', 10)
-     * }))
-     * ```
-     */
-    bxp<RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression>(lhs: RE, op: OP, rhs: OperandValueExpression<DB, TB, RE>): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
     /**
      * Creates an unary expression.
      *
@@ -621,7 +612,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * select * from "person" where "age" between $1 and $2
      * ```
      */
-    between<RE extends ReferenceExpression<DB, TB>>(expr: RE, start: OperandValueExpression<DB, TB, RE>, end: OperandValueExpression<DB, TB, RE>): ExpressionWrapper<DB, TB, SqlBool>;
+    between<RE extends ReferenceExpression<DB, TB>, SE extends OperandValueExpression<DB, TB, RE>, EE extends OperandValueExpression<DB, TB, RE>>(expr: RE, start: SE, end: EE): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Creates a `between symmetric` expression.
      *
@@ -639,7 +630,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * select * from "person" where "age" between symmetric $1 and $2
      * ```
      */
-    betweenSymmetric<RE extends ReferenceExpression<DB, TB>>(expr: RE, start: OperandValueExpression<DB, TB, RE>, end: OperandValueExpression<DB, TB, RE>): ExpressionWrapper<DB, TB, SqlBool>;
+    betweenSymmetric<RE extends ReferenceExpression<DB, TB>, SE extends OperandValueExpression<DB, TB, RE>, EE extends OperandValueExpression<DB, TB, RE>>(expr: RE, start: SE, end: EE): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Combines two or more expressions using the logical `and` operator.
      *
@@ -698,8 +689,8 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * )
      * ```
      */
-    and(exprs: ReadonlyArray<OperandExpression<SqlBool>>): ExpressionWrapper<DB, TB, SqlBool>;
-    and(exprs: Readonly<FilterObject<DB, TB>>): ExpressionWrapper<DB, TB, SqlBool>;
+    and<E extends OperandExpression<SqlBool>>(exprs: ReadonlyArray<E>): ExpressionWrapper<DB, TB, SqlBool>;
+    and<E extends Readonly<FilterObject<DB, TB>>>(exprs: E): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Combines two or more expressions using the logical `or` operator.
      *
@@ -758,8 +749,8 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * )
      * ```
      */
-    or(exprs: ReadonlyArray<OperandExpression<SqlBool>>): ExpressionWrapper<DB, TB, SqlBool>;
-    or(exprs: Readonly<FilterObject<DB, TB>>): ExpressionWrapper<DB, TB, SqlBool>;
+    or<E extends OperandExpression<SqlBool>>(exprs: ReadonlyArray<E>): ExpressionWrapper<DB, TB, SqlBool>;
+    or<E extends Readonly<FilterObject<DB, TB>>>(exprs: E): ExpressionWrapper<DB, TB, SqlBool>;
     /**
      * Wraps the expression in parentheses.
      *
@@ -799,7 +790,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * where ("age" = $1 or "age" = $2) and ("first_name" = $3 or "first_name" = $4)
      * ```
      */
-    parens<RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression>(lhs: RE, op: OP, rhs: OperandValueExpressionOrList<DB, TB, RE>): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    parens<RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: OP, rhs: VE): ExpressionWrapper<DB, TB, OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
     parens<T>(expr: Expression<T>): ExpressionWrapper<DB, TB, T>;
     /**
      * See {@link QueryCreator.withSchema}

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

@@ -21,8 +21,8 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const json_path_builder_js_1 = require("../query-builder/json-path-builder.js");
 const binary_operation_node_js_1 = require("../operation-node/binary-operation-node.js");
 const and_node_js_1 = require("../operation-node/and-node.js");
-const select_parser_js_1 = require("../parser/select-parser.js");
 const tuple_node_js_1 = require("../operation-node/tuple-node.js");
+const json_path_node_js_1 = require("../operation-node/json-path-node.js");
 function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_EXECUTOR) {
     function binary(lhs, op, rhs) {
         return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseValueBinaryOperation)(lhs, op, rhs));
@@ -40,13 +40,6 @@ function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_
                 queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)(table)),
             });
         },
-        selectNoFrom(selection) {
-            return (0, select_query_builder_js_1.createSelectQueryBuilder)({
-                queryId: (0, query_id_js_1.createQueryId)(),
-                executor,
-                queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSelections(select_query_node_js_1.SelectQueryNode.create(), (0, select_parser_js_1.parseSelectArg)(selection)),
-            });
-        },
         case(reference) {
             return new case_builder_js_1.CaseBuilder({
                 node: case_node_js_1.CaseNode.create((0, object_utils_js_1.isUndefined)(reference)
@@ -60,8 +53,14 @@ function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_
             }
             return new json_path_builder_js_1.JSONPathBuilder((0, reference_parser_js_1.parseJSONReference)(reference, op));
         },
+        jsonPath() {
+            return new json_path_builder_js_1.JSONPathBuilder(json_path_node_js_1.JSONPathNode.create());
+        },
+        table(table) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, table_parser_js_1.parseTable)(table));
+        },
         val(value) {
-            return new expression_wrapper_js_1.ExpressionWrapper((0, value_parser_js_1.parseValueExpressionOrList)(value));
+            return new expression_wrapper_js_1.ExpressionWrapper((0, value_parser_js_1.parseValueExpression)(value));
         },
         refTuple(...values) {
             return new expression_wrapper_js_1.ExpressionWrapper(tuple_node_js_1.TupleNode.create(values.map(reference_parser_js_1.parseReferenceExpression)));
@@ -72,14 +71,6 @@ function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_
         lit(value) {
             return new expression_wrapper_js_1.ExpressionWrapper((0, value_parser_js_1.parseSafeImmediateValue)(value));
         },
-        // @deprecated
-        cmpr(lhs, op, rhs) {
-            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseValueBinaryOperation)(lhs, op, rhs));
-        },
-        // @deprecated
-        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);

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

@@ -173,8 +173,8 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * )
      * ```
      */
-    or<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
-    or(expression: OperandExpression<SqlBool>): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
+    or<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
+    or<E extends OperandExpression<SqlBool>>(expression: E): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
     /**
      * Combines `this` and another expression using `AND`.
      *
@@ -235,15 +235,25 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * )
      * ```
      */
-    and<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
-    and(expression: OperandExpression<SqlBool>): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
+    and<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
+    and<E extends OperandExpression<SqlBool>>(expression: E): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
     /**
      * Change the output type of the 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<DB, TB, T>;
+    $castTo<C>(): ExpressionWrapper<DB, TB, C>;
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull(): ExpressionWrapper<DB, TB, Exclude<T, null>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -389,15 +399,15 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      *
      * See {@link ExpressionWrapper.or} for examples.
      */
-    or<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OrWrapper<DB, TB, T>;
-    or(expression: OperandExpression<SqlBool>): OrWrapper<DB, TB, T>;
+    or<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): OrWrapper<DB, TB, T>;
+    or<E extends OperandExpression<SqlBool>>(expression: E): OrWrapper<DB, TB, T>;
     /**
      * Change the output type of the expression.
      *
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `OrWrapper` with a new output type.
      */
-    $castTo<T extends SqlBool>(): OrWrapper<DB, TB, T>;
+    $castTo<C extends SqlBool>(): OrWrapper<DB, TB, C>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -525,15 +535,15 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      *
      * See {@link ExpressionWrapper.and} for examples.
      */
-    and<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AndWrapper<DB, TB, T>;
-    and(expression: OperandExpression<SqlBool>): AndWrapper<DB, TB, T>;
+    and<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): AndWrapper<DB, TB, T>;
+    and<E extends OperandExpression<SqlBool>>(expression: E): AndWrapper<DB, TB, T>;
     /**
      * Change the output type of the expression.
      *
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `AndWrapper` with a new output type.
      */
-    $castTo<T extends SqlBool>(): AndWrapper<DB, TB, T>;
+    $castTo<C extends SqlBool>(): AndWrapper<DB, TB, C>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *

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

@@ -35,6 +35,18 @@ class ExpressionWrapper {
     $castTo() {
         return new ExpressionWrapper(this.#node);
     }
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull() {
+        return new ExpressionWrapper(this.#node);
+    }
     toOperationNode() {
         return this.#node;
     }

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

@@ -0,0 +1,152 @@
+import { Expression } from '../expression/expression.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Simplify } from '../util/type-utils.js';
+/**
+ * An MS SQL Server helper for aggregating a subquery into a JSON array.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *         .modifyEnd(sql`offset 0 rows`)
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce((select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *     offset 0 rows
+ *   ) as "agg" for json path, include_null_values), '[]')
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>[]>;
+/**
+ * An MS SQL Server helper for turning a subquery into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', 1)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = @1
+ *   ) as "agg" for json path, include_null_values, without_array_wrapper
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O> | null>;
+/**
+ * The MS SQL Server `json_query` function, single argument variant.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### 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()
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", json_query(
+ *   '{"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;
+}>>;