kysely 0.16.6 → 0.16.7

package/dist/cjs/query-builder/update-query-builder.d.ts

@@ -6,13 +6,14 @@ import { SelectExpression } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { ParseContext } from '../parser/parse-context.js';
+import { UpdateResult } from './update-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
 import { JoinInterface } from './join-interface.js';
@@ -676,24 +677,63 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
      * db.updateTable('person')
      *   .set(values)
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
+     *   .call(log)
      *   .execute()
      * ```
      */
     call<T>(func: (qb: this) => T): T;
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function updatePerson(id: number, updates: UpdateablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .updateTable('person')
+     *     .set(updates)
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `updatePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, TB, O2>): UpdateQueryBuilder<DB, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
@@ -701,6 +741,9 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): UpdateQueryBuilder<DB, TB, T>;
+    /**
+     * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, TB, O>;
     toOperationNode(): UpdateQueryNode;
     compile(): CompiledQuery;

package/dist/cjs/query-builder/update-query-builder.js

@@ -194,26 +194,72 @@ class UpdateQueryBuilder {
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
      * db.updateTable('person')
      *   .set(values)
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
+     *   .call(log)
      *   .execute()
      * ```
      */
     call(func) {
         return func(this);
     }
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function updatePerson(id: number, updates: UpdateablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .updateTable('person')
+     *     .set(updates)
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `updatePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new UpdateQueryBuilder({
+            ...this.#props,
+        });
+    }
     /**
      * Change the output type of the query.
      *
@@ -223,6 +269,9 @@ class UpdateQueryBuilder {
     castTo() {
         return new UpdateQueryBuilder(this.#props);
     }
+    /**
+     * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin) {
         return new UpdateQueryBuilder({
             ...this.#props,

package/dist/cjs/query-creator.d.ts

@@ -162,7 +162,7 @@ export declare class QueryCreator<DB> {
     /**
      * Creates a delete query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
      * a where clause for the delete operation.
      *
      * The return value of the query is an instance of {@link DeleteResult}.
@@ -182,7 +182,7 @@ export declare class QueryCreator<DB> {
     /**
      * Creates an update query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
      * a where clause for the update operation.
      *
      * See the {@link UpdateQueryBuilder.set} method for examples on how to

package/dist/cjs/query-creator.js

@@ -78,7 +78,7 @@ class QueryCreator {
     /**
      * Creates a delete query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
      * a where clause for the delete operation.
      *
      * The return value of the query is an instance of {@link DeleteResult}.
@@ -105,7 +105,7 @@ class QueryCreator {
     /**
      * Creates an update query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
      * a where clause for the update operation.
      *
      * See the {@link UpdateQueryBuilder.set} method for examples on how to

package/dist/cjs/schema/create-view-builder.js

@@ -5,7 +5,7 @@ const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const create_view_node_js_1 = require("../operation-node/create-view-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
-const immediate_value_plugin_js_1 = require("../plugin/immediate-value.ts/immediate-value-plugin.js");
+const immediate_value_plugin_js_1 = require("../plugin/immediate-value/immediate-value-plugin.js");
 class CreateViewBuilder {
     #props;
     constructor(props) {

package/dist/cjs/util/object-utils.d.ts

@@ -16,3 +16,4 @@ export declare function asArray<T>(arg: T | T[]): T[];
 export declare function asReadonlyArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
 export declare function isReadonlyArray(arg: unknown): arg is ReadonlyArray<unknown>;
 export declare function noop<T>(obj: T): T;
+export declare function compare(obj1: unknown, obj2: unknown): boolean;

package/dist/cjs/util/object-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
+exports.compare = exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
 function isEmpty(obj) {
     if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
         return obj.length === 0;
@@ -83,3 +83,52 @@ function noop(obj) {
     return obj;
 }
 exports.noop = noop;
+function compare(obj1, obj2) {
+    if (isReadonlyArray(obj1) && isReadonlyArray(obj2)) {
+        return compareArrays(obj1, obj2);
+    }
+    else if (isObject(obj1) && isObject(obj2)) {
+        return compareObjects(obj1, obj2);
+    }
+    return obj1 === obj2;
+}
+exports.compare = compare;
+function compareArrays(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; ++i) {
+        if (!compare(arr1[i], arr2[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function compareObjects(obj1, obj2) {
+    if (isBuffer(obj1) && isBuffer(obj2)) {
+        return compareBuffers(obj1, obj2);
+    }
+    else if (isDate(obj1) && isDate(obj2)) {
+        return compareDates(obj1, obj2);
+    }
+    return compareGenericObjects(obj1, obj2);
+}
+function compareBuffers(buf1, buf2) {
+    return Buffer.compare(buf1, buf2) === 0;
+}
+function compareDates(date1, date2) {
+    return date1.getTime() === date2.getTime();
+}
+function compareGenericObjects(obj1, obj2) {
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!compare(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/cjs/util/type-utils.d.ts

@@ -111,3 +111,24 @@ export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
+/**
+ * Takes all properties from T1 and merges all properties from T2
+ * that don't exist in T1 as optional properties.
+ *
+ * Example:
+ *
+ * interface Person {
+ *   name: string
+ *   age: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * type Merged = MergePartial<Person, Pet>
+ *
+ * // { name: string, age: number, species?: 'cat' | 'dog' }
+ */
+export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;

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

@@ -3,6 +3,7 @@ import { MysqlDriver } from './mysql-driver.js';
 import { MysqlQueryCompiler } from './mysql-query-compiler.js';
 import { MysqlIntrospector } from './mysql-introspector.js';
 import { MysqlAdapter } from './mysql-adapter.js';
+import { freeze } from '../../util/object-utils.js';
 /**
  * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
  *
@@ -13,7 +14,7 @@ import { MysqlAdapter } from './mysql-adapter.js';
 export class MysqlDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     createDriver() {
         return new MysqlDriver(this.#config);

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

@@ -1,13 +1,13 @@
 /// <reference types="./mysql-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { isFunction, isObject } from '../../util/object-utils.js';
+import { isFunction, isObject, freeze } from '../../util/object-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class MysqlDriver {
     #config;
     #connections = new WeakMap();
     #pool;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     async init() {
         // Import the `mysql2` module here instead at the top of the file

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

@@ -3,6 +3,7 @@ import { PostgresDriver } from './postgres-driver.js';
 import { PostgresIntrospector } from './postgres-introspector.js';
 import { PostgresQueryCompiler } from './postgres-query-compiler.js';
 import { PostgresAdapter } from './postgres-adapter.js';
+import { freeze } from '../../util/object-utils.js';
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
@@ -16,7 +17,7 @@ import { PostgresAdapter } from './postgres-adapter.js';
 export class PostgresDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     createDriver() {
         return new PostgresDriver(this.#config);

package/dist/esm/dialect/postgres/postgres-driver.js

@@ -1,13 +1,13 @@
 /// <reference types="./postgres-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { isFunction } from '../../util/object-utils.js';
+import { isFunction, freeze } from '../../util/object-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class PostgresDriver {
     #config;
     #connections = new WeakMap();
     #pool = null;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     async init() {
         // Import the `pg` module here instead at the top of the file

package/dist/esm/dialect/sqlite/sqlite-dialect.js

@@ -3,6 +3,7 @@ import { SqliteDriver } from './sqlite-driver.js';
 import { SqliteQueryCompiler } from './sqlite-query-compiler.js';
 import { SqliteIntrospector } from './sqlite-introspector.js';
 import { SqliteAdapter } from './sqlite-adapter.js';
+import { freeze } from '../../util/object-utils.js';
 /**
  * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
  *
@@ -13,7 +14,7 @@ import { SqliteAdapter } from './sqlite-adapter.js';
 export class SqliteDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     createDriver() {
         return new SqliteDriver(this.#config);

package/dist/esm/dialect/sqlite/sqlite-driver.js

@@ -1,13 +1,13 @@
 /// <reference types="./sqlite-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { isBoolean, isFunction, isNumber } from '../../util/object-utils.js';
+import { freeze, isBoolean, isFunction, isNumber, } from '../../util/object-utils.js';
 export class SqliteDriver {
     #config;
     #connectionMutex = new ConnectionMutex();
     #db;
     #connection;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     async init() {
         // Import the `better-sqlite3` module here instead at the top of the file

package/dist/esm/driver/dummy-driver.d.ts

@@ -1,5 +1,33 @@
 import { DatabaseConnection } from './database-connection.js';
 import { Driver } from './driver.js';
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter() {
+ *       return new PostgresAdapter()
+ *     },
+ *     createDriver() {
+ *       return new DummyDriver()
+ *     },
+ *     createIntrospector(db: Kysely<any>) {
+ *       return new PostgresIntrospector(db)
+ *     },
+ *     createQueryCompiler() {
+ *       return new PostgresQueryCompiler()
+ *     },
+ *   },
+ * })
+ * ```
+ */
 export declare class DummyDriver implements Driver {
     /**
      * Initializes the driver.

package/dist/esm/driver/dummy-driver.js

@@ -1,7 +1,35 @@
 /// <reference types="./dummy-driver.d.ts" />
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter() {
+ *       return new PostgresAdapter()
+ *     },
+ *     createDriver() {
+ *       return new DummyDriver()
+ *     },
+ *     createIntrospector(db: Kysely<any>) {
+ *       return new PostgresIntrospector(db)
+ *     },
+ *     createQueryCompiler() {
+ *       return new PostgresQueryCompiler()
+ *     },
+ *   },
+ * })
+ * ```
+ */
 export class DummyDriver {
-    init() {
-        throw new Error('Method not implemented.');
+    async init() {
+        // Nothing to do here.
     }
     async acquireConnection() {
         return new DummyConnection();
@@ -23,7 +51,7 @@ export class DummyDriver {
     }
 }
 class DummyConnection {
-    async executeQuery(compiledQuery) {
+    async executeQuery() {
         return {
             rows: [],
         };

package/dist/esm/index-nodeless.d.ts

@@ -59,6 +59,7 @@ export * from './query-compiler/query-compiler.js';
 export * from './migration/migrator.js';
 export * from './plugin/kysely-plugin.js';
 export * from './plugin/camel-case/camel-case-plugin.js';
+export * from './plugin/deduplicate-joins/deduplicate-joins-plugin.js';
 export * from './operation-node/add-column-node.js';
 export * from './operation-node/add-constraint-node.js';
 export * from './operation-node/alias-node.js';

package/dist/esm/index-nodeless.js

@@ -60,6 +60,7 @@ export * from './query-compiler/query-compiler.js';
 export * from './migration/migrator.js';
 export * from './plugin/kysely-plugin.js';
 export * from './plugin/camel-case/camel-case-plugin.js';
+export * from './plugin/deduplicate-joins/deduplicate-joins-plugin.js';
 export * from './operation-node/add-column-node.js';
 export * from './operation-node/add-constraint-node.js';
 export * from './operation-node/alias-node.js';

package/dist/esm/kysely.d.ts

@@ -22,22 +22,24 @@ import { DialectAdapter } from './dialect/dialect-adapter.js';
  * This example assumes your database has tables `person` and `pet`:
  *
  * ```ts
- * interface Person {
- *   id: number
+ * import { Kysely, Generated, PostgresDialect } from 'kysely'
+ *
+ * interface PersonTable {
+ *   id: Generated<number>
  *   first_name: string
  *   last_name: string
  * }
  *
- * interface Pet {
- *   id: number
+ * interface PetTable {
+ *   id: Generated<number>
  *   owner_id: number
  *   name: string
  *   species 'cat' | 'dog'
  * }
  *
  * interface Database {
- *   person: Person,
- *   pet: Pet
+ *   person: PersonTable,
+ *   pet: PetTable
  * }
  *
  * const db = new Kysely<Database>({

package/dist/esm/kysely.js

@@ -24,22 +24,24 @@ import { PRIVATE_ADAPTER } from './util/private-symbols.js';
  * This example assumes your database has tables `person` and `pet`:
  *
  * ```ts
- * interface Person {
- *   id: number
+ * import { Kysely, Generated, PostgresDialect } from 'kysely'
+ *
+ * interface PersonTable {
+ *   id: Generated<number>
  *   first_name: string
  *   last_name: string
  * }
  *
- * interface Pet {
- *   id: number
+ * interface PetTable {
+ *   id: Generated<number>
  *   owner_id: number
  *   name: string
  *   species 'cat' | 'dog'
  * }
  *
  * interface Database {
- *   person: Person,
- *   pet: Pet
+ *   person: PersonTable,
+ *   pet: PetTable
  * }
  *
  * const db = new Kysely<Database>({

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-plugin.d.ts

@@ -0,0 +1,48 @@
+import { QueryResult } from '../../driver/database-connection.js';
+import { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import { UnknownRow } from '../../util/type-utils.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+/**
+ * Plugin that removes duplicate joins from queries.
+ *
+ * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
+ */
+export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
+    #private;
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * const plugin = {
+     *   data: new WeakMap<QueryId, SomeData>(),
+     *
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     this.data.set(args.queryId, something)
+     *     return args.node
+     *   },
+     *
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
+     *     const data = this.data.get(args.queryId)
+     *     return args.result
+     *   }
+     * }
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-plugin.js

@@ -0,0 +1,16 @@
+/// <reference types="./deduplicate-joins-plugin.d.ts" />
+import { DeduplicateJoinsTransformer } from './deduplicate-joins-transformer.js';
+/**
+ * Plugin that removes duplicate joins from queries.
+ *
+ * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
+ */
+export class DeduplicateJoinsPlugin {
+    #transformer = new DeduplicateJoinsTransformer();
+    transformQuery(args) {
+        return this.#transformer.transformNode(args.node);
+    }
+    transformResult(args) {
+        return Promise.resolve(args.result);
+    }
+}