kysely 0.2.1 → 0.2.5

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

@@ -5,6 +5,9 @@ export interface AndNode extends OperationNode {
     readonly left: FilterExpressionNode;
     readonly right: FilterExpressionNode;
 }
+/**
+ * @internal
+ */
 export declare const andNode: Readonly<{
     is(node: OperationNode): node is AndNode;
     create(left: FilterExpressionNode, right: FilterExpressionNode): AndNode;

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

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

package/lib/operation-node/check-constraint-node.d.ts

@@ -1,10 +1,15 @@
 import { OperationNode } from './operation-node';
 import { RawNode } from './raw-node';
+import { IdentifierNode } from './identifier-node';
 export interface CheckConstraintNode extends OperationNode {
     readonly kind: 'CheckConstraintNode';
     readonly expression: RawNode;
+    readonly name?: IdentifierNode;
 }
+/**
+ * @internal
+ */
 export declare const checkConstraintNode: Readonly<{
     is(node: OperationNode): node is CheckConstraintNode;
-    create(expressionSql: string): CheckConstraintNode;
+    create(expressionSql: string, constraintName?: string | undefined): CheckConstraintNode;
 }>;

package/lib/operation-node/check-constraint-node.js

@@ -3,14 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkConstraintNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const raw_node_1 = require("./raw-node");
+const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.checkConstraintNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'CheckConstraintNode';
     },
-    create(expressionSql) {
+    create(expressionSql, constraintName) {
         return object_utils_1.freeze({
             kind: 'CheckConstraintNode',
             expression: raw_node_1.rawNode.createWithSql(expressionSql),
+            name: constraintName ? identifier_node_1.identifierNode.create(constraintName) : undefined,
         });
     },
 });

package/lib/operation-node/column-definition-node.d.ts

@@ -0,0 +1,29 @@
+import { CheckConstraintNode } from './check-constraint-node';
+import { ColumnNode } from './column-node';
+import { DataTypeNode } from './data-type-node';
+import { OperationNode } from './operation-node';
+import { RawNode } from './raw-node';
+import { ReferencesNode } from './references-node';
+import { ValueNode } from './value-node';
+export declare type ColumnDefinitionNodeParams = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
+export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
+export interface ColumnDefinitionNode extends OperationNode {
+    readonly kind: 'ColumnDefinitionNode';
+    readonly column: ColumnNode;
+    readonly dataType: ColumnDataTypeNode;
+    readonly references?: ReferencesNode;
+    readonly isPrimaryKey: boolean;
+    readonly isAutoIncrementing: boolean;
+    readonly isUnique: boolean;
+    readonly isNullable: boolean;
+    readonly defaultTo?: ValueNode | RawNode;
+    readonly check?: CheckConstraintNode;
+}
+/**
+ * @internal
+ */
+export declare const columnDefinitionNode: Readonly<{
+    is(node: OperationNode): node is ColumnDefinitionNode;
+    create(column: string, dataType: ColumnDataTypeNode): ColumnDefinitionNode;
+    cloneWith(node: ColumnDefinitionNode, params: ColumnDefinitionNodeParams): ColumnDefinitionNode;
+}>;

package/lib/operation-node/column-definition-node.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.columnDefinitionNode = void 0;
+const object_utils_1 = require("../util/object-utils");
+const column_node_1 = require("./column-node");
+/**
+ * @internal
+ */
+exports.columnDefinitionNode = object_utils_1.freeze({
+    is(node) {
+        return node.kind === 'ColumnDefinitionNode';
+    },
+    create(column, dataType) {
+        return object_utils_1.freeze({
+            kind: 'ColumnDefinitionNode',
+            column: column_node_1.columnNode.create(column),
+            dataType,
+            isPrimaryKey: false,
+            isAutoIncrementing: false,
+            isUnique: false,
+            isNullable: true,
+        });
+    },
+    cloneWith(node, params) {
+        return object_utils_1.freeze({
+            ...node,
+            ...params,
+        });
+    },
+});

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

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

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

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

package/lib/operation-node/column-update-node.d.ts

@@ -6,6 +6,9 @@ export interface ColumnUpdateNode extends OperationNode {
     readonly column: ColumnNode;
     readonly value: ValueExpressionNode;
 }
+/**
+ * @internal
+ */
 export declare const columnUpdateNode: Readonly<{
     is(node: OperationNode): node is ColumnUpdateNode;
     create(column: ColumnNode, value: ValueExpressionNode): ColumnUpdateNode;

package/lib/operation-node/column-update-node.js

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

package/lib/operation-node/common-table-expression-node.d.ts

@@ -7,6 +7,9 @@ export interface CommonTableExpressionNode extends OperationNode {
     readonly name: IdentifierNode;
     readonly expression: QueryNode | RawNode;
 }
+/**
+ * @internal
+ */
 export declare const commonTableExpressionNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNode;
     create(name: IdentifierNode, expression: QueryNode | RawNode): CommonTableExpressionNode;

package/lib/operation-node/common-table-expression-node.js

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

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

@@ -0,0 +1,5 @@
+import { CheckConstraintNode } from "./check-constraint-node";
+import { ForeignKeyConstraintNode } from "./foreign-key-constraint-node";
+import { PrimaryKeyConstraintNode } from "./primary-constraint-node";
+import { UniqueConstraintNode } from "./unique-constraint-node";
+export declare type ConstraintNode = PrimaryKeyConstraintNode | UniqueConstraintNode | CheckConstraintNode | ForeignKeyConstraintNode;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/operation-node/create-index-node.d.ts

@@ -14,6 +14,9 @@ export interface CreateIndexNode extends OperationNode {
     readonly unique?: boolean;
     readonly using?: RawNode;
 }
+/**
+ * @internal
+ */
 export declare const createIndexNode: Readonly<{
     is(node: OperationNode): node is CreateIndexNode;
     create(name: string): CreateIndexNode;

package/lib/operation-node/create-index-node.js

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

package/lib/operation-node/create-schema-node.d.ts

@@ -7,6 +7,9 @@ export interface CreateSchemaNode extends OperationNode {
     readonly schema: IdentifierNode;
     readonly modifier?: CreateSchemaNodeModifier;
 }
+/**
+ * @internal
+ */
 export declare const createSchemaNode: Readonly<{
     is(node: OperationNode): node is CreateSchemaNode;
     create(schema: string, params?: CreateSchemaNodeParams | undefined): CreateSchemaNode;

package/lib/operation-node/create-schema-node.js

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

package/lib/operation-node/create-table-node.d.ts

@@ -1,25 +1,25 @@
-import { CheckConstraintNode } from './check-constraint-node';
-import { AddColumnNode } from './add-column-node';
 import { OperationNode } from './operation-node';
 import { TableNode } from './table-node';
-import { TablePrimaryConstraintNode } from './table-primary-constraint-node';
-import { TableUniqueConstraintNode } from './table-unique-constraint-node';
+import { ConstraintNode } from './constraint-node';
+import { ColumnDefinitionNode } from './column-definition-node';
 export declare type CreateTableNodeModifier = 'IfNotExists';
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;
-    readonly columns: ReadonlyArray<AddColumnNode>;
+    readonly columns: ReadonlyArray<ColumnDefinitionNode>;
     readonly modifier?: CreateTableNodeModifier;
-    readonly primaryKeyConstraint?: TablePrimaryConstraintNode;
-    readonly uniqueConstraints?: ReadonlyArray<TableUniqueConstraintNode>;
-    readonly checkConstraints?: ReadonlyArray<CheckConstraintNode>;
+    readonly constraints?: ReadonlyArray<ConstraintNode>;
 }
+/**
+ * @internal
+ */
 export declare const createTableNode: Readonly<{
     is(node: OperationNode): node is CreateTableNode;
     create(table: TableNode): CreateTableNode;
-    cloneWithColumn(createTable: CreateTableNode, column: AddColumnNode): CreateTableNode;
+    cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
     cloneWithModifier(createTable: CreateTableNode, modifier: CreateTableNodeModifier): CreateTableNode;
-    cloneWithPrimaryKeyConstraint(createTable: CreateTableNode, columns: string[]): CreateTableNode;
-    cloneWithUniqueConstraint(createTable: CreateTableNode, columns: string[]): CreateTableNode;
-    cloneWithCheckConstraint(createTable: CreateTableNode, sql: string): CreateTableNode;
+    cloneWithPrimaryKeyConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
+    cloneWithUniqueConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
+    cloneWithCheckConstraint(createTable: CreateTableNode, constraintName: string, sql: string): CreateTableNode;
+    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraintName: string, sourceColumns: string[], targetTable: string, targetColumns: string[]): CreateTableNode;
 }>;

package/lib/operation-node/create-table-node.js

@@ -3,8 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTableNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const check_constraint_node_1 = require("./check-constraint-node");
-const table_primary_constraint_node_1 = require("./table-primary-constraint-node");
-const table_unique_constraint_node_1 = require("./table-unique-constraint-node");
+const table_node_1 = require("./table-node");
+const primary_constraint_node_1 = require("./primary-constraint-node");
+const unique_constraint_node_1 = require("./unique-constraint-node");
+const foreign_key_constraint_node_1 = require("./foreign-key-constraint-node");
+const column_node_1 = require("./column-node");
+/**
+ * @internal
+ */
 exports.createTableNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'CreateTableNode';
@@ -28,27 +34,39 @@ exports.createTableNode = object_utils_1.freeze({
             modifier,
         });
     },
-    cloneWithPrimaryKeyConstraint(createTable, columns) {
+    cloneWithPrimaryKeyConstraint(createTable, constraintName, columns) {
+        const constraint = primary_constraint_node_1.primaryConstraintNode.create(columns, constraintName);
         return object_utils_1.freeze({
             ...createTable,
-            primaryKeyConstraint: table_primary_constraint_node_1.tablePrimaryConstraintNode.create(columns),
+            constraints: createTable.constraints
+                ? object_utils_1.freeze([...createTable.constraints, constraint])
+                : object_utils_1.freeze([constraint]),
+        });
+    },
+    cloneWithUniqueConstraint(createTable, constraintName, columns) {
+        const constraint = unique_constraint_node_1.uniqueConstraintNode.create(columns, constraintName);
+        return object_utils_1.freeze({
+            ...createTable,
+            constraints: createTable.constraints
+                ? object_utils_1.freeze([...createTable.constraints, constraint])
+                : object_utils_1.freeze([constraint]),
         });
     },
-    cloneWithUniqueConstraint(createTable, columns) {
-        const constraint = table_unique_constraint_node_1.tableUniqueConstraintNode.create(columns);
+    cloneWithCheckConstraint(createTable, constraintName, sql) {
+        const constraint = check_constraint_node_1.checkConstraintNode.create(sql, constraintName);
         return object_utils_1.freeze({
             ...createTable,
-            uniqueConstraints: createTable.uniqueConstraints
-                ? object_utils_1.freeze([...createTable.uniqueConstraints, constraint])
+            constraints: createTable.constraints
+                ? object_utils_1.freeze([...createTable.constraints, constraint])
                 : object_utils_1.freeze([constraint]),
         });
     },
-    cloneWithCheckConstraint(createTable, sql) {
-        const constraint = check_constraint_node_1.checkConstraintNode.create(sql);
+    cloneWithForeignKeyConstraint(createTable, constraintName, sourceColumns, targetTable, targetColumns) {
+        const constraint = foreign_key_constraint_node_1.foreignKeyConstraintNode.create(sourceColumns.map(column_node_1.columnNode.create), table_node_1.tableNode.create(targetTable), targetColumns.map(column_node_1.columnNode.create), constraintName);
         return object_utils_1.freeze({
             ...createTable,
-            checkConstraints: createTable.checkConstraints
-                ? object_utils_1.freeze([...createTable.checkConstraints, constraint])
+            constraints: createTable.constraints
+                ? object_utils_1.freeze([...createTable.constraints, constraint])
                 : object_utils_1.freeze([constraint]),
         });
     },

package/lib/operation-node/data-type-node.d.ts

@@ -5,6 +5,9 @@ export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';
     readonly dataType: ColumnDataType;
 }
+/**
+ * @internal
+ */
 export declare const dataTypeNode: Readonly<{
     is(node: OperationNode): node is DataTypeNode;
     create(dataType: ColumnDataType): DataTypeNode;

package/lib/operation-node/data-type-node.js

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

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

@@ -13,6 +13,9 @@ export interface DeleteQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
 }
+/**
+ * @internal
+ */
 export declare const deleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
     create(fromItem: TableExpressionNode, withNode?: WithNode | undefined): DeleteQueryNode;

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

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

package/lib/operation-node/drop-column-node.d.ts

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node';
+import { ColumnNode } from './column-node';
+export interface DropColumnNode extends OperationNode {
+    readonly kind: 'DropColumnNode';
+    readonly column: ColumnNode;
+}
+/**
+ * @internal
+ */
+export declare const dropColumnNode: Readonly<{
+    is(node: OperationNode): node is DropColumnNode;
+    create(column: string): DropColumnNode;
+}>;

package/lib/operation-node/drop-column-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropColumnNode = void 0;
+const object_utils_1 = require("../util/object-utils");
+const column_node_1 = require("./column-node");
+/**
+ * @internal
+ */
+exports.dropColumnNode = object_utils_1.freeze({
+    is(node) {
+        return node.kind === 'DropColumnNode';
+    },
+    create(column) {
+        return object_utils_1.freeze({
+            kind: 'DropColumnNode',
+            column: column_node_1.columnNode.create(column),
+        });
+    },
+});

package/lib/operation-node/drop-constraint-node.d.ts

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

package/lib/operation-node/drop-constraint-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropConstraintNode = void 0;
+const object_utils_1 = require("../util/object-utils");
+const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
+exports.dropConstraintNode = object_utils_1.freeze({
+    is(node) {
+        return node.kind === 'DropConstraintNode';
+    },
+    create(constraintName) {
+        return object_utils_1.freeze({
+            kind: 'DropConstraintNode',
+            constraintName: identifier_node_1.identifierNode.create(constraintName),
+        });
+    },
+});

package/lib/operation-node/drop-index-node.d.ts

@@ -7,6 +7,9 @@ export interface DropIndexNode extends OperationNode {
     readonly name: IdentifierNode;
     readonly modifier?: DropIndexNodeModifier;
 }
+/**
+ * @internal
+ */
 export declare const dropIndexNode: Readonly<{
     is(node: OperationNode): node is DropIndexNode;
     create(name: string, params?: DropIndexNodeParams | undefined): DropIndexNode;

package/lib/operation-node/drop-index-node.js

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

package/lib/operation-node/drop-schema-node.d.ts

@@ -7,6 +7,9 @@ export interface DropSchemaNode extends OperationNode {
     readonly schema: IdentifierNode;
     readonly modifier?: DropSchemaNodeModifier;
 }
+/**
+ * @internal
+ */
 export declare const dropSchemaNode: Readonly<{
     is(node: OperationNode): node is DropSchemaNode;
     create(schema: string, params?: DropSchemaNodeParams | undefined): DropSchemaNode;

package/lib/operation-node/drop-schema-node.js

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

package/lib/operation-node/drop-table-node.d.ts

@@ -1,14 +1,17 @@
 import { OperationNode } from './operation-node';
 import { TableNode } from './table-node';
-export declare type DropIndexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
+export declare type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
 export declare type DropTableNodeModifier = 'IfExists';
 export interface DropTableNode extends OperationNode {
     readonly kind: 'DropTableNode';
     readonly table: TableNode;
     readonly modifier?: DropTableNodeModifier;
 }
+/**
+ * @internal
+ */
 export declare const dropTableNode: Readonly<{
     is(node: OperationNode): node is DropTableNode;
-    create(table: TableNode, params?: DropIndexNodeParams | undefined): DropTableNode;
+    create(table: TableNode, params?: DropTablexNodeParams | undefined): DropTableNode;
     cloneWithModifier(dropIndex: DropTableNode, modifier: DropTableNodeModifier): DropTableNode;
 }>;

package/lib/operation-node/drop-table-node.js

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

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

@@ -9,6 +9,9 @@ export interface FilterNode extends OperationNode {
     readonly op: OperatorNode | RawNode;
     readonly right: ValueExpressionNode;
 }
+/**
+ * @internal
+ */
 export declare const filterNode: Readonly<{
     is(node: OperationNode): node is FilterNode;
     create(left: ReferenceExpressionNode | undefined, op: OperatorNode | RawNode, right: ValueExpressionNode): FilterNode;

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

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

package/lib/operation-node/foreign-key-constraint-node.d.ts

@@ -0,0 +1,18 @@
+import { ColumnNode } from './column-node';
+import { IdentifierNode } from './identifier-node';
+import { OperationNode } from './operation-node';
+import { ReferencesNode } from './references-node';
+import { TableNode } from './table-node';
+export interface ForeignKeyConstraintNode extends OperationNode {
+    readonly kind: 'ForeignKeyConstraintNode';
+    readonly columns: ReadonlyArray<ColumnNode>;
+    readonly references: ReferencesNode;
+    readonly name?: IdentifierNode;
+}
+/**
+ * @internal
+ */
+export declare const foreignKeyConstraintNode: Readonly<{
+    is(node: OperationNode): node is ForeignKeyConstraintNode;
+    create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string | undefined): ForeignKeyConstraintNode;
+}>;

package/lib/operation-node/foreign-key-constraint-node.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foreignKeyConstraintNode = void 0;
+const object_utils_1 = require("../util/object-utils");
+const identifier_node_1 = require("./identifier-node");
+const references_node_1 = require("./references-node");
+/**
+ * @internal
+ */
+exports.foreignKeyConstraintNode = object_utils_1.freeze({
+    is(node) {
+        return node.kind === 'ForeignKeyConstraintNode';
+    },
+    create(sourceColumns, targetTable, targetColumns, constraintName) {
+        return object_utils_1.freeze({
+            kind: 'ForeignKeyConstraintNode',
+            columns: sourceColumns,
+            references: references_node_1.referencesNode.create(targetTable, targetColumns),
+            name: constraintName ? identifier_node_1.identifierNode.create(constraintName) : undefined,
+        });
+    },
+});

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

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

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

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

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;