@drej/postgres 0.2.0 → 0.3.0

package/dist/index.d.mts

@@ -0,0 +1,24 @@
+import { CheckpointInfo, EnvironmentRecord, IStorageAdapter, LedgerEntry, ListSandboxOptions, SandboxDetails } from "@drej/core";
+
+//#region src/adapter.d.ts
+declare class PostgresAdapter implements IStorageAdapter {
+  private readonly sql;
+  constructor(connectionString: string);
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  append(entry: LedgerEntry): Promise<void>;
+  readAll(name: string, sandboxId: string): Promise<LedgerEntry[]>;
+  lastCheckpoint(name: string, sandboxId: string): Promise<LedgerEntry | null>;
+  private _aggQuery;
+  listSandboxDetails(name: string, opts?: ListSandboxOptions): Promise<SandboxDetails[]>;
+  listAllSandboxDetails(opts?: ListSandboxOptions): Promise<SandboxDetails[]>;
+  getSandboxDetails(name: string, sandboxId: string): Promise<SandboxDetails | null>;
+  deleteSandbox(name: string, sandboxId: string): Promise<void>;
+  listCheckpoints(name: string, sandboxId: string): Promise<CheckpointInfo[]>;
+  getEnvironment(name: string): Promise<EnvironmentRecord | null>;
+  saveEnvironment(record: EnvironmentRecord): Promise<void>;
+  deleteEnvironment(name: string): Promise<void>;
+  listEnvironments(): Promise<EnvironmentRecord[]>;
+}
+//#endregion
+export { PostgresAdapter };

package/dist/index.mjs

@@ -0,0 +1,183 @@
+import postgres from "postgres";
+import { SandboxStatus } from "@drej/core";
+//#region src/migrations.ts
+const MIGRATION_SQL = `
+CREATE TABLE IF NOT EXISTS drej_events (
+  id          BIGSERIAL   PRIMARY KEY,
+  sandbox_id  TEXT        NOT NULL,
+  name        TEXT        NOT NULL,
+  step_idx    INTEGER     NOT NULL,
+  branch      INTEGER,
+  event       TEXT        NOT NULL,
+  payload     JSONB,
+  error       TEXT,
+  ts          BIGINT      NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS drej_events_sandbox_id ON drej_events(sandbox_id);
+CREATE INDEX IF NOT EXISTS drej_events_name ON drej_events(name);
+
+CREATE TABLE IF NOT EXISTS drej_environments (
+  name        TEXT    PRIMARY KEY,
+  snapshot_id TEXT    NOT NULL,
+  image       TEXT    NOT NULL,
+  built_at    BIGINT  NOT NULL
+);
+`;
+//#endregion
+//#region src/adapter.ts
+function aggRowToDetails(row) {
+	return {
+		name: row.name,
+		sandboxId: row.sandbox_id,
+		status: Number(row.is_closed) ? SandboxStatus.Completed : SandboxStatus.Running,
+		startedAt: Number(row.started_at),
+		completedAt: row.completed_at != null ? Number(row.completed_at) : void 0,
+		execCount: Number(row.exec_count)
+	};
+}
+function applyOpts(details, opts) {
+	let result = details;
+	if (opts?.before != null) result = result.filter((d) => d.startedAt < opts.before);
+	if (opts?.status != null) result = result.filter((d) => d.status === opts.status);
+	if (opts?.limit != null) result = result.slice(0, opts.limit);
+	return result;
+}
+function rowToEntry(row) {
+	return {
+		sandboxId: row.sandbox_id,
+		name: row.name,
+		stepIndex: row.step_idx,
+		branch: row.branch ?? void 0,
+		event: row.event,
+		payload: row.payload ?? void 0,
+		error: row.error ?? void 0,
+		ts: Number(row.ts)
+	};
+}
+var PostgresAdapter = class {
+	sql;
+	constructor(connectionString) {
+		this.sql = postgres(connectionString);
+	}
+	async connect() {
+		await this.sql.unsafe(MIGRATION_SQL);
+	}
+	async close() {
+		await this.sql.end();
+	}
+	async append(entry) {
+		await this.sql`
+      INSERT INTO drej_events (sandbox_id, name, step_idx, branch, event, payload, error, ts)
+      VALUES (
+        ${entry.sandboxId},
+        ${entry.name},
+        ${entry.stepIndex},
+        ${entry.branch ?? null},
+        ${entry.event},
+        ${entry.payload !== void 0 ? JSON.stringify(entry.payload) : null},
+        ${entry.error ?? null},
+        ${entry.ts}
+      )
+    `;
+	}
+	async readAll(name, sandboxId) {
+		return (await this.sql`
+      SELECT sandbox_id, name, step_idx, branch, event, payload, error, ts
+      FROM drej_events
+      WHERE name = ${name} AND sandbox_id = ${sandboxId}
+      ORDER BY ts ASC
+    `).map(rowToEntry);
+	}
+	async lastCheckpoint(name, sandboxId) {
+		const rows = await this.sql`
+      SELECT sandbox_id, name, step_idx, branch, event, payload, error, ts
+      FROM drej_events
+      WHERE name = ${name} AND sandbox_id = ${sandboxId} AND event = 'checkpoint_created'
+      ORDER BY ts DESC
+      LIMIT 1
+    `;
+		return rows.length ? rowToEntry(rows[0]) : null;
+	}
+	async _aggQuery(whereClause, params) {
+		return this.sql.unsafe(`WITH agg AS (
+        SELECT
+          name,
+          sandbox_id,
+          MIN(CASE WHEN event = 'sandbox_created' THEN ts END) AS started_at,
+          MAX(CASE WHEN event = 'sandbox_closed'  THEN ts END) AS completed_at,
+          MAX(CASE WHEN event = 'sandbox_closed'  THEN 1 ELSE 0 END)::int AS is_closed,
+          COUNT(CASE WHEN event = 'exec_complete' THEN 1 END)::int AS exec_count
+        FROM drej_events
+        ${whereClause}
+        GROUP BY name, sandbox_id
+      )
+      SELECT * FROM agg WHERE started_at IS NOT NULL ORDER BY started_at DESC`, params);
+	}
+	async listSandboxDetails(name, opts) {
+		return applyOpts((await this._aggQuery("WHERE name = $1", [name])).map(aggRowToDetails), opts);
+	}
+	async listAllSandboxDetails(opts) {
+		return applyOpts((await this._aggQuery("", [])).map(aggRowToDetails), opts);
+	}
+	async getSandboxDetails(name, sandboxId) {
+		const rows = await this._aggQuery("WHERE name = $1 AND sandbox_id = $2", [name, sandboxId]);
+		return rows.length ? aggRowToDetails(rows[0]) : null;
+	}
+	async deleteSandbox(name, sandboxId) {
+		await this.sql`DELETE FROM drej_events WHERE name = ${name} AND sandbox_id = ${sandboxId}`;
+	}
+	async listCheckpoints(name, sandboxId) {
+		return (await this.sql`
+      SELECT sandbox_id, name, step_idx, branch, event, payload, error, ts
+      FROM drej_events
+      WHERE name = ${name} AND sandbox_id = ${sandboxId} AND event = 'checkpoint_created'
+      ORDER BY ts ASC
+    `).map((r) => {
+			const p = r.payload ?? {};
+			return {
+				snapshotId: p.snapshotId,
+				tag: p.name,
+				createdAt: Number(r.ts)
+			};
+		});
+	}
+	async getEnvironment(name) {
+		const rows = await this.sql`
+      SELECT name, snapshot_id, image, built_at FROM drej_environments WHERE name = ${name}
+    `;
+		if (!rows.length) return null;
+		const r = rows[0];
+		return {
+			name: r.name,
+			snapshotId: r.snapshot_id,
+			image: r.image,
+			builtAt: Number(r.built_at)
+		};
+	}
+	async saveEnvironment(record) {
+		await this.sql`
+      INSERT INTO drej_environments (name, snapshot_id, image, built_at)
+      VALUES (${record.name}, ${record.snapshotId}, ${record.image}, ${record.builtAt})
+      ON CONFLICT (name) DO UPDATE
+        SET snapshot_id = excluded.snapshot_id,
+            image       = excluded.image,
+            built_at    = excluded.built_at
+    `;
+	}
+	async deleteEnvironment(name) {
+		await this.sql`DELETE FROM drej_environments WHERE name = ${name}`;
+	}
+	async listEnvironments() {
+		return (await this.sql`
+      SELECT name, snapshot_id, image, built_at FROM drej_environments ORDER BY built_at DESC
+    `).map((r) => ({
+			name: r.name,
+			snapshotId: r.snapshot_id,
+			image: r.image,
+			builtAt: Number(r.built_at)
+		}));
+	}
+};
+//#endregion
+export { PostgresAdapter };

package/package.json

@@ -1,16 +1,31 @@
 {
   "name": "@drej/postgres",
-  "version": "0.2.0",
+  "version": "0.3.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
-  "main": "./src/index.ts",
+  "scripts": {
+    "build": "tsdown"
+  },
   "dependencies": {
-    "postgres": "3.4.9",
-    "@drej/core": "workspace:*"
+    "@drej/core": "workspace:*",
+    "postgres": "3.4.9"
   },
   "devDependencies": {
     "bun-types": "1.3.14",
+    "tsdown": "0.22.3",
     "typescript": "6.0.3"
   }
 }

package/CHANGELOG.md

@@ -1,58 +0,0 @@
-# @drej/postgres
-
-## 0.2.0
-
-### Minor Changes
-
-- 2fd33e0: feat: run management API
-
-  Add `RunStatus` enum, `RunDetails` type, and `ListRunsOptions` for filtering. Replace `listRuns()` with `listRunDetails()`, `listAllRunDetails()`, `getRunDetails()`, and `deleteRun()` on both `IStorageAdapter` and `DrejClient`. Add `WorkflowRun.status` property that tracks execution state as events are consumed.
-
-### Patch Changes
-
-- Updated dependencies [22b8a32]
-- Updated dependencies [799b6dd]
-- Updated dependencies [8d9d8bb]
-- Updated dependencies [2fd33e0]
-- Updated dependencies [0d94c2a]
-  - @drej/core@0.3.0
-
-## 0.1.2
-
-### Patch Changes
-
-- Updated dependencies [4c0ad93]
-- Updated dependencies [b04f8eb]
-- Updated dependencies [a971b7b]
-- Updated dependencies [ce173be]
-- Updated dependencies [86c2dde]
-- Updated dependencies [82094ae]
-  - @drej/core@0.2.0
-
-## 0.1.1
-
-### Patch Changes
-
-- 0ea4c33: Rename npm scope from `@drej/*` to `@drej/*` and add TSDoc to all public API surfaces.
-
-  - All workspace packages now published under `@drej/*` (e.g. `@drej/sqlite`, `@drej/postgres`)
-  - `DrejClient`, `WorkflowBuilder`, `SandboxStepBuilder`, `IStorageAdapter`, `LedgerEvent`, `SandboxOpts` and all their members now have hover documentation visible in VS Code
-
-- Updated dependencies [0ea4c33]
-  - @drej/core@0.1.1
-
-## 0.1.0
-
-### Minor Changes
-
-- 82e77fd: Introduce pluggable storage adapter system.
-
-  - `ILedger` renamed to `IStorageAdapter` with optional `connect()` and `close()` lifecycle methods
-  - `DrejClientOptions.adapter` accepts any `IStorageAdapter` implementation; `DrejClient` exposes matching `connect()` and `close()` methods
-  - New `@drej/postgres` package: `PostgresAdapter` backed by a user-supplied Postgres connection string; owns its schema and runs migrations on `connect()`
-
-### Patch Changes
-
-- Updated dependencies [82e77fd]
-- Updated dependencies [5d77498]
-  - @drej/core@0.1.0

package/src/adapter.ts

@@ -1,156 +0,0 @@
-import postgres from "postgres";
-import type { IStorageAdapter, LedgerEntry, LedgerEvent, RunDetails, ListRunsOptions } from "@drej/core";
-import { RunStatus } from "@drej/core";
-import { MIGRATION_SQL } from "./migrations";
-
-type Row = {
-  run_id: string;
-  wf_name: string;
-  step_idx: number;
-  branch: number | null;
-  event: string;
-  payload: unknown;
-  error: string | null;
-  ts: string;
-};
-
-type AggRow = {
-  wf_name: string;
-  run_id: string;
-  started_at: string | null;
-  completed_at: string | null;
-  terminal_event: string | null;
-  error_msg: string | null;
-  step_count: string;
-};
-
-function terminalToStatus(event: string | null): RunStatus {
-  if (event === "workflow_complete") return RunStatus.Completed;
-  if (event === "workflow_failed") return RunStatus.Failed;
-  return RunStatus.Running;
-}
-
-function aggRowToDetails(row: AggRow): RunDetails {
-  return {
-    workflowName: row.wf_name,
-    runId: row.run_id,
-    status: terminalToStatus(row.terminal_event),
-    startedAt: Number(row.started_at),
-    completedAt: row.completed_at != null ? Number(row.completed_at) : undefined,
-    stepCount: Number(row.step_count),
-    error: row.error_msg ?? undefined,
-  };
-}
-
-function applyOpts(details: RunDetails[], opts?: ListRunsOptions): RunDetails[] {
-  let result = details;
-  if (opts?.before != null) result = result.filter((d) => d.startedAt < opts.before!);
-  if (opts?.status != null) result = result.filter((d) => d.status === opts.status);
-  if (opts?.limit != null) result = result.slice(0, opts.limit);
-  return result;
-}
-
-function rowToEntry(row: Row): LedgerEntry {
-  return {
-    runId: row.run_id,
-    workflowName: row.wf_name,
-    stepIndex: row.step_idx,
-    branch: row.branch ?? undefined,
-    event: row.event as LedgerEvent,
-    payload: row.payload ?? undefined,
-    error: row.error ?? undefined,
-    ts: Number(row.ts),
-  };
-}
-
-export class PostgresAdapter implements IStorageAdapter {
-  private readonly sql: ReturnType<typeof postgres>;
-
-  constructor(connectionString: string) {
-    this.sql = postgres(connectionString);
-  }
-
-  async connect(): Promise<void> {
-    await this.sql.unsafe(MIGRATION_SQL);
-  }
-
-  async close(): Promise<void> {
-    await this.sql.end();
-  }
-
-  async append(entry: LedgerEntry): Promise<void> {
-    await this.sql`
-      INSERT INTO drej_events (run_id, wf_name, step_idx, branch, event, payload, error, ts)
-      VALUES (
-        ${entry.runId},
-        ${entry.workflowName},
-        ${entry.stepIndex},
-        ${entry.branch ?? null},
-        ${entry.event},
-        ${entry.payload !== undefined ? JSON.stringify(entry.payload) : null},
-        ${entry.error ?? null},
-        ${entry.ts}
-      )
-    `;
-  }
-
-  async readAll(workflowName: string, runId: string): Promise<LedgerEntry[]> {
-    const rows = await this.sql<Row[]>`
-      SELECT run_id, wf_name, step_idx, branch, event, payload, error, ts
-      FROM drej_events
-      WHERE wf_name = ${workflowName} AND run_id = ${runId}
-      ORDER BY ts ASC
-    `;
-    return rows.map(rowToEntry);
-  }
-
-  async lastCheckpoint(workflowName: string, runId: string): Promise<LedgerEntry | null> {
-    const rows = await this.sql<Row[]>`
-      SELECT run_id, wf_name, step_idx, branch, event, payload, error, ts
-      FROM drej_events
-      WHERE wf_name = ${workflowName} AND run_id = ${runId} AND event = 'checkpoint'
-      ORDER BY ts DESC
-      LIMIT 1
-    `;
-    return rows.length ? rowToEntry(rows[0]) : null;
-  }
-
-  private async _aggQuery(whereClause: string, params: string[]): Promise<AggRow[]> {
-    return this.sql.unsafe<AggRow[]>(
-      `WITH agg AS (
-        SELECT
-          wf_name,
-          run_id,
-          MIN(CASE WHEN event = 'run_started' THEN ts END) AS started_at,
-          MAX(CASE WHEN event IN ('workflow_complete', 'workflow_failed') THEN ts END) AS completed_at,
-          MAX(CASE WHEN event IN ('workflow_complete', 'workflow_failed') THEN event END) AS terminal_event,
-          MAX(CASE WHEN event = 'workflow_failed' THEN error END) AS error_msg,
-          COUNT(CASE WHEN event = 'step_complete' THEN 1 END)::int AS step_count
-        FROM drej_events
-        ${whereClause}
-        GROUP BY wf_name, run_id
-      )
-      SELECT * FROM agg WHERE started_at IS NOT NULL ORDER BY started_at DESC`,
-      params,
-    );
-  }
-
-  async listRunDetails(workflowName: string, opts?: ListRunsOptions): Promise<RunDetails[]> {
-    const rows = await this._aggQuery("WHERE wf_name = $1", [workflowName]);
-    return applyOpts(rows.map(aggRowToDetails), opts);
-  }
-
-  async listAllRunDetails(opts?: ListRunsOptions): Promise<RunDetails[]> {
-    const rows = await this._aggQuery("", []);
-    return applyOpts(rows.map(aggRowToDetails), opts);
-  }
-
-  async getRunDetails(workflowName: string, runId: string): Promise<RunDetails | null> {
-    const rows = await this._aggQuery("WHERE wf_name = $1 AND run_id = $2", [workflowName, runId]);
-    return rows.length ? aggRowToDetails(rows[0]) : null;
-  }
-
-  async deleteRun(workflowName: string, runId: string): Promise<void> {
-    await this.sql`DELETE FROM drej_events WHERE wf_name = ${workflowName} AND run_id = ${runId}`;
-  }
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { PostgresAdapter } from "./adapter";

package/src/migrations.ts

@@ -1,16 +0,0 @@
-export const MIGRATION_SQL = `
-CREATE TABLE IF NOT EXISTS drej_events (
-  id        BIGSERIAL   PRIMARY KEY,
-  run_id    TEXT        NOT NULL,
-  wf_name   TEXT        NOT NULL,
-  step_idx  INTEGER     NOT NULL,
-  branch    INTEGER,
-  event     TEXT        NOT NULL,
-  payload   JSONB,
-  error     TEXT,
-  ts        BIGINT      NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS drej_events_run_id ON drej_events(run_id);
-CREATE INDEX IF NOT EXISTS drej_events_wf_name ON drej_events(wf_name);
-`;

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "noEmit": true,
-    "skipLibCheck": true,
-    "allowImportingTsExtensions": true,
-    "types": ["bun-types"]
-  },
-  "include": ["src"]
-}