@pikku/kysely 0.13.3 → 0.13.4

package/src/kysely-ai-run-state-service.ts

@@ -3,6 +3,8 @@ import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import type { AIRunStateService, CreateRunInput } from '@pikku/core/services'
 import type { AgentRunState, PendingApproval } from '@pikku/core/ai-agent'
+import { ensurePikkuSchema } from './schema/index.js'
+import { aiSchema } from './schema/ai.schema.js'
 
 export class KyselyAIRunStateService implements AIRunStateService {
   private initialized = false
@@ -11,30 +13,7 @@ export class KyselyAIRunStateService implements AIRunStateService {
 
   async init(): Promise<void> {
     if (this.initialized) return
-
-    await this.db.schema
-      .createTable('aiRun')
-      .ifNotExists()
-      .addColumn('runId', 'text', (col) => col.primaryKey())
-      .addColumn('agentName', 'text', (col) => col.notNull())
-      .addColumn('threadId', 'text', (col) => col.notNull())
-      .addColumn('resourceId', 'text', (col) => col.notNull())
-      .addColumn('status', 'text', (col) => col.defaultTo('running').notNull())
-      .addColumn('errorMessage', 'text')
-      .addColumn('suspendReason', 'text')
-      .addColumn('missingRpcs', 'text')
-      .addColumn('pendingApprovals', 'text')
-      .addColumn('usageInputTokens', 'integer', (col) => col.defaultTo(0))
-      .addColumn('usageOutputTokens', 'integer', (col) => col.defaultTo(0))
-      .addColumn('usageModel', 'text', (col) => col.defaultTo(''))
-      .addColumn('createdAt', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addColumn('updatedAt', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
+    await ensurePikkuSchema(this.db, aiSchema)
     this.initialized = true
   }
 
@@ -113,7 +92,7 @@ export class KyselyAIRunStateService implements AIRunStateService {
   ): Promise<void> {
     const rows = await this.db
       .selectFrom('aiRun')
-      .select(['runId', 'pendingApprovals' as any])
+      .select(['runId', 'pendingApprovals'])
       .where('status', '=', 'suspended')
       .execute()
 
@@ -121,7 +100,7 @@ export class KyselyAIRunStateService implements AIRunStateService {
       let approvals: PendingApproval[] = []
       if (row.pendingApprovals) {
         try {
-          approvals = JSON.parse(row.pendingApprovals as string)
+          approvals = JSON.parse(row.pendingApprovals)
         } catch {
           console.warn(
             `Failed to parse pendingApprovals for run ${row.runId}, treating as empty`
@@ -159,9 +138,9 @@ export class KyselyAIRunStateService implements AIRunStateService {
 
     for (const row of rows) {
       let approvals: PendingApproval[] = []
-      if ((row as any).pendingApprovals) {
+      if (row.pendingApprovals) {
         try {
-          approvals = JSON.parse((row as any).pendingApprovals)
+          approvals = JSON.parse(row.pendingApprovals)
         } catch {
           console.warn(
             `Failed to parse pendingApprovals for run ${row.runId}, treating as empty`

package/src/kysely-ai-storage-service.ts

@@ -5,9 +5,10 @@ import type {
 } from '@pikku/core/services'
 import type { AIThread, AIMessage, AgentRunState } from '@pikku/core/ai-agent'
 import type { Kysely } from 'kysely'
-import { sql } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { parseJson } from './kysely-json.js'
+import { ensurePikkuSchema } from './schema/index.js'
+import { aiSchema } from './schema/ai.schema.js'
 
 export class KyselyAIStorageService
   implements AIStorageService, AIRunStateService
@@ -16,158 +17,9 @@ export class KyselyAIStorageService
 
   constructor(private db: Kysely<KyselyPikkuDB>) {}
 
-  private async createIndexSafe(builder: {
-    execute(): Promise<void>
-  }): Promise<void> {
-    try {
-      await builder.execute()
-    } catch (e: any) {
-      // Ignore "index already exists" errors across databases
-      // MySQL: ER_DUP_KEYNAME, Postgres: 42P07, SQLite: "already exists"
-      if (e?.code === 'ER_DUP_KEYNAME' || e?.errno === 1061) return
-      if (e?.code === '42P07') return
-      if (e?.message?.includes('already exists')) return
-      throw e
-    }
-  }
-
   public async init(): Promise<void> {
-    if (this.initialized) {
-      return
-    }
-
-    await this.db.schema
-      .createTable('ai_threads')
-      .ifNotExists()
-      .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-      .addColumn('resource_id', 'varchar(255)', (col) => col.notNull())
-      .addColumn('title', 'text')
-      .addColumn('metadata', 'text')
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addColumn('updated_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    await this.createIndexSafe(
-      this.db.schema
-        .createIndex('idx_ai_threads_resource')
-        .on('ai_threads')
-        .column('resource_id')
-    )
-
-    await this.db.schema
-      .createTable('ai_message')
-      .ifNotExists()
-      .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-      .addColumn('thread_id', 'varchar(36)', (col) =>
-        col.notNull().references('ai_threads.id').onDelete('cascade')
-      )
-      .addColumn('role', 'varchar(50)', (col) => col.notNull())
-      .addColumn('content', 'text')
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    await this.createIndexSafe(
-      this.db.schema
-        .createIndex('idx_ai_message_thread')
-        .on('ai_message')
-        .columns(['thread_id', 'created_at'])
-    )
-
-    await this.db.schema
-      .createTable('ai_tool_call')
-      .ifNotExists()
-      .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-      .addColumn('thread_id', 'varchar(36)', (col) =>
-        col.notNull().references('ai_threads.id').onDelete('cascade')
-      )
-      .addColumn('message_id', 'varchar(36)', (col) =>
-        col.notNull().references('ai_message.id').onDelete('cascade')
-      )
-      .addColumn('run_id', 'varchar(36)')
-      .addColumn('tool_name', 'varchar(255)', (col) => col.notNull())
-      .addColumn('args', 'text', (col) => col.notNull())
-      .addColumn('result', 'text')
-      .addColumn('approval_status', 'varchar(50)')
-      .addColumn('approval_type', 'varchar(50)')
-      .addColumn('agent_run_id', 'varchar(36)')
-      .addColumn('display_tool_name', 'varchar(255)')
-      .addColumn('display_args', 'text')
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    await this.createIndexSafe(
-      this.db.schema
-        .createIndex('idx_ai_tool_call_thread')
-        .on('ai_tool_call')
-        .column('thread_id')
-    )
-
-    await this.createIndexSafe(
-      this.db.schema
-        .createIndex('idx_ai_tool_call_message')
-        .on('ai_tool_call')
-        .column('message_id')
-    )
-
-    await this.db.schema
-      .createTable('ai_working_memory')
-      .ifNotExists()
-      .addColumn('id', 'varchar(255)', (col) => col.notNull())
-      .addColumn('scope', 'varchar(50)', (col) => col.notNull())
-      .addColumn('data', 'text', (col) => col.notNull())
-      .addColumn('updated_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addPrimaryKeyConstraint('ai_working_memory_pk', ['id', 'scope'])
-      .execute()
-
-    await this.db.schema
-      .createTable('ai_run')
-      .ifNotExists()
-      .addColumn('run_id', 'varchar(36)', (col) => col.primaryKey())
-      .addColumn('agent_name', 'varchar(255)', (col) => col.notNull())
-      .addColumn('thread_id', 'varchar(36)', (col) =>
-        col.notNull().references('ai_threads.id').onDelete('cascade')
-      )
-      .addColumn('resource_id', 'varchar(255)', (col) => col.notNull())
-      .addColumn('status', 'varchar(50)', (col) =>
-        col.notNull().defaultTo('running')
-      )
-      .addColumn('error_message', 'text')
-      .addColumn('suspend_reason', 'text')
-      .addColumn('missing_rpcs', 'text')
-      .addColumn('usage_input_tokens', 'integer', (col) =>
-        col.notNull().defaultTo(0)
-      )
-      .addColumn('usage_output_tokens', 'integer', (col) =>
-        col.notNull().defaultTo(0)
-      )
-      .addColumn('usage_model', 'varchar(255)', (col) =>
-        col.notNull().defaultTo('')
-      )
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addColumn('updated_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    await this.createIndexSafe(
-      this.db.schema
-        .createIndex('idx_ai_run_thread')
-        .on('ai_run')
-        .columns(['thread_id', 'created_at'])
-    )
-
+    if (this.initialized) return
+    await ensurePikkuSchema(this.db, aiSchema)
     this.initialized = true
   }
 

package/src/kysely-channel-store.ts

@@ -1,9 +1,10 @@
 import type { Channel } from '@pikku/core/channel'
 import { ChannelStore } from '@pikku/core/channel'
 import type { Kysely } from 'kysely'
-import { sql } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { parseJson } from './kysely-json.js'
+import { ensurePikkuSchema } from './schema/index.js'
+import { channelSchema } from './schema/channel.schema.js'
 
 export class KyselyChannelStore extends ChannelStore {
   private initialized = false
@@ -13,39 +14,8 @@ export class KyselyChannelStore extends ChannelStore {
   }
 
   public async init(): Promise<void> {
-    if (this.initialized) {
-      return
-    }
-
-    await this.db.schema
-      .createTable('channels')
-      .ifNotExists()
-      .addColumn('channel_id', 'text', (col) => col.primaryKey())
-      .addColumn('channel_name', 'text', (col) => col.notNull())
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addColumn('opening_data', 'text', (col) => col.notNull().defaultTo('{}'))
-      .addColumn('pikku_user_id', 'text')
-      .addColumn('state', 'text')
-      .addColumn('last_wire', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    await this.db.schema
-      .createTable('channel_subscriptions')
-      .ifNotExists()
-      .addColumn('channel_id', 'text', (col) =>
-        col.notNull().references('channels.channel_id').onDelete('cascade')
-      )
-      .addColumn('topic', 'text', (col) => col.notNull())
-      .addPrimaryKeyConstraint('channel_subscriptions_pk', [
-        'channel_id',
-        'topic',
-      ])
-      .execute()
-
+    if (this.initialized) return
+    await ensurePikkuSchema(this.db, channelSchema)
     this.initialized = true
   }
 

package/src/kysely-credential-service.ts

@@ -1,12 +1,13 @@
 import type { CredentialService } from '@pikku/core/services'
 import type { Kysely } from 'kysely'
-import { sql } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import {
   envelopeEncrypt,
   envelopeDecrypt,
   envelopeRewrap,
 } from '@pikku/core/crypto-utils'
+import { ensurePikkuSchema } from './schema/index.js'
+import { credentialSchema } from './schema/credential.schema.js'
 
 export interface KyselyCredentialServiceConfig {
   key: string
@@ -37,41 +38,7 @@ export class KyselyCredentialService implements CredentialService {
 
   public async init(): Promise<void> {
     if (this.initialized) return
-
-    await this.db.schema
-      .createTable('credentials')
-      .ifNotExists()
-      .addColumn('name', 'varchar(255)', (col) => col.notNull())
-      .addColumn('user_id', 'varchar(255)')
-      .addColumn('ciphertext', 'text', (col) => col.notNull())
-      .addColumn('wrapped_dek', 'text', (col) => col.notNull())
-      .addColumn('key_version', 'integer', (col) => col.notNull())
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addColumn('updated_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    await sql`CREATE UNIQUE INDEX IF NOT EXISTS credentials_name_user_id_unique ON credentials (name, COALESCE(user_id, ''))`.execute(
-      this.db
-    )
-
-    if (this.audit) {
-      await this.db.schema
-        .createTable('credentials_audit')
-        .ifNotExists()
-        .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-        .addColumn('credential_name', 'varchar(255)', (col) => col.notNull())
-        .addColumn('user_id', 'varchar(255)')
-        .addColumn('action', 'varchar(20)', (col) => col.notNull())
-        .addColumn('performed_at', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .execute()
-    }
-
+    await ensurePikkuSchema(this.db, credentialSchema)
     this.initialized = true
   }
 

package/src/kysely-deployment-service.ts

@@ -7,8 +7,9 @@ import type {
 import type { JWTService, SecretService } from '@pikku/core/services'
 import { getAllFunctionNames } from '@pikku/core/function'
 import type { Kysely } from 'kysely'
-import { sql } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
+import { ensurePikkuSchema } from './schema/index.js'
+import { deploymentSchema } from './schema/deployment.schema.js'
 
 export class KyselyDeploymentService implements DeploymentService {
   private initialized = false
@@ -28,55 +29,8 @@ export class KyselyDeploymentService implements DeploymentService {
   }
 
   public async init(): Promise<void> {
-    if (this.initialized) {
-      return
-    }
-
-    await this.db.schema
-      .createTable('pikku_deployments')
-      .ifNotExists()
-      .addColumn('deployment_id', 'text', (col) => col.primaryKey())
-      .addColumn('endpoint', 'text', (col) => col.notNull())
-      .addColumn('last_heartbeat', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    await this.db.schema
-      .createTable('pikku_deployment_functions')
-      .ifNotExists()
-      .addColumn('deployment_id', 'text', (col) =>
-        col
-          .notNull()
-          .references('pikku_deployments.deployment_id')
-          .onDelete('cascade')
-      )
-      .addColumn('function_name', 'text', (col) => col.notNull())
-      .addPrimaryKeyConstraint('pikku_deployment_functions_pk', [
-        'deployment_id',
-        'function_name',
-      ])
-      .execute()
-
-    await this.createIndexSafe(
-      this.db.schema
-        .createIndex('idx_pikku_deployments_heartbeat')
-        .ifNotExists()
-        .on('pikku_deployments')
-        .column('last_heartbeat')
-    )
-
-    await this.createIndexSafe(
-      this.db.schema
-        .createIndex('idx_pikku_deployment_functions_name')
-        .ifNotExists()
-        .on('pikku_deployment_functions')
-        .column('function_name')
-    )
-
+    if (this.initialized) return
+    await ensurePikkuSchema(this.db, deploymentSchema)
     this.initialized = true
   }
 
@@ -192,19 +146,6 @@ export class KyselyDeploymentService implements DeploymentService {
     return response.json()
   }
 
-  private async createIndexSafe(builder: {
-    execute(): Promise<void>
-  }): Promise<void> {
-    try {
-      await builder.execute()
-    } catch (e: any) {
-      if (e?.code === 'ER_DUP_KEYNAME' || e?.errno === 1061) return
-      if (e?.code === '42P07') return
-      if (e?.message?.includes('already exists')) return
-      throw e
-    }
-  }
-
   private async sendHeartbeat(): Promise<void> {
     if (!this.deploymentConfig) return
 

package/src/kysely-scope-service.ts

@@ -1,8 +1,9 @@
 import type { Role, ScopeService } from '@pikku/core/services'
 import type { FlatScope } from '@pikku/core/scope'
 import type { Kysely } from 'kysely'
-import { sql } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
+import { ensurePikkuSchema } from './schema/index.js'
+import { scopeSchema } from './schema/scope.schema.js'
 
 /**
  * Resolves and administers user scopes against four self-created tables.
@@ -22,86 +23,8 @@ export class KyselyScopeService implements ScopeService {
   constructor(private db: Kysely<KyselyPikkuDB>) {}
 
   public async init(): Promise<void> {
-    if (this.initialized) {
-      return
-    }
-
-    await this.db.schema
-      .createTable('pikku_scopes')
-      .ifNotExists()
-      .addColumn('name', 'text', (col) => col.primaryKey())
-      .addColumn('description', 'text')
-      .addColumn('declared', 'boolean', (col) => col.defaultTo(true).notNull())
-      .execute()
-
-    await this.db.schema
-      .createTable('pikku_roles')
-      .ifNotExists()
-      .addColumn('name', 'text', (col) => col.primaryKey())
-      .addColumn('description', 'text')
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    await this.db.schema
-      .createTable('pikku_role_scopes')
-      .ifNotExists()
-      .addColumn('role', 'text', (col) =>
-        col.notNull().references('pikku_roles.name').onDelete('cascade')
-      )
-      .addColumn('scope', 'text', (col) =>
-        col.notNull().references('pikku_scopes.name').onDelete('cascade')
-      )
-      .addPrimaryKeyConstraint('pikku_role_scopes_pk', ['role', 'scope'])
-      .execute()
-
-    await this.db.schema
-      .createTable('pikku_user_role')
-      .ifNotExists()
-      .addColumn('user_id', 'text', (col) =>
-        col.notNull().references('user.id').onDelete('cascade')
-      )
-      .addColumn('role', 'text', (col) =>
-        col.notNull().references('pikku_roles.name').onDelete('cascade')
-      )
-      .addColumn('granted_by', 'text')
-      .addColumn('granted_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addPrimaryKeyConstraint('pikku_user_role_pk', ['user_id', 'role'])
-      .execute()
-
-    await this.db.schema
-      .createTable('pikku_user_scope')
-      .ifNotExists()
-      .addColumn('user_id', 'text', (col) =>
-        col.notNull().references('user.id').onDelete('cascade')
-      )
-      .addColumn('scope', 'text', (col) =>
-        col.notNull().references('pikku_scopes.name').onDelete('cascade')
-      )
-      .addColumn('granted_by', 'text')
-      .addColumn('granted_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addPrimaryKeyConstraint('pikku_user_scope_pk', ['user_id', 'scope'])
-      .execute()
-
-    await this.db.schema
-      .createIndex('pikku_role_scopes_scope_idx')
-      .ifNotExists()
-      .on('pikku_role_scopes')
-      .column('scope')
-      .execute()
-
-    await this.db.schema
-      .createIndex('pikku_user_role_role_idx')
-      .ifNotExists()
-      .on('pikku_user_role')
-      .column('role')
-      .execute()
-
+    if (this.initialized) return
+    await ensurePikkuSchema(this.db, scopeSchema)
     this.initialized = true
   }
 

package/src/kysely-secret-service.ts

@@ -1,12 +1,13 @@
 import type { SecretService } from '@pikku/core/services'
 import type { Kysely } from 'kysely'
-import { sql } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import {
   envelopeEncrypt,
   envelopeDecrypt,
   envelopeRewrap,
 } from '@pikku/core/crypto-utils'
+import { ensurePikkuSchema } from './schema/index.js'
+import { secretSchema } from './schema/secret.schema.js'
 
 export interface KyselySecretServiceConfig {
   key: string
@@ -37,35 +38,7 @@ export class KyselySecretService implements SecretService {
 
   public async init(): Promise<void> {
     if (this.initialized) return
-
-    await this.db.schema
-      .createTable('secrets')
-      .ifNotExists()
-      .addColumn('key', 'varchar(255)', (col) => col.primaryKey())
-      .addColumn('ciphertext', 'text', (col) => col.notNull())
-      .addColumn('wrapped_dek', 'text', (col) => col.notNull())
-      .addColumn('key_version', 'integer', (col) => col.notNull())
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addColumn('updated_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
-    if (this.audit) {
-      await this.db.schema
-        .createTable('secrets_audit')
-        .ifNotExists()
-        .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-        .addColumn('secret_key', 'varchar(255)', (col) => col.notNull())
-        .addColumn('action', 'varchar(20)', (col) => col.notNull())
-        .addColumn('performed_at', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .execute()
-    }
-
+    await ensurePikkuSchema(this.db, secretSchema)
     this.initialized = true
   }
 
@@ -149,9 +122,9 @@ export class KyselySecretService implements SecretService {
     await this.logAudit(key, 'delete')
   }
 
-  async getSecrets<
-    T extends Record<string, unknown> = Record<string, unknown>,
-  >(keys: (keyof T & string)[]): Promise<T> {
+  async getSecrets<T extends Record<string, unknown> = Record<string, unknown>>(
+    keys: (keyof T & string)[]
+  ): Promise<T> {
     const rows = await this.db
       .selectFrom('secrets')
       .select(['key', 'ciphertext', 'wrappedDek', 'keyVersion'])

package/src/kysely-session-store.ts

@@ -1,9 +1,10 @@
 import type { CoreUserSession } from '@pikku/core'
 import type { SessionStore } from '@pikku/core/services'
 import type { Kysely } from 'kysely'
-import { sql } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { parseJson } from './kysely-json.js'
+import { ensurePikkuSchema } from './schema/index.js'
+import { sessionSchema } from './schema/session.schema.js'
 
 export class KyselySessionStore implements SessionStore {
   private initialized = false
@@ -11,23 +12,8 @@ export class KyselySessionStore implements SessionStore {
   constructor(private db: Kysely<KyselyPikkuDB>) {}
 
   public async init(): Promise<void> {
-    if (this.initialized) {
-      return
-    }
-
-    await this.db.schema
-      .createTable('pikku_user_sessions')
-      .ifNotExists()
-      .addColumn('pikku_user_id', 'text', (col) => col.primaryKey())
-      .addColumn('session', 'text', (col) => col.notNull())
-      .addColumn('created_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .addColumn('updated_at', 'timestamp', (col) =>
-        col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      )
-      .execute()
-
+    if (this.initialized) return
+    await ensurePikkuSchema(this.db, sessionSchema)
     this.initialized = true
   }