kysely 0.21.6 → 0.23.0

package/dist/esm/parser/table-parser.js

@@ -2,7 +2,7 @@
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { parseAliasedComplexExpression, } from './complex-expression-parser.js';
+import { parseAliasedExpression, } from './expression-parser.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 export function parseTableExpressionOrList(table) {
     if (isReadonlyArray(table)) {
@@ -17,7 +17,7 @@ export function parseTableExpression(table) {
         return parseAliasedTable(table);
     }
     else {
-        return parseAliasedComplexExpression(table);
+        return parseAliasedExpression(table);
     }
 }
 export function parseAliasedTable(from) {

package/dist/esm/parser/unary-operation-parser.d.ts

@@ -0,0 +1,5 @@
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { ExpressionOrFactory } from './expression-parser.js';
+export declare type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
+export declare function parseExists(arg: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseNotExists(arg: ExistsExpression<any, any>): UnaryOperationNode;

package/dist/esm/parser/unary-operation-parser.js

@@ -0,0 +1,13 @@
+/// <reference types="./unary-operation-parser.d.ts" />
+import { OperatorNode, } from '../operation-node/operator-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { parseValueExpressionOrList } from './value-parser.js';
+export function parseExists(arg) {
+    return parseUnaryOperation('exists', arg);
+}
+export function parseNotExists(arg) {
+    return parseUnaryOperation('not exists', arg);
+}
+function parseUnaryOperation(type, arg) {
+    return UnaryOperationNode.create(OperatorNode.create(type), parseValueExpressionOrList(arg));
+}

package/dist/esm/parser/update-set-parser.d.ts

@@ -2,6 +2,6 @@ import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
 export declare type MutationObject<DB, TB extends keyof DB, TM extends keyof DB> = {
-    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>>;
+    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>> | undefined;
 };
 export declare function parseUpdateObject(row: MutationObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/parser/value-parser.d.ts

@@ -1,9 +1,6 @@
-import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { ComplexExpression } from './complex-expression-parser.js';
-export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB, V>;
+import { ExpressionOrFactory } from './expression-parser.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
-export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
-export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;

package/dist/esm/parser/value-parser.js

@@ -3,7 +3,7 @@ import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-n
 import { ValueListNode } from '../operation-node/value-list-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
 import { isReadonlyArray } from '../util/object-utils.js';
-import { parseComplexExpression, isComplexExpression, } from './complex-expression-parser.js';
+import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
 export function parseValueExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
         return parseValueExpressionList(arg);
@@ -13,13 +13,13 @@ export function parseValueExpressionOrList(arg) {
     }
 }
 export function parseValueExpression(exp) {
-    if (isComplexExpression(exp)) {
-        return parseComplexExpression(exp);
+    if (isExpressionOrFactory(exp)) {
+        return parseExpression(exp);
     }
     return ValueNode.create(exp);
 }
 function parseValueExpressionList(arg) {
-    if (arg.some(isComplexExpression)) {
+    if (arg.some(isExpressionOrFactory)) {
         return ValueListNode.create(arg.map((it) => parseValueExpression(it)));
     }
     return PrimitiveValueListNode.create(arg);

package/dist/esm/parser/with-parser.d.ts

@@ -1,21 +1,20 @@
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
 import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
 import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { QueryCreator } from '../query-creator.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Expression } from '../expression/expression.js';
 export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
 export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
-declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
+declare type CommonTableExpressionOutput<DB, CN extends string> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
 /**
  * Given a common CommonTableExpression CTE extracts the row type from it.
  *
  * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
  * would result in `Pick<Person, 'id' | 'first_name'>`.
  */
-declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : never : never;
 /**
  * Extracts 'person' from a string like 'person(id, first_name)'.
  */

package/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -1,5 +1,5 @@
 /// <reference types="./camel-case-plugin.d.ts" />
-import { isBuffer, isDate, isObject } from '../../util/object-utils.js';
+import { isArrayBufferOrView, isBuffer, isDate, isObject, } from '../../util/object-utils.js';
 import { SnakeCaseTransformer } from './camel-case-transformer.js';
 import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
 /**
@@ -108,5 +108,5 @@ export class CamelCasePlugin {
     }
 }
 function canMap(obj) {
-    return isObject(obj) && !isDate(obj) && !isBuffer(obj);
+    return (isObject(obj) && !isDate(obj) && !isBuffer(obj) && !isArrayBufferOrView(obj));
 }

package/dist/esm/query-builder/aggregate-function-builder.d.ts

@@ -0,0 +1,348 @@
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OverBuilder } from './over-builder.js';
+import { AliasedExpression, Expression } from '../expression/expression.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ExistsExpression } from '../parser/unary-operation-parser.js';
+export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements Expression<O> {
+    #private;
+    constructor(props: AggregateFunctionBuilderProps);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): O | undefined;
+    /**
+     * Returns an aliased version of the function.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.count<number>('id').as('person_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `person_count: number` field exists in the result type.
+     * console.log(result.person_count)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count("id") as "person_count"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedAggregateFunctionBuilder<DB, TB, O, A>;
+    /**
+     * Adds a `distinct` clause inside the function.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     eb.fn.count<number>('first_name').distinct().as('first_name_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count(distinct "first_name") as "first_name_count"
+     * from "person"
+     * ```
+     */
+    distinct(): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `filter` clause with a nested `where` clause after the function.
+     *
+     * Similar to {@link WhereInterface}'s `where` method.
+     *
+     * Also see {@link orFilterWhere}, {@link filterWhereExists} and {@link filterWhereRef}.
+     *
+     * ### Examples
+     *
+     * Count by gender:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select([
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhere('gender', '=', 'female')
+     *         .as('female_count'),
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhere('gender', '=', 'male')
+     *         .as('male_count'),
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhere('gender', '=', 'other')
+     *         .as('other_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   count("id") filter(where "gender" = $1) as "female_count",
+     *   count("id") filter(where "gender" = $2) as "male_count",
+     *   count("id") filter(where "gender" = $3) as "other_count"
+     * from "person"
+     * ```
+     */
+    filterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere(grouper: WhereGrouper<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `filter` clause with a nested `where exists` clause after the function.
+     *
+     * Similar to {@link WhereInterface}'s `whereExists` method.
+     *
+     * ### Examples
+     *
+     * Count pet owners versus general public:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select([
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('person.id')
+     *         .filterWhereExists((qb) =>
+     *           qb
+     *             .selectFrom('pet')
+     *             .select('pet.id')
+     *             .whereRef('pet.owner_id', '=', 'person.id')
+     *         )
+     *         .as('pet_owner_count'),
+     *     (eb) => eb.fn.count<number>('person.id').as('total_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count("person"."id") filter(where exists (
+     *   select "pet"."id"
+     *   from "pet"
+     *   where "pet"."owner_id" = "person"."id"
+     * )) as "pet_ower_count",
+     *   count("person"."id") as "total_count"
+     * from "person"
+     * ```
+     */
+    filterWhereExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Just like {@link filterWhereExists} but creates a `not exists` clause inside
+     * the `filter` clause.
+     */
+    filterWhereNotExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `filter` clause with a nested `where` clause after the function, where
+     * both sides of the operator are references to columns.
+     *
+     * Similar to {@link WhereInterface}'s `whereRef` method.
+     *
+     * ### Examples
+     *
+     * Count people with same first and last names versus general public:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select([
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhereRef('first_name', '=', 'last_name')
+     *         .as('repeat_name_count'),
+     *     (eb) => eb.fn.count<number>('id').as('total_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   count("id") filter(where "first_name" = "last_name") as "repeat_name_count",
+     *   count("id") as "total_count"
+     * from "person"
+     * ```
+     */
+    filterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `filter` clause with a nested `or where` clause after the function.
+     * Otherwise works just like {@link filterWhere}.
+     *
+     * Similar to {@link WhereInterface}'s `orWhere` method.
+     *
+     * ### Examples
+     *
+     * For some reason you're tasked with counting adults (18+) or people called
+     * "Bob" versus general public:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select([
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhere('age', '>=', '18')
+     *         .orFilterWhere('first_name', '=', 'Bob')
+     *         .as('adult_or_bob_count'),
+     *     (eb) => eb.fn.count<number>('id').as('total_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   count("id") filter(where "age" >= $1 or "first_name" = $2) as "adult_or_bob_count",
+     *   count("id") as "total_count"
+     * from "person"
+     * ```
+     */
+    orFilterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
+    orFilterWhere(grouper: WhereGrouper<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    orFilterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Just like {@link filterWhereExists} but creates an `or exists` clause inside
+     * the `filter` clause.
+     *
+     * Similar to {@link WhereInterface}'s `orWhereExists` method.
+     */
+    orFilterWhereExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Just like {@link filterWhereExists} but creates an `or not exists` clause inside
+     * the `filter` clause.
+     *
+     * Similar to {@link WhereInterface}'s `orWhereNotExists` method.
+     */
+    orFilterWhereNotExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds an `or where` clause inside the `filter` clause. Otherwise works just
+     * like {@link filterWhereRef}.
+     *
+     * Also see {@link orFilterWhere} and {@link filterWhere}.
+     *
+     * Similar to {@link WhereInterface}'s `orWhereRef` method.
+     */
+    orFilterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds an `over` clause (window functions) after the function.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over().as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over() as "average_age"
+     * from "person"
+     * ```
+     *
+     * Also supports passing a callback that returns an over builder,
+     * allowing to add partition by and sort by clauses inside over.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     eb => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy('last_name').orderBy('first_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name" order by "first_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    over(over?: OverBuilderCallback<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): AggregateFunctionNode;
+}
+/**
+ * {@link AggregateFunctionBuilder} with an alias. The result of calling {@link AggregateFunctionBuilder.as}.
+ */
+export declare class AliasedAggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown, A extends string = never> implements AliasedExpression<O, A> {
+    #private;
+    constructor(aggregateFunctionBuilder: AggregateFunctionBuilder<DB, TB, O>, alias: A);
+    /** @private */
+    /**
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<O>;
+    /** @private */
+    /**
+     * Returns the alias.
+     */
+    get alias(): A;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     */
+    toOperationNode(): AliasNode;
+}
+export interface AggregateFunctionBuilderProps {
+    aggregateFunctionNode: AggregateFunctionNode;
+}
+export declare type OverBuilderCallback<DB, TB extends keyof DB> = (builder: OverBuilder<DB, TB>) => OverBuilder<DB, TB>;