@pikku/kysely 0.12.6 → 0.12.7

package/src/kysely-tables.ts

@@ -6,21 +6,21 @@ import type {
 } from '@pikku/core/workflow'
 
 export interface ChannelsTable {
-  channel_id: string
-  channel_name: string
-  created_at: Generated<Date>
-  opening_data: string
-  user_session: string | null
-  last_wire: Generated<Date>
+  channelId: string
+  channelName: string
+  createdAt: Generated<Date>
+  openingData: string
+  userSession: string | null
+  lastWire: Generated<Date>
 }
 
 export interface ChannelSubscriptionsTable {
-  channel_id: string
+  channelId: string
   topic: string
 }
 
 export interface WorkflowRunsTable {
-  workflow_run_id: Generated<string>
+  workflowRunId: Generated<string>
   workflow: string
   status: WorkflowStatus
   input: string
@@ -28,169 +28,169 @@ export interface WorkflowRunsTable {
   error: string | null
   state: Generated<string>
   inline: Generated<boolean>
-  graph_hash: string | null
+  graphHash: string | null
   wire: string | null
-  created_at: Generated<Date>
-  updated_at: Generated<Date>
+  createdAt: Generated<Date>
+  updatedAt: Generated<Date>
 }
 
 export interface WorkflowStepTable {
-  workflow_step_id: Generated<string>
-  workflow_run_id: string
-  step_name: string
-  rpc_name: string | null
+  workflowStepId: Generated<string>
+  workflowRunId: string
+  stepName: string
+  rpcName: string | null
   data: string | null
   status: Generated<StepStatus>
   result: string | null
   error: string | null
-  child_run_id: string | null
-  branch_taken: string | null
+  childRunId: string | null
+  branchTaken: string | null
   retries: number | null
-  retry_delay: string | null
-  created_at: Generated<Date>
-  updated_at: Generated<Date>
+  retryDelay: string | null
+  createdAt: Generated<Date>
+  updatedAt: Generated<Date>
 }
 
 export interface WorkflowStepHistoryTable {
-  history_id: Generated<string>
-  workflow_step_id: string
+  historyId: Generated<string>
+  workflowStepId: string
   status: StepStatus
   result: string | null
   error: string | null
-  created_at: Generated<Date>
-  running_at: Date | null
-  scheduled_at: Date | null
-  succeeded_at: Date | null
-  failed_at: Date | null
+  createdAt: Generated<Date>
+  runningAt: Date | null
+  scheduledAt: Date | null
+  succeededAt: Date | null
+  failedAt: Date | null
 }
 
 export interface WorkflowVersionsTable {
-  workflow_name: string
-  graph_hash: string
+  workflowName: string
+  graphHash: string
   graph: string
   source: string
   status: Generated<WorkflowVersionStatus>
-  created_at: Generated<Date>
+  createdAt: Generated<Date>
 }
 
 export interface AIThreadsTable {
   id: string
-  resource_id: string
+  resourceId: string
   title: string | null
   metadata: string | null
-  created_at: Generated<Date>
-  updated_at: Generated<Date>
+  createdAt: Generated<Date>
+  updatedAt: Generated<Date>
 }
 
 export interface AIMessageTable {
   id: string
-  thread_id: string
+  threadId: string
   role: 'system' | 'user' | 'assistant' | 'tool'
   content: string | null
-  created_at: Generated<Date>
+  createdAt: Generated<Date>
 }
 
 export interface AIToolCallTable {
   id: string
-  thread_id: string
-  message_id: string
-  run_id: string | null
-  tool_name: string
+  threadId: string
+  messageId: string
+  runId: string | null
+  toolName: string
   args: string
   result: string | null
-  approval_status: 'approved' | 'denied' | 'pending' | null
-  approval_type: 'agent-call' | 'tool-call' | null
-  agent_run_id: string | null
-  display_tool_name: string | null
-  display_args: string | null
-  created_at: Generated<Date>
+  approvalStatus: 'approved' | 'denied' | 'pending' | null
+  approvalType: 'agent-call' | 'tool-call' | null
+  agentRunId: string | null
+  displayToolName: string | null
+  displayArgs: string | null
+  createdAt: Generated<Date>
 }
 
 export interface AIWorkingMemoryTable {
   id: string
   scope: string
   data: string
-  updated_at: Generated<Date>
+  updatedAt: Generated<Date>
 }
 
 export interface AIRunTable {
-  run_id: Generated<string>
-  agent_name: string
-  thread_id: string
-  resource_id: string
+  runId: Generated<string>
+  agentName: string
+  threadId: string
+  resourceId: string
   status: Generated<'running' | 'suspended' | 'completed' | 'failed'>
-  error_message: string | null
-  suspend_reason: 'approval' | 'rpc-missing' | null
-  missing_rpcs: string | null
-  usage_input_tokens: Generated<number>
-  usage_output_tokens: Generated<number>
-  usage_model: Generated<string>
-  created_at: Generated<Date>
-  updated_at: Generated<Date>
+  errorMessage: string | null
+  suspendReason: 'approval' | 'rpc-missing' | null
+  missingRpcs: string | null
+  usageInputTokens: Generated<number>
+  usageOutputTokens: Generated<number>
+  usageModel: Generated<string>
+  createdAt: Generated<Date>
+  updatedAt: Generated<Date>
 }
 
 export interface PikkuDeploymentsTable {
-  deployment_id: string
+  deploymentId: string
   endpoint: string
-  last_heartbeat: Generated<Date>
-  created_at: Generated<Date>
+  lastHeartbeat: Generated<Date>
+  createdAt: Generated<Date>
 }
 
 export interface PikkuDeploymentFunctionsTable {
-  deployment_id: string
-  function_name: string
+  deploymentId: string
+  functionName: string
 }
 
 export interface SecretsTable {
   key: string
   ciphertext: string
-  wrapped_dek: string
-  key_version: number
-  created_at: Generated<Date>
-  updated_at: Generated<Date>
+  wrappedDek: string
+  keyVersion: number
+  createdAt: Generated<Date>
+  updatedAt: Generated<Date>
 }
 
 export interface SecretsAuditTable {
   id: string
-  secret_key: string
+  secretKey: string
   action: string
-  performed_at: Generated<Date>
+  performedAt: Generated<Date>
 }
 
 export interface CredentialsTable {
   name: string
-  user_id: string | null
+  userId: string | null
   ciphertext: string
-  wrapped_dek: string
-  key_version: number
-  created_at: Generated<Date>
-  updated_at: Generated<Date>
+  wrappedDek: string
+  keyVersion: number
+  createdAt: Generated<Date>
+  updatedAt: Generated<Date>
 }
 
 export interface CredentialsAuditTable {
   id: string
-  credential_name: string
-  user_id: string | null
+  credentialName: string
+  userId: string | null
   action: string
-  performed_at: Generated<Date>
+  performedAt: Generated<Date>
 }
 
 export interface KyselyPikkuDB {
   channels: ChannelsTable
-  channel_subscriptions: ChannelSubscriptionsTable
-  workflow_runs: WorkflowRunsTable
-  workflow_step: WorkflowStepTable
-  workflow_step_history: WorkflowStepHistoryTable
-  workflow_versions: WorkflowVersionsTable
-  ai_threads: AIThreadsTable
-  ai_message: AIMessageTable
-  ai_tool_call: AIToolCallTable
-  ai_working_memory: AIWorkingMemoryTable
-  ai_run: AIRunTable
-  pikku_deployments: PikkuDeploymentsTable
-  pikku_deployment_functions: PikkuDeploymentFunctionsTable
+  channelSubscriptions: ChannelSubscriptionsTable
+  workflowRuns: WorkflowRunsTable
+  workflowStep: WorkflowStepTable
+  workflowStepHistory: WorkflowStepHistoryTable
+  workflowVersions: WorkflowVersionsTable
+  aiThreads: AIThreadsTable
+  aiMessage: AIMessageTable
+  aiToolCall: AIToolCallTable
+  aiWorkingMemory: AIWorkingMemoryTable
+  aiRun: AIRunTable
+  pikkuDeployments: PikkuDeploymentsTable
+  pikkuDeploymentFunctions: PikkuDeploymentFunctionsTable
   secrets: SecretsTable
-  secrets_audit: SecretsAuditTable
+  secretsAudit: SecretsAuditTable
   credentials: CredentialsTable
-  credentials_audit: CredentialsAuditTable
+  credentialsAudit: CredentialsAuditTable
 }

package/src/kysely-workflow-run-service.ts

@@ -20,19 +20,19 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
     const { workflowName, status, limit = 50, offset = 0 } = options ?? {}
 
     let query = this.db
-      .selectFrom('workflow_runs')
+      .selectFrom('workflowRuns')
       .select([
-        'workflow_run_id',
+        'workflowRunId',
         'workflow',
         'status',
         'input',
         'output',
         'error',
         'inline',
-        'graph_hash',
+        'graphHash',
         'wire',
-        'created_at',
-        'updated_at',
+        'createdAt',
+        'updatedAt',
       ])
 
     if (workflowName) {
@@ -44,7 +44,7 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
     }
 
     const result = await query
-      .orderBy('created_at', 'desc')
+      .orderBy('createdAt', 'desc')
       .limit(limit)
       .offset(offset)
       .execute()
@@ -54,21 +54,21 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
 
   async getRun(id: string): Promise<WorkflowRun | null> {
     const row = await this.db
-      .selectFrom('workflow_runs')
+      .selectFrom('workflowRuns')
       .select([
-        'workflow_run_id',
+        'workflowRunId',
         'workflow',
         'status',
         'input',
         'output',
         'error',
         'inline',
-        'graph_hash',
+        'graphHash',
         'wire',
-        'created_at',
-        'updated_at',
+        'createdAt',
+        'updatedAt',
       ])
-      .where('workflow_run_id', '=', id)
+      .where('workflowRunId', '=', id)
       .executeTakeFirst()
 
     if (!row) return null
@@ -81,50 +81,50 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
     Array<StepState & { stepName: string; rpcName?: string; data?: any }>
   > {
     const result = await this.db
-      .selectFrom('workflow_step as s')
+      .selectFrom('workflowStep as s')
       .select([
-        's.workflow_step_id',
-        's.step_name',
-        's.rpc_name',
+        's.workflowStepId',
+        's.stepName',
+        's.rpcName',
         's.data',
         's.status',
         's.result',
         's.error',
-        's.child_run_id',
+        's.childRunId',
         's.retries',
-        's.retry_delay',
-        's.created_at',
-        's.updated_at',
+        's.retryDelay',
+        's.createdAt',
+        's.updatedAt',
       ])
       .select((eb) =>
         eb
-          .selectFrom('workflow_step_history')
+          .selectFrom('workflowStepHistory')
           .select(eb.fn.countAll<number>().as('cnt'))
           .whereRef(
-            'workflow_step_history.workflow_step_id',
+            'workflowStepHistory.workflowStepId',
             '=',
-            's.workflow_step_id'
+            's.workflowStepId'
           )
-          .as('attempt_count')
+          .as('attemptCount')
       )
-      .where('s.workflow_run_id', '=', runId)
-      .orderBy('s.created_at', 'asc')
+      .where('s.workflowRunId', '=', runId)
+      .orderBy('s.createdAt', 'asc')
       .execute()
 
     return result.map((row) => ({
-      stepId: row.workflow_step_id,
-      stepName: row.step_name,
-      rpcName: row.rpc_name ?? undefined,
+      stepId: row.workflowStepId,
+      stepName: row.stepName,
+      rpcName: row.rpcName ?? undefined,
       data: parseJson(row.data),
       status: row.status as StepState['status'],
       result: parseJson(row.result),
       error: parseJson(row.error),
-      childRunId: row.child_run_id ?? undefined,
-      attemptCount: Number(row.attempt_count || 1),
+      childRunId: row.childRunId ?? undefined,
+      attemptCount: Number(row.attemptCount || 1),
       retries: row.retries != null ? Number(row.retries) : undefined,
-      retryDelay: row.retry_delay ?? undefined,
-      createdAt: new Date(row.created_at as unknown as string),
-      updatedAt: new Date(row.updated_at as unknown as string),
+      retryDelay: row.retryDelay ?? undefined,
+      createdAt: new Date(row.createdAt as unknown as string),
+      updatedAt: new Date(row.updatedAt as unknown as string),
     }))
   }
 
@@ -132,57 +132,57 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
     runId: string
   ): Promise<Array<StepState & { stepName: string }>> {
     const result = await this.db
-      .selectFrom('workflow_step as s')
+      .selectFrom('workflowStep as s')
       .innerJoin(
-        'workflow_step_history as h',
-        'h.workflow_step_id',
-        's.workflow_step_id'
+        'workflowStepHistory as h',
+        'h.workflowStepId',
+        's.workflowStepId'
       )
       .select([
-        's.workflow_step_id',
-        's.step_name',
+        's.workflowStepId',
+        's.stepName',
         's.retries',
-        's.retry_delay',
+        's.retryDelay',
         'h.status',
         'h.result',
         'h.error',
-        'h.created_at',
-        'h.running_at',
-        'h.scheduled_at',
-        'h.succeeded_at',
-        'h.failed_at',
+        'h.createdAt',
+        'h.runningAt',
+        'h.scheduledAt',
+        'h.succeededAt',
+        'h.failedAt',
       ])
-      .where('s.workflow_run_id', '=', runId)
-      .orderBy('h.created_at', 'asc')
+      .where('s.workflowRunId', '=', runId)
+      .orderBy('h.createdAt', 'asc')
       .execute()
 
     let attemptCounters: Record<string, number> = {}
     return result.map((row) => {
-      const stepId = row.workflow_step_id
+      const stepId = row.workflowStepId
       attemptCounters[stepId] = (attemptCounters[stepId] ?? 0) + 1
 
       return {
         stepId,
-        stepName: row.step_name,
+        stepName: row.stepName,
         status: row.status as StepState['status'],
         result: parseJson(row.result),
         error: parseJson(row.error),
         attemptCount: attemptCounters[stepId]!,
         retries: row.retries != null ? Number(row.retries) : undefined,
-        retryDelay: row.retry_delay ?? undefined,
-        createdAt: new Date(row.created_at as unknown as string),
-        updatedAt: new Date(row.created_at as unknown as string),
-        runningAt: row.running_at
-          ? new Date(row.running_at as unknown as string)
+        retryDelay: row.retryDelay ?? undefined,
+        createdAt: new Date(row.createdAt as unknown as string),
+        updatedAt: new Date(row.createdAt as unknown as string),
+        runningAt: row.runningAt
+          ? new Date(row.runningAt as unknown as string)
           : undefined,
-        scheduledAt: row.scheduled_at
-          ? new Date(row.scheduled_at as unknown as string)
+        scheduledAt: row.scheduledAt
+          ? new Date(row.scheduledAt as unknown as string)
           : undefined,
-        succeededAt: row.succeeded_at
-          ? new Date(row.succeeded_at as unknown as string)
+        succeededAt: row.succeededAt
+          ? new Date(row.succeededAt as unknown as string)
           : undefined,
-        failedAt: row.failed_at
-          ? new Date(row.failed_at as unknown as string)
+        failedAt: row.failedAt
+          ? new Date(row.failedAt as unknown as string)
           : undefined,
       }
     })
@@ -190,7 +190,7 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
 
   async getDistinctWorkflowNames(): Promise<string[]> {
     const result = await this.db
-      .selectFrom('workflow_runs')
+      .selectFrom('workflowRuns')
       .select('workflow')
       .distinct()
       .orderBy('workflow')
@@ -204,10 +204,10 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
     graphHash: string
   ): Promise<{ graph: any; source: string } | null> {
     const row = await this.db
-      .selectFrom('workflow_versions')
+      .selectFrom('workflowVersions')
       .select(['graph', 'source'])
-      .where('workflow_name', '=', name)
-      .where('graph_hash', '=', graphHash)
+      .where('workflowName', '=', name)
+      .where('graphHash', '=', graphHash)
       .executeTakeFirst()
 
     if (!row) return null
@@ -221,25 +221,25 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
     agentName?: string
   ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>> {
     let query = this.db
-      .selectFrom('workflow_versions')
-      .select(['workflow_name', 'graph_hash', 'graph'])
+      .selectFrom('workflowVersions')
+      .select(['workflowName', 'graphHash', 'graph'])
       .where('source', '=', 'ai-agent')
       .where('status', '=', 'active')
     if (agentName) {
-      query = query.where('workflow_name', 'like', `ai:${agentName}:%`)
+      query = query.where('workflowName', 'like', `ai:${agentName}:%`)
     }
     const rows = await query.execute()
     return rows.map((row) => ({
-      workflowName: row.workflow_name,
-      graphHash: row.graph_hash,
+      workflowName: row.workflowName,
+      graphHash: row.graphHash,
       graph: parseJson(row.graph),
     }))
   }
 
   async deleteRun(id: string): Promise<boolean> {
     const result = await this.db
-      .deleteFrom('workflow_runs')
-      .where('workflow_run_id', '=', id)
+      .deleteFrom('workflowRuns')
+      .where('workflowRunId', '=', id)
       .executeTakeFirst()
 
     return BigInt(result.numDeletedRows) > 0n
@@ -247,17 +247,17 @@ export class KyselyWorkflowRunService implements WorkflowRunService {
 
   private mapRunRow(row: any): WorkflowRun {
     return {
-      id: row.workflow_run_id as string,
+      id: row.workflowRunId as string,
       workflow: row.workflow as string,
       status: row.status as WorkflowStatus,
       input: parseJson(row.input),
       output: parseJson(row.output),
       error: parseJson(row.error),
       inline: row.inline as boolean | undefined,
-      graphHash: row.graph_hash as string | undefined,
+      graphHash: row.graphHash as string | undefined,
       wire: parseJson(row.wire) ?? { type: 'unknown' },
-      createdAt: new Date(row.created_at as string),
-      updatedAt: new Date(row.updated_at as string),
+      createdAt: new Date(row.createdAt as string),
+      updatedAt: new Date(row.updatedAt as string),
     }
   }
 }