@azlib/scheduler 0.2.0 → 1.0.1

package/dist/index.cjs

@@ -176,11 +176,11 @@ function createCronExpression() {
 function createInMemoryJobExecutionStore() {
 	const byExecution = /* @__PURE__ */ new Map();
 	return {
-		create(record) {
+		async create(record) {
 			byExecution.set(record.executionId, record);
 			return record;
 		},
-		update(executionId, patch) {
+		async update(executionId, patch) {
 			const current = byExecution.get(executionId);
 			if (!current) return null;
 			const next = {
@@ -190,7 +190,7 @@ function createInMemoryJobExecutionStore() {
 			byExecution.set(executionId, next);
 			return next;
 		},
-		listByJob(jobId) {
+		async listByJob(jobId) {
 			return Array.from(byExecution.values()).filter((item) => item.jobId === jobId);
 		}
 	};
@@ -200,7 +200,7 @@ function createInMemoryJobExecutionStore() {
 function createInMemoryScheduleCursorStore() {
 	const cursors = /* @__PURE__ */ new Map();
 	return {
-		set(jobId, nextRunAt, now) {
+		async set(jobId, nextRunAt, now) {
 			const previous = cursors.get(jobId);
 			const next = {
 				jobId,
@@ -212,7 +212,7 @@ function createInMemoryScheduleCursorStore() {
 			cursors.set(jobId, next);
 			return next;
 		},
-		markTriggered(jobId, triggeredAt) {
+		async markTriggered(jobId, triggeredAt) {
 			const current = cursors.get(jobId);
 			if (!current) return null;
 			const next = {
@@ -223,10 +223,10 @@ function createInMemoryScheduleCursorStore() {
 			cursors.set(jobId, next);
 			return next;
 		},
-		get(jobId) {
+		async get(jobId) {
 			return cursors.get(jobId) ?? null;
 		},
-		remove(jobId) {
+		async remove(jobId) {
 			return cursors.delete(jobId);
 		}
 	};
@@ -285,17 +285,17 @@ function createSchedulerEngine(dependencies) {
 		if (cached?.status === "hit" && cached.value) return cached.value;
 		const nextRunAt = computeNextRunAt(parseSchedule(job.schedule.scheduleType, job.schedule.expression, job.schedule.timezone), now);
 		await dependencies.cache?.set(cacheKey, nextRunAt);
-		dependencies.cursorStore.set(job.jobId, nextRunAt, now.toISOString());
+		await dependencies.cursorStore.set(job.jobId, nextRunAt, now.toISOString());
 		return nextRunAt;
 	}
 	async function evaluateTick() {
 		const now = /* @__PURE__ */ new Date();
-		const candidates = dependencies.jobStore.list().filter((job) => job.enabled).slice(0, dependencies.maxDueJobsPerTick);
+		const candidates = (await dependencies.jobStore.list()).filter((job) => job.enabled).slice(0, dependencies.maxDueJobsPerTick);
 		for (const job of candidates) {
 			const nextRunAt = await computeNextRun(job, now);
 			if (new Date(nextRunAt).getTime() > now.getTime()) continue;
 			const executionId = `exec_${(0, node_crypto.randomUUID)()}`;
-			dependencies.executionStore.create({
+			await dependencies.executionStore.create({
 				executionId,
 				jobId: job.jobId,
 				scheduledFor: nextRunAt,
@@ -303,7 +303,7 @@ function createSchedulerEngine(dependencies) {
 				status: "queued",
 				attemptCount: 0
 			});
-			dependencies.cursorStore.markTriggered(job.jobId, now.toISOString());
+			await dependencies.cursorStore.markTriggered(job.jobId, now.toISOString());
 			if (dependencies.queueService) await dependencies.queueService.enqueue({
 				idempotencyKey: `scheduler:${job.jobId}:${nextRunAt}`,
 				payloadRef: {
@@ -378,7 +378,7 @@ function createSchedulerHandlerRegistry() {
 function createInMemorySchedulerJobStore() {
 	const jobs = /* @__PURE__ */ new Map();
 	return {
-		create(jobId, definition) {
+		async create(jobId, definition) {
 			const now = (/* @__PURE__ */ new Date()).toISOString();
 			const created = {
 				...definition,
@@ -390,7 +390,7 @@ function createInMemorySchedulerJobStore() {
 			jobs.set(jobId, created);
 			return created;
 		},
-		update(jobId, patch) {
+		async update(jobId, patch) {
 			const current = jobs.get(jobId);
 			if (!current) return null;
 			const updated = {
@@ -401,7 +401,7 @@ function createInMemorySchedulerJobStore() {
 			jobs.set(jobId, updated);
 			return updated;
 		},
-		setEnabled(jobId, enabled) {
+		async setEnabled(jobId, enabled) {
 			const current = jobs.get(jobId);
 			if (!current) return null;
 			const updated = {
@@ -412,13 +412,13 @@ function createInMemorySchedulerJobStore() {
 			jobs.set(jobId, updated);
 			return updated;
 		},
-		get(jobId) {
+		async get(jobId) {
 			return jobs.get(jobId) ?? null;
 		},
-		list() {
+		async list() {
 			return Array.from(jobs.values());
 		},
-		remove(jobId) {
+		async remove(jobId) {
 			return jobs.delete(jobId);
 		}
 	};
@@ -479,7 +479,7 @@ function filterExecutions(items, query) {
 }
 //#endregion
 //#region src/core/scheduler-service-retry.ts
-function retryFailedExecutionById(allExecutions, executionStore, executionId) {
+async function retryFailedExecutionById(allExecutions, executionStore, executionId) {
 	const target = allExecutions.find((item) => item.executionId === executionId);
 	if (!target) throw new Error(`Execution not found: ${executionId}`);
 	if (target.status !== "failed" && target.status !== "dead-letter") throw new Error("Only failed or dead-letter executions can be retried");
@@ -491,18 +491,354 @@ function retryFailedExecutionById(allExecutions, executionStore, executionId) {
 		attemptCount: target.attemptCount + 1,
 		triggeredAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	executionStore.create(retry);
+	await executionStore.create(retry);
 	return retry;
 }
 //#endregion
+//#region src/core/persistence.ts
+function namespaceFor(config) {
+	return config.namespace?.trim() || "azlib";
+}
+function tableNames(namespace) {
+	return {
+		jobs: `${namespace}__scheduler_jobs`,
+		cursors: `${namespace}__scheduler_cursors`,
+		executions: `${namespace}__scheduler_executions`
+	};
+}
+function quoted(dialect, tableName) {
+	return dialect.quoteIdentifier(tableName);
+}
+async function bootstrapSchedulerPersistence(client, dialect, names) {
+	await client.transaction(async (tx) => {
+		await tx.execute(`CREATE TABLE IF NOT EXISTS ${quoted(dialect, names.jobs)} (
+      job_id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      handler_key TEXT NOT NULL,
+      schedule_type TEXT NOT NULL,
+      expression TEXT NOT NULL,
+      timezone TEXT NOT NULL,
+      overlap_policy TEXT,
+      missed_run_policy TEXT,
+      config_json TEXT NOT NULL,
+      enabled INTEGER NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )`);
+		await tx.execute(`CREATE TABLE IF NOT EXISTS ${quoted(dialect, names.cursors)} (
+      job_id TEXT PRIMARY KEY,
+      last_evaluated_at TEXT NOT NULL,
+      last_triggered_at TEXT,
+      next_run_at TEXT NOT NULL,
+      version INTEGER NOT NULL
+    )`);
+		await tx.execute(`CREATE TABLE IF NOT EXISTS ${quoted(dialect, names.executions)} (
+      execution_id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      scheduled_for TEXT NOT NULL,
+      triggered_at TEXT NOT NULL,
+      status TEXT NOT NULL,
+      queue_task_id TEXT,
+      attempt_count INTEGER NOT NULL,
+      last_error TEXT
+    )`);
+	});
+}
+function toJobRow(jobId, definition) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		jobId,
+		name: definition.name,
+		handlerKey: definition.handlerKey,
+		scheduleType: definition.schedule.scheduleType,
+		expression: definition.schedule.expression,
+		timezone: definition.schedule.timezone,
+		overlapPolicy: definition.schedule.overlapPolicy ?? null,
+		missedRunPolicy: definition.schedule.missedRunPolicy ?? null,
+		configJson: JSON.stringify(definition.config),
+		enabled: definition.enabled ?? true ? 1 : 0,
+		createdAt: now,
+		updatedAt: now
+	};
+}
+function rowToJobRecord(row) {
+	return {
+		jobId: row.jobId,
+		name: row.name,
+		handlerKey: row.handlerKey,
+		schedule: {
+			scheduleType: row.scheduleType,
+			expression: row.expression,
+			timezone: row.timezone,
+			overlapPolicy: row.overlapPolicy === null ? void 0 : row.overlapPolicy,
+			missedRunPolicy: row.missedRunPolicy === null ? void 0 : row.missedRunPolicy
+		},
+		config: JSON.parse(row.configJson),
+		enabled: Boolean(row.enabled),
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt
+	};
+}
+async function readJobRow(client, dialect, names, jobId) {
+	const rows = await client.query(`SELECT job_id AS jobId, name, handler_key AS handlerKey, schedule_type AS scheduleType, expression, timezone, overlap_policy AS overlapPolicy, missed_run_policy AS missedRunPolicy, config_json AS configJson, enabled, created_at AS createdAt, updated_at AS updatedAt
+     FROM ${quoted(dialect, names.jobs)} WHERE job_id = ? LIMIT 1`, [jobId]);
+	return rows[0] ? rowToJobRecord(rows[0]) : null;
+}
+async function readCursorRow(client, dialect, names, jobId) {
+	const row = (await client.query(`SELECT job_id AS jobId, last_evaluated_at AS lastEvaluatedAt, last_triggered_at AS lastTriggeredAt, next_run_at AS nextRunAt, version
+     FROM ${quoted(dialect, names.cursors)} WHERE job_id = ? LIMIT 1`, [jobId]))[0];
+	return row ? {
+		jobId: row.jobId,
+		lastEvaluatedAt: row.lastEvaluatedAt,
+		lastTriggeredAt: row.lastTriggeredAt ?? void 0,
+		nextRunAt: row.nextRunAt,
+		version: row.version
+	} : null;
+}
+async function readExecutionRow(client, dialect, names, executionId) {
+	const row = (await client.query(`SELECT execution_id AS executionId, job_id AS jobId, scheduled_for AS scheduledFor, triggered_at AS triggeredAt, status, queue_task_id AS queueTaskId, attempt_count AS attemptCount, last_error AS lastError
+     FROM ${quoted(dialect, names.executions)} WHERE execution_id = ? LIMIT 1`, [executionId]))[0];
+	return row ? {
+		executionId: row.executionId,
+		jobId: row.jobId,
+		scheduledFor: row.scheduledFor,
+		triggeredAt: row.triggeredAt,
+		status: row.status,
+		queueTaskId: row.queueTaskId ?? void 0,
+		attemptCount: row.attemptCount,
+		lastError: row.lastError ?? void 0
+	} : null;
+}
+function createSchedulerPersistence(config) {
+	const names = tableNames(namespaceFor(config));
+	let bootstrapPromise = null;
+	async function ensureBootstrapped() {
+		if (!bootstrapPromise) bootstrapPromise = bootstrapSchedulerPersistence(config.client, config.dialect, names);
+		await bootstrapPromise;
+	}
+	return {
+		jobStore: {
+			async create(jobId, definition) {
+				await ensureBootstrapped();
+				const row = toJobRow(jobId, definition);
+				await config.client.transaction(async (tx) => {
+					await tx.execute(`DELETE FROM ${quoted(config.dialect, names.jobs)} WHERE job_id = ?`, [jobId]);
+					await tx.execute(`INSERT INTO ${quoted(config.dialect, names.jobs)} (job_id, name, handler_key, schedule_type, expression, timezone, overlap_policy, missed_run_policy, config_json, enabled, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+						row.jobId,
+						row.name,
+						row.handlerKey,
+						row.scheduleType,
+						row.expression,
+						row.timezone,
+						row.overlapPolicy,
+						row.missedRunPolicy,
+						row.configJson,
+						row.enabled,
+						row.createdAt,
+						row.updatedAt
+					]);
+				});
+				return rowToJobRecord(row);
+			},
+			async update(jobId, patch) {
+				const current = await readJobRow(config.client, config.dialect, names, jobId);
+				if (!current) return null;
+				const next = {
+					...current,
+					...patch,
+					schedule: {
+						...current.schedule,
+						...patch.schedule
+					},
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				await config.client.transaction(async (tx) => {
+					await tx.execute(`DELETE FROM ${quoted(config.dialect, names.jobs)} WHERE job_id = ?`, [jobId]);
+					await tx.execute(`INSERT INTO ${quoted(config.dialect, names.jobs)} (job_id, name, handler_key, schedule_type, expression, timezone, overlap_policy, missed_run_policy, config_json, enabled, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+						next.jobId,
+						next.name,
+						next.handlerKey,
+						next.schedule.scheduleType,
+						next.schedule.expression,
+						next.schedule.timezone,
+						next.schedule.overlapPolicy ?? null,
+						next.schedule.missedRunPolicy ?? null,
+						JSON.stringify(next.config),
+						next.enabled ? 1 : 0,
+						next.createdAt,
+						next.updatedAt
+					]);
+				});
+				return next;
+			},
+			async setEnabled(jobId, enabled) {
+				const current = await readJobRow(config.client, config.dialect, names, jobId);
+				if (!current) return null;
+				const next = {
+					...current,
+					enabled,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				await config.client.transaction(async (tx) => {
+					await tx.execute(`DELETE FROM ${quoted(config.dialect, names.jobs)} WHERE job_id = ?`, [jobId]);
+					await tx.execute(`INSERT INTO ${quoted(config.dialect, names.jobs)} (job_id, name, handler_key, schedule_type, expression, timezone, overlap_policy, missed_run_policy, config_json, enabled, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+						next.jobId,
+						next.name,
+						next.handlerKey,
+						next.schedule.scheduleType,
+						next.schedule.expression,
+						next.schedule.timezone,
+						next.schedule.overlapPolicy ?? null,
+						next.schedule.missedRunPolicy ?? null,
+						JSON.stringify(next.config),
+						next.enabled ? 1 : 0,
+						next.createdAt,
+						next.updatedAt
+					]);
+				});
+				return next;
+			},
+			async get(jobId) {
+				await ensureBootstrapped();
+				return readJobRow(config.client, config.dialect, names, jobId);
+			},
+			async list() {
+				await ensureBootstrapped();
+				return (await config.client.query(`SELECT job_id AS jobId, name, handler_key AS handlerKey, schedule_type AS scheduleType, expression, timezone, overlap_policy AS overlapPolicy, missed_run_policy AS missedRunPolicy, config_json AS configJson, enabled, created_at AS createdAt, updated_at AS updatedAt
+           FROM ${quoted(config.dialect, names.jobs)} ORDER BY created_at ASC`, [])).map(rowToJobRecord);
+			},
+			async remove(jobId) {
+				await ensureBootstrapped();
+				await config.client.execute(`DELETE FROM ${quoted(config.dialect, names.jobs)} WHERE job_id = ?`, [jobId]);
+				return true;
+			}
+		},
+		cursorStore: {
+			async set(jobId, nextRunAt, now) {
+				await ensureBootstrapped();
+				const current = await readCursorRow(config.client, config.dialect, names, jobId);
+				const next = {
+					jobId,
+					lastEvaluatedAt: now,
+					lastTriggeredAt: current?.lastTriggeredAt ?? null,
+					nextRunAt,
+					version: (current?.version ?? 0) + 1
+				};
+				await config.client.transaction(async (tx) => {
+					await tx.execute(`DELETE FROM ${quoted(config.dialect, names.cursors)} WHERE job_id = ?`, [jobId]);
+					await tx.execute(`INSERT INTO ${quoted(config.dialect, names.cursors)} (job_id, last_evaluated_at, last_triggered_at, next_run_at, version) VALUES (?, ?, ?, ?, ?)`, [
+						next.jobId,
+						next.lastEvaluatedAt,
+						next.lastTriggeredAt,
+						next.nextRunAt,
+						next.version
+					]);
+				});
+				return {
+					jobId: next.jobId,
+					lastEvaluatedAt: next.lastEvaluatedAt,
+					lastTriggeredAt: next.lastTriggeredAt ?? void 0,
+					nextRunAt: next.nextRunAt,
+					version: next.version
+				};
+			},
+			async markTriggered(jobId, triggeredAt) {
+				await ensureBootstrapped();
+				const current = await readCursorRow(config.client, config.dialect, names, jobId);
+				if (!current) return null;
+				const next = {
+					...current,
+					lastTriggeredAt: triggeredAt,
+					version: current.version + 1
+				};
+				await config.client.execute(`UPDATE ${quoted(config.dialect, names.cursors)} SET last_triggered_at = ?, version = ? WHERE job_id = ?`, [
+					next.lastTriggeredAt,
+					next.version,
+					jobId
+				]);
+				return {
+					jobId: next.jobId,
+					lastEvaluatedAt: next.lastEvaluatedAt,
+					lastTriggeredAt: next.lastTriggeredAt ?? void 0,
+					nextRunAt: next.nextRunAt,
+					version: next.version
+				};
+			},
+			async get(jobId) {
+				await ensureBootstrapped();
+				return readCursorRow(config.client, config.dialect, names, jobId);
+			},
+			async remove(jobId) {
+				await ensureBootstrapped();
+				await config.client.execute(`DELETE FROM ${quoted(config.dialect, names.cursors)} WHERE job_id = ?`, [jobId]);
+				return true;
+			}
+		},
+		executionStore: {
+			async create(record) {
+				await ensureBootstrapped();
+				await config.client.execute(`INSERT INTO ${quoted(config.dialect, names.executions)} (execution_id, job_id, scheduled_for, triggered_at, status, queue_task_id, attempt_count, last_error)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+					record.executionId,
+					record.jobId,
+					record.scheduledFor,
+					record.triggeredAt,
+					record.status,
+					record.queueTaskId ?? null,
+					record.attemptCount,
+					record.lastError ?? null
+				]);
+				return record;
+			},
+			async update(executionId, patch) {
+				const current = await readExecutionRow(config.client, config.dialect, names, executionId);
+				if (!current) return null;
+				const next = {
+					...current,
+					...patch
+				};
+				await config.client.execute(`UPDATE ${quoted(config.dialect, names.executions)} SET job_id = ?, scheduled_for = ?, triggered_at = ?, status = ?, queue_task_id = ?, attempt_count = ?, last_error = ? WHERE execution_id = ?`, [
+					next.jobId,
+					next.scheduledFor,
+					next.triggeredAt,
+					next.status,
+					next.queueTaskId ?? null,
+					next.attemptCount,
+					next.lastError ?? null,
+					executionId
+				]);
+				return next;
+			},
+			async listByJob(jobId) {
+				await ensureBootstrapped();
+				return (await config.client.query(`SELECT execution_id AS executionId, job_id AS jobId, scheduled_for AS scheduledFor, triggered_at AS triggeredAt, status, queue_task_id AS queueTaskId, attempt_count AS attemptCount, last_error AS lastError
+           FROM ${quoted(config.dialect, names.executions)} WHERE job_id = ? ORDER BY triggered_at ASC`, [jobId])).map((row) => ({
+					executionId: row.executionId,
+					jobId: row.jobId,
+					scheduledFor: row.scheduledFor,
+					triggeredAt: row.triggeredAt,
+					status: row.status,
+					queueTaskId: row.queueTaskId ?? void 0,
+					attemptCount: row.attemptCount,
+					lastError: row.lastError ?? void 0
+				}));
+			}
+		}
+	};
+}
+//#endregion
 //#region src/core/scheduler-service.ts
 function createSchedulerService$1(options) {
 	assertRuntimeConfig(options);
 	const logger = options.logger ?? createSchedulerLogger();
 	const cache = options.cache ?? createSchedulerCache();
-	const jobStore = createInMemorySchedulerJobStore();
-	const cursorStore = createInMemoryScheduleCursorStore();
-	const executionStore = createInMemoryJobExecutionStore();
+	const persistence = options.persistence ? createSchedulerPersistence(options.persistence) : void 0;
+	const jobStore = persistence?.jobStore ?? createInMemorySchedulerJobStore();
+	const cursorStore = persistence?.cursorStore ?? createInMemoryScheduleCursorStore();
+	const executionStore = persistence?.executionStore ?? createInMemoryJobExecutionStore();
 	const events = createInMemorySchedulerEventBus();
 	const handlers = createSchedulerHandlerRegistry();
 	const queueService = options.queueService;
@@ -522,9 +858,9 @@ function createSchedulerService$1(options) {
 			async registerJob(job) {
 				if (!handlers.has(job.handlerKey)) throw new Error(`Unknown handlerKey: ${job.handlerKey}`);
 				const jobId = `job_${(0, node_crypto.randomUUID)()}`;
-				const created = jobStore.create(jobId, job);
+				const created = await jobStore.create(jobId, job);
 				const nextRunAt = await engine.computeNextRun(created);
-				cursorStore.set(jobId, nextRunAt, (/* @__PURE__ */ new Date()).toISOString());
+				await cursorStore.set(jobId, nextRunAt, (/* @__PURE__ */ new Date()).toISOString());
 				events.emit({
 					eventType: "job-created",
 					jobId,
@@ -533,32 +869,32 @@ function createSchedulerService$1(options) {
 				return { jobId };
 			},
 			async updateJob(jobId, patch) {
-				const updated = jobStore.update(jobId, patch);
+				const updated = await jobStore.update(jobId, patch);
 				if (!updated) throw new Error(`Job not found: ${jobId}`);
 				const nextRunAt = await engine.computeNextRun(updated);
-				cursorStore.set(jobId, nextRunAt, (/* @__PURE__ */ new Date()).toISOString());
+				await cursorStore.set(jobId, nextRunAt, (/* @__PURE__ */ new Date()).toISOString());
 				events.emit({
 					eventType: "job-updated",
 					jobId
 				});
 			},
 			async pauseJob(jobId) {
-				if (!jobStore.setEnabled(jobId, false)) throw new Error(`Job not found: ${jobId}`);
+				if (!await jobStore.setEnabled(jobId, false)) throw new Error(`Job not found: ${jobId}`);
 				events.emit({
 					eventType: "job-paused",
 					jobId
 				});
 			},
 			async resumeJob(jobId) {
-				if (!jobStore.setEnabled(jobId, true)) throw new Error(`Job not found: ${jobId}`);
+				if (!await jobStore.setEnabled(jobId, true)) throw new Error(`Job not found: ${jobId}`);
 				events.emit({
 					eventType: "job-resumed",
 					jobId
 				});
 			},
 			async deleteJob(jobId) {
-				const removed = jobStore.remove(jobId);
-				cursorStore.remove(jobId);
+				const removed = await jobStore.remove(jobId);
+				await cursorStore.remove(jobId);
 				if (!removed) throw new Error(`Job not found: ${jobId}`);
 				events.emit({
 					eventType: "job-deleted",
@@ -566,8 +902,9 @@ function createSchedulerService$1(options) {
 				});
 			},
 			async listJobs() {
-				return jobStore.list().map((job) => {
-					const cursor = cursorStore.get(job.jobId);
+				const jobs = await jobStore.list();
+				return Promise.all(jobs.map(async (job) => {
+					const cursor = await cursorStore.get(job.jobId);
 					return toJobListItem({
 						jobId: job.jobId,
 						name: job.name,
@@ -575,13 +912,15 @@ function createSchedulerService$1(options) {
 						timezone: job.schedule.timezone,
 						nextRunAt: cursor?.nextRunAt
 					});
-				});
+				}));
 			},
 			async listExecutions(query) {
-				return filterExecutions(jobStore.list().flatMap((job) => executionStore.listByJob(job.jobId)), query);
+				const jobs = await jobStore.list();
+				return filterExecutions((await Promise.all(jobs.map((job) => executionStore.listByJob(job.jobId)))).flat(), query);
 			},
 			async retryFailedExecution(executionId) {
-				const retry = retryFailedExecutionById(jobStore.list().flatMap((job) => executionStore.listByJob(job.jobId)), executionStore, executionId);
+				const jobs = await jobStore.list();
+				const retry = await retryFailedExecutionById((await Promise.all(jobs.map((job) => executionStore.listByJob(job.jobId)))).flat(), executionStore, executionId);
 				events.emit({
 					eventType: "retry",
 					jobId: retry.jobId,
@@ -642,4 +981,5 @@ exports.CronWeekday = CronWeekday;
 exports.bindSchedulerToHost = bindSchedulerToHost;
 exports.createCronExpression = createCronExpression;
 exports.createSchedulerDashboardService = createSchedulerDashboardService;
+exports.createSchedulerPersistence = createSchedulerPersistence;
 exports.createSchedulerService = createSchedulerService;

package/dist/index.d.cts

@@ -1,3 +1,4 @@
+import { SqlClientAdapter, SqlDialectAdapter } from "@azlib/persistence";
 //#region src/contracts/scheduler-types.d.ts
 type SchedulerMode = "standalone" | "embedded";
 type ScheduleType = "once" | "cron";
@@ -74,6 +75,12 @@ interface SchedulerServiceOptions {
   };
   tickIntervalMs?: number;
   maxDueJobsPerTick?: number;
+  persistence?: SchedulerPersistenceConfig;
+}
+interface SchedulerPersistenceConfig {
+  client: SqlClientAdapter;
+  dialect: SqlDialectAdapter;
+  namespace?: string;
 }
 interface SchedulerHandlerRegistry {
   register<TConfig>(handlerKey: string, handler: (input: TConfig) => Promise<void>): void;
@@ -162,11 +169,51 @@ interface SchedulerDashboardService {
 }
 declare function createSchedulerDashboardService(scheduler: SchedulerService): SchedulerDashboardService;
 //#endregion
+//#region src/core/job-execution-store.d.ts
+interface JobExecutionStore {
+  create(record: SchedulerExecutionRecord): Promise<SchedulerExecutionRecord>;
+  update(executionId: string, patch: Partial<Omit<SchedulerExecutionRecord, "executionId">>): Promise<SchedulerExecutionRecord | null>;
+  listByJob(jobId: string): Promise<SchedulerExecutionRecord[]>;
+}
+//#endregion
+//#region src/core/schedule-cursor-store.d.ts
+interface ScheduleCursorRecord {
+  jobId: string;
+  lastEvaluatedAt: string;
+  lastTriggeredAt?: string;
+  nextRunAt: string;
+  version: number;
+}
+interface ScheduleCursorStore {
+  set(jobId: string, nextRunAt: string, now: string): Promise<ScheduleCursorRecord>;
+  markTriggered(jobId: string, triggeredAt: string): Promise<ScheduleCursorRecord | null>;
+  get(jobId: string): Promise<ScheduleCursorRecord | null>;
+  remove(jobId: string): Promise<boolean>;
+}
+//#endregion
+//#region src/core/scheduler-job-store.d.ts
+interface SchedulerJobStore {
+  create(jobId: string, definition: SchedulerJobDefinition): Promise<SchedulerJobRecord>;
+  update(jobId: string, patch: Partial<SchedulerJobDefinition>): Promise<SchedulerJobRecord | null>;
+  setEnabled(jobId: string, enabled: boolean): Promise<SchedulerJobRecord | null>;
+  get(jobId: string): Promise<SchedulerJobRecord | null>;
+  list(): Promise<SchedulerJobRecord[]>;
+  remove(jobId: string): Promise<boolean>;
+}
+//#endregion
+//#region src/core/persistence.d.ts
+interface SchedulerPersistence {
+  jobStore: SchedulerJobStore;
+  cursorStore: ScheduleCursorStore;
+  executionStore: JobExecutionStore;
+}
+declare function createSchedulerPersistence(config: SchedulerPersistenceConfig): SchedulerPersistence;
+//#endregion
 //#region index.d.ts
 declare function createSchedulerService(options: SchedulerServiceOptions): {
   service: SchedulerService;
   handlers: SchedulerHandlerRegistry;
 };
 //#endregion
-export { CronWeekday, type CronWeekdayValue, type SchedulerHandlerRegistry, type SchedulerHostAdapter, type SchedulerJobDefinition, type SchedulerJobRecord, type SchedulerMissedRunPolicy, type SchedulerMode, type SchedulerOverlapPolicy, type SchedulerScheduleConfig, type SchedulerService, type SchedulerServiceOptions, bindSchedulerToHost, createCronExpression, createSchedulerDashboardService, createSchedulerService };
+export { CronWeekday, type CronWeekdayValue, type SchedulerHandlerRegistry, type SchedulerHostAdapter, type SchedulerJobDefinition, type SchedulerJobRecord, type SchedulerMissedRunPolicy, type SchedulerMode, type SchedulerOverlapPolicy, type SchedulerPersistenceConfig, type SchedulerScheduleConfig, type SchedulerService, type SchedulerServiceOptions, bindSchedulerToHost, createCronExpression, createSchedulerDashboardService, createSchedulerPersistence, createSchedulerService };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/contracts/scheduler-types.ts","../src/contracts/scheduler-host.ts","../src/core/scheduler-host-binding.ts","../src/core/cron-expression-builder.ts","../src/dashboard/queue-queries.ts","../src/dashboard/queue-dashboard-service.ts","../index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/contracts/scheduler-types.ts","../src/contracts/scheduler-host.ts","../src/core/scheduler-host-binding.ts","../src/core/cron-expression-builder.ts","../src/dashboard/queue-queries.ts","../src/dashboard/queue-dashboard-service.ts","../src/core/job-execution-store.ts","../src/core/schedule-cursor-store.ts","../src/core/scheduler-job-store.ts","../src/core/persistence.ts","../index.ts"],"mappings":";;KAEY;KAEA;KAEA;KAEA;UAEK;EACf,cAAc;EACd;EACA;EACA,gBAAgB;EAChB,kBAAkB;;UAGH,uBAAuB;EACtC;EACA;EACA,UAAU;EACV,QAAQ;EACR;;UAGe,mBAAmB,2BAA2B,uBAAuB;EACpF;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA,SAAS;EACT;EACA;EACA;;UAGe;EACf,YAAY,SAAS,KAAK,uBAAuB,WAAW;IAAU;;EACtE,UAAU,SAAS,eAAe,OAAO,QAAQ,uBAAuB,YAAY;EACpF,SAAS,gBAAgB;EACzB,UAAU,gBAAgB;EAC1B,UAAU,gBAAgB;EAC1B,YAAY,QAAQ;EACpB,eAAe,QAAQ,0BAA0B,QAAQ;EACzD,qBAAqB,sBAAsB;EAC3C,SAAS;EACT,QAAQ;;UAGO;EACf,MAAM;EACN;EACA,sCAAsC;EACtC,+BAA+B;EAC/B;IACE,MAAM,iBAAiB,OAAO;IAC9B,KAAK,iBAAiB,OAAO;IAC7B,KAAK,iBAAiB,OAAO;IAC7B,MAAM,iBAAiB,OAAO;;EAEhC;EACA;EACA,cAAc;;UAGC;EACf,QAAQ;EACR,SAAS;EACT;;UAGe;EACf,SAAS,SAAS,oBAAoB,UAAU,OAAO,YAAY;EACnE,QAAQ,uBAAuB,mBAAmB;EAClD,IAAI;;;;UClGW;EACf,QAAQ,gBAAgB;EACxB,OAAO,gBAAgB;;;;iBCCT,oBACd,WAAW,kBACX,MAAM;;;cCLK;;;;;;;;;KAUD,2BAA2B,0BAA0B;cAyBpD;UACH;UACA;UACA;UACA;UACA;EAER;EAKA,cAAc;EAMd,SAAS;EAMT,UAAU;EASV;EAKA,YAAY;EAMZ,OAAO;EAMP,QAAQ;EASR,aAAa;EAMb,cAAc;EASd,kBAAkB;EAMlB;EAKA,QAAQ;EAMR,SAAS;EAST,aAAa;EAMb,UAAU,SAAS;EAMnB,WAAW,UAAU;EASrB,eAAe;EAMf;EAKA;EAKA,QAAQ,cAAc;EAStB,SAAS,SAAS,kBAAkB,eAAU;EAS9C,UAAU,oBAAoB,eAAU;EASxC;EAIA;;iBAKc,wBAAwB;;;UC9MvB;EACf;EACA;EACA;EACA;;iBAGoB,qBACpB,WAAW,mBACV,QAAQ;iBAYW,oBAAoB,WAAW,mBAAgB;cAAhB;;;;;;;;;UCpBpC;EACf,aAAa,kBAAkB;EAC/B,aAAa,kBAAkB;EAC/B,SAAS,gBAAgB;EACzB,UAAU,gBAAgB;EAC1B,eAAe,sBAAsB;;iBAGvB,gCACd,WAAW,mBACV;;;UCXc;EACf,OAAO,QAAQ,2BAA2B,QAAQ;EAClD,OACE,qBACA,OAAO,QAAQ,KAAK,4CACnB,QAAQ;EACX,UAAU,gBAAgB,QAAQ;;;;UCRnB;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf,IAAI,eAAe,mBAAmB,cAAc,QAAQ;EAC5D,cAAc,eAAe,sBAAsB,QAAQ;EAC3D,IAAI,gBAAgB,QAAQ;EAC5B,OAAO,gBAAgB;;;;UCVR;EACf,OAAO,eAAe,YAAY,yBAAyB,QAAQ;EACnE,OAAO,eAAe,OAAO,QAAQ,0BAA0B,QAAQ;EACvE,WAAW,eAAe,mBAAmB,QAAQ;EACrD,IAAI,gBAAgB,QAAQ;EAC5B,QAAQ,QAAQ;EAChB,OAAO,gBAAgB;;;;UCgLR;EACf,UAAU;EACV,aAAa;EACb,gBAAgB;;iBAGF,2BAA2B,QAAQ,6BAA6B;;;iBC/JhE,uBAAuB,SAAS;EAC9C,SAAS;EACT,UAAU"}