@pikku/kysely 0.13.33 → 0.13.34

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 0.13.34
+
+### Patch Changes
+
+- 80c94f9: MySQL is a third dialect for the `pikku db` commands, beside sqlite and postgres.
+
+  Set `mysqlUrl` in `createConfig` and `db migrate`, `generate`, `check`, `baseline`, `reset`, `codegen` and the dev seed behave as they do elsewhere, with migrations in `db/mysql/` and the seed in `db/mysql-dev-seed.sql`. MySQL has no embedded engine, so a command that needs a throwaway database creates and drops a `pikku_scratch_<hex>` one on your server — the account needs `CREATE` and `DROP`. DDL is not transactional there, so a migration that fails halfway is replayed from the top. `db.schema` is refused, because a MySQL schema is a database.
+
+  `@pikku/migrator-sql` gains `@pikku/migrator-sql/mysql`. The runtime schemas in `@pikku/kysely` now compile for MySQL without changing what sqlite and postgres get: keys are `varchar(255)`, free text is `longtext`, literal text defaults are expressions, and foreign keys are table-level constraints, because MySQL parses an inline `REFERENCES` and silently drops it. A foreign key onto a column another source owns takes that column's full type (`varchar(36)`), not the bare `varchar` the introspector reports.
+
+  An addon that ships `db/mysql` migrations needs `db.mysqlUrl` in its `pikku.config.json` for `pikku all` to publish them. The standalone bundle does not support MySQL yet and refuses a MySQL project by name.
+
+- Updated dependencies [149faae]
+  - @pikku/core@0.12.136
+
 ## 0.13.33
 
 ### Patch Changes

package/dist/src/kysely-workflow-service.d.ts

@@ -23,6 +23,11 @@ export declare class KyselyWorkflowService extends PikkuWorkflowService {
     protected listStepStates(runId: string): Promise<Array<StepState & {
         stepName: string;
     }>>;
+    getRunSteps(runId: string): Promise<Array<StepState & {
+        stepName: string;
+        rpcName?: string;
+        data?: any;
+    }>>;
     getRunHistory(runId: string): Promise<Array<StepState & {
         stepName: string;
     }>>;

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

@@ -147,6 +147,9 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .execute();
         return rows.map((row) => ({ ...toStepState(row), stepName: row.stepName }));
     }
+    async getRunSteps(runId) {
+        return this.runService.getRunSteps(runId);
+    }
     async getRunHistory(runId) {
         return this.runService.getRunHistory(runId);
     }

package/dist/src/schema/agent.schema.js

@@ -13,89 +13,96 @@ export const agentSchema = {
     name: 'agent',
     ownedBy: ['agentStorage', 'agentRunState', 'agentRunService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('agentThreads')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
             .addColumn('resourceId', 'varchar(255)', (col) => col.notNull())
-            .addColumn('title', 'text')
-            .addColumn('metadata', 'text')
+            .addColumn('title', ctx.text)
+            .addColumn('metadata', ctx.text)
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_agent_threads_resource')
             .on('agentThreads')
             .column('resourceId'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('agentMessage')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('agentThreads.id').onDelete('cascade'))
+            .addColumn('threadId', 'varchar(36)', (col) => ctx.references(col.notNull(), 'agentThreads.id'))
             .addColumn('role', 'varchar(50)', (col) => col.notNull())
-            .addColumn('content', 'text')
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+            .addColumn('content', ctx.text)
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .$call(ctx.foreignKeys('agentMessage', { threadId: 'agentThreads.id' })),
+        (db, _types, ctx) => db.schema
             .createIndex('idx_agent_message_thread')
             .on('agentMessage')
             .columns(['threadId', 'createdAt']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('agentToolCall')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('agentThreads.id').onDelete('cascade'))
-            .addColumn('messageId', 'varchar(36)', (col) => col.notNull().references('agentMessage.id').onDelete('cascade'))
+            .addColumn('threadId', 'varchar(36)', (col) => ctx.references(col.notNull(), 'agentThreads.id'))
+            .addColumn('messageId', 'varchar(36)', (col) => ctx.references(col.notNull(), 'agentMessage.id'))
             .addColumn('runId', 'varchar(36)')
             .addColumn('toolName', 'varchar(255)', (col) => col.notNull())
-            .addColumn('args', 'text', (col) => col.notNull())
-            .addColumn('result', 'text')
+            .addColumn('args', ctx.text, (col) => col.notNull())
+            .addColumn('result', ctx.text)
             .addColumn('approvalStatus', 'varchar(50)')
             .addColumn('approvalType', 'varchar(50)')
             .addColumn('agentRunId', 'varchar(36)')
             .addColumn('displayToolName', 'varchar(255)')
-            .addColumn('displayArgs', 'text')
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+            .addColumn('displayArgs', ctx.text)
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .$call(ctx.foreignKeys('agentToolCall', {
+            threadId: 'agentThreads.id',
+            messageId: 'agentMessage.id',
+        })),
+        (db, _types, ctx) => db.schema
             .createIndex('idx_agent_tool_call_thread')
             .on('agentToolCall')
             .column('threadId'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_agent_tool_call_message')
             .on('agentToolCall')
             .column('messageId'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('agentWorkingMemory')
             .addColumn('id', 'varchar(255)', (col) => col.notNull())
             .addColumn('scope', 'varchar(50)', (col) => col.notNull())
-            .addColumn('data', 'text', (col) => col.notNull())
+            .addColumn('data', ctx.text, (col) => col.notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addPrimaryKeyConstraint('agent_working_memory_pk', ['id', 'scope']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('agentRun')
             .addColumn('runId', 'varchar(36)', (col) => col.primaryKey())
             .addColumn('agentName', 'varchar(255)', (col) => col.notNull())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('agentThreads.id').onDelete('cascade'))
+            .addColumn('threadId', 'varchar(36)', (col) => ctx.references(col.notNull(), 'agentThreads.id'))
             .addColumn('resourceId', 'varchar(255)', (col) => col.notNull())
-            .addColumn('status', 'varchar(50)', (col) => col.notNull().defaultTo('running'))
-            .addColumn('errorMessage', 'text')
-            .addColumn('suspendReason', 'text')
-            .addColumn('missingRpcs', 'text')
-            .addColumn('pendingApprovals', 'text')
+            .addColumn('status', 'varchar(50)', (col) => col.notNull().defaultTo(ctx.defaultText('running')))
+            .addColumn('errorMessage', ctx.text)
+            .addColumn('suspendReason', ctx.text)
+            .addColumn('missingRpcs', ctx.text)
+            .addColumn('pendingApprovals', ctx.text)
             .addColumn('usageInputTokens', 'integer', (col) => col.notNull().defaultTo(0))
             .addColumn('usageOutputTokens', 'integer', (col) => col.notNull().defaultTo(0))
-            .addColumn('usageModel', 'varchar(255)', (col) => col.notNull().defaultTo(''))
+            .addColumn('usageModel', 'varchar(255)', (col) => col.notNull().defaultTo(ctx.defaultText('')))
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .$call(ctx.foreignKeys('agentRun', { threadId: 'agentThreads.id' })),
+        (db, _types, ctx) => db.schema
             .createIndex('idx_agent_run_thread')
             .on('agentRun')
             .columns(['threadId', 'createdAt']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('agentRunScore')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('runId', 'varchar(36)', (col) => col.notNull().references('agentRun.runId').onDelete('cascade'))
+            .addColumn('runId', 'varchar(36)', (col) => ctx.references(col.notNull(), 'agentRun.runId'))
             .addColumn('scorerName', 'varchar(255)', (col) => col.notNull())
             .addColumn('score', 'real', (col) => col.notNull())
-            .addColumn('reason', 'text')
-            .addColumn('metadata', 'text')
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+            .addColumn('reason', ctx.text)
+            .addColumn('metadata', ctx.text)
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .$call(ctx.foreignKeys('agentRunScore', { runId: 'agentRun.runId' })),
+        (db, _types, ctx) => db.schema
             .createIndex('idx_agent_run_score_run')
             .on('agentRunScore')
             .columns(['runId', 'createdAt']),

package/dist/src/schema/analytics.schema.js

@@ -17,30 +17,30 @@ export const analyticsSchema = {
     name: 'analytics',
     ownedBy: ['analyticsService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuAnalyticsEvents')
-            .addColumn('eventId', 'text', (col) => col.primaryKey())
-            .addColumn('name', 'text', (col) => col.notNull())
-            .addColumn('occurredAt', 'text', (col) => col.notNull())
-            .addColumn('source', 'text', (col) => col.notNull())
-            .addColumn('functionId', 'text')
-            .addColumn('wireType', 'text')
-            .addColumn('traceId', 'text')
-            .addColumn('userId', 'text')
-            .addColumn('orgId', 'text')
-            .addColumn('pikkuUserId', 'text')
+            .addColumn('eventId', ctx.key, (col) => col.primaryKey())
+            .addColumn('name', ctx.key, (col) => col.notNull())
+            .addColumn('occurredAt', ctx.key, (col) => col.notNull())
+            .addColumn('source', ctx.text, (col) => col.notNull())
+            .addColumn('functionId', ctx.text)
+            .addColumn('wireType', ctx.text)
+            .addColumn('traceId', ctx.text)
+            .addColumn('userId', ctx.text)
+            .addColumn('orgId', ctx.text)
+            .addColumn('pikkuUserId', ctx.text)
             // The device id for a visitor with no session. Its own column beside
             // `userId` and not folded into it: the whole point of the anonymous id
             // is the traffic that has no user to be attributed to yet.
-            .addColumn('anonymousId', 'text')
-            .addColumn('vendorIds', 'text')
-            .addColumn('consent', 'text')
-            .addColumn('props', 'text'),
-        (db) => db.schema
+            .addColumn('anonymousId', ctx.text)
+            .addColumn('vendorIds', ctx.text)
+            .addColumn('consent', ctx.text)
+            .addColumn('props', ctx.text),
+        (db, _types, ctx) => db.schema
             .createIndex('idx_pikku_analytics_events_occurred_at')
             .on('pikkuAnalyticsEvents')
             .column('occurredAt'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_pikku_analytics_events_name')
             .on('pikkuAnalyticsEvents')
             .column('name'),

package/dist/src/schema/audit.schema.js

@@ -17,33 +17,33 @@ export const auditSchema = {
     name: 'audit',
     ownedBy: ['audit', 'auditLog'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('audit')
-            .addColumn('auditId', 'text', (col) => col.primaryKey())
-            .addColumn('occurredAt', 'text', (col) => col.notNull())
-            .addColumn('type', 'text', (col) => col.notNull())
-            .addColumn('source', 'text', (col) => col.defaultTo('auto').notNull())
-            .addColumn('outcome', 'text')
-            .addColumn('functionId', 'text')
-            .addColumn('wireType', 'text')
-            .addColumn('traceId', 'text')
-            .addColumn('transactionId', 'text')
-            .addColumn('queryId', 'text')
-            .addColumn('userId', 'text')
-            .addColumn('orgId', 'text')
-            .addColumn('pikkuUserId', 'text')
-            .addColumn('tables', 'text')
-            .addColumn('changedCols', 'text')
-            .addColumn('event', 'text')
-            .addColumn('old', 'text')
-            .addColumn('data', 'text'),
+            .addColumn('auditId', ctx.key, (col) => col.primaryKey())
+            .addColumn('occurredAt', ctx.key, (col) => col.notNull())
+            .addColumn('type', ctx.key, (col) => col.notNull())
+            .addColumn('source', ctx.text, (col) => col.defaultTo(ctx.defaultText('auto')).notNull())
+            .addColumn('outcome', ctx.text)
+            .addColumn('functionId', ctx.text)
+            .addColumn('wireType', ctx.text)
+            .addColumn('traceId', ctx.text)
+            .addColumn('transactionId', ctx.text)
+            .addColumn('queryId', ctx.text)
+            .addColumn('userId', ctx.key)
+            .addColumn('orgId', ctx.text)
+            .addColumn('pikkuUserId', ctx.text)
+            .addColumn('tables', ctx.text)
+            .addColumn('changedCols', ctx.text)
+            .addColumn('event', ctx.text)
+            .addColumn('old', ctx.text)
+            .addColumn('data', ctx.text),
         // The trail is only ever read newest-first, and the two filters the console
         // offers are user and type.
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_audit_occurred_at')
             .on('audit')
             .column('occurredAt'),
-        (db) => db.schema.createIndex('idx_audit_user_id').on('audit').column('userId'),
-        (db) => db.schema.createIndex('idx_audit_type').on('audit').column('type'),
+        (db, _types, ctx) => db.schema.createIndex('idx_audit_user_id').on('audit').column('userId'),
+        (db, _types, ctx) => db.schema.createIndex('idx_audit_type').on('audit').column('type'),
     ],
 };

package/dist/src/schema/channel.schema.js

@@ -4,22 +4,25 @@ export const channelSchema = {
     name: 'channel',
     ownedBy: ['channelStore', 'eventHub'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('channels')
-            .addColumn('channelId', 'text', (col) => col.primaryKey())
-            .addColumn('channelName', 'text', (col) => col.notNull())
+            .addColumn('channelId', ctx.key, (col) => col.primaryKey())
+            .addColumn('channelName', ctx.text, (col) => col.notNull())
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('openingData', 'text', (col) => col.notNull().defaultTo('{}'))
-            .addColumn('pikkuUserId', 'text')
-            .addColumn('state', 'text')
+            .addColumn('openingData', ctx.text, (col) => col.notNull().defaultTo(ctx.defaultText('{}')))
+            .addColumn('pikkuUserId', ctx.text)
+            .addColumn('state', ctx.text)
             .addColumn('lastWire', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('channelSubscriptions')
-            .addColumn('channelId', 'text', (col) => col.notNull().references('channels.channelId').onDelete('cascade'))
-            .addColumn('topic', 'text', (col) => col.notNull())
+            .addColumn('channelId', ctx.key, (col) => ctx.references(col.notNull(), 'channels.channelId'))
+            .addColumn('topic', ctx.key, (col) => col.notNull())
             .addPrimaryKeyConstraint('channel_subscriptions_pk', [
             'channelId',
             'topic',
-        ]),
+        ])
+            .$call(ctx.foreignKeys('channelSubscriptions', {
+            channelId: 'channels.channelId',
+        })),
     ],
 };

package/dist/src/schema/credential.schema.js

@@ -14,22 +14,22 @@ export const credentialSchema = {
     name: 'credential',
     ownedBy: ['credentialService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('credentials')
             .addColumn('name', 'varchar(255)', (col) => col.notNull())
             .addColumn('userId', 'varchar(255)')
-            .addColumn('ciphertext', 'text', (col) => col.notNull())
-            .addColumn('wrappedDek', 'text', (col) => col.notNull())
+            .addColumn('ciphertext', ctx.text, (col) => col.notNull())
+            .addColumn('wrappedDek', ctx.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()),
-        rawStatement(({ table }) => sql `CREATE UNIQUE INDEX credentials_name_user_id_unique ON ${table('credentials')} (name, COALESCE(user_id, ''))`),
-        (db) => db.schema
+        rawStatement(({ table, mysql }) => sql `CREATE UNIQUE INDEX credentials_name_user_id_unique ON ${table('credentials')} (name, ${mysql ? sql `(COALESCE(user_id, ''))` : sql `COALESCE(user_id, '')`})`),
+        (db, _types, ctx) => db.schema
             .createTable('credentialKekSalts')
             .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
+        (db, _types, ctx) => db.schema
             .createTable('credentialsAudit')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
             .addColumn('credentialName', 'varchar(255)', (col) => col.notNull())

package/dist/src/schema/deployment.schema.js

@@ -3,28 +3,28 @@ import { sql } from 'kysely';
 export const deploymentSchema = {
     name: 'deployment',
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuDeployments')
-            .addColumn('deploymentId', 'text', (col) => col.primaryKey())
-            .addColumn('endpoint', 'text', (col) => col.notNull())
+            .addColumn('deploymentId', ctx.key, (col) => col.primaryKey())
+            .addColumn('endpoint', ctx.text, (col) => col.notNull())
             .addColumn('lastHeartbeat', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuDeploymentFunctions')
-            .addColumn('deploymentId', 'text', (col) => col
-            .notNull()
-            .references('pikkuDeployments.deploymentId')
-            .onDelete('cascade'))
-            .addColumn('functionName', 'text', (col) => col.notNull())
+            .addColumn('deploymentId', ctx.key, (col) => ctx.references(col.notNull(), 'pikkuDeployments.deploymentId'))
+            .addColumn('functionName', ctx.key, (col) => col.notNull())
             .addPrimaryKeyConstraint('pikku_deployment_functions_pk', [
             'deploymentId',
             'functionName',
-        ]),
-        (db) => db.schema
+        ])
+            .$call(ctx.foreignKeys('pikkuDeploymentFunctions', {
+            deploymentId: 'pikkuDeployments.deploymentId',
+        })),
+        (db, _types, ctx) => db.schema
             .createIndex('idx_pikku_deployments_heartbeat')
             .on('pikkuDeployments')
             .column('lastHeartbeat'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_pikku_deployment_functions_name')
             .on('pikkuDeploymentFunctions')
             .column('functionName'),

package/dist/src/schema/flag.schema.js

@@ -17,14 +17,14 @@ export const flagSchema = {
     name: 'flag',
     ownedBy: ['featureFlags'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuFeatureFlags')
-            .addColumn('name', 'text', (col) => col.primaryKey())
-            .addColumn('description', 'text')
+            .addColumn('name', ctx.key, (col) => col.primaryKey())
+            .addColumn('description', ctx.text)
             // The declared `anyOf` scope list, as JSON. Read by the console to say
             // who would see the feature; never read on the request path, where the
             // capability half comes from the session's own scopes.
-            .addColumn('anyOf', 'text')
+            .addColumn('anyOf', ctx.text)
             // Off until somebody turns it on. A flag exists so a feature can ship
             // dark, so the row a deploy creates has to start closed — the opposite
             // default would make merging the declaration the moment of launch.
@@ -37,26 +37,29 @@ export const flagSchema = {
             // longer offered, awaiting `pikku flags prune`. The same additive
             // contract as `pikkuScopes.declared`.
             .addColumn('declared', 'boolean', (col) => col.defaultTo(true).notNull())
-            .addColumn('updatedBy', 'text')
+            .addColumn('updatedBy', ctx.text)
             // Why it was flipped. A kill switch is pulled during an incident, and
             // the one question afterwards is always who turned it off and why.
-            .addColumn('note', 'text')
+            .addColumn('note', ctx.text)
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuFeatureFlagOverrides')
-            .addColumn('flag', 'text', (col) => col.notNull().references('pikkuFeatureFlags.name').onDelete('cascade'))
-            .addColumn('subjectId', 'text', (col) => col.notNull())
+            .addColumn('flag', ctx.key, (col) => ctx.references(col.notNull(), 'pikkuFeatureFlags.name'))
+            .addColumn('subjectId', ctx.key, (col) => col.notNull())
             // Which id this is, for the console to render. Resolution keys on the
             // id alone, because that is all the resolver has: it prefers the
             // organization and falls back to the user, and by then the two are one
             // string.
-            .addColumn('subjectKind', 'text', (col) => col.notNull())
+            .addColumn('subjectKind', ctx.text, (col) => col.notNull())
             .addColumn('enabled', 'boolean', (col) => col.notNull())
-            .addColumn('grantedBy', 'text')
+            .addColumn('grantedBy', ctx.text)
             .addColumn('grantedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addPrimaryKeyConstraint('pikku_feature_flag_overrides_pk', [
             'flag',
             'subjectId',
-        ]),
+        ])
+            .$call(ctx.foreignKeys('pikkuFeatureFlagOverrides', {
+            flag: 'pikkuFeatureFlags.name',
+        })),
     ],
 };

package/dist/src/schema/incoming-webhook.schema.js

@@ -4,15 +4,15 @@ export const incomingWebhookSchema = {
     name: 'incoming-webhook',
     ownedBy: ['incomingWebhookService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('webhookReceipt')
-            .addColumn('receiptId', 'text', (col) => col.primaryKey())
-            .addColumn('source', 'text', (col) => col.notNull())
-            .addColumn('event', 'text', (col) => col.notNull())
-            .addColumn('providerEventId', 'text')
-            .addColumn('status', 'text', (col) => col.defaultTo('pending').notNull())
+            .addColumn('receiptId', ctx.key, (col) => col.primaryKey())
+            .addColumn('source', ctx.key, (col) => col.notNull())
+            .addColumn('event', ctx.key, (col) => col.notNull())
+            .addColumn('providerEventId', ctx.key)
+            .addColumn('status', ctx.text, (col) => col.defaultTo(ctx.defaultText('pending')).notNull())
             .addColumn('attempts', 'integer', (col) => col.defaultTo(0).notNull())
-            .addColumn('lastError', 'text')
+            .addColumn('lastError', ctx.text)
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('deliveredAt', 'timestamp'),
         (db) => db.schema

package/dist/src/schema/index.js

@@ -1,4 +1,4 @@
-import { CamelCasePlugin } from 'kysely';
+import { CamelCasePlugin, sql } from 'kysely';
 import { schemaContext, } from './pikku-schema.types.js';
 import { agentSchema } from './agent.schema.js';
 import { analyticsSchema } from './analytics.schema.js';
@@ -102,10 +102,30 @@ const bind = (db) => db.withPlugin(new CamelCasePlugin());
  * connection they are handed. A caller that had to remember to say the schema
  * twice would eventually say it once.
  */
-const boundSchema = (db) => CREATE_TABLE.exec(db.schema.createTable('pikkuSchemaProbe').addColumn('id', 'text').compile()
-    .sql)?.[1];
-/** The context for statements compiled against `db`, matching its binding. */
-const contextFor = (db) => schemaContext(boundSchema(db));
+const probe = (db) => db.schema.createTable('pikkuSchemaProbe').addColumn('id', 'text').compile()
+    .sql;
+/**
+ * The context for statements compiled against `db`, matching its binding and
+ * its dialect — MySQL is recognised by the backtick it quotes with.
+ */
+const contextFor = (db) => {
+    const sql = probe(db);
+    return schemaContext(CREATE_TABLE.exec(sql)?.[1], {
+        mysql: sql.includes('`'),
+    });
+};
+/**
+ * A MySQL column's full declared type — `varchar(36)`, not the `varchar` the
+ * introspector reports. The length is part of the type a foreign key has to
+ * match, and a bare `varchar` is not a type MySQL accepts.
+ */
+const mysqlColumnType = async (db, table, column) => {
+    const { rows } = await sql `
+    select column_type as type from information_schema.columns
+    where table_schema = database() and table_name = ${table} and column_name = ${column}
+  `.execute(db);
+    return rows[0].type;
+};
 /**
  * Look up every prerequisite in `db`, reporting the gaps and the types found.
  *
@@ -122,6 +142,7 @@ export const resolveRequirements = async (db, schemas = pikkuSchemas) => {
         table.name,
         table,
     ]));
+    const mysql = contextFor(bind(db)).mysql;
     const types = {};
     const unmet = [];
     for (const schema of schemas) {
@@ -133,7 +154,9 @@ export const resolveRequirements = async (db, schemas = pikkuSchemas) => {
                 unmet.push({ schema, requirement });
             }
             else {
-                types[`${requirement.table}.${requirement.column}`] = column.dataType;
+                types[`${requirement.table}.${requirement.column}`] = mysql
+                    ? await mysqlColumnType(db, requirement.table, requirement.column)
+                    : column.dataType;
             }
         }
     }
@@ -234,7 +257,7 @@ const displayName = (table) => table.schema ? `${table.schema}.${table.name}` :
  * identifier — matching the first one instead reads a `withSchema('app')`
  * connection's DDL as a table called `app`, which is no table at all.
  */
-const CREATE_TABLE = /^\s*create table (?:if not exists\s+)?(?:"([^"]+)"\.)?"([^"]+)"/i;
+const CREATE_TABLE = /^\s*create table (?:if not exists\s+)?(?:["`]([^"`]+)["`]\.)?["`]([^"`]+)["`]/i;
 /**
  * The tables a schema creates, read back out of its own compiled SQL.
  *

package/dist/src/schema/lease.schema.js

@@ -2,10 +2,10 @@ export const leaseSchema = {
     name: 'lease',
     ownedBy: ['leaseService', 'workflowService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuLease')
-            .addColumn('key', 'text', (col) => col.primaryKey())
-            .addColumn('holder', 'text', (col) => col.notNull())
+            .addColumn('key', ctx.key, (col) => col.primaryKey())
+            .addColumn('holder', ctx.text, (col) => col.notNull())
             .addColumn('token', 'integer', (col) => col.notNull())
             .addColumn('expiresAt', 'bigint', (col) => col.notNull()),
     ],

package/dist/src/schema/pikku-schema.types.d.ts

@@ -1,4 +1,5 @@
-import { type CompiledQuery, type Kysely, type RawBuilder } from 'kysely';
+import { type ColumnDefinitionBuilder, type CompiledQuery, type CreateTableBuilder, type Kysely, type RawBuilder } from 'kysely';
+type DataTypeExpression = Parameters<CreateTableBuilder<any, any>['addColumn']>[1];
 /**
  * One DDL statement, bound to a database.
  *
@@ -21,6 +22,12 @@ export type SchemaStatementFactory = (db: Kysely<any>, types: RequiredTypes, ctx
  * statement that spells its own SQL has to spell the qualifier too.
  */
 export interface SchemaContext {
+    /**
+     * Whether the connection is MySQL, which is the one engine the declarations
+     * cannot spell the same way: it refuses a `TEXT` column in a key or with a
+     * literal default, and quotes with backticks.
+     */
+    mysql: boolean;
     /**
      * A table as the surrounding DDL addresses it: `"app"."credentials"` on a
      * schema-bound connection, `"credentials"` otherwise.
@@ -30,6 +37,36 @@ export interface SchemaContext {
      * physical names throughout and this is no exception.
      */
     table: (name: string) => RawBuilder<unknown>;
+    /**
+     * The type of a text column that is part of a key — primary, foreign, unique
+     * or indexed. `text` everywhere but MySQL, where a key needs a bounded type.
+     */
+    key: DataTypeExpression;
+    /**
+     * The type of free text of any length. `text` everywhere but MySQL, where
+     * `TEXT` stops at 64KB and these columns hold serialized state and payloads.
+     */
+    text: DataTypeExpression;
+    /**
+     * A literal default for a text column. MySQL refuses one on `TEXT`, so it
+     * takes the parenthesised expression form (8.0.13+); everywhere else the
+     * literal itself.
+     */
+    defaultText: (value: string) => string | RawBuilder<unknown>;
+    /**
+     * An inline `references ... on delete cascade` on a column.
+     *
+     * A no-op on MySQL, which parses an inline `REFERENCES` and discards it — the
+     * constraint never exists. There the same relationship is declared once, at
+     * table level, through `foreignKeys`.
+     */
+    references: (column: ColumnDefinitionBuilder, target: string) => ColumnDefinitionBuilder;
+    /**
+     * The table-level foreign keys MySQL needs in place of inline `references`,
+     * keyed by local column to `table.column` target. Identity everywhere else,
+     * where `references` has already done the work.
+     */
+    foreignKeys: (table: string, keys: Record<string, string>) => <T extends CreateTableBuilder<any, any>>(builder: T) => T;
 }
 /**
  * The `SchemaContext` for DDL that names no schema.
@@ -44,7 +81,9 @@ export declare const unqualifiedContext: SchemaContext;
  * Identifiers are quoted rather than interpolated bare so a schema named after
  * a reserved word still compiles.
  */
-export declare const schemaContext: (schema: string | undefined) => SchemaContext;
+export declare const schemaContext: (schema: string | undefined, options?: {
+    mysql?: boolean;
+}) => SchemaContext;
 /**
  * The physical types of the columns named in `requires`, keyed `table.column`.
  *
@@ -129,3 +168,4 @@ export interface SchemaRequirement {
  */
 export declare function rawStatement(fragment: RawBuilder<unknown>): SchemaStatementFactory;
 export declare function rawStatement(build: (ctx: SchemaContext) => RawBuilder<unknown>): SchemaStatementFactory;
+export {};

package/dist/src/schema/pikku-schema.types.js

@@ -1,22 +1,38 @@
-import { sql } from 'kysely';
+import { sql, } from 'kysely';
 /**
  * The `SchemaContext` for DDL that names no schema.
  *
  * The default everywhere a schema has not been asked for, which is every engine
  * but postgres and most postgres projects too.
  */
-export const unqualifiedContext = {
-    table: (name) => sql.raw(`"${name}"`),
-};
+export const unqualifiedContext = buildContext(undefined, false);
+function buildContext(schema, mysql) {
+    const quote = mysql ? '`' : '"';
+    const name = (table) => schema
+        ? `${quote}${schema}${quote}.${quote}${table}${quote}`
+        : `${quote}${table}${quote}`;
+    return {
+        mysql,
+        table: (table) => sql.raw(name(table)),
+        key: mysql ? sql.raw('varchar(255)') : 'text',
+        text: mysql ? sql.raw('longtext') : 'text',
+        defaultText: (value) => (mysql ? sql `(${sql.lit(value)})` : value),
+        references: (column, target) => mysql ? column : column.references(target).onDelete('cascade'),
+        foreignKeys: (table, keys) => (builder) => mysql
+            ? Object.entries(keys).reduce((acc, [column, target]) => {
+                const [targetTable, targetColumn] = target.split('.');
+                return acc.addForeignKeyConstraint(`${table}_${column}_fk`, [column], targetTable, [targetColumn], (fk) => fk.onDelete('cascade'));
+            }, builder)
+            : builder,
+    };
+}
 /**
  * A `SchemaContext` qualifying every table into `schema`.
  *
  * Identifiers are quoted rather than interpolated bare so a schema named after
  * a reserved word still compiles.
  */
-export const schemaContext = (schema) => schema
-    ? { table: (name) => sql.raw(`"${schema}"."${name}"`) }
-    : unqualifiedContext;
+export const schemaContext = (schema, options = {}) => buildContext(schema, options.mysql ?? false);
 /**
  * The declared type for a foreign key onto a column another source owns.
  *

package/dist/src/schema/scope.schema.js

@@ -21,15 +21,15 @@ export const scopeSchema = {
     ownedBy: ['scopeService'],
     requires: [{ table: 'user', column: 'id', owner: 'Better Auth' }],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuScopes')
-            .addColumn('name', 'text', (col) => col.primaryKey())
-            .addColumn('description', 'text')
+            .addColumn('name', ctx.key, (col) => col.primaryKey())
+            .addColumn('description', ctx.text)
             .addColumn('declared', 'boolean', (col) => col.defaultTo(true).notNull()),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuRoles')
-            .addColumn('name', 'text', (col) => col.primaryKey())
-            .addColumn('description', 'text')
+            .addColumn('name', ctx.key, (col) => col.primaryKey())
+            .addColumn('description', ctx.text)
             // Declared in code with `defineSystemRole` rather than composed by an
             // admin. What it buys is the refusals: a system role cannot be renamed,
             // re-scoped or deleted from the console, and a console role cannot be
@@ -43,30 +43,42 @@ export const scopeSchema = {
             // be able to cause.
             .addColumn('declared', 'boolean', (col) => col.defaultTo(true).notNull())
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuRoleScopes')
-            .addColumn('role', 'text', (col) => col.notNull().references('pikkuRoles.name').onDelete('cascade'))
-            .addColumn('scope', 'text', (col) => col.notNull().references('pikkuScopes.name').onDelete('cascade'))
-            .addPrimaryKeyConstraint('pikku_role_scopes_pk', ['role', 'scope']),
-        (db, types) => db.schema
+            .addColumn('role', ctx.key, (col) => ctx.references(col.notNull(), 'pikkuRoles.name'))
+            .addColumn('scope', ctx.key, (col) => ctx.references(col.notNull(), 'pikkuScopes.name'))
+            .addPrimaryKeyConstraint('pikku_role_scopes_pk', ['role', 'scope'])
+            .$call(ctx.foreignKeys('pikkuRoleScopes', {
+            role: 'pikkuRoles.name',
+            scope: 'pikkuScopes.name',
+        })),
+        (db, types, ctx) => db.schema
             .createTable('pikkuUserRole')
-            .addColumn('userId', requiredType(types, 'user', 'id'), (col) => col.notNull().references('user.id').onDelete('cascade'))
-            .addColumn('role', 'text', (col) => col.notNull().references('pikkuRoles.name').onDelete('cascade'))
-            .addColumn('grantedBy', 'text')
+            .addColumn('userId', requiredType(types, 'user', 'id'), (col) => ctx.references(col.notNull(), 'user.id'))
+            .addColumn('role', ctx.key, (col) => ctx.references(col.notNull(), 'pikkuRoles.name'))
+            .addColumn('grantedBy', ctx.text)
             .addColumn('grantedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('pikku_user_role_pk', ['userId', 'role']),
-        (db, types) => db.schema
+            .addPrimaryKeyConstraint('pikku_user_role_pk', ['userId', 'role'])
+            .$call(ctx.foreignKeys('pikkuUserRole', {
+            userId: 'user.id',
+            role: 'pikkuRoles.name',
+        })),
+        (db, types, ctx) => db.schema
             .createTable('pikkuUserScope')
-            .addColumn('userId', requiredType(types, 'user', 'id'), (col) => col.notNull().references('user.id').onDelete('cascade'))
-            .addColumn('scope', 'text', (col) => col.notNull().references('pikkuScopes.name').onDelete('cascade'))
-            .addColumn('grantedBy', 'text')
+            .addColumn('userId', requiredType(types, 'user', 'id'), (col) => ctx.references(col.notNull(), 'user.id'))
+            .addColumn('scope', ctx.key, (col) => ctx.references(col.notNull(), 'pikkuScopes.name'))
+            .addColumn('grantedBy', ctx.text)
             .addColumn('grantedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('pikku_user_scope_pk', ['userId', 'scope']),
-        (db) => db.schema
+            .addPrimaryKeyConstraint('pikku_user_scope_pk', ['userId', 'scope'])
+            .$call(ctx.foreignKeys('pikkuUserScope', {
+            userId: 'user.id',
+            scope: 'pikkuScopes.name',
+        })),
+        (db, _types, ctx) => db.schema
             .createIndex('pikku_role_scopes_scope_idx')
             .on('pikkuRoleScopes')
             .column('scope'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('pikku_user_role_role_idx')
             .on('pikkuUserRole')
             .column('role'),

package/dist/src/schema/secret.schema.js

@@ -11,20 +11,20 @@ import { sql } from 'kysely';
 export const secretSchema = {
     name: 'secret',
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('secrets')
             .addColumn('key', 'varchar(255)', (col) => col.primaryKey())
-            .addColumn('ciphertext', 'text', (col) => col.notNull())
-            .addColumn('wrappedDek', 'text', (col) => col.notNull())
+            .addColumn('ciphertext', ctx.text, (col) => col.notNull())
+            .addColumn('wrappedDek', ctx.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
+        (db, _types, ctx) => 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
+        (db, _types, ctx) => db.schema
             .createTable('secretsAudit')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
             .addColumn('secretKey', 'varchar(255)', (col) => col.notNull())

package/dist/src/schema/session.schema.js

@@ -3,10 +3,10 @@ import { sql } from 'kysely';
 export const sessionSchema = {
     name: 'session',
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuUserSessions')
-            .addColumn('pikkuUserId', 'text', (col) => col.primaryKey())
-            .addColumn('session', 'text', (col) => col.notNull())
+            .addColumn('pikkuUserId', ctx.key, (col) => col.primaryKey())
+            .addColumn('session', ctx.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/dist/src/schema/trigger-source.schema.js

@@ -7,17 +7,17 @@ export const triggerSourceSchema = {
     name: 'trigger-source',
     ownedBy: ['triggerSourceStore'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuTriggerSource')
-            .addColumn('name', 'text', (col) => col.primaryKey())
-            .addColumn('kind', 'text', (col) => col.notNull())
-            .addColumn('baseUrl', 'text')
-            .addColumn('labelPrefix', 'text')
+            .addColumn('name', ctx.key, (col) => col.primaryKey())
+            .addColumn('kind', ctx.text, (col) => col.notNull())
+            .addColumn('baseUrl', ctx.text)
+            .addColumn('labelPrefix', ctx.text)
             .addColumn('declared', 'boolean', (col) => col.defaultTo(true).notNull())
             .addColumn('enabled', 'boolean', (col) => col.defaultTo(false).notNull())
-            .addColumn('status', 'text')
-            .addColumn('state', 'text')
-            .addColumn('detail', 'text')
+            .addColumn('status', ctx.text)
+            .addColumn('state', ctx.text)
+            .addColumn('detail', ctx.text)
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
     ],
 };

package/dist/src/schema/virtual-user-schedule.schema.js

@@ -15,7 +15,7 @@ export const virtualUserScheduleSchema = {
     name: 'virtual-user-schedule',
     ownedBy: ['virtualUserScheduleStore'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => 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
@@ -23,8 +23,8 @@ export const virtualUserScheduleSchema = {
             // 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')
+            .addColumn('goals', ctx.text, (col) => col.defaultTo(ctx.defaultText('[]')).notNull())
+            .addColumn('budget', ctx.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())
@@ -35,7 +35,7 @@ export const virtualUserScheduleSchema = {
             .addColumn('lastRunId', 'varchar(36)')
             .addColumn('lastRunAt', 'timestamp'),
         // The only read that matters at speed: which rows are due, on every tick.
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_virtual_user_schedule_due')
             .on('virtualUserSchedule')
             .columns(['enabled', 'nextRunAt']),

package/dist/src/schema/virtual-user.schema.js

@@ -21,7 +21,7 @@ export const virtualUserSchema = {
     name: 'virtual-user',
     ownedBy: ['virtualUserRunStore'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('virtualUserRun')
             .addColumn('runId', 'varchar(36)', (col) => col.primaryKey())
             .addColumn('persona', 'varchar(255)', (col) => col.notNull())
@@ -30,29 +30,29 @@ export const virtualUserSchema = {
             // 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())
+            .addColumn('status', 'varchar(50)', (col) => col.defaultTo(ctx.defaultText('running')).notNull())
+            .addColumn('goals', ctx.text, (col) => col.defaultTo(ctx.defaultText('[]')).notNull())
+            .addColumn('memory', ctx.text, (col) => col.defaultTo(ctx.defaultText('{}')).notNull())
+            .addColumn('findings', ctx.text, (col) => col.defaultTo(ctx.defaultText('[]')).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())
+            .addColumn('intents', ctx.text, (col) => col.defaultTo(ctx.defaultText('[]')).notNull())
             // Counts the engine kept: steps, calls, mutations, tokens, elapsed.
-            .addColumn('tally', 'text')
+            .addColumn('tally', ctx.text)
             .addColumn('stoppedBy', 'varchar(255)')
             // Why the run itself failed, as opposed to what it found.
-            .addColumn('error', 'text')
+            .addColumn('error', ctx.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
+        (db, _types, ctx) => db.schema
             .createIndex('idx_virtual_user_run_created')
             .on('virtualUserRun')
             .column('createdAt'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_virtual_user_run_persona')
             .on('virtualUserRun')
             .columns(['persona', 'createdAt']),
@@ -62,7 +62,7 @@ export const virtualUserSchema = {
         // 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
+        (db, _types, ctx) => db.schema
             .createTable('virtualUserRunStep')
             .addColumn('runId', 'varchar(36)', (col) => col.notNull())
             // The engine's own step number, which is what the intent records point
@@ -72,7 +72,7 @@ export const virtualUserSchema = {
             .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('action', ctx.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.
@@ -81,8 +81,8 @@ export const virtualUserSchema = {
             // 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('response', ctx.text)
+            .addColumn('findingKinds', ctx.text)
             .addColumn('tokensIn', 'integer', (col) => col.defaultTo(0).notNull())
             .addColumn('tokensOut', 'integer', (col) => col.defaultTo(0).notNull())
             .addPrimaryKeyConstraint('pk_virtual_user_run_step', [

package/dist/src/schema/webhook.schema.js

@@ -4,34 +4,34 @@ export const webhookSchema = {
     name: 'webhook',
     ownedBy: ['webhookService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => 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('deliveryId', ctx.key, (col) => col.primaryKey())
+            .addColumn('organizationId', ctx.key)
+            .addColumn('url', ctx.text, (col) => col.notNull())
+            .addColumn('event', ctx.text)
+            .addColumn('status', ctx.text, (col) => col.defaultTo(ctx.defaultText('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
+        (db, _types, ctx) => db.schema
             .createTable('webhookDeliveryAttempt')
-            .addColumn('attemptId', 'text', (col) => col.primaryKey())
-            .addColumn('deliveryId', 'text', (col) => col
-            .notNull()
-            .references('webhookDelivery.deliveryId')
-            .onDelete('cascade'))
+            .addColumn('attemptId', ctx.key, (col) => col.primaryKey())
+            .addColumn('deliveryId', ctx.key, (col) => ctx.references(col.notNull(), 'webhookDelivery.deliveryId'))
             .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
+            .addColumn('responseBody', ctx.text)
+            .addColumn('error', ctx.text)
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .$call(ctx.foreignKeys('webhookDeliveryAttempt', {
+            deliveryId: 'webhookDelivery.deliveryId',
+        })),
+        (db, _types, ctx) => db.schema
             .createIndex('idx_webhook_delivery_org')
             .on('webhookDelivery')
             .column('organizationId'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_webhook_delivery_attempt_delivery')
             .on('webhookDeliveryAttempt')
             .column('deliveryId'),

package/dist/src/schema/workflow.schema.js

@@ -18,40 +18,37 @@ export const workflowSchema = {
     name: 'workflow',
     ownedBy: ['workflowService', 'workflowRunService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => 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('workflowRunId', ctx.key, (col) => col.primaryKey())
+            .addColumn('workflow', ctx.key, (col) => col.notNull())
+            .addColumn('status', ctx.key, (col) => col.notNull())
+            .addColumn('input', ctx.text, (col) => col.notNull())
+            .addColumn('output', ctx.text)
+            .addColumn('error', ctx.text)
+            .addColumn('state', ctx.text, (col) => col.defaultTo(ctx.defaultText('{}')))
             .addColumn('inline', 'boolean', (col) => col.defaultTo(false))
-            .addColumn('graphHash', 'text')
+            .addColumn('graphHash', ctx.key)
             .addColumn('deterministic', 'boolean', (col) => col.defaultTo(false))
-            .addColumn('plannedSteps', 'text')
-            .addColumn('wire', 'text')
+            .addColumn('plannedSteps', ctx.text)
+            .addColumn('wire', ctx.text)
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+        (db, _types, ctx) => 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('workflowStepId', ctx.key, (col) => col.primaryKey())
+            .addColumn('workflowRunId', ctx.key, (col) => ctx.references(col.notNull(), 'workflowRuns.workflowRunId'))
+            .addColumn('stepName', ctx.key, (col) => col.notNull())
+            .addColumn('rpcName', ctx.text)
+            .addColumn('data', ctx.text)
+            .addColumn('status', ctx.key, (col) => col.notNull().defaultTo(ctx.defaultText('pending')))
+            .addColumn('result', ctx.text)
+            .addColumn('error', ctx.text)
+            .addColumn('childRunId', ctx.text)
+            .addColumn('branchTaken', ctx.text)
             .addColumn('retries', 'integer')
-            .addColumn('retryDelay', 'text')
-            .addColumn('fromStepName', 'text')
+            .addColumn('retryDelay', ctx.text)
+            .addColumn('fromStepName', ctx.text)
             .addColumn('currentAttempt', 'integer')
             .addColumn('leaseExpiresAt', 'bigint')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
@@ -59,30 +56,33 @@ export const workflowSchema = {
             .addUniqueConstraint('workflow_step_run_name_unique', [
             'workflowRunId',
             'stepName',
-        ]),
-        (db) => db.schema
+        ])
+            .$call(ctx.foreignKeys('workflowStep', {
+            workflowRunId: 'workflowRuns.workflowRunId',
+        })),
+        (db, _types, ctx) => 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('historyId', ctx.key, (col) => col.primaryKey())
+            .addColumn('workflowStepId', ctx.key, (col) => ctx.references(col.notNull(), 'workflowStep.workflowStepId'))
+            .addColumn('status', ctx.key, (col) => col.notNull())
+            .addColumn('result', ctx.text)
+            .addColumn('error', ctx.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
+            .addColumn('failedAt', 'timestamp')
+            .$call(ctx.foreignKeys('workflowStepHistory', {
+            workflowStepId: 'workflowStep.workflowStepId',
+        })),
+        (db, _types, ctx) => 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('workflowName', ctx.key, (col) => col.notNull())
+            .addColumn('graphHash', ctx.key, (col) => col.notNull())
+            .addColumn('graph', ctx.text, (col) => col.notNull())
+            .addColumn('source', ctx.key, (col) => col.notNull())
+            .addColumn('status', ctx.key, (col) => col.notNull().defaultTo(ctx.defaultText('active')))
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addPrimaryKeyConstraint('workflow_versions_pk', [
             'workflowName',
@@ -90,23 +90,23 @@ export const workflowSchema = {
         ]),
         // 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
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_runs_status_created')
             .on('workflowRuns')
             .columns(['status', 'createdAt']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_runs_workflow_created')
             .on('workflowRuns')
             .columns(['workflow', 'createdAt']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_step_run_status')
             .on('workflowStep')
             .columns(['workflowRunId', 'status']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_step_history_step')
             .on('workflowStepHistory')
             .columns(['workflowStepId', 'createdAt']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_versions_source_status')
             .on('workflowVersions')
             .columns(['source', 'status']),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely",
-  "version": "0.13.33",
+  "version": "0.13.34",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -26,7 +26,7 @@
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.133"
+    "@pikku/core": "^0.12.136"
   },
   "dependencies": {
     "kysely": "^0.29.5"