@pikku/kysely 0.12.10 → 0.12.12

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

@@ -0,0 +1,329 @@
+import { sql } from 'kysely';
+/**
+ * Kysely-backed `WorkflowRunMirror`.
+ *
+ * Forwards executor writes to the same `workflow_runs` / `workflow_step` /
+ * `workflow_step_history` / `workflow_versions` tables that
+ * `KyselyWorkflowService` uses, so a `KyselyWorkflowRunService` reading
+ * those tables will see runs driven by any executor (Cloudflare Durable
+ * Object, Redis, MongoDB, in-memory) — not just kysely-driven runs.
+ *
+ * Errors thrown here are caught by the executor's `safeMirror` wrapper
+ * and logged, so a mirror outage cannot break a running workflow.
+ */
+export class KyselyWorkflowMirror {
+    db;
+    initialized = false;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Create the underlying tables if they don't exist. Safe to call from
+     * either the mirror or `KyselyWorkflowService.init()` — schema is the
+     * same and uses `ifNotExists`.
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        await this.db.schema
+            .createTable('workflow_runs')
+            .ifNotExists()
+            .addColumn('workflow_run_id', 'text', (col) => col.primaryKey())
+            .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('deterministic', 'boolean', (col) => col.defaultTo(false))
+            .addColumn('planned_steps', '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())
+            .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('child_run_id', '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())
+            .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('status', 'text', (col) => col.notNull().defaultTo('active'))
+            .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(runId, workflowName, input, inline, graphHash, wire, options) {
+        await this.db
+            .insertInto('workflowRuns')
+            .values({
+            workflowRunId: runId,
+            workflow: workflowName,
+            status: 'running',
+            input: JSON.stringify(input),
+            inline,
+            graphHash: graphHash ?? null,
+            deterministic: options?.deterministic ?? false,
+            plannedSteps: options?.plannedSteps
+                ? JSON.stringify(options.plannedSteps)
+                : null,
+            wire: wire ? JSON.stringify(wire) : null,
+        })
+            .execute();
+    }
+    async updateRunStatus(id, status, output, error) {
+        await this.db
+            .updateTable('workflowRuns')
+            .set({
+            status,
+            output: output !== undefined ? JSON.stringify(output) : null,
+            error: error !== undefined ? JSON.stringify(error) : null,
+            updatedAt: new Date(),
+        })
+            .where('workflowRunId', '=', id)
+            .execute();
+    }
+    async insertStepState(runId, step) {
+        const now = step.createdAt ?? new Date();
+        await this.db
+            .insertInto('workflowStep')
+            .values({
+            workflowStepId: step.stepId,
+            workflowRunId: runId,
+            stepName: step.stepName,
+            rpcName: step.rpcName,
+            data: step.data != null ? JSON.stringify(step.data) : null,
+            status: step.status,
+            retries: step.retries ?? null,
+            retryDelay: step.retryDelay?.toString() ?? null,
+            createdAt: now,
+            updatedAt: now,
+        })
+            .execute();
+        await this.insertHistoryRecord(step.stepId, step.status);
+    }
+    async setStepRunning(stepId) {
+        await this.updateStepStatus(stepId, 'running');
+        await this.appendOrUpdateLatestHistory(stepId, 'running');
+    }
+    async setStepScheduled(stepId) {
+        await this.updateStepStatus(stepId, 'scheduled');
+    }
+    async setStepResult(stepId, result) {
+        const resultJson = JSON.stringify(result);
+        await this.db
+            .updateTable('workflowStep')
+            .set({
+            status: 'succeeded',
+            result: resultJson,
+            error: null,
+            updatedAt: new Date(),
+        })
+            .where('workflowStepId', '=', stepId)
+            .execute();
+        await this.appendOrUpdateLatestHistory(stepId, 'succeeded', resultJson);
+    }
+    async setStepChildRunId(stepId, childRunId) {
+        await this.db
+            .updateTable('workflowStep')
+            .set({ childRunId, updatedAt: new Date() })
+            .where('workflowStepId', '=', stepId)
+            .execute();
+    }
+    async setStepError(stepId, error) {
+        const errorJson = JSON.stringify(error);
+        await this.db
+            .updateTable('workflowStep')
+            .set({
+            status: 'failed',
+            error: errorJson,
+            result: null,
+            updatedAt: new Date(),
+        })
+            .where('workflowStepId', '=', stepId)
+            .execute();
+        await this.appendOrUpdateLatestHistory(stepId, 'failed', undefined, errorJson);
+    }
+    async createRetryAttempt(failedStepId, newStep) {
+        await this.db
+            .updateTable('workflowStep')
+            .set({
+            status: newStep.status,
+            result: null,
+            error: null,
+            updatedAt: new Date(),
+        })
+            .where('workflowStepId', '=', failedStepId)
+            .execute();
+        await this.insertHistoryRecord(failedStepId, newStep.status);
+    }
+    async setBranchTaken(stepId, branchKey) {
+        await this.db
+            .updateTable('workflowStep')
+            .set({ branchTaken: branchKey, updatedAt: new Date() })
+            .where('workflowStepId', '=', stepId)
+            .execute();
+    }
+    async updateRunState(runId, name, value) {
+        const row = await this.db
+            .selectFrom('workflowRuns')
+            .select('state')
+            .where('workflowRunId', '=', runId)
+            .executeTakeFirst();
+        const state = row?.state != null
+            ? typeof row.state === 'string'
+                ? JSON.parse(row.state)
+                : row.state
+            : {};
+        state[name] = value;
+        await this.db
+            .updateTable('workflowRuns')
+            .set({ state: JSON.stringify(state), updatedAt: new Date() })
+            .where('workflowRunId', '=', runId)
+            .execute();
+    }
+    async upsertWorkflowVersion(name, graphHash, graph, source, status = 'active') {
+        await this.db
+            .insertInto('workflowVersions')
+            .values({
+            workflowName: name,
+            graphHash,
+            graph: JSON.stringify(graph),
+            source,
+            status,
+        })
+            .onConflict((oc) => oc.columns(['workflowName', 'graphHash']).doNothing())
+            .execute();
+    }
+    async updateWorkflowVersionStatus(name, graphHash, status) {
+        await this.db
+            .updateTable('workflowVersions')
+            .set({ status })
+            .where('workflowName', '=', name)
+            .where('graphHash', '=', graphHash)
+            .execute();
+    }
+    // ─── internals ────────────────────────────────────────────────────
+    async updateStepStatus(stepId, status) {
+        await this.db
+            .updateTable('workflowStep')
+            .set({ status, updatedAt: new Date() })
+            .where('workflowStepId', '=', stepId)
+            .execute();
+    }
+    async insertHistoryRecord(stepId, status, resultJson, errorJson) {
+        const now = new Date();
+        const values = {
+            historyId: crypto.randomUUID(),
+            workflowStepId: stepId,
+            status,
+            result: resultJson ?? null,
+            error: errorJson ?? null,
+            createdAt: now,
+        };
+        const tsField = timestampFieldFor(status);
+        if (tsField)
+            values[tsField] = now;
+        await this.db
+            .insertInto('workflowStepHistory')
+            .values(values)
+            .execute();
+    }
+    /**
+     * The executor pattern is: `insertStepState` writes a 'pending' history
+     * row, then later transitions UPDATE that latest row in place rather
+     * than appending a new one — except for retry attempts which append.
+     *
+     * We mirror the same shape so `KyselyWorkflowRunService.getRunHistory`
+     * returns the same sequence the executor would have produced.
+     */
+    async appendOrUpdateLatestHistory(stepId, status, resultJson, errorJson) {
+        const latest = await this.db
+            .selectFrom('workflowStepHistory')
+            .select('historyId')
+            .where('workflowStepId', '=', stepId)
+            .orderBy('createdAt', 'desc')
+            .limit(1)
+            .executeTakeFirst();
+        if (latest) {
+            const update = { status };
+            if (resultJson !== undefined)
+                update.result = resultJson;
+            if (errorJson !== undefined)
+                update.error = errorJson;
+            const tsField = timestampFieldFor(status);
+            if (tsField)
+                update[tsField] = new Date();
+            await this.db
+                .updateTable('workflowStepHistory')
+                .set(update)
+                .where('historyId', '=', latest.historyId)
+                .execute();
+        }
+        else {
+            await this.insertHistoryRecord(stepId, status, resultJson, errorJson);
+        }
+    }
+}
+function timestampFieldFor(status) {
+    switch (status) {
+        case 'running':
+            return 'runningAt';
+        case 'scheduled':
+            return 'scheduledAt';
+        case 'succeeded':
+            return 'succeededAt';
+        case 'failed':
+            return 'failedAt';
+        default:
+            return null;
+    }
+}

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

@@ -17,6 +17,8 @@ export class KyselyWorkflowRunService {
             'error',
             'inline',
             'graphHash',
+            'deterministic',
+            'plannedSteps',
             'wire',
             'createdAt',
             'updatedAt',
@@ -46,6 +48,8 @@ export class KyselyWorkflowRunService {
             'error',
             'inline',
             'graphHash',
+            'deterministic',
+            'plannedSteps',
             'wire',
             'createdAt',
             'updatedAt',
@@ -204,6 +208,8 @@ export class KyselyWorkflowRunService {
             error: parseJson(row.error),
             inline: row.inline,
             graphHash: row.graphHash,
+            deterministic: row.deterministic,
+            plannedSteps: parseJson(row.plannedSteps),
             wire: parseJson(row.wire) ?? { type: 'unknown' },
             createdAt: new Date(row.createdAt),
             updatedAt: new Date(row.updatedAt),

package/dist/src/kysely-workflow-service.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedError } from '@pikku/core';
-import { PikkuWorkflowService, type WorkflowRun, type WorkflowRunWire, type StepState, type WorkflowStatus, type WorkflowVersionStatus } from '@pikku/core/workflow';
+import { PikkuWorkflowService, type WorkflowPlannedStep, type WorkflowRun, type WorkflowRunWire, type StepState, type WorkflowStatus, type WorkflowVersionStatus } from '@pikku/core/workflow';
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 export declare class KyselyWorkflowService extends PikkuWorkflowService {
@@ -8,10 +8,13 @@ export declare class KyselyWorkflowService extends PikkuWorkflowService {
     private runService;
     constructor(db: Kysely<KyselyPikkuDB>);
     init(): Promise<void>;
-    createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire): Promise<string>;
+    protected createRunImpl(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire, options?: {
+        deterministic?: boolean;
+        plannedSteps?: WorkflowPlannedStep[];
+    }): Promise<string>;
     getRun(id: string): Promise<WorkflowRun | null>;
-    updateRunStatus(id: string, status: WorkflowStatus, output?: any, error?: SerializedError): Promise<void>;
-    insertStepState(runId: string, stepName: string, rpcName: string | null, data: any, stepOptions?: {
+    protected updateRunStatusImpl(id: string, status: WorkflowStatus, output?: any, error?: SerializedError): Promise<void>;
+    protected insertStepStateImpl(runId: string, stepName: string, rpcName: string | null, data: any, stepOptions?: {
         retries?: number;
         retryDelay?: string | number;
     }): Promise<StepState>;
@@ -19,14 +22,14 @@ export declare class KyselyWorkflowService extends PikkuWorkflowService {
     getRunHistory(runId: string): Promise<Array<StepState & {
         stepName: string;
     }>>;
-    setStepRunning(stepId: string): Promise<void>;
-    setStepScheduled(stepId: string): Promise<void>;
+    protected setStepRunningImpl(stepId: string): Promise<void>;
+    protected setStepScheduledImpl(stepId: string): Promise<void>;
     private insertHistoryRecord;
     private getTimestampFieldForStatus;
-    setStepChildRunId(stepId: string, childRunId: string): Promise<void>;
-    setStepResult(stepId: string, result: any): Promise<void>;
-    setStepError(stepId: string, error: Error): Promise<void>;
-    createRetryAttempt(stepId: string, status: 'pending' | 'running'): Promise<StepState>;
+    protected setStepChildRunIdImpl(stepId: string, childRunId: string): Promise<void>;
+    protected setStepResultImpl(stepId: string, result: any): Promise<void>;
+    protected setStepErrorImpl(stepId: string, error: Error): Promise<void>;
+    protected createRetryAttemptImpl(stepId: string, status: 'pending' | 'running'): Promise<StepState>;
     withRunLock<T>(_id: string, fn: () => Promise<T>): Promise<T>;
     withStepLock<T>(_runId: string, _stepName: string, fn: () => Promise<T>): Promise<T>;
     getCompletedGraphState(runId: string): Promise<{
@@ -36,11 +39,11 @@ export declare class KyselyWorkflowService extends PikkuWorkflowService {
     }>;
     getNodesWithoutSteps(runId: string, nodeIds: string[]): Promise<string[]>;
     getNodeResults(runId: string, nodeIds: string[]): Promise<Record<string, any>>;
-    setBranchTaken(stepId: string, branchKey: string): Promise<void>;
-    updateRunState(runId: string, name: string, value: unknown): Promise<void>;
+    protected setBranchTakenImpl(stepId: string, branchKey: string): Promise<void>;
+    protected updateRunStateImpl(runId: string, name: string, value: unknown): Promise<void>;
     getRunState(runId: string): Promise<Record<string, unknown>>;
-    upsertWorkflowVersion(name: string, graphHash: string, graph: any, source: string, status?: WorkflowVersionStatus): Promise<void>;
-    updateWorkflowVersionStatus(name: string, graphHash: string, status: WorkflowVersionStatus): Promise<void>;
+    protected upsertWorkflowVersionImpl(name: string, graphHash: string, graph: any, source: string, status?: WorkflowVersionStatus): Promise<void>;
+    protected updateWorkflowVersionStatusImpl(name: string, graphHash: string, status: WorkflowVersionStatus): Promise<void>;
     getWorkflowVersion(name: string, graphHash: string): Promise<{
         graph: any;
         source: string;

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

@@ -29,6 +29,8 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .addColumn('state', 'text', (col) => col.defaultTo('{}'))
             .addColumn('inline', 'boolean', (col) => col.defaultTo(false))
             .addColumn('graph_hash', 'text')
+            .addColumn('deterministic', 'boolean', (col) => col.defaultTo(false))
+            .addColumn('planned_steps', '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())
@@ -95,7 +97,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .execute();
         this.initialized = true;
     }
-    async createRun(workflowName, input, inline, graphHash, wire) {
+    async createRunImpl(workflowName, input, inline, graphHash, wire, options) {
         const id = crypto.randomUUID();
         await this.db
             .insertInto('workflowRuns')
@@ -106,6 +108,10 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             input: JSON.stringify(input),
             inline,
             graphHash: graphHash ?? null,
+            deterministic: options?.deterministic ?? false,
+            plannedSteps: options?.plannedSteps
+                ? JSON.stringify(options.plannedSteps)
+                : null,
             wire: wire ? JSON.stringify(wire) : null,
         })
             .execute();
@@ -114,7 +120,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
     async getRun(id) {
         return this.runService.getRun(id);
     }
-    async updateRunStatus(id, status, output, error) {
+    async updateRunStatusImpl(id, status, output, error) {
         await this.db
             .updateTable('workflowRuns')
             .set({
@@ -126,7 +132,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .where('workflowRunId', '=', id)
             .execute();
     }
-    async insertStepState(runId, stepName, rpcName, data, stepOptions) {
+    async insertStepStateImpl(runId, stepName, rpcName, data, stepOptions) {
         const stepId = crypto.randomUUID();
         const now = new Date();
         await this.db
@@ -196,7 +202,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
     async getRunHistory(runId) {
         return this.runService.getRunHistory(runId);
     }
-    async setStepRunning(stepId) {
+    async setStepRunningImpl(stepId) {
         await this.db
             .updateTable('workflowStep')
             .set({ status: 'running', updatedAt: new Date() })
@@ -217,7 +223,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
                 .execute();
         }
     }
-    async setStepScheduled(stepId) {
+    async setStepScheduledImpl(stepId) {
         await this.db
             .updateTable('workflowStep')
             .set({ status: 'scheduled', updatedAt: new Date() })
@@ -257,7 +263,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
                 return 'createdAt';
         }
     }
-    async setStepChildRunId(stepId, childRunId) {
+    async setStepChildRunIdImpl(stepId, childRunId) {
         await this.db
             .updateTable('workflowStep')
             .set({
@@ -267,7 +273,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .where('workflowStepId', '=', stepId)
             .execute();
     }
-    async setStepResult(stepId, result) {
+    async setStepResultImpl(stepId, result) {
         const resultJson = JSON.stringify(result);
         await this.db
             .updateTable('workflowStep')
@@ -294,7 +300,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
                 .execute();
         }
     }
-    async setStepError(stepId, error) {
+    async setStepErrorImpl(stepId, error) {
         const serializedError = {
             message: error.message,
             stack: error.stack,
@@ -326,7 +332,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
                 .execute();
         }
     }
-    async createRetryAttempt(stepId, status) {
+    async createRetryAttemptImpl(stepId, status) {
         await this.db
             .updateTable('workflowStep')
             .set({ status, result: null, error: null, updatedAt: new Date() })
@@ -430,14 +436,14 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
         }
         return results;
     }
-    async setBranchTaken(stepId, branchKey) {
+    async setBranchTakenImpl(stepId, branchKey) {
         await this.db
             .updateTable('workflowStep')
             .set({ branchTaken: branchKey, updatedAt: new Date() })
             .where('workflowStepId', '=', stepId)
             .execute();
     }
-    async updateRunState(runId, name, value) {
+    async updateRunStateImpl(runId, name, value) {
         const row = await this.db
             .selectFrom('workflowRuns')
             .select('state')
@@ -461,7 +467,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             return {};
         return parseJson(row.state) ?? {};
     }
-    async upsertWorkflowVersion(name, graphHash, graph, source, status) {
+    async upsertWorkflowVersionImpl(name, graphHash, graph, source, status) {
         await this.db
             .insertInto('workflowVersions')
             .values({
@@ -474,7 +480,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .onConflict((oc) => oc.columns(['workflowName', 'graphHash']).doNothing())
             .execute();
     }
-    async updateWorkflowVersionStatus(name, graphHash, status) {
+    async updateWorkflowVersionStatusImpl(name, graphHash, status) {
         await this.db
             .updateTable('workflowVersions')
             .set({ status })

package/dist/tsconfig.tsbuildinfo

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely",
-  "version": "0.12.10",
+  "version": "0.12.12",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/src/index.js",
@@ -20,14 +20,14 @@
     "prepublishOnly": "yarn build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.18"
+    "@pikku/core": "^0.12.24"
   },
   "dependencies": {
     "kysely": "^0.28.12"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
-    "better-sqlite3": "^12.6.2",
+    "better-sqlite3": "^12.10.0",
     "kysely-codegen": "^0.20.0",
     "kysely-plugin-serialize": "^0.8.2",
     "kysely-postgres-js": "^3.0.0",