workplane 0.4.1 → 0.4.2

package/dist/migrate.js

@@ -17,11 +17,14 @@ __export(sqlite_exports, {
   runInputEvents: () => runInputEvents2,
   runLogs: () => runLogs2,
   runs: () => runs2,
-  tasks: () => tasks2
+  tasks: () => tasks2,
+  workplanRuns: () => workplanRuns2,
+  workplanSchedules: () => workplanSchedules2,
+  workplanStepResults: () => workplanStepResults2
 });
 import { isNull as isNull2, sql as sql3 } from "drizzle-orm";
 import { index as index2, integer as integer2, sqliteTable, text as text2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/sqlite-core";
-var nowDefault, tasks2, nodes2, runs2, runLogs2, artifacts2, runInputEvents2;
+var nowDefault, tasks2, nodes2, runs2, runLogs2, artifacts2, workplanSchedules2, workplanRuns2, workplanStepResults2, runInputEvents2;
 var init_sqlite = __esm({
   "../db/src/schema/sqlite.ts"() {
     "use strict";
@@ -83,6 +86,49 @@ var init_sqlite = __esm({
     }, (table) => ({
       runIdIdx: index2("idx_artifacts_run_id").on(table.runId)
     }));
+    workplanSchedules2 = sqliteTable("workplan_schedules", {
+      id: text2("id").primaryKey(),
+      planId: text2("plan_id").notNull(),
+      name: text2("name").notNull(),
+      cronExpression: text2("cron_expression").notNull(),
+      timezone: text2("timezone").notNull(),
+      inputs: text2("inputs", { mode: "json" }).$type().notNull().default({}),
+      enabled: integer2("enabled", { mode: "boolean" }).notNull().default(true),
+      lastRunAt: text2("last_run_at"),
+      nextRunAt: text2("next_run_at"),
+      createdBy: text2("created_by"),
+      createdAt: text2("created_at").notNull().default(nowDefault),
+      updatedAt: text2("updated_at").notNull().default(nowDefault)
+    }, (table) => ({
+      dueIdx: index2("idx_workplan_schedules_due").on(table.nextRunAt)
+    }));
+    workplanRuns2 = sqliteTable("workplan_runs", {
+      id: text2("id").primaryKey(),
+      scheduleId: text2("schedule_id").references(() => workplanSchedules2.id),
+      planId: text2("plan_id").notNull(),
+      planName: text2("plan_name").notNull(),
+      status: text2("status").notNull().default("running"),
+      idempotencyKey: text2("idempotency_key"),
+      createdAt: text2("created_at").notNull().default(nowDefault),
+      endedAt: text2("ended_at"),
+      error: text2("error")
+    }, (table) => ({
+      scheduleIdx: index2("idx_workplan_runs_schedule_id").on(table.scheduleId),
+      idempotencyUnique: uniqueIndex2("idx_workplan_runs_idempotency").on(table.idempotencyKey)
+    }));
+    workplanStepResults2 = sqliteTable("workplan_step_results", {
+      id: text2("id").primaryKey(),
+      workplanRunId: text2("workplan_run_id").notNull().references(() => workplanRuns2.id),
+      stepId: text2("step_id").notNull(),
+      stepName: text2("step_name").notNull(),
+      output: text2("output"),
+      exitCode: integer2("exit_code"),
+      durationMs: integer2("duration_ms"),
+      metadata: text2("metadata", { mode: "json" }).$type(),
+      createdAt: text2("created_at").notNull().default(nowDefault)
+    }, (table) => ({
+      runIdx: index2("idx_workplan_step_results_run_id").on(table.workplanRunId)
+    }));
     runInputEvents2 = sqliteTable("run_input_events", {
       id: integer2("id").primaryKey({ autoIncrement: true }),
       runId: text2("run_id").notNull().references(() => runs2.id),
@@ -151,7 +197,7 @@ function parseCsv(value) {
 // ../db/src/migration.ts
 import { mkdirSync as mkdirSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname2, join as join3, resolve } from "path";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
 // ../db/src/client.ts
@@ -164,7 +210,7 @@ import Database from "better-sqlite3";
 import { Pool } from "pg";
 
 // ../db/src/pg-store.ts
-import { and, asc, desc, eq, gt, sql as sql2 } from "drizzle-orm";
+import { and, arrayContains, asc, desc, eq, gt, isNotNull, lte, sql as sql2 } from "drizzle-orm";
 
 // ../db/src/schema/pg.ts
 var pg_exports = {};
@@ -174,10 +220,13 @@ __export(pg_exports, {
   runInputEvents: () => runInputEvents,
   runLogs: () => runLogs,
   runs: () => runs,
-  tasks: () => tasks
+  tasks: () => tasks,
+  workplanRuns: () => workplanRuns,
+  workplanSchedules: () => workplanSchedules,
+  workplanStepResults: () => workplanStepResults
 });
 import { isNull, sql } from "drizzle-orm";
-import { bigint, bigserial, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { bigint, bigserial, boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
 var tasks = pgTable("tasks", {
   id: text("id").primaryKey(),
   kind: text("kind").notNull(),
@@ -235,6 +284,49 @@ var artifacts = pgTable("artifacts", {
 }, (table) => ({
   runIdIdx: index("idx_artifacts_run_id").on(table.runId)
 }));
+var workplanSchedules = pgTable("workplan_schedules", {
+  id: text("id").primaryKey(),
+  planId: text("plan_id").notNull(),
+  name: text("name").notNull(),
+  cronExpression: text("cron_expression").notNull(),
+  timezone: text("timezone").notNull(),
+  inputs: jsonb("inputs").$type().notNull().default({}),
+  enabled: boolean("enabled").notNull().default(true),
+  lastRunAt: timestamp("last_run_at", { withTimezone: true }),
+  nextRunAt: timestamp("next_run_at", { withTimezone: true }),
+  createdBy: text("created_by"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => ({
+  dueIdx: index("idx_workplan_schedules_due").on(table.nextRunAt)
+}));
+var workplanRuns = pgTable("workplan_runs", {
+  id: text("id").primaryKey(),
+  scheduleId: text("schedule_id").references(() => workplanSchedules.id),
+  planId: text("plan_id").notNull(),
+  planName: text("plan_name").notNull(),
+  status: text("status").notNull().default("running"),
+  idempotencyKey: text("idempotency_key"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  endedAt: timestamp("ended_at", { withTimezone: true }),
+  error: text("error")
+}, (table) => ({
+  scheduleIdx: index("idx_workplan_runs_schedule_id").on(table.scheduleId),
+  idempotencyUnique: uniqueIndex("idx_workplan_runs_idempotency").on(table.idempotencyKey)
+}));
+var workplanStepResults = pgTable("workplan_step_results", {
+  id: text("id").primaryKey(),
+  workplanRunId: text("workplan_run_id").notNull().references(() => workplanRuns.id),
+  stepId: text("step_id").notNull(),
+  stepName: text("step_name").notNull(),
+  output: text("output"),
+  exitCode: integer("exit_code"),
+  durationMs: integer("duration_ms"),
+  metadata: jsonb("metadata").$type(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => ({
+  runIdx: index("idx_workplan_step_results_run_id").on(table.workplanRunId)
+}));
 var runInputEvents = pgTable("run_input_events", {
   id: bigserial("id", { mode: "number" }).primaryKey(),
   runId: text("run_id").notNull().references(() => runs.id),
@@ -249,7 +341,7 @@ var runInputEvents = pgTable("run_input_events", {
 }));
 
 // ../db/src/sqlite-store.ts
-import { and as and2, asc as asc2, desc as desc2, eq as eq2, gt as gt2 } from "drizzle-orm";
+import { and as and2, asc as asc2, desc as desc2, eq as eq2, gt as gt2, lte as lte2, sql as sql4 } from "drizzle-orm";
 init_sqlite();
 
 // ../db/src/client.ts
@@ -266,6 +358,144 @@ function getDrizzle(pool) {
   return drizzlePg(pool, { schema: pg_exports });
 }
 
+// ../db/src/baseline-migrations.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function readJournal(migrationsFolder) {
+  return JSON.parse(
+    readFileSync(resolve(migrationsFolder, "meta/_journal.json"), "utf8")
+  );
+}
+function migrationHash(migrationsFolder, tag) {
+  const sql5 = readFileSync(resolve(migrationsFolder, `${tag}.sql`), "utf8");
+  return createHash("sha256").update(sql5).digest("hex");
+}
+function baselineEntries(migrationsFolder, upToIdx) {
+  const journal = readJournal(migrationsFolder);
+  return journal.entries.filter((entry) => entry.idx <= upToIdx).map((entry) => ({
+    hash: migrationHash(migrationsFolder, entry.tag),
+    createdAt: entry.when,
+    tag: entry.tag
+  }));
+}
+async function tableExistsPg(pool, tableName) {
+  const result = await pool.query(
+    `SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = $1
+    ) AS exists`,
+    [tableName]
+  );
+  return Boolean(result.rows[0]?.exists);
+}
+async function getLastMigrationCreatedAtPg(pool) {
+  await pool.query("CREATE SCHEMA IF NOT EXISTS drizzle");
+  await pool.query(`
+    CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
+      id SERIAL PRIMARY KEY,
+      hash text NOT NULL,
+      created_at bigint
+    )
+  `);
+  const result = await pool.query(
+    "SELECT created_at FROM drizzle.__drizzle_migrations ORDER BY created_at DESC LIMIT 1"
+  );
+  const value = result.rows[0]?.created_at;
+  return value === null || value === void 0 ? null : Number(value);
+}
+async function insertBaselinePg(pool, entries) {
+  const inserted = [];
+  const lastCreatedAt = await getLastMigrationCreatedAtPg(pool);
+  for (const entry of entries) {
+    if (lastCreatedAt !== null && lastCreatedAt >= entry.createdAt) {
+      continue;
+    }
+    const existing = await pool.query(
+      "SELECT id FROM drizzle.__drizzle_migrations WHERE created_at = $1 LIMIT 1",
+      [entry.createdAt]
+    );
+    if (existing.rowCount) {
+      continue;
+    }
+    await pool.query(
+      'INSERT INTO drizzle.__drizzle_migrations ("hash", "created_at") VALUES ($1, $2)',
+      [entry.hash, entry.createdAt]
+    );
+    inserted.push(entry.tag);
+  }
+  return inserted;
+}
+async function baselineLegacyPostgresMigrations(pool, migrationsFolder) {
+  const hasTasks = await tableExistsPg(pool, "tasks");
+  if (!hasTasks) {
+    return;
+  }
+  const hasWorkplanSchedules = await tableExistsPg(pool, "workplan_schedules");
+  const upToIdx = hasWorkplanSchedules ? 1 : 0;
+  const inserted = await insertBaselinePg(pool, baselineEntries(migrationsFolder, upToIdx));
+  if (inserted.length > 0) {
+    process.stdout.write(
+      `Baselined existing Postgres schema for migration(s): ${inserted.join(", ")}
+`
+    );
+  }
+}
+function tableExistsSqlite(db, tableName) {
+  const row = db.prepare(
+    "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1"
+  ).get(tableName);
+  return Boolean(row);
+}
+function getLastMigrationCreatedAtSqlite(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS __drizzle_migrations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      hash text NOT NULL,
+      created_at numeric
+    )
+  `);
+  const row = db.prepare(
+    "SELECT created_at FROM __drizzle_migrations ORDER BY created_at DESC LIMIT 1"
+  ).get();
+  return row?.created_at ?? null;
+}
+function insertBaselineSqlite(db, entries) {
+  const inserted = [];
+  const lastCreatedAt = getLastMigrationCreatedAtSqlite(db);
+  const insert = db.prepare(
+    'INSERT INTO __drizzle_migrations ("hash", "created_at") VALUES (?, ?)'
+  );
+  const exists = db.prepare(
+    "SELECT 1 FROM __drizzle_migrations WHERE created_at = ? LIMIT 1"
+  );
+  for (const entry of entries) {
+    if (lastCreatedAt !== null && lastCreatedAt >= entry.createdAt) {
+      continue;
+    }
+    if (exists.get(entry.createdAt)) {
+      continue;
+    }
+    insert.run(entry.hash, entry.createdAt);
+    inserted.push(entry.tag);
+  }
+  return inserted;
+}
+function baselineLegacySqliteMigrations(db, migrationsFolder) {
+  if (!tableExistsSqlite(db, "tasks")) {
+    return;
+  }
+  const hasWorkplanSchedules = tableExistsSqlite(db, "workplan_schedules");
+  const upToIdx = hasWorkplanSchedules ? 1 : 0;
+  const inserted = insertBaselineSqlite(db, baselineEntries(migrationsFolder, upToIdx));
+  if (inserted.length > 0) {
+    process.stdout.write(
+      `Baselined existing SQLite schema for migration(s): ${inserted.join(", ")}
+`
+    );
+  }
+}
+
 // ../db/src/migration.ts
 var distDir = dirname2(fileURLToPath(import.meta.url));
 async function migratePostgres(databaseUrl) {
@@ -296,8 +526,10 @@ async function migratePostgres(databaseUrl) {
     await adminPool.end();
   }
   const pool = getPool(databaseUrl);
+  const migrationsFolder = resolve2(distDir, "migrations/pg");
+  await baselineLegacyPostgresMigrations(pool, migrationsFolder);
   const { migrate } = await import("drizzle-orm/node-postgres/migrator");
-  await migrate(getDrizzle(pool), { migrationsFolder: resolve(distDir, "migrations/pg") });
+  await migrate(getDrizzle(pool), { migrationsFolder });
   await pool.end();
   process.stdout.write("Postgres migrations applied.\n");
 }
@@ -312,8 +544,10 @@ async function migrateSqlite(databaseUrl) {
   const sqlite = new Database2(filePath);
   sqlite.pragma("journal_mode = WAL");
   sqlite.pragma("synchronous = NORMAL");
+  const migrationsFolder = resolve2(distDir, "migrations/sqlite");
+  baselineLegacySqliteMigrations(sqlite, migrationsFolder);
   const db = drizzle(sqlite, { schema: sqliteSchema });
-  migrate(db, { migrationsFolder: resolve(distDir, "migrations/sqlite") });
+  migrate(db, { migrationsFolder });
   sqlite.close();
   process.stdout.write(`SQLite migrations applied: ${filePath}
 `);