@pikku/kysely 0.13.34 → 0.13.37

package/dist/src/kysely-scope-service.js

@@ -1,5 +1,6 @@
 import { SystemRoleImmutableError, SystemRoleShadowedError, } from '@pikku/core/errors';
 import { requirePikkuSchema } from './schema/index.js';
+import { INSERTED, insertOrIgnore, isMysql, upsert } from './kysely-upsert.js';
 import { scopeSchema } from './schema/scope.schema.js';
 /**
  * Resolves and administers user scopes against four self-created tables.
@@ -37,18 +38,11 @@ export class KyselyScopeService {
     async syncScopes(scopes) {
         await this.db.transaction().execute(async (trx) => {
             if (scopes.length > 0) {
-                await trx
-                    .insertInto('pikkuScopes')
-                    .values(scopes.map((scope) => ({
+                await upsert(trx, trx.insertInto('pikkuScopes').values(scopes.map((scope) => ({
                     name: scope.id,
                     description: scope.description ?? null,
                     declared: true,
-                })))
-                    .onConflict((oc) => oc.column('name').doUpdateSet((eb) => ({
-                    description: eb.ref('excluded.description'),
-                    declared: true,
-                })))
-                    .execute();
+                }))), ['name'], { description: INSERTED, declared: true }).execute();
             }
             const markStale = trx.updateTable('pikkuScopes').set({ declared: false });
             await (scopes.length > 0
@@ -93,20 +87,12 @@ export class KyselyScopeService {
     async syncSystemRoles(roles) {
         await this.db.transaction().execute(async (trx) => {
             for (const role of roles) {
-                await trx
-                    .insertInto('pikkuRoles')
-                    .values({
+                await upsert(trx, trx.insertInto('pikkuRoles').values({
                     name: role.name,
                     description: role.description ?? null,
                     system: true,
                     declared: true,
-                })
-                    .onConflict((oc) => oc.column('name').doUpdateSet((eb) => ({
-                    description: eb.ref('excluded.description'),
-                    system: true,
-                    declared: true,
-                })))
-                    .execute();
+                }), ['name'], { description: INSERTED, system: true, declared: true }).execute();
                 await trx
                     .deleteFrom('pikkuRoleScopes')
                     .where('role', '=', role.name)
@@ -215,11 +201,9 @@ export class KyselyScopeService {
         }));
     }
     async addUserToRole(userId, role, grantedBy) {
-        await this.db
+        await insertOrIgnore(this.db, this.db
             .insertInto('pikkuUserRole')
-            .values({ userId, role, grantedBy: grantedBy ?? null })
-            .onConflict((oc) => oc.columns(['userId', 'role']).doNothing())
-            .execute();
+            .values({ userId, role, grantedBy: grantedBy ?? null }), ['userId', 'role']).execute();
     }
     async removeUserFromRole(userId, role) {
         await this.db
@@ -266,11 +250,9 @@ export class KyselyScopeService {
         return byUser;
     }
     async addScopeToUser(userId, scope, grantedBy) {
-        await this.db
+        await insertOrIgnore(this.db, this.db
             .insertInto('pikkuUserScope')
-            .values({ userId, scope, grantedBy: grantedBy ?? null })
-            .onConflict((oc) => oc.columns(['userId', 'scope']).doNothing())
-            .execute();
+            .values({ userId, scope, grantedBy: grantedBy ?? null }), ['userId', 'scope']).execute();
     }
     async removeScopeFromUser(userId, scope) {
         await this.db
@@ -318,13 +300,31 @@ export class KyselyScopeService {
             return [];
         }
         const names = stale.map((s) => s.scope);
-        const deleted = await this.db
-            .deleteFrom('pikkuScopes')
-            .where('name', 'in', names)
-            .where('declared', '=', false)
-            .returning('name')
-            .execute();
-        return deleted.map((r) => r.name);
+        // MySQL has no `returning`: read what the delete's predicate matches inside
+        // the same transaction, then delete it.
+        return this.db.transaction().execute(async (trx) => {
+            const matching = () => trx
+                .selectFrom('pikkuScopes')
+                .select('name')
+                .where('name', 'in', names)
+                .where('declared', '=', false);
+            if (isMysql(trx)) {
+                const rows = await matching().forUpdate().execute();
+                await trx
+                    .deleteFrom('pikkuScopes')
+                    .where('name', 'in', names)
+                    .where('declared', '=', false)
+                    .execute();
+                return rows.map((r) => r.name);
+            }
+            const deleted = await trx
+                .deleteFrom('pikkuScopes')
+                .where('name', 'in', names)
+                .where('declared', '=', false)
+                .returning('name')
+                .execute();
+            return deleted.map((r) => r.name);
+        });
     }
     /**
      * System roles the last sync found no declaration for, with how many people
@@ -358,13 +358,33 @@ export class KyselyScopeService {
         if (stale.length === 0) {
             return [];
         }
-        const deleted = await this.db
-            .deleteFrom('pikkuRoles')
-            .where('name', 'in', stale.map((s) => s.role))
-            .where('system', '=', true)
-            .where('declared', '=', false)
-            .returning('name')
-            .execute();
-        return deleted.map((r) => r.name);
+        const names = stale.map((s) => s.role);
+        return this.db.transaction().execute(async (trx) => {
+            if (isMysql(trx)) {
+                const rows = await trx
+                    .selectFrom('pikkuRoles')
+                    .select('name')
+                    .where('name', 'in', names)
+                    .where('system', '=', true)
+                    .where('declared', '=', false)
+                    .forUpdate()
+                    .execute();
+                await trx
+                    .deleteFrom('pikkuRoles')
+                    .where('name', 'in', names)
+                    .where('system', '=', true)
+                    .where('declared', '=', false)
+                    .execute();
+                return rows.map((r) => r.name);
+            }
+            const deleted = await trx
+                .deleteFrom('pikkuRoles')
+                .where('name', 'in', names)
+                .where('system', '=', true)
+                .where('declared', '=', false)
+                .returning('name')
+                .execute();
+            return deleted.map((r) => r.name);
+        });
     }
 }

package/dist/src/kysely-secret-service.js

@@ -1,6 +1,7 @@
 import { deriveKEK, envelopeDecrypt, envelopeEncrypt, envelopeRewrap, generateKEKSalt, } from '@pikku/core/crypto-utils';
 import { createSecretValue, isSecretValue } from '@pikku/core/classification';
 import { requirePikkuSchema } from './schema/index.js';
+import { insertOrIgnore, timestampParam, upsert } from './kysely-upsert.js';
 import { secretSchema } from './schema/secret.schema.js';
 export class KyselySecretService {
     db;
@@ -37,7 +38,7 @@ export class KyselySecretService {
             id: crypto.randomUUID(),
             secretKey: secretKey,
             action,
-            performedAt: new Date().toISOString(),
+            performedAt: timestampParam(this.db),
         })
             .execute();
     }
@@ -52,15 +53,11 @@ export class KyselySecretService {
             .executeTakeFirst();
         let salt = existing?.salt;
         if (!salt) {
-            await this.db
-                .insertInto('secretKekSalts')
-                .values({
+            await insertOrIgnore(this.db, this.db.insertInto('secretKekSalts').values({
                 keyVersion: version,
                 salt: generateKEKSalt(),
-                createdAt: new Date().toISOString(),
-            })
-                .onConflict((oc) => oc.column('keyVersion').doNothing())
-                .execute();
+                createdAt: timestampParam(this.db),
+            }), ['keyVersion']).execute();
             const row = await this.db
                 .selectFrom('secretKekSalts')
                 .select('salt')
@@ -108,24 +105,20 @@ export class KyselySecretService {
         // Encrypting the wrapper would store its redaction, not the secret —
         // writing a secret back to the vault is exactly what this method is for.
         const { ciphertext, wrappedDEK } = await envelopeEncrypt(await this.getKEK(this.keyVersion), isSecretValue(value) ? value.reveal() : value);
-        const now = new Date().toISOString();
-        await this.db
-            .insertInto('secrets')
-            .values({
+        const now = timestampParam(this.db);
+        await upsert(this.db, this.db.insertInto('secrets').values({
             key,
             ciphertext,
             wrappedDek: wrappedDEK,
             keyVersion: this.keyVersion,
             createdAt: now,
             updatedAt: now,
-        })
-            .onConflict((oc) => oc.column('key').doUpdateSet({
+        }), ['key'], {
             ciphertext,
             wrappedDek: wrappedDEK,
             keyVersion: this.keyVersion,
             updatedAt: now,
-        }))
-            .execute();
+        }).execute();
         await this.logAudit(key, 'write');
     }
     async deleteSecret(key) {
@@ -175,7 +168,7 @@ export class KyselySecretService {
                 .set({
                 wrappedDek: newWrappedDEK,
                 keyVersion: this.keyVersion,
-                updatedAt: new Date().toISOString(),
+                updatedAt: timestampParam(this.db),
             })
                 .where('key', '=', row.key)
                 .execute();

package/dist/src/kysely-session-store.js

@@ -1,5 +1,6 @@
 import { parseJson } from './kysely-json.js';
 import { requirePikkuSchema } from './schema/index.js';
+import { upsert } from './kysely-upsert.js';
 import { sessionSchema } from './schema/session.schema.js';
 export class KyselySessionStore {
     db;
@@ -25,18 +26,11 @@ export class KyselySessionStore {
         return (parseJson(row.session) ?? undefined);
     }
     async set(pikkuUserId, session) {
-        await this.db
-            .insertInto('pikkuUserSessions')
-            .values({
+        await upsert(this.db, this.db.insertInto('pikkuUserSessions').values({
             pikkuUserId,
             session: JSON.stringify(session),
             updatedAt: new Date(),
-        })
-            .onConflict((oc) => oc.column('pikkuUserId').doUpdateSet({
-            session: JSON.stringify(session),
-            updatedAt: new Date(),
-        }))
-            .execute();
+        }), ['pikkuUserId'], { session: JSON.stringify(session), updatedAt: new Date() }).execute();
     }
     async clear(pikkuUserId) {
         await this.db

package/dist/src/kysely-tables.d.ts

@@ -329,7 +329,7 @@ export interface WebhookReceiptTable {
  */
 export interface VirtualUserRunTable {
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: string;
     /**
      * Read back as a string by some drivers — a BIGINT does not always fit a JS
@@ -424,11 +424,11 @@ export interface VirtualUserRunStepTable {
     tokensOut: Generated<number>;
 }
 /**
- * One persona's cadence. Nullable timestamps and 0/1 flags for the same driver
+ * One virtual user's cadence. Nullable timestamps and 0/1 flags for the same driver
  * reasons as {@link VirtualUserRunTable}.
  */
 export interface VirtualUserScheduleTable {
-    persona: string;
+    virtualUserId: string;
     /** 0 or 1: not every driver in this package can bind a boolean. */
     enabled: Generated<number>;
     disposition: string;

package/dist/src/kysely-trigger-source-store.js

@@ -1,4 +1,5 @@
 import { requirePikkuSchema } from './schema/index.js';
+import { upsert } from './kysely-upsert.js';
 import { triggerSourceSchema } from './schema/trigger-source.schema.js';
 const parseState = (value) => {
     if (!value)
@@ -43,11 +44,9 @@ export class KyselyTriggerSourceStore {
                     ...(baseUrl !== undefined ? { baseUrl } : {}),
                     ...(labelPrefix !== undefined ? { labelPrefix } : {}),
                 };
-                await trx
+                await upsert(trx, trx
                     .insertInto('pikkuTriggerSource')
-                    .values({ name, kind, declared: true, ...address })
-                    .onConflict((oc) => oc.column('name').doUpdateSet({ kind, declared: true, ...address }))
-                    .execute();
+                    .values({ name, kind, declared: true, ...address }), ['name'], { kind, declared: true, ...address }).execute();
             }
             const markStale = trx
                 .updateTable('pikkuTriggerSource')

package/dist/src/kysely-upsert.d.ts

@@ -0,0 +1,37 @@
+import { type Kysely } from 'kysely';
+/**
+ * Whether `db` talks to MySQL.
+ *
+ * Read from the dialect's adapter rather than configured, so a store handed any
+ * Kysely instance (or an open transaction) answers for the engine it will
+ * actually run against.
+ */
+export declare const isMysql: (db: Kysely<any>) => boolean;
+/** In an upsert's update set: take the value the insert proposed for this column. */
+export declare const INSERTED: unique symbol;
+/**
+ * Insert, leaving an existing row alone when `conflictColumns` already match one.
+ *
+ * Postgres and sqlite spell this `on conflict do nothing`. MySQL has no such
+ * clause; `insert ignore` is the closest, and unlike `on conflict (cols)` it
+ * also swallows other row errors, so it is only used where the conflict target
+ * is the table's key.
+ */
+export declare const insertOrIgnore: (db: Kysely<any>, query: any, conflictColumns?: string[]) => any;
+/**
+ * Insert, or update the row `conflictColumns` match.
+ *
+ * `set` maps column to the new value, or to `INSERTED` for "whatever this
+ * insert carried" — `excluded.col` on postgres and sqlite, `values(col)` on
+ * MySQL, which has no `excluded`.
+ */
+export declare const upsert: (db: Kysely<any>, query: any, conflictColumns: string[], set: Record<string, unknown>) => any;
+/**
+ * A moment as a `timestamp` column's parameter.
+ *
+ * An ISO 8601 string with its trailing `Z` is accepted by postgres and stored
+ * as written by sqlite, but MySQL refuses it for a `TIMESTAMP` column
+ * (`Incorrect datetime value`). The driver formats a `Date` for MySQL itself,
+ * so that is what it is given.
+ */
+export declare const timestampParam: (db: Kysely<any>, at?: Date) => Date;

package/dist/src/kysely-upsert.js

@@ -0,0 +1,54 @@
+import { MysqlAdapter } from 'kysely';
+/**
+ * Whether `db` talks to MySQL.
+ *
+ * Read from the dialect's adapter rather than configured, so a store handed any
+ * Kysely instance (or an open transaction) answers for the engine it will
+ * actually run against.
+ */
+export const isMysql = (db) => db.getExecutor().adapter instanceof MysqlAdapter;
+/** In an upsert's update set: take the value the insert proposed for this column. */
+export const INSERTED = Symbol('inserted');
+/**
+ * Insert, leaving an existing row alone when `conflictColumns` already match one.
+ *
+ * Postgres and sqlite spell this `on conflict do nothing`. MySQL has no such
+ * clause; `insert ignore` is the closest, and unlike `on conflict (cols)` it
+ * also swallows other row errors, so it is only used where the conflict target
+ * is the table's key.
+ */
+export const insertOrIgnore = (db, query, conflictColumns) => isMysql(db)
+    ? query.ignore()
+    : query.onConflict((oc) => conflictColumns
+        ? oc.columns(conflictColumns).doNothing()
+        : oc.doNothing());
+/**
+ * Insert, or update the row `conflictColumns` match.
+ *
+ * `set` maps column to the new value, or to `INSERTED` for "whatever this
+ * insert carried" — `excluded.col` on postgres and sqlite, `values(col)` on
+ * MySQL, which has no `excluded`.
+ */
+export const upsert = (db, query, conflictColumns, set) => {
+    if (isMysql(db)) {
+        return query.onDuplicateKeyUpdate((eb) => Object.fromEntries(Object.entries(set).map(([column, value]) => [
+            column,
+            value === INSERTED ? eb.fn('values', [eb.ref(column)]) : value,
+        ])));
+    }
+    return query.onConflict((oc) => oc
+        .columns(conflictColumns)
+        .doUpdateSet((eb) => Object.fromEntries(Object.entries(set).map(([column, value]) => [
+        column,
+        value === INSERTED ? eb.ref(`excluded.${column}`) : value,
+    ]))));
+};
+/**
+ * A moment as a `timestamp` column's parameter.
+ *
+ * An ISO 8601 string with its trailing `Z` is accepted by postgres and stored
+ * as written by sqlite, but MySQL refuses it for a `TIMESTAMP` column
+ * (`Incorrect datetime value`). The driver formats a `Date` for MySQL itself,
+ * so that is what it is given.
+ */
+export const timestampParam = (db, at = new Date()) => isMysql(db) ? at : at.toISOString();

package/dist/src/kysely-virtual-user-run-store.d.ts

@@ -17,7 +17,7 @@ export declare class KyselyVirtualUserRunStore implements VirtualUserRunStore {
     fail(runId: string, error: string): Promise<void>;
     get(runId: string): Promise<VirtualUserRunRecord | null>;
     list(options?: {
-        persona?: string;
+        virtualUserId?: string;
         limit?: number;
         offset?: number;
     }): Promise<VirtualUserRunRecord[]>;

package/dist/src/kysely-virtual-user-run-store.js

@@ -1,7 +1,7 @@
-import { randomUUID } from 'node:crypto';
 import { parseJson } from './kysely-json.js';
 import { requirePikkuSchema } from './schema/index.js';
 import { virtualUserSchema } from './schema/virtual-user.schema.js';
+import { timestampParam } from './kysely-upsert.js';
 /**
  * Records virtual-user runs in a `virtualUserRun` table.
  *
@@ -49,12 +49,12 @@ export class KyselyVirtualUserRunStore {
     }
     async start(run) {
         await this.init();
-        const runId = randomUUID();
+        const runId = globalThis.crypto.randomUUID();
         await this.db
             .insertInto('virtualUserRun')
             .values({
             runId,
-            persona: run.persona,
+            virtualUserId: run.virtualUserId,
             disposition: run.disposition,
             // Text on every engine (see the schema), so the seed round-trips
             // through drivers that hand a BIGINT back as a string.
@@ -81,7 +81,7 @@ export class KyselyVirtualUserRunStore {
             memory: JSON.stringify(outcome.memory),
             intents: JSON.stringify(outcome.intents),
             stoppedBy: outcome.stoppedBy,
-            finishedAt: new Date().toISOString(),
+            finishedAt: timestampParam(this.db),
         })
             .where('runId', '=', runId)
             .executeTakeFirst();
@@ -98,7 +98,7 @@ export class KyselyVirtualUserRunStore {
             .set({
             status: 'failed',
             error,
-            finishedAt: new Date().toISOString(),
+            finishedAt: timestampParam(this.db),
         })
             .where('runId', '=', runId)
             .execute();
@@ -115,8 +115,8 @@ export class KyselyVirtualUserRunStore {
     async list(options) {
         await this.init();
         let query = this.db.selectFrom('virtualUserRun').selectAll();
-        if (options?.persona) {
-            query = query.where('persona', '=', options.persona);
+        if (options?.virtualUserId) {
+            query = query.where('virtualUserId', '=', options.virtualUserId);
         }
         const rows = await query
             .orderBy('createdAt', 'desc')
@@ -179,7 +179,7 @@ export class KyselyVirtualUserRunStore {
     toRecord(row) {
         return {
             runId: row.runId,
-            persona: row.persona,
+            virtualUserId: row.virtualUserId,
             disposition: row.disposition,
             seed: Number(row.seed),
             status: row.status,

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

@@ -2,7 +2,7 @@ import type { Kysely } from 'kysely';
 import type { VirtualUserScheduleInput, VirtualUserScheduleRecord, VirtualUserScheduleStore } from '@pikku/core/virtual-user';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 /**
- * Keeps each persona's cadence in a `virtualUserSchedule` table.
+ * Keeps each virtual user'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
@@ -19,15 +19,15 @@ export declare class KyselyVirtualUserScheduleStore implements VirtualUserSchedu
     constructor(db: Kysely<KyselyPikkuDB>);
     init(): Promise<void>;
     set(schedule: VirtualUserScheduleInput): Promise<VirtualUserScheduleRecord>;
-    get(persona: string): Promise<VirtualUserScheduleRecord | null>;
+    get(virtualUserId: string): Promise<VirtualUserScheduleRecord | null>;
     list(): Promise<VirtualUserScheduleRecord[]>;
     due(now: Date): Promise<VirtualUserScheduleRecord[]>;
-    claim(persona: string, claim: {
+    claim(virtualUserId: string, claim: {
         from: Date;
         nextRunAt: Date;
         runId: string | null;
         at: Date;
     }): Promise<boolean>;
-    remove(persona: string): Promise<void>;
+    remove(virtualUserId: string): Promise<void>;
     private toRecord;
 }

package/dist/src/kysely-virtual-user-schedule-store.js

@@ -1,9 +1,10 @@
 import { DEFAULT_MAX_INTERVAL_MS, DEFAULT_MIN_INTERVAL_MS, } from '@pikku/core/virtual-user';
 import { parseJson } from './kysely-json.js';
 import { requirePikkuSchema } from './schema/index.js';
+import { upsert } from './kysely-upsert.js';
 import { virtualUserScheduleSchema } from './schema/virtual-user-schedule.schema.js';
 /**
- * Keeps each persona's cadence in a `virtualUserSchedule` table.
+ * Keeps each virtual user'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
@@ -31,9 +32,9 @@ export class KyselyVirtualUserScheduleStore {
         // 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 existing = await this.get(schedule.virtualUserId);
         const merged = {
-            persona: schedule.persona,
+            virtualUserId: schedule.virtualUserId,
             enabled: schedule.enabled ?? existing?.enabled ?? false,
             disposition: schedule.disposition ?? existing?.disposition ?? 'realistic',
             goals: [...(schedule.goals ?? existing?.goals ?? [])],
@@ -53,7 +54,7 @@ export class KyselyVirtualUserScheduleStore {
             lastRunAt: existing?.lastRunAt ?? null,
         };
         const values = {
-            persona: merged.persona,
+            virtualUserId: merged.virtualUserId,
             enabled: merged.enabled ? 1 : 0,
             disposition: merged.disposition,
             goals: JSON.stringify(merged.goals),
@@ -62,10 +63,7 @@ export class KyselyVirtualUserScheduleStore {
             maxIntervalMs: String(merged.maxIntervalMs),
             nextRunAt: merged.nextRunAt.toISOString(),
         };
-        await this.db
-            .insertInto('virtualUserSchedule')
-            .values(values)
-            .onConflict((oc) => oc.column('persona').doUpdateSet({
+        await upsert(this.db, this.db.insertInto('virtualUserSchedule').values(values), ['virtualUserId'], {
             enabled: values.enabled,
             disposition: values.disposition,
             goals: values.goals,
@@ -73,16 +71,15 @@ export class KyselyVirtualUserScheduleStore {
             minIntervalMs: values.minIntervalMs,
             maxIntervalMs: values.maxIntervalMs,
             nextRunAt: values.nextRunAt,
-        }))
-            .execute();
+        }).execute();
         return merged;
     }
-    async get(persona) {
+    async get(virtualUserId) {
         await this.init();
         const row = await this.db
             .selectFrom('virtualUserSchedule')
             .selectAll()
-            .where('persona', '=', persona)
+            .where('virtualUserId', '=', virtualUserId)
             .executeTakeFirst();
         return row ? this.toRecord(row) : null;
     }
@@ -91,7 +88,7 @@ export class KyselyVirtualUserScheduleStore {
         const rows = await this.db
             .selectFrom('virtualUserSchedule')
             .selectAll()
-            .orderBy('persona', 'asc')
+            .orderBy('virtualUserId', 'asc')
             .execute();
         return rows.map((row) => this.toRecord(row));
     }
@@ -106,35 +103,35 @@ export class KyselyVirtualUserScheduleStore {
             .execute();
         return rows.map((row) => this.toRecord(row));
     }
-    async claim(persona, claim) {
+    async claim(virtualUserId, claim) {
         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.
+            // not blank out which run this virtual user last managed to start.
             ...(claim.runId
                 ? { lastRunId: claim.runId, lastRunAt: claim.at.toISOString() }
                 : {}),
         })
-            .where('persona', '=', persona)
+            .where('virtualUserId', '=', virtualUserId)
             // 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) {
+    async remove(virtualUserId) {
         await this.init();
         await this.db
             .deleteFrom('virtualUserSchedule')
-            .where('persona', '=', persona)
+            .where('virtualUserId', '=', virtualUserId)
             .execute();
     }
     toRecord(row) {
         return {
-            persona: row.persona,
+            virtualUserId: row.virtualUserId,
             enabled: Boolean(row.enabled),
             disposition: row.disposition,
             goals: parseJson(row.goals) ?? [],

package/dist/src/kysely-workflow-mirror.js

@@ -1,4 +1,5 @@
 import { requirePikkuSchema } from './schema/index.js';
+import { insertOrIgnore } from './kysely-upsert.js';
 import { workflowSchema } from './schema/workflow.schema.js';
 /**
  * Kysely-backed `WorkflowRunMirror`.
@@ -181,7 +182,7 @@ export class KyselyWorkflowMirror {
             source,
             status,
         })
-            .onConflict((oc) => oc.columns(['workflowName', 'graphHash']).doNothing())
+            .$call((q) => insertOrIgnore(this.db, q, ['workflowName', 'graphHash']))
             .execute();
     }
     async updateWorkflowVersionStatus(name, graphHash, status) {

package/dist/src/kysely-workflow-service.js

@@ -4,6 +4,7 @@ import { appNowMs, leaseUntil } from './kysely-lease-clock.js';
 import { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
 import { parseJson } from './kysely-json.js';
 import { requirePikkuSchema } from './schema/index.js';
+import { insertOrIgnore, isMysql } from './kysely-upsert.js';
 import { workflowSchema } from './schema/workflow.schema.js';
 /**
  * What a step read returns, one list for the single read and the whole-run
@@ -590,6 +591,9 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
      * @param json - The value as JSON text
      */
     jsonSetState(path, json) {
+        if (isMysql(this.db)) {
+            return sql `JSON_SET(COALESCE(state, '{}'), ${path}, CAST(${json} AS JSON))`;
+        }
         return sql `json_set(coalesce(state, '{}'), ${path}, json(${json}))`;
     }
     /**
@@ -698,7 +702,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             source,
             status: status ?? 'active',
         })
-            .onConflict((oc) => oc.columns(['workflowName', 'graphHash']).doNothing())
+            .$call((q) => insertOrIgnore(this.db, q, ['workflowName', 'graphHash']))
             .execute();
     }
     async updateWorkflowVersionStatusImpl(name, graphHash, status) {