kysely 0.26.0 → 0.26.2

package/dist/esm/query-creator.js

@@ -1,5 +1,5 @@
 /// <reference types="./query-creator.d.ts" />
-import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
+import { createSelectQueryBuilder, } from './query-builder/select-query-builder.js';
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
 import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
 import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
@@ -13,16 +13,71 @@ import { WithNode } from './operation-node/with-node.js';
 import { createQueryId } from './util/query-id.js';
 import { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';
 import { freeze } from './util/object-utils.js';
+import { parseSelectArg, } from './parser/select-parser.js';
 export class QueryCreator {
     #props;
     constructor(props) {
         this.#props = freeze(props);
     }
     selectFrom(from) {
-        return new SelectQueryBuilder({
+        return createSelectQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            queryNode: SelectQueryNode.create(parseTableExpressionOrList(from), this.#props.withNode),
+            queryNode: SelectQueryNode.createFrom(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 createSelectQueryBuilder({
+            queryId: createQueryId(),
+            executor: this.#props.executor,
+            queryNode: SelectQueryNode.cloneWithSelections(SelectQueryNode.create(this.#props.withNode), parseSelectArg(selection)),
         });
     }
     /**
@@ -157,9 +212,26 @@ export 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 = parseCommonTableExpression(name, expression);
+    with(nameOrBuilder, expression) {
+        const cte = parseCommonTableExpression(nameOrBuilder, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -170,10 +242,15 @@ export 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 = parseCommonTableExpression(name, expression);
+    withRecursive(nameOrBuilder, expression) {
+        const cte = parseCommonTableExpression(nameOrBuilder, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode

package/dist/esm/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/esm/raw-builder/raw-builder.js

@@ -1,48 +1,29 @@
 /// <reference types="./raw-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
 import { preventAwait } from '../util/prevent-await.js';
-import { freeze, isFunction, isObject } from '../util/object-utils.js';
+import { freeze } from '../util/object-utils.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { isOperationNodeSource } from '../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.
- */
-export class RawBuilder {
+class RawBuilderImpl {
     #props;
     constructor(props) {
         this.#props = 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
                 ? freeze([...this.#props.plugins, plugin])
@@ -74,36 +55,30 @@ export class RawBuilder {
         return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
     }
 }
-export function isRawBuilder(obj) {
-    return (isObject(obj) &&
-        isFunction(obj.as) &&
-        isFunction(obj.$castTo) &&
-        isFunction(obj.withPlugin) &&
-        isFunction(obj.toOperationNode) &&
-        isFunction(obj.execute));
+export function createRawBuilder(props) {
+    return new RawBuilderImpl(props);
 }
-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}.
- */
-export class AliasedRawBuilder {
+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 AliasNode.create(this.#rawBuilder.toOperationNode(), isOperationNodeSource(this.#alias)
             ? this.#alias.toOperationNode()
             : IdentifierNode.create(this.#alias));
     }
 }
+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/esm/raw-builder/sql.js

@@ -6,21 +6,21 @@ import { parseStringReference } from '../parser/reference-parser.js';
 import { parseTable } from '../parser/table-parser.js';
 import { parseValueExpression } from '../parser/value-parser.js';
 import { createQueryId } from '../util/query-id.js';
-import { RawBuilder } from './raw-builder.js';
+import { createRawBuilder } from './raw-builder.js';
 export const sql = Object.assign((sqlFragments, ...parameters) => {
-    return new RawBuilder({
+    return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.create(sqlFragments, parameters?.map(parseValueExpression) ?? []),
     });
 }, {
     ref(columnReference) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChild(parseStringReference(columnReference)),
         });
     },
     val(value) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChild(parseValueExpression(value)),
         });
@@ -29,7 +29,7 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
         return this.val(value);
     },
     table(tableReference) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChild(parseTable(tableReference)),
         });
@@ -38,13 +38,13 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
         const fragments = new Array(ids.length + 1).fill('.');
         fragments[0] = '';
         fragments[fragments.length - 1] = '';
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.create(fragments, ids.map(IdentifierNode.create)),
         });
     },
     lit(value) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChild(ValueNode.createImmediate(value)),
         });
@@ -53,7 +53,7 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
         return this.lit(value);
     },
     raw(sql) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithSql(sql),
         });
@@ -67,7 +67,7 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
                 nodes[2 * i + 1] = sep;
             }
         }
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChildren(nodes),
         });

package/dist/esm/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/esm/schema/alter-table-builder.js

@@ -22,6 +22,7 @@ import { AlterColumnBuilder, } from './alter-column-builder.js';
 import { AlterTableExecutor } from './alter-table-executor.js';
 import { AlterTableAddForeignKeyConstraintBuilder } from './alter-table-add-foreign-key-constraint-builder.js';
 import { AlterTableDropConstraintBuilder } from './alter-table-drop-constraint-builder.js';
+import { PrimaryConstraintNode } from '../operation-node/primary-constraint-node.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -114,6 +115,17 @@ export class AlterTableBuilder {
             constraintBuilder: new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), parseTable(targetTable), targetColumns.map(ColumnNode.create), constraintName)),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addPrimaryKeyConstraint}
+     */
+    addPrimaryKeyConstraint(constraintName, columns) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addConstraint: AddConstraintNode.create(PrimaryConstraintNode.create(columns, constraintName)),
+            }),
+        });
+    }
     dropConstraint(constraintName) {
         return new AlterTableDropConstraintBuilder({
             ...this.#props,

package/dist/esm/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/esm/schema/create-index-builder.js

@@ -5,7 +5,7 @@ import { parseOrderedColumnName, } from '../parser/reference-parser.js';
 import { parseTable } from '../parser/table-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
-import { parseFilter, } from '../parser/binary-operation-parser.js';
+import { parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { ImmediateValueTransformer } from '../plugin/immediate-value/immediate-value-transformer.js';
 export class CreateIndexBuilder {
@@ -148,7 +148,7 @@ export class CreateIndexBuilder {
         const transformer = new ImmediateValueTransformer();
         return new CreateIndexBuilder({
             ...this.#props,
-            node: QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode(parseFilter(args))),
+            node: QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode(parseValueBinaryOperationOrExpression(args))),
         });
     }
     /**

package/dist/esm/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/esm/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/esm/util/json-object-args.js

@@ -0,0 +1,32 @@
+/// <reference types="./json-object-args.d.ts" />
+import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { ReferenceNode } from '../operation-node/reference-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+export function getJsonObjectArgs(node, table) {
+    const args = [];
+    for (const { selection: s } of node.selections ?? []) {
+        if (ReferenceNode.is(s) && ColumnNode.is(s.column)) {
+            args.push(colName(s.column.column.name), colRef(table, s.column.column.name));
+        }
+        else if (ColumnNode.is(s)) {
+            args.push(colName(s.column.name), colRef(table, s.column.name));
+        }
+        else if (AliasNode.is(s) && 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;
+}
+function colName(col) {
+    return new ExpressionWrapper(ValueNode.createImmediate(col));
+}
+function colRef(table, col) {
+    return new ExpressionWrapper(ReferenceNode.create(ColumnNode.create(col), TableNode.create(table)));
+}

package/dist/esm/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/esm/util/object-utils.js

@@ -43,6 +43,13 @@ export function isObject(obj) {
 export function isArrayBufferOrView(obj) {
     return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
 }
+export function isPlainObject(obj) {
+    return (isObject(obj) &&
+        !Array.isArray(obj) &&
+        !isDate(obj) &&
+        !isBuffer(obj) &&
+        !isArrayBufferOrView(obj));
+}
 export function getLast(arr) {
     return arr[arr.length - 1];
 }