KyselyPlugin Interface

interface KyselyPlugin {
  transformQuery(args: PluginTransformQueryArgs): RootOperationNode
  transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>
}

transformQuery(args: PluginTransformQueryArgs): RootOperationNode

import { OperationNodeTransformer, KyselyPlugin } from 'kysely'

class MyTransformer extends OperationNodeTransformer {
  // Override specific transformation methods
}

class MyPlugin implements KyselyPlugin {
  #transformer = new MyTransformer()

  transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    return this.#transformer.transformNode(args.node, args.queryId)
  }
}

transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>

async transformResult(
  args: PluginTransformResultArgs
): Promise<QueryResult<UnknownRow>> {
  if (args.result.rows && Array.isArray(args.result.rows)) {
    return {
      ...args.result,
      rows: args.result.rows.map(row => transformRow(row))
    }
  }
  
  return args.result
}

import type {
  KyselyPlugin,
  QueryResult,
  RootOperationNode,
  UnknownRow
} from 'kysely'

interface MyData {
  // Your data structure
}

const data = new WeakMap<any, MyData>()

const plugin = {
  transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    const something: MyData = {
      // Collect data during query transformation
    }

    data.set(args.queryId, something)
    return args.node
  },

  async transformResult(
    args: PluginTransformResultArgs
  ): Promise<QueryResult<UnknownRow>> {
    const something = data.get(args.queryId)
    // Use the data to transform results
    return args.result
  }
} satisfies KyselyPlugin

import { Kysely } from 'kysely'

const db = new Kysely<Database>({
  dialect,
  plugins: [new MyPlugin()]
})

const result = await db
  .selectFrom('person')
  .selectAll()
  .withPlugin(new MyPlugin())
  .execute()