@pikku/kysely 0.13.24 → 0.13.27

package/src/schema/secret.schema.ts

@@ -1,49 +0,0 @@
-import { sql } from 'kysely'
-import type { PikkuSchema } from './pikku-schema.types.js'
-
-/**
- * Encrypted secrets and their audit trail.
- *
- * The audit table is declared unconditionally, where `init()` created it only
- * when the service was constructed with auditing on. A migration cannot depend
- * on runtime configuration, and the asymmetry favours declaring it: an unused
- * table costs nothing, while turning auditing on against a database that never
- * got the table fails on the first write.
- */
-export const secretSchema: PikkuSchema = {
-  name: 'secret',
-  statements: [
-    (db) =>
-      db.schema
-        .createTable('secrets')
-        .addColumn('key', 'varchar(255)', (col) => col.primaryKey())
-        .addColumn('ciphertext', 'text', (col) => col.notNull())
-        .addColumn('wrappedDek', 'text', (col) => col.notNull())
-        .addColumn('keyVersion', 'integer', (col) => col.notNull())
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addColumn('updatedAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        ),
-
-    (db) =>
-      db.schema
-        .createTable('secretKekSalts')
-        .addColumn('keyVersion', 'integer', (col) => col.primaryKey())
-        .addColumn('salt', 'varchar(64)', (col) => col.notNull())
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        ),
-
-    (db) =>
-      db.schema
-        .createTable('secretsAudit')
-        .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-        .addColumn('secretKey', 'varchar(255)', (col) => col.notNull())
-        .addColumn('action', 'varchar(20)', (col) => col.notNull())
-        .addColumn('performedAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        ),
-  ],
-}

package/src/schema/session.schema.ts

@@ -1,20 +0,0 @@
-import { sql } from 'kysely'
-import type { PikkuSchema } from './pikku-schema.types.js'
-
-/** Server-side session storage. */
-export const sessionSchema: PikkuSchema = {
-  name: 'session',
-  statements: [
-    (db) =>
-      db.schema
-        .createTable('pikkuUserSessions')
-        .addColumn('pikkuUserId', 'text', (col) => col.primaryKey())
-        .addColumn('session', 'text', (col) => col.notNull())
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addColumn('updatedAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        ),
-  ],
-}

package/src/schema/virtual-user-schedule.schema.ts

@@ -1,48 +0,0 @@
-import type { PikkuSchema } from './pikku-schema.types.js'
-
-/**
- * The `virtualUserSchedule` table {@link KyselyVirtualUserScheduleStore} writes
- * to: one row per persona that keeps using the app on its own.
- *
- * Its own schema rather than a third table in {@link virtualUserSchema}, and
- * owned by its own store: recording what a persona did and deciding that it
- * keeps going on its own are separate opt-ins, and a project that only wants
- * the first should not be handed a cadence table it never writes to.
- *
- * `persona` is the primary key: a persona has one cadence, and a second row for
- * the same one would mean two copies of the same user acting at once — not a
- * heavier test, a different and unreproducible one.
- */
-export const virtualUserScheduleSchema: PikkuSchema = {
-  name: 'virtual-user-schedule',
-  ownedBy: ['virtualUserScheduleStore'],
-  statements: [
-    (db) =>
-      db.schema
-        .createTable('virtualUserSchedule')
-        .addColumn('persona', 'varchar(255)', (col) => col.primaryKey())
-        // 0 or 1 rather than a boolean, matching the run tables: a bare sqlite
-        // driver cannot bind one, and `SerializePlugin` is not installed
-        // everywhere. Off by default, so creating the table spends nothing.
-        .addColumn('enabled', 'integer', (col) => col.defaultTo(0).notNull())
-        .addColumn('disposition', 'varchar(50)', (col) => col.notNull())
-        .addColumn('goals', 'text', (col) => col.defaultTo('[]').notNull())
-        .addColumn('budget', 'text')
-        // The gap to the next run is drawn between these rather than fixed, so
-        // the persona does not keep an appointment.
-        .addColumn('minIntervalMs', 'bigint', (col) => col.notNull())
-        .addColumn('maxIntervalMs', 'bigint', (col) => col.notNull())
-        // The entire schedule. Written before a run is dispatched, so a tick
-        // that dies halfway cannot leave the row due for the next one.
-        .addColumn('nextRunAt', 'timestamp', (col) => col.notNull())
-        .addColumn('lastRunId', 'varchar(36)')
-        .addColumn('lastRunAt', 'timestamp'),
-
-    // The only read that matters at speed: which rows are due, on every tick.
-    (db) =>
-      db.schema
-        .createIndex('idx_virtual_user_schedule_due')
-        .on('virtualUserSchedule')
-        .columns(['enabled', 'nextRunAt']),
-  ],
-}

package/src/schema/virtual-user.schema.ts

@@ -1,106 +0,0 @@
-import { sql } from 'kysely'
-import type { PikkuSchema } from './pikku-schema.types.js'
-
-/**
- * The `virtualUserRun` and `virtualUserRunStep` tables
- * {@link KyselyVirtualUserRunStore} writes to.
- *
- * Deliberately not in `pikkuSchemas`: the runtime never needs this table, only
- * a project that runs virtual users does, and creating it for everyone would
- * put an empty table in every database. `KyselyVirtualUserRunStore.init()`
- * applies it, so it arrives exactly when the thing that fills it does.
- *
- * `persona` is text rather than a foreign key: personas are declared in code
- * with `definePersonas()`, not rows, and a run has to outlive the deletion of
- * the persona it ran as.
- *
- * The JSON columns are text on every engine, like the audit table's, because
- * the store serialises them itself — a project on SQLite and one on Postgres
- * then hold the same bytes, and comparing this week's findings against last
- * week's does not depend on which database they were found in.
- */
-export const virtualUserSchema: PikkuSchema = {
-  name: 'virtual-user',
-  ownedBy: ['virtualUserRunStore'],
-  statements: [
-    (db) =>
-      db.schema
-        .createTable('virtualUserRun')
-        .addColumn('runId', 'varchar(36)', (col) => col.primaryKey())
-        .addColumn('persona', 'varchar(255)', (col) => col.notNull())
-        .addColumn('disposition', 'varchar(50)', (col) => col.notNull())
-        .addColumn('seed', 'bigint', (col) => col.notNull())
-        // running | completed | failed. Not derived from `finishedAt` being
-        // null: a crashed run has no finish time either, and "crashed" and
-        // "still going" are not the same answer.
-        .addColumn('status', 'varchar(50)', (col) =>
-          col.defaultTo('running').notNull()
-        )
-        .addColumn('goals', 'text', (col) => col.defaultTo('[]').notNull())
-        .addColumn('memory', 'text', (col) => col.defaultTo('{}').notNull())
-        .addColumn('findings', 'text', (col) => col.defaultTo('[]').notNull())
-        // What the user set out to do and how far each one got. On the run row
-        // rather than beside the steps: there are a handful of them, and every
-        // read of the run wants them.
-        .addColumn('intents', 'text', (col) => col.defaultTo('[]').notNull())
-        // Counts the engine kept: steps, calls, mutations, tokens, elapsed.
-        .addColumn('tally', 'text')
-        .addColumn('stoppedBy', 'varchar(255)')
-        // Why the run itself failed, as opposed to what it found.
-        .addColumn('error', 'text')
-        .addColumn('startedBy', 'varchar(255)')
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addColumn('finishedAt', 'timestamp'),
-
-    // The two reads: the run list newest-first, and one persona's history when
-    // a finding needs comparing against what that persona found before.
-    (db) =>
-      db.schema
-        .createIndex('idx_virtual_user_run_created')
-        .on('virtualUserRun')
-        .column('createdAt'),
-
-    (db) =>
-      db.schema
-        .createIndex('idx_virtual_user_run_persona')
-        .on('virtualUserRun')
-        .columns(['persona', 'createdAt']),
-
-    // One row per turn, kept out of `virtualUserRun` so that listing runs does
-    // not drag a budget's worth of transcript along with it. No foreign key
-    // onto the run for the same reason `persona` is not one: this table is
-    // created by the store at boot on whatever engine the project uses, and a
-    // cascade that half the engines enforce differently is worse than the read
-    // rule that a step with no run is orphaned.
-    (db) =>
-      db.schema
-        .createTable('virtualUserRunStep')
-        .addColumn('runId', 'varchar(36)', (col) => col.notNull())
-        // The engine's own step number, which is what the intent records point
-        // at — not a surrogate key, so a transcript reads the same after paging.
-        // Spelled `stepIndex` because `index` is a reserved word in mysql.
-        .addColumn('stepIndex', 'integer', (col) => col.notNull())
-        .addColumn('intentId', 'varchar(255)')
-        // The action as the engine scheduled it, including the `invalid` shape
-        // for a turn the model got wrong — that turn is the interesting one.
-        .addColumn('action', 'text', (col) => col.notNull())
-        .addColumn('status', 'integer')
-        // 0 or 1 rather than a boolean, because a bare sqlite driver cannot
-        // bind one at all and `SerializePlugin` is not installed everywhere.
-        .addColumn('ok', 'integer')
-        // Already truncated by the engine, and stored JSON-encoded rather than
-        // raw: a truncated API response usually starts with a brace, which
-        // `SerializePlugin` would read back as an object rather than the string
-        // the engine actually saw.
-        .addColumn('response', 'text')
-        .addColumn('findingKinds', 'text')
-        .addColumn('tokensIn', 'integer', (col) => col.defaultTo(0).notNull())
-        .addColumn('tokensOut', 'integer', (col) => col.defaultTo(0).notNull())
-        .addPrimaryKeyConstraint('pk_virtual_user_run_step', [
-          'runId',
-          'stepIndex',
-        ]),
-  ],
-}

package/src/schema/webhook.schema.ts

@@ -1,58 +0,0 @@
-import { sql } from 'kysely'
-import type { PikkuSchema } from './pikku-schema.types.js'
-
-/** Webhook deliveries and one row per delivery attempt. */
-export const webhookSchema: PikkuSchema = {
-  name: 'webhook',
-  ownedBy: ['webhookService'],
-  statements: [
-    (db) =>
-      db.schema
-        .createTable('webhookDelivery')
-        .addColumn('deliveryId', 'text', (col) => col.primaryKey())
-        .addColumn('organizationId', 'text')
-        .addColumn('url', 'text', (col) => col.notNull())
-        .addColumn('event', 'text')
-        .addColumn('status', 'text', (col) =>
-          col.defaultTo('pending').notNull()
-        )
-        .addColumn('attempts', 'integer', (col) => col.defaultTo(0).notNull())
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addColumn('updatedAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addColumn('deliveredAt', 'timestamp'),
-
-    (db) =>
-      db.schema
-        .createTable('webhookDeliveryAttempt')
-        .addColumn('attemptId', 'text', (col) => col.primaryKey())
-        .addColumn('deliveryId', 'text', (col) =>
-          col
-            .notNull()
-            .references('webhookDelivery.deliveryId')
-            .onDelete('cascade')
-        )
-        .addColumn('attemptNumber', 'integer', (col) => col.notNull())
-        .addColumn('statusCode', 'integer')
-        .addColumn('responseBody', 'text')
-        .addColumn('error', 'text')
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        ),
-
-    (db) =>
-      db.schema
-        .createIndex('idx_webhook_delivery_org')
-        .on('webhookDelivery')
-        .column('organizationId'),
-
-    (db) =>
-      db.schema
-        .createIndex('idx_webhook_delivery_attempt_delivery')
-        .on('webhookDeliveryAttempt')
-        .column('deliveryId'),
-  ],
-}

package/src/schema/workflow.schema.ts

@@ -1,150 +0,0 @@
-import { sql } from 'kysely'
-import type { PikkuSchema } from './pikku-schema.types.js'
-
-/**
- * Workflow runs, their steps, per-step history and the versioned graphs.
- *
- * Two things from the boot-time DDL are deliberately not carried over. The
- * primary keys had `defaultTo(sql.raw("'" + crypto.randomUUID() + "'"))`, which
- * evaluates once while the statement is built — every row would have taken the
- * same default, so it was never a generator; the services supply the id. And
- * `workflowStep.fromStepName`, `workflowStep.currentAttempt` and
- * `workflowStepHistory.attempt` were each backfilled by an
- * `alterTable(...).catch(() => {})` bolted on after the fact, which is the job a
- * migration does — they are declared here and nowhere else.
- *
- * `KyselyWorkflowMirror` created these same four tables separately. There is one
- * declaration now, and both services read it.
- */
-export const workflowSchema: PikkuSchema = {
-  name: 'workflow',
-  ownedBy: ['workflowService', 'workflowRunService'],
-  statements: [
-    (db) =>
-      db.schema
-        .createTable('workflowRuns')
-        .addColumn('workflowRunId', 'text', (col) => col.primaryKey())
-        .addColumn('workflow', 'text', (col) => col.notNull())
-        .addColumn('status', 'text', (col) => col.notNull())
-        .addColumn('input', 'text', (col) => col.notNull())
-        .addColumn('output', 'text')
-        .addColumn('error', 'text')
-        .addColumn('state', 'text', (col) => col.defaultTo('{}'))
-        .addColumn('inline', 'boolean', (col) => col.defaultTo(false))
-        .addColumn('graphHash', 'text')
-        .addColumn('deterministic', 'boolean', (col) => col.defaultTo(false))
-        .addColumn('plannedSteps', 'text')
-        .addColumn('wire', 'text')
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addColumn('updatedAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        ),
-
-    (db) =>
-      db.schema
-        .createTable('workflowStep')
-        .addColumn('workflowStepId', 'text', (col) => col.primaryKey())
-        .addColumn('workflowRunId', 'text', (col) =>
-          col
-            .notNull()
-            .references('workflowRuns.workflowRunId')
-            .onDelete('cascade')
-        )
-        .addColumn('stepName', 'text', (col) => col.notNull())
-        .addColumn('rpcName', 'text')
-        .addColumn('data', 'text')
-        .addColumn('status', 'text', (col) =>
-          col.notNull().defaultTo('pending')
-        )
-        .addColumn('result', 'text')
-        .addColumn('error', 'text')
-        .addColumn('childRunId', 'text')
-        .addColumn('branchTaken', 'text')
-        .addColumn('retries', 'integer')
-        .addColumn('retryDelay', 'text')
-        .addColumn('fromStepName', 'text')
-        .addColumn('currentAttempt', 'integer')
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addColumn('updatedAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addUniqueConstraint('workflow_step_run_name_unique', [
-          'workflowRunId',
-          'stepName',
-        ]),
-
-    (db) =>
-      db.schema
-        .createTable('workflowStepHistory')
-        .addColumn('historyId', 'text', (col) => col.primaryKey())
-        .addColumn('workflowStepId', 'text', (col) =>
-          col
-            .notNull()
-            .references('workflowStep.workflowStepId')
-            .onDelete('cascade')
-        )
-        .addColumn('status', 'text', (col) => col.notNull())
-        .addColumn('result', 'text')
-        .addColumn('error', 'text')
-        .addColumn('attempt', 'integer')
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addColumn('runningAt', 'timestamp')
-        .addColumn('scheduledAt', 'timestamp')
-        .addColumn('succeededAt', 'timestamp')
-        .addColumn('failedAt', 'timestamp'),
-
-    (db) =>
-      db.schema
-        .createTable('workflowVersions')
-        .addColumn('workflowName', 'text', (col) => col.notNull())
-        .addColumn('graphHash', 'text', (col) => col.notNull())
-        .addColumn('graph', 'text', (col) => col.notNull())
-        .addColumn('source', 'text', (col) => col.notNull())
-        .addColumn('status', 'text', (col) => col.notNull().defaultTo('active'))
-        .addColumn('createdAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addPrimaryKeyConstraint('workflow_versions_pk', [
-          'workflowName',
-          'graphHash',
-        ]),
-
-    // The indexes trail the tables so that a table is never indexed before it
-    // exists, whatever order the declarations are read in.
-    (db) =>
-      db.schema
-        .createIndex('idx_workflow_runs_status_created')
-        .on('workflowRuns')
-        .columns(['status', 'createdAt']),
-
-    (db) =>
-      db.schema
-        .createIndex('idx_workflow_runs_workflow_created')
-        .on('workflowRuns')
-        .columns(['workflow', 'createdAt']),
-
-    (db) =>
-      db.schema
-        .createIndex('idx_workflow_step_run_status')
-        .on('workflowStep')
-        .columns(['workflowRunId', 'status']),
-
-    (db) =>
-      db.schema
-        .createIndex('idx_workflow_step_history_step')
-        .on('workflowStepHistory')
-        .columns(['workflowStepId', 'createdAt']),
-
-    (db) =>
-      db.schema
-        .createIndex('idx_workflow_versions_source_status')
-        .on('workflowVersions')
-        .columns(['source', 'status']),
-  ],
-}

package/src/serialize-plugin.ts

@@ -1,233 +0,0 @@
-/**
- * Serialize / deserialize plugin for Kysely.
- *
- * Adapted from `kysely-plugin-serialize` (MIT, by subframe7536 —
- * https://github.com/subframe7536/kysely-plugin-serialize), which is
- * unmaintained and ships no `exports` map, so modern Node16/ESM resolution
- * falls back to its CommonJS build and cannot import ESM-only kysely (>= 0.29).
- * Maintained here directly as part of @pikku/kysely so we publish it ourselves.
- *
- * Serializes object/array/Date/boolean parameters to strings on the way into
- * SQLite-style dialects, and deserializes them back on the way out.
- */
-import {
-  OperationNodeTransformer,
-  type ColumnUpdateNode,
-  type KyselyPlugin,
-  type PluginTransformQueryArgs,
-  type PluginTransformResultArgs,
-  type PrimitiveValueListNode,
-  type QueryId,
-  type QueryResult,
-  type RootOperationNode,
-  type UnknownRow,
-  type ValueNode,
-} from 'kysely'
-
-export type Serializer = (parameter: unknown) => unknown
-export type Deserializer = (parameter: unknown) => unknown
-
-class SerializeParametersTransformer extends OperationNodeTransformer {
-  private readonly serializer: Serializer
-
-  constructor(serializer: Serializer) {
-    super()
-    this.serializer = serializer
-  }
-
-  protected override transformPrimitiveValueList(
-    node: PrimitiveValueListNode
-  ): PrimitiveValueListNode {
-    return {
-      ...node,
-      values: node.values.map(this.serializer),
-    }
-  }
-
-  // https://www.npmjs.com/package/zodsql
-  protected override transformColumnUpdate(
-    node: ColumnUpdateNode
-  ): ColumnUpdateNode {
-    const { value: valueNode } = node
-    if (valueNode.kind !== 'ValueNode') {
-      return super.transformColumnUpdate(node)
-    }
-    const { value, ...item } = valueNode as ValueNode
-    const serializedValue = this.serializer(value)
-    if (value === serializedValue) {
-      return super.transformColumnUpdate(node)
-    }
-    const serializedNode: ValueNode = { ...item, value: serializedValue }
-    return super.transformColumnUpdate({ ...node, value: serializedNode })
-  }
-
-  protected override transformValue(node: ValueNode): ValueNode {
-    return {
-      ...node,
-      value: this.serializer(node.value),
-    }
-  }
-}
-
-export const defaultSerializer: Serializer = (parameter) => {
-  if (skipTransform(parameter) || typeof parameter === 'string') {
-    return parameter
-  } else if (typeof parameter === 'boolean') {
-    return '' + parameter
-  } else if (parameter instanceof Date) {
-    return parameter.toISOString()
-  } else {
-    try {
-      return JSON.stringify(parameter)
-    } catch {
-      return parameter
-    }
-  }
-}
-
-export const dateRegex = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$/
-
-export const defaultDeserializer: Deserializer = (parameter) => {
-  if (skipTransform(parameter)) {
-    return parameter
-  }
-  if (typeof parameter === 'string') {
-    if (parameter === 'true') {
-      return true
-    } else if (parameter === 'false') {
-      return false
-    } else if (dateRegex.test(parameter)) {
-      return new Date(parameter)
-    } else if (maybeJson(parameter)) {
-      try {
-        return JSON.parse(parameter)
-      } catch {
-        // not valid JSON — fall through and return the raw string
-      }
-    }
-    return parameter
-  }
-  return parameter
-}
-
-/**
- * Checks if a given string parameter is a JSON-like string.
- *
- * Determines whether the input starts and ends with curly braces `{}` or
- * square brackets `[]`, the typical indicators of JSON objects and arrays.
- */
-export function maybeJson(parameter: string): boolean {
-  return (
-    (parameter.startsWith('{') && parameter.endsWith('}')) ||
-    (parameter.startsWith('[') && parameter.endsWith(']'))
-  )
-}
-
-/**
- * Determines whether a given parameter should be skipped during transformation.
- *
- * Skipped when it is `undefined`, `null`, a `bigint`, a `number`, or an object
- * that exposes a `buffer` property (e.g. a typed array / Buffer).
- */
-export function skipTransform(parameter: unknown): boolean {
-  return (
-    parameter === undefined ||
-    parameter === null ||
-    typeof parameter === 'bigint' ||
-    typeof parameter === 'number' ||
-    (typeof parameter === 'object' && 'buffer' in parameter)
-  )
-}
-
-export class BaseSerializePlugin implements KyselyPlugin {
-  private readonly transformer: SerializeParametersTransformer
-  private readonly deserializer: Deserializer
-  private readonly skipNodeSet?: Set<RootOperationNode['kind']>
-  private readonly ctx?: WeakSet<QueryId>
-
-  /**
-   * Base class for {@link SerializePlugin}, without default options.
-   */
-  constructor(
-    serializer: Serializer,
-    deserializer: Deserializer,
-    skipNodeKind: Array<RootOperationNode['kind']>
-  ) {
-    this.transformer = new SerializeParametersTransformer(serializer)
-    this.deserializer = deserializer
-    if (skipNodeKind.length) {
-      this.skipNodeSet = new Set(skipNodeKind)
-      this.ctx = new WeakSet()
-    }
-  }
-
-  transformQuery({
-    node,
-    queryId,
-  }: PluginTransformQueryArgs): RootOperationNode {
-    if (this.skipNodeSet?.has(node.kind)) {
-      this.ctx?.add(queryId)
-      return node
-    }
-    return this.transformer.transformNode(node)
-  }
-
-  async transformResult({
-    result,
-    queryId,
-  }: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
-    return this.ctx?.has(queryId)
-      ? result
-      : { ...result, rows: this.parseRows(result.rows) }
-  }
-
-  private parseRows(rows: UnknownRow[]): UnknownRow[] {
-    const result: UnknownRow[] = []
-    for (const row of rows) {
-      if (!row) {
-        continue
-      }
-      const parsedRow: UnknownRow = {}
-      for (const [key, value] of Object.entries(row)) {
-        parsedRow[key] = this.deserializer(value)
-      }
-      result.push(parsedRow)
-    }
-    return result
-  }
-}
-
-export interface SerializePluginOptions {
-  /**
-   * serialize params
-   */
-  serializer?: Serializer
-  /**
-   * deserialize params
-   */
-  deserializer?: Deserializer
-  /**
-   * node kind to skip transform
-   */
-  skipNodeKind?: Array<RootOperationNode['kind']>
-}
-
-export class SerializePlugin extends BaseSerializePlugin {
-  /**
-   * _**THIS PLUGIN SHOULD BE PLACED AT THE END OF PLUGINS ARRAY !!!**_
-   *
-   * reference from https://github.com/koskimas/kysely/pull/138
-   *
-   * Serializes object/array/Date/boolean column values to strings for
-   * SQLite-style dialects and deserializes them on the way back out. Pass a
-   * custom `serializer`/`deserializer` to override the default behaviour.
-   */
-  constructor(options: SerializePluginOptions = {}) {
-    const {
-      deserializer = defaultDeserializer,
-      serializer = defaultSerializer,
-      skipNodeKind = [],
-    } = options
-    super(serializer, deserializer, skipNodeKind)
-  }
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "module": "Node18",
-    "outDir": "dist",
-    "target": "esnext",
-    "declaration": true
-  },
-  "include": ["src/**/*.ts", "bin/**/*.ts", "bin/pikku-kysely-pure.ts"],
-  "exclude": ["**/*.test.ts", "node_modules", "bin/dist"],
-  "references": [
-    {
-      "path": "../../core/tsconfig.json"
-    }
-  ]
-}