@pikku/kysely 0.13.23 → 0.13.27

package/src/kysely-virtual-user-schedule-store.test.ts

@@ -1,187 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-import Database from 'better-sqlite3'
-import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
-
-import { KyselyVirtualUserScheduleStore } from './kysely-virtual-user-schedule-store.js'
-import { SerializePlugin } from './serialize-plugin.js'
-import { applyPikkuSchemas, virtualUserScheduleSchema } from './schema/index.js'
-import type { KyselyPikkuDB } from './kysely-tables.js'
-
-// With the plugin, because most projects in this package run with it and it is
-// the harder case: it deserialises columns the store has already stringified.
-const withPlugin = () =>
-  new Kysely<KyselyPikkuDB>({
-    dialect: new SqliteDialect({ database: new Database(':memory:') }),
-    plugins: [new CamelCasePlugin(), new SerializePlugin()],
-  })
-
-const bare = () =>
-  new Kysely<KyselyPikkuDB>({
-    dialect: new SqliteDialect({ database: new Database(':memory:') }),
-    plugins: [new CamelCasePlugin()],
-  })
-
-const HOUR = 60 * 60 * 1000
-
-describe('KyselyVirtualUserScheduleStore', () => {
-  let db: Kysely<KyselyPikkuDB>
-  let store: KyselyVirtualUserScheduleStore
-
-  beforeEach(async () => {
-    db = withPlugin()
-    await applyPikkuSchemas(db, [virtualUserScheduleSchema])
-    store = new KyselyVirtualUserScheduleStore(db)
-  })
-
-  test('a persona given a cadence is not running until someone says so', async () => {
-    const written = await store.set({ persona: 'guest' })
-    assert.equal(written.enabled, false)
-    assert.deepEqual(await store.due(new Date(Date.now() + 1000)), [])
-    assert.equal((await store.get('guest'))?.enabled, false)
-  })
-
-  test('a schedule written without an interval gets one, sparse by default', async () => {
-    const written = await store.set({ persona: 'guest' })
-    assert.ok(written.minIntervalMs >= HOUR)
-    assert.ok(written.maxIntervalMs >= written.minIntervalMs)
-    const stored = await store.get('guest')
-    assert.equal(stored?.minIntervalMs, written.minIntervalMs)
-    assert.equal(stored?.maxIntervalMs, written.maxIntervalMs)
-  })
-
-  test('setting one field leaves the rest of the schedule alone', async () => {
-    await store.set({
-      persona: 'guest',
-      enabled: true,
-      disposition: 'adversarial',
-      goals: ['book a room'],
-      budget: { steps: 40 },
-      minIntervalMs: HOUR,
-      maxIntervalMs: 2 * HOUR,
-    })
-    await store.set({ persona: 'guest', enabled: false })
-
-    const stored = await store.get('guest')
-    assert.equal(stored?.enabled, false)
-    assert.equal(stored?.disposition, 'adversarial')
-    assert.deepEqual(stored?.goals, ['book a room'])
-    assert.deepEqual(stored?.budget, { steps: 40 })
-    assert.equal(stored?.minIntervalMs, HOUR)
-  })
-
-  test('only enabled personas whose time has come come back as due', async () => {
-    const now = new Date()
-    await store.set({
-      persona: 'due',
-      enabled: true,
-      nextRunAt: new Date(now.getTime() - HOUR),
-    })
-    await store.set({
-      persona: 'later',
-      enabled: true,
-      nextRunAt: new Date(now.getTime() + HOUR),
-    })
-    await store.set({
-      persona: 'off',
-      enabled: false,
-      nextRunAt: new Date(now.getTime() - HOUR),
-    })
-
-    assert.deepEqual(
-      (await store.due(now)).map((row) => row.persona),
-      ['due']
-    )
-  })
-
-  test('claiming pushes the persona out of the due list', async () => {
-    const now = new Date()
-    const due = new Date(now.getTime() - HOUR)
-    await store.set({ persona: 'guest', enabled: true, nextRunAt: due })
-    const acquired = await store.claim('guest', {
-      from: due,
-      nextRunAt: new Date(now.getTime() + HOUR),
-      runId: 'run-1',
-      at: now,
-    })
-
-    assert.equal(acquired, true)
-
-    assert.deepEqual(await store.due(now), [])
-    const stored = await store.get('guest')
-    assert.equal(stored?.lastRunId, 'run-1')
-    assert.equal(stored?.lastRunAt?.getTime(), now.getTime())
-  })
-
-  test('the claim written before a run starts does not blank the last run', async () => {
-    const now = new Date()
-    const written = await store.set({ persona: 'guest', enabled: true })
-    await store.claim('guest', {
-      from: written.nextRunAt,
-      nextRunAt: now,
-      runId: 'run-1',
-      at: now,
-    })
-    await store.claim('guest', {
-      from: now,
-      nextRunAt: new Date(now.getTime() + HOUR),
-      runId: null,
-      at: now,
-    })
-
-    assert.equal((await store.get('guest'))?.lastRunId, 'run-1')
-  })
-
-  test('only one of two ticks holding the same due row can claim it', async () => {
-    const now = new Date()
-    const due = new Date(now.getTime() - HOUR)
-    await store.set({ persona: 'guest', enabled: true, nextRunAt: due })
-
-    const [first] = await store.due(now)
-    const [second] = await store.due(now)
-    assert.equal(first?.nextRunAt.getTime(), second?.nextRunAt.getTime())
-
-    const won = await store.claim('guest', {
-      from: first!.nextRunAt,
-      nextRunAt: new Date(now.getTime() + HOUR),
-      runId: 'run-1',
-      at: now,
-    })
-    const lost = await store.claim('guest', {
-      from: second!.nextRunAt,
-      nextRunAt: new Date(now.getTime() + 2 * HOUR),
-      runId: 'run-2',
-      at: now,
-    })
-
-    assert.deepEqual([won, lost], [true, false])
-    assert.equal((await store.get('guest'))?.lastRunId, 'run-1')
-  })
-
-  test('a cadence survives a store with no serialize plugin', async () => {
-    const plainDb = bare()
-    await applyPikkuSchemas(plainDb, [virtualUserScheduleSchema])
-    const plain = new KyselyVirtualUserScheduleStore(plainDb)
-    await plain.set({
-      persona: 'guest',
-      enabled: true,
-      goals: ['book a room'],
-      budget: { steps: 40, duration: '30m' },
-      minIntervalMs: HOUR,
-      maxIntervalMs: 2 * HOUR,
-    })
-
-    const stored = await plain.get('guest')
-    assert.equal(stored?.enabled, true)
-    assert.deepEqual(stored?.goals, ['book a room'])
-    assert.deepEqual(stored?.budget, { steps: 40, duration: '30m' })
-    assert.ok(stored?.nextRunAt instanceof Date)
-  })
-
-  test('a persona can be taken off the clock entirely', async () => {
-    await store.set({ persona: 'guest', enabled: true })
-    await store.remove('guest')
-    assert.equal(await store.get('guest'), null)
-    assert.deepEqual(await store.list(), [])
-  })
-})

package/src/kysely-virtual-user-schedule-store.ts

@@ -1,187 +0,0 @@
-import type { Kysely, Selectable } from 'kysely'
-import type {
-  VirtualUserBudget,
-  VirtualUserDisposition,
-  VirtualUserScheduleInput,
-  VirtualUserScheduleRecord,
-  VirtualUserScheduleStore,
-} from '@pikku/core/virtual-user'
-import {
-  DEFAULT_MAX_INTERVAL_MS,
-  DEFAULT_MIN_INTERVAL_MS,
-} from '@pikku/core/virtual-user'
-import type {
-  KyselyPikkuDB,
-  VirtualUserScheduleTable,
-} from './kysely-tables.js'
-import { parseJson } from './kysely-json.js'
-import { requirePikkuSchema } from './schema/index.js'
-import { virtualUserScheduleSchema } from './schema/virtual-user-schedule.schema.js'
-
-/**
- * Keeps each persona's cadence in a `virtualUserSchedule` table.
- *
- * Wiring this is what turns virtual users from something a person triggers into
- * something that happens: without it, {@link KyselyVirtualUserRunStore} still
- * records every run, and every run still had someone behind it. Two services
- * rather than one so that an app can want the history without wanting the bill.
- *
- * Reads and writes the same way the run store does — JSON as text, timestamps
- * as ISO strings, flags as 0/1 — so a project on SQLite and one on Postgres
- * hold the same bytes and `SerializePlugin` is optional on both.
- */
-export class KyselyVirtualUserScheduleStore implements VirtualUserScheduleStore {
-  private initialized = false
-
-  constructor(private db: Kysely<KyselyPikkuDB>) {}
-
-  public async init(): Promise<void> {
-    if (this.initialized) return
-    await requirePikkuSchema(this.db, virtualUserScheduleSchema)
-    this.initialized = true
-  }
-
-  async set(
-    schedule: VirtualUserScheduleInput
-  ): Promise<VirtualUserScheduleRecord> {
-    await this.init()
-    // Read-then-write rather than a partial upsert: a schedule is configuration
-    // written by a person, and the alternative is two dialects of "leave the
-    // columns I did not mention alone".
-    const existing = await this.get(schedule.persona)
-    const merged: VirtualUserScheduleRecord = {
-      persona: schedule.persona,
-      enabled: schedule.enabled ?? existing?.enabled ?? false,
-      disposition: schedule.disposition ?? existing?.disposition ?? 'realistic',
-      goals: [...(schedule.goals ?? existing?.goals ?? [])],
-      budget:
-        schedule.budget === undefined
-          ? (existing?.budget ?? null)
-          : schedule.budget,
-      minIntervalMs:
-        schedule.minIntervalMs ??
-        existing?.minIntervalMs ??
-        DEFAULT_MIN_INTERVAL_MS,
-      maxIntervalMs:
-        schedule.maxIntervalMs ??
-        existing?.maxIntervalMs ??
-        DEFAULT_MAX_INTERVAL_MS,
-      // A new schedule is due immediately. Enabling one is a deliberate act, and
-      // waiting a random half-day to find out whether it works is not a feature.
-      nextRunAt: schedule.nextRunAt ?? existing?.nextRunAt ?? new Date(),
-      lastRunId: existing?.lastRunId ?? null,
-      lastRunAt: existing?.lastRunAt ?? null,
-    }
-
-    const values = {
-      persona: merged.persona,
-      enabled: merged.enabled ? 1 : 0,
-      disposition: merged.disposition,
-      goals: JSON.stringify(merged.goals),
-      budget: merged.budget ? JSON.stringify(merged.budget) : null,
-      minIntervalMs: String(merged.minIntervalMs),
-      maxIntervalMs: String(merged.maxIntervalMs),
-      nextRunAt: merged.nextRunAt.toISOString(),
-    }
-
-    await this.db
-      .insertInto('virtualUserSchedule')
-      .values(values)
-      .onConflict((oc) =>
-        oc.column('persona').doUpdateSet({
-          enabled: values.enabled,
-          disposition: values.disposition,
-          goals: values.goals,
-          budget: values.budget,
-          minIntervalMs: values.minIntervalMs,
-          maxIntervalMs: values.maxIntervalMs,
-          nextRunAt: values.nextRunAt,
-        })
-      )
-      .execute()
-
-    return merged
-  }
-
-  async get(persona: string): Promise<VirtualUserScheduleRecord | null> {
-    await this.init()
-    const row = await this.db
-      .selectFrom('virtualUserSchedule')
-      .selectAll()
-      .where('persona', '=', persona)
-      .executeTakeFirst()
-    return row ? this.toRecord(row) : null
-  }
-
-  async list(): Promise<VirtualUserScheduleRecord[]> {
-    await this.init()
-    const rows = await this.db
-      .selectFrom('virtualUserSchedule')
-      .selectAll()
-      .orderBy('persona', 'asc')
-      .execute()
-    return rows.map((row) => this.toRecord(row))
-  }
-
-  async due(now: Date): Promise<VirtualUserScheduleRecord[]> {
-    await this.init()
-    const rows = await this.db
-      .selectFrom('virtualUserSchedule')
-      .selectAll()
-      .where('enabled', '=', 1)
-      .where('nextRunAt', '<=', now.toISOString())
-      .orderBy('nextRunAt', 'asc')
-      .execute()
-    return rows.map((row) => this.toRecord(row))
-  }
-
-  async claim(
-    persona: string,
-    claim: { from: Date; nextRunAt: Date; runId: string | null; at: Date }
-  ): Promise<boolean> {
-    await this.init()
-    const result = await this.db
-      .updateTable('virtualUserSchedule')
-      .set({
-        nextRunAt: claim.nextRunAt.toISOString(),
-        // A claim with no run id is the one written before dispatch, and must
-        // not blank out which run this persona last managed to start.
-        ...(claim.runId
-          ? { lastRunId: claim.runId, lastRunAt: claim.at.toISOString() }
-          : {}),
-      })
-      .where('persona', '=', persona)
-      // The compare-and-set: whoever writes first moves `nextRunAt`, and every
-      // other tick holding the value they read matches nothing.
-      .where('nextRunAt', '=', claim.from.toISOString())
-      .executeTakeFirst()
-    return Number(result.numUpdatedRows ?? 0) > 0
-  }
-
-  async remove(persona: string): Promise<void> {
-    await this.init()
-    await this.db
-      .deleteFrom('virtualUserSchedule')
-      .where('persona', '=', persona)
-      .execute()
-  }
-
-  private toRecord(
-    row: Selectable<VirtualUserScheduleTable>
-  ): VirtualUserScheduleRecord {
-    return {
-      persona: row.persona,
-      enabled: Boolean(row.enabled),
-      disposition: row.disposition as VirtualUserDisposition,
-      goals: parseJson(row.goals) ?? [],
-      budget: row.budget
-        ? ((parseJson(row.budget) ?? null) as VirtualUserBudget | null)
-        : null,
-      minIntervalMs: Number(row.minIntervalMs),
-      maxIntervalMs: Number(row.maxIntervalMs),
-      nextRunAt: new Date(row.nextRunAt),
-      lastRunId: row.lastRunId,
-      lastRunAt: row.lastRunAt ? new Date(row.lastRunAt) : null,
-    }
-  }
-}

package/src/kysely-webhook-service.test.ts

@@ -1,124 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
-import Database from 'better-sqlite3'
-import { setSingletonServices } from '@pikku/core/state'
-
-import type { KyselyPikkuDB } from './kysely-tables.js'
-import { SerializePlugin } from './serialize-plugin.js'
-import { KyselyWebhookService } from './kysely-webhook-service.js'
-import { applyPikkuSchemas, webhookSchema } from './schema/index.js'
-
-const noopLogger = { error() {}, info() {}, warn() {}, debug() {} }
-
-function createDb(): Kysely<KyselyPikkuDB> {
-  return new Kysely<KyselyPikkuDB>({
-    dialect: new SqliteDialect({ database: new Database(':memory:') }),
-    plugins: [new CamelCasePlugin(), new SerializePlugin()],
-  })
-}
-
-const createQueue = () => {
-  const added: { data: any; options: any }[] = []
-  return {
-    added,
-    queue: {
-      supportsResults: false,
-      add: async (_name: string, data: any, options: any) => {
-        added.push({ data, options })
-        return options?.jobId ?? 'job-1'
-      },
-      getJob: async () => null,
-    },
-  }
-}
-
-// send() resolves config/secrets through the singleton services.
-const setServices = () =>
-  setSingletonServices({
-    logger: noopLogger,
-    config: {},
-    secrets: {
-      getSecret: async (key: string) => {
-        throw new Error(`Secret not found: ${key}`)
-      },
-    },
-  } as any)
-
-describe('KyselyWebhookService', () => {
-  beforeEach(setServices)
-
-  test('send() inserts a pending delivery and enqueues with deliveryId === jobId', async () => {
-    const db = createDb()
-    const { added, queue } = createQueue()
-    await applyPikkuSchemas(db, [webhookSchema])
-    const service = new KyselyWebhookService(queue as any, db)
-    await service.init()
-
-    const { jobId } = await service.send({
-      url: 'https://example.com/hook',
-      event: 'user.created',
-      data: { id: 'u1' },
-      organizationId: 'org-1',
-    })
-
-    // jobId is the delivery id and rides in the payload.
-    assert.equal(added.length, 1)
-    assert.equal(added[0]!.options.jobId, jobId)
-    assert.equal(added[0]!.data.deliveryId, jobId)
-
-    const delivery = await service.getDelivery(jobId)
-    assert.ok(delivery)
-    assert.equal(delivery!.delivery.status, 'pending')
-    assert.equal(delivery!.delivery.organizationId, 'org-1')
-    assert.equal(delivery!.delivery.url, 'https://example.com/hook')
-    assert.equal(delivery!.attempts.length, 0)
-  })
-
-  test('recordAttempt() appends attempts and rolls status forward', async () => {
-    const db = createDb()
-    const { queue } = createQueue()
-    await applyPikkuSchemas(db, [webhookSchema])
-    const service = new KyselyWebhookService(queue as any, db)
-    await service.init()
-
-    const { jobId } = await service.send({
-      url: 'https://example.com/hook',
-      data: {},
-    })
-
-    await service.recordAttempt(jobId, {
-      statusCode: 500,
-      error: 'boom',
-      delivered: false,
-    })
-    await service.recordAttempt(jobId, { statusCode: 200, delivered: true })
-
-    const result = await service.getDelivery(jobId)
-    assert.equal(result!.attempts.length, 2)
-    assert.equal(result!.attempts[0]!.attemptNumber, 1)
-    assert.equal(result!.attempts[0]!.statusCode, 500)
-    assert.equal(result!.attempts[1]!.attemptNumber, 2)
-    assert.equal(result!.delivery.status, 'delivered')
-    assert.equal(result!.delivery.attempts, 2)
-    assert.ok(result!.delivery.deliveredAt)
-  })
-
-  test('listDeliveries() filters by organization', async () => {
-    const db = createDb()
-    const { queue } = createQueue()
-    await applyPikkuSchemas(db, [webhookSchema])
-    const service = new KyselyWebhookService(queue as any, db)
-    await service.init()
-
-    await service.send({ url: 'https://a.com', data: {}, organizationId: 'o1' })
-    await service.send({ url: 'https://b.com', data: {}, organizationId: 'o2' })
-
-    const o1 = await service.listDeliveries({ organizationId: 'o1' })
-    assert.equal(o1.length, 1)
-    assert.equal(o1[0]!.url, 'https://a.com')
-
-    const all = await service.listDeliveries()
-    assert.equal(all.length, 2)
-  })
-})

package/src/kysely-webhook-service.ts

@@ -1,137 +0,0 @@
-import { QueueWebhookService } from '@pikku/core/services'
-import type { QueueService } from '@pikku/core/queue'
-import {
-  PIKKU_OUTGOING_WEBHOOK_QUEUE_NAME,
-  type SendWebhookInput,
-  type SendWebhookResult,
-  type WebhookAttemptResult,
-  type WebhookDeliveryRecord,
-  type WebhookDeliveryWithAttempts,
-} from '@pikku/core/services'
-import type { Kysely } from 'kysely'
-import type { KyselyPikkuDB } from './kysely-tables.js'
-import { requirePikkuSchema } from './schema/index.js'
-import { webhookSchema } from './schema/webhook.schema.js'
-
-/**
- * Durable {@link QueueWebhookService}: still delivers through the
- * `pikku-outgoing-webhooks` queue, but records a `webhook_delivery` row per
- * `send()` and one `webhook_delivery_attempt` row per try. Register it as the
- * `webhookService` singleton; the queue worker persists each attempt through
- * {@link recordAttempt}, overriding the base's throwing default.
- */
-export class KyselyWebhookService extends QueueWebhookService {
-  private initialized = false
-
-  constructor(
-    queueService: QueueService,
-    private db: Kysely<KyselyPikkuDB>
-  ) {
-    super(queueService)
-  }
-
-  public async init(): Promise<void> {
-    if (this.initialized) return
-    await requirePikkuSchema(this.db, webhookSchema)
-    this.initialized = true
-  }
-
-  public async send(input: SendWebhookInput): Promise<SendWebhookResult> {
-    const deliveryId = globalThis.crypto.randomUUID()
-    const { jobData, options } = await this.prepareDelivery(input)
-
-    await this.db
-      .insertInto('webhookDelivery')
-      .values({
-        deliveryId,
-        organizationId: input.organizationId ?? null,
-        url: input.url,
-        event: input.event ?? null,
-      })
-      .execute()
-
-    // deliveryId doubles as the queue jobId (idempotency) and rides in the
-    // payload so the worker can record attempts against this row.
-    const jobId = await this.queueService.add(
-      PIKKU_OUTGOING_WEBHOOK_QUEUE_NAME,
-      { ...jobData, deliveryId },
-      { ...options, jobId: deliveryId }
-    )
-    return { jobId }
-  }
-
-  public async recordAttempt(
-    deliveryId: string,
-    { statusCode, responseBody, error, delivered }: WebhookAttemptResult
-  ): Promise<void> {
-    const now = new Date()
-    await this.db.transaction().execute(async (trx) => {
-      const existing = await trx
-        .selectFrom('webhookDeliveryAttempt')
-        .select((eb) => eb.fn.countAll<number>().as('count'))
-        .where('deliveryId', '=', deliveryId)
-        .executeTakeFirst()
-      const attemptNumber = Number(existing?.count ?? 0) + 1
-
-      await trx
-        .insertInto('webhookDeliveryAttempt')
-        .values({
-          attemptId: globalThis.crypto.randomUUID(),
-          deliveryId,
-          attemptNumber,
-          statusCode: statusCode ?? null,
-          responseBody: responseBody ?? null,
-          error: error ?? null,
-        })
-        .execute()
-
-      await trx
-        .updateTable('webhookDelivery')
-        .set({
-          status: delivered ? 'delivered' : 'failed',
-          attempts: attemptNumber,
-          updatedAt: now,
-          ...(delivered ? { deliveredAt: now } : {}),
-        })
-        .where('deliveryId', '=', deliveryId)
-        .execute()
-    })
-  }
-
-  /** List deliveries, most recent first — for the console webhooks view. */
-  public async listDeliveries(opts?: {
-    organizationId?: string
-    limit?: number
-  }): Promise<WebhookDeliveryRecord[]> {
-    let query = this.db
-      .selectFrom('webhookDelivery')
-      .selectAll()
-      .orderBy('createdAt', 'desc')
-      .limit(opts?.limit ?? 100)
-    if (opts?.organizationId) {
-      query = query.where('organizationId', '=', opts.organizationId)
-    }
-    return query.execute()
-  }
-
-  /** A single delivery with its full attempt history, or null if unknown. */
-  public async getDelivery(
-    deliveryId: string
-  ): Promise<WebhookDeliveryWithAttempts | null> {
-    const delivery = await this.db
-      .selectFrom('webhookDelivery')
-      .selectAll()
-      .where('deliveryId', '=', deliveryId)
-      .executeTakeFirst()
-    if (!delivery) {
-      return null
-    }
-    const attempts = await this.db
-      .selectFrom('webhookDeliveryAttempt')
-      .selectAll()
-      .where('deliveryId', '=', deliveryId)
-      .orderBy('attemptNumber', 'asc')
-      .execute()
-    return { delivery, attempts }
-  }
-}