feat: add file and Redis persistence providers for cron job state management

Author: chaqchase

lib/baker.ts

@@ -1,17 +1,17 @@
 import Cron from './cron';
-import { 
-  CronOptions, 
-  IBaker, 
-  IBakerOptions, 
-  ICron, 
-  Status, 
-  ExecutionHistory, 
+import {
+  CronOptions,
+  IBaker,
+  IBakerOptions,
+  ICron,
+  Status,
+  ExecutionHistory,
   JobMetrics,
   SchedulerConfig,
-  PersistenceOptions 
+  PersistenceOptions,
 } from './types';
-import * as fs from 'fs';
-import * as path from 'path';
+import { FilePersistenceProvider } from './persistence/file';
+import type { PersistenceProvider } from './persistence/types';
 
 /**
  * A class that implements the `IBaker` interface and provides methods to manage cron jobs.
@@ -20,6 +20,7 @@ class Baker implements IBaker {
   private crons: Map<string, ICron> = new Map();
   private config: SchedulerConfig;
   private persistence: PersistenceOptions;
+  private persistenceProvider?: PersistenceProvider;
   private enableMetrics: boolean;
   private onError?: (error: Error, jobName: string) => void;
 
@@ -34,7 +35,20 @@ class Baker implements IBaker {
       enabled: options.persistence?.enabled ?? false,
       filePath: options.persistence?.filePath ?? './cronbake-state.json',
       autoRestore: options.persistence?.autoRestore ?? true,
+      strategy: options.persistence?.strategy ?? 'file',
+      provider: options.persistence?.provider,
+      redis: options.persistence?.redis,
     };
+
+    if (this.persistence.enabled) {
+      if (this.persistence.provider) {
+        this.persistenceProvider = this.persistence.provider;
+      } else if (this.persistence.strategy === 'file') {
+        this.persistenceProvider = new FilePersistenceProvider(this.persistence.filePath!);
+      } else if (this.persistence.strategy === 'redis') {
+        throw new Error('Redis persistence selected but no provider supplied. Pass persistence.provider or use FilePersistenceProvider.');
+      }
+    }
 
     this.enableMetrics = options.enableMetrics ?? true;
     this.onError = options.onError;
@@ -225,58 +239,40 @@ class Baker implements IBaker {
   }
 
   async saveState(): Promise<void> {
-    if (!this.persistence.enabled) return;
-
+    if (!this.persistence.enabled || !this.persistenceProvider) return;
     try {
       const state = {
+        version: 1,
         timestamp: new Date().toISOString(),
         jobs: Array.from(this.crons.entries()).map(([name, cron]) => ({
           name,
-          cron: cron.cron,
+          cron: String(cron.cron),
           status: cron.getStatus(),
           priority: cron.priority,
           metrics: this.enableMetrics ? cron.getMetrics() : undefined,
           history: this.enableMetrics ? cron.getHistory() : undefined,
         })),
         config: this.config,
-      };
-
-      const filePath = path.resolve(this.persistence.filePath!);
-      const dir = path.dirname(filePath);
-      
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-
-      await fs.promises.writeFile(filePath, JSON.stringify(state, null, 2), 'utf8');
+      } as const;
+      await this.persistenceProvider.save(state);
     } catch (error) {
       throw new Error(`Failed to save state: ${error}`);
     }
   }
 
   async restoreState(): Promise<void> {
-    if (!this.persistence.enabled) return;
-
+    if (!this.persistence.enabled || !this.persistenceProvider) return;
     try {
-      const filePath = path.resolve(this.persistence.filePath!);
-      
-      if (!fs.existsSync(filePath)) {
-        return;
-      }
-
-      const data = await fs.promises.readFile(filePath, 'utf8');
-      const state = JSON.parse(data);
-
+      const state = await this.persistenceProvider.load();
+      if (!state) return;
       if (!state.jobs || !Array.isArray(state.jobs)) {
-        throw new Error('Invalid state file format');
+        throw new Error('Invalid state format');
       }
-
       for (const jobData of state.jobs) {
         if (!jobData.name || !jobData.cron) {
           console.warn('Skipping invalid job data:', jobData);
           continue;
         }
-
         try {
           const options: CronOptions = {
             name: jobData.name,
@@ -287,13 +283,11 @@ class Baker implements IBaker {
             priority: jobData.priority,
             start: jobData.status === 'running',
           };
-
           this.add(options);
         } catch (error) {
           console.warn(`Failed to restore job '${jobData.name}':`, error);
         }
       }
-
       console.log(`Restored ${state.jobs.length} cron jobs from persistence`);
     } catch (error) {
       throw new Error(`Failed to restore state: ${error}`);

lib/index.test.ts

@@ -364,6 +364,7 @@ describe("Baker", () => {
     persistenceBaker.destroyAll();
   });
 
+
   it("should prevent overrun when enabled (interval mode)", async () => {
     const configuredBaker = new Baker({
       schedulerConfig: {

lib/index.ts

@@ -1,6 +1,8 @@
 import Cron from "./cron";
 import Baker from "./baker";
 import CronParser from "./parser";
+import { FilePersistenceProvider } from "./persistence/file";
+import { RedisPersistenceProvider } from "./persistence/redis";
 
 export {
   type CronOptions,
@@ -21,5 +23,5 @@ export {
   type unit,
 } from "./types";
 
-export { Cron, Baker, CronParser };
+export { Cron, Baker, CronParser, FilePersistenceProvider, RedisPersistenceProvider };
 export default Baker;

lib/persistence.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'bun:test';
+import Baker from '@/lib/baker';
+import { createFileProvider, createRedisProvider, cleanupFile, sleep } from '@/lib/test/utils';
+
+describe('Persistence Providers', () => {
+  it('File provider: saves and restores jobs', async () => {
+    const { provider, filePath } = createFileProvider();
+
+    const baker1 = new Baker({
+      persistence: { enabled: true, autoRestore: false, strategy: 'file', provider },
+    });
+
+    baker1.add({ name: 'file-job', cron: '* * * * * *', callback: () => {} });
+    await baker1.saveState();
+
+    const baker2 = new Baker({
+      persistence: { enabled: true, autoRestore: true, strategy: 'file', provider },
+    });
+    await sleep(10);
+    expect(baker2.getJobNames()).toContain('file-job');
+    baker2.destroyAll();
+    baker1.destroyAll();
+    cleanupFile(filePath);
+  });
+
+  it('Redis provider: saves and restores jobs with fake client', async () => {
+    const { provider } = createRedisProvider('test:cronbake');
+
+    const baker1 = new Baker({
+      persistence: { enabled: true, autoRestore: false, strategy: 'redis', provider },
+    });
+    baker1.add({ name: 'redis-job', cron: '* * * * * *', callback: () => {} });
+    await baker1.saveState();
+
+    const baker2 = new Baker({
+      persistence: { enabled: true, autoRestore: true, strategy: 'redis', provider },
+    });
+    await sleep(10);
+    expect(baker2.getJobNames()).toContain('redis-job');
+    baker2.destroyAll();
+    baker1.destroyAll();
+  });
+
+  it('Throws if redis strategy without provider', () => {
+    expect(() => new Baker({ persistence: { enabled: true, strategy: 'redis' } })).toThrow();
+  });
+});

lib/persistence/file.ts

@@ -0,0 +1,28 @@
+import * as fs from "fs";
+import * as path from "path";
+import { PersistedState, PersistenceProvider } from "./types";
+
+class FilePersistenceProvider implements PersistenceProvider {
+  constructor(private filePath: string) {}
+
+  async save(state: PersistedState): Promise<void> {
+    const filePath = path.resolve(this.filePath);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    await fs.promises.writeFile(filePath, JSON.stringify(state, null, 2), "utf8");
+  }
+
+  async load(): Promise<PersistedState | null> {
+    const filePath = path.resolve(this.filePath);
+    if (!fs.existsSync(filePath)) return null;
+    const data = await fs.promises.readFile(filePath, "utf8");
+    const state = JSON.parse(data);
+    if (!state || typeof state !== "object") return null;
+    return state as PersistedState;
+  }
+}
+
+export { FilePersistenceProvider };
+

lib/persistence/index.ts

@@ -0,0 +1,4 @@
+export { type PersistedState, type PersistedJob, type PersistenceProvider, type RedisLikeClient } from "./types";
+export { FilePersistenceProvider } from "./file";
+export { RedisPersistenceProvider, type RedisProviderOptions } from "./redis";
+

lib/persistence/redis.ts

@@ -0,0 +1,36 @@
+import { PersistedState, PersistenceProvider, RedisLikeClient } from "./types";
+
+type RedisProviderOptions = {
+  client: RedisLikeClient;
+  key?: string;
+};
+
+class RedisPersistenceProvider implements PersistenceProvider {
+  private key: string;
+  constructor(private options: RedisProviderOptions) {
+    if (!options?.client) {
+      throw new Error("RedisPersistenceProvider requires a redis-like client with get/set");
+    }
+    this.key = options.key ?? "cronbake:state";
+  }
+
+  async save(state: PersistedState): Promise<void> {
+    await this.options.client.set(this.key, JSON.stringify(state));
+  }
+
+  async load(): Promise<PersistedState | null> {
+    const raw = await this.options.client.get(this.key);
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw) as PersistedState;
+      if (!parsed || typeof parsed !== "object") return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+}
+
+export { RedisPersistenceProvider };
+export type { RedisProviderOptions };
+

lib/persistence/types.ts

@@ -0,0 +1,31 @@
+import { ExecutionHistory, JobMetrics, SchedulerConfig, Status } from "../types";
+
+type PersistedJob = {
+  name: string;
+  cron: string;
+  status: Status;
+  priority: number;
+  metrics?: JobMetrics;
+  history?: ExecutionHistory[];
+};
+
+type PersistedState = {
+  version: number;
+  timestamp: string;
+  config: SchedulerConfig;
+  jobs: PersistedJob[];
+};
+
+interface PersistenceProvider {
+  save(state: PersistedState): Promise<void>;
+  load(): Promise<PersistedState | null>;
+}
+
+/** Minimal redis-like client */
+interface RedisLikeClient {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<unknown>;
+}
+
+export type { PersistedState, PersistedJob, PersistenceProvider, RedisLikeClient };
+

lib/test/utils.ts

@@ -0,0 +1,42 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { FilePersistenceProvider } from '@/lib/persistence/file';
+import { RedisPersistenceProvider } from '@/lib/persistence/redis';
+import type { RedisLikeClient } from '@/lib/persistence/types';
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+const tmpFile = (prefix = 'cronbake-test-'): string => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  return path.join(dir, 'state.json');
+};
+
+const cleanupFile = (filePath: string) => {
+  try { fs.unlinkSync(filePath); } catch {}
+  try { fs.rmdirSync(path.dirname(filePath)); } catch {}
+};
+
+class FakeRedis implements RedisLikeClient {
+  private store = new Map<string, string>();
+  async get(key: string): Promise<string | null> {
+    return this.store.get(key) ?? null;
+  }
+  async set(key: string, value: string): Promise<void> {
+    this.store.set(key, value);
+  }
+}
+
+const createFileProvider = (filePath?: string) => {
+  const fp = filePath ?? tmpFile();
+  return { provider: new FilePersistenceProvider(fp), filePath: fp };
+};
+
+const createRedisProvider = (key = 'test:cronbake') => {
+  const client = new FakeRedis();
+  const provider = new RedisPersistenceProvider({ client, key });
+  return { provider, client };
+};
+
+export { sleep, tmpFile, cleanupFile, FakeRedis, createFileProvider, createRedisProvider };
+

lib/types.ts

@@ -300,10 +300,22 @@ type JobMetrics = {
 /**
  * Persistence options for cron jobs
  */
+import type { PersistenceProvider } from "./persistence/types";
+
+type PersistenceStrategy = 'file' | 'redis' | 'custom';
+
+type RedisPersistenceOptions = {
+  key?: string;
+  // user must provide a client via provider for now; kept for future extension
+};
+
 type PersistenceOptions = {
   enabled: boolean;
   filePath?: string;
   autoRestore?: boolean;
+  strategy?: PersistenceStrategy;
+  provider?: PersistenceProvider;
+  redis?: RedisPersistenceOptions;
 };
 
 /**
@@ -485,4 +497,5 @@ export {
   type JobMetrics,
   type PersistenceOptions,
   type SchedulerConfig,
+  type PersistenceStrategy,
 };