@osolmaz/pi-workflows 0.16.4 → 0.16.6

package/src/state/project-store.ts

@@ -0,0 +1,218 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { StateDatabase, workflowStatePath } from "./database.js";
+import { recordViewerDeltas } from "./viewer.js";
+
+type LeaseRow = {
+  generation: number;
+  ownerType: string | null;
+  ownerId: string | null;
+  tokenHash: Buffer | null;
+  expiresAt: number | null;
+};
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isLeaseRow(value: unknown): value is LeaseRow {
+  return isRecord(value);
+}
+
+function isProjectRow(value: unknown): value is { projectId: string } {
+  return isRecord(value);
+}
+
+function isRevisionRow(value: unknown): value is { revision: number } {
+  return isRecord(value);
+}
+
+export function isSequenceRow(value: unknown): value is { seq: number } {
+  return isRecord(value);
+}
+
+function projectIdFor(canonicalPath: string): string {
+  return `project-${createHash("sha256").update(canonicalPath).digest("hex").slice(0, 40)}`;
+}
+
+function canonicalProjectPath(value: string): string {
+  try {
+    return fs.realpathSync.native(value);
+  } catch {
+    return path.resolve(value);
+  }
+}
+
+export function validTimestamp(value?: string): string {
+  const date = value === undefined ? new Date() : new Date(value);
+  if (!Number.isFinite(date.getTime())) throw new Error("Invalid timestamp");
+  return date.toISOString();
+}
+
+export function epoch(value: string): number {
+  return Date.parse(value);
+}
+
+/** Shared connection, project, and revision operations; domain stores own their rows. */
+export abstract class ProjectStore {
+  readonly filePath: string;
+
+  readonly state: StateDatabase;
+
+  private readonly ownsState: boolean;
+
+  protected readonly projectId: string | null;
+
+  private closed = false;
+
+  constructor(
+    filePath: string = workflowStatePath(),
+    options: {
+      readOnly?: boolean;
+      projectPath?: string;
+      state?: StateDatabase;
+      /** Server-only global view. Project-scoped mutations still require projectPath. */
+      global?: boolean;
+    } = {},
+  ) {
+    this.ownsState = options.state === undefined;
+    this.state =
+      options.state ??
+      new StateDatabase({
+        filePath,
+        mode: options.readOnly === true ? "read-only" : "read-write",
+        checkLegacyState: filePath === workflowStatePath(),
+      });
+    this.filePath = this.state.filePath;
+    if (options.global === true) {
+      this.projectId = null;
+    } else {
+      const projectPath = options.projectPath === undefined ? process.cwd() : options.projectPath;
+      this.projectId =
+        this.state.mode === "read-only"
+          ? this.findProject(projectPath)
+          : this.ensureProject(projectPath);
+    }
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.ownsState) this.state.close();
+  }
+
+  private ensureProject(projectPath: string): string {
+    const canonicalPath = canonicalProjectPath(projectPath);
+    const projectId = projectIdFor(canonicalPath);
+    this.state.connection
+      .prepare(
+        `INSERT INTO projects(project_id, canonical_path, created_at)
+         VALUES (?, ?, ?) ON CONFLICT(project_id) DO NOTHING`,
+      )
+      .run(projectId, canonicalPath, Date.now());
+    return projectId;
+  }
+
+  private findProject(projectPath: string): string | null {
+    const row = this.state.connection
+      .prepare("SELECT project_id AS projectId FROM projects WHERE canonical_path = ?")
+      .get(canonicalProjectPath(projectPath));
+    return isProjectRow(row) ? row.projectId : null;
+  }
+
+  protected requireProjectId(): string {
+    if (this.projectId === null) throw new Error("Project is not registered in the state database");
+    return this.projectId;
+  }
+
+  protected requireLease(resourceId: string): LeaseRow {
+    const row = this.state.connection
+      .prepare(
+        `SELECT generation, owner_type AS ownerType, owner_id AS ownerId,
+                token_hash AS tokenHash, expires_at AS expiresAt
+         FROM leases WHERE resource_id = ?`,
+      )
+      .get(resourceId);
+    /* istanbul ignore if -- exact schema and internal query shape */
+    /* istanbul ignore if -- impossible after exact schema and transaction checks */
+    if (!isLeaseRow(row)) throw new Error(`Lease is missing: ${resourceId}`);
+    return row;
+  }
+
+  protected resourceRevision(resourceId: string): number {
+    const row = this.state.connection
+      .prepare("SELECT revision FROM resources WHERE resource_id = ?")
+      .get(resourceId);
+    /* istanbul ignore if -- exact schema and internal query shape */
+    /* istanbul ignore if -- impossible after exact schema and transaction checks */
+    if (!isRevisionRow(row)) throw new Error(`Resource is missing: ${resourceId}`);
+    return row.revision;
+  }
+
+  protected bumpResource(resourceId: string, expectedRevision: number, now: number): void {
+    const result = this.state.connection
+      .prepare(
+        "UPDATE resources SET revision = revision + 1, updated_at = ? WHERE resource_id = ? AND revision = ?",
+      )
+      .run(now, resourceId, expectedRevision);
+    if (result.changes !== 1) throw new Error("Resource revision conflict");
+    const run = this.state.connection
+      .prepare(
+        `SELECT r.run_id AS runId
+         FROM runs r JOIN viewer_runs v ON v.run_id = r.run_id
+         WHERE r.resource_id = ?`,
+      )
+      .get(resourceId);
+    if (isRecord(run) && typeof run.runId === "string") {
+      recordViewerDeltas(
+        this.state,
+        run.runId,
+        [
+          { targetType: "summary" },
+          { targetType: "graph" },
+          { targetType: "replay" },
+          { targetType: "inspector", targetKey: "run" },
+        ],
+        now,
+      );
+    }
+  }
+
+  protected insertEvent(
+    resourceId: string,
+    revision: number,
+    type: string,
+    actorType: string,
+    actorId: string | null,
+    payload: unknown,
+    now: number,
+    leaseGeneration?: number,
+  ): string {
+    const eventId = `event-${randomUUID()}`;
+    const payloadHash = this.state.putJson(payload, now);
+    this.state.connection
+      .prepare(
+        `INSERT INTO events(
+           event_id, resource_id, resource_revision, event_type, actor_type,
+           actor_id, lease_generation, payload_hash, recorded_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        eventId,
+        resourceId,
+        revision,
+        type,
+        actorType,
+        actorId,
+        leaseGeneration ?? null,
+        payloadHash,
+        now,
+      );
+    return eventId;
+  }
+
+  protected assertWritable(): void {
+    if (this.state.mode === "read-only") throw new Error("State store is read-only");
+  }
+}