@pikku/kysely 0.13.33 → 0.13.35

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'),