create-windy 0.6.12 → 0.6.15

package/template/apps/server/src/agent-workflow/drizzle-repository-write.ts

@@ -0,0 +1,311 @@
+import {
+  agentWorkflowDefinitions,
+  agentWorkflowEvents,
+  agentWorkflowNodeRuns,
+  agentWorkflowReleases,
+  agentWorkflowRuns,
+} from "@southwind-ai/database";
+import type { AgentWorkflowRelease } from "@southwind-ai/shared";
+import { and, eq, inArray, or, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import {
+  assertMutationReplay,
+  assertPendingEvent,
+  assertRunCreate,
+  conflict,
+  mutationResult,
+  replayEvents,
+  sameRunCreate,
+  validateRunMutation,
+} from "./in-memory-repository-support.js";
+import {
+  eventRow,
+  nodeRunRow,
+  releaseRows,
+  runCreateRow,
+  toEvent,
+  toNodeRun,
+  toRelease,
+} from "./drizzle-repository-mappers.js";
+import type {
+  AgentWorkflowMutationResult,
+  AgentWorkflowRunMutation,
+  CreateAgentWorkflowRunInput,
+} from "./repository.js";
+import {
+  agentWorkflowDefinitionDigest,
+  sameAgentWorkflowRelease,
+} from "./release.js";
+import { assertDrizzleEventAppend } from "./drizzle-event-validation.js";
+import { assertDrizzleRunLineage } from "./drizzle-repository-lineage.js";
+import { applyRunMutation, lock, runRecord } from "./drizzle-write-support.js";
+import {
+  assertImmutableNodeRunIdentity,
+  assertImmutableRunIdentity,
+  assertNodeInsertLineage,
+} from "./service-mutation-identity.js";
+
+export async function publishDrizzleRelease(
+  db: NodePgDatabase,
+  release: AgentWorkflowRelease,
+) {
+  return db.transaction(async (tx) => {
+    await lock(
+      tx,
+      `release:${release.definition.workflowKey}:${release.definition.version}`,
+    );
+    const [existingDefinition] = await tx
+      .select()
+      .from(agentWorkflowDefinitions)
+      .where(
+        or(
+          eq(agentWorkflowDefinitions.definitionId, release.definitionId),
+          and(
+            eq(
+              agentWorkflowDefinitions.workflowKey,
+              release.definition.workflowKey,
+            ),
+            eq(agentWorkflowDefinitions.version, release.definition.version),
+          ),
+          and(
+            eq(
+              agentWorkflowDefinitions.workflowKey,
+              release.definition.workflowKey,
+            ),
+            eq(
+              agentWorkflowDefinitions.definitionDigest,
+              release.definitionDigest,
+            ),
+          ),
+        ),
+      )
+      .limit(1);
+    if (
+      existingDefinition &&
+      (existingDefinition.definitionId !== release.definitionId ||
+        existingDefinition.definitionDigest !== release.definitionDigest ||
+        agentWorkflowDefinitionDigest(existingDefinition.definitionJson) !==
+          release.definitionDigest)
+    ) {
+      conflict("RELEASE_IMMUTABLE_CONFLICT");
+    }
+    const [existingRelease] = await tx
+      .select()
+      .from(agentWorkflowReleases)
+      .where(
+        or(
+          eq(agentWorkflowReleases.releaseId, release.releaseId),
+          eq(agentWorkflowReleases.releaseDigest, release.releaseDigest),
+          eq(agentWorkflowReleases.definitionId, release.definitionId),
+        ),
+      )
+      .limit(1);
+    if (existingRelease) {
+      const value = toRelease(existingRelease);
+      if (!sameAgentWorkflowRelease(value, release))
+        conflict("RELEASE_IMMUTABLE_CONFLICT");
+      return { release: value, created: false };
+    }
+    const rows = releaseRows(release);
+    if (!existingDefinition)
+      await tx.insert(agentWorkflowDefinitions).values(rows.definition);
+    const [created] = await tx
+      .insert(agentWorkflowReleases)
+      .values(rows.release)
+      .returning();
+    if (!created) throw new Error("Workflow Release insert 未返回记录");
+    return { release: toRelease(created), created: true };
+  });
+}
+
+export async function createDrizzleRun(
+  db: NodePgDatabase,
+  input: CreateAgentWorkflowRunInput,
+): Promise<AgentWorkflowMutationResult> {
+  return db.transaction(async (tx) => {
+    const idempotencyCoordinate = [
+      input.run.tenantId,
+      input.run.actorId,
+      input.run.releaseId,
+      input.run.routeKey,
+      input.run.inputDigest,
+      input.idempotencyKey,
+    ].join("\u0000");
+    await lock(tx, `run:${idempotencyCoordinate}`);
+    const [release] = await tx
+      .select({ id: agentWorkflowReleases.releaseId })
+      .from(agentWorkflowReleases)
+      .where(eq(agentWorkflowReleases.releaseId, input.run.releaseId))
+      .limit(1);
+    assertRunCreate(input, Boolean(release));
+    const [existing] = await tx
+      .select()
+      .from(agentWorkflowRuns)
+      .where(
+        and(
+          eq(agentWorkflowRuns.tenantId, input.run.tenantId),
+          eq(agentWorkflowRuns.actorId, input.run.actorId),
+          eq(agentWorkflowRuns.releaseId, input.run.releaseId),
+          eq(agentWorkflowRuns.routeKey, input.run.routeKey),
+          eq(agentWorkflowRuns.inputDigest, input.run.inputDigest),
+          eq(agentWorkflowRuns.idempotencyKey, input.idempotencyKey),
+        ),
+      )
+      .limit(1);
+    if (existing) {
+      const [node, event] = await Promise.all([
+        tx
+          .select()
+          .from(agentWorkflowNodeRuns)
+          .where(
+            and(
+              eq(agentWorkflowNodeRuns.runId, existing.runId),
+              eq(agentWorkflowNodeRuns.nodeId, input.initialNodeRun.nodeId),
+              eq(agentWorkflowNodeRuns.attempt, 1),
+            ),
+          )
+          .limit(1),
+        tx
+          .select()
+          .from(agentWorkflowEvents)
+          .where(eq(agentWorkflowEvents.eventId, input.event.eventId))
+          .limit(1),
+      ]);
+      const record = await runRecord(tx, existing);
+      if (
+        node[0] &&
+        event[0] &&
+        sameRunCreate(record, toNodeRun(node[0]), input)
+      ) {
+        return mutationResult(record, [toEvent(event[0])], true);
+      }
+      conflict("RUN_IDEMPOTENCY_CONFLICT");
+    }
+    assertPendingEvent(input.event, input.run.runId, 1);
+    await assertDrizzleRunLineage(tx, input);
+    await assertDrizzleEventAppend({
+      tx,
+      runId: input.run.runId,
+      events: [input.event],
+    });
+    await tx
+      .insert(agentWorkflowRuns)
+      .values(runCreateRow(input.run, input.idempotencyKey));
+    await tx
+      .insert(agentWorkflowNodeRuns)
+      .values(nodeRunRow(input.initialNodeRun));
+    const [createdEvent] = await tx
+      .insert(agentWorkflowEvents)
+      .values(eventRow(input.run.runId, 1, input.event))
+      .returning();
+    if (!createdEvent) throw new Error("Workflow Run Created Event 未返回记录");
+    return mutationResult(
+      {
+        run: input.run,
+        idempotencyKey: input.idempotencyKey,
+        headSequence: 1,
+        recoveryCount: 0,
+      },
+      [toEvent(createdEvent)],
+      false,
+    );
+  });
+}
+
+export async function commitDrizzleMutation(
+  db: NodePgDatabase,
+  input: AgentWorkflowRunMutation,
+): Promise<AgentWorkflowMutationResult> {
+  return db.transaction(async (tx) => {
+    await tx.execute(
+      sql`select 1 from ${agentWorkflowRuns} where ${agentWorkflowRuns.runId} = ${input.runId} for update`,
+    );
+    const [run] = await tx
+      .select()
+      .from(agentWorkflowRuns)
+      .where(eq(agentWorkflowRuns.runId, input.runId))
+      .limit(1);
+    if (!run) conflict("RUN_NOT_FOUND");
+    if (!input.events.length)
+      throw new Error("Workflow mutation 必须追加 Event");
+    const existingEvents = await tx
+      .select()
+      .from(agentWorkflowEvents)
+      .where(
+        inArray(
+          agentWorkflowEvents.eventId,
+          input.events.map(({ eventId }) => eventId),
+        ),
+      );
+    const record = await runRecord(tx, run);
+    if (existingEvents.length) {
+      const byId = new Map(
+        existingEvents.map((event) => [event.eventId, toEvent(event)]),
+      );
+      const replay = replayEvents(input.runId, input.events, byId);
+      if (replay) {
+        const nodes = await tx
+          .select()
+          .from(agentWorkflowNodeRuns)
+          .where(eq(agentWorkflowNodeRuns.runId, input.runId));
+        assertMutationReplay(
+          record,
+          input,
+          new Map(nodes.map((node) => [node.nodeRunId, toNodeRun(node)])),
+        );
+        return mutationResult(record, replay, true);
+      }
+    }
+    if (record.headSequence !== input.expectedSequence)
+      conflict("SEQUENCE_CONFLICT");
+    input.events.forEach((event, index) =>
+      assertPendingEvent(event, input.runId, record.headSequence + index + 1),
+    );
+    await assertDrizzleEventAppend({
+      tx,
+      runId: input.runId,
+      events: input.events,
+    });
+    validateRunMutation(record, input);
+    const currentNodeRows = await tx
+      .select()
+      .from(agentWorkflowNodeRuns)
+      .where(eq(agentWorkflowNodeRuns.runId, input.runId));
+    const currentNodes = new Map(
+      currentNodeRows.map((row) => {
+        const nodeRun = toNodeRun(row);
+        return [nodeRun.nodeRunId, nodeRun] as const;
+      }),
+    );
+    if (input.runUpdate) {
+      assertImmutableRunIdentity(record.run, input.runUpdate.value);
+    }
+    for (const update of input.nodeUpdates ?? []) {
+      const current = currentNodes.get(update.value.nodeRunId);
+      if (!current) conflict("VERSION_CONFLICT");
+      assertImmutableNodeRunIdentity(current, update.value);
+    }
+    for (const nodeRun of input.nodeInserts ?? []) {
+      assertNodeInsertLineage(nodeRun, currentNodes);
+    }
+    await applyRunMutation(tx, input);
+    const events = input.events.map((event, index) =>
+      eventRow(input.runId, record.headSequence + index + 1, event),
+    );
+    const inserted = await tx
+      .insert(agentWorkflowEvents)
+      .values(events)
+      .returning();
+    const [updatedRun] = await tx
+      .select()
+      .from(agentWorkflowRuns)
+      .where(eq(agentWorkflowRuns.runId, input.runId))
+      .limit(1);
+    if (!updatedRun) conflict("RUN_NOT_FOUND");
+    return mutationResult(
+      await runRecord(tx, updatedRun),
+      inserted.map(toEvent),
+      false,
+    );
+  });
+}

package/template/apps/server/src/agent-workflow/drizzle-repository.ts

@@ -0,0 +1,285 @@
+import {
+  agentWorkflowDefinitions,
+  agentWorkflowEvents,
+  agentWorkflowNodeRuns,
+  agentWorkflowReleases,
+  agentWorkflowRuns,
+  agentWorkflowSideEffectCommands,
+} from "@southwind-ai/database";
+import type {
+  AgentWorkflowRelease,
+  AgentWorkflowSideEffectCommand,
+} from "@southwind-ai/shared";
+import { and, asc, desc, eq, gt } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import {
+  toEvent,
+  toNodeRun,
+  toRelease,
+  toRun,
+  toSideEffect,
+} from "./drizzle-repository-mappers.js";
+import {
+  commitDrizzleMutation,
+  createDrizzleRun,
+  publishDrizzleRelease,
+} from "./drizzle-repository-write.js";
+import {
+  prepareDrizzleSideEffect,
+  updateDrizzleSideEffect,
+} from "./drizzle-side-effect-repository.js";
+import { admitDrizzleRecovery } from "./drizzle-recovery-admission.js";
+import type {
+  AgentWorkflowEventReadInput,
+  AgentWorkflowRecoveryAdmissionInput,
+  AgentWorkflowRepository,
+  AgentWorkflowRunMutation,
+  CreateAgentWorkflowRunInput,
+} from "./repository.js";
+
+/** PostgreSQL production repository. In-memory repository is a contract double only. */
+export class DrizzleAgentWorkflowRepository implements AgentWorkflowRepository {
+  constructor(private readonly db: NodePgDatabase) {}
+
+  publishRelease(release: AgentWorkflowRelease) {
+    return publishDrizzleRelease(this.db, release);
+  }
+
+  getRelease(releaseId: string) {
+    return this.db
+      .select()
+      .from(agentWorkflowReleases)
+      .where(eq(agentWorkflowReleases.releaseId, releaseId))
+      .limit(1)
+      .then(([row]) => (row ? toRelease(row) : undefined));
+  }
+
+  findRelease(workflowKey: string, version: string) {
+    return this.db
+      .select({ release: agentWorkflowReleases })
+      .from(agentWorkflowReleases)
+      .innerJoin(
+        agentWorkflowDefinitions,
+        eq(
+          agentWorkflowDefinitions.definitionId,
+          agentWorkflowReleases.definitionId,
+        ),
+      )
+      .where(
+        and(
+          eq(agentWorkflowDefinitions.workflowKey, workflowKey),
+          eq(agentWorkflowDefinitions.version, version),
+        ),
+      )
+      .limit(1)
+      .then(([row]) => (row ? toRelease(row.release) : undefined));
+  }
+
+  createRun(input: CreateAgentWorkflowRunInput) {
+    return createDrizzleRun(this.db, input);
+  }
+
+  async getRun(runId: string) {
+    const [run, head] = await Promise.all([
+      this.db
+        .select()
+        .from(agentWorkflowRuns)
+        .where(eq(agentWorkflowRuns.runId, runId))
+        .limit(1),
+      this.db
+        .select({ sequence: agentWorkflowEvents.sequence })
+        .from(agentWorkflowEvents)
+        .where(eq(agentWorkflowEvents.runId, runId))
+        .orderBy(desc(agentWorkflowEvents.sequence))
+        .limit(1),
+    ]);
+    const row = run[0];
+    if (!row) return undefined;
+    return {
+      run: toRun(row),
+      idempotencyKey: row.idempotencyKey,
+      headSequence: head[0]?.sequence ?? 0,
+      recoveryCount: row.recoveryCount,
+    };
+  }
+
+  async listRunsForActor(
+    tenantId: string,
+    actorId: string,
+    scopeDigest: string,
+    limit: number,
+  ) {
+    if (
+      !tenantId.trim() ||
+      !actorId.trim() ||
+      !scopeDigest.trim() ||
+      !Number.isSafeInteger(limit) ||
+      limit < 1 ||
+      limit > 200
+    ) {
+      throw new Error("Workflow Run object query 无效");
+    }
+    const rows = await this.db
+      .select()
+      .from(agentWorkflowRuns)
+      .where(
+        and(
+          eq(agentWorkflowRuns.tenantId, tenantId),
+          eq(agentWorkflowRuns.actorId, actorId),
+          eq(agentWorkflowRuns.scopeDigest, scopeDigest),
+        ),
+      )
+      .orderBy(desc(agentWorkflowRuns.createdAt))
+      .limit(limit);
+    return Promise.all(
+      rows.map(async (row) => {
+        const [head] = await this.db
+          .select({ sequence: agentWorkflowEvents.sequence })
+          .from(agentWorkflowEvents)
+          .where(eq(agentWorkflowEvents.runId, row.runId))
+          .orderBy(desc(agentWorkflowEvents.sequence))
+          .limit(1);
+        return {
+          run: toRun(row),
+          idempotencyKey: row.idempotencyKey,
+          headSequence: head?.sequence ?? 0,
+          recoveryCount: row.recoveryCount,
+        };
+      }),
+    );
+  }
+
+  async getSnapshot(runId: string) {
+    return this.db.transaction(
+      async (tx) => {
+        const [run] = await tx
+          .select()
+          .from(agentWorkflowRuns)
+          .where(eq(agentWorkflowRuns.runId, runId))
+          .limit(1);
+        if (!run) return undefined;
+        const [head, nodeRuns, sideEffects] = await Promise.all([
+          tx
+            .select({ sequence: agentWorkflowEvents.sequence })
+            .from(agentWorkflowEvents)
+            .where(eq(agentWorkflowEvents.runId, runId))
+            .orderBy(desc(agentWorkflowEvents.sequence))
+            .limit(1),
+          tx
+            .select()
+            .from(agentWorkflowNodeRuns)
+            .where(eq(agentWorkflowNodeRuns.runId, runId))
+            .orderBy(
+              asc(agentWorkflowNodeRuns.nodeId),
+              asc(agentWorkflowNodeRuns.attempt),
+            ),
+          tx
+            .select()
+            .from(agentWorkflowSideEffectCommands)
+            .where(eq(agentWorkflowSideEffectCommands.runId, runId))
+            .orderBy(asc(agentWorkflowSideEffectCommands.createdAt)),
+        ]);
+        return {
+          run: toRun(run),
+          idempotencyKey: run.idempotencyKey,
+          headSequence: head[0]?.sequence ?? 0,
+          recoveryCount: run.recoveryCount,
+          nodeRuns: nodeRuns.map(toNodeRun),
+          sideEffects: sideEffects.map(toSideEffect),
+        };
+      },
+      { isolationLevel: "repeatable read", accessMode: "read only" },
+    );
+  }
+
+  getNodeRun(nodeRunId: string) {
+    return this.db
+      .select()
+      .from(agentWorkflowNodeRuns)
+      .where(eq(agentWorkflowNodeRuns.nodeRunId, nodeRunId))
+      .limit(1)
+      .then(([row]) => (row ? toNodeRun(row) : undefined));
+  }
+
+  listNodeRuns(runId: string) {
+    return this.db
+      .select()
+      .from(agentWorkflowNodeRuns)
+      .where(eq(agentWorkflowNodeRuns.runId, runId))
+      .orderBy(
+        asc(agentWorkflowNodeRuns.nodeId),
+        asc(agentWorkflowNodeRuns.attempt),
+      )
+      .then((rows) => rows.map(toNodeRun));
+  }
+
+  readEvents(input: AgentWorkflowEventReadInput) {
+    if (
+      !Number.isSafeInteger(input.afterSequence) ||
+      input.afterSequence < 0 ||
+      !Number.isSafeInteger(input.limit) ||
+      input.limit < 1 ||
+      input.limit > 1_000
+    ) {
+      throw new Error("Workflow Event 读取范围无效");
+    }
+    return this.db
+      .select()
+      .from(agentWorkflowEvents)
+      .where(
+        and(
+          eq(agentWorkflowEvents.runId, input.runId),
+          gt(agentWorkflowEvents.sequence, input.afterSequence),
+        ),
+      )
+      .orderBy(asc(agentWorkflowEvents.sequence))
+      .limit(input.limit)
+      .then((rows) => rows.map(toEvent));
+  }
+
+  findEvent(eventId: string) {
+    return this.db
+      .select()
+      .from(agentWorkflowEvents)
+      .where(eq(agentWorkflowEvents.eventId, eventId))
+      .limit(1)
+      .then(([row]) => (row ? toEvent(row) : undefined));
+  }
+
+  commit(input: AgentWorkflowRunMutation) {
+    return commitDrizzleMutation(this.db, input);
+  }
+
+  admitRecovery(input: AgentWorkflowRecoveryAdmissionInput) {
+    return admitDrizzleRecovery(this.db, input);
+  }
+
+  prepareSideEffect(command: AgentWorkflowSideEffectCommand) {
+    return prepareDrizzleSideEffect(this.db, command);
+  }
+
+  getSideEffect(commandId: string) {
+    return this.db
+      .select()
+      .from(agentWorkflowSideEffectCommands)
+      .where(eq(agentWorkflowSideEffectCommands.commandId, commandId))
+      .limit(1)
+      .then(([row]) => (row ? toSideEffect(row) : undefined));
+  }
+
+  listSideEffects(runId: string) {
+    return this.db
+      .select()
+      .from(agentWorkflowSideEffectCommands)
+      .where(eq(agentWorkflowSideEffectCommands.runId, runId))
+      .orderBy(asc(agentWorkflowSideEffectCommands.createdAt))
+      .then((rows) => rows.map(toSideEffect));
+  }
+
+  updateSideEffect(
+    command: AgentWorkflowSideEffectCommand,
+    expectedVersion: number,
+  ) {
+    return updateDrizzleSideEffect(this.db, command, expectedVersion);
+  }
+}

package/template/apps/server/src/agent-workflow/drizzle-side-effect-repository.ts

@@ -0,0 +1,83 @@
+import { agentWorkflowSideEffectCommands } from "@southwind-ai/database";
+import type { AgentWorkflowSideEffectCommand } from "@southwind-ai/shared";
+import { and, eq, or } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { sideEffectRow, toSideEffect } from "./drizzle-repository-mappers.js";
+import { conflict } from "./in-memory-repository-support.js";
+import { samePreparedSideEffect } from "./side-effect-state.js";
+import { lock } from "./drizzle-write-support.js";
+
+export async function prepareDrizzleSideEffect(
+  db: NodePgDatabase,
+  command: AgentWorkflowSideEffectCommand,
+) {
+  return db.transaction(async (tx) => {
+    await lock(tx, `effect:${command.idempotencyKey}`);
+    const [existing] = await tx
+      .select()
+      .from(agentWorkflowSideEffectCommands)
+      .where(
+        or(
+          eq(agentWorkflowSideEffectCommands.commandId, command.commandId),
+          eq(
+            agentWorkflowSideEffectCommands.idempotencyKey,
+            command.idempotencyKey,
+          ),
+          and(
+            eq(agentWorkflowSideEffectCommands.nodeRunId, command.nodeRunId),
+            eq(agentWorkflowSideEffectCommands.effectKind, command.effectKind),
+            eq(agentWorkflowSideEffectCommands.effectKey, command.effectKey),
+          ),
+        ),
+      )
+      .limit(1);
+    if (existing) {
+      const value = toSideEffect(existing);
+      if (samePreparedSideEffect(value, command)) {
+        return { command: value, created: false };
+      }
+      conflict("SIDE_EFFECT_CONFLICT");
+    }
+    const [created] = await tx
+      .insert(agentWorkflowSideEffectCommands)
+      .values(sideEffectRow(command))
+      .returning();
+    if (!created) conflict("SIDE_EFFECT_CONFLICT");
+    return { command: toSideEffect(created), created: true };
+  });
+}
+
+export async function updateDrizzleSideEffect(
+  db: NodePgDatabase,
+  command: AgentWorkflowSideEffectCommand,
+  expectedVersion: number,
+) {
+  return db.transaction(async (tx) => {
+    const [existing] = await tx
+      .select()
+      .from(agentWorkflowSideEffectCommands)
+      .where(eq(agentWorkflowSideEffectCommands.commandId, command.commandId))
+      .for("update")
+      .limit(1);
+    if (
+      !existing ||
+      existing.version !== expectedVersion ||
+      command.version !== expectedVersion + 1 ||
+      !samePreparedSideEffect(toSideEffect(existing), command)
+    ) {
+      conflict("VERSION_CONFLICT");
+    }
+    const [updated] = await tx
+      .update(agentWorkflowSideEffectCommands)
+      .set(sideEffectRow(command))
+      .where(
+        and(
+          eq(agentWorkflowSideEffectCommands.commandId, command.commandId),
+          eq(agentWorkflowSideEffectCommands.version, expectedVersion),
+        ),
+      )
+      .returning();
+    if (!updated) conflict("VERSION_CONFLICT");
+    return toSideEffect(updated);
+  });
+}