kysely 0.24.2 → 0.25.0

package/dist/esm/operation-node/case-node.js

@@ -0,0 +1,40 @@
+/// <reference types="./case-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { WhenNode } from './when-node.js';
+/**
+ * @internal
+ */
+export const CaseNode = freeze({
+    is(node) {
+        return node.kind === 'CaseNode';
+    },
+    create(value) {
+        return freeze({
+            kind: 'CaseNode',
+            value,
+        });
+    },
+    cloneWithWhen(caseNode, when) {
+        return freeze({
+            ...caseNode,
+            when: freeze(caseNode.when ? [...caseNode.when, when] : [when]),
+        });
+    },
+    cloneWithThen(caseNode, then) {
+        return freeze({
+            ...caseNode,
+            when: caseNode.when
+                ? freeze([
+                    ...caseNode.when.slice(0, -1),
+                    WhenNode.cloneWithResult(caseNode.when[caseNode.when.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+    cloneWith(caseNode, props) {
+        return freeze({
+            ...caseNode,
+            ...props,
+        });
+    },
+});

package/dist/esm/operation-node/create-index-node.d.ts

@@ -9,7 +9,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly kind: 'CreateIndexNode';
     readonly name: IdentifierNode;
     readonly table?: TableNode;
-    readonly expression?: OperationNode;
+    readonly columns?: OperationNode[];
     readonly unique?: boolean;
     readonly using?: RawNode;
     readonly ifNotExists?: boolean;
@@ -22,4 +22,5 @@ export declare const CreateIndexNode: Readonly<{
     is(node: OperationNode): node is CreateIndexNode;
     create(name: string): CreateIndexNode;
     cloneWith(node: CreateIndexNode, props: CreateIndexNodeProps): CreateIndexNode;
+    cloneWithColumns(node: CreateIndexNode, columns: OperationNode[]): CreateIndexNode;
 }>;

package/dist/esm/operation-node/create-index-node.js

@@ -20,4 +20,10 @@ export const CreateIndexNode = freeze({
             ...props,
         });
     },
+    cloneWithColumns(node, columns) {
+        return freeze({
+            ...node,
+            columns: [...(node.columns || []), ...columns],
+        });
+    },
 });

package/dist/esm/operation-node/data-type-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | `datetime(${number})` | 'time' | `time(${number})` | 'timetz' | `timetz(${number})` | 'timestamp' | `timestamp(${number})` | 'timestamptz' | `timestamptz(${number})` | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
+export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'char' | `char(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | `binary(${number})` | 'bytea' | 'date' | 'datetime' | `datetime(${number})` | 'time' | `time(${number})` | 'timetz' | `timetz(${number})` | 'timestamp' | `timestamp(${number})` | 'timestamptz' | `timestamptz(${number})` | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
 export declare type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -78,6 +78,8 @@ import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
 import { UsingNode } from './using-node.js';
 import { FunctionNode } from './function-node.js';
+import { CaseNode } from './case-node.js';
+import { WhenNode } from './when-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -185,6 +187,8 @@ export declare class OperationNodeTransformer {
     protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
     protected transformUsing(node: UsingNode): UsingNode;
     protected transformFunction(node: FunctionNode): FunctionNode;
+    protected transformCase(node: CaseNode): CaseNode;
+    protected transformWhen(node: WhenNode): WhenNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/dist/esm/operation-node/operation-node-transformer.js

@@ -112,6 +112,8 @@ export class OperationNodeTransformer {
         UnaryOperationNode: this.transformUnaryOperation.bind(this),
         UsingNode: this.transformUsing.bind(this),
         FunctionNode: this.transformFunction.bind(this),
+        CaseNode: this.transformCase.bind(this),
+        WhenNode: this.transformWhen.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -402,7 +404,7 @@ export class OperationNodeTransformer {
             kind: 'CreateIndexNode',
             name: this.transformNode(node.name),
             table: this.transformNode(node.table),
-            expression: this.transformNode(node.expression),
+            columns: this.transformNodeList(node.columns),
             unique: node.unique,
             using: this.transformNode(node.using),
             ifNotExists: node.ifNotExists,
@@ -651,7 +653,7 @@ export class OperationNodeTransformer {
     transformAggregateFunction(node) {
         return requireAllProps({
             kind: 'AggregateFunctionNode',
-            aggregated: this.transformNode(node.aggregated),
+            aggregated: this.transformNodeList(node.aggregated),
             distinct: node.distinct,
             filter: this.transformNode(node.filter),
             func: node.func,
@@ -705,6 +707,22 @@ export class OperationNodeTransformer {
             arguments: this.transformNodeList(node.arguments),
         });
     }
+    transformCase(node) {
+        return requireAllProps({
+            kind: 'CaseNode',
+            value: this.transformNode(node.value),
+            when: this.transformNodeList(node.when),
+            else: this.transformNode(node.else),
+            isStatement: node.isStatement,
+        });
+    }
+    transformWhen(node) {
+        return requireAllProps({
+            kind: 'WhenNode',
+            condition: this.transformNode(node.condition),
+            result: this.transformNode(node.result),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -78,6 +78,8 @@ import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
 import { UsingNode } from './using-node.js';
 import { FunctionNode } from './function-node.js';
+import { WhenNode } from './when-node.js';
+import { CaseNode } from './case-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -162,4 +164,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
     protected abstract visitUsing(node: UsingNode): void;
     protected abstract visitFunction(node: FunctionNode): void;
+    protected abstract visitCase(node: CaseNode): void;
+    protected abstract visitWhen(node: WhenNode): void;
 }

package/dist/esm/operation-node/operation-node-visitor.js

@@ -85,6 +85,8 @@ export class OperationNodeVisitor {
         UnaryOperationNode: this.visitUnaryOperation.bind(this),
         UsingNode: this.visitUsing.bind(this),
         FunctionNode: this.visitFunction.bind(this),
+        CaseNode: this.visitCase.bind(this),
+        WhenNode: this.visitWhen.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/when-node.d.ts

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export interface WhenNode extends OperationNode {
+    readonly kind: 'WhenNode';
+    readonly condition: OperationNode;
+    readonly result?: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const WhenNode: Readonly<{
+    is(node: OperationNode): node is WhenNode;
+    create(condition: OperationNode): WhenNode;
+    cloneWithResult(whenNode: WhenNode, result: OperationNode): WhenNode;
+}>;

package/dist/esm/operation-node/when-node.js

@@ -0,0 +1,22 @@
+/// <reference types="./when-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const WhenNode = freeze({
+    is(node) {
+        return node.kind === 'WhenNode';
+    },
+    create(condition) {
+        return freeze({
+            kind: 'WhenNode',
+            condition,
+        });
+    },
+    cloneWithResult(whenNode, result) {
+        return freeze({
+            ...whenNode,
+            result,
+        });
+    },
+});

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

@@ -17,3 +17,4 @@ export declare function parseReferentialComparison(leftOperand: ReferenceExpress
 export declare function parseWhere(args: any[]): OperationNode;
 export declare function parseHaving(args: any[]): OperationNode;
 export declare function parseOn(args: any[]): OperationNode;
+export declare function parseWhen(args: any[]): OperationNode;

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

@@ -12,6 +12,8 @@ import { createJoinBuilder, createSelectQueryBuilder } from './parse-utils.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { JoinNode } from '../operation-node/join-node.js';
 import { expressionBuilder } from '../expression/expression-builder.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { CaseNode } from '../operation-node/case-node.js';
 export function parseValueBinaryOperation(leftOperand, operator, rightOperand) {
     if (!isBinaryOperator(operator) && !isOperationNodeSource(operator)) {
         throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
@@ -48,6 +50,9 @@ export function parseHaving(args) {
 export function parseOn(args) {
     return parseFilter('on', args);
 }
+export function parseWhen(args) {
+    return parseFilter('when', args);
+}
 function parseFilter(type, args) {
     if (args.length === 3) {
         return parseValueComparison(args[0], args[1], args[2]);
@@ -75,14 +80,24 @@ function parseOperator(operator) {
 }
 function parseOneArgFilterExpression(type, arg) {
     if (isFunction(arg)) {
+        if (type === 'when') {
+            throw new Error(`when method doesn't accept a callback as an argument`);
+        }
         return CALLBACK_PARSERS[type](arg);
     }
     else if (isOperationNodeSource(arg)) {
         const node = arg.toOperationNode();
-        if (RawNode.is(node)) {
+        if (RawNode.is(node) ||
+            BinaryOperationNode.is(node) ||
+            UnaryOperationNode.is(node) ||
+            ParensNode.is(node) ||
+            CaseNode.is(node)) {
             return node;
         }
     }
+    else if (type === 'when') {
+        return ValueNode.create(arg);
+    }
     throw createFilterExpressionError(type, arg);
 }
 function createFilterExpressionError(type, args) {

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

@@ -3,7 +3,8 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-export declare type ExpressionOrFactory<DB, TB extends keyof DB, V> = SelectQueryBuilder<any, any, Record<string, V>> | SelectQueryBuilderFactory<DB, TB, Record<string, V>> | Expression<V> | ExpressionFactory<DB, TB, V>;
+import { ShallowRecord } from '../util/type-utils.js';
+export declare type ExpressionOrFactory<DB, TB extends keyof DB, V> = SelectQueryBuilder<any, any, ShallowRecord<string, V>> | SelectQueryBuilderFactory<DB, TB, ShallowRecord<string, V>> | Expression<V> | ExpressionFactory<DB, TB, V>;
 export declare type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | AliasedExpressionFactory<DB, TB>;
 declare type SelectQueryBuilderFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => SelectQueryBuilder<any, any, V>;
 declare type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;

package/dist/esm/parser/order-by-parser.d.ts

@@ -2,6 +2,7 @@ import { Expression } from '../expression/expression.js';
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type OrderByDirection = 'asc' | 'desc';
+export declare function isOrderByDirection(thing: unknown): thing is OrderByDirection;
 export declare type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
 export declare type OrderByDirectionExpression = OrderByDirection | Expression<any>;
 export declare function parseOrderBy(orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

package/dist/esm/parser/order-by-parser.js

@@ -2,6 +2,9 @@
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';
+export function isOrderByDirection(thing) {
+    return thing === 'asc' || thing === 'desc';
+}
 export function parseOrderBy(orderBy, direction) {
     return OrderByItemNode.create(parseOrderByExpression(orderBy), parseOrderByDirectionExpression(direction));
 }

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

@@ -1,6 +1,6 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
-import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
+import { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ExpressionOrFactory } from './expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
@@ -8,15 +8,19 @@ import { SelectType } from '../util/column-type.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
 import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
+import { OrderByDirection } from './order-by-parser.js';
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
 export declare type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
 export declare type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
 export declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
+export declare type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
+export declare type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;
 export declare function parseSimpleReferenceExpression(exp: SimpleReferenceExpression<any, any>): SimpleReferenceExpressionNode;
 export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): OperationNode[];
 export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): OperationNode;
 export declare function parseStringReference(ref: string): SimpleReferenceExpressionNode;
 export declare function parseAliasedStringReference(ref: string): SimpleReferenceExpressionNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
+export declare function parseOrderedColumnName(column: string): OperationNode;

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

@@ -6,6 +6,7 @@ import { TableNode } from '../operation-node/table-node.js';
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOrderByDirection, parseOrderBy, } from './order-by-parser.js';
 export function parseSimpleReferenceExpression(exp) {
     if (isString(exp)) {
         return parseStringReference(exp);
@@ -57,6 +58,19 @@ export function parseAliasedStringReference(ref) {
 export function parseColumnName(column) {
     return ColumnNode.create(column);
 }
+export function parseOrderedColumnName(column) {
+    const ORDER_SEPARATOR = ' ';
+    if (column.includes(ORDER_SEPARATOR)) {
+        const [columnName, order] = column.split(ORDER_SEPARATOR).map(trim);
+        if (!isOrderByDirection(order)) {
+            throw new Error(`invalid order direction "${order}" next to "${columnName}"`);
+        }
+        return parseOrderBy(columnName, order);
+    }
+    else {
+        return parseColumnName(column);
+    }
+}
 function parseStringReferenceWithTableAndSchema(parts) {
     const [schema, table, column] = parts;
     return ReferenceNode.create(TableNode.createWithSchema(schema, table), ColumnNode.create(column));

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

@@ -1,6 +1,6 @@
 import { AliasedSelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
+import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, ExtractColumnType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { Selectable, SelectType } from '../util/column-type.js';
@@ -8,12 +8,12 @@ import { AliasedExpression } from '../expression/expression.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
 export declare type SelectArg<DB, TB extends keyof DB, SE extends SelectExpression<DB, TB>> = SE | ReadonlyArray<SE> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SE>);
-export declare type Selection<DB, TB extends keyof DB, SE> = {
+export declare type Selection<DB, TB extends keyof DB, SE> = DrainOuterGeneric<{
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
-};
+}>;
 declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedExpression<any, infer EA> ? EA : SE extends (qb: any) => AliasedExpression<any, infer EA> ? EA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
-declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends (qb: any) => AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
+declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : never : SE extends AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends (qb: any) => AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
 export declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
     [C in AnyColumn<DB, TB>]: {

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

@@ -3,17 +3,18 @@ import { TableNode } from '../operation-node/table-node.js';
 import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { AliasedExpression } from '../expression/expression.js';
+import { DrainOuterGeneric, ShallowRecord } from '../util/type-utils.js';
 export declare type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
 export declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 export declare type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
-export declare type From<DB, TE> = {
+export declare type From<DB, TE> = DrainOuterGeneric<{
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
-};
-export declare type FromTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
+}>;
+export declare type FromTables<DB, TB extends keyof DB, TE> = DrainOuterGeneric<TB | ExtractAliasFromTableExpression<DB, TE>>;
 export declare type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never;
-export declare type PickTableWithAlias<DB, T extends AnyAliasedTable<DB>> = T extends `${infer TB} as ${infer A}` ? TB extends keyof DB ? Record<A, DB[TB]> : never : never;
+export declare type PickTableWithAlias<DB, T extends AnyAliasedTable<DB>> = T extends `${infer TB} as ${infer A}` ? TB extends keyof DB ? ShallowRecord<A, DB[TB]> : never : never;
 declare type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? ExtractTableAlias<DB, TE> : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
 declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : never;
 declare type AnyTable<DB> = keyof DB & string;

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

@@ -4,9 +4,10 @@ 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 { Expression } from '../expression/expression.js';
+import { ShallowRecord } from '../util/type-utils.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>>>;
+export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & ShallowRecord<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
+export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & ShallowRecord<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
 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.
@@ -30,7 +31,7 @@ declare type ExtractTableFromCommonTableExpressionName<CN extends string> = CN e
  */
 declare type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${string}(${infer CL})` ? {
     [C in ExtractColumnNamesFromColumnList<CL>]: any;
-} : Record<string, any>;
+} : ShallowRecord<string, any>;
 /**
  * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
  */

package/dist/esm/query-builder/case-builder.d.ts

@@ -0,0 +1,111 @@
+import { Expression } from '../expression/expression.js';
+import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { CaseNode } from '../operation-node/case-node.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { KyselyTypeError } from '../util/type-error.js';
+export declare class CaseBuilder<DB, TB extends keyof DB, W = unknown, O = never> implements Whenable<DB, TB, W, O> {
+    #private;
+    constructor(props: CaseBuilderProps);
+    /**
+     * Adds a `when` clause to the case statement.
+     *
+     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
+     */
+    when<RE extends ReferenceExpression<DB, TB>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): CaseThenBuilder<DB, TB, W, O>;
+    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
+    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
+}
+interface CaseBuilderProps {
+    readonly node: CaseNode;
+}
+export declare class CaseThenBuilder<DB, TB extends keyof DB, W, O> {
+    #private;
+    constructor(props: CaseBuilderProps);
+    /**
+     * Adds a `then` clause to the `case` statement.
+     *
+     * A `then` call can be followed by {@link Whenable.when}, {@link CaseWhenBuilder.else},
+     * {@link CaseWhenBuilder.end} or {@link CaseWhenBuilder.endCase} call.
+     */
+    then<O2>(expression: Expression<O2>): CaseWhenBuilder<DB, TB, W, O | O2>;
+    then<V>(value: V): CaseWhenBuilder<DB, TB, W, O | V>;
+}
+export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements Whenable<DB, TB, W, O>, Endable<O | null> {
+    #private;
+    constructor(props: CaseBuilderProps);
+    /**
+     * Adds a `when` clause to the case statement.
+     *
+     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
+     */
+    when<RE extends ReferenceExpression<DB, TB>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): CaseThenBuilder<DB, TB, W, O>;
+    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
+    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
+    /**
+     * Adds an `else` clause to the `case` statement.
+     *
+     * An `else` call must be followed by an {@link Endable.end} or {@link Endable.endCase} call.
+     */
+    else<O2>(expression: Expression<O2>): CaseEndBuilder<O | O2>;
+    else<V>(value: V): CaseEndBuilder<O | V>;
+    /**
+     * Adds an `end` keyword to the case operator.
+     *
+     * `case` operators can only be used as part of a query.
+     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
+     */
+    end(): ExpressionWrapper<O | null>;
+    /**
+     * Adds `end case` keywords to the case statement.
+     *
+     * `case` statements can only be used for flow control in stored programs.
+     * For a `case` operator used as part of a query, use {@link end} instead.
+     */
+    endCase(): ExpressionWrapper<O | null>;
+}
+export declare class CaseEndBuilder<O> implements Endable<O> {
+    #private;
+    constructor(props: CaseBuilderProps);
+    /**
+     * Adds an `end` keyword to the case operator.
+     *
+     * `case` operators can only be used as part of a query.
+     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
+     */
+    end(): ExpressionWrapper<O>;
+    /**
+     * Adds `end case` keywords to the case statement.
+     *
+     * `case` statements can only be used for flow control in stored programs.
+     * For a `case` operator used as part of a query, use {@link end} instead.
+     */
+    endCase(): ExpressionWrapper<O>;
+}
+interface Whenable<DB, TB extends keyof DB, W, O> {
+    /**
+     * Adds a `when` clause to the case statement.
+     *
+     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
+     */
+    when<RE extends ReferenceExpression<DB, TB>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): CaseThenBuilder<DB, TB, W, O>;
+    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
+    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
+}
+interface Endable<O> {
+    /**
+     * Adds an `end` keyword to the case operator.
+     *
+     * `case` operators can only be used as part of a query.
+     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
+     */
+    end(): ExpressionWrapper<O>;
+    /**
+     * Adds `end case` keywords to the case statement.
+     *
+     * `case` statements can only be used for flow control in stored programs.
+     * For a `case` operator used as part of a query, use {@link end} instead.
+     */
+    endCase(): ExpressionWrapper<O>;
+}
+export {};

package/dist/esm/query-builder/case-builder.js

@@ -0,0 +1,69 @@
+/// <reference types="./case-builder.d.ts" />
+import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import { freeze } from '../util/object-utils.js';
+import { CaseNode } from '../operation-node/case-node.js';
+import { WhenNode } from '../operation-node/when-node.js';
+import { parseWhen, } from '../parser/binary-operation-parser.js';
+import { parseValueExpression } from '../parser/value-parser.js';
+export class CaseBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    when(...args) {
+        return new CaseThenBuilder({
+            ...this.#props,
+            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseWhen(args))),
+        });
+    }
+}
+export class CaseThenBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    then(valueExpression) {
+        return new CaseWhenBuilder({
+            ...this.#props,
+            node: CaseNode.cloneWithThen(this.#props.node, parseValueExpression(valueExpression)),
+        });
+    }
+}
+export class CaseWhenBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    when(...args) {
+        return new CaseThenBuilder({
+            ...this.#props,
+            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseWhen(args))),
+        });
+    }
+    else(valueExpression) {
+        return new CaseEndBuilder({
+            ...this.#props,
+            node: CaseNode.cloneWith(this.#props.node, {
+                else: parseValueExpression(valueExpression),
+            }),
+        });
+    }
+    end() {
+        return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: false }));
+    }
+    endCase() {
+        return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: true }));
+    }
+}
+export class CaseEndBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    end() {
+        return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: false }));
+    }
+    endCase() {
+        return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: true }));
+    }
+}