kysely 0.12.2 → 0.15.0

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

@@ -2,24 +2,25 @@ import { CheckConstraintNode } from './check-constraint-node.js';
 import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
 import { DefaultValueNode } from './default-value-node.js';
-import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { GeneratedNode } from './generated-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
-export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
+export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
 export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
     readonly kind: 'ColumnDefinitionNode';
     readonly column: ColumnNode;
     readonly dataType: ColumnDataTypeNode;
     readonly references?: ReferencesNode;
-    readonly primaryKey: boolean;
-    readonly autoIncrement: boolean;
-    readonly unique: boolean;
-    readonly nullable: boolean;
+    readonly primaryKey?: boolean;
+    readonly autoIncrement?: boolean;
+    readonly unique?: boolean;
+    readonly notNull?: boolean;
     readonly defaultTo?: DefaultValueNode;
     readonly check?: CheckConstraintNode;
-    readonly generatedAlwaysAs?: GeneratedAlwaysAsNode;
+    readonly generated?: GeneratedNode;
+    readonly unsigned?: boolean;
 }
 /**
  * @internal

package/dist/esm/operation-node/column-definition-node.js

@@ -12,10 +12,6 @@ export const ColumnDefinitionNode = freeze({
             kind: 'ColumnDefinitionNode',
             column: ColumnNode.create(column),
             dataType,
-            primaryKey: false,
-            autoIncrement: false,
-            unique: false,
-            nullable: true,
         });
     },
     cloneWith(node, props) {

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' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb';
+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' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | '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/generated-node.d.ts

@@ -0,0 +1,20 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export declare type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
+export interface GeneratedNode extends OperationNode {
+    readonly kind: 'GeneratedNode';
+    readonly byDefault?: boolean;
+    readonly always?: boolean;
+    readonly identity?: boolean;
+    readonly stored?: boolean;
+    readonly expression?: RawNode;
+}
+/**
+ * @internal
+ */
+export declare const GeneratedNode: Readonly<{
+    is(node: OperationNode): node is GeneratedNode;
+    create(params: GeneratedNodeParams): GeneratedNode;
+    createWithExpression(expression: RawNode): GeneratedNode;
+    cloneWith(node: GeneratedNode, params: GeneratedNodeParams): GeneratedNode;
+}>;

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

@@ -0,0 +1,28 @@
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const GeneratedNode = freeze({
+    is(node) {
+        return node.kind === 'GeneratedNode';
+    },
+    create(params) {
+        return freeze({
+            kind: 'GeneratedNode',
+            ...params,
+        });
+    },
+    createWithExpression(expression) {
+        return freeze({
+            kind: 'GeneratedNode',
+            always: true,
+            expression,
+        });
+    },
+    cloneWith(node, params) {
+        return freeze({
+            ...node,
+            ...params,
+        });
+    },
+});

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

@@ -1,13 +1,19 @@
 import { ColumnNode } from './column-node.js';
 import { ColumnUpdateNode } from './column-update-node.js';
 import { IdentifierNode } from './identifier-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind'>;
+import { RawNode } from './raw-node.js';
+import { WhereNode } from './where-node.js';
+export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
 export interface OnConflictNode extends OperationNode {
     readonly kind: 'OnConflictNode';
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly constraint?: IdentifierNode;
+    readonly indexExpression?: RawNode;
+    readonly indexWhere?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
+    readonly updateWhere?: WhereNode;
     readonly doNothing?: boolean;
 }
 /**
@@ -15,5 +21,10 @@ export interface OnConflictNode extends OperationNode {
  */
 export declare const OnConflictNode: Readonly<{
     is(node: OperationNode): node is OnConflictNode;
-    create(props: OnConflictNodeProps): OnConflictNode;
+    create(): OnConflictNode;
+    cloneWith(node: OnConflictNode, props: OnConflictNodeProps): OnConflictNode;
+    cloneWithIndexWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithIndexOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithUpdateWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithUpdateOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
 }>;

package/dist/esm/operation-node/on-conflict-node.js

@@ -1,4 +1,5 @@
 import { freeze } from '../util/object-utils.js';
+import { WhereNode } from './where-node.js';
 /**
  * @internal
  */
@@ -6,10 +7,47 @@ export const OnConflictNode = freeze({
     is(node) {
         return node.kind === 'OnConflictNode';
     },
-    create(props) {
+    create() {
         return freeze({
             kind: 'OnConflictNode',
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
             ...props,
         });
     },
+    cloneWithIndexWhere(node, filter) {
+        return freeze({
+            ...node,
+            indexWhere: node.indexWhere
+                ? WhereNode.cloneWithFilter(node.indexWhere, 'And', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithIndexOrWhere(node, filter) {
+        return freeze({
+            ...node,
+            indexWhere: node.indexWhere
+                ? WhereNode.cloneWithFilter(node.indexWhere, 'Or', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithUpdateWhere(node, filter) {
+        return freeze({
+            ...node,
+            updateWhere: node.updateWhere
+                ? WhereNode.cloneWithFilter(node.updateWhere, 'And', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithUpdateOrWhere(node, filter) {
+        return freeze({
+            ...node,
+            updateWhere: node.updateWhere
+                ? WhereNode.cloneWithFilter(node.updateWhere, 'Or', filter)
+                : WhereNode.create(filter),
+        });
+    },
 });

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

@@ -61,7 +61,7 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
-import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
@@ -156,7 +156,7 @@ export declare class OperationNodeTransformer {
     protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
-    protected transformGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): GeneratedAlwaysAsNode;
+    protected transformGenerated(node: GeneratedNode): GeneratedNode;
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;

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

@@ -93,7 +93,7 @@ export class OperationNodeTransformer {
         UnionNode: this.transformUnion.bind(this),
         CreateViewNode: this.transformCreateView.bind(this),
         DropViewNode: this.transformDropView.bind(this),
-        GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
+        GeneratedNode: this.transformGenerated.bind(this),
         DefaultValueNode: this.transformDefaultValue.bind(this),
         OnNode: this.transformOn.bind(this),
         ValuesNode: this.transformValues.bind(this),
@@ -281,10 +281,11 @@ export class OperationNodeTransformer {
             primaryKey: node.primaryKey,
             autoIncrement: node.autoIncrement,
             unique: node.unique,
-            nullable: node.nullable,
+            notNull: node.notNull,
+            unsigned: node.unsigned,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
-            generatedAlwaysAs: this.transformNode(node.generatedAlwaysAs),
+            generated: this.transformNode(node.generated),
         };
     }
     transformAddColumn(node) {
@@ -360,7 +361,10 @@ export class OperationNodeTransformer {
             kind: 'OnConflictNode',
             columns: this.transformNodeList(node.columns),
             constraint: this.transformNode(node.constraint),
+            indexExpression: this.transformNode(node.indexExpression),
+            indexWhere: this.transformNode(node.indexWhere),
             updates: this.transformNodeList(node.updates),
+            updateWhere: this.transformNode(node.updateWhere),
             doNothing: node.doNothing,
         };
     }
@@ -559,11 +563,14 @@ export class OperationNodeTransformer {
             materialized: node.materialized,
         };
     }
-    transformGeneratedAlwaysAs(node) {
+    transformGenerated(node) {
         return {
-            kind: 'GeneratedAlwaysAsNode',
-            expression: this.transformNode(node.expression),
+            kind: 'GeneratedNode',
+            byDefault: node.byDefault,
+            always: node.always,
+            identity: node.identity,
             stored: node.stored,
+            expression: this.transformNode(node.expression),
         };
     }
     transformDefaultValue(node) {

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

@@ -61,7 +61,7 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
-import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
@@ -132,7 +132,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitOperator(node: OperatorNode): void;
     protected abstract visitCreateView(node: CreateViewNode): void;
     protected abstract visitDropView(node: DropViewNode): void;
-    protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
+    protected abstract visitGenerated(node: GeneratedNode): void;
     protected abstract visitDefaultValue(node: DefaultValueNode): void;
     protected abstract visitOn(node: OnNode): void;
     protected abstract visitValues(node: ValuesNode): void;

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

@@ -67,7 +67,7 @@ export class OperationNodeVisitor {
         UnionNode: this.visitUnion.bind(this),
         CreateViewNode: this.visitCreateView.bind(this),
         DropViewNode: this.visitDropView.bind(this),
-        GeneratedAlwaysAsNode: this.visitGeneratedAlwaysAs.bind(this),
+        GeneratedNode: this.visitGenerated.bind(this),
         DefaultValueNode: this.visitDefaultValue.bind(this),
         OnNode: this.visitOn.bind(this),
         ValuesNode: this.visitValues.bind(this),

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/parser/insert-values-parser.d.ts

@@ -1,12 +1,12 @@
 import { ColumnNode } from '../operation-node/column-node.js';
-import { GeneratedPlaceholder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 import { ValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
+import { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
-    [C in keyof DB[TB]]: InsertValueExpression<DB, TB, DB[TB][C]>;
+    [C in NonNullableInsertKeys<DB[TB]>]: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
+} & {
+    [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-declare type InsertValueExpression<DB, TB extends keyof DB, T> = ValueExpression<DB, TB, T> | GeneratedPlaceholder;
 export declare function parseInsertObjectOrList(ctx: ParseContext, args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];
-export {};

package/dist/esm/parser/insert-values-parser.js

@@ -1,7 +1,6 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
-import { isGeneratedPlaceholder } from '../util/generated-placeholder.js';
 import { freeze, isPrimitive } from '../util/object-utils.js';
 import { parseValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
@@ -20,7 +19,7 @@ function parseColumnNamesAndIndexes(rows) {
     for (const row of rows) {
         const cols = Object.keys(row);
         for (const col of cols) {
-            if (!columns.has(col) && !isGeneratedPlaceholder(row[col])) {
+            if (!columns.has(col) && row[col] !== undefined) {
                 columns.set(col, columns.size);
             }
         }
@@ -33,7 +32,7 @@ function parseRowValues(ctx, row, columns) {
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
         const value = row[col];
-        if (columnIdx !== undefined && !isGeneratedPlaceholder(value)) {
+        if (columnIdx !== undefined) {
             rowValues[columnIdx] = value;
         }
     }

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

@@ -3,17 +3,18 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { PrimitiveValue } from '../util/object-utils.js';
-import { AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
+import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ParseContext } from './parse-context.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { SelectType } from '../util/column-type.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
-declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, R = RowType<DB, TB>> = 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 keyof R ? R[RE] : PrimitiveValue;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = 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> : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;

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

@@ -1,10 +1,11 @@
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
+import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ParseContext } from './parse-context.js';
 import { AliasedComplexExpression } from './complex-expression-parser.js';
+import { Selectable, SelectType } from '../util/column-type.js';
 export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB>;
 export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
 /**
@@ -15,14 +16,19 @@ export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, SE> =
 /**
  * `selectAll` output query builder type.
  */
-export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & RowType<DB, S>>;
+export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & AllSelection<DB, S>>;
 export declare type Selection<DB, TB extends keyof DB, SE> = {
-    [A in ExtractAliasFromSelectExpression<SE>]: ExtractTypeFromSelectExpression<DB, TB, SE, A>;
+    [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
 declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : 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 AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<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, R = RowType<DB, TB>> = 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 keyof R ? R[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 keyof R ? R[SE] : 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;
+declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
+    [C in AnyColumn<DB, TB>]: {
+        [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
+    }[TB];
+}>;
 export declare function parseSelectExpressionOrList(ctx: ParseContext, selection: SelectExpressionOrList<any, any>): SelectionNode[];
 export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

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

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

package/dist/esm/plugin/camel-case/camel-case-plugin.d.ts

@@ -12,8 +12,8 @@ export interface CamelCasePluginOptions {
     upperCase?: boolean;
     /**
      * If true, an underscore is added before each digit when converting
-     * camelCase to snake_case. For example `foo1Bar => foo_1_bar` and
-     * `foo_1_bar => foo1Bar`
+     * camelCase to snake_case. For example `foo12Bar => foo_12_bar` and
+     * `foo_12_bar => foo12Bar`
      *
      * Defaults to false.
      */

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

@@ -539,7 +539,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -553,7 +552,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id, first_name } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -569,7 +567,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })