@pikku/kysely 0.12.6 → 0.12.8

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

@@ -1,19 +1,19 @@
 import type { Generated } from 'kysely';
 import type { WorkflowStatus, StepStatus, WorkflowVersionStatus } 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;
@@ -21,154 +21,154 @@ 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' | 'credential' | '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/dist/src/kysely-workflow-run-service.js

@@ -7,19 +7,19 @@ export class KyselyWorkflowRunService {
     async listRuns(options) {
         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) {
             query = query.where('workflow', '=', workflowName);
@@ -28,7 +28,7 @@ export class KyselyWorkflowRunService {
             query = query.where('status', '=', status);
         }
         const result = await query
-            .orderBy('created_at', 'desc')
+            .orderBy('createdAt', 'desc')
             .limit(limit)
             .offset(offset)
             .execute();
@@ -36,21 +36,21 @@ export class KyselyWorkflowRunService {
     }
     async getRun(id) {
         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;
@@ -58,99 +58,99 @@ export class KyselyWorkflowRunService {
     }
     async getRunSteps(runId) {
         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().as('cnt'))
-            .whereRef('workflow_step_history.workflow_step_id', '=', 's.workflow_step_id')
-            .as('attempt_count'))
-            .where('s.workflow_run_id', '=', runId)
-            .orderBy('s.created_at', 'asc')
+            .whereRef('workflowStepHistory.workflowStepId', '=', 's.workflowStepId')
+            .as('attemptCount'))
+            .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,
             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),
-            updatedAt: new Date(row.updated_at),
+            retryDelay: row.retryDelay ?? undefined,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
         }));
     }
     async getRunHistory(runId) {
         const result = await this.db
-            .selectFrom('workflow_step as s')
-            .innerJoin('workflow_step_history as h', 'h.workflow_step_id', 's.workflow_step_id')
+            .selectFrom('workflowStep as s')
+            .innerJoin('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 = {};
         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,
                 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),
-                updatedAt: new Date(row.created_at),
-                runningAt: row.running_at
-                    ? new Date(row.running_at)
+                retryDelay: row.retryDelay ?? undefined,
+                createdAt: new Date(row.createdAt),
+                updatedAt: new Date(row.createdAt),
+                runningAt: row.runningAt
+                    ? new Date(row.runningAt)
                     : undefined,
-                scheduledAt: row.scheduled_at
-                    ? new Date(row.scheduled_at)
+                scheduledAt: row.scheduledAt
+                    ? new Date(row.scheduledAt)
                     : undefined,
-                succeededAt: row.succeeded_at
-                    ? new Date(row.succeeded_at)
+                succeededAt: row.succeededAt
+                    ? new Date(row.succeededAt)
                     : undefined,
-                failedAt: row.failed_at
-                    ? new Date(row.failed_at)
+                failedAt: row.failedAt
+                    ? new Date(row.failedAt)
                     : undefined,
             };
         });
     }
     async getDistinctWorkflowNames() {
         const result = await this.db
-            .selectFrom('workflow_runs')
+            .selectFrom('workflowRuns')
             .select('workflow')
             .distinct()
             .orderBy('workflow')
@@ -159,10 +159,10 @@ export class KyselyWorkflowRunService {
     }
     async getWorkflowVersion(name, graphHash) {
         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;
@@ -173,40 +173,40 @@ export class KyselyWorkflowRunService {
     }
     async getAIGeneratedWorkflows(agentName) {
         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) {
         const result = await this.db
-            .deleteFrom('workflow_runs')
-            .where('workflow_run_id', '=', id)
+            .deleteFrom('workflowRuns')
+            .where('workflowRunId', '=', id)
             .executeTakeFirst();
         return BigInt(result.numDeletedRows) > 0n;
     }
     mapRunRow(row) {
         return {
-            id: row.workflow_run_id,
+            id: row.workflowRunId,
             workflow: row.workflow,
             status: row.status,
             input: parseJson(row.input),
             output: parseJson(row.output),
             error: parseJson(row.error),
             inline: row.inline,
-            graphHash: row.graph_hash,
+            graphHash: row.graphHash,
             wire: parseJson(row.wire) ?? { type: 'unknown' },
-            createdAt: new Date(row.created_at),
-            updatedAt: new Date(row.updated_at),
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
         };
     }
 }