kysely
    Preparing search index...

    Class ParseJSONResultsPlugin

    Parses JSON strings in query results into JSON objects.

    This plugin can be useful with dialects that don't automatically parse JSON into objects and arrays but return JSON strings instead.

    To apply this plugin globally, pass an instance of it to the plugins option when creating a new Kysely instance:

    import * as Sqlite from 'better-sqlite3'
    import { Kysely, ParseJSONResultsPlugin, SqliteDialect } from 'kysely'
    import type { Database } from 'type-editor' // imaginary module

    const db = new Kysely<Database>({
      dialect: new SqliteDialect({
        database: new Sqlite(':memory:'),
      }),
      plugins: [new ParseJSONResultsPlugin()],
    })

    To apply this plugin to a single query:

    import { ParseJSONResultsPlugin } from 'kysely'
    import { jsonArrayFrom } from 'kysely/helpers/sqlite'

    const result = await db
      .selectFrom('person')
      .select((eb) => [
        'id',
        'first_name',
        'last_name',
        jsonArrayFrom(
          eb.selectFrom('pet')
            .whereRef('owner_id', '=', 'person.id')
            .select(['name', 'species'])
        ).as('pets')
      ])
      .withPlugin(new ParseJSONResultsPlugin())
      .execute()

    Implements

    Index

    Constructors

    constructor

    Properties

    opt

    Methods

    transformQuery transformResult

    Constructors

    Properties

    opt: ParseJSONResultsPluginOptions = {}

    Methods

    • This is called for each query before it is executed. You can modify the query by transforming its OperationNode tree provided in args.node and returning the transformed tree. You'd usually want to use an OperationNodeTransformer for this.

      If you need to pass some query-related data between this method and transformResult you can use a WeakMap with args.queryId as the key:

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

      interface MyData {
        // ...
      }
      const data = new WeakMap<any, MyData>()

      const plugin = {
        transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
          const something: MyData = {}

          // ...

          data.set(args.queryId, something)

          // ...

          return args.node
        },

        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 is not always matched by a call to transformResult which would leave orphaned items in the map and cause a memory leak.

      Parameters

      Returns RootOperationNode

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods