@runfusion/fusion 0.43.1 → 0.44.0

package/dist/chunk-S2EVJUY3.js

@@ -0,0 +1,353 @@
+import {
+  assertProjectRootDir,
+  require_dist
+} from "./chunk-RXMQ5OMY.js";
+import {
+  Database,
+  fromJson
+} from "./chunk-BHM3UYWS.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../core/dist/automation-store.js
+var import_cron_parser = __toESM(require_dist(), 1);
+import { EventEmitter } from "events";
+import { join } from "path";
+import { randomUUID } from "crypto";
+
+// ../core/dist/automation.js
+var AUTOMATION_PRESETS = {
+  hourly: "0 * * * *",
+  daily: "0 0 * * *",
+  weekly: "0 0 * * 1",
+  monthly: "0 0 1 * *",
+  every15Minutes: "*/15 * * * *",
+  every30Minutes: "*/30 * * * *",
+  every2Hours: "0 */2 * * *",
+  every6Hours: "0 */6 * * *",
+  every12Hours: "0 */12 * * *",
+  weekdays: "0 9 * * 1-5"
+};
+var MAX_RUN_HISTORY = 50;
+
+// ../core/dist/automation-store.js
+var CRON_TIMEZONE = "UTC";
+var AutomationStore = class _AutomationStore extends EventEmitter {
+  rootDir;
+  /** Per-schedule promise chain for serializing writes. */
+  scheduleLocks = /* @__PURE__ */ new Map();
+  /** SQLite database instance */
+  _db = null;
+  inMemoryDb;
+  constructor(rootDir, options) {
+    super();
+    this.rootDir = rootDir;
+    assertProjectRootDir(rootDir, "AutomationStore");
+    this.inMemoryDb = options?.inMemoryDb === true;
+  }
+  /**
+   * Get the SQLite database, initializing it on first access.
+   */
+  get db() {
+    if (!this._db) {
+      const fusionDir = join(this.rootDir, ".fusion");
+      this._db = new Database(fusionDir, { inMemory: this.inMemoryDb });
+      this._db.init();
+    }
+    return this._db;
+  }
+  /** Initialize the store. */
+  async init() {
+    const _ = this.db;
+  }
+  // ── Row Conversion ─────────────────────────────────────────────────
+  rowToSchedule(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description || void 0,
+      scheduleType: row.scheduleType,
+      cronExpression: row.cronExpression,
+      command: row.command,
+      enabled: row.enabled === 1,
+      timeoutMs: row.timeoutMs ?? void 0,
+      steps: fromJson(row.steps),
+      nextRunAt: row.nextRunAt || void 0,
+      lastRunAt: row.lastRunAt || void 0,
+      lastRunResult: fromJson(row.lastRunResult),
+      runCount: row.runCount || 0,
+      runHistory: fromJson(row.runHistory) || [],
+      scope: row.scope || "project",
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  upsertSchedule(schedule) {
+    this.db.prepare(`
+      INSERT OR REPLACE INTO automations (
+        id, name, description, scheduleType, cronExpression, command,
+        enabled, timeoutMs, steps, nextRunAt, lastRunAt, lastRunResult,
+        runCount, runHistory, scope, createdAt, updatedAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(schedule.id, schedule.name, schedule.description ?? null, schedule.scheduleType, schedule.cronExpression, schedule.command, schedule.enabled ? 1 : 0, schedule.timeoutMs ?? null, schedule.steps ? JSON.stringify(schedule.steps) : null, schedule.nextRunAt ?? null, schedule.lastRunAt ?? null, schedule.lastRunResult ? JSON.stringify(schedule.lastRunResult) : null, schedule.runCount || 0, JSON.stringify(schedule.runHistory || []), schedule.scope ?? "project", schedule.createdAt, schedule.updatedAt);
+  }
+  // ── Locking ────────────────────────────────────────────────────────
+  /**
+   * Serialize all mutations to a given schedule by chaining promises.
+   * Concurrent callers for the same ID will queue behind each other.
+   */
+  withScheduleLock(id, fn) {
+    const prev = this.scheduleLocks.get(id) ?? Promise.resolve();
+    let resolve;
+    const next = new Promise((r) => {
+      resolve = r;
+    });
+    this.scheduleLocks.set(id, next);
+    return prev.then(async () => {
+      try {
+        return await fn();
+      } finally {
+        if (this.scheduleLocks.get(id) === next) {
+          this.scheduleLocks.delete(id);
+        }
+        resolve();
+      }
+    });
+  }
+  // ── Persistence ────────────────────────────────────────────────────
+  async readScheduleJson(id) {
+    const row = this.db.prepare("SELECT * FROM automations WHERE id = ?").get(id);
+    if (!row) {
+      throw Object.assign(new Error(`Schedule '${id}' not found`), { code: "ENOENT" });
+    }
+    return this.rowToSchedule(row);
+  }
+  async persistSchedule(schedule) {
+    this.upsertSchedule(schedule);
+    this.db.bumpLastModified();
+  }
+  // ── Cron Computation ───────────────────────────────────────────────
+  /**
+   * Compute the next run time from a cron expression.
+   * @param cronExpression - A valid cron expression (5 fields).
+   * @param fromDate - The date to compute from. Defaults to now.
+   * @returns ISO-8601 timestamp of the next run.
+   */
+  computeNextRun(cronExpression, fromDate) {
+    const interval = import_cron_parser.CronExpressionParser.parse(cronExpression, {
+      currentDate: fromDate ?? /* @__PURE__ */ new Date(),
+      tz: CRON_TIMEZONE
+    });
+    const next = interval.next();
+    return next.toISOString() ?? new Date(next.getTime()).toISOString();
+  }
+  /**
+   * Validate a cron expression. Returns true if valid.
+   */
+  static isValidCron(cronExpression) {
+    try {
+      import_cron_parser.CronExpressionParser.parse(cronExpression);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ── CRUD ───────────────────────────────────────────────────────────
+  async createSchedule(input) {
+    if (!input.name?.trim()) {
+      throw new Error("Name is required and cannot be empty");
+    }
+    const hasSteps = input.steps && input.steps.length > 0;
+    if (!hasSteps && !input.command?.trim()) {
+      throw new Error("Command is required and cannot be empty");
+    }
+    let cronExpression;
+    if (input.scheduleType === "custom") {
+      if (!input.cronExpression?.trim()) {
+        throw new Error("Cron expression is required for custom schedule type");
+      }
+      if (!_AutomationStore.isValidCron(input.cronExpression)) {
+        throw new Error(`Invalid cron expression: "${input.cronExpression}"`);
+      }
+      cronExpression = input.cronExpression.trim();
+    } else {
+      cronExpression = AUTOMATION_PRESETS[input.scheduleType];
+    }
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const enabled = input.enabled !== void 0 ? input.enabled : true;
+    const schedule = {
+      id,
+      name: input.name.trim(),
+      description: input.description?.trim() || void 0,
+      scheduleType: input.scheduleType,
+      cronExpression,
+      command: (input.command ?? "").trim(),
+      enabled,
+      runCount: 0,
+      runHistory: [],
+      timeoutMs: input.timeoutMs,
+      steps: hasSteps ? input.steps : void 0,
+      nextRunAt: enabled ? this.computeNextRun(cronExpression) : void 0,
+      scope: input.scope ?? "project",
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.persistSchedule(schedule);
+    this.emit("schedule:created", schedule);
+    return schedule;
+  }
+  async getSchedule(id) {
+    return this.readScheduleJson(id);
+  }
+  async listSchedules() {
+    const rows = this.db.prepare("SELECT * FROM automations ORDER BY createdAt ASC").all();
+    return rows.map((row) => this.rowToSchedule(row));
+  }
+  async updateSchedule(id, updates) {
+    return this.withScheduleLock(id, async () => {
+      const schedule = await this.getSchedule(id);
+      const previousEnabled = schedule.enabled;
+      const previousScheduleType = schedule.scheduleType;
+      const previousCronExpression = schedule.cronExpression;
+      if (updates.name !== void 0) {
+        if (!updates.name.trim())
+          throw new Error("Name cannot be empty");
+        schedule.name = updates.name.trim();
+      }
+      if (updates.description !== void 0) {
+        schedule.description = updates.description?.trim() || void 0;
+      }
+      if (updates.command !== void 0) {
+        schedule.command = updates.command.trim();
+      }
+      if (updates.steps !== void 0) {
+        schedule.steps = updates.steps.length > 0 ? updates.steps : void 0;
+      }
+      const willHaveSteps = schedule.steps && schedule.steps.length > 0;
+      if (!willHaveSteps && !schedule.command) {
+        throw new Error("Command is required and cannot be empty");
+      }
+      if (updates.timeoutMs !== void 0) {
+        schedule.timeoutMs = updates.timeoutMs;
+      }
+      if (updates.scheduleType !== void 0 || updates.cronExpression !== void 0) {
+        const newType = updates.scheduleType ?? schedule.scheduleType;
+        let newCron;
+        if (newType === "custom") {
+          const customCron = updates.cronExpression ?? schedule.cronExpression;
+          if (!customCron?.trim()) {
+            throw new Error("Cron expression is required for custom schedule type");
+          }
+          if (!_AutomationStore.isValidCron(customCron)) {
+            throw new Error(`Invalid cron expression: "${customCron}"`);
+          }
+          newCron = customCron.trim();
+        } else {
+          newCron = AUTOMATION_PRESETS[newType];
+        }
+        schedule.scheduleType = newType;
+        schedule.cronExpression = newCron;
+      }
+      if (updates.enabled !== void 0) {
+        schedule.enabled = updates.enabled;
+      }
+      const cadenceChanged = schedule.scheduleType !== previousScheduleType || schedule.cronExpression !== previousCronExpression;
+      const enabledFromDisabled = !previousEnabled && schedule.enabled;
+      const missingNextRunAt = !schedule.nextRunAt;
+      if (!schedule.enabled) {
+        schedule.nextRunAt = void 0;
+      } else if (cadenceChanged || enabledFromDisabled || missingNextRunAt) {
+        schedule.nextRunAt = this.computeNextRun(schedule.cronExpression);
+      }
+      schedule.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.persistSchedule(schedule);
+      this.emit("schedule:updated", schedule);
+      return schedule;
+    });
+  }
+  /**
+   * Reorder the steps of a schedule by providing the step IDs in the desired order.
+   * The `stepIds` array must contain exactly the same IDs as the current steps.
+   */
+  async reorderSteps(scheduleId, stepIds) {
+    return this.withScheduleLock(scheduleId, async () => {
+      const schedule = await this.getSchedule(scheduleId);
+      if (!schedule.steps || schedule.steps.length === 0) {
+        throw new Error("Schedule has no steps to reorder");
+      }
+      if (stepIds.length !== schedule.steps.length) {
+        throw new Error(`Step ID count mismatch: expected ${schedule.steps.length}, got ${stepIds.length}`);
+      }
+      const stepMap = new Map(schedule.steps.map((s) => [s.id, s]));
+      const reordered = [];
+      for (const id of stepIds) {
+        const step = stepMap.get(id);
+        if (!step) {
+          throw new Error(`Unknown step ID: "${id}"`);
+        }
+        reordered.push(step);
+      }
+      schedule.steps = reordered;
+      schedule.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.persistSchedule(schedule);
+      this.emit("schedule:updated", schedule);
+      return schedule;
+    });
+  }
+  async deleteSchedule(id) {
+    return this.withScheduleLock(id, async () => {
+      const schedule = await this.getSchedule(id);
+      this.db.prepare("DELETE FROM automations WHERE id = ?").run(id);
+      this.db.bumpLastModified();
+      this.emit("schedule:deleted", schedule);
+      return schedule;
+    });
+  }
+  /**
+   * Record a run result for a schedule. Updates lastRunAt, lastRunResult,
+   * nextRunAt, runCount, and appends to runHistory.
+   */
+  async recordRun(id, result) {
+    return this.withScheduleLock(id, async () => {
+      const schedule = await this.getSchedule(id);
+      schedule.lastRunAt = result.startedAt;
+      schedule.lastRunResult = result;
+      schedule.runCount += 1;
+      schedule.runHistory.unshift(result);
+      if (schedule.runHistory.length > MAX_RUN_HISTORY) {
+        schedule.runHistory = schedule.runHistory.slice(0, MAX_RUN_HISTORY);
+      }
+      if (schedule.enabled) {
+        schedule.nextRunAt = this.computeNextRun(schedule.cronExpression);
+      }
+      schedule.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.persistSchedule(schedule);
+      this.emit("schedule:run", { schedule, result });
+      return schedule;
+    });
+  }
+  /**
+   * Get all schedules that are due to run (nextRunAt <= now and enabled).
+   * Filters by scope: "global" or "project".
+   */
+  async getDueSchedules(scope) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = this.db.prepare("SELECT * FROM automations WHERE enabled = 1 AND nextRunAt IS NOT NULL AND nextRunAt <= ? AND scope = ?").all(now, scope);
+    return rows.map((row) => this.rowToSchedule(row));
+  }
+  /**
+   * Get all schedules that are due to run (nextRunAt <= now and enabled) for both scopes.
+   * Returns schedules from both "global" and "project" scopes.
+   */
+  async getDueSchedulesAllScopes() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = this.db.prepare("SELECT * FROM automations WHERE enabled = 1 AND nextRunAt IS NOT NULL AND nextRunAt <= ?").all(now);
+    return rows.map((row) => this.rowToSchedule(row));
+  }
+};
+
+export {
+  AutomationStore
+};