@dexto/tools-scheduler 1.6.0

package/dist/storage.cjs

@@ -0,0 +1,249 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var storage_exports = {};
+__export(storage_exports, {
+  ScheduleStorage: () => ScheduleStorage
+});
+module.exports = __toCommonJS(storage_exports);
+var import_errors = require("./errors.js");
+const SCHEDULE_PREFIX = "schedule:";
+const EXECUTION_LOG_PREFIX = "execution:";
+const SCHEDULE_LIST_KEY = "scheduler:schedules";
+class ScheduleStorage {
+  constructor(storageManager, maxExecutionHistory, logger) {
+    this.storageManager = storageManager;
+    this.maxExecutionHistory = maxExecutionHistory;
+    this.logger = logger;
+  }
+  listLock = Promise.resolve();
+  /**
+   * Save a schedule to persistent storage
+   */
+  async saveSchedule(schedule) {
+    const key = `${SCHEDULE_PREFIX}${schedule.id}`;
+    let persisted = false;
+    try {
+      await this.storageManager.getDatabase().set(key, schedule);
+      persisted = true;
+      await this.addScheduleToList(schedule.id);
+      this.logger.debug(`Schedule ${schedule.id} saved to storage`, { name: schedule.name });
+    } catch (error) {
+      if (persisted) {
+        try {
+          await this.storageManager.getDatabase().delete(key);
+        } catch (cleanupError) {
+          this.logger.error(
+            `Failed to rollback schedule ${schedule.id} after list update failure: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
+          );
+        }
+      }
+      throw import_errors.SchedulerError.storageWriteFailed(
+        "save schedule",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Load a schedule from storage
+   */
+  async loadSchedule(scheduleId) {
+    try {
+      const key = `${SCHEDULE_PREFIX}${scheduleId}`;
+      const schedule = await this.storageManager.getDatabase().get(key);
+      return schedule || null;
+    } catch (error) {
+      throw import_errors.SchedulerError.storageReadFailed(
+        "load schedule",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * List all schedules from storage
+   */
+  async listSchedules() {
+    try {
+      const scheduleIds = await this.storageManager.getDatabase().get(SCHEDULE_LIST_KEY) || [];
+      const schedules = [];
+      for (const scheduleId of scheduleIds) {
+        const schedule = await this.loadSchedule(scheduleId);
+        if (schedule) {
+          schedules.push(schedule);
+        }
+      }
+      return schedules;
+    } catch (error) {
+      throw import_errors.SchedulerError.storageReadFailed(
+        "list schedules",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Delete a schedule from storage
+   */
+  async deleteSchedule(scheduleId) {
+    let removedFromList = false;
+    let deletedSchedule = false;
+    try {
+      const key = `${SCHEDULE_PREFIX}${scheduleId}`;
+      await this.removeScheduleFromList(scheduleId);
+      removedFromList = true;
+      await this.storageManager.getDatabase().delete(key);
+      deletedSchedule = true;
+      await this.deleteExecutionLogs(scheduleId);
+      this.logger.debug(`Schedule ${scheduleId} deleted from storage`);
+    } catch (error) {
+      if (removedFromList && !deletedSchedule) {
+        try {
+          await this.addScheduleToList(scheduleId);
+        } catch (restoreError) {
+          this.logger.error(
+            `Failed to restore schedule ${scheduleId} to list after delete failure: ${restoreError instanceof Error ? restoreError.message : String(restoreError)}`
+          );
+        }
+      }
+      throw import_errors.SchedulerError.storageWriteFailed(
+        "delete schedule",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Save an execution log
+   */
+  async saveExecutionLog(log) {
+    try {
+      const key = `${EXECUTION_LOG_PREFIX}${log.scheduleId}:${log.id}`;
+      await this.storageManager.getDatabase().set(key, log);
+      await this.pruneExecutionHistory(log.scheduleId);
+      this.logger.debug(`Execution log ${log.id} saved for schedule ${log.scheduleId}`, {
+        status: log.status
+      });
+    } catch (error) {
+      throw import_errors.SchedulerError.storageWriteFailed(
+        "save execution log",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Get execution logs for a schedule
+   */
+  async getExecutionLogs(scheduleId, limit) {
+    try {
+      const prefix = `${EXECUTION_LOG_PREFIX}${scheduleId}:`;
+      const keys = await this.storageManager.getDatabase().list(prefix);
+      const logs = [];
+      for (const key of keys) {
+        const log = await this.storageManager.getDatabase().get(key);
+        if (log) {
+          logs.push(log);
+        }
+      }
+      logs.sort((a, b) => b.triggeredAt - a.triggeredAt);
+      return limit ? logs.slice(0, limit) : logs;
+    } catch (error) {
+      throw import_errors.SchedulerError.storageReadFailed(
+        "get execution logs",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Delete all execution logs for a schedule
+   */
+  async deleteExecutionLogs(scheduleId) {
+    try {
+      const prefix = `${EXECUTION_LOG_PREFIX}${scheduleId}:`;
+      const keys = await this.storageManager.getDatabase().list(prefix);
+      for (const key of keys) {
+        await this.storageManager.getDatabase().delete(key);
+      }
+      this.logger.debug(`Execution logs deleted for schedule ${scheduleId}`);
+    } catch (error) {
+      this.logger.error(
+        `Failed to delete execution logs for schedule ${scheduleId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Prune execution history to maintain limit
+   */
+  async pruneExecutionHistory(scheduleId) {
+    try {
+      const logs = await this.getExecutionLogs(scheduleId);
+      if (logs.length > this.maxExecutionHistory) {
+        const logsToDelete = logs.slice(this.maxExecutionHistory);
+        for (const log of logsToDelete) {
+          const key = `${EXECUTION_LOG_PREFIX}${scheduleId}:${log.id}`;
+          await this.storageManager.getDatabase().delete(key);
+        }
+        this.logger.debug(
+          `Pruned ${logsToDelete.length} old execution logs for schedule ${scheduleId}`
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to prune execution history for schedule ${scheduleId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Add schedule ID to master list
+   */
+  async addScheduleToList(scheduleId) {
+    await this.withListLock(async () => {
+      const scheduleIds = await this.storageManager.getDatabase().get(SCHEDULE_LIST_KEY) || [];
+      if (!scheduleIds.includes(scheduleId)) {
+        scheduleIds.push(scheduleId);
+        await this.storageManager.getDatabase().set(SCHEDULE_LIST_KEY, scheduleIds);
+      }
+    });
+  }
+  /**
+   * Remove schedule ID from master list
+   */
+  async removeScheduleFromList(scheduleId) {
+    await this.withListLock(async () => {
+      const scheduleIds = await this.storageManager.getDatabase().get(SCHEDULE_LIST_KEY) || [];
+      const filtered = scheduleIds.filter((id) => id !== scheduleId);
+      await this.storageManager.getDatabase().set(SCHEDULE_LIST_KEY, filtered);
+    });
+  }
+  async withListLock(handler) {
+    const previous = this.listLock;
+    let release;
+    this.listLock = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await handler();
+    } finally {
+      if (release) {
+        release();
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScheduleStorage
+});

package/dist/storage.d.cts

@@ -0,0 +1,62 @@
+import { StorageManager, Logger } from '@dexto/core';
+import { Schedule, ExecutionLog } from './types.cjs';
+import './schemas.cjs';
+import 'zod';
+
+/**
+ * Storage layer for schedules and execution logs
+ */
+
+/**
+ * Storage layer for scheduler persistence
+ */
+declare class ScheduleStorage {
+    private storageManager;
+    private maxExecutionHistory;
+    private logger;
+    private listLock;
+    constructor(storageManager: StorageManager, maxExecutionHistory: number, logger: Logger);
+    /**
+     * Save a schedule to persistent storage
+     */
+    saveSchedule(schedule: Schedule): Promise<void>;
+    /**
+     * Load a schedule from storage
+     */
+    loadSchedule(scheduleId: string): Promise<Schedule | null>;
+    /**
+     * List all schedules from storage
+     */
+    listSchedules(): Promise<Schedule[]>;
+    /**
+     * Delete a schedule from storage
+     */
+    deleteSchedule(scheduleId: string): Promise<void>;
+    /**
+     * Save an execution log
+     */
+    saveExecutionLog(log: ExecutionLog): Promise<void>;
+    /**
+     * Get execution logs for a schedule
+     */
+    getExecutionLogs(scheduleId: string, limit?: number): Promise<ExecutionLog[]>;
+    /**
+     * Delete all execution logs for a schedule
+     */
+    private deleteExecutionLogs;
+    /**
+     * Prune execution history to maintain limit
+     */
+    private pruneExecutionHistory;
+    /**
+     * Add schedule ID to master list
+     */
+    private addScheduleToList;
+    /**
+     * Remove schedule ID from master list
+     */
+    private removeScheduleFromList;
+    private withListLock;
+}
+
+export { ScheduleStorage };

package/dist/storage.d.ts

@@ -0,0 +1,62 @@
+import { StorageManager, Logger } from '@dexto/core';
+import { Schedule, ExecutionLog } from './types.js';
+import './schemas.js';
+import 'zod';
+
+/**
+ * Storage layer for schedules and execution logs
+ */
+
+/**
+ * Storage layer for scheduler persistence
+ */
+declare class ScheduleStorage {
+    private storageManager;
+    private maxExecutionHistory;
+    private logger;
+    private listLock;
+    constructor(storageManager: StorageManager, maxExecutionHistory: number, logger: Logger);
+    /**
+     * Save a schedule to persistent storage
+     */
+    saveSchedule(schedule: Schedule): Promise<void>;
+    /**
+     * Load a schedule from storage
+     */
+    loadSchedule(scheduleId: string): Promise<Schedule | null>;
+    /**
+     * List all schedules from storage
+     */
+    listSchedules(): Promise<Schedule[]>;
+    /**
+     * Delete a schedule from storage
+     */
+    deleteSchedule(scheduleId: string): Promise<void>;
+    /**
+     * Save an execution log
+     */
+    saveExecutionLog(log: ExecutionLog): Promise<void>;
+    /**
+     * Get execution logs for a schedule
+     */
+    getExecutionLogs(scheduleId: string, limit?: number): Promise<ExecutionLog[]>;
+    /**
+     * Delete all execution logs for a schedule
+     */
+    private deleteExecutionLogs;
+    /**
+     * Prune execution history to maintain limit
+     */
+    private pruneExecutionHistory;
+    /**
+     * Add schedule ID to master list
+     */
+    private addScheduleToList;
+    /**
+     * Remove schedule ID from master list
+     */
+    private removeScheduleFromList;
+    private withListLock;
+}
+
+export { ScheduleStorage };

package/dist/storage.js

@@ -0,0 +1,225 @@
+import { SchedulerError } from "./errors.js";
+const SCHEDULE_PREFIX = "schedule:";
+const EXECUTION_LOG_PREFIX = "execution:";
+const SCHEDULE_LIST_KEY = "scheduler:schedules";
+class ScheduleStorage {
+  constructor(storageManager, maxExecutionHistory, logger) {
+    this.storageManager = storageManager;
+    this.maxExecutionHistory = maxExecutionHistory;
+    this.logger = logger;
+  }
+  listLock = Promise.resolve();
+  /**
+   * Save a schedule to persistent storage
+   */
+  async saveSchedule(schedule) {
+    const key = `${SCHEDULE_PREFIX}${schedule.id}`;
+    let persisted = false;
+    try {
+      await this.storageManager.getDatabase().set(key, schedule);
+      persisted = true;
+      await this.addScheduleToList(schedule.id);
+      this.logger.debug(`Schedule ${schedule.id} saved to storage`, { name: schedule.name });
+    } catch (error) {
+      if (persisted) {
+        try {
+          await this.storageManager.getDatabase().delete(key);
+        } catch (cleanupError) {
+          this.logger.error(
+            `Failed to rollback schedule ${schedule.id} after list update failure: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
+          );
+        }
+      }
+      throw SchedulerError.storageWriteFailed(
+        "save schedule",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Load a schedule from storage
+   */
+  async loadSchedule(scheduleId) {
+    try {
+      const key = `${SCHEDULE_PREFIX}${scheduleId}`;
+      const schedule = await this.storageManager.getDatabase().get(key);
+      return schedule || null;
+    } catch (error) {
+      throw SchedulerError.storageReadFailed(
+        "load schedule",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * List all schedules from storage
+   */
+  async listSchedules() {
+    try {
+      const scheduleIds = await this.storageManager.getDatabase().get(SCHEDULE_LIST_KEY) || [];
+      const schedules = [];
+      for (const scheduleId of scheduleIds) {
+        const schedule = await this.loadSchedule(scheduleId);
+        if (schedule) {
+          schedules.push(schedule);
+        }
+      }
+      return schedules;
+    } catch (error) {
+      throw SchedulerError.storageReadFailed(
+        "list schedules",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Delete a schedule from storage
+   */
+  async deleteSchedule(scheduleId) {
+    let removedFromList = false;
+    let deletedSchedule = false;
+    try {
+      const key = `${SCHEDULE_PREFIX}${scheduleId}`;
+      await this.removeScheduleFromList(scheduleId);
+      removedFromList = true;
+      await this.storageManager.getDatabase().delete(key);
+      deletedSchedule = true;
+      await this.deleteExecutionLogs(scheduleId);
+      this.logger.debug(`Schedule ${scheduleId} deleted from storage`);
+    } catch (error) {
+      if (removedFromList && !deletedSchedule) {
+        try {
+          await this.addScheduleToList(scheduleId);
+        } catch (restoreError) {
+          this.logger.error(
+            `Failed to restore schedule ${scheduleId} to list after delete failure: ${restoreError instanceof Error ? restoreError.message : String(restoreError)}`
+          );
+        }
+      }
+      throw SchedulerError.storageWriteFailed(
+        "delete schedule",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Save an execution log
+   */
+  async saveExecutionLog(log) {
+    try {
+      const key = `${EXECUTION_LOG_PREFIX}${log.scheduleId}:${log.id}`;
+      await this.storageManager.getDatabase().set(key, log);
+      await this.pruneExecutionHistory(log.scheduleId);
+      this.logger.debug(`Execution log ${log.id} saved for schedule ${log.scheduleId}`, {
+        status: log.status
+      });
+    } catch (error) {
+      throw SchedulerError.storageWriteFailed(
+        "save execution log",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Get execution logs for a schedule
+   */
+  async getExecutionLogs(scheduleId, limit) {
+    try {
+      const prefix = `${EXECUTION_LOG_PREFIX}${scheduleId}:`;
+      const keys = await this.storageManager.getDatabase().list(prefix);
+      const logs = [];
+      for (const key of keys) {
+        const log = await this.storageManager.getDatabase().get(key);
+        if (log) {
+          logs.push(log);
+        }
+      }
+      logs.sort((a, b) => b.triggeredAt - a.triggeredAt);
+      return limit ? logs.slice(0, limit) : logs;
+    } catch (error) {
+      throw SchedulerError.storageReadFailed(
+        "get execution logs",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Delete all execution logs for a schedule
+   */
+  async deleteExecutionLogs(scheduleId) {
+    try {
+      const prefix = `${EXECUTION_LOG_PREFIX}${scheduleId}:`;
+      const keys = await this.storageManager.getDatabase().list(prefix);
+      for (const key of keys) {
+        await this.storageManager.getDatabase().delete(key);
+      }
+      this.logger.debug(`Execution logs deleted for schedule ${scheduleId}`);
+    } catch (error) {
+      this.logger.error(
+        `Failed to delete execution logs for schedule ${scheduleId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Prune execution history to maintain limit
+   */
+  async pruneExecutionHistory(scheduleId) {
+    try {
+      const logs = await this.getExecutionLogs(scheduleId);
+      if (logs.length > this.maxExecutionHistory) {
+        const logsToDelete = logs.slice(this.maxExecutionHistory);
+        for (const log of logsToDelete) {
+          const key = `${EXECUTION_LOG_PREFIX}${scheduleId}:${log.id}`;
+          await this.storageManager.getDatabase().delete(key);
+        }
+        this.logger.debug(
+          `Pruned ${logsToDelete.length} old execution logs for schedule ${scheduleId}`
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to prune execution history for schedule ${scheduleId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Add schedule ID to master list
+   */
+  async addScheduleToList(scheduleId) {
+    await this.withListLock(async () => {
+      const scheduleIds = await this.storageManager.getDatabase().get(SCHEDULE_LIST_KEY) || [];
+      if (!scheduleIds.includes(scheduleId)) {
+        scheduleIds.push(scheduleId);
+        await this.storageManager.getDatabase().set(SCHEDULE_LIST_KEY, scheduleIds);
+      }
+    });
+  }
+  /**
+   * Remove schedule ID from master list
+   */
+  async removeScheduleFromList(scheduleId) {
+    await this.withListLock(async () => {
+      const scheduleIds = await this.storageManager.getDatabase().get(SCHEDULE_LIST_KEY) || [];
+      const filtered = scheduleIds.filter((id) => id !== scheduleId);
+      await this.storageManager.getDatabase().set(SCHEDULE_LIST_KEY, filtered);
+    });
+  }
+  async withListLock(handler) {
+    const previous = this.listLock;
+    let release;
+    this.listLock = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await handler();
+    } finally {
+      if (release) {
+        release();
+      }
+    }
+  }
+}
+export {
+  ScheduleStorage
+};