kysely 0.27.4 → 0.27.5

package/dist/cjs/migration/migrator.js

@@ -20,16 +20,29 @@ exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true }
  * other way.
  *
  * ```ts
- * import { promises as fs } from 'fs'
- * import path from 'path'
+ * import { promises as fs } from 'node:fs'
+ * import path from 'node:path'
+ * import * as Sqlite from 'better-sqlite3'
+ * import {
+ *   FileMigrationProvider,
+ *   Kysely,
+ *   Migrator,
+ *   SqliteDialect
+ * } from 'kysely'
+ *
+ * const db = new Kysely<any>({
+ *   dialect: new SqliteDialect({
+ *     database: Sqlite(':memory:')
+ *   })
+ * })
  *
  * const migrator = new Migrator({
  *   db,
  *   provider: new FileMigrationProvider({
  *     fs,
- *     path,
  *     // Path to the folder that contains all your migrations.
- *     migrationFolder: 'some/path/to/migrations'
+ *     migrationFolder: 'some/path/to/migrations',
+ *     path,
  *   })
  * })
  * ```
@@ -78,19 +91,18 @@ class Migrator {
      * ### Examples
      *
      * ```ts
-     * const db = new Kysely<Database>({
-     *   dialect: new PostgresDialect({
-     *     host: 'localhost',
-     *     database: 'kysely_test',
-     *   }),
-     * })
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import * as Sqlite from 'better-sqlite3'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
      *
      * const migrator = new Migrator({
      *   db,
-     *   provider: new FileMigrationProvider(
-     *     // Path to the folder that contains all your migrations.
-     *     'some/path/to/migrations'
-     *   )
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
      * })
      *
      * const { error, results } = await migrator.migrateToLatest()
@@ -123,6 +135,20 @@ class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateTo('some_migration')
      * ```
      *
@@ -132,6 +158,20 @@ class Migrator {
      * you can use a special constant `NO_MIGRATIONS`:
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator, NO_MIGRATIONS } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateTo(NO_MIGRATIONS)
      * ```
      */
@@ -170,6 +210,20 @@ class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateUp()
      * ```
      */
@@ -187,6 +241,20 @@ class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateDown()
      * ```
      */

package/dist/cjs/operation-node/aggregate-function-node.d.ts

@@ -1,11 +1,14 @@
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
 import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: string;
     readonly aggregated: readonly OperationNode[];
     readonly distinct?: boolean;
+    readonly orderBy?: OrderByNode;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
 }
@@ -16,6 +19,7 @@ export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
     create(aggregateFunction: string, aggregated?: readonly OperationNode[]): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;

package/dist/cjs/operation-node/aggregate-function-node.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateFunctionNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const where_node_js_1 = require("./where-node.js");
+const order_by_node_js_1 = require("./order-by-node.js");
 /**
  * @internal
  */
@@ -23,6 +24,14 @@ exports.AggregateFunctionNode = (0, object_utils_js_1.freeze)({
             distinct: true,
         });
     },
+    cloneWithOrderBy(aggregateFunctionNode, orderItems) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            orderBy: aggregateFunctionNode.orderBy
+                ? order_by_node_js_1.OrderByNode.cloneWithItems(aggregateFunctionNode.orderBy, orderItems)
+                : order_by_node_js_1.OrderByNode.create(orderItems),
+        });
+    },
     cloneWithFilter(aggregateFunctionNode, filter) {
         return (0, object_utils_js_1.freeze)({
             ...aggregateFunctionNode,

package/dist/cjs/operation-node/data-type-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["varchar", "char", "text", "integer", "int2", "int4", "int8", "smallint", "bigint", "boolean", "real", "double precision", "float4", "float8", "decimal", "numeric", "binary", "bytea", "date", "datetime", "time", "timetz", "timestamp", "timestamptz", "serial", "bigserial", "uuid", "json", "jsonb", "blob", "varbinary"];
+declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["varchar", "char", "text", "integer", "int2", "int4", "int8", "smallint", "bigint", "boolean", "real", "double precision", "float4", "float8", "decimal", "numeric", "binary", "bytea", "date", "datetime", "time", "timetz", "timestamp", "timestamptz", "serial", "bigserial", "uuid", "json", "jsonb", "blob", "varbinary", "int4range", "int4multirange", "int8range", "int8multirange", "numrange", "nummultirange", "tsrange", "tsmultirange", "tstzrange", "tstzmultirange", "daterange", "datemultirange"];
 type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number];
 export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`;
 export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;

package/dist/cjs/operation-node/data-type-node.js

@@ -35,6 +35,18 @@ const SIMPLE_COLUMN_DATA_TYPES = [
     'jsonb',
     'blob',
     'varbinary',
+    'int4range',
+    'int4multirange',
+    'int8range',
+    'int8multirange',
+    'numrange',
+    'nummultirange',
+    'tsrange',
+    'tsmultirange',
+    'tstzrange',
+    'tstzmultirange',
+    'daterange',
+    'datemultirange',
 ];
 const COLUMN_DATA_TYPE_REGEX = [
     /^varchar\(\d+\)$/,

package/dist/cjs/operation-node/delete-query-node.d.ts

@@ -22,6 +22,7 @@ export interface DeleteQueryNode extends OperationNode {
     readonly orderBy?: OrderByNode;
     readonly limit?: LimitNode;
     readonly explain?: ExplainNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly top?: TopNode;
     readonly output?: OutputNode;
 }

package/dist/cjs/operation-node/insert-query-node.d.ts

@@ -22,6 +22,7 @@ export interface InsertQueryNode extends OperationNode {
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
     readonly defaultValues?: boolean;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly top?: TopNode;
     readonly output?: OutputNode;
 }

package/dist/cjs/operation-node/merge-query-node.d.ts

@@ -14,6 +14,7 @@ export interface MergeQueryNode extends OperationNode {
     readonly with?: WithNode;
     readonly top?: TopNode;
     readonly output?: OutputNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal

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

@@ -106,9 +106,12 @@ import { OutputNode } from './output-node.js';
  * snake_case, you'd do something like this:
  *
  * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
  * class CamelCaseTransformer extends OperationNodeTransformer {
- *   transformIdentifier(node: IdentifierNode): IdentifierNode {
- *     node = super.transformIdentifier(node),
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
  *
  *     return {
  *       ...node,
@@ -118,7 +121,10 @@ import { OutputNode } from './output-node.js';
  * }
  *
  * const transformer = new CamelCaseTransformer()
- * const tree = transformer.transformNode(tree)
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
  * ```
  */
 export declare class OperationNodeTransformer {

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

@@ -17,9 +17,12 @@ const require_all_props_js_1 = require("../util/require-all-props.js");
  * snake_case, you'd do something like this:
  *
  * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
  * class CamelCaseTransformer extends OperationNodeTransformer {
- *   transformIdentifier(node: IdentifierNode): IdentifierNode {
- *     node = super.transformIdentifier(node),
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
  *
  *     return {
  *       ...node,
@@ -29,7 +32,10 @@ const require_all_props_js_1 = require("../util/require-all-props.js");
  * }
  *
  * const transformer = new CamelCaseTransformer()
- * const tree = transformer.transformNode(tree)
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
  * ```
  */
 class OperationNodeTransformer {
@@ -263,6 +269,7 @@ class OperationNodeTransformer {
             returning: this.transformNode(node.returning),
             onConflict: this.transformNode(node.onConflict),
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             ignore: node.ignore,
             replace: node.replace,
@@ -286,6 +293,7 @@ class OperationNodeTransformer {
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
@@ -383,6 +391,7 @@ class OperationNodeTransformer {
             where: this.transformNode(node.where),
             updates: this.transformNodeList(node.updates),
             returning: this.transformNode(node.returning),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             explain: this.transformNode(node.explain),
             limit: this.transformNode(node.limit),
@@ -689,6 +698,7 @@ class OperationNodeTransformer {
             kind: 'AggregateFunctionNode',
             aggregated: this.transformNodeList(node.aggregated),
             distinct: node.distinct,
+            orderBy: this.transformNode(node.orderBy),
             filter: this.transformNode(node.filter),
             func: node.func,
             over: this.transformNode(node.over),
@@ -799,6 +809,7 @@ class OperationNodeTransformer {
             whens: this.transformNodeList(node.whens),
             with: this.transformNode(node.with),
             top: this.transformNode(node.top),
+            endModifiers: this.transformNodeList(node.endModifiers),
             output: this.transformNode(node.output),
         });
     }

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

@@ -32,11 +32,15 @@ type HasTop = {
 type HasOutput = {
     output?: OutputNode;
 };
+type HasEndModifiers = {
+    endModifiers?: ReadonlyArray<OperationNode>;
+};
 /**
  * @internal
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
+    cloneWithEndModifier<T extends HasEndModifiers>(node: T, modifier: OperationNode): T;
     cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
     cloneWithJoin<T extends HasJoins>(node: T, join: JoinNode): T;
     cloneWithReturning<T extends HasReturning>(node: T, selections: ReadonlyArray<SelectionNode>): T;

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

@@ -22,6 +22,14 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
             delete_query_node_js_1.DeleteQueryNode.is(node) ||
             merge_query_node_js_1.MergeQueryNode.is(node));
     },
+    cloneWithEndModifier(node, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            endModifiers: node.endModifiers
+                ? (0, object_utils_js_1.freeze)([...node.endModifiers, modifier])
+                : (0, object_utils_js_1.freeze)([modifier]),
+        });
+    },
     cloneWithWhere(node, operation) {
         return (0, object_utils_js_1.freeze)({
             ...node,

package/dist/cjs/operation-node/select-query-node.d.ts

@@ -46,7 +46,6 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
     cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
-    cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithOrderByItems(selectNode: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;

package/dist/cjs/operation-node/select-query-node.js

@@ -50,14 +50,6 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)([modifier]),
         });
     },
-    cloneWithEndModifier(select, modifier) {
-        return (0, object_utils_js_1.freeze)({
-            ...select,
-            endModifiers: select.endModifiers
-                ? (0, object_utils_js_1.freeze)([...select.endModifiers, modifier])
-                : (0, object_utils_js_1.freeze)([modifier]),
-        });
-    },
     cloneWithOrderByItems(selectNode, items) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,

package/dist/cjs/operation-node/update-query-node.d.ts

@@ -22,6 +22,7 @@ export interface UpdateQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
     readonly explain?: ExplainNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly limit?: LimitNode;
     readonly top?: TopNode;
     readonly output?: OutputNode;

package/dist/cjs/plugin/camel-case/camel-case-plugin.d.ts

@@ -42,38 +42,39 @@ export interface CamelCasePluginOptions {
  * using `CamelCasePlugin` we would setup Kysely like this:
  *
  * ```ts
- * interface Person {
- *   firstName: string
- *   lastName: string
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
  *
- * interface Database {
- *   personTable: Person
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
  * }
  *
- * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     database: 'kysely_test',
- *     host: 'localhost',
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   }),
- *   plugins: [
- *     new CamelCasePlugin()
- *   ]
+ *   plugins: [new CamelCasePlugin()],
  * })
  *
- * const person = await db.selectFrom('personTable')
+ * const person = await db.selectFrom('userMetadata')
  *   .where('firstName', '=', 'Arnold')
  *   .select(['firstName', 'lastName'])
  *   .executeTakeFirst()
  *
- * // generated sql:
- * // select first_name, last_name from person_table where first_name = $1
- *
  * if (person) {
  *   console.log(person.firstName)
  * }
  * ```
  *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
  * As you can see from the example, __everything__ needs to be defined
  * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
@@ -88,11 +89,15 @@ export interface CamelCasePluginOptions {
  * ```ts
  * class MyCamelCasePlugin extends CamelCasePlugin {
  *   protected override snakeCase(str: string): string {
- *     return mySnakeCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  *
  *   protected override camelCase(str: string): string {
- *     return myCamelCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  * }
  * ```
@@ -111,19 +116,41 @@ export declare class CamelCasePlugin implements KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`

package/dist/cjs/plugin/camel-case/camel-case-plugin.js

@@ -13,38 +13,39 @@ const camel_case_js_1 = require("./camel-case.js");
  * using `CamelCasePlugin` we would setup Kysely like this:
  *
  * ```ts
- * interface Person {
- *   firstName: string
- *   lastName: string
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
  *
- * interface Database {
- *   personTable: Person
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
  * }
  *
- * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     database: 'kysely_test',
- *     host: 'localhost',
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   }),
- *   plugins: [
- *     new CamelCasePlugin()
- *   ]
+ *   plugins: [new CamelCasePlugin()],
  * })
  *
- * const person = await db.selectFrom('personTable')
+ * const person = await db.selectFrom('userMetadata')
  *   .where('firstName', '=', 'Arnold')
  *   .select(['firstName', 'lastName'])
  *   .executeTakeFirst()
  *
- * // generated sql:
- * // select first_name, last_name from person_table where first_name = $1
- *
  * if (person) {
  *   console.log(person.firstName)
  * }
  * ```
  *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
  * As you can see from the example, __everything__ needs to be defined
  * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
@@ -59,11 +60,15 @@ const camel_case_js_1 = require("./camel-case.js");
  * ```ts
  * class MyCamelCasePlugin extends CamelCasePlugin {
  *   protected override snakeCase(str: string): string {
- *     return mySnakeCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  *
  *   protected override camelCase(str: string): string {
- *     return myCamelCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  * }
  * ```

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

@@ -5,7 +5,7 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
 /**
  * Plugin that removes duplicate joins from queries.
  *
- * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/deduplicate-joins.md)
+ * See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0008-deduplicate-joins.md)
  */
 export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
     #private;
@@ -19,19 +19,41 @@ export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`