kysely 0.9.0 → 0.9.4

package/dist/cjs/dialect/mysql/mysql-dialect.d.ts

@@ -5,6 +5,13 @@ import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../../introspection/database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
+ *
+ * The {@link MysqlDialectConfig | configuration} passed to the constructor
+ * is given as-is to the mysql2 library's [createPool](https://github.com/sidorares/node-mysql2#using-connection-pools)
+ * method.
+ */
 export declare class MysqlDialect implements Dialect {
     #private;
     constructor(config: MysqlDialectConfig);
@@ -17,6 +24,8 @@ export declare class MysqlDialect implements Dialect {
  * Config for the mysql dialect.
  *
  * This interface is equal to `mysql2` library's pool config.
+ *
+ * https://github.com/sidorares/node-mysql2#using-connection-pools
  */
 export interface MysqlDialectConfig {
     /**

package/dist/cjs/dialect/mysql/mysql-dialect.js

@@ -5,6 +5,13 @@ const mysql_driver_js_1 = require("./mysql-driver.js");
 const mysql_query_compiler_js_1 = require("./mysql-query-compiler.js");
 const mysql_introspector_js_1 = require("./mysql-introspector.js");
 const mysql_adapter_js_1 = require("./mysql-adapter.js");
+/**
+ * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
+ *
+ * The {@link MysqlDialectConfig | configuration} passed to the constructor
+ * is given as-is to the mysql2 library's [createPool](https://github.com/sidorares/node-mysql2#using-connection-pools)
+ * method.
+ */
 class MysqlDialect {
     #config;
     constructor(config) {

package/dist/cjs/dialect/mysql/mysql-driver.js

@@ -107,13 +107,13 @@ class MysqlConnection {
     async executeQuery(compiledQuery) {
         const result = await this.#executeQuery(compiledQuery);
         if ((0, object_utils_js_1.isObject)(result) && 'insertId' in result && 'affectedRows' in result) {
-            if (result.insertId) {
+            if ((0, object_utils_js_1.isNumber)(result.insertId) && result.insertId > 0) {
                 return {
                     insertedPrimaryKey: result.insertId,
                     rows: [],
                 };
             }
-            else {
+            else if ((0, object_utils_js_1.isNumber)(result.affectedRows)) {
                 return {
                     numUpdatedOrDeletedRows: result.affectedRows,
                     rows: [],

package/dist/cjs/dialect/postgres/postgres-dialect.d.ts

@@ -8,6 +8,16 @@ import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../../introspection/database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
+ *
+ * The {@link PostgresDialectConfig | configuration} passed to the constructor
+ * is given as-is to the pg library's [Pool](https://node-postgres.com/api/pool)
+ * constructor. See the following two links for more documentation:
+ *
+ * https://node-postgres.com/api/pool
+ * https://node-postgres.com/api/client
+ */
 export declare class PostgresDialect implements Dialect {
     #private;
     constructor(config: PostgresDialectConfig);
@@ -19,7 +29,7 @@ export declare class PostgresDialect implements Dialect {
 /**
  * Config for the postgres dialect.
  *
- * This interface is equal to `pg` library's pool config:
+ * This interface is equal to `pg` library's `Pool` config:
  *
  * https://node-postgres.com/api/pool
  * https://node-postgres.com/api/client

package/dist/cjs/dialect/postgres/postgres-dialect.js

@@ -5,6 +5,16 @@ const postgres_driver_js_1 = require("./postgres-driver.js");
 const postgres_introspector_js_1 = require("./postgres-introspector.js");
 const postgres_query_compiler_js_1 = require("./postgres-query-compiler.js");
 const postgres_adapter_js_1 = require("./postgres-adapter.js");
+/**
+ * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
+ *
+ * The {@link PostgresDialectConfig | configuration} passed to the constructor
+ * is given as-is to the pg library's [Pool](https://node-postgres.com/api/pool)
+ * constructor. See the following two links for more documentation:
+ *
+ * https://node-postgres.com/api/pool
+ * https://node-postgres.com/api/client
+ */
 class PostgresDialect {
     #config;
     constructor(config) {

package/dist/cjs/driver/runtime-driver.d.ts

@@ -1,3 +1,4 @@
+import { Log } from '../util/log.js';
 import { DatabaseConnection } from './database-connection.js';
 import { Driver, TransactionSettings } from './driver.js';
 /**
@@ -7,10 +8,10 @@ import { Driver, TransactionSettings } from './driver.js';
  */
 export declare class RuntimeDriver implements Driver {
     #private;
-    constructor(driver: Driver);
+    constructor(driver: Driver, log: Log);
     init(): Promise<void>;
     acquireConnection(): Promise<DatabaseConnection>;
-    releaseConnection(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(runtimeConnection: DatabaseConnection): Promise<void>;
     beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
     commitTransaction(connection: DatabaseConnection): Promise<void>;
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;

package/dist/cjs/driver/runtime-driver.js

@@ -8,10 +8,13 @@ exports.RuntimeDriver = void 0;
  */
 class RuntimeDriver {
     #driver;
+    #log;
     #initPromise;
     #destroyPromise;
-    constructor(driver) {
+    #connections = new WeakMap();
+    constructor(driver, log) {
         this.#driver = driver;
+        this.#log = log;
     }
     async init() {
         if (!this.#initPromise) {
@@ -24,10 +27,18 @@ class RuntimeDriver {
     }
     async acquireConnection() {
         await this.init();
-        return this.#driver.acquireConnection();
+        const connection = await this.#driver.acquireConnection();
+        let runtimeConnection = this.#connections.get(connection);
+        if (!runtimeConnection) {
+            runtimeConnection = new RuntimeConnection(connection, this.#log);
+            this.#connections.set(connection, runtimeConnection);
+        }
+        return runtimeConnection;
     }
-    releaseConnection(connection) {
-        return this.#driver.releaseConnection(connection);
+    async releaseConnection(runtimeConnection) {
+        if (runtimeConnection instanceof RuntimeConnection) {
+            await this.#driver.releaseConnection(runtimeConnection.connection);
+        }
     }
     beginTransaction(connection, settings) {
         return this.#driver.beginTransaction(connection, settings);
@@ -53,3 +64,31 @@ class RuntimeDriver {
     }
 }
 exports.RuntimeDriver = RuntimeDriver;
+class RuntimeConnection {
+    #connection;
+    #log;
+    get connection() {
+        return this.#connection;
+    }
+    constructor(connection, log) {
+        this.#connection = connection;
+        this.#log = log;
+    }
+    async executeQuery(compiledQuery) {
+        const startTime = process.hrtime.bigint();
+        try {
+            return await this.#connection.executeQuery(compiledQuery);
+        }
+        finally {
+            this.#log.query((log) => {
+                log(compiledQuery.sql);
+                log(`duration: ${this.#calculateDurationMillis(startTime)}ms`);
+            });
+        }
+    }
+    #calculateDurationMillis(startTime) {
+        const endTime = process.hrtime.bigint();
+        const durationTensMillis = Number((endTime - startTime) / 100000n);
+        return durationTensMillis / 10;
+    }
+}

package/dist/cjs/index.d.ts

@@ -110,7 +110,7 @@ export * from './operation-node/operation-node-source.js';
 export * from './operation-node/order-by-node.js';
 export * from './introspection/database-introspector.js';
 export * from './util/compilable.js';
-export { AnyColumn, UnknownRow as AnyRow } from './util/type-utils.js';
+export { AnyColumn, UnknownRow, AnyQueryBuilder } from './util/type-utils.js';
 export { SelectExpression, SelectExpressionOrList, } from './parser/select-parser.js';
 export { ReferenceExpression, ReferenceExpressionOrList, } from './parser/reference-parser.js';
 export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';

package/dist/cjs/kysely.d.ts

@@ -10,6 +10,7 @@ import { DatabaseIntrospector } from './introspection/database-introspector.js';
 import { Driver, IsolationLevel } from './driver/driver.js';
 import { ParseContext } from './parser/parse-context.js';
 import { FunctionBuilder } from './query-builder/function-builder.js';
+import { LogLevel } from './util/log.js';
 /**
  * The main Kysely class.
  *
@@ -127,15 +128,20 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      */
     get fn(): FunctionBuilder<DB, keyof DB>;
     /**
-     * Starts a transaction. If the callback throws the transaction is rolled back,
-     * otherwise it's committed.
+     * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
      *
-     * @example
-     * In the example below if either query fails or `someFunction` throws, both inserts
-     * will be rolled back. Otherwise the transaction will be committed by the time the
-     * `transaction` function returns the output value. The output value of the
-     * `transaction` method is the value returned from the callback.
+     * The returned {@link TransactionBuilder} can be used to configure the transaction. The
+     * {@link TransactionBuilder.execute} method can then be called to run the transaction.
+     * {@link TransactionBuilder.execute} takes a function that is run inside the
+     * transaction. If the function throws, the transaction is rolled back. Otherwise
+     * the transaction is committed.
+     *
+     * The callback function passed to the {@link TransactionBuilder.execute | execute}
+     * method gets the transaction object as its only argument. The transaction is
+     * of type {@link Transaction} which inherits {@link Kysely}. Any query
+     * started through the transaction object is executed inside the transaction.
      *
+     * @example
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
@@ -220,8 +226,19 @@ export interface KyselyProps {
 }
 export declare function isKyselyProps(obj: unknown): obj is KyselyProps;
 export interface KyselyConfig {
-    dialect: Dialect;
-    plugins?: KyselyPlugin[];
+    readonly dialect: Dialect;
+    readonly plugins?: KyselyPlugin[];
+    /**
+     * A list of log levels to log.
+     *
+     * Currently there's only one level: `query` and it's logged using
+     * `console.log`. This will be expanded based on user request later.
+     *
+     * Log levels:
+     *
+     *  - query: Log each query's SQL and duration.
+     */
+    readonly log?: ReadonlyArray<LogLevel>;
 }
 export declare class ConnectionBuilder<DB> {
     #private;

package/dist/cjs/kysely.js

@@ -15,6 +15,7 @@ const driver_js_1 = require("./driver/driver.js");
 const prevent_await_js_1 = require("./util/prevent-await.js");
 const parse_context_js_1 = require("./parser/parse-context.js");
 const function_builder_js_1 = require("./query-builder/function-builder.js");
+const log_js_1 = require("./util/log.js");
 /**
  * The main Kysely class.
  *
@@ -60,15 +61,16 @@ class Kysely extends query_creator_js_1.QueryCreator {
     constructor(args) {
         if (isKyselyProps(args)) {
             super({ executor: args.executor, parseContext: args.parseContext });
-            this.#props = (0, object_utils_js_1.freeze)(args);
+            this.#props = (0, object_utils_js_1.freeze)({ ...args });
         }
         else {
             const dialect = args.dialect;
             const driver = dialect.createDriver();
             const compiler = dialect.createQueryCompiler();
             const adapter = dialect.createAdapter();
+            const log = new log_js_1.Log(args.log ?? []);
             const parseContext = new parse_context_js_1.DefaultParseContext(adapter);
-            const runtimeDriver = new runtime_driver_js_1.RuntimeDriver(driver);
+            const runtimeDriver = new runtime_driver_js_1.RuntimeDriver(driver, log);
             const connectionProvider = new default_connection_provider_js_1.DefaultConnectionProvider(runtimeDriver);
             const executor = new default_query_executor_js_1.DefaultQueryExecutor(compiler, connectionProvider, args.plugins ?? []);
             super({ executor, parseContext });
@@ -166,15 +168,20 @@ class Kysely extends query_creator_js_1.QueryCreator {
         return new function_builder_js_1.FunctionBuilder({ executor: this.#props.executor });
     }
     /**
-     * Starts a transaction. If the callback throws the transaction is rolled back,
-     * otherwise it's committed.
+     * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
      *
-     * @example
-     * In the example below if either query fails or `someFunction` throws, both inserts
-     * will be rolled back. Otherwise the transaction will be committed by the time the
-     * `transaction` function returns the output value. The output value of the
-     * `transaction` method is the value returned from the callback.
+     * The returned {@link TransactionBuilder} can be used to configure the transaction. The
+     * {@link TransactionBuilder.execute} method can then be called to run the transaction.
+     * {@link TransactionBuilder.execute} takes a function that is run inside the
+     * transaction. If the function throws, the transaction is rolled back. Otherwise
+     * the transaction is committed.
+     *
+     * The callback function passed to the {@link TransactionBuilder.execute | execute}
+     * method gets the transaction object as its only argument. The transaction is
+     * of type {@link Transaction} which inherits {@link Kysely}. Any query
+     * started through the transaction object is executed inside the transaction.
      *
+     * @example
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')

package/dist/cjs/migration/migration.d.ts

@@ -24,6 +24,38 @@ export declare class MigrationModule {
      *   path.join(__dirname, 'migrations')
      * )
      * ```
+     *
+     * In the next example, we use a record of migration objects instead of file folder path.
+     * The keys in the object are migration names that can be anything you want. The order of
+     * the migrations is determined based on the alphabetical order of the keys in the record.
+     * This can be useful if you are using a bundler like webpack or esbuild.
+     *
+     * @example
+     * ```ts
+     * await db.migration.migrateToLatest({
+     *   migration1: {
+     *     async up(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     },
+     *
+     *     async down(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     }
+     *   },
+     *
+     *   migration2: {
+     *     async up(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     },
+     *
+     *     async down(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     }
+     *   },
+     *
+     *  ...
+     * })
+     * ```
      */
     migrateToLatest(migrationsFolderPath: string): Promise<void>;
     migrateToLatest(allMigrations: Record<string, Migration>): Promise<void>;

package/dist/cjs/operation-node/create-schema-node.d.ts

@@ -13,5 +13,5 @@ export interface CreateSchemaNode extends OperationNode {
 export declare const CreateSchemaNode: Readonly<{
     is(node: OperationNode): node is CreateSchemaNode;
     create(schema: string, params?: CreateSchemaNodeParams | undefined): CreateSchemaNode;
-    cloneWithModifier(createSchema: CreateSchemaNode, modifier: CreateSchemaNodeModifier): CreateSchemaNode;
+    cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): CreateSchemaNode;
 }>;

package/dist/cjs/operation-node/create-schema-node.js

@@ -17,10 +17,10 @@ exports.CreateSchemaNode = (0, object_utils_js_1.freeze)({
             ...params,
         });
     },
-    cloneWithModifier(createSchema, modifier) {
+    cloneWith(createSchema, params) {
         return (0, object_utils_js_1.freeze)({
             ...createSchema,
-            modifier,
+            ...params,
         });
     },
 });

package/dist/cjs/operation-node/create-table-node.d.ts

@@ -1,6 +1,5 @@
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
-import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 export declare type CreateTableNodeModifier = 'IfNotExists';
@@ -19,8 +18,5 @@ export declare const CreateTableNode: Readonly<{
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
     cloneWithModifier(createTable: CreateTableNode, modifier: CreateTableNodeModifier): 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, constraint: ForeignKeyConstraintNode): CreateTableNode;
+    cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
 }>;

package/dist/cjs/operation-node/create-table-node.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateTableNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const check_constraint_node_js_1 = require("./check-constraint-node.js");
-const primary_constraint_node_js_1 = require("./primary-constraint-node.js");
-const unique_constraint_node_js_1 = require("./unique-constraint-node.js");
 /**
  * @internal
  */
@@ -31,34 +28,7 @@ exports.CreateTableNode = (0, object_utils_js_1.freeze)({
             modifier,
         });
     },
-    cloneWithPrimaryKeyConstraint(createTable, constraintName, columns) {
-        const constraint = primary_constraint_node_js_1.PrimaryConstraintNode.create(columns, constraintName);
-        return (0, object_utils_js_1.freeze)({
-            ...createTable,
-            constraints: createTable.constraints
-                ? (0, object_utils_js_1.freeze)([...createTable.constraints, constraint])
-                : (0, object_utils_js_1.freeze)([constraint]),
-        });
-    },
-    cloneWithUniqueConstraint(createTable, constraintName, columns) {
-        const constraint = unique_constraint_node_js_1.UniqueConstraintNode.create(columns, constraintName);
-        return (0, object_utils_js_1.freeze)({
-            ...createTable,
-            constraints: createTable.constraints
-                ? (0, object_utils_js_1.freeze)([...createTable.constraints, constraint])
-                : (0, object_utils_js_1.freeze)([constraint]),
-        });
-    },
-    cloneWithCheckConstraint(createTable, constraintName, sql) {
-        const constraint = check_constraint_node_js_1.CheckConstraintNode.create(sql, constraintName);
-        return (0, object_utils_js_1.freeze)({
-            ...createTable,
-            constraints: createTable.constraints
-                ? (0, object_utils_js_1.freeze)([...createTable.constraints, constraint])
-                : (0, object_utils_js_1.freeze)([constraint]),
-        });
-    },
-    cloneWithForeignKeyConstraint(createTable, constraint) {
+    cloneWithConstraint(createTable, constraint) {
         return (0, object_utils_js_1.freeze)({
             ...createTable,
             constraints: createTable.constraints

package/dist/cjs/operation-node/join-node.d.ts

@@ -21,5 +21,6 @@ export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
     createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, op: 'And' | 'Or', on: JoinNodeOnNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
 }>;

package/dist/cjs/operation-node/join-node.js

@@ -27,14 +27,16 @@ exports.JoinNode = (0, object_utils_js_1.freeze)({
             on,
         });
     },
-    cloneWithOn(joinNode, op, on) {
+    cloneWithOn(joinNode, on) {
         return (0, object_utils_js_1.freeze)({
             ...joinNode,
-            on: joinNode.on
-                ? op === 'And'
-                    ? and_node_js_1.AndNode.create(joinNode.on, on)
-                    : or_node_js_1.OrNode.create(joinNode.on, on)
-                : on,
+            on: joinNode.on ? and_node_js_1.AndNode.create(joinNode.on, on) : on,
+        });
+    },
+    cloneWithOrOn(joinNode, on) {
+        return (0, object_utils_js_1.freeze)({
+            ...joinNode,
+            on: joinNode.on ? or_node_js_1.OrNode.create(joinNode.on, on) : on,
         });
     },
 });

package/dist/cjs/operation-node/operation-node-source.d.ts

@@ -2,4 +2,4 @@ import { OperationNode } from './operation-node.js';
 export interface OperationNodeSource {
     toOperationNode(): OperationNode;
 }
-export declare function isOperationNodeSource(obj: any): obj is OperationNodeSource;
+export declare function isOperationNodeSource(obj: unknown): obj is OperationNodeSource;

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

@@ -57,6 +57,7 @@ import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
+import { UnionNode } from './union-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -129,6 +130,7 @@ export declare class OperationNodeTransformer {
     protected transformPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): PrimaryKeyConstraintNode;
     protected transformUniqueConstraint(node: UniqueConstraintNode): UniqueConstraintNode;
     protected transformForeignKeyConstraint(node: ForeignKeyConstraintNode): ForeignKeyConstraintNode;
+    protected transformUnion(node: UnionNode): UnionNode;
     protected transformReferences(node: ReferencesNode): ReferencesNode;
     protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
     protected transformWith(node: WithNode): WithNode;

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

@@ -92,6 +92,7 @@ class OperationNodeTransformer {
         AddConstraintNode: this.transformAddConstraint.bind(this),
         DropConstraintNode: this.transformDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
+        UnionNode: this.transformUnion.bind(this),
     };
     transformNode = (node) => {
         if (!node) {
@@ -124,6 +125,7 @@ class OperationNodeTransformer {
             offset: this.transformNode(node.offset),
             with: this.transformNode(node.with),
             having: this.transformNode(node.having),
+            union: this.transformNodeList(node.union),
         };
     }
     transformSelection(node) {
@@ -403,6 +405,13 @@ class OperationNodeTransformer {
             onUpdate: node.onUpdate,
         };
     }
+    transformUnion(node) {
+        return {
+            kind: 'UnionNode',
+            union: this.transformNode(node.union),
+            all: node.all,
+        };
+    }
     transformReferences(node) {
         return {
             kind: 'ReferencesNode',
@@ -456,11 +465,12 @@ class OperationNodeTransformer {
             kind: 'AlterTableNode',
             table: this.transformNode(node.table),
             renameTo: this.transformNode(node.renameTo),
-            renameColumn: this.transformNode(node.renameColumn),
             setSchema: this.transformNode(node.setSchema),
+            renameColumn: this.transformNode(node.renameColumn),
             addColumn: this.transformNode(node.addColumn),
             dropColumn: this.transformNode(node.dropColumn),
             alterColumn: this.transformNode(node.alterColumn),
+            modifyColumn: this.transformNode(node.modifyColumn),
             addConstraint: this.transformNode(node.addConstraint),
             dropConstraint: this.transformNode(node.dropConstraint),
         };