kysely 0.28.17 → 0.29.0

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

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExpressionBuilder = createExpressionBuilder;
-exports.expressionBuilder = expressionBuilder;
-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 parens_node_js_1 = require("../operation-node/parens-node.js");
-const expression_wrapper_js_1 = require("./expression-wrapper.js");
-const operator_node_js_1 = require("../operation-node/operator-node.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 case_builder_js_1 = require("../query-builder/case-builder.js");
-const case_node_js_1 = require("../operation-node/case-node.js");
-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 tuple_node_js_1 = require("../operation-node/tuple-node.js");
-const json_path_node_js_1 = require("../operation-node/json-path-node.js");
-const data_type_parser_js_1 = require("../parser/data-type-parser.js");
-const cast_node_js_1 = require("../operation-node/cast-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));
-    }
-    function unary(op, expr) {
-        return new expression_wrapper_js_1.ExpressionWrapper((0, unary_operation_parser_js_1.parseUnaryOperation)(op, expr));
-    }
-    const eb = Object.assign(binary, {
-        fn: undefined,
-        eb: undefined,
-        selectFrom(table) {
-            return (0, select_query_builder_js_1.createSelectQueryBuilder)({
-                queryId: (0, query_id_js_1.createQueryId)(),
-                executor,
-                queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)(table)),
-            });
-        },
-        case(reference) {
-            return new case_builder_js_1.CaseBuilder({
-                node: case_node_js_1.CaseNode.create((0, object_utils_js_1.isUndefined)(reference)
-                    ? undefined
-                    : (0, reference_parser_js_1.parseReferenceExpression)(reference)),
-            });
-        },
-        ref(reference, op) {
-            if ((0, object_utils_js_1.isUndefined)(op)) {
-                return new expression_wrapper_js_1.ExpressionWrapper((0, reference_parser_js_1.parseStringReference)(reference));
-            }
-            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.parseValueExpression)(value));
-        },
-        refTuple(...values) {
-            return new expression_wrapper_js_1.ExpressionWrapper(tuple_node_js_1.TupleNode.create(values.map(reference_parser_js_1.parseReferenceExpression)));
-        },
-        tuple(...values) {
-            return new expression_wrapper_js_1.ExpressionWrapper(tuple_node_js_1.TupleNode.create(values.map(value_parser_js_1.parseValueExpression)));
-        },
-        lit(value) {
-            return new expression_wrapper_js_1.ExpressionWrapper((0, value_parser_js_1.parseSafeImmediateValue)(value));
-        },
-        unary,
-        not(expr) {
-            return unary('not', expr);
-        },
-        exists(expr) {
-            return unary('exists', expr);
-        },
-        neg(expr) {
-            return unary('-', expr);
-        },
-        between(expr, start, end) {
-            return new expression_wrapper_js_1.ExpressionWrapper(binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(expr), operator_node_js_1.OperatorNode.create('between'), and_node_js_1.AndNode.create((0, value_parser_js_1.parseValueExpression)(start), (0, value_parser_js_1.parseValueExpression)(end))));
-        },
-        betweenSymmetric(expr, start, end) {
-            return new expression_wrapper_js_1.ExpressionWrapper(binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(expr), operator_node_js_1.OperatorNode.create('between symmetric'), and_node_js_1.AndNode.create((0, value_parser_js_1.parseValueExpression)(start), (0, value_parser_js_1.parseValueExpression)(end))));
-        },
-        and(exprs) {
-            if ((0, object_utils_js_1.isReadonlyArray)(exprs)) {
-                return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseFilterList)(exprs, 'and'));
-            }
-            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseFilterObject)(exprs, 'and'));
-        },
-        or(exprs) {
-            if ((0, object_utils_js_1.isReadonlyArray)(exprs)) {
-                return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseFilterList)(exprs, 'or'));
-            }
-            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseFilterObject)(exprs, 'or'));
-        },
-        parens(...args) {
-            const node = (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args);
-            if (parens_node_js_1.ParensNode.is(node)) {
-                // No double wrapping.
-                return new expression_wrapper_js_1.ExpressionWrapper(node);
-            }
-            else {
-                return new expression_wrapper_js_1.ExpressionWrapper(parens_node_js_1.ParensNode.create(node));
-            }
-        },
-        cast(expr, dataType) {
-            return new expression_wrapper_js_1.ExpressionWrapper(cast_node_js_1.CastNode.create((0, reference_parser_js_1.parseReferenceExpression)(expr), (0, data_type_parser_js_1.parseDataTypeExpression)(dataType)));
-        },
-        withSchema(schema) {
-            return createExpressionBuilder(executor.withPluginAtFront(new with_schema_plugin_js_1.WithSchemaPlugin(schema)));
-        },
-    });
-    eb.fn = (0, function_module_js_1.createFunctionModule)();
-    eb.eb = eb;
-    return eb;
-}
-function expressionBuilder(_) {
-    return createExpressionBuilder();
-}

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

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AndWrapper = exports.OrWrapper = exports.AliasedExpressionWrapper = exports.ExpressionWrapper = void 0;
-const alias_node_js_1 = require("../operation-node/alias-node.js");
-const and_node_js_1 = require("../operation-node/and-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");
-const or_node_js_1 = require("../operation-node/or-node.js");
-const parens_node_js_1 = require("../operation-node/parens-node.js");
-const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
-class ExpressionWrapper {
-    #node;
-    constructor(node) {
-        this.#node = node;
-    }
-    /** @private */
-    get expressionType() {
-        return undefined;
-    }
-    as(alias) {
-        return new AliasedExpressionWrapper(this, alias);
-    }
-    or(...args) {
-        return new OrWrapper(or_node_js_1.OrNode.create(this.#node, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)));
-    }
-    and(...args) {
-        return new AndWrapper(and_node_js_1.AndNode.create(this.#node, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)));
-    }
-    /**
-     * 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() {
-        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;
-    }
-}
-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;
-class OrWrapper {
-    #node;
-    constructor(node) {
-        this.#node = node;
-    }
-    /** @private */
-    get expressionType() {
-        return undefined;
-    }
-    as(alias) {
-        return new AliasedExpressionWrapper(this, alias);
-    }
-    or(...args) {
-        return new OrWrapper(or_node_js_1.OrNode.create(this.#node, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)));
-    }
-    /**
-     * 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() {
-        return new OrWrapper(this.#node);
-    }
-    toOperationNode() {
-        return parens_node_js_1.ParensNode.create(this.#node);
-    }
-}
-exports.OrWrapper = OrWrapper;
-class AndWrapper {
-    #node;
-    constructor(node) {
-        this.#node = node;
-    }
-    /** @private */
-    get expressionType() {
-        return undefined;
-    }
-    as(alias) {
-        return new AliasedExpressionWrapper(this, alias);
-    }
-    and(...args) {
-        return new AndWrapper(and_node_js_1.AndNode.create(this.#node, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)));
-    }
-    /**
-     * 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() {
-        return new AndWrapper(this.#node);
-    }
-    toOperationNode() {
-        return parens_node_js_1.ParensNode.create(this.#node);
-    }
-}
-exports.AndWrapper = AndWrapper;

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

@@ -1,198 +0,0 @@
-import type { AliasNode } from '../operation-node/alias-node.js';
-import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
-import type { OperationNode } from '../operation-node/operation-node.js';
-/**
- * `Expression` represents an arbitrary SQL expression with a type.
- *
- * Most Kysely methods accept instances of `Expression` and most classes like `SelectQueryBuilder`
- * and the return value of the {@link sql} template tag implement it.
- *
- * ### Examples
- *
- * ```ts
- * import { type Expression, sql } from 'kysely'
- *
- * const exp1: Expression<string> = sql<string>`CONCAT('hello', ' ', 'world')`
- * const exp2: Expression<{ first_name: string }> = db.selectFrom('person').select('first_name')
- * ```
- *
- * You can implement the `Expression` interface to create your own type-safe utilities for Kysely.
- */
-export interface Expression<T> extends OperationNodeSource {
-    /**
-     * 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:
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { type Expression, type OperationNode, sql } from 'kysely'
-     *
-     * class SomeExpression<T> implements Expression<T> {
-     *   get expressionType(): T | undefined {
-     *     return undefined
-     *   }
-     *
-     *   toOperationNode(): OperationNode {
-     *     return sql`some sql here`.toOperationNode()
-     *   }
-     * }
-     * ```
-     *
-     * 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;
-    /**
-     * Creates the OperationNode that describes how to compile this expression into SQL.
-     *
-     * ### Examples
-     *
-     * If you are creating a custom expression, it's often easiest to use the {@link sql}
-     * template tag to build the node:
-     *
-     * ```ts
-     * import { type Expression, type OperationNode, sql } from 'kysely'
-     *
-     * class SomeExpression<T> implements Expression<T> {
-     *   get expressionType(): T | undefined {
-     *     return undefined
-     *   }
-     *
-     *   toOperationNode(): OperationNode {
-     *     return sql`some sql here`.toOperationNode()
-     *   }
-     * }
-     * ```
-     */
-    toOperationNode(): OperationNode;
-}
-/**
- * An expression with an `as` method.
- */
-export interface AliasableExpression<T> extends Expression<T> {
-    /**
-     * Returns an aliased version of the expression.
-     *
-     * ### Examples
-     *
-     * In addition to slapping `as "the_alias"` at the end of the expression,
-     * this method also provides strict typing:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select((eb) =>
-     *     // `eb.fn<string>` returns an AliasableExpression<string>
-     *     eb.fn<string>('concat', ['first_name', eb.val(' '), 'last_name']).as('full_name')
-     *   )
-     *   .executeTakeFirstOrThrow()
-     *
-     * // `full_name: string` field exists in the result type.
-     * console.log(result.full_name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select
-     *   concat("first_name", $1, "last_name") as "full_name"
-     * from
-     *   "person"
-     * ```
-     *
-     * You can also pass in a raw SQL snippet (or any expression) but in that case you must
-     * provide the alias as the only type argument:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
-     *
-     * // The alias is `t(a, b)` which specifies the column names
-     * // in addition to the table name. We must tell kysely that
-     * // columns of the table can be referenced through `t`
-     * // by providing an explicit type argument.
-     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
-     *
-     * await db
-     *   .insertInto('person')
-     *   .columns(['first_name', 'last_name'])
-     *   .expression(
-     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * insert into "person" ("first_name", "last_name")
-     * from (values (1, 'foo')) as t(a, b)
-     * select "t"."a", "t"."b"
-     * ```
-     */
-    as<A extends string>(alias: A): AliasedExpression<T, A>;
-    as<A extends string>(alias: Expression<any>): AliasedExpression<T, A>;
-}
-/**
- * A type that holds an expression and an alias for it.
- *
- * `AliasedExpression<T, A>` can be used in places where, in addition to the value type `T`, you
- * also need a name `A` for that value. For example anything you can pass into the `select` method
- * needs to implement an `AliasedExpression<T, A>`. `A` becomes the name of the selected expression
- * in the result and `T` becomes its type.
- *
- * ### Examples
- *
- * ```ts
- * import {
- *   AliasNode,
- *   type AliasedExpression,
- *   type Expression,
- *   IdentifierNode
- * } from 'kysely'
- *
- * class SomeAliasedExpression<T, A extends string> implements AliasedExpression<T, A> {
- *   #expression: Expression<T>
- *   #alias: A
- *
- *   constructor(expression: Expression<T>, alias: A) {
- *     this.#expression = expression
- *     this.#alias = alias
- *   }
- *
- *   get expression(): Expression<T> {
- *     return this.#expression
- *   }
- *
- *   get alias(): A {
- *     return this.#alias
- *   }
- *
- *   toOperationNode(): AliasNode {
- *     return AliasNode.create(
- *       this.#expression.toOperationNode(),
- *       IdentifierNode.create(this.#alias)
- *     )
- *   }
- * }
- * ```
- */
-export interface AliasedExpression<T, A extends string> extends OperationNodeSource {
-    /**
-     * Returns the aliased expression.
-     */
-    get expression(): Expression<T>;
-    /**
-     * Returns the alias.
-     */
-    get alias(): A | Expression<unknown>;
-    /**
-     * Creates the OperationNode that describes how to compile this expression into SQL.
-     */
-    toOperationNode(): AliasNode;
-}
-export declare function isExpression(obj: unknown): obj is Expression<any>;
-export declare function isAliasedExpression(obj: unknown): obj is AliasedExpression<any, any>;

package/dist/cjs/expression/expression.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExpression = isExpression;
-exports.isAliasedExpression = isAliasedExpression;
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
-const object_utils_js_1 = require("../util/object-utils.js");
-function isExpression(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && 'expressionType' in obj && (0, operation_node_source_js_1.isOperationNodeSource)(obj);
-}
-function isAliasedExpression(obj) {
-    return ((0, object_utils_js_1.isObject)(obj) &&
-        'expression' in obj &&
-        (0, object_utils_js_1.isString)(obj.alias) &&
-        (0, operation_node_source_js_1.isOperationNodeSource)(obj));
-}

package/dist/cjs/helpers/mssql.js

@@ -1,219 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonArrayFrom = jsonArrayFrom;
-exports.jsonObjectFrom = jsonObjectFrom;
-exports.jsonBuildObject = jsonBuildObject;
-const sql_js_1 = require("../raw-builder/sql.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
- * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
- * import * as Tarn from 'tarn'
- * import * as Tedious from 'tedious'
- * import type { Database } from 'type-editor' // imaginary module
- *
- * const db = new Kysely<Database>({
- *   dialect: new MssqlDialect({
- *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
- *     tedious: {
- *       ...Tedious,
- *       connectionFactory: () => new Tedious.Connection({
- *         authentication: {
- *           options: { password: 'password', userName: 'sa' },
- *           type: 'default',
- *         },
- *         options: { database: 'test', port: 21433, trustServerCertificate: true },
- *         server: 'localhost',
- *       }),
- *     },
- *   }),
- *   plugins: [new ParseJSONResultsPlugin()]
- * })
- * ```
- *
- * ### Examples
- *
- * ```ts
- * import { jsonArrayFrom } from 'kysely/helpers/mssql'
- *
- * 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')
- *         .offset(0)
- *     ).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 @1 rows
- *   ) as "agg" for json path, include_null_values), '[]')
- * ) as "pets"
- * from "person"
- * ```
- */
-function jsonArrayFrom(expr) {
-    return (0, sql_js_1.sql) `coalesce((select * from ${expr} as agg for json path, include_null_values), '[]')`;
-}
-/**
- * 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
- * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
- * import * as Tarn from 'tarn'
- * import * as Tedious from 'tedious'
- * import type { Database } from 'type-editor' // imaginary module
- *
- * const db = new Kysely<Database>({
- *   dialect: new MssqlDialect({
- *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
- *     tedious: {
- *       ...Tedious,
- *       connectionFactory: () => new Tedious.Connection({
- *         authentication: {
- *           options: { password: 'password', userName: 'sa' },
- *           type: 'default',
- *         },
- *         options: { database: 'test', port: 21433, trustServerCertificate: true },
- *         server: 'localhost',
- *       }),
- *     },
- *   }),
- *   plugins: [new ParseJSONResultsPlugin()]
- * })
- * ```
- *
- * ### Examples
- *
- * ```ts
- * import { jsonObjectFrom } from 'kysely/helpers/mssql'
- *
- * 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"
- * ```
- */
-function jsonObjectFrom(expr) {
-    return (0, sql_js_1.sql) `(select * from ${expr} as agg for json path, include_null_values, without_array_wrapper)`;
-}
-/**
- * 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
- * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
- * import * as Tarn from 'tarn'
- * import * as Tedious from 'tedious'
- * import type { Database } from 'type-editor' // imaginary module
- *
- * const db = new Kysely<Database>({
- *   dialect: new MssqlDialect({
- *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
- *     tedious: {
- *       ...Tedious,
- *       connectionFactory: () => new Tedious.Connection({
- *         authentication: {
- *           options: { password: 'password', userName: 'sa' },
- *           type: 'default',
- *         },
- *         options: { database: 'test', port: 21433, trustServerCertificate: true },
- *         server: 'localhost',
- *       }),
- *     },
- *   }),
- *   plugins: [new ParseJSONResultsPlugin()]
- * })
- * ```
- *
- * ### Examples
- *
- * ```ts
- * import { jsonBuildObject } from 'kysely/helpers/mssql'
- *
- * 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"
- * ```
- */
-function jsonBuildObject(obj) {
-    return (0, sql_js_1.sql) `json_query('{${sql_js_1.sql.join(Object.keys(obj).map((k) => (0, sql_js_1.sql) `"${sql_js_1.sql.raw(k)}":"'+${obj[k]}+'"`), (0, sql_js_1.sql) `,`)}}')`;
-}