kysely 0.2.2 → 0.2.6

package/lib/operation-node/group-by-item-node.d.ts

@@ -4,6 +4,9 @@ export interface GroupByItemNode extends OperationNode {
     readonly kind: 'GroupByItemNode';
     readonly groupBy: ReferenceExpressionNode;
 }
+/**
+ * @internal
+ */
 export declare const groupByItemNode: Readonly<{
     is(node: OperationNode): node is GroupByItemNode;
     create(groupBy: ReferenceExpressionNode): GroupByItemNode;

package/lib/operation-node/group-by-item-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupByItemNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.groupByItemNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'GroupByItemNode';

package/lib/operation-node/group-by-node.d.ts

@@ -4,6 +4,9 @@ export interface GroupByNode extends OperationNode {
     readonly kind: 'GroupByNode';
     readonly items: ReadonlyArray<GroupByItemNode>;
 }
+/**
+ * @internal
+ */
 export declare const groupByNode: Readonly<{
     is(node: OperationNode): node is GroupByNode;
     create(items: ReadonlyArray<GroupByItemNode>): GroupByNode;

package/lib/operation-node/group-by-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupByNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.groupByNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'GroupByNode';

package/lib/operation-node/having-node.d.ts

@@ -8,6 +8,9 @@ export interface HavingNode extends OperationNode {
     readonly kind: 'HavingNode';
     readonly having: HavingNodeChild;
 }
+/**
+ * @internal
+ */
 export declare const havingNode: Readonly<{
     is(node: OperationNode): node is HavingNode;
     create(filter: HavingNodeChild): HavingNode;

package/lib/operation-node/having-node.js

@@ -4,6 +4,9 @@ exports.havingNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const and_node_1 = require("./and-node");
 const or_node_1 = require("./or-node");
+/**
+ * @internal
+ */
 exports.havingNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'HavingNode';

package/lib/operation-node/identifier-node.d.ts

@@ -3,6 +3,9 @@ export interface IdentifierNode extends OperationNode {
     readonly kind: 'IdentifierNode';
     readonly identifier: string;
 }
+/**
+ * @internal
+ */
 export declare const identifierNode: Readonly<{
     is(node: OperationNode): node is IdentifierNode;
     create(identifier: string): IdentifierNode;

package/lib/operation-node/identifier-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identifierNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.identifierNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'IdentifierNode';

package/lib/operation-node/insert-query-node.d.ts

@@ -17,6 +17,9 @@ export interface InsertQueryNode extends OperationNode {
     readonly onConflict?: OnConflictNode;
     readonly with?: WithNode;
 }
+/**
+ * @internal
+ */
 export declare const insertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
     create(into: TableNode, withNode?: WithNode | undefined): InsertQueryNode;

package/lib/operation-node/insert-query-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertQueryNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const on_conflict_node_1 = require("./on-conflict-node");
+/**
+ * @internal
+ */
 exports.insertQueryNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'InsertQueryNode';

package/lib/operation-node/join-node.d.ts

@@ -14,6 +14,9 @@ export interface JoinNode extends OperationNode {
     readonly table: JoinTableNode;
     readonly on?: JoinNodeOnNode;
 }
+/**
+ * @internal
+ */
 export declare const joinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;

package/lib/operation-node/join-node.js

@@ -4,6 +4,9 @@ exports.joinNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const and_node_1 = require("./and-node");
 const or_node_1 = require("./or-node");
+/**
+ * @internal
+ */
 exports.joinNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'JoinNode';

package/lib/operation-node/limit-node.d.ts

@@ -4,6 +4,9 @@ export interface LimitNode extends OperationNode {
     readonly kind: 'LimitNode';
     readonly limit: ValueNode;
 }
+/**
+ * @internal
+ */
 export declare const limitNode: Readonly<{
     is(node: OperationNode): node is LimitNode;
     create(limit: number): LimitNode;

package/lib/operation-node/limit-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.limitNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const value_node_1 = require("./value-node");
+/**
+ * @internal
+ */
 exports.limitNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'LimitNode';

package/lib/operation-node/list-node.d.ts

@@ -3,6 +3,9 @@ export interface ListNode extends OperationNode {
     readonly kind: 'ListNode';
     readonly items: ReadonlyArray<OperationNode>;
 }
+/**
+ * @internal
+ */
 export declare const listNode: Readonly<{
     is(node: OperationNode): node is ListNode;
     create(items: ReadonlyArray<OperationNode>): ListNode;

package/lib/operation-node/list-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.listNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'ListNode';

package/lib/operation-node/offset-node.d.ts

@@ -4,6 +4,9 @@ export interface OffsetNode extends OperationNode {
     readonly kind: 'OffsetNode';
     readonly offset: ValueNode;
 }
+/**
+ * @internal
+ */
 export declare const offsetNode: Readonly<{
     is(node: OperationNode): node is OffsetNode;
     create(offset: number): OffsetNode;

package/lib/operation-node/offset-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.offsetNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const value_node_1 = require("./value-node");
+/**
+ * @internal
+ */
 exports.offsetNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'OffsetNode';

package/lib/operation-node/on-conflict-node.d.ts

@@ -7,6 +7,9 @@ export interface OnConflictNode extends OperationNode {
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
     readonly doNothing?: boolean;
 }
+/**
+ * @internal
+ */
 export declare const onConflictNode: Readonly<{
     is(node: OperationNode): node is OnConflictNode;
     createWithDoNothing(columns: ReadonlyArray<ColumnNode>): OnConflictNode;

package/lib/operation-node/on-conflict-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onConflictNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.onConflictNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'OnConflictNode';

package/lib/operation-node/operation-node-transformer.d.ts

@@ -38,8 +38,8 @@ import { OnConflictNode } from './on-conflict-node';
 import { CreateIndexNode } from './create-index-node';
 import { ListNode } from './list-node';
 import { DropIndexNode } from './drop-index-node';
-import { TablePrimaryConstraintNode } from './table-primary-constraint-node';
-import { TableUniqueConstraintNode } from './table-unique-constraint-node';
+import { PrimaryKeyConstraintNode } from './primary-constraint-node';
+import { UniqueConstraintNode } from './unique-constraint-node';
 import { ReferencesNode } from './references-node';
 import { CheckConstraintNode } from './check-constraint-node';
 import { WithNode } from './with-node';
@@ -47,6 +47,14 @@ import { CommonTableExpressionNode } from './common-table-expression-node';
 import { HavingNode } from './having-node';
 import { CreateSchemaNode } from './create-schema-node';
 import { DropSchemaNode } from './drop-schema-node';
+import { AlterTableNode } from './alter-table-node';
+import { DropColumnNode } from './drop-column-node';
+import { RenameColumnNode } from './rename-column-node';
+import { AlterColumnNode } from './alter-column-node';
+import { AddConstraintNode } from './add-constraint-node';
+import { DropConstraintNode } from './drop-constraint-node';
+import { ForeignKeyConstraintNode } from './foreign-key-constraint-node';
+import { ColumnDefinitionNode } from './column-definition-node';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -100,6 +108,7 @@ export declare class OperationNodeTransformer {
     protected transformDeleteQuery(node: DeleteQueryNode): DeleteQueryNode;
     protected transformReturning(node: ReturningNode): ReturningNode;
     protected transformCreateTable(node: CreateTableNode): CreateTableNode;
+    protected transformColumnDefinition(node: ColumnDefinitionNode): ColumnDefinitionNode;
     protected transformAddColumn(node: AddColumnNode): AddColumnNode;
     protected transformDropTable(node: DropTableNode): DropTableNode;
     protected transformOrderBy(node: OrderByNode): OrderByNode;
@@ -114,8 +123,9 @@ export declare class OperationNodeTransformer {
     protected transformCreateIndex(node: CreateIndexNode): CreateIndexNode;
     protected transformList(node: ListNode): ListNode;
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
-    protected transformTablePrimaryConstraint(node: TablePrimaryConstraintNode): TablePrimaryConstraintNode;
-    protected transformTableUniqueConstraint(node: TableUniqueConstraintNode): TableUniqueConstraintNode;
+    protected transformPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): PrimaryKeyConstraintNode;
+    protected transformUniqueConstraint(node: UniqueConstraintNode): UniqueConstraintNode;
+    protected transformForeignKeyConstraint(node: ForeignKeyConstraintNode): ForeignKeyConstraintNode;
     protected transformReferences(node: ReferencesNode): ReferencesNode;
     protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
     protected transformWith(node: WithNode): WithNode;
@@ -123,6 +133,12 @@ export declare class OperationNodeTransformer {
     protected transformHaving(node: HavingNode): HavingNode;
     protected transformCreateSchema(node: CreateSchemaNode): CreateSchemaNode;
     protected transformDropSchema(node: DropSchemaNode): DropSchemaNode;
+    protected transformAlterTable(node: AlterTableNode): AlterTableNode;
+    protected transformDropColumn(node: DropColumnNode): DropColumnNode;
+    protected transformRenameColumn(node: RenameColumnNode): RenameColumnNode;
+    protected transformAlterColumn(node: AlterColumnNode): AlterColumnNode;
+    protected transformAddConstraint(node: AddConstraintNode): AddConstraintNode;
+    protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/lib/operation-node/operation-node-transformer.js

@@ -59,6 +59,7 @@ class OperationNodeTransformer {
         ReturningNode: this.transformReturning.bind(this),
         CreateTableNode: this.transformCreateTable.bind(this),
         AddColumnNode: this.transformAddColumn.bind(this),
+        ColumnDefinitionNode: this.transformColumnDefinition.bind(this),
         DropTableNode: this.transformDropTable.bind(this),
         DataTypeNode: this.transformDataType.bind(this),
         OrderByNode: this.transformOrderBy.bind(this),
@@ -73,8 +74,8 @@ class OperationNodeTransformer {
         CreateIndexNode: this.transformCreateIndex.bind(this),
         DropIndexNode: this.transformDropIndex.bind(this),
         ListNode: this.transformList.bind(this),
-        TablePrimaryConstraintNode: this.transformTablePrimaryConstraint.bind(this),
-        TableUniqueConstraintNode: this.transformTableUniqueConstraint.bind(this),
+        PrimaryKeyConstraintNode: this.transformPrimaryKeyConstraint.bind(this),
+        UniqueConstraintNode: this.transformUniqueConstraint.bind(this),
         ReferencesNode: this.transformReferences.bind(this),
         CheckConstraintNode: this.transformCheckConstraint.bind(this),
         WithNode: this.transformWith.bind(this),
@@ -82,6 +83,13 @@ class OperationNodeTransformer {
         HavingNode: this.transformHaving.bind(this),
         CreateSchemaNode: this.transformCreateSchema.bind(this),
         DropSchemaNode: this.transformDropSchema.bind(this),
+        AlterTableNode: this.transformAlterTable.bind(this),
+        DropColumnNode: this.transformDropColumn.bind(this),
+        RenameColumnNode: this.transformRenameColumn.bind(this),
+        AlterColumnNode: this.transformAlterColumn.bind(this),
+        AddConstraintNode: this.transformAddConstraint.bind(this),
+        DropConstraintNode: this.transformDropConstraint.bind(this),
+        ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
     };
     transformNode = (node) => {
         if (!node) {
@@ -241,15 +249,13 @@ class OperationNodeTransformer {
             kind: 'CreateTableNode',
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
+            constraints: this.transformNodeList(node.constraints),
             modifier: node.modifier,
-            primaryKeyConstraint: this.transformNode(node.primaryKeyConstraint),
-            uniqueConstraints: this.transformNodeList(node.uniqueConstraints),
-            checkConstraints: this.transformNodeList(node.checkConstraints),
         };
     }
-    transformAddColumn(node) {
+    transformColumnDefinition(node) {
         return {
-            kind: 'AddColumnNode',
+            kind: 'ColumnDefinitionNode',
             column: this.transformNode(node.column),
             dataType: this.transformNode(node.dataType),
             references: this.transformNode(node.references),
@@ -261,6 +267,12 @@ class OperationNodeTransformer {
             check: this.transformNode(node.check),
         };
     }
+    transformAddColumn(node) {
+        return {
+            kind: 'AddColumnNode',
+            column: this.transformNode(node.column),
+        };
+    }
     transformDropTable(node) {
         return {
             kind: 'DropTableNode',
@@ -354,23 +366,33 @@ class OperationNodeTransformer {
             modifier: node.modifier,
         };
     }
-    transformTablePrimaryConstraint(node) {
+    transformPrimaryKeyConstraint(node) {
         return {
-            kind: 'TablePrimaryConstraintNode',
+            kind: 'PrimaryKeyConstraintNode',
             columns: this.transformNodeList(node.columns),
+            name: this.transformNode(node.name),
         };
     }
-    transformTableUniqueConstraint(node) {
+    transformUniqueConstraint(node) {
         return {
-            kind: 'TableUniqueConstraintNode',
+            kind: 'UniqueConstraintNode',
             columns: this.transformNodeList(node.columns),
+            name: this.transformNode(node.name),
+        };
+    }
+    transformForeignKeyConstraint(node) {
+        return {
+            kind: 'ForeignKeyConstraintNode',
+            columns: this.transformNodeList(node.columns),
+            references: this.transformNode(node.references),
+            name: this.transformNode(node.name),
         };
     }
     transformReferences(node) {
         return {
             kind: 'ReferencesNode',
             table: this.transformNode(node.table),
-            column: this.transformNode(node.column),
+            columns: this.transformNodeList(node.columns),
             onDelete: node.onDelete,
         };
     }
@@ -378,6 +400,7 @@ class OperationNodeTransformer {
         return {
             kind: 'CheckConstraintNode',
             expression: this.transformNode(node.expression),
+            name: this.transformNode(node.name),
         };
     }
     transformWith(node) {
@@ -412,6 +435,57 @@ class OperationNodeTransformer {
             modifier: node.modifier,
         };
     }
+    transformAlterTable(node) {
+        return {
+            kind: 'AlterTableNode',
+            table: this.transformNode(node.table),
+            renameTo: this.transformNode(node.renameTo),
+            renameColumn: this.transformNode(node.renameColumn),
+            setSchema: this.transformNode(node.setSchema),
+            addColumn: this.transformNode(node.addColumn),
+            dropColumn: this.transformNode(node.dropColumn),
+            alterColumn: this.transformNode(node.alterColumn),
+            addConstraint: this.transformNode(node.addConstraint),
+            dropConstraint: this.transformNode(node.dropConstraint),
+        };
+    }
+    transformDropColumn(node) {
+        return {
+            kind: 'DropColumnNode',
+            column: this.transformNode(node.column),
+        };
+    }
+    transformRenameColumn(node) {
+        return {
+            kind: 'RenameColumnNode',
+            column: this.transformNode(node.column),
+            renameTo: this.transformNode(node.renameTo),
+        };
+    }
+    transformAlterColumn(node) {
+        return {
+            kind: 'AlterColumnNode',
+            column: this.transformNode(node.column),
+            dataType: this.transformNode(node.dataType),
+            dataTypeExpression: this.transformNode(node.dataTypeExpression),
+            setDefault: this.transformNode(node.setDefault),
+            dropDefault: node.dropDefault,
+            setNotNull: node.setNotNull,
+            dropNotNull: node.dropNotNull,
+        };
+    }
+    transformAddConstraint(node) {
+        return {
+            kind: 'AddConstraintNode',
+            constraint: this.transformNode(node.constraint),
+        };
+    }
+    transformDropConstraint(node) {
+        return {
+            kind: 'DropConstraintNode',
+            constraintName: this.transformNode(node.constraintName),
+        };
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/lib/operation-node/operation-node-visitor.d.ts

@@ -38,8 +38,8 @@ import { OnConflictNode } from './on-conflict-node';
 import { CreateIndexNode } from './create-index-node';
 import { ListNode } from './list-node';
 import { DropIndexNode } from './drop-index-node';
-import { TablePrimaryConstraintNode } from './table-primary-constraint-node';
-import { TableUniqueConstraintNode } from './table-unique-constraint-node';
+import { PrimaryKeyConstraintNode } from './primary-constraint-node';
+import { UniqueConstraintNode } from './unique-constraint-node';
 import { ReferencesNode } from './references-node';
 import { CheckConstraintNode } from './check-constraint-node';
 import { WithNode } from './with-node';
@@ -47,6 +47,14 @@ import { CommonTableExpressionNode } from './common-table-expression-node';
 import { HavingNode } from './having-node';
 import { CreateSchemaNode } from './create-schema-node';
 import { DropSchemaNode } from './drop-schema-node';
+import { AlterTableNode } from './alter-table-node';
+import { DropColumnNode } from './drop-column-node';
+import { RenameColumnNode } from './rename-column-node';
+import { AlterColumnNode } from './alter-column-node';
+import { AddConstraintNode } from './add-constraint-node';
+import { DropConstraintNode } from './drop-constraint-node';
+import { ForeignKeyConstraintNode } from './foreign-key-constraint-node';
+import { ColumnDefinitionNode } from './column-definition-node';
 export declare class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -71,6 +79,7 @@ export declare class OperationNodeVisitor {
     protected visitReturning(node: ReturningNode): void;
     protected visitCreateTable(node: CreateTableNode): void;
     protected visitAddColumn(node: AddColumnNode): void;
+    protected visitColumnDefinition(node: ColumnDefinitionNode): void;
     protected visitDropTable(node: DropTableNode): void;
     protected visitOrderBy(node: OrderByNode): void;
     protected visitOrderByItem(node: OrderByItemNode): void;
@@ -84,8 +93,8 @@ export declare class OperationNodeVisitor {
     protected visitCreateIndex(node: CreateIndexNode): void;
     protected visitList(node: ListNode): void;
     protected visitDropIndex(node: DropIndexNode): void;
-    protected visitTablePrimaryConstraint(node: TablePrimaryConstraintNode): void;
-    protected visitTableUniqueConstraint(node: TableUniqueConstraintNode): void;
+    protected visitPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): void;
+    protected visitUniqueConstraint(node: UniqueConstraintNode): void;
     protected visitReferences(node: ReferencesNode): void;
     protected visitCheckConstraint(node: CheckConstraintNode): void;
     protected visitWith(node: WithNode): void;
@@ -93,6 +102,13 @@ export declare class OperationNodeVisitor {
     protected visitHaving(node: HavingNode): void;
     protected visitCreateSchema(node: CreateSchemaNode): void;
     protected visitDropSchema(node: DropSchemaNode): void;
+    protected visitAlterTable(node: AlterTableNode): void;
+    protected visitDropColumn(node: DropColumnNode): void;
+    protected visitRenameColumn(node: RenameColumnNode): void;
+    protected visitAlterColumn(node: AlterColumnNode): void;
+    protected visitAddConstraint(node: AddConstraintNode): void;
+    protected visitDropConstraint(node: DropConstraintNode): void;
+    protected visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
     protected visitDataType(node: DataTypeNode): void;
     protected visitSelectAll(_: SelectAllNode): void;
     protected visitIdentifier(_: IdentifierNode): void;

package/lib/operation-node/operation-node-visitor.js

@@ -29,6 +29,7 @@ class OperationNodeVisitor {
         ReturningNode: this.visitReturning.bind(this),
         CreateTableNode: this.visitCreateTable.bind(this),
         AddColumnNode: this.visitAddColumn.bind(this),
+        ColumnDefinitionNode: this.visitColumnDefinition.bind(this),
         DropTableNode: this.visitDropTable.bind(this),
         DataTypeNode: this.visitDataType.bind(this),
         OrderByNode: this.visitOrderBy.bind(this),
@@ -43,8 +44,8 @@ class OperationNodeVisitor {
         CreateIndexNode: this.visitCreateIndex.bind(this),
         DropIndexNode: this.visitDropIndex.bind(this),
         ListNode: this.visitList.bind(this),
-        TablePrimaryConstraintNode: this.visitTablePrimaryConstraint.bind(this),
-        TableUniqueConstraintNode: this.visitTableUniqueConstraint.bind(this),
+        PrimaryKeyConstraintNode: this.visitPrimaryKeyConstraint.bind(this),
+        UniqueConstraintNode: this.visitUniqueConstraint.bind(this),
         ReferencesNode: this.visitReferences.bind(this),
         CheckConstraintNode: this.visitCheckConstraint.bind(this),
         WithNode: this.visitWith.bind(this),
@@ -52,6 +53,13 @@ class OperationNodeVisitor {
         HavingNode: this.visitHaving.bind(this),
         CreateSchemaNode: this.visitCreateSchema.bind(this),
         DropSchemaNode: this.visitDropSchema.bind(this),
+        AlterTableNode: this.visitAlterTable.bind(this),
+        DropColumnNode: this.visitDropColumn.bind(this),
+        RenameColumnNode: this.visitRenameColumn.bind(this),
+        AlterColumnNode: this.visitAlterColumn.bind(this),
+        AddConstraintNode: this.visitAddConstraint.bind(this),
+        DropConstraintNode: this.visitDropConstraint.bind(this),
+        ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
     };
     visitNode = (node) => {
         this.nodeStack.push(node);
@@ -182,13 +190,22 @@ class OperationNodeVisitor {
     visitCreateTable(node) {
         this.visitNode(node.table);
         node.columns.forEach(this.visitNode);
+        if (node.constraints) {
+            node.constraints.forEach(this.visitNode);
+        }
     }
     visitAddColumn(node) {
         this.visitNode(node.column);
+    }
+    visitColumnDefinition(node) {
+        this.visitNode(node.column);
         this.visitNode(node.dataType);
         if (node.defaultTo) {
             this.visitNode(node.defaultTo);
         }
+        if (node.references) {
+            this.visitNode(node.references);
+        }
         if (node.check) {
             this.visitNode(node.check);
         }
@@ -260,17 +277,26 @@ class OperationNodeVisitor {
     visitDropIndex(node) {
         this.visitNode(node.name);
     }
-    visitTablePrimaryConstraint(node) {
+    visitPrimaryKeyConstraint(node) {
+        if (node.name) {
+            this.visitNode(node.name);
+        }
         node.columns.forEach(this.visitNode);
     }
-    visitTableUniqueConstraint(node) {
+    visitUniqueConstraint(node) {
+        if (node.name) {
+            this.visitNode(node.name);
+        }
         node.columns.forEach(this.visitNode);
     }
     visitReferences(node) {
-        this.visitNode(node.column);
+        node.columns.forEach(this.visitNode);
         this.visitNode(node.table);
     }
     visitCheckConstraint(node) {
+        if (node.name) {
+            this.visitNode(node.name);
+        }
         this.visitNode(node.expression);
     }
     visitWith(node) {
@@ -289,6 +315,50 @@ class OperationNodeVisitor {
     visitDropSchema(node) {
         this.visitNode(node.schema);
     }
+    visitAlterTable(node) {
+        this.visitNode(node.table);
+        if (node.renameTo) {
+            this.visitNode(node.renameTo);
+        }
+        if (node.renameColumn) {
+            this.visitNode(node.renameColumn);
+        }
+        if (node.setSchema) {
+            this.visitNode(node.setSchema);
+        }
+        if (node.addColumn) {
+            this.visitNode(node.addColumn);
+        }
+        if (node.dropColumn) {
+            this.visitNode(node.dropColumn);
+        }
+        if (node.alterColumn) {
+            this.visitNode(node.alterColumn);
+        }
+    }
+    visitDropColumn(node) {
+        this.visitNode(node.column);
+    }
+    visitRenameColumn(node) {
+        this.visitNode(node.column);
+        this.visitNode(node.renameTo);
+    }
+    visitAlterColumn(node) {
+        this.visitNode(node.column);
+    }
+    visitAddConstraint(node) {
+        this.visitNode(node.constraint);
+    }
+    visitDropConstraint(node) {
+        this.visitNode(node.constraintName);
+    }
+    visitForeignKeyConstraint(node) {
+        if (node.name) {
+            this.visitNode(node.name);
+        }
+        node.columns.forEach(this.visitNode);
+        this.visitNode(node.references);
+    }
     visitDataType(node) { }
     visitSelectAll(_) { }
     visitIdentifier(_) { }

package/lib/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' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'TablePrimaryConstraintNode' | 'TableUniqueConstraintNode' | 'ReferencesNode' | 'CheckConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode';
+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' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }