kysely 0.27.5 → 0.28.0

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

@@ -37,7 +37,7 @@ import { OnConflictNode } from './on-conflict-node.js';
 import { CreateIndexNode } from './create-index-node.js';
 import { ListNode } from './list-node.js';
 import { DropIndexNode } from './drop-index-node.js';
-import { PrimaryKeyConstraintNode } from './primary-constraint-node.js';
+import { PrimaryKeyConstraintNode } from './primary-key-constraint-node.js';
 import { UniqueConstraintNode } from './unique-constraint-node.js';
 import { ReferencesNode } from './references-node.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
@@ -92,6 +92,10 @@ import { CastNode } from './cast-node.js';
 import { FetchNode } from './fetch-node.js';
 import { TopNode } from './top-node.js';
 import { OutputNode } from './output-node.js';
+import { RefreshMaterializedViewNode } from './refresh-materialized-view-node.js';
+import { OrActionNode } from './or-action-node.js';
+import { CollateNode } from './collate-node.js';
+import { RenameConstraintNode } from './rename-constraint-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -148,6 +152,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitModifyColumn(node: ModifyColumnNode): void;
     protected abstract visitAddConstraint(node: AddConstraintNode): void;
     protected abstract visitDropConstraint(node: DropConstraintNode): void;
+    protected abstract visitRenameConstraint(node: RenameConstraintNode): void;
     protected abstract visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
     protected abstract visitDataType(node: DataTypeNode): void;
     protected abstract visitSelectAll(node: SelectAllNode): void;
@@ -157,6 +162,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitPrimitiveValueList(node: PrimitiveValueListNode): void;
     protected abstract visitOperator(node: OperatorNode): void;
     protected abstract visitCreateView(node: CreateViewNode): void;
+    protected abstract visitRefreshMaterializedView(node: RefreshMaterializedViewNode): void;
     protected abstract visitDropView(node: DropViewNode): void;
     protected abstract visitGenerated(node: GeneratedNode): void;
     protected abstract visitDefaultValue(node: DefaultValueNode): void;
@@ -190,4 +196,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitFetch(node: FetchNode): void;
     protected abstract visitTop(node: TopNode): void;
     protected abstract visitOutput(node: OutputNode): void;
+    protected abstract visitOrAction(node: OrActionNode): void;
+    protected abstract visitCollate(node: CollateNode): void;
 }

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

@@ -64,8 +64,10 @@ export class OperationNodeVisitor {
         ModifyColumnNode: this.visitModifyColumn.bind(this),
         AddConstraintNode: this.visitAddConstraint.bind(this),
         DropConstraintNode: this.visitDropConstraint.bind(this),
+        RenameConstraintNode: this.visitRenameConstraint.bind(this),
         ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
         CreateViewNode: this.visitCreateView.bind(this),
+        RefreshMaterializedViewNode: this.visitRefreshMaterializedView.bind(this),
         DropViewNode: this.visitDropView.bind(this),
         GeneratedNode: this.visitGenerated.bind(this),
         DefaultValueNode: this.visitDefaultValue.bind(this),
@@ -99,6 +101,8 @@ export class OperationNodeVisitor {
         FetchNode: this.visitFetch.bind(this),
         TopNode: this.visitTop.bind(this),
         OutputNode: this.visitOutput.bind(this),
+        OrActionNode: this.visitOrAction.bind(this),
+        CollateNode: this.visitCollate.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export 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' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'MergeQueryNode' | 'MatchedNode' | 'AddIndexNode' | 'CastNode' | 'FetchNode' | 'TopNode' | 'OutputNode';
+export 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' | 'RefreshMaterializedViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'MergeQueryNode' | 'MatchedNode' | 'AddIndexNode' | 'CastNode' | 'FetchNode' | 'TopNode' | 'OutputNode' | 'OrActionNode' | 'CollateNode' | 'RenameConstraintNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -0,0 +1,12 @@
+import { OperationNode } from './operation-node.js';
+export interface OrActionNode extends OperationNode {
+    readonly kind: 'OrActionNode';
+    readonly action: string;
+}
+/**
+ * @internal
+ */
+export declare const OrActionNode: Readonly<{
+    is(node: OperationNode): node is OrActionNode;
+    create(action: string): OrActionNode;
+}>;

package/dist/esm/operation-node/or-action-node.js

@@ -0,0 +1,16 @@
+/// <reference types="./or-action-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const OrActionNode = freeze({
+    is(node) {
+        return node.kind === 'OrActionNode';
+    },
+    create(action) {
+        return freeze({
+            kind: 'OrActionNode',
+            action,
+        });
+    },
+});

package/dist/esm/operation-node/order-by-item-node.d.ts

@@ -1,8 +1,12 @@
+import { CollateNode } from './collate-node.js';
 import { OperationNode } from './operation-node.js';
+export type OrderByItemNodeProps = Omit<OrderByItemNode, 'kind' | 'orderBy'>;
 export interface OrderByItemNode extends OperationNode {
     readonly kind: 'OrderByItemNode';
     readonly orderBy: OperationNode;
     readonly direction?: OperationNode;
+    readonly nulls?: 'first' | 'last';
+    readonly collation?: CollateNode;
 }
 /**
  * @internal
@@ -10,4 +14,5 @@ export interface OrderByItemNode extends OperationNode {
 export declare const OrderByItemNode: Readonly<{
     is(node: OperationNode): node is OrderByItemNode;
     create(orderBy: OperationNode, direction?: OperationNode): OrderByItemNode;
+    cloneWith(node: OrderByItemNode, props: OrderByItemNodeProps): OrderByItemNode;
 }>;

package/dist/esm/operation-node/order-by-item-node.js

@@ -14,4 +14,10 @@ export const OrderByItemNode = freeze({
             direction,
         });
     },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
 });

package/dist/esm/operation-node/primary-key-constraint-node.d.ts

@@ -0,0 +1,29 @@
+import { ColumnNode } from './column-node.js';
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export interface PrimaryKeyConstraintNode extends OperationNode {
+    readonly kind: 'PrimaryKeyConstraintNode';
+    readonly columns: ReadonlyArray<ColumnNode>;
+    readonly name?: IdentifierNode;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+export type PrimaryKeyConstraintNodeProps = Omit<Partial<PrimaryKeyConstraintNode>, 'kind'>;
+/**
+ * @internal
+ */
+export declare const PrimaryKeyConstraintNode: Readonly<{
+    is(node: OperationNode): node is PrimaryKeyConstraintNode;
+    create(columns: string[], constraintName?: string): PrimaryKeyConstraintNode;
+    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): PrimaryKeyConstraintNode;
+}>;
+/**
+ * Backwards compatibility for a typo in the codebase.
+ *
+ * @deprecated Use {@link PrimaryKeyConstraintNode} instead.
+ */
+export declare const PrimaryConstraintNode: Readonly<{
+    is(node: OperationNode): node is PrimaryKeyConstraintNode;
+    create(columns: string[], constraintName?: string): PrimaryKeyConstraintNode;
+    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): PrimaryKeyConstraintNode;
+}>;

package/dist/esm/operation-node/{primary-constraint-node.js → primary-key-constraint-node.js}

@@ -1,11 +1,11 @@
-/// <reference types="./primary-constraint-node.d.ts" />
+/// <reference types="./primary-key-constraint-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
 /**
  * @internal
  */
-export const PrimaryConstraintNode = freeze({
+export const PrimaryKeyConstraintNode = freeze({
     is(node) {
         return node.kind === 'PrimaryKeyConstraintNode';
     },
@@ -16,4 +16,13 @@ export const PrimaryConstraintNode = freeze({
             name: constraintName ? IdentifierNode.create(constraintName) : undefined,
         });
     },
+    cloneWith(node, props) {
+        return freeze({ ...node, ...props });
+    },
 });
+/**
+ * Backwards compatibility for a typo in the codebase.
+ *
+ * @deprecated Use {@link PrimaryKeyConstraintNode} instead.
+ */
+export const PrimaryConstraintNode = PrimaryKeyConstraintNode;

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

@@ -13,6 +13,8 @@ import { Expression } from '../expression/expression.js';
 import { MergeQueryNode } from './merge-query-node.js';
 import { TopNode } from './top-node.js';
 import { OutputNode } from './output-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
 export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode | MergeQueryNode;
 type HasJoins = {
     joins?: ReadonlyArray<JoinNode>;
@@ -35,6 +37,9 @@ type HasOutput = {
 type HasEndModifiers = {
     endModifiers?: ReadonlyArray<OperationNode>;
 };
+type HasOrderBy = {
+    orderBy?: OrderByNode;
+};
 /**
  * @internal
  */
@@ -49,5 +54,7 @@ export declare const QueryNode: Readonly<{
     cloneWithExplain<T extends HasExplain>(node: T, format: ExplainFormat | undefined, options: Expression<any> | undefined): T;
     cloneWithTop<T extends HasTop>(node: T, top: TopNode): T;
     cloneWithOutput<T extends HasOutput>(node: T, selections: ReadonlyArray<SelectionNode>): T;
+    cloneWithOrderByItems<T extends HasOrderBy>(node: T, items: ReadonlyArray<OrderByItemNode>): T;
+    cloneWithoutOrderBy<T extends HasOrderBy>(node: T): T;
 }>;
 export {};

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

@@ -9,6 +9,7 @@ import { ReturningNode } from './returning-node.js';
 import { ExplainNode } from './explain-node.js';
 import { MergeQueryNode } from './merge-query-node.js';
 import { OutputNode } from './output-node.js';
+import { OrderByNode } from './order-by-node.js';
 /**
  * @internal
  */
@@ -82,4 +83,18 @@ export const QueryNode = freeze({
                 : OutputNode.create(selections),
         });
     },
+    cloneWithOrderByItems(node, items) {
+        return freeze({
+            ...node,
+            orderBy: node.orderBy
+                ? OrderByNode.cloneWithItems(node.orderBy, items)
+                : OrderByNode.create(items),
+        });
+    },
+    cloneWithoutOrderBy(node) {
+        return freeze({
+            ...node,
+            orderBy: undefined,
+        });
+    },
 });

package/dist/esm/operation-node/refresh-materialized-view-node.d.ts

@@ -0,0 +1,17 @@
+import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+export type RefreshMaterializedViewNodeParams = Omit<Partial<RefreshMaterializedViewNode>, 'kind' | 'name'>;
+export interface RefreshMaterializedViewNode extends OperationNode {
+    readonly kind: 'RefreshMaterializedViewNode';
+    readonly name: SchemableIdentifierNode;
+    readonly concurrently?: boolean;
+    readonly withNoData?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const RefreshMaterializedViewNode: Readonly<{
+    is(node: OperationNode): node is RefreshMaterializedViewNode;
+    create(name: string): RefreshMaterializedViewNode;
+    cloneWith(createView: RefreshMaterializedViewNode, params: RefreshMaterializedViewNodeParams): RefreshMaterializedViewNode;
+}>;

package/dist/esm/operation-node/refresh-materialized-view-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./refresh-materialized-view-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+/**
+ * @internal
+ */
+export const RefreshMaterializedViewNode = freeze({
+    is(node) {
+        return node.kind === 'RefreshMaterializedViewNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'RefreshMaterializedViewNode',
+            name: SchemableIdentifierNode.create(name),
+        });
+    },
+    cloneWith(createView, params) {
+        return freeze({
+            ...createView,
+            ...params,
+        });
+    },
+});

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+import { IdentifierNode } from './identifier-node.js';
+export interface RenameConstraintNode extends OperationNode {
+    readonly kind: 'RenameConstraintNode';
+    readonly oldName: IdentifierNode;
+    readonly newName: IdentifierNode;
+}
+/**
+ * @internal
+ */
+export declare const RenameConstraintNode: Readonly<{
+    is(node: OperationNode): node is RenameConstraintNode;
+    create(oldName: string, newName: string): RenameConstraintNode;
+}>;

package/dist/esm/operation-node/rename-constraint-node.js

@@ -0,0 +1,18 @@
+/// <reference types="./rename-constraint-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const RenameConstraintNode = freeze({
+    is(node) {
+        return node.kind === 'RenameConstraintNode';
+    },
+    create(oldName, newName) {
+        return freeze({
+            kind: 'RenameConstraintNode',
+            oldName: IdentifierNode.create(oldName),
+            newName: IdentifierNode.create(newName),
+        });
+    },
+});

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

@@ -46,7 +46,10 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
     cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
-    cloneWithOrderByItems(selectNode: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>): SelectQueryNode;
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>) => SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
@@ -56,6 +59,9 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
-    cloneWithoutOrderBy(select: SelectQueryNode): SelectQueryNode;
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node: SelectQueryNode) => SelectQueryNode;
     cloneWithoutGroupBy(select: SelectQueryNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -3,7 +3,7 @@ import { freeze } from '../util/object-utils.js';
 import { FromNode } from './from-node.js';
 import { GroupByNode } from './group-by-node.js';
 import { HavingNode } from './having-node.js';
-import { OrderByNode } from './order-by-node.js';
+import { QueryNode } from './query-node.js';
 /**
  * @internal
  */
@@ -48,14 +48,11 @@ export const SelectQueryNode = freeze({
                 : freeze([modifier]),
         });
     },
-    cloneWithOrderByItems(selectNode, items) {
-        return freeze({
-            ...selectNode,
-            orderBy: selectNode.orderBy
-                ? OrderByNode.cloneWithItems(selectNode.orderBy, items)
-                : OrderByNode.create(items),
-        });
-    },
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node, items) => QueryNode.cloneWithOrderByItems(node, items),
     cloneWithGroupByItems(selectNode, items) {
         return freeze({
             ...selectNode,
@@ -116,12 +113,11 @@ export const SelectQueryNode = freeze({
             offset: undefined,
         });
     },
-    cloneWithoutOrderBy(select) {
-        return freeze({
-            ...select,
-            orderBy: undefined,
-        });
-    },
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node) => QueryNode.cloneWithoutOrderBy(node),
     cloneWithoutGroupBy(select) {
         return freeze({
             ...select,

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

@@ -6,6 +6,8 @@ export interface UniqueConstraintNode extends OperationNode {
     readonly columns: ReadonlyArray<ColumnNode>;
     readonly name?: IdentifierNode;
     readonly nullsNotDistinct?: boolean;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
 }
 export type UniqueConstraintNodeProps = Omit<Partial<UniqueConstraintNode>, 'kind'>;
 /**

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

@@ -1,9 +1,7 @@
 import { ColumnUpdateNode } from './column-update-node.js';
 import { JoinNode } from './join-node.js';
 import { OperationNode } from './operation-node.js';
-import { PrimitiveValueListNode } from './primitive-value-list-node.js';
 import { ReturningNode } from './returning-node.js';
-import { ValueListNode } from './value-list-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { FromNode } from './from-node.js';
@@ -11,7 +9,7 @@ import { ExplainNode } from './explain-node.js';
 import { LimitNode } from './limit-node.js';
 import { TopNode } from './top-node.js';
 import { OutputNode } from './output-node.js';
-export type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
+import { OrderByNode } from './order-by-node.js';
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
     readonly table?: OperationNode;
@@ -26,13 +24,14 @@ export interface UpdateQueryNode extends OperationNode {
     readonly limit?: LimitNode;
     readonly top?: TopNode;
     readonly output?: OutputNode;
+    readonly orderBy?: OrderByNode;
 }
 /**
  * @internal
  */
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
-    create(table: OperationNode, withNode?: WithNode): UpdateQueryNode;
+    create(tables: ReadonlyArray<OperationNode>, withNode?: WithNode): UpdateQueryNode;
     createWithoutTable(): UpdateQueryNode;
     cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;

package/dist/esm/operation-node/update-query-node.js

@@ -1,6 +1,7 @@
 /// <reference types="./update-query-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { FromNode } from './from-node.js';
+import { ListNode } from './list-node.js';
 /**
  * @internal
  */
@@ -8,10 +9,12 @@ export const UpdateQueryNode = freeze({
     is(node) {
         return node.kind === 'UpdateQueryNode';
     },
-    create(table, withNode) {
+    create(tables, withNode) {
         return freeze({
             kind: 'UpdateQueryNode',
-            table,
+            // For backwards compatibility, use the raw table node when there's only one table
+            // and don't rename the property to something like `tables`.
+            table: tables.length === 1 ? tables[0] : ListNode.create(tables),
             ...(withNode && { with: withNode }),
         });
     },

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

@@ -0,0 +1 @@
+export type Collation = 'nocase' | 'binary' | 'rtrim' | (string & {});

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

@@ -0,0 +1,2 @@
+/// <reference types="./collate-parser.d.ts" />
+export {};

package/dist/esm/parser/delete-from-parser.d.ts

@@ -0,0 +1,5 @@
+import type { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
+import type { DeleteResult } from '../query-builder/delete-result.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
+export type DeleteFrom<DB, TE extends TableExpressionOrList<DB, never>> = TE extends ReadonlyArray<infer T> ? DeleteQueryBuilder<From<DB, T>, FromTables<DB, never, T>, DeleteResult> : TE extends keyof DB & string ? DeleteQueryBuilder<DB, ExtractTableAlias<DB, TE>, DeleteResult> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? DeleteQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, DeleteResult> : never : DeleteQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, DeleteResult>;

package/dist/esm/parser/delete-from-parser.js

@@ -0,0 +1,2 @@
+/// <reference types="./delete-from-parser.d.ts" />
+export {};

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

@@ -40,9 +40,11 @@ function parseRowValues(row, columns) {
         length: columns.size,
     });
     let hasUndefinedOrComplexColumns = false;
+    let indexedRowColumns = rowColumns.length;
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
         if (isUndefined(columnIdx)) {
+            indexedRowColumns--;
             continue;
         }
         const value = row[col];
@@ -51,7 +53,7 @@ function parseRowValues(row, columns) {
         }
         rowValues[columnIdx] = value;
     }
-    const hasMissingColumns = rowColumns.length < columns.size;
+    const hasMissingColumns = indexedRowColumns < columns.size;
     if (hasMissingColumns || hasUndefinedOrComplexColumns) {
         const defaultValue = DefaultInsertValueNode.create();
         return ValueListNode.create(rowValues.map((it) => isUndefined(it) ? defaultValue : parseValueExpression(it)));

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

@@ -1,7 +1,7 @@
 import { JoinNode, JoinType } from '../operation-node/join-node.js';
+import { JoinBuilder } from '../query-builder/join-builder.js';
 import { AnyColumn, AnyColumnWithTable, DrainOuterGeneric } from '../util/type-utils.js';
 import { From, FromTables } from './table-parser.js';
-import { JoinBuilder } from '../query-builder/join-builder.js';
 export type JoinReferenceExpression<DB, TB extends keyof DB, TE> = DrainOuterGeneric<AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>>;
 export type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
 type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;

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

@@ -1,8 +1,8 @@
 /// <reference types="./join-parser.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
-import { parseTableExpression, } from './table-parser.js';
 import { parseReferentialBinaryOperation } from './binary-operation-parser.js';
 import { createJoinBuilder } from './parse-utils.js';
+import { parseTableExpression, } from './table-parser.js';
 export function parseJoin(joinType, args) {
     if (args.length === 3) {
         return parseSingleOnJoin(joinType, args[0], args[1], args[2]);
@@ -10,6 +10,9 @@ export function parseJoin(joinType, args) {
     else if (args.length === 2) {
         return parseCallbackJoin(joinType, args[0], args[1]);
     }
+    else if (args.length === 1) {
+        return parseOnlessJoin(joinType, args[0]);
+    }
     else {
         throw new Error('not implemented');
     }
@@ -20,3 +23,6 @@ function parseCallbackJoin(joinType, from, callback) {
 function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
     return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferentialBinaryOperation(lhsColumn, '=', rhsColumn));
 }
+function parseOnlessJoin(joinType, from) {
+    return JoinNode.create(joinType, parseTableExpression(from));
+}

package/dist/esm/parser/merge-into-parser.d.ts

@@ -0,0 +1,5 @@
+import type { MergeQueryBuilder } from '../query-builder/merge-query-builder.js';
+import type { MergeResult } from '../query-builder/merge-result.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+import type { ExtractTableAlias, SimpleTableReference } from './table-parser.js';
+export type MergeInto<DB, TE extends SimpleTableReference<DB>> = TE extends keyof DB & string ? MergeQueryBuilder<DB, ExtractTableAlias<DB, TE>, MergeResult> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? MergeQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, MergeResult> : never : never;

package/dist/esm/parser/merge-into-parser.js

@@ -0,0 +1,2 @@
+/// <reference types="./merge-into-parser.d.ts" />
+export {};

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

@@ -1,12 +1,25 @@
+import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { Expression } from '../expression/expression.js';
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
-import { StringReference } from './reference-parser.js';
-import { ReferenceExpression } from './reference-parser.js';
+import { OrderByItemBuilder } from '../query-builder/order-by-item-builder.js';
+import { ExpressionOrFactory } from './expression-parser.js';
+import { ReferenceExpression, StringReference } from './reference-parser.js';
+export type OrderByExpression<DB, TB extends keyof DB, O> = StringReference<DB, TB> | (keyof O & string) | ExpressionOrFactory<DB, TB, any> | DynamicReferenceBuilder<any>;
+export type OrderByModifiers = OrderByDirection | OrderByModifiersCallbackExpression;
 export type OrderByDirection = 'asc' | 'desc';
 export declare function isOrderByDirection(thing: unknown): thing is OrderByDirection;
+export type OrderByModifiersCallbackExpression = (builder: OrderByItemBuilder) => OrderByItemBuilder;
+/**
+ * @deprecated performance reasons, use {@link OrderByExpression} instead.
+ */
 export type DirectedOrderByStringReference<DB, TB extends keyof DB, O> = `${StringReference<DB, TB> | (keyof O & string)} ${OrderByDirection}`;
-export type UndirectedOrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
-export type OrderByExpression<DB, TB extends keyof DB, O> = UndirectedOrderByExpression<DB, TB, O> | DirectedOrderByStringReference<DB, TB, O>;
+/**
+ * @deprecated replaced with {@link OrderByModifiers}
+ */
 export type OrderByDirectionExpression = OrderByDirection | Expression<any>;
+/**
+ * @deprecated use {@link OrderByExpression} instead.
+ */
+export type UndirectedOrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
 export declare function parseOrderBy(args: any[]): OrderByItemNode[];
-export declare function parseOrderByItem(ref: ReferenceExpression<any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;
+export declare function parseOrderByItem(expr: OrderByExpression<any, any, any>, modifiers?: OrderByModifiers): OrderByItemNode;