kysely 0.19.8 → 0.19.11

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

@@ -1,5 +1,6 @@
 /// <reference types="./operation-node-transformer.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { requireAllProps } from '../util/require-all-props.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -98,6 +99,9 @@ export class OperationNodeTransformer {
         DefaultValueNode: this.transformDefaultValue.bind(this),
         OnNode: this.transformOn.bind(this),
         ValuesNode: this.transformValues.bind(this),
+        SelectModifierNode: this.transformSelectModifier.bind(this),
+        CreateTypeNode: this.transformCreateType.bind(this),
+        DropTypeNode: this.transformDropType.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -115,120 +119,120 @@ export class OperationNodeTransformer {
         return freeze(list.map(this.transformNode));
     }
     transformSelectQuery(node) {
-        return {
+        return requireAllProps({
             kind: 'SelectQueryNode',
             from: this.transformNode(node.from),
             selections: this.transformNodeList(node.selections),
             distinctOnSelections: this.transformNodeList(node.distinctOnSelections),
-            distinct: node.distinct,
             joins: this.transformNodeList(node.joins),
             groupBy: this.transformNode(node.groupBy),
             orderBy: this.transformNode(node.orderBy),
             where: this.transformNode(node.where),
-            modifiers: node.modifiers,
+            frontModifiers: this.transformNodeList(node.frontModifiers),
+            endModifiers: this.transformNodeList(node.endModifiers),
             limit: this.transformNode(node.limit),
             offset: this.transformNode(node.offset),
             with: this.transformNode(node.with),
             having: this.transformNode(node.having),
             union: this.transformNodeList(node.union),
-        };
+        });
     }
     transformSelection(node) {
-        return {
+        return requireAllProps({
             kind: 'SelectionNode',
             selection: this.transformNode(node.selection),
-        };
+        });
     }
     transformColumn(node) {
-        return {
+        return requireAllProps({
             kind: 'ColumnNode',
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformAlias(node) {
-        return {
+        return requireAllProps({
             kind: 'AliasNode',
             node: this.transformNode(node.node),
             alias: this.transformNode(node.alias),
-        };
+        });
     }
     transformTable(node) {
-        return {
+        return requireAllProps({
             kind: 'TableNode',
             schema: this.transformNode(node.schema),
             table: this.transformNode(node.table),
-        };
+        });
     }
     transformFrom(node) {
-        return {
+        return requireAllProps({
             kind: 'FromNode',
             froms: this.transformNodeList(node.froms),
-        };
+        });
     }
     transformReference(node) {
-        return {
+        return requireAllProps({
             kind: 'ReferenceNode',
             table: this.transformNode(node.table),
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformFilter(node) {
-        return {
+        return requireAllProps({
             kind: 'FilterNode',
             left: this.transformNode(node.left),
             op: this.transformNode(node.op),
             right: this.transformNode(node.right),
-        };
+        });
     }
     transformAnd(node) {
-        return {
+        return requireAllProps({
             kind: 'AndNode',
             left: this.transformNode(node.left),
             right: this.transformNode(node.right),
-        };
+        });
     }
     transformOr(node) {
-        return {
+        return requireAllProps({
             kind: 'OrNode',
             left: this.transformNode(node.left),
             right: this.transformNode(node.right),
-        };
+        });
     }
     transformValueList(node) {
-        return {
+        return requireAllProps({
             kind: 'ValueListNode',
             values: this.transformNodeList(node.values),
-        };
+        });
     }
     transformParens(node) {
-        return {
+        return requireAllProps({
             kind: 'ParensNode',
             node: this.transformNode(node.node),
-        };
+        });
     }
     transformJoin(node) {
-        return {
+        return requireAllProps({
             kind: 'JoinNode',
             joinType: node.joinType,
             table: this.transformNode(node.table),
             on: this.transformNode(node.on),
-        };
+        });
     }
     transformRaw(node) {
-        return {
+        return requireAllProps({
             kind: 'RawNode',
             sqlFragments: freeze([...node.sqlFragments]),
             parameters: this.transformNodeList(node.parameters),
-        };
+        });
     }
     transformWhere(node) {
-        return {
+        return requireAllProps({
             kind: 'WhereNode',
             where: this.transformNode(node.where),
-        };
+        });
     }
     transformInsertQuery(node) {
-        return {
+        return requireAllProps({
             kind: 'InsertQueryNode',
             into: this.transformNode(node.into),
             columns: this.transformNodeList(node.columns),
@@ -238,16 +242,17 @@ export class OperationNodeTransformer {
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
             with: this.transformNode(node.with),
             ignore: node.ignore,
-        };
+            replace: node.replace,
+        });
     }
     transformValues(node) {
-        return {
+        return requireAllProps({
             kind: 'ValuesNode',
             values: this.transformNodeList(node.values),
-        };
+        });
     }
     transformDeleteQuery(node) {
-        return {
+        return requireAllProps({
             kind: 'DeleteQueryNode',
             from: this.transformNode(node.from),
             joins: this.transformNodeList(node.joins),
@@ -256,16 +261,16 @@ export class OperationNodeTransformer {
             with: this.transformNode(node.with),
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
-        };
+        });
     }
     transformReturning(node) {
-        return {
+        return requireAllProps({
             kind: 'ReturningNode',
             selections: this.transformNodeList(node.selections),
-        };
+        });
     }
     transformCreateTable(node) {
-        return {
+        return requireAllProps({
             kind: 'CreateTableNode',
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
@@ -273,10 +278,10 @@ export class OperationNodeTransformer {
             temporary: node.temporary,
             ifNotExists: node.ifNotExists,
             onCommit: node.onCommit,
-        };
+        });
     }
     transformColumnDefinition(node) {
-        return {
+        return requireAllProps({
             kind: 'ColumnDefinitionNode',
             column: this.transformNode(node.column),
             dataType: this.transformNode(node.dataType),
@@ -289,48 +294,48 @@ export class OperationNodeTransformer {
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
             generated: this.transformNode(node.generated),
-        };
+        });
     }
     transformAddColumn(node) {
-        return {
+        return requireAllProps({
             kind: 'AddColumnNode',
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformDropTable(node) {
-        return {
+        return requireAllProps({
             kind: 'DropTableNode',
             table: this.transformNode(node.table),
             ifExists: node.ifExists,
-        };
+        });
     }
     transformOrderBy(node) {
-        return {
+        return requireAllProps({
             kind: 'OrderByNode',
             items: this.transformNodeList(node.items),
-        };
+        });
     }
     transformOrderByItem(node) {
-        return {
+        return requireAllProps({
             kind: 'OrderByItemNode',
             orderBy: this.transformNode(node.orderBy),
             direction: this.transformNode(node.direction),
-        };
+        });
     }
     transformGroupBy(node) {
-        return {
+        return requireAllProps({
             kind: 'GroupByNode',
             items: this.transformNodeList(node.items),
-        };
+        });
     }
     transformGroupByItem(node) {
-        return {
+        return requireAllProps({
             kind: 'GroupByItemNode',
             groupBy: this.transformNode(node.groupBy),
-        };
+        });
     }
     transformUpdateQuery(node) {
-        return {
+        return requireAllProps({
             kind: 'UpdateQueryNode',
             table: this.transformNode(node.table),
             from: this.transformNode(node.from),
@@ -339,29 +344,29 @@ export class OperationNodeTransformer {
             updates: this.transformNodeList(node.updates),
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
-        };
+        });
     }
     transformColumnUpdate(node) {
-        return {
+        return requireAllProps({
             kind: 'ColumnUpdateNode',
             column: this.transformNode(node.column),
             value: this.transformNode(node.value),
-        };
+        });
     }
     transformLimit(node) {
-        return {
+        return requireAllProps({
             kind: 'LimitNode',
             limit: this.transformNode(node.limit),
-        };
+        });
     }
     transformOffset(node) {
-        return {
+        return requireAllProps({
             kind: 'OffsetNode',
             offset: this.transformNode(node.offset),
-        };
+        });
     }
     transformOnConflict(node) {
-        return {
+        return requireAllProps({
             kind: 'OnConflictNode',
             columns: this.transformNodeList(node.columns),
             constraint: this.transformNode(node.constraint),
@@ -370,128 +375,128 @@ export class OperationNodeTransformer {
             updates: this.transformNodeList(node.updates),
             updateWhere: this.transformNode(node.updateWhere),
             doNothing: node.doNothing,
-        };
+        });
     }
     transformOnDuplicateKey(node) {
-        return {
+        return requireAllProps({
             kind: 'OnDuplicateKeyNode',
             updates: this.transformNodeList(node.updates),
-        };
+        });
     }
     transformCreateIndex(node) {
-        return {
+        return requireAllProps({
             kind: 'CreateIndexNode',
             name: this.transformNode(node.name),
             table: this.transformNode(node.table),
             expression: this.transformNode(node.expression),
             unique: node.unique,
             using: this.transformNode(node.using),
-        };
+        });
     }
     transformList(node) {
-        return {
+        return requireAllProps({
             kind: 'ListNode',
             items: this.transformNodeList(node.items),
-        };
+        });
     }
     transformDropIndex(node) {
-        return {
+        return requireAllProps({
             kind: 'DropIndexNode',
             name: this.transformNode(node.name),
             table: this.transformNode(node.table),
             ifExists: node.ifExists,
-        };
+        });
     }
     transformPrimaryKeyConstraint(node) {
-        return {
+        return requireAllProps({
             kind: 'PrimaryKeyConstraintNode',
             columns: this.transformNodeList(node.columns),
             name: this.transformNode(node.name),
-        };
+        });
     }
     transformUniqueConstraint(node) {
-        return {
+        return requireAllProps({
             kind: 'UniqueConstraintNode',
             columns: this.transformNodeList(node.columns),
             name: this.transformNode(node.name),
-        };
+        });
     }
     transformForeignKeyConstraint(node) {
-        return {
+        return requireAllProps({
             kind: 'ForeignKeyConstraintNode',
             columns: this.transformNodeList(node.columns),
             references: this.transformNode(node.references),
             name: this.transformNode(node.name),
             onDelete: node.onDelete,
             onUpdate: node.onUpdate,
-        };
+        });
     }
     transformUnion(node) {
-        return {
+        return requireAllProps({
             kind: 'UnionNode',
             union: this.transformNode(node.union),
             all: node.all,
-        };
+        });
     }
     transformReferences(node) {
-        return {
+        return requireAllProps({
             kind: 'ReferencesNode',
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             onDelete: node.onDelete,
             onUpdate: node.onUpdate,
-        };
+        });
     }
     transformCheckConstraint(node) {
-        return {
+        return requireAllProps({
             kind: 'CheckConstraintNode',
             expression: this.transformNode(node.expression),
             name: this.transformNode(node.name),
-        };
+        });
     }
     transformWith(node) {
-        return {
+        return requireAllProps({
             kind: 'WithNode',
             expressions: this.transformNodeList(node.expressions),
             recursive: node.recursive,
-        };
+        });
     }
     transformCommonTableExpression(node) {
-        return {
+        return requireAllProps({
             kind: 'CommonTableExpressionNode',
             name: this.transformNode(node.name),
             expression: this.transformNode(node.expression),
-        };
+        });
     }
     transformCommonTableExpressionName(node) {
-        return {
+        return requireAllProps({
             kind: 'CommonTableExpressionNameNode',
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
-        };
+        });
     }
     transformHaving(node) {
-        return {
+        return requireAllProps({
             kind: 'HavingNode',
             having: this.transformNode(node.having),
-        };
+        });
     }
     transformCreateSchema(node) {
-        return {
+        return requireAllProps({
             kind: 'CreateSchemaNode',
             schema: this.transformNode(node.schema),
             ifNotExists: node.ifNotExists,
-        };
+        });
     }
     transformDropSchema(node) {
-        return {
+        return requireAllProps({
             kind: 'DropSchemaNode',
             schema: this.transformNode(node.schema),
             ifExists: node.ifExists,
-        };
+        });
     }
     transformAlterTable(node) {
-        return {
+        return requireAllProps({
             kind: 'AlterTableNode',
             table: this.transformNode(node.table),
             renameTo: this.transformNode(node.renameTo),
@@ -503,23 +508,23 @@ export class OperationNodeTransformer {
             modifyColumn: this.transformNode(node.modifyColumn),
             addConstraint: this.transformNode(node.addConstraint),
             dropConstraint: this.transformNode(node.dropConstraint),
-        };
+        });
     }
     transformDropColumn(node) {
-        return {
+        return requireAllProps({
             kind: 'DropColumnNode',
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformRenameColumn(node) {
-        return {
+        return requireAllProps({
             kind: 'RenameColumnNode',
             column: this.transformNode(node.column),
             renameTo: this.transformNode(node.renameTo),
-        };
+        });
     }
     transformAlterColumn(node) {
-        return {
+        return requireAllProps({
             kind: 'AlterColumnNode',
             column: this.transformNode(node.column),
             dataType: this.transformNode(node.dataType),
@@ -528,30 +533,30 @@ export class OperationNodeTransformer {
             dropDefault: node.dropDefault,
             setNotNull: node.setNotNull,
             dropNotNull: node.dropNotNull,
-        };
+        });
     }
     transformModifyColumn(node) {
-        return {
+        return requireAllProps({
             kind: 'ModifyColumnNode',
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformAddConstraint(node) {
-        return {
+        return requireAllProps({
             kind: 'AddConstraintNode',
             constraint: this.transformNode(node.constraint),
-        };
+        });
     }
     transformDropConstraint(node) {
-        return {
+        return requireAllProps({
             kind: 'DropConstraintNode',
             constraintName: this.transformNode(node.constraintName),
             ifExists: node.ifExists,
             modifier: node.modifier,
-        };
+        });
     }
     transformCreateView(node) {
-        return {
+        return requireAllProps({
             kind: 'CreateViewNode',
             name: this.transformNode(node.name),
             temporary: node.temporary,
@@ -560,37 +565,58 @@ export class OperationNodeTransformer {
             materialized: node.materialized,
             columns: this.transformNodeList(node.columns),
             as: this.transformNode(node.as),
-        };
+        });
     }
     transformDropView(node) {
-        return {
+        return requireAllProps({
             kind: 'DropViewNode',
             name: this.transformNode(node.name),
             ifExists: node.ifExists,
             materialized: node.materialized,
-        };
+        });
     }
     transformGenerated(node) {
-        return {
+        return requireAllProps({
             kind: 'GeneratedNode',
             byDefault: node.byDefault,
             always: node.always,
             identity: node.identity,
             stored: node.stored,
             expression: this.transformNode(node.expression),
-        };
+        });
     }
     transformDefaultValue(node) {
-        return {
+        return requireAllProps({
             kind: 'DefaultValueNode',
             defaultValue: this.transformNode(node.defaultValue),
-        };
+        });
     }
     transformOn(node) {
-        return {
+        return requireAllProps({
             kind: 'OnNode',
             on: this.transformNode(node.on),
-        };
+        });
+    }
+    transformSelectModifier(node) {
+        return requireAllProps({
+            kind: 'SelectModifierNode',
+            modifier: node.modifier,
+            rawModifier: this.transformNode(node.rawModifier),
+        });
+    }
+    transformCreateType(node) {
+        return requireAllProps({
+            kind: 'CreateTypeNode',
+            name: this.transformNode(node.name),
+            enum: this.transformNode(node.enum),
+        });
+    }
+    transformDropType(node) {
+        return requireAllProps({
+            kind: 'DropTypeNode',
+            name: this.transformNode(node.name),
+            ifExists: node.ifExists,
+        });
     }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.

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

@@ -65,6 +65,9 @@ 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';
+import { SelectModifierNode } from './select-modifier-node.js';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -136,4 +139,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitDefaultValue(node: DefaultValueNode): void;
     protected abstract visitOn(node: OnNode): void;
     protected abstract visitValues(node: ValuesNode): void;
+    protected abstract visitSelectModifier(node: SelectModifierNode): void;
+    protected abstract visitCreateType(node: CreateTypeNode): void;
+    protected abstract visitDropType(node: DropTypeNode): void;
 }

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

@@ -72,6 +72,9 @@ export class OperationNodeVisitor {
         DefaultValueNode: this.visitDefaultValue.bind(this),
         OnNode: this.visitOn.bind(this),
         ValuesNode: this.visitValues.bind(this),
+        SelectModifierNode: this.visitSelectModifier.bind(this),
+        CreateTypeNode: this.visitCreateType.bind(this),
+        DropTypeNode: this.visitDropType.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' | '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 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' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked' | 'Distinct';
+export interface SelectModifierNode extends OperationNode {
+    readonly kind: 'SelectModifierNode';
+    readonly modifier?: SelectModifier;
+    readonly rawModifier?: RawNode;
+}
+/**
+ * @internal
+ */
+export declare const SelectModifierNode: Readonly<{
+    is(node: OperationNode): node is SelectModifierNode;
+    create(modifier: SelectModifier): SelectModifierNode;
+    createWithRaw(modifier: RawNode): SelectModifierNode;
+}>;