@pikku/kysely 0.13.40 → 0.13.41

package/dist/src/kysely-channel-store.d.ts

@@ -7,7 +7,7 @@ export declare class KyselyChannelStore extends ChannelStore {
     private initialized;
     constructor(db: Kysely<KyselyPikkuDB>);
     init(): Promise<void>;
-    addChannel({ channelId, channelName, openingData, }: Channel): Promise<void>;
+    addChannel({ channelId, channelName, openingData, traceparent, }: Channel): Promise<void>;
     removeChannels(channelIds: string[]): Promise<void>;
     setPikkuUserId(channelId: string, pikkuUserId: string | null): Promise<void>;
     getChannel(channelId: string): Promise<Channel & {

package/dist/src/kysely-channel-store.js

@@ -15,13 +15,14 @@ export class KyselyChannelStore extends ChannelStore {
         await requirePikkuSchema(this.db, channelSchema);
         this.initialized = true;
     }
-    async addChannel({ channelId, channelName, openingData, }) {
+    async addChannel({ channelId, channelName, openingData, traceparent, }) {
         await this.db
             .insertInto('channels')
             .values({
             channelId: channelId,
             channelName: channelName,
             openingData: JSON.stringify(openingData || {}),
+            traceparent: traceparent ?? null,
         })
             .execute();
     }
@@ -44,7 +45,13 @@ export class KyselyChannelStore extends ChannelStore {
     async getChannel(channelId) {
         const row = await this.db
             .selectFrom('channels')
-            .select(['channelId', 'channelName', 'openingData', 'pikkuUserId'])
+            .select([
+            'channelId',
+            'channelName',
+            'openingData',
+            'traceparent',
+            'pikkuUserId',
+        ])
             .where('channelId', '=', channelId)
             .executeTakeFirst();
         if (!row) {
@@ -54,6 +61,7 @@ export class KyselyChannelStore extends ChannelStore {
             channelId: row.channelId,
             channelName: row.channelName,
             openingData: parseJson(row.openingData) ?? {},
+            traceparent: row.traceparent ?? undefined,
             pikkuUserId: row.pikkuUserId ?? undefined,
         };
     }

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

@@ -16,6 +16,6 @@ export declare class KyselyDeploymentService implements DeploymentService {
     init(): Promise<void>;
     start(config: DeploymentConfig): Promise<void>;
     stop(): Promise<void>;
-    invoke(funcName: string, data: unknown, session?: unknown, traceId?: string): Promise<unknown>;
+    invoke(funcName: string, data: unknown, session?: unknown, traceparent?: string): Promise<unknown>;
     private sendHeartbeat;
 }

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

@@ -65,8 +65,8 @@ export class KyselyDeploymentService {
                 .execute();
         }
     }
-    async invoke(funcName, data, session, traceId) {
-        const headers = await buildMeshHeaders(this.jwt, this.secrets, funcName, session, traceId);
+    async invoke(funcName, data, session, traceparent) {
+        const headers = await buildMeshHeaders(this.jwt, this.secrets, funcName, session, traceparent);
         const ttlMs = this.heartbeatTtl;
         const cutoff = new Date(Date.now() - ttlMs);
         const result = await this.db

package/dist/src/kysely-incoming-webhook-service.d.ts

@@ -14,10 +14,11 @@ export declare class KyselyIncomingWebhookService extends IncomingWebhookService
     private initialized;
     constructor(queueService: QueueService, db: Kysely<KyselyPikkuDB>, retries?: number);
     init(): Promise<void>;
-    accept({ source, events, }: {
+    accept({ source, events, traceparent, }: {
         source: string;
         request: WebhookRequest;
         events: TriggerEvent[];
+        traceparent?: string;
     }): Promise<number>;
     /** The new receipt's id, or undefined when this provider event id was already received. */
     private record;

package/dist/src/kysely-incoming-webhook-service.js

@@ -20,14 +20,14 @@ export class KyselyIncomingWebhookService extends IncomingWebhookService {
         await requirePikkuSchema(this.db, incomingWebhookSchema);
         this.initialized = true;
     }
-    async accept({ source, events, }) {
+    async accept({ source, events, traceparent, }) {
         let accepted = 0;
         for (const event of events) {
             const receiptId = await this.record(source, event);
             if (!receiptId)
                 continue;
             try {
-                await this.enqueue({ source, event, receiptId });
+                await this.enqueue({ source, event, receiptId }, traceparent);
             }
             catch (error) {
                 // Without the receipt the provider's retry is accepted again rather

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

@@ -5,6 +5,8 @@ export interface ChannelsTable {
     channelName: string;
     createdAt: Generated<Date>;
     openingData: string;
+    /** The connection's W3C trace. */
+    traceparent: string | null;
     pikkuUserId: string | null;
     /** JSON-serialized per-socket channel state, keyed by channelId. */
     state: string | null;

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

@@ -1,6 +1,6 @@
 import type { SerializedError } from '@pikku/core/errors';
 import { PikkuWorkflowService } from '@pikku/core/workflow';
-import type { WorkflowPlannedStep, WorkflowServiceOptions, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/workflow';
+import type { WorkflowPlannedStep, WorkflowServiceOptions, ScheduledStep, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/workflow';
 import { type Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 export declare class KyselyWorkflowService extends PikkuWorkflowService {
@@ -142,6 +142,7 @@ export declare class KyselyWorkflowService extends PikkuWorkflowService {
         stepId: string;
     }>>;
     protected findStalledRunIds(before: Date, limit: number): Promise<string[]>;
+    protected findScheduledSteps(limit: number, offset: number): Promise<ScheduledStep[]>;
     getRunState(runId: string): Promise<Record<string, unknown>>;
     protected upsertWorkflowVersionImpl(name: string, graphHash: string, graph: any, source: string, status?: WorkflowVersionStatus): Promise<void>;
     protected updateWorkflowVersionStatusImpl(name: string, graphHash: string, status: WorkflowVersionStatus): Promise<void>;

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

@@ -418,6 +418,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
                     return null;
                 }
                 await this.setStepError(stepState.stepId, new WorkflowStepLeaseExpiredError(runId, stepName, stepState.attemptCount), stepState.attemptCount);
+                await this.logStepAttemptsExhausted(runId, stepName, stepState.attemptCount);
                 // `executeWorkflowStepInner` reads a null claim as "another dispatch
                 // owns it" and returns without resuming, so the run would stay
                 // `running` until a stalled sweep. Requeue the orchestrator here.
@@ -432,7 +433,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
         }
         if (stepState.status === 'failed' || stepState.status === 'running') {
             const attempt = stepState.attemptCount + 1;
-            return this.mirrored(() => this.reclaimStepAttempt(stepState, attempt, leaseMs), async (mirror, newStep) => {
+            const reclaimed = await this.mirrored(() => this.reclaimStepAttempt(stepState, attempt, leaseMs), async (mirror, newStep) => {
                 if (newStep) {
                     await mirror.createRetryAttempt(stepState.stepId, {
                         ...newStep,
@@ -440,6 +441,11 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
                     });
                 }
             });
+            // A `failed` step threw, and this is its ordinary retry.
+            if (reclaimed && stepState.status === 'running') {
+                await this.logStepRerun(runId, stepName, reclaimed.attemptCount);
+            }
+            return reclaimed;
         }
         if (stepState.status === 'pending' || stepState.status === 'scheduled') {
             if (!(await this.claimStepStatus(stepState.stepId, ['pending', 'scheduled'], leaseMs))) {
@@ -660,12 +666,13 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             eb('s.status', 'in', ['scheduled', 'suspended']),
             // A `running` step counts as in flight only while someone
             // still holds it. A lapsed lease is a dispatch that died, and
-            // a null one a step nothing was expected to hand back.
+            // a null one with no child run is a step worked inside a pass,
+            // which the run's lease answers for, not this query.
             eb.and([
                 eb('s.status', '=', 'running'),
                 eb.or([
-                    eb('s.leaseExpiresAt', 'is', null),
                     eb('s.leaseExpiresAt', '>', this.nowMs()),
+                    eb('s.childRunId', 'is not', null),
                 ]),
             ]),
         ])))))
@@ -682,6 +689,40 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .execute();
         return rows.map((row) => row.workflowRunId);
     }
+    async findScheduledSteps(limit, offset) {
+        const rows = await this.db
+            .selectFrom('workflowStep as s')
+            .innerJoin('workflowRuns as r', 'r.workflowRunId', 's.workflowRunId')
+            .select([
+            's.workflowRunId',
+            's.workflowStepId',
+            's.stepName',
+            's.rpcName',
+            's.data',
+            's.fromStepName',
+            's.retries',
+            's.retryDelay',
+            's.updatedAt',
+        ])
+            .where('s.status', '=', 'scheduled')
+            .where('r.status', '=', 'running')
+            .orderBy('s.updatedAt', 'asc')
+            .orderBy('s.workflowStepId', 'asc')
+            .limit(limit)
+            .offset(offset)
+            .execute();
+        return rows.map((row) => ({
+            runId: row.workflowRunId,
+            stepId: row.workflowStepId,
+            stepName: row.stepName,
+            rpcName: row.rpcName ?? null,
+            data: parseJson(row.data),
+            fromStepName: row.fromStepName ?? undefined,
+            retries: row.retries != null ? Number(row.retries) : undefined,
+            retryDelay: row.retryDelay ?? undefined,
+            scheduledAt: new Date(row.updatedAt),
+        }));
+    }
     async getRunState(runId) {
         const row = await this.db
             .selectFrom('workflowRuns')

package/dist/src/schema/channel.schema.js

@@ -10,6 +10,7 @@ export const channelSchema = {
             .addColumn('channelName', ctx.text, (col) => col.notNull())
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('openingData', ctx.text, (col) => col.notNull().defaultTo(ctx.defaultText('{}')))
+            .addColumn('traceparent', ctx.text)
             .addColumn('pikkuUserId', ctx.text)
             .addColumn('state', ctx.text)
             .addColumn('lastWire', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely",
-  "version": "0.13.40",
+  "version": "0.13.41",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -28,7 +28,7 @@
     "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.146"
+    "@pikku/core": "^0.12.151"
   },
   "dependencies": {
     "kysely": "^0.29.6"