kysely 0.26.0 → 0.26.2

package/dist/cjs/query-creator.js

@@ -15,16 +15,71 @@ const with_node_js_1 = require("./operation-node/with-node.js");
 const query_id_js_1 = require("./util/query-id.js");
 const with_schema_plugin_js_1 = require("./plugin/with-schema/with-schema-plugin.js");
 const object_utils_js_1 = require("./util/object-utils.js");
+const select_parser_js_1 = require("./parser/select-parser.js");
 class QueryCreator {
     #props;
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
     selectFrom(from) {
-        return new select_query_builder_js_1.SelectQueryBuilder({
+        return (0, select_query_builder_js_1.createSelectQueryBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
-            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(from), this.#props.withNode),
+            queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)(from), this.#props.withNode),
+        });
+    }
+    /**
+     * Creates a `select` query builder 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 more examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = db.select((eb) => [
+     *   eb.selectFrom('person')
+     *     .select('id')
+     *     .where('first_name', '=', 'Jennifer')
+     *     .limit(1)
+     *     .as('jennifer_id'),
+     *
+     *   eb.selectFrom('pet')
+     *     .select('id')
+     *     .where('name', '=', 'Doggo')
+     *     .limit(1)
+     *     .as('doggo_id')
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     *
+     * console.log(result.jennifer_id)
+     * console.log(result.doggo_id)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select (
+     *   select "id"
+     *   from "person"
+     *   where "first_name" = $1
+     *   limit $2
+     * ) as "jennifer_id", (
+     *   select "id"
+     *   from "pet"
+     *   where "name" = $3
+     *   limit $4
+     * ) as "doggo_id"
+     * ```
+     */
+    selectNoFrom(selection) {
+        return (0, select_query_builder_js_1.createSelectQueryBuilder)({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#props.executor,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSelections(select_query_node_js_1.SelectQueryNode.create(this.#props.withNode), (0, select_parser_js_1.parseSelectArg)(selection)),
         });
     }
     /**
@@ -159,9 +214,26 @@ class QueryCreator {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The first argument can also be a callback. The callback is passed
+     * a `CTEBuilder` instance that can be used to configure the CTE:
+     *
+     * ```ts
+     * await db
+     *   .with(
+     *     (cte) => cte('jennifers').materialized(),
+     *     (db) => db
+     *       .selectFrom('person')
+     *       .where('first_name', '=', 'Jennifer')
+     *       .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
      */
-    with(name, expression) {
-        const cte = (0, with_parser_js_1.parseCommonTableExpression)(name, expression);
+    with(nameOrBuilder, expression) {
+        const cte = (0, with_parser_js_1.parseCommonTableExpression)(nameOrBuilder, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -172,10 +244,15 @@ class QueryCreator {
     /**
      * Creates a recursive `with` query (Common Table Expression).
      *
+     * Note that recursiveness is a property of the whole `with` statement.
+     * You cannot have recursive and non-recursive CTEs in a same `with` statement.
+     * Therefore the recursiveness is determined by the **first** `with` or
+     * `withRecusive` call you make.
+     *
      * See the {@link with} method for examples and more documentation.
      */
-    withRecursive(name, expression) {
-        const cte = (0, with_parser_js_1.parseCommonTableExpression)(name, expression);
+    withRecursive(nameOrBuilder, expression) {
+        const cte = (0, with_parser_js_1.parseCommonTableExpression)(nameOrBuilder, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode

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

@@ -1,38 +1,21 @@
 import { QueryResult } from '../driver/database-connection.js';
-import { AliasNode } from '../operation-node/alias-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
-import { AliasedExpression, Expression } from '../expression/expression.js';
+import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
  * You shouldn't need to create `RawBuilder` instances directly. Instead you should
  * use the {@link sql} template tag.
  */
-export declare class RawBuilder<O> implements Expression<O> {
-    #private;
-    constructor(props: RawBuilderProps);
-    /** @private */
+export interface RawBuilder<O> extends AliasableExpression<O> {
     /**
-     * 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>`.
+     * @private Without this SelectQueryBuilder extends RawBuilder and things break.
      */
-    get expressionType(): O | undefined;
+    get isRawBuilder(): true;
     /**
      * Returns an aliased version of the SQL expression.
      *
@@ -87,6 +70,62 @@ export declare class RawBuilder<O> implements Expression<O> {
      * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * 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):
+     *
+     * ```ts
+     * 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
+     * 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'])
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * 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: Expression<any>): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
@@ -95,14 +134,31 @@ export declare class RawBuilder<O> implements Expression<O> {
      * returns a copy of this `RawBuilder` with a new output type.
      */
     $castTo<T>(): RawBuilder<T>;
-    /**
-     * @deprecated Use `$castTo` instead.
-     */
-    castTo<T>(): RawBuilder<T>;
     /**
      * Adds a plugin for this SQL snippet.
      */
     withPlugin(plugin: KyselyPlugin): RawBuilder<O>;
+    /**
+     * Compiles the builder to a `CompiledQuery`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { sql } = sql`select * from ${sql.table('person')}`.compile(db)
+     * console.log(sql)
+     * ```
+     */
+    compile(executorProvider: QueryExecutorProvider): CompiledQuery<O>;
+    /**
+     * Executes the raw query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await sql`select * from ${sql.table('person')}`.execute(db)
+     * ```
+     */
+    execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -118,33 +174,16 @@ export declare class RawBuilder<O> implements Expression<O> {
      * ```
      */
     toOperationNode(): RawNode;
-    compile(executorProvider: QueryExecutorProvider): CompiledQuery<O>;
-    execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>;
-}
-export declare function isRawBuilder(obj: unknown): obj is RawBuilder<unknown>;
-/**
- * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
- */
-export declare class AliasedRawBuilder<O = unknown, A extends string = never> implements AliasedExpression<O, A> {
-    #private;
-    constructor(rawBuilder: RawBuilder<O>, alias: A | Expression<unknown>);
-    /** @private */
-    /**
-     * Returns the aliased expression.
-     */
-    get expression(): Expression<O>;
-    /** @private */
-    /**
-     * Returns the alias.
-     */
-    get alias(): A | Expression<unknown>;
-    /**
-     * Creates the OperationNode that describes how to compile this expression into SQL.
-     */
-    toOperationNode(): AliasNode;
 }
 export interface RawBuilderProps {
     readonly queryId: QueryId;
     readonly rawNode: RawNode;
     readonly plugins?: ReadonlyArray<KyselyPlugin>;
 }
+export declare function createRawBuilder<O>(props: RawBuilderProps): RawBuilder<O>;
+/**
+ * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
+ */
+export interface AliasedRawBuilder<O = unknown, A extends string = never> extends AliasedExpression<O, A> {
+    get rawBuilder(): RawBuilder<O>;
+}

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

@@ -1,50 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AliasedRawBuilder = exports.isRawBuilder = exports.RawBuilder = void 0;
+exports.createRawBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.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");
-/**
- * An instance of this class can be used to create raw SQL snippets or queries.
- *
- * You shouldn't need to create `RawBuilder` instances directly. Instead you should
- * use the {@link sql} template tag.
- */
-class RawBuilder {
+class RawBuilderImpl {
     #props;
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
-    /** @private */
     get expressionType() {
         return undefined;
     }
+    get isRawBuilder() {
+        return true;
+    }
     as(alias) {
-        return new AliasedRawBuilder(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 `RawBuilder` with a new output type.
-     */
-    $castTo() {
-        return new RawBuilder({ ...this.#props });
+        return new AliasedRawBuilderImpl(this, alias);
     }
-    /**
-     * @deprecated Use `$castTo` instead.
-     */
-    castTo() {
-        return this.$castTo();
+    $castTo() {
+        return new RawBuilderImpl({ ...this.#props });
     }
-    /**
-     * Adds a plugin for this SQL snippet.
-     */
     withPlugin(plugin) {
-        return new RawBuilder({
+        return new RawBuilderImpl({
             ...this.#props,
             plugins: this.#props.plugins !== undefined
                 ? (0, object_utils_js_1.freeze)([...this.#props.plugins, plugin])
@@ -76,39 +57,31 @@ class RawBuilder {
         return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
     }
 }
-exports.RawBuilder = RawBuilder;
-function isRawBuilder(obj) {
-    return ((0, object_utils_js_1.isObject)(obj) &&
-        (0, object_utils_js_1.isFunction)(obj.as) &&
-        (0, object_utils_js_1.isFunction)(obj.$castTo) &&
-        (0, object_utils_js_1.isFunction)(obj.withPlugin) &&
-        (0, object_utils_js_1.isFunction)(obj.toOperationNode) &&
-        (0, object_utils_js_1.isFunction)(obj.execute));
+function createRawBuilder(props) {
+    return new RawBuilderImpl(props);
 }
-exports.isRawBuilder = isRawBuilder;
-(0, prevent_await_js_1.preventAwait)(RawBuilder, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
-/**
- * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
- */
-class AliasedRawBuilder {
+exports.createRawBuilder = createRawBuilder;
+(0, prevent_await_js_1.preventAwait)(RawBuilderImpl, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
+class AliasedRawBuilderImpl {
     #rawBuilder;
     #alias;
     constructor(rawBuilder, alias) {
         this.#rawBuilder = rawBuilder;
         this.#alias = alias;
     }
-    /** @private */
     get expression() {
         return this.#rawBuilder;
     }
-    /** @private */
     get alias() {
         return this.#alias;
     }
+    get rawBuilder() {
+        return this.#rawBuilder;
+    }
     toOperationNode() {
         return alias_node_js_1.AliasNode.create(this.#rawBuilder.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias)
             ? this.#alias.toOperationNode()
             : identifier_node_js_1.IdentifierNode.create(this.#alias));
     }
 }
-exports.AliasedRawBuilder = AliasedRawBuilder;
+(0, prevent_await_js_1.preventAwait)(AliasedRawBuilderImpl, "don't await AliasedRawBuilder instances directly. AliasedRawBuilder should never be executed directly since it's always a part of another query.");

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

@@ -10,19 +10,19 @@ const value_parser_js_1 = require("../parser/value-parser.js");
 const query_id_js_1 = require("../util/query-id.js");
 const raw_builder_js_1 = require("./raw-builder.js");
 exports.sql = Object.assign((sqlFragments, ...parameters) => {
-    return new raw_builder_js_1.RawBuilder({
+    return (0, raw_builder_js_1.createRawBuilder)({
         queryId: (0, query_id_js_1.createQueryId)(),
         rawNode: raw_node_js_1.RawNode.create(sqlFragments, parameters?.map(value_parser_js_1.parseValueExpression) ?? []),
     });
 }, {
     ref(columnReference) {
-        return new raw_builder_js_1.RawBuilder({
+        return (0, raw_builder_js_1.createRawBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.createWithChild((0, reference_parser_js_1.parseStringReference)(columnReference)),
         });
     },
     val(value) {
-        return new raw_builder_js_1.RawBuilder({
+        return (0, raw_builder_js_1.createRawBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.createWithChild((0, value_parser_js_1.parseValueExpression)(value)),
         });
@@ -31,7 +31,7 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
         return this.val(value);
     },
     table(tableReference) {
-        return new raw_builder_js_1.RawBuilder({
+        return (0, raw_builder_js_1.createRawBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.createWithChild((0, table_parser_js_1.parseTable)(tableReference)),
         });
@@ -40,13 +40,13 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
         const fragments = new Array(ids.length + 1).fill('.');
         fragments[0] = '';
         fragments[fragments.length - 1] = '';
-        return new raw_builder_js_1.RawBuilder({
+        return (0, raw_builder_js_1.createRawBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.create(fragments, ids.map(identifier_node_js_1.IdentifierNode.create)),
         });
     },
     lit(value) {
-        return new raw_builder_js_1.RawBuilder({
+        return (0, raw_builder_js_1.createRawBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.createWithChild(value_node_js_1.ValueNode.createImmediate(value)),
         });
@@ -55,7 +55,7 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
         return this.lit(value);
     },
     raw(sql) {
-        return new raw_builder_js_1.RawBuilder({
+        return (0, raw_builder_js_1.createRawBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.createWithSql(sql),
         });
@@ -69,7 +69,7 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
                 nodes[2 * i + 1] = sep;
             }
         }
-        return new raw_builder_js_1.RawBuilder({
+        return (0, raw_builder_js_1.createRawBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.createWithChildren(nodes),
         });

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

@@ -48,6 +48,10 @@ export declare class AlterTableBuilder implements ColumnAlteringInterface {
      * is because you can only add one column per `ALTER TABLE` query.
      */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
+    /**
+     * See {@link CreateTableBuilder.addPrimaryKeyConstraint}
+     */
+    addPrimaryKeyConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
     dropConstraint(constraintName: string): AlterTableDropConstraintBuilder;
     /**
      * Calls the given function passing `this` as the only argument.

package/dist/cjs/schema/alter-table-builder.js

@@ -24,6 +24,7 @@ const alter_column_builder_js_1 = require("./alter-column-builder.js");
 const alter_table_executor_js_1 = require("./alter-table-executor.js");
 const alter_table_add_foreign_key_constraint_builder_js_1 = require("./alter-table-add-foreign-key-constraint-builder.js");
 const alter_table_drop_constraint_builder_js_1 = require("./alter-table-drop-constraint-builder.js");
+const primary_constraint_node_js_1 = require("../operation-node/primary-constraint-node.js");
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -116,6 +117,17 @@ class AlterTableBuilder {
             constraintBuilder: new foreign_key_constraint_builder_js_1.ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(columns.map(column_node_js_1.ColumnNode.create), (0, table_parser_js_1.parseTable)(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName)),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addPrimaryKeyConstraint}
+     */
+    addPrimaryKeyConstraint(constraintName, columns) {
+        return new alter_table_executor_js_1.AlterTableExecutor({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addConstraint: add_constraint_node_js_1.AddConstraintNode.create(primary_constraint_node_js_1.PrimaryConstraintNode.create(columns, constraintName)),
+            }),
+        });
+    }
     dropConstraint(constraintName) {
         return new alter_table_drop_constraint_builder_js_1.AlterTableDropConstraintBuilder({
             ...this.#props,

package/dist/cjs/schema/create-index-builder.d.ts

@@ -133,7 +133,7 @@ export declare class CreateIndexBuilder<C = never> implements OperationNodeSourc
      */
     where(lhs: C | Expression<any>, op: ComparisonOperatorExpression, rhs: unknown): CreateIndexBuilder<C>;
     where(factory: (qb: ExpressionBuilder<ShallowRecord<string, ShallowRecord<C & string, any>>, string>) => Expression<SqlBool>): CreateIndexBuilder<C>;
-    where(expression: Expression<any>): CreateIndexBuilder<C>;
+    where(expression: Expression<SqlBool>): CreateIndexBuilder<C>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.

package/dist/cjs/schema/create-index-builder.js

@@ -150,7 +150,7 @@ class CreateIndexBuilder {
         const transformer = new immediate_value_transformer_js_1.ImmediateValueTransformer();
         return new CreateIndexBuilder({
             ...this.#props,
-            node: query_node_js_1.QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode((0, binary_operation_parser_js_1.parseFilter)(args))),
+            node: query_node_js_1.QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode((0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args))),
         });
     }
     /**

package/dist/cjs/util/column-type.d.ts

@@ -1,3 +1,4 @@
+import { DrainOuterGeneric } from './type-utils.js';
 /**
  * This type can be used to specify a different type for
  * select, insert and update operations.
@@ -123,9 +124,9 @@ export type UpdateKeys<R> = {
  * // }
  * ```
  */
-export type Selectable<R> = {
+export type Selectable<R> = DrainOuterGeneric<{
     [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
-};
+}>;
 /**
  * Given a table interface, extracts the insert type from all
  * {@link ColumnType} types.
@@ -147,11 +148,11 @@ export type Selectable<R> = {
  * // }
  * ```
  */
-export type Insertable<R> = {
+export type Insertable<R> = DrainOuterGeneric<{
     [K in NonNullableInsertKeys<R>]: InsertType<R[K]>;
 } & {
     [K in NullableInsertKeys<R>]?: InsertType<R[K]>;
-};
+}>;
 /**
  * Given a table interface, extracts the update type from all
  * {@link ColumnType} types.
@@ -172,7 +173,7 @@ export type Insertable<R> = {
  * // }
  * ```
  */
-export type Updateable<R> = {
+export type Updateable<R> = DrainOuterGeneric<{
     [K in UpdateKeys<R>]?: UpdateType<R[K]>;
-};
+}>;
 export {};

package/dist/cjs/util/json-object-args.d.ts

@@ -0,0 +1,3 @@
+import { Expression } from '../expression/expression.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+export declare function getJsonObjectArgs(node: SelectQueryNode, table: string): Expression<unknown>[];

package/dist/cjs/util/json-object-args.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonObjectArgs = void 0;
+const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
+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 table_node_js_1 = require("../operation-node/table-node.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+function getJsonObjectArgs(node, table) {
+    const args = [];
+    for (const { selection: s } of node.selections ?? []) {
+        if (reference_node_js_1.ReferenceNode.is(s) && column_node_js_1.ColumnNode.is(s.column)) {
+            args.push(colName(s.column.column.name), colRef(table, s.column.column.name));
+        }
+        else if (column_node_js_1.ColumnNode.is(s)) {
+            args.push(colName(s.column.name), colRef(table, s.column.name));
+        }
+        else if (alias_node_js_1.AliasNode.is(s) && identifier_node_js_1.IdentifierNode.is(s.alias)) {
+            args.push(colName(s.alias.name), colRef(table, s.alias.name));
+        }
+        else {
+            throw new Error(`can't extract column names from the select query node`);
+        }
+    }
+    return args;
+}
+exports.getJsonObjectArgs = getJsonObjectArgs;
+function colName(col) {
+    return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(col));
+}
+function colRef(table, col) {
+    return new expression_wrapper_js_1.ExpressionWrapper(reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(col), table_node_js_1.TableNode.create(table)));
+}

package/dist/cjs/util/object-utils.d.ts

@@ -13,6 +13,7 @@ export declare function isBuffer(obj: unknown): obj is {
 export declare function isFunction(obj: unknown): obj is Function;
 export declare function isObject(obj: unknown): obj is ShallowRecord<string, unknown>;
 export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
+export declare function isPlainObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;
 export declare function asArray<T>(arg: T | T[]): T[];

package/dist/cjs/util/object-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compare = exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isArrayBufferOrView = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isUndefined = exports.isEmpty = void 0;
+exports.compare = exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isPlainObject = exports.isArrayBufferOrView = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isUndefined = exports.isEmpty = void 0;
 function isEmpty(obj) {
     if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
         return obj.length === 0;
@@ -57,6 +57,14 @@ function isArrayBufferOrView(obj) {
     return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
 }
 exports.isArrayBufferOrView = isArrayBufferOrView;
+function isPlainObject(obj) {
+    return (isObject(obj) &&
+        !Array.isArray(obj) &&
+        !isDate(obj) &&
+        !isBuffer(obj) &&
+        !isArrayBufferOrView(obj));
+}
+exports.isPlainObject = isPlainObject;
 function getLast(arr) {
     return arr[arr.length - 1];
 }