@azlib/scheduler 1.1.0 → 1.2.1

package/README.md

@@ -26,6 +26,7 @@ Cron-style job scheduler for Node.js, supporting timezone normalization, overlap
 | `createSchedulerDashboardService(scheduler, options?)`                          | Function | Operator API: health, list, pause/resume, run-now, retry, CRUD.           |
 | `createSchedulerDashboardFromPersistence(persistence)`                          | Function | Sidecar dashboard against the same SQL tables (does not start the engine). |
 | `createSchedulerDashboardServer(options)`                                       | Function | Serves the React UI and JSON API (`@azlib/scheduler/dashboard`).          |
+| `createSchedulerDashboardNodeHandler(options)`                                  | Function | Same monitor as the standalone server, for Express/`http` hosts.          |
 
 ### Dashboard
 
@@ -35,6 +36,7 @@ The dashboard can run **in-process** next to a live `SchedulerService`, or as a
 import {
   createSchedulerDashboardServer,
   createSchedulerDashboardService,
+  createSchedulerDashboardNodeHandler,
 } from "@azlib/scheduler/dashboard";
 
 const dashboard = createSchedulerDashboardService(service, { handlers });
@@ -44,6 +46,17 @@ const server = createSchedulerDashboardServer({
   host: "127.0.0.1",
 });
 await server.listen();
+
+// Or mount the same monitor on an existing Node/Express server:
+app.use(
+  createSchedulerDashboardNodeHandler({
+    dashboard,
+    basePath: "/scheduler",
+    authorize: async ({ authorization }) => {
+      // throw DashboardHttpError(401 | 403, message) to reject
+    },
+  }),
+);
 ```
 
 Sidecar CLI (`azlib-scheduler-dashboard`) and Docker (`packages/scheduler/Dockerfile`, `compose.yaml`):

package/dist/{cli-config-Cz8QP_4I.cjs → cli-config-DLwU62NO.cjs}

@@ -22,9 +22,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 const require_store_dashboard = require("./store-dashboard-Sg4BBWiJ.cjs");
 let _azlib_std = require("@azlib/std");
-let node_fs = require("node:fs");
 let node_http = require("node:http");
 node_http = __toESM(node_http, 1);
+let node_fs = require("node:fs");
 let node_path = require("node:path");
 let node_url = require("node:url");
 let node_async_hooks = require("node:async_hooks");
@@ -72,7 +72,11 @@ function parseScheduleFromRecord(record) {
 	if (scheduleType !== "cron" && scheduleType !== "once") throw new DashboardHttpError(400, "scheduleType must be cron or once.");
 	const expression = requiredText(record.expression ?? nested?.expression, "expression");
 	const timezone = (0, _azlib_std.asString)(record.timezone)?.trim() || (0, _azlib_std.asString)(nested?.timezone)?.trim() || DEFAULT_TIMEZONE;
-	require_store_dashboard.parseSchedule(scheduleType, expression, timezone);
+	try {
+		require_store_dashboard.parseSchedule(scheduleType, expression, timezone);
+	} catch (error) {
+		throw new DashboardHttpError(400, error instanceof Error ? error.message : "Invalid schedule.");
+	}
 	return {
 		scheduleType,
 		expression,
@@ -102,6 +106,36 @@ function parseUpdateJobBody(body) {
 	return patch;
 }
 //#endregion
+//#region src/dashboard/http-path.ts
+function normalizeDashboardBasePath(basePath) {
+	const trimmed = basePath?.trim();
+	if (!trimmed || trimmed === "/") return "";
+	return (trimmed.startsWith("/") ? trimmed : `/${trimmed}`).replace(/\/+$/, "");
+}
+function stripDashboardBasePath(pathname, basePath) {
+	const base = normalizeDashboardBasePath(basePath);
+	const path = pathname || "/";
+	if (!base) return path.startsWith("/") ? path : `/${path}`;
+	if (path === base || path === `${base}/`) return "/";
+	if (path.startsWith(`${base}/`)) {
+		const rest = path.slice(base.length);
+		return rest.startsWith("/") ? rest : `/${rest}`;
+	}
+	return null;
+}
+function resolveDashboardApiBase(pathname) {
+	const trimmed = (pathname.split("?")[0] || "/").replace(/\/index\.html$/i, "/").replace(/\/[^/]+\.[a-z0-9]+$/i, "/").replace(/\/+$/, "");
+	return trimmed === "" ? "/api" : `${trimmed}/api`;
+}
+function requestPathname(url, originalUrl) {
+	const raw = originalUrl || url || "/";
+	try {
+		return new URL(raw, "http://127.0.0.1").pathname;
+	} catch {
+		return raw.split("?")[0] || "/";
+	}
+}
+//#endregion
 //#region src/dashboard/public-dir.ts
 function resolveDashboardPublicDir(fromFileUrl) {
 	const dir = (0, node_path.dirname)((0, node_url.fileURLToPath)(fromFileUrl));
@@ -112,7 +146,7 @@ function resolveDashboardPublicDir(fromFileUrl) {
 	return nested;
 }
 //#endregion
-//#region src/dashboard/http-server.ts
+//#region src/dashboard/http-handler.ts
 const MIME_TYPES = {
 	".css": "text/css; charset=utf-8",
 	".html": "text/html; charset=utf-8",
@@ -126,7 +160,7 @@ function sendJson(res, status, body) {
 	res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
 	res.end(JSON.stringify(body));
 }
-function sendError(res, error) {
+function sendDashboardError(res, error) {
 	if (error instanceof DashboardHttpError) {
 		sendJson(res, error.status, { error: error.message });
 		return;
@@ -134,10 +168,17 @@ function sendError(res, error) {
 	const message = error instanceof Error ? error.message : "Unknown error";
 	sendJson(res, message.includes("not found") ? 404 : message.includes("Only failed") ? 400 : message.includes("Unknown handlerKey") ? 400 : 500, { error: message });
 }
+function hasParsedBody(req) {
+	return Object.prototype.hasOwnProperty.call(req, "body");
+}
 async function readJsonBody(req) {
+	if (req.readableEnded && hasParsedBody(req)) return req.body ?? {};
 	const chunks = [];
 	for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-	if (chunks.length === 0) return {};
+	if (chunks.length === 0) {
+		if (hasParsedBody(req)) return req.body ?? {};
+		return {};
+	}
 	const raw = Buffer.concat(chunks).toString("utf8");
 	if (!raw.trim()) return {};
 	try {
@@ -175,115 +216,158 @@ function servePublicFile(publicDir, urlPath, res) {
 	(0, node_fs.createReadStream)(filePath).pipe(res);
 	return true;
 }
-function createSchedulerDashboardServer(options) {
-	const port = options.port ?? 9100;
-	const host = options.host ?? "127.0.0.1";
-	const publicDir = options.publicDir ?? resolveDashboardPublicDir(require("url").pathToFileURL(__filename).href);
-	const dashboard = options.dashboard;
-	const server = node_http.createServer((req, res) => {
-		handleRequest(req, res).catch((error) => {
-			if (!res.headersSent) sendError(res, error);
+async function authorizeApi(options, method, pathname, req) {
+	if (options.authorize) {
+		await options.authorize({
+			method,
+			pathname,
+			authorization: req.headers.authorization
 		});
+		return;
+	}
+	authorizeDashboardRequest({
+		token: options.token,
+		authorization: req.headers.authorization
 	});
-	async function handleRequest(req, res) {
-		const method = req.method ?? "GET";
-		const pathname = new URL(req.url ?? "/", `http://${host}:${port}`).pathname;
-		if (method === "GET" && pathname === "/health") {
-			res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
-			res.end("ok");
+}
+async function handleApi(dashboard, method, pathname, req, res) {
+	if (method === "GET" && pathname === "/api/health") {
+		sendJson(res, 200, await dashboard.getHealth());
+		return;
+	}
+	if (method === "GET" && pathname === "/api/handlers") {
+		sendJson(res, 200, { handlers: dashboard.listHandlerKeys() });
+		return;
+	}
+	if (method === "GET" && pathname === "/api/jobs") {
+		sendJson(res, 200, { items: await dashboard.listItems() });
+		return;
+	}
+	if (method === "POST" && pathname === "/api/jobs") {
+		sendJson(res, 201, await dashboard.createJob(parseCreateJobBody(await readJsonBody(req))));
+		return;
+	}
+	const jobExec = matchPath(pathname, "/api/jobs/:jobId/executions");
+	if (jobExec && method === "GET") {
+		sendJson(res, 200, { executions: await dashboard.listExecutions(jobExec.jobId ?? "") });
+		return;
+	}
+	const jobAction = matchPath(pathname, "/api/jobs/:jobId/:action");
+	if (jobAction && method === "POST") {
+		const jobId = jobAction.jobId ?? "";
+		if (jobAction.action === "pause") {
+			await dashboard.pauseJob(jobId);
+			res.writeHead(204);
+			res.end();
 			return;
 		}
-		if (pathname === "/api" || pathname.startsWith("/api/")) {
-			authorizeDashboardRequest({
-				token: options.token,
-				authorization: req.headers.authorization
-			});
-			await handleApi(method, pathname, req, res);
+		if (jobAction.action === "resume") {
+			await dashboard.resumeJob(jobId);
+			res.writeHead(204);
+			res.end();
 			return;
 		}
-		if (method === "GET" && servePublicFile(publicDir, pathname, res)) return;
+		if (jobAction.action === "run") {
+			await dashboard.runJob(jobId);
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+	}
+	const retry = matchPath(pathname, "/api/executions/:executionId/retry");
+	if (retry && method === "POST") {
+		await dashboard.retryExecution(retry.executionId ?? "");
+		res.writeHead(204);
+		res.end();
+		return;
+	}
+	const job = matchPath(pathname, "/api/jobs/:jobId");
+	if (job) {
+		const jobId = job.jobId ?? "";
+		if (method === "GET") {
+			const item = await dashboard.getJob(jobId);
+			if (!item) throw new DashboardHttpError(404, `Job not found: ${jobId}`);
+			sendJson(res, 200, item);
+			return;
+		}
+		if (method === "PATCH") {
+			await dashboard.updateJob(jobId, parseUpdateJobBody(await readJsonBody(req)));
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (method === "DELETE") {
+			await dashboard.deleteJob(jobId);
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+	}
+	sendJson(res, 404, { error: "Not Found" });
+}
+async function handleSchedulerDashboardRequest(req, res, options) {
+	const method = req.method ?? "GET";
+	const originalUrl = "originalUrl" in req && typeof req.originalUrl === "string" ? req.originalUrl : void 0;
+	const pathname = requestPathname(req.url, originalUrl);
+	const basePath = normalizeDashboardBasePath(options.basePath);
+	const relative = stripDashboardBasePath(pathname, basePath);
+	if (relative === null) return false;
+	if (method === "GET" && basePath && pathname === basePath) {
+		res.writeHead(302, { Location: `${basePath}/` });
+		res.end();
+		return true;
+	}
+	const publicDir = options.publicDir ?? resolveDashboardPublicDir(require("url").pathToFileURL(__filename).href);
+	try {
+		if (method === "GET" && relative === "/health") {
+			res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+			res.end("ok");
+			return true;
+		}
+		if (relative === "/api" || relative.startsWith("/api/")) {
+			await authorizeApi(options, method, relative, req);
+			await handleApi(options.dashboard, method, relative, req, res);
+			return true;
+		}
+		if (method === "GET" && servePublicFile(publicDir, relative, res)) return true;
 		res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
 		res.end("Not Found");
+		return true;
+	} catch (error) {
+		sendDashboardError(res, error);
+		return true;
 	}
-	async function handleApi(method, pathname, req, res) {
-		try {
-			if (method === "GET" && pathname === "/api/health") {
-				sendJson(res, 200, await dashboard.getHealth());
-				return;
-			}
-			if (method === "GET" && pathname === "/api/handlers") {
-				sendJson(res, 200, { handlers: dashboard.listHandlerKeys() });
-				return;
-			}
-			if (method === "GET" && pathname === "/api/jobs") {
-				sendJson(res, 200, { items: await dashboard.listItems() });
-				return;
-			}
-			if (method === "POST" && pathname === "/api/jobs") {
-				sendJson(res, 201, await dashboard.createJob(parseCreateJobBody(await readJsonBody(req))));
-				return;
-			}
-			const jobExec = matchPath(pathname, "/api/jobs/:jobId/executions");
-			if (jobExec && method === "GET") {
-				sendJson(res, 200, { executions: await dashboard.listExecutions(jobExec.jobId ?? "") });
-				return;
-			}
-			const jobAction = matchPath(pathname, "/api/jobs/:jobId/:action");
-			if (jobAction && method === "POST") {
-				const jobId = jobAction.jobId ?? "";
-				if (jobAction.action === "pause") {
-					await dashboard.pauseJob(jobId);
-					res.writeHead(204);
-					res.end();
-					return;
-				}
-				if (jobAction.action === "resume") {
-					await dashboard.resumeJob(jobId);
-					res.writeHead(204);
-					res.end();
-					return;
-				}
-				if (jobAction.action === "run") {
-					await dashboard.runJob(jobId);
-					res.writeHead(204);
-					res.end();
-					return;
-				}
-			}
-			const retry = matchPath(pathname, "/api/executions/:executionId/retry");
-			if (retry && method === "POST") {
-				await dashboard.retryExecution(retry.executionId ?? "");
-				res.writeHead(204);
-				res.end();
+}
+function createSchedulerDashboardNodeHandler(options) {
+	return (req, res, next) => {
+		handleSchedulerDashboardRequest(req, res, options).then((handled) => {
+			if (!handled) next?.();
+		}).catch((error) => {
+			if (next) {
+				next(error);
 				return;
 			}
-			const job = matchPath(pathname, "/api/jobs/:jobId");
-			if (job) {
-				const jobId = job.jobId ?? "";
-				if (method === "GET") {
-					const item = await dashboard.getJob(jobId);
-					if (!item) throw new DashboardHttpError(404, `Job not found: ${jobId}`);
-					sendJson(res, 200, item);
-					return;
-				}
-				if (method === "PATCH") {
-					await dashboard.updateJob(jobId, parseUpdateJobBody(await readJsonBody(req)));
-					res.writeHead(204);
-					res.end();
-					return;
-				}
-				if (method === "DELETE") {
-					await dashboard.deleteJob(jobId);
-					res.writeHead(204);
-					res.end();
-					return;
-				}
+			if (!res.headersSent) sendDashboardError(res, error);
+		});
+	};
+}
+//#endregion
+//#region src/dashboard/http-server.ts
+function createSchedulerDashboardServer(options) {
+	const port = options.port ?? 9100;
+	const host = options.host ?? "127.0.0.1";
+	const handler = createSchedulerDashboardNodeHandler({
+		...options,
+		publicDir: options.publicDir ?? resolveDashboardPublicDir(require("url").pathToFileURL(__filename).href)
+	});
+	const server = node_http.createServer((req, res) => {
+		handler(req, res, () => {
+			if (!res.headersSent) {
+				res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+				res.end("Not Found");
 			}
-			sendJson(res, 404, { error: "Not Found" });
-		} catch (error) {
-			sendError(res, error);
-		}
-	}
+		});
+	});
 	return {
 		get port() {
 			return port;
@@ -480,6 +564,12 @@ function parseDashboardCliEnv(env) {
 	};
 }
 //#endregion
+Object.defineProperty(exports, "DashboardHttpError", {
+	enumerable: true,
+	get: function() {
+		return DashboardHttpError;
+	}
+});
 Object.defineProperty(exports, "createDashboardPersistenceConfig", {
 	enumerable: true,
 	get: function() {
@@ -492,21 +582,51 @@ Object.defineProperty(exports, "createDashboardSqlDriver", {
 		return createDashboardSqlDriver;
 	}
 });
+Object.defineProperty(exports, "createSchedulerDashboardNodeHandler", {
+	enumerable: true,
+	get: function() {
+		return createSchedulerDashboardNodeHandler;
+	}
+});
 Object.defineProperty(exports, "createSchedulerDashboardServer", {
 	enumerable: true,
 	get: function() {
 		return createSchedulerDashboardServer;
 	}
 });
+Object.defineProperty(exports, "handleSchedulerDashboardRequest", {
+	enumerable: true,
+	get: function() {
+		return handleSchedulerDashboardRequest;
+	}
+});
+Object.defineProperty(exports, "normalizeDashboardBasePath", {
+	enumerable: true,
+	get: function() {
+		return normalizeDashboardBasePath;
+	}
+});
 Object.defineProperty(exports, "parseDashboardCliEnv", {
 	enumerable: true,
 	get: function() {
 		return parseDashboardCliEnv;
 	}
 });
+Object.defineProperty(exports, "resolveDashboardApiBase", {
+	enumerable: true,
+	get: function() {
+		return resolveDashboardApiBase;
+	}
+});
 Object.defineProperty(exports, "resolveDashboardPublicDir", {
 	enumerable: true,
 	get: function() {
 		return resolveDashboardPublicDir;
 	}
 });
+Object.defineProperty(exports, "stripDashboardBasePath", {
+	enumerable: true,
+	get: function() {
+		return stripDashboardBasePath;
+	}
+});