@swirls/looms 0.4.0 → 0.5.1

package/dist/projectors/event-log.js

@@ -0,0 +1,396 @@
+import { DateTime, Effect, Option, Predicate, Schema } from 'effect';
+import createPostgresClient, {} from 'postgres';
+import { completedRunStatus, isJsonObject, readRunLaunchSource, } from '@swirls/looms/core';
+import { runProjectorPromise } from './projector.js';
+const decodeAttributes = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.String));
+export const POSTGRES_EVENT_LOG_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS looms_run_events (
+  run_id TEXT NOT NULL,
+  seq BIGINT NOT NULL,
+  event_id TEXT NOT NULL,
+  ts TIMESTAMPTZ NOT NULL,
+  type TEXT NOT NULL,
+  payload JSONB NOT NULL,
+  thread_id TEXT,
+  parent_thread_id TEXT,
+  causation_id TEXT,
+  correlation_id TEXT,
+  effect_id TEXT,
+  origin JSONB NOT NULL,
+  idempotency_key TEXT,
+  PRIMARY KEY (run_id, seq)
+);
+
+CREATE TABLE IF NOT EXISTS looms_run_index (
+  run_id TEXT PRIMARY KEY,
+  status TEXT NOT NULL,
+  kind TEXT,
+  definition_name TEXT,
+  definition_version TEXT,
+  root_thread_id TEXT,
+  parent_run_id TEXT,
+  launched_by_effect_id TEXT,
+  correlation_id TEXT,
+  attributes JSONB NOT NULL DEFAULT '{}'::jsonb,
+  tenant TEXT,
+  project TEXT,
+  org TEXT,
+  started_at TIMESTAMPTZ,
+  updated_at TIMESTAMPTZ NOT NULL,
+  completed_at TIMESTAMPTZ
+);
+
+CREATE INDEX IF NOT EXISTS looms_run_index_tenant ON looms_run_index (tenant);
+CREATE INDEX IF NOT EXISTS looms_run_index_project ON looms_run_index (project);
+CREATE INDEX IF NOT EXISTS looms_run_index_org ON looms_run_index (org);
+CREATE INDEX IF NOT EXISTS looms_run_index_parent ON looms_run_index (parent_run_id);
+CREATE INDEX IF NOT EXISTS looms_run_index_status ON looms_run_index (status);
+`.trim();
+const terminal = new Set(['completed', 'failed', 'cancelled']);
+export function eventLogOps(event) {
+    if (event.ephemeral) {
+        return [];
+    }
+    const entry = {
+        runId: event.runId,
+        seq: event.seq,
+        eventId: event.id,
+        ts: event.ts,
+        type: event.type,
+        payload: event.payload,
+        threadId: event.threadId,
+        parentThreadId: event.parentThreadId ?? null,
+        causationId: event.causationId ?? null,
+        correlationId: event.correlationId ?? null,
+        effectId: event.effectId ?? null,
+        origin: event.origin,
+        idempotencyKey: event.idempotencyKey ?? null,
+    };
+    const payload = isJsonObject(event.payload) ? event.payload : {};
+    switch (event.type) {
+        case 'runtime.run.started':
+            return [{ type: 'insert', entry }, startOp(event, payload)];
+        case 'runtime.run.completed':
+            return [
+                { type: 'insert', entry },
+                {
+                    type: 'finish',
+                    runId: event.runId,
+                    status: completedRunStatus(event.payload),
+                    at: event.ts,
+                },
+            ];
+        case 'runtime.run.cancelled':
+            return [
+                { type: 'insert', entry },
+                { type: 'finish', runId: event.runId, status: 'cancelled', at: event.ts },
+            ];
+        default:
+            return [
+                { type: 'insert', entry },
+                { type: 'touch', runId: event.runId, at: event.ts },
+            ];
+    }
+}
+export function memoryEventLog() {
+    const events = new Map();
+    const runs = new Map();
+    const projector = createEventLogProjector('memory-event-log', {
+        init: () => Promise.resolve(),
+        apply: (batch) => {
+            for (const event of batch) {
+                for (const op of eventLogOps(event)) {
+                    applyMemoryOp(events, runs, op);
+                }
+            }
+            return Promise.resolve();
+        },
+    });
+    return {
+        ...projector,
+        events: (runId) => [...events.values()]
+            .filter((entry) => entry.runId === runId)
+            .toSorted((left, right) => left.seq - right.seq),
+        run: (runId) => {
+            const row = runs.get(runId);
+            return row ? { ...row, attributes: { ...row.attributes } } : null;
+        },
+    };
+}
+export function postgresEventLog(options) {
+    const created = 'url' in options;
+    const connected = created ? createPostgresClient(options.url) : options.sql;
+    return createEventLogProjector('postgres-event-log', postgresStore(connected, created));
+}
+function createEventLogProjector(name, store) {
+    return {
+        name,
+        version: '1',
+        init: store.init,
+        project: (events) => store.apply(events),
+        dispose: store.dispose,
+        rebuild: (source, options) => Effect.runPromise(rebuildEventLog(store, source, options)),
+    };
+}
+function rebuildEventLog(store, source, options) {
+    const batchSize = options?.batchSize ?? 100;
+    return Effect.gen(function* () {
+        yield* Effect.promise(() => store.init());
+        const runIds = options?.runId ? [options.runId] : yield* source.listRuns;
+        let written = 0;
+        for (const runId of runIds) {
+            let fromSeq = 1;
+            while (fromSeq > 0) {
+                const events = yield* source.read(runId, { fromSeq, limit: batchSize });
+                const last = events.at(-1);
+                if (!last) {
+                    break;
+                }
+                yield* Effect.promise(() => store.apply(events));
+                written += events.filter((event) => !event.ephemeral).length;
+                fromSeq = events.length < batchSize ? 0 : last.seq + 1;
+            }
+        }
+        return written;
+    });
+}
+function applyMemoryOp(events, runs, op) {
+    switch (op.type) {
+        case 'insert':
+            events.set(`${op.entry.runId}:${op.entry.seq}`, op.entry);
+            return;
+        case 'start':
+            runs.set(op.runId, mergeStart(runs.get(op.runId), op));
+            return;
+        case 'finish':
+            runs.set(op.runId, mergeFinish(runs.get(op.runId), op));
+            return;
+        case 'touch': {
+            const existing = runs.get(op.runId);
+            if (!existing || existing.updatedAt >= op.at) {
+                return;
+            }
+            runs.set(op.runId, { ...existing, updatedAt: op.at });
+            return;
+        }
+        default: {
+            const unexpected = op;
+            return unexpected;
+        }
+    }
+}
+function mergeStart(existing, op) {
+    const status = existing && terminal.has(existing.status) ? existing.status : 'running';
+    return {
+        runId: op.runId,
+        status,
+        kind: existing?.kind ?? op.kind,
+        definitionName: existing?.definitionName ?? op.definitionName,
+        definitionVersion: existing?.definitionVersion ?? op.definitionVersion,
+        rootThreadId: existing?.rootThreadId ?? op.rootThreadId,
+        parentRunId: existing?.parentRunId ?? op.parentRunId,
+        launchedByEffectId: existing?.launchedByEffectId ?? op.launchedByEffectId,
+        correlationId: existing?.correlationId ?? op.correlationId,
+        attributes: existing && Object.keys(existing.attributes).length > 0
+            ? existing.attributes
+            : { ...op.attributes },
+        tenant: existing?.tenant ?? op.tenant,
+        project: existing?.project ?? op.project,
+        org: existing?.org ?? op.org,
+        startedAt: existing?.startedAt ?? op.at,
+        updatedAt: Math.max(existing?.updatedAt ?? 0, op.at),
+        completedAt: existing?.completedAt ?? null,
+    };
+}
+function mergeFinish(existing, op) {
+    return {
+        runId: op.runId,
+        status: op.status,
+        kind: existing?.kind ?? null,
+        definitionName: existing?.definitionName ?? null,
+        definitionVersion: existing?.definitionVersion ?? null,
+        rootThreadId: existing?.rootThreadId ?? null,
+        parentRunId: existing?.parentRunId ?? null,
+        launchedByEffectId: existing?.launchedByEffectId ?? null,
+        correlationId: existing?.correlationId ?? null,
+        attributes: existing?.attributes ?? {},
+        tenant: existing?.tenant ?? null,
+        project: existing?.project ?? null,
+        org: existing?.org ?? null,
+        startedAt: existing?.startedAt ?? null,
+        updatedAt: Math.max(existing?.updatedAt ?? 0, op.at),
+        completedAt: existing?.completedAt ?? op.at,
+    };
+}
+function utcDate(ms) {
+    return DateTime.toDateUtc(DateTime.makeUnsafe(ms));
+}
+function startOp(event, payload) {
+    const launchedBy = readRunLaunchSource(payload.launchedBy === undefined ? undefined : payload.launchedBy);
+    const attributes = readAttributes(payload.attributes);
+    return {
+        type: 'start',
+        runId: event.runId,
+        kind: readString(payload, 'kind'),
+        definitionName: readString(payload, 'definitionName'),
+        definitionVersion: readString(payload, 'definitionVersion'),
+        rootThreadId: readString(payload, 'rootThreadId'),
+        parentRunId: launchedBy?.runId ?? null,
+        launchedByEffectId: launchedBy?.effectId ?? null,
+        correlationId: event.correlationId ?? null,
+        attributes,
+        tenant: attributes.tenant ?? null,
+        project: attributes.project ?? null,
+        org: attributes.org ?? null,
+        at: event.ts,
+    };
+}
+function readString(payload, key) {
+    const value = payload[key];
+    return Predicate.isString(value) ? value : null;
+}
+function readAttributes(value) {
+    if (value === undefined) {
+        return {};
+    }
+    return Option.getOrElse(decodeAttributes(value), () => ({}));
+}
+function postgresStore(sql, ownsClient) {
+    return {
+        init: () => runProjectorPromise('postgres-event-log', () => sql.unsafe(POSTGRES_EVENT_LOG_SCHEMA_SQL)).then(() => undefined),
+        apply: (events) => {
+            const ops = events.flatMap(eventLogOps);
+            if (ops.length === 0) {
+                return Promise.resolve();
+            }
+            return runProjectorPromise('postgres-event-log', () => sql.begin((tx) => applySqlOps(tx, ops))).then(() => undefined);
+        },
+        dispose: () => ownsClient
+            ? runProjectorPromise('postgres-event-log', () => sql.end({ timeout: 5 })).then(() => undefined)
+            : Promise.resolve(),
+    };
+}
+/** Keeps each statement under Postgres's 65,535 bind parameters (13 per event row). */
+const INSERT_CHUNK_ROWS = 1_000;
+function runIndexPatches(ops) {
+    const patches = new Map();
+    for (const op of ops) {
+        if (op.type === 'insert') {
+            continue;
+        }
+        const patch = patches.get(op.runId) ?? {
+            runId: op.runId,
+            start: null,
+            finish: null,
+            completedAt: null,
+            updatedAt: op.at,
+        };
+        patch.updatedAt = Math.max(patch.updatedAt, op.at);
+        if (op.type === 'start') {
+            patch.start ??= op;
+        }
+        if (op.type === 'finish') {
+            patch.finish = op;
+            patch.completedAt ??= op.at;
+        }
+        patches.set(op.runId, patch);
+    }
+    return [...patches.values()];
+}
+function applySqlOps(sql, ops) {
+    const entries = ops.flatMap((op) => (op.type === 'insert' ? [op.entry] : []));
+    const patches = runIndexPatches(ops);
+    const upserts = patches.filter((patch) => patch.start !== null || patch.finish !== null);
+    const touches = patches.filter((patch) => patch.start === null && patch.finish === null);
+    const statements = [];
+    for (let index = 0; index < entries.length; index += INSERT_CHUNK_ROWS) {
+        statements.push(insertEvents(sql, entries.slice(index, index + INSERT_CHUNK_ROWS)));
+    }
+    if (upserts.length > 0) {
+        statements.push(upsertRuns(sql, upserts));
+    }
+    if (touches.length > 0) {
+        statements.push(touchRuns(sql, touches));
+    }
+    return Promise.all(statements).then(() => undefined);
+}
+function insertEvents(sql, entries) {
+    const rows = entries.map((entry) => ({
+        run_id: entry.runId,
+        seq: entry.seq,
+        event_id: entry.eventId,
+        ts: utcDate(entry.ts),
+        type: entry.type,
+        payload: sql.json(entry.payload),
+        thread_id: entry.threadId,
+        parent_thread_id: entry.parentThreadId,
+        causation_id: entry.causationId,
+        correlation_id: entry.correlationId,
+        effect_id: entry.effectId,
+        origin: sql.json(entry.origin),
+        idempotency_key: entry.idempotencyKey,
+    }));
+    return sql `
+    INSERT INTO looms_run_events ${sql(rows)}
+    ON CONFLICT (run_id, seq) DO NOTHING
+  `.then(() => undefined);
+}
+// A finish in the batch sets the status; otherwise a finished run keeps its status and a
+// started run becomes running. Start fields fill only columns that are still empty.
+function upsertRuns(sql, patches) {
+    const rows = patches.map(({ runId, start, finish, completedAt, updatedAt }) => ({
+        run_id: runId,
+        status: finish?.status ?? 'running',
+        kind: start?.kind ?? null,
+        definition_name: start?.definitionName ?? null,
+        definition_version: start?.definitionVersion ?? null,
+        root_thread_id: start?.rootThreadId ?? null,
+        parent_run_id: start?.parentRunId ?? null,
+        launched_by_effect_id: start?.launchedByEffectId ?? null,
+        correlation_id: start?.correlationId ?? null,
+        attributes: sql.json(start?.attributes ?? {}),
+        tenant: start?.tenant ?? null,
+        project: start?.project ?? null,
+        org: start?.org ?? null,
+        started_at: start ? utcDate(start.at) : null,
+        updated_at: utcDate(updatedAt),
+        completed_at: completedAt === null ? null : utcDate(completedAt),
+    }));
+    return sql `
+    INSERT INTO looms_run_index ${sql(rows)}
+    ON CONFLICT (run_id) DO UPDATE SET
+      status = CASE
+        WHEN EXCLUDED.completed_at IS NOT NULL THEN EXCLUDED.status
+        WHEN looms_run_index.status IN ('completed', 'failed', 'cancelled') THEN looms_run_index.status
+        ELSE EXCLUDED.status
+      END,
+      kind = COALESCE(looms_run_index.kind, EXCLUDED.kind),
+      definition_name = COALESCE(looms_run_index.definition_name, EXCLUDED.definition_name),
+      definition_version = COALESCE(looms_run_index.definition_version, EXCLUDED.definition_version),
+      root_thread_id = COALESCE(looms_run_index.root_thread_id, EXCLUDED.root_thread_id),
+      parent_run_id = COALESCE(looms_run_index.parent_run_id, EXCLUDED.parent_run_id),
+      launched_by_effect_id = COALESCE(looms_run_index.launched_by_effect_id, EXCLUDED.launched_by_effect_id),
+      correlation_id = COALESCE(looms_run_index.correlation_id, EXCLUDED.correlation_id),
+      attributes = CASE
+        WHEN looms_run_index.attributes = '{}'::jsonb THEN EXCLUDED.attributes
+        ELSE looms_run_index.attributes
+      END,
+      tenant = COALESCE(looms_run_index.tenant, EXCLUDED.tenant),
+      project = COALESCE(looms_run_index.project, EXCLUDED.project),
+      org = COALESCE(looms_run_index.org, EXCLUDED.org),
+      started_at = COALESCE(looms_run_index.started_at, EXCLUDED.started_at),
+      updated_at = GREATEST(looms_run_index.updated_at, EXCLUDED.updated_at),
+      completed_at = COALESCE(looms_run_index.completed_at, EXCLUDED.completed_at)
+  `.then(() => undefined);
+}
+function touchRuns(sql, patches) {
+    const runIds = patches.map((patch) => patch.runId);
+    const touchedAt = patches.map((patch) => DateTime.formatIso(DateTime.makeUnsafe(patch.updatedAt)));
+    return sql `
+    UPDATE looms_run_index AS run
+    SET updated_at = GREATEST(run.updated_at, touched.at)
+    FROM unnest(${sql.array(runIds)}::text[], ${sql.array(touchedAt)}::timestamptz[])
+      AS touched (run_id, at)
+    WHERE run.run_id = touched.run_id
+  `.then(() => undefined);
+}

package/dist/projectors/index-model.d.ts

@@ -8,6 +8,12 @@ export interface ActorIndexRow {
     status: string | null;
     definitionName: string | null;
     parentActorId: string | null;
+    /** On a run row: the run whose effect launched this one. */
+    launchedByRunId: string | null;
+    /** On a run row: the effect, in `launchedByRunId`, that launched this one. */
+    launchedByEffectId: string | null;
+    /** On a run row: the root run of its launch chain. */
+    correlationId: string | null;
     updatedAt: number;
 }
 export interface ReviewIndexRow {
@@ -25,6 +31,9 @@ export type IndexOp = {
     status: string | null;
     definitionName: string | null;
     parentActorId: string | null;
+    launchedByRunId: string | null;
+    launchedByEffectId: string | null;
+    correlationId: string | null;
     updatedAt: number;
 } | {
     type: 'setActorStatus';
@@ -49,6 +58,7 @@ export type IndexOp = {
 export interface IndexBackend {
     applyOps: (ops: ReadonlyArray<IndexOp>) => Promise<void>;
     getActor: (runId: string, actorId: string) => Promise<ActorIndexRow | null>;
+    listLaunched: (runId: string) => Promise<ActorIndexRow[]>;
     listReviews: (runId?: string) => Promise<ReviewIndexRow[]>;
     init?: () => Promise<void>;
     dispose?: () => Promise<void>;
@@ -56,6 +66,8 @@ export interface IndexBackend {
 export interface IndexProjector extends Projector {
     /** The run's row, or one of its threads when `actorId` is given. */
     getActor: (runId: string, actorId?: string) => Promise<ActorIndexRow | null>;
+    /** Rows of the runs that effects in `runId` launched. */
+    listLaunched: (runId: string) => Promise<ActorIndexRow[]>;
     listReviews: (runId?: string) => Promise<ReviewIndexRow[]>;
 }
 export declare function indexOpsFor(event: EventEnvelope): IndexOp[];

package/dist/projectors/index-model.js

@@ -1,5 +1,5 @@
 import { Predicate } from 'effect';
-import { completedRunStatus } from '@swirls/looms/core';
+import { completedRunStatus, readRunLaunchSource, } from '@swirls/looms/core';
 function payloadObject(event) {
     if (!Predicate.isObject(event.payload)) {
         return {};
@@ -15,7 +15,8 @@ export function indexOpsFor(event) {
     const runId = event.runId;
     const actorId = readString(payload, 'threadId') ?? event.threadId ?? runId;
     switch (event.type) {
-        case 'runtime.run.started':
+        case 'runtime.run.started': {
+            const launchedBy = readRunLaunchSource(payload.launchedBy);
             return [
                 {
                     type: 'upsertActor',
@@ -25,9 +26,13 @@ export function indexOpsFor(event) {
                     status: 'running',
                     definitionName: readString(payload, 'definitionName') ?? null,
                     parentActorId: null,
+                    launchedByRunId: launchedBy?.runId ?? null,
+                    launchedByEffectId: launchedBy?.effectId ?? null,
+                    correlationId: event.correlationId ?? null,
                     updatedAt: event.ts,
                 },
             ];
+        }
         case 'runtime.thread.started':
             return [
                 {
@@ -38,6 +43,9 @@ export function indexOpsFor(event) {
                     status: 'running',
                     definitionName: readString(payload, 'definitionName') ?? null,
                     parentActorId: readString(payload, 'parentThreadId') ?? null,
+                    launchedByRunId: null,
+                    launchedByEffectId: null,
+                    correlationId: null,
                     updatedAt: event.ts,
                 },
             ];
@@ -94,7 +102,7 @@ export function indexOpsFor(event) {
             return [];
     }
 }
-export function createIndexProjector(name, backend, version = '2') {
+export function createIndexProjector(name, backend, version = '3') {
     return {
         name,
         version,
@@ -105,6 +113,7 @@ export function createIndexProjector(name, backend, version = '2') {
             return ops.length === 0 ? Promise.resolve() : backend.applyOps(ops);
         },
         getActor: (runId, actorId) => backend.getActor(runId, actorId ?? runId),
+        listLaunched: (runId) => backend.listLaunched(runId),
         listReviews: (runId) => backend.listReviews(runId),
     };
 }

package/dist/projectors/memory.js

@@ -13,6 +13,9 @@ function applyOp(actors, reviews, op) {
                 status: op.status,
                 definitionName: op.definitionName,
                 parentActorId: op.parentActorId,
+                launchedByRunId: op.launchedByRunId,
+                launchedByEffectId: op.launchedByEffectId,
+                correlationId: op.correlationId,
                 updatedAt: op.updatedAt,
             });
             return;
@@ -26,6 +29,9 @@ function applyOp(actors, reviews, op) {
                 status: op.status,
                 definitionName: existing?.definitionName ?? null,
                 parentActorId: existing?.parentActorId ?? null,
+                launchedByRunId: existing?.launchedByRunId ?? null,
+                launchedByEffectId: existing?.launchedByEffectId ?? null,
+                correlationId: existing?.correlationId ?? null,
                 updatedAt: op.updatedAt,
             });
             return;
@@ -66,6 +72,7 @@ export function memory() {
             }
         }),
         getActor: (runId, actorId) => runProjectorSync('memory', () => actors.get(rowKey(runId, actorId)) ?? null),
+        listLaunched: (runId) => runProjectorSync('memory', () => [...actors.values()].filter((row) => row.launchedByRunId === runId)),
         listReviews: (runId) => runProjectorSync('memory', () => {
             const rows = [...reviews.values()];
             return runId ? rows.filter((row) => row.runId === runId) : rows;

package/dist/projectors/postgres.d.ts

@@ -1,6 +1,7 @@
 import { type Sql } from 'postgres';
 import { type IndexProjector } from './index-model';
 export { POSTGRES_SCHEMA_SQL } from './schema';
+export { memoryEventLog, postgresEventLog, POSTGRES_EVENT_LOG_SCHEMA_SQL, type EventLogEntry, type EventLogProjector, type MemoryEventLog, type RunLogRow, } from './event-log';
 export type PostgresProjectorOptions = {
     url: string;
 } | {

package/dist/projectors/postgres.js

@@ -4,21 +4,45 @@ import { createIndexProjector, } from './index-model.js';
 import { runProjectorPromise } from './projector.js';
 import { POSTGRES_SCHEMA_SQL } from './schema.js';
 export { POSTGRES_SCHEMA_SQL } from './schema.js';
+export { memoryEventLog, postgresEventLog, POSTGRES_EVENT_LOG_SCHEMA_SQL, } from './event-log.js';
 function ownsClient(options) {
     return 'url' in options;
 }
+function actorFromRow(row) {
+    return {
+        runId: row.run_id,
+        actorId: row.actor_id,
+        kind: row.kind,
+        status: row.status,
+        definitionName: row.definition_name,
+        parentActorId: row.parent_actor_id,
+        launchedByRunId: row.launched_by_run_id,
+        launchedByEffectId: row.launched_by_effect_id,
+        correlationId: row.correlation_id,
+        updatedAt: row.updated_at.getTime(),
+    };
+}
 function applyOp(sql, op) {
     const date = DateTime.toDateUtc(DateTime.makeUnsafe(op.updatedAt));
     switch (op.type) {
         case 'upsertActor':
             return sql `
-        INSERT INTO looms_run_actors (run_id, actor_id, kind, status, definition_name, parent_actor_id, updated_at)
-        VALUES (${op.runId}, ${op.actorId}, ${op.kind}, ${op.status}, ${op.definitionName}, ${op.parentActorId}, ${date})
+        INSERT INTO looms_run_actors (
+          run_id, actor_id, kind, status, definition_name, parent_actor_id,
+          launched_by_run_id, launched_by_effect_id, correlation_id, updated_at
+        )
+        VALUES (
+          ${op.runId}, ${op.actorId}, ${op.kind}, ${op.status}, ${op.definitionName}, ${op.parentActorId},
+          ${op.launchedByRunId}, ${op.launchedByEffectId}, ${op.correlationId}, ${date}
+        )
         ON CONFLICT (run_id, actor_id) DO UPDATE SET
           kind = EXCLUDED.kind,
           status = EXCLUDED.status,
           definition_name = EXCLUDED.definition_name,
           parent_actor_id = EXCLUDED.parent_actor_id,
+          launched_by_run_id = EXCLUDED.launched_by_run_id,
+          launched_by_effect_id = EXCLUDED.launched_by_effect_id,
+          correlation_id = EXCLUDED.correlation_id,
           updated_at = EXCLUDED.updated_at
       `;
         case 'setActorStatus':
@@ -57,22 +81,15 @@ export function postgres(options) {
             discard: true,
         })))).then(() => undefined),
         getActor: (runId, actorId) => runProjectorPromise('postgres', () => sql `
-          SELECT run_id, actor_id, kind, status, definition_name, parent_actor_id, updated_at
-          FROM looms_run_actors WHERE run_id = ${runId} AND actor_id = ${actorId}
+          SELECT * FROM looms_run_actors WHERE run_id = ${runId} AND actor_id = ${actorId}
         `).then((rows) => {
             const row = rows[0];
-            return row
-                ? {
-                    runId: row.run_id,
-                    actorId: row.actor_id,
-                    kind: row.kind,
-                    status: row.status,
-                    definitionName: row.definition_name,
-                    parentActorId: row.parent_actor_id,
-                    updatedAt: row.updated_at.getTime(),
-                }
-                : null;
+            return row ? actorFromRow(row) : null;
         }),
+        listLaunched: (runId) => runProjectorPromise('postgres', () => sql `
+          SELECT * FROM looms_run_actors
+          WHERE launched_by_run_id = ${runId} AND actor_id = run_id ORDER BY updated_at
+        `).then((rows) => rows.map(actorFromRow)),
         listReviews: (runId) => runProjectorPromise('postgres', () => runId
             ? sql `
             SELECT run_id, review_id, status, title, updated_at

package/dist/projectors/schema.d.ts

@@ -2,4 +2,9 @@
  * SQL schema for the optional Looms secondary index.
  */
 export declare const POSTGRES_SCHEMA_SQL: string;
+export declare const SQLITE_TABLES_SQL: string;
+/** Columns added after the first release. SQLite cannot add a column only if it is missing. */
+export declare const SQLITE_ADDED_ACTOR_COLUMNS: readonly ['launched_by_run_id', 'launched_by_effect_id', 'correlation_id'];
+export declare const SQLITE_INDEXES_SQL: string;
+/** The full schema for a new database. An existing one needs the added columns first. */
 export declare const SQLITE_SCHEMA_SQL: string;

package/dist/projectors/schema.js

@@ -9,10 +9,20 @@ CREATE TABLE IF NOT EXISTS looms_run_actors (
   status TEXT,
   definition_name TEXT,
   parent_actor_id TEXT,
+  launched_by_run_id TEXT,
+  launched_by_effect_id TEXT,
+  correlation_id TEXT,
   updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
   PRIMARY KEY (run_id, actor_id)
 );
 
+ALTER TABLE looms_run_actors ADD COLUMN IF NOT EXISTS launched_by_run_id TEXT;
+ALTER TABLE looms_run_actors ADD COLUMN IF NOT EXISTS launched_by_effect_id TEXT;
+ALTER TABLE looms_run_actors ADD COLUMN IF NOT EXISTS correlation_id TEXT;
+
+CREATE INDEX IF NOT EXISTS looms_run_actors_launched_by ON looms_run_actors (launched_by_run_id);
+CREATE INDEX IF NOT EXISTS looms_run_actors_correlation ON looms_run_actors (correlation_id);
+
 CREATE TABLE IF NOT EXISTS looms_run_reviews (
   run_id TEXT NOT NULL,
   review_id TEXT NOT NULL,
@@ -22,7 +32,7 @@ CREATE TABLE IF NOT EXISTS looms_run_reviews (
   PRIMARY KEY (run_id, review_id)
 );
 `.trim();
-export const SQLITE_SCHEMA_SQL = `
+export const SQLITE_TABLES_SQL = `
 CREATE TABLE IF NOT EXISTS looms_run_actors (
   run_id TEXT NOT NULL,
   actor_id TEXT NOT NULL,
@@ -30,6 +40,9 @@ CREATE TABLE IF NOT EXISTS looms_run_actors (
   status TEXT,
   definition_name TEXT,
   parent_actor_id TEXT,
+  launched_by_run_id TEXT,
+  launched_by_effect_id TEXT,
+  correlation_id TEXT,
   updated_at INTEGER NOT NULL,
   PRIMARY KEY (run_id, actor_id)
 );
@@ -43,3 +56,15 @@ CREATE TABLE IF NOT EXISTS looms_run_reviews (
   PRIMARY KEY (run_id, review_id)
 );
 `.trim();
+/** Columns added after the first release. SQLite cannot add a column only if it is missing. */
+export const SQLITE_ADDED_ACTOR_COLUMNS = [
+    'launched_by_run_id',
+    'launched_by_effect_id',
+    'correlation_id',
+];
+export const SQLITE_INDEXES_SQL = `
+CREATE INDEX IF NOT EXISTS looms_run_actors_launched_by ON looms_run_actors (launched_by_run_id);
+CREATE INDEX IF NOT EXISTS looms_run_actors_correlation ON looms_run_actors (correlation_id);
+`.trim();
+/** The full schema for a new database. An existing one needs the added columns first. */
+export const SQLITE_SCHEMA_SQL = `${SQLITE_TABLES_SQL}\n\n${SQLITE_INDEXES_SQL}`;