@pikku/kysely 0.11.0 → 0.12.0

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

@@ -0,0 +1,485 @@
+import { PikkuWorkflowService, } from '@pikku/core/workflow';
+import { sql } from 'kysely';
+import { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
+import { parseJson } from './kysely-json.js';
+export class KyselyWorkflowService extends PikkuWorkflowService {
+    db;
+    initialized = false;
+    runService;
+    constructor(db) {
+        super();
+        this.db = db;
+        this.runService = new KyselyWorkflowRunService(db);
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        await this.db.schema
+            .createTable('workflow_runs')
+            .ifNotExists()
+            .addColumn('workflow_run_id', 'text', (col) => col
+            .primaryKey()
+            .defaultTo(sql `${sql.raw("'" + crypto.randomUUID() + "'")}`))
+            .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('inline', 'boolean', (col) => col.defaultTo(false))
+            .addColumn('graph_hash', 'text')
+            .addColumn('wire', '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.db.schema
+            .createTable('workflow_step')
+            .ifNotExists()
+            .addColumn('workflow_step_id', 'text', (col) => col
+            .primaryKey()
+            .defaultTo(sql `${sql.raw("'" + crypto.randomUUID() + "'")}`))
+            .addColumn('workflow_run_id', 'text', (col) => col
+            .notNull()
+            .references('workflow_runs.workflow_run_id')
+            .onDelete('cascade'))
+            .addColumn('step_name', 'text', (col) => col.notNull())
+            .addColumn('rpc_name', 'text')
+            .addColumn('data', 'text')
+            .addColumn('status', 'text', (col) => col.notNull().defaultTo('pending'))
+            .addColumn('result', 'text')
+            .addColumn('error', 'text')
+            .addColumn('branch_taken', 'text')
+            .addColumn('retries', 'integer')
+            .addColumn('retry_delay', 'text')
+            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addUniqueConstraint('workflow_step_run_name_unique', [
+            'workflow_run_id',
+            'step_name',
+        ])
+            .execute();
+        await this.db.schema
+            .createTable('workflow_step_history')
+            .ifNotExists()
+            .addColumn('history_id', 'text', (col) => col
+            .primaryKey()
+            .defaultTo(sql `${sql.raw("'" + crypto.randomUUID() + "'")}`))
+            .addColumn('workflow_step_id', 'text', (col) => col
+            .notNull()
+            .references('workflow_step.workflow_step_id')
+            .onDelete('cascade'))
+            .addColumn('status', 'text', (col) => col.notNull())
+            .addColumn('result', 'text')
+            .addColumn('error', 'text')
+            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addColumn('running_at', 'timestamp')
+            .addColumn('scheduled_at', 'timestamp')
+            .addColumn('succeeded_at', 'timestamp')
+            .addColumn('failed_at', 'timestamp')
+            .execute();
+        await this.db.schema
+            .createTable('workflow_versions')
+            .ifNotExists()
+            .addColumn('workflow_name', 'text', (col) => col.notNull())
+            .addColumn('graph_hash', 'text', (col) => col.notNull())
+            .addColumn('graph', 'text', (col) => col.notNull())
+            .addColumn('source', 'text', (col) => col.notNull())
+            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addPrimaryKeyConstraint('workflow_versions_pk', [
+            'workflow_name',
+            'graph_hash',
+        ])
+            .execute();
+        this.initialized = true;
+    }
+    async createRun(workflowName, input, inline, graphHash, wire) {
+        const id = crypto.randomUUID();
+        await this.db
+            .insertInto('workflow_runs')
+            .values({
+            workflow_run_id: id,
+            workflow: workflowName,
+            status: 'running',
+            input: JSON.stringify(input),
+            inline,
+            graph_hash: graphHash,
+            wire: JSON.stringify(wire),
+        })
+            .execute();
+        return id;
+    }
+    async getRun(id) {
+        return this.runService.getRun(id);
+    }
+    async updateRunStatus(id, status, output, error) {
+        await this.db
+            .updateTable('workflow_runs')
+            .set({
+            status,
+            output: output ? JSON.stringify(output) : null,
+            error: error ? JSON.stringify(error) : null,
+            updated_at: new Date(),
+        })
+            .where('workflow_run_id', '=', id)
+            .execute();
+    }
+    async insertStepState(runId, stepName, rpcName, data, stepOptions) {
+        const stepId = crypto.randomUUID();
+        const now = new Date();
+        await this.db
+            .insertInto('workflow_step')
+            .values({
+            workflow_step_id: stepId,
+            workflow_run_id: runId,
+            step_name: stepName,
+            rpc_name: rpcName,
+            data: data != null ? JSON.stringify(data) : null,
+            status: 'pending',
+            retries: stepOptions?.retries ?? null,
+            retry_delay: stepOptions?.retryDelay?.toString() ?? null,
+            created_at: now,
+            updated_at: now,
+        })
+            .execute();
+        await this.insertHistoryRecord(stepId, 'pending');
+        return {
+            stepId,
+            status: 'pending',
+            result: undefined,
+            error: undefined,
+            attemptCount: 1,
+            retries: stepOptions?.retries,
+            retryDelay: stepOptions?.retryDelay?.toString(),
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    async getStepState(runId, stepName) {
+        const row = await this.db
+            .selectFrom('workflow_step as s')
+            .select([
+            's.workflow_step_id',
+            's.status',
+            's.result',
+            's.error',
+            's.retries',
+            's.retry_delay',
+            's.created_at',
+            's.updated_at',
+        ])
+            .select((eb) => eb
+            .selectFrom('workflow_step_history')
+            .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)
+            .where('s.step_name', '=', stepName)
+            .executeTakeFirst();
+        if (!row) {
+            throw new Error(`Step not found: runId=${runId}, stepName=${stepName}. Use insertStepState to create it.`);
+        }
+        return {
+            stepId: row.workflow_step_id,
+            status: row.status,
+            result: parseJson(row.result),
+            error: parseJson(row.error),
+            attemptCount: Number(row.attempt_count),
+            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),
+        };
+    }
+    async getRunHistory(runId) {
+        return this.runService.getRunHistory(runId);
+    }
+    async setStepRunning(stepId) {
+        await this.db
+            .updateTable('workflow_step')
+            .set({ status: 'running', updated_at: new Date() })
+            .where('workflow_step_id', '=', stepId)
+            .execute();
+        const latestHistory = await this.db
+            .selectFrom('workflow_step_history')
+            .select('history_id')
+            .where('workflow_step_id', '=', stepId)
+            .orderBy('created_at', 'desc')
+            .limit(1)
+            .executeTakeFirst();
+        if (latestHistory) {
+            await this.db
+                .updateTable('workflow_step_history')
+                .set({ status: 'running' })
+                .where('history_id', '=', latestHistory.history_id)
+                .execute();
+        }
+    }
+    async setStepScheduled(stepId) {
+        await this.db
+            .updateTable('workflow_step')
+            .set({ status: 'scheduled', updated_at: new Date() })
+            .where('workflow_step_id', '=', stepId)
+            .execute();
+    }
+    async insertHistoryRecord(stepId, status, result, error) {
+        const now = new Date();
+        const values = {
+            history_id: crypto.randomUUID(),
+            workflow_step_id: stepId,
+            status,
+            result: result != null ? JSON.stringify(result) : null,
+            error: error != null ? JSON.stringify(error) : null,
+            created_at: now,
+        };
+        const timestampField = this.getTimestampFieldForStatus(status);
+        if (timestampField !== 'created_at') {
+            values[timestampField] = now;
+        }
+        await this.db
+            .insertInto('workflow_step_history')
+            .values(values)
+            .execute();
+    }
+    getTimestampFieldForStatus(status) {
+        switch (status) {
+            case 'running':
+                return 'running_at';
+            case 'scheduled':
+                return 'scheduled_at';
+            case 'succeeded':
+                return 'succeeded_at';
+            case 'failed':
+                return 'failed_at';
+            default:
+                return 'created_at';
+        }
+    }
+    async setStepResult(stepId, result) {
+        const resultJson = JSON.stringify(result);
+        await this.db
+            .updateTable('workflow_step')
+            .set({
+            status: 'succeeded',
+            result: resultJson,
+            error: null,
+            updated_at: new Date(),
+        })
+            .where('workflow_step_id', '=', stepId)
+            .execute();
+        const latestHistory = await this.db
+            .selectFrom('workflow_step_history')
+            .select('history_id')
+            .where('workflow_step_id', '=', stepId)
+            .orderBy('created_at', 'desc')
+            .limit(1)
+            .executeTakeFirst();
+        if (latestHistory) {
+            await this.db
+                .updateTable('workflow_step_history')
+                .set({ status: 'succeeded', result: resultJson })
+                .where('history_id', '=', latestHistory.history_id)
+                .execute();
+        }
+    }
+    async setStepError(stepId, error) {
+        const serializedError = {
+            message: error.message,
+            stack: error.stack,
+            code: error.code,
+        };
+        const errorJson = JSON.stringify(serializedError);
+        await this.db
+            .updateTable('workflow_step')
+            .set({
+            status: 'failed',
+            error: errorJson,
+            result: null,
+            updated_at: new Date(),
+        })
+            .where('workflow_step_id', '=', stepId)
+            .execute();
+        const latestHistory = await this.db
+            .selectFrom('workflow_step_history')
+            .select('history_id')
+            .where('workflow_step_id', '=', stepId)
+            .orderBy('created_at', 'desc')
+            .limit(1)
+            .executeTakeFirst();
+        if (latestHistory) {
+            await this.db
+                .updateTable('workflow_step_history')
+                .set({ status: 'failed', error: errorJson })
+                .where('history_id', '=', latestHistory.history_id)
+                .execute();
+        }
+    }
+    async createRetryAttempt(stepId, status) {
+        await this.db
+            .updateTable('workflow_step')
+            .set({ status, result: null, error: null, updated_at: new Date() })
+            .where('workflow_step_id', '=', stepId)
+            .execute();
+        await this.insertHistoryRecord(stepId, status);
+        const row = await this.db
+            .selectFrom('workflow_step as s')
+            .select([
+            's.workflow_step_id',
+            's.status',
+            's.result',
+            's.error',
+            's.retries',
+            's.retry_delay',
+            's.created_at',
+            's.updated_at',
+        ])
+            .select((eb) => eb
+            .selectFrom('workflow_step_history')
+            .select(eb.fn.countAll().as('cnt'))
+            .whereRef('workflow_step_history.workflow_step_id', '=', 's.workflow_step_id')
+            .as('attempt_count'))
+            .where('s.workflow_step_id', '=', stepId)
+            .executeTakeFirstOrThrow();
+        return {
+            stepId: row.workflow_step_id,
+            status: row.status,
+            result: parseJson(row.result),
+            error: parseJson(row.error),
+            attemptCount: Number(row.attempt_count),
+            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),
+        };
+    }
+    async withRunLock(id, fn) {
+        return this.db.transaction().execute(async (trx) => {
+            await trx
+                .selectFrom('workflow_runs')
+                .select('workflow_run_id')
+                .where('workflow_run_id', '=', id)
+                .forUpdate()
+                .executeTakeFirst();
+            return fn();
+        });
+    }
+    async withStepLock(runId, stepName, fn) {
+        return this.db.transaction().execute(async (trx) => {
+            await trx
+                .selectFrom('workflow_step')
+                .select('workflow_step_id')
+                .where('workflow_run_id', '=', runId)
+                .where('step_name', '=', stepName)
+                .forUpdate()
+                .executeTakeFirst();
+            return fn();
+        });
+    }
+    async getCompletedGraphState(runId) {
+        const results = await this.db
+            .selectFrom('workflow_step as ws')
+            .select(['ws.step_name', 'ws.status', 'ws.branch_taken', 'ws.retries'])
+            .select((eb) => eb
+            .selectFrom('workflow_step_history as h')
+            .select(eb.fn.countAll().as('cnt'))
+            .whereRef('h.workflow_step_id', '=', 'ws.workflow_step_id')
+            .as('attempt_count'))
+            .where('ws.workflow_run_id', '=', runId)
+            .where('ws.status', 'in', ['succeeded', 'failed'])
+            .execute();
+        const completedNodeIds = [];
+        const failedNodeIds = [];
+        const branchKeys = {};
+        for (const row of results) {
+            const nodeId = row.step_name;
+            if (row.status === 'succeeded') {
+                completedNodeIds.push(nodeId);
+                if (row.branch_taken) {
+                    branchKeys[nodeId] = row.branch_taken;
+                }
+            }
+            else if (row.status === 'failed') {
+                const maxAttempts = (row.retries ?? 0) + 1;
+                if (Number(row.attempt_count) >= maxAttempts) {
+                    failedNodeIds.push(nodeId);
+                }
+            }
+        }
+        return { completedNodeIds, failedNodeIds, branchKeys };
+    }
+    async getNodesWithoutSteps(runId, nodeIds) {
+        if (nodeIds.length === 0)
+            return [];
+        const result = await this.db
+            .selectFrom('workflow_step')
+            .select('step_name')
+            .where('workflow_run_id', '=', runId)
+            .where('step_name', 'in', nodeIds)
+            .execute();
+        const existingStepNames = new Set(result.map((r) => r.step_name));
+        return nodeIds.filter((id) => !existingStepNames.has(id));
+    }
+    async getNodeResults(runId, nodeIds) {
+        if (nodeIds.length === 0)
+            return {};
+        const result = await this.db
+            .selectFrom('workflow_step')
+            .select(['step_name', 'result'])
+            .where('workflow_run_id', '=', runId)
+            .where('step_name', 'in', nodeIds)
+            .where('status', '=', 'succeeded')
+            .execute();
+        const results = {};
+        for (const row of result) {
+            results[row.step_name] = parseJson(row.result);
+        }
+        return results;
+    }
+    async setBranchTaken(stepId, branchKey) {
+        await this.db
+            .updateTable('workflow_step')
+            .set({ branch_taken: branchKey, updated_at: new Date() })
+            .where('workflow_step_id', '=', stepId)
+            .execute();
+    }
+    async updateRunState(runId, name, value) {
+        const row = await this.db
+            .selectFrom('workflow_runs')
+            .select('state')
+            .where('workflow_run_id', '=', runId)
+            .executeTakeFirst();
+        const state = parseJson(row?.state) ?? {};
+        state[name] = value;
+        await this.db
+            .updateTable('workflow_runs')
+            .set({ state: JSON.stringify(state), updated_at: new Date() })
+            .where('workflow_run_id', '=', runId)
+            .execute();
+    }
+    async getRunState(runId) {
+        const row = await this.db
+            .selectFrom('workflow_runs')
+            .select('state')
+            .where('workflow_run_id', '=', runId)
+            .executeTakeFirst();
+        if (!row)
+            return {};
+        return parseJson(row.state) ?? {};
+    }
+    async upsertWorkflowVersion(name, graphHash, graph, source) {
+        await this.db
+            .insertInto('workflow_versions')
+            .values({
+            workflow_name: name,
+            graph_hash: graphHash,
+            graph: JSON.stringify(graph),
+            source,
+        })
+            .onConflict((oc) => oc.columns(['workflow_name', 'graph_hash']).doNothing())
+            .execute();
+    }
+    async getWorkflowVersion(name, graphHash) {
+        return this.runService.getWorkflowVersion(name, graphHash);
+    }
+    async close() { }
+}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/pikku-kysely.ts","../bin/pikku-kysely-pure.ts"],"version":"5.9.3"}
+{"root":["../src/index.ts","../src/kysely-agent-run-service.ts","../src/kysely-ai-storage-service.ts","../src/kysely-channel-store.ts","../src/kysely-deployment-service.ts","../src/kysely-eventhub-store.ts","../src/kysely-json.ts","../src/kysely-tables.ts","../src/kysely-workflow-run-service.ts","../src/kysely-workflow-service.ts","../src/pikku-kysely.ts","../bin/pikku-kysely-pure.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/src/index.js",
@@ -13,21 +13,27 @@
     "tsc": "tsc",
     "ncu": "npx npm-check-updates",
     "build": "tsc -b",
+    "test": "bash run-tests.sh",
+    "test:watch": "bash run-tests.sh --watch",
+    "test:coverage": "bash run-tests.sh --coverage",
     "release": "npm run build && npm test"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.11.0"
+    "@pikku/core": "^0.12.0"
   },
   "dependencies": {
-    "kysely": "^0.28.8",
+    "kysely": "^0.28.11",
     "kysely-postgres-js": "^3.0.0",
-    "postgres": "^3.4.7"
+    "postgres": "^3.4.8"
   },
   "devDependencies": {
-    "kysely": "^0.28.8",
+    "@types/better-sqlite3": "^7.6.13",
+    "better-sqlite3": "^12.6.2",
+    "kysely": "^0.28.11",
     "kysely-codegen": "^0.19.0",
+    "kysely-plugin-serialize": "^0.8.2",
     "kysely-postgres-js": "^3.0.0",
-    "postgres": "^3.4.7",
+    "postgres": "^3.4.8",
     "typescript": "^5.9"
   }
 }

package/src/index.ts

@@ -1 +1,13 @@
 export { PikkuKysely } from './pikku-kysely.js'
+
+export { KyselyChannelStore } from './kysely-channel-store.js'
+export { KyselyEventHubStore } from './kysely-eventhub-store.js'
+export { KyselyWorkflowService } from './kysely-workflow-service.js'
+export { KyselyWorkflowRunService } from './kysely-workflow-run-service.js'
+export { KyselyDeploymentService } from './kysely-deployment-service.js'
+export { KyselyAIStorageService } from './kysely-ai-storage-service.js'
+export { KyselyAgentRunService } from './kysely-agent-run-service.js'
+
+export type { KyselyPikkuDB } from './kysely-tables.js'
+export type { WorkflowRunService } from '@pikku/core/workflow'
+export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent'