@azlib/scheduler 1.0.5 → 1.2.0

package/dist/index.mjs

@@ -1,3 +1,5 @@
+import { a as dispatchJobExecution, i as retryFailedExecutionById, n as createSchedulerDashboardFromStores, o as computeNextRunAt, r as createSchedulerPersistence, s as parseSchedule, t as createSchedulerDashboardFromPersistence } from "./store-dashboard-Cyf_JILa.mjs";
+import { t as createSchedulerDashboardService } from "./queue-dashboard-service-C0QapgOg.mjs";
 import { unique } from "@azlib/std";
 import { randomUUID } from "node:crypto";
 import { createCache } from "@azlib/cache";
@@ -240,42 +242,6 @@ function createSchedulerCache(namespace = "scheduler-core") {
 	});
 }
 //#endregion
-//#region src/core/schedule-parser.ts
-const CRON_FIELD_PATTERN = /^\*|\*\/\d+|\d+|\d+-\d+|\d+(?:,\d+)*$/;
-function assertValidTimezone(timezone) {
-	try {
-		new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format(/* @__PURE__ */ new Date());
-	} catch {
-		throw new Error(`Invalid timezone: ${timezone}`);
-	}
-}
-function assertValidCronExpression(expression) {
-	const fields = expression.trim().split(/\s+/);
-	if (fields.length !== 5) throw new Error("Cron expression must contain 5 fields");
-	for (const field of fields) if (!CRON_FIELD_PATTERN.test(field)) throw new Error(`Invalid cron field: ${field}`);
-}
-function assertValidOnceExpression(expression) {
-	const date = new Date(expression);
-	if (Number.isNaN(date.getTime())) throw new Error("Once schedule expression must be a valid ISO datetime");
-}
-function parseSchedule(scheduleType, expression, timezone) {
-	assertValidTimezone(timezone);
-	if (scheduleType === "cron") assertValidCronExpression(expression);
-	else assertValidOnceExpression(expression);
-	return {
-		scheduleType,
-		expression: expression.trim(),
-		timezone
-	};
-}
-function computeNextRunAt(parsed, now = /* @__PURE__ */ new Date()) {
-	if (parsed.scheduleType === "once") return new Date(parsed.expression).toISOString();
-	const next = new Date(now);
-	next.setUTCSeconds(0, 0);
-	next.setUTCMinutes(next.getUTCMinutes() + 1);
-	return next.toISOString();
-}
-//#endregion
 //#region src/core/scheduler-engine.ts
 function createSchedulerEngine(dependencies) {
 	let timer;
@@ -294,26 +260,16 @@ function createSchedulerEngine(dependencies) {
 		for (const job of candidates) {
 			const nextRunAt = await computeNextRun(job, now);
 			if (new Date(nextRunAt).getTime() > now.getTime()) continue;
-			const executionId = `exec_${randomUUID()}`;
-			await dependencies.executionStore.create({
-				executionId,
-				jobId: job.jobId,
+			await dispatchJobExecution({
+				job,
+				executionStore: dependencies.executionStore,
+				queueService: dependencies.queueService,
 				scheduledFor: nextRunAt,
-				triggeredAt: now.toISOString(),
-				status: "queued",
-				attemptCount: 0
+				attemptCount: 0,
+				idempotencyKey: `scheduler:${job.jobId}:${nextRunAt}`
 			});
 			await dependencies.cursorStore.markTriggered(job.jobId, now.toISOString());
-			if (dependencies.queueService) await dependencies.queueService.enqueue({
-				idempotencyKey: `scheduler:${job.jobId}:${nextRunAt}`,
-				payloadRef: {
-					executionId,
-					handlerKey: job.handlerKey,
-					config: job.config
-				}
-			});
 			dependencies.logger.info("scheduler.job.triggered", {
-				executionId,
 				jobId: job.jobId,
 				scheduledFor: nextRunAt
 			});
@@ -370,6 +326,9 @@ function createSchedulerHandlerRegistry() {
 		},
 		has(handlerKey) {
 			return handlers.has(handlerKey);
+		},
+		keys() {
+			return Array.from(handlers.keys());
 		}
 	};
 }
@@ -462,7 +421,12 @@ function toJobListItem(input) {
 		name: input.name,
 		enabled: input.enabled,
 		timezone: input.timezone,
-		nextRunAt: input.nextRunAt
+		nextRunAt: input.nextRunAt,
+		handlerKey: input.handlerKey,
+		schedule: input.schedule,
+		config: input.config,
+		createdAt: input.createdAt,
+		updatedAt: input.updatedAt
 	};
 }
 function filterExecutions(items, query) {
@@ -478,358 +442,6 @@ function filterExecutions(items, query) {
 	}).slice(0, query.limit ?? items.length);
 }
 //#endregion
-//#region src/core/scheduler-service-retry.ts
-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");
-	const retryExecutionId = `exec_${randomUUID()}`;
-	const retry = {
-		...target,
-		executionId: retryExecutionId,
-		status: "queued",
-		attemptCount: target.attemptCount + 1,
-		triggeredAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-	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);
@@ -910,7 +522,12 @@ function createSchedulerService$1(options) {
 						name: job.name,
 						enabled: job.enabled,
 						timezone: job.schedule.timezone,
-						nextRunAt: cursor?.nextRunAt
+						nextRunAt: cursor?.nextRunAt,
+						handlerKey: job.handlerKey,
+						schedule: job.schedule,
+						config: job.config,
+						createdAt: job.createdAt,
+						updatedAt: job.updatedAt
 					});
 				}));
 			},
@@ -920,7 +537,7 @@ function createSchedulerService$1(options) {
 			},
 			async retryFailedExecution(executionId) {
 				const jobs = await jobStore.list();
-				const retry = await retryFailedExecutionById((await Promise.all(jobs.map((job) => executionStore.listByJob(job.jobId)))).flat(), executionStore, executionId);
+				const retry = await retryFailedExecutionById((await Promise.all(jobs.map((job) => executionStore.listByJob(job.jobId)))).flat(), jobs, executionStore, queueService, executionId);
 				events.emit({
 					eventType: "retry",
 					jobId: retry.jobId,
@@ -928,6 +545,25 @@ function createSchedulerService$1(options) {
 					metadata: { previousExecutionId: executionId }
 				});
 			},
+			async runNow(jobId) {
+				const job = await jobStore.get(jobId);
+				if (!job) throw new Error(`Job not found: ${jobId}`);
+				const scheduledFor = (/* @__PURE__ */ new Date()).toISOString();
+				const execution = await dispatchJobExecution({
+					job,
+					executionStore,
+					queueService,
+					scheduledFor,
+					attemptCount: 0,
+					idempotencyKey: `scheduler:${job.jobId}:manual:${scheduledFor}`
+				});
+				events.emit({
+					eventType: "triggered",
+					jobId,
+					executionId: execution.executionId,
+					metadata: { reason: "run-now" }
+				});
+			},
 			async start() {
 				logger.info("scheduler.service.start", { mode: options.mode });
 				await runtime.start();
@@ -941,42 +577,11 @@ function createSchedulerService$1(options) {
 	};
 }
 //#endregion
-//#region src/dashboard/queue-queries.ts
-async function querySchedulerHealth(scheduler) {
-	const jobs = await scheduler.listJobs();
-	const executions = await scheduler.listExecutions({ status: "failed" });
-	return {
-		totalJobs: jobs.length,
-		enabledJobs: jobs.filter((job) => job.enabled).length,
-		pausedJobs: jobs.filter((job) => !job.enabled).length,
-		failedExecutions: executions.length
-	};
-}
-async function querySchedulerItems(scheduler) {
-	const jobs = await scheduler.listJobs();
-	const executions = await scheduler.listExecutions({ limit: 100 });
-	return jobs.map((job) => ({
-		...job,
-		executions: executions.filter((execution) => execution.jobId === job.jobId)
-	}));
-}
-//#endregion
-//#region src/dashboard/queue-dashboard-service.ts
-function createSchedulerDashboardService(scheduler) {
-	return {
-		getHealth: () => querySchedulerHealth(scheduler),
-		listItems: () => querySchedulerItems(scheduler),
-		pauseJob: (jobId) => scheduler.pauseJob(jobId),
-		resumeJob: (jobId) => scheduler.resumeJob(jobId),
-		retryExecution: (executionId) => scheduler.retryFailedExecution(executionId)
-	};
-}
-//#endregion
 //#region index.ts
 function createSchedulerService(options) {
 	return createSchedulerService$1(options);
 }
 //#endregion
-export { CronWeekday, bindSchedulerToHost, createCronExpression, createSchedulerDashboardService, createSchedulerPersistence, createSchedulerService };
+export { CronWeekday, bindSchedulerToHost, createCronExpression, createSchedulerDashboardFromPersistence, createSchedulerDashboardFromStores, createSchedulerDashboardService, createSchedulerPersistence, createSchedulerService };
 
 //# sourceMappingURL=index.mjs.map