@azlib/scheduler 1.0.5 → 1.1.0

package/dist/store-dashboard-Sg4BBWiJ.cjs

@@ -0,0 +1,554 @@
+let node_crypto = require("node:crypto");
+//#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-job-trigger.ts
+async function dispatchJobExecution(input) {
+	const executionId = `exec_${(0, node_crypto.randomUUID)()}`;
+	const created = {
+		executionId,
+		jobId: input.job.jobId,
+		scheduledFor: input.scheduledFor,
+		triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+		status: "queued",
+		attemptCount: input.attemptCount ?? 0
+	};
+	await input.executionStore.create(created);
+	if (!input.queueService) return created;
+	const accepted = await input.queueService.enqueue({
+		idempotencyKey: input.idempotencyKey,
+		payloadRef: {
+			executionId,
+			handlerKey: input.job.handlerKey,
+			config: input.job.config
+		}
+	});
+	return await input.executionStore.update(executionId, { queueTaskId: accepted.taskId }) ?? {
+		...created,
+		queueTaskId: accepted.taskId
+	};
+}
+//#endregion
+//#region src/core/scheduler-service-retry.ts
+function findRetryableExecution(allExecutions, 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");
+	return target;
+}
+async function retryFailedExecutionById(allExecutions, jobs, executionStore, queueService, executionId) {
+	const target = findRetryableExecution(allExecutions, executionId);
+	const job = jobs.find((item) => item.jobId === target.jobId);
+	if (!job) throw new Error(`Job not found: ${target.jobId}`);
+	return dispatchJobExecution({
+		job,
+		executionStore,
+		queueService,
+		scheduledFor: target.scheduledFor,
+		attemptCount: target.attemptCount + 1,
+		idempotencyKey: `scheduler:${job.jobId}:retry:${executionId}`
+	});
+}
+//#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/dashboard/store-dashboard.ts
+function nextRunForJob(job, now = /* @__PURE__ */ new Date()) {
+	return computeNextRunAt(parseSchedule(job.schedule.scheduleType, job.schedule.expression, job.schedule.timezone), now);
+}
+async function toDashboardItem(jobStore, cursorStore, executionStore, jobId) {
+	const job = await jobStore.get(jobId);
+	if (!job) return null;
+	const cursor = await cursorStore.get(jobId);
+	const executions = await executionStore.listByJob(jobId);
+	return {
+		...job,
+		nextRunAt: cursor?.nextRunAt,
+		executions
+	};
+}
+function createSchedulerDashboardFromStores(stores, options) {
+	const { jobStore, cursorStore, executionStore } = stores;
+	const handlerKeys = [...options?.handlerKeys ?? []];
+	return {
+		async getHealth() {
+			const jobs = await jobStore.list();
+			const failed = (await Promise.all(jobs.map((job) => executionStore.listByJob(job.jobId)))).flat().filter((item) => item.status === "failed" || item.status === "dead-letter");
+			return {
+				totalJobs: jobs.length,
+				enabledJobs: jobs.filter((job) => job.enabled).length,
+				pausedJobs: jobs.filter((job) => !job.enabled).length,
+				failedExecutions: failed.length
+			};
+		},
+		async listItems() {
+			const jobs = await jobStore.list();
+			return Promise.all(jobs.map(async (job) => {
+				return await toDashboardItem(jobStore, cursorStore, executionStore, job.jobId);
+			}));
+		},
+		async getJob(jobId) {
+			return toDashboardItem(jobStore, cursorStore, executionStore, jobId);
+		},
+		async createJob(job) {
+			parseSchedule(job.schedule.scheduleType, job.schedule.expression, job.schedule.timezone);
+			const jobId = `job_${(0, node_crypto.randomUUID)()}`;
+			const nextRunAt = nextRunForJob(await jobStore.create(jobId, job));
+			await cursorStore.set(jobId, nextRunAt, (/* @__PURE__ */ new Date()).toISOString());
+			return { jobId };
+		},
+		async updateJob(jobId, patch) {
+			const updated = await jobStore.update(jobId, patch);
+			if (!updated) throw new Error(`Job not found: ${jobId}`);
+			const nextRunAt = nextRunForJob(updated);
+			await cursorStore.set(jobId, nextRunAt, (/* @__PURE__ */ new Date()).toISOString());
+		},
+		async pauseJob(jobId) {
+			if (!await jobStore.setEnabled(jobId, false)) throw new Error(`Job not found: ${jobId}`);
+		},
+		async resumeJob(jobId) {
+			if (!await jobStore.setEnabled(jobId, true)) throw new Error(`Job not found: ${jobId}`);
+		},
+		async deleteJob(jobId) {
+			const removed = await jobStore.remove(jobId);
+			await cursorStore.remove(jobId);
+			if (!removed) throw new Error(`Job not found: ${jobId}`);
+		},
+		async runJob(jobId) {
+			const job = await jobStore.get(jobId);
+			if (!job) throw new Error(`Job not found: ${jobId}`);
+			const scheduledFor = (/* @__PURE__ */ new Date()).toISOString();
+			await dispatchJobExecution({
+				job,
+				executionStore,
+				queueService: options?.queueService,
+				scheduledFor,
+				attemptCount: 0,
+				idempotencyKey: `scheduler:${job.jobId}:manual:${scheduledFor}`
+			});
+		},
+		async listExecutions(jobId) {
+			if (!await jobStore.get(jobId)) throw new Error(`Job not found: ${jobId}`);
+			return executionStore.listByJob(jobId);
+		},
+		async retryExecution(executionId) {
+			const jobs = await jobStore.list();
+			await retryFailedExecutionById((await Promise.all(jobs.map((job) => executionStore.listByJob(job.jobId)))).flat(), jobs, executionStore, options?.queueService, executionId);
+		},
+		listHandlerKeys() {
+			return handlerKeys;
+		}
+	};
+}
+function createSchedulerDashboardFromPersistence(persistence, options) {
+	return createSchedulerDashboardFromStores(createSchedulerPersistence(persistence), options);
+}
+//#endregion
+Object.defineProperty(exports, "computeNextRunAt", {
+	enumerable: true,
+	get: function() {
+		return computeNextRunAt;
+	}
+});
+Object.defineProperty(exports, "createSchedulerDashboardFromPersistence", {
+	enumerable: true,
+	get: function() {
+		return createSchedulerDashboardFromPersistence;
+	}
+});
+Object.defineProperty(exports, "createSchedulerDashboardFromStores", {
+	enumerable: true,
+	get: function() {
+		return createSchedulerDashboardFromStores;
+	}
+});
+Object.defineProperty(exports, "createSchedulerPersistence", {
+	enumerable: true,
+	get: function() {
+		return createSchedulerPersistence;
+	}
+});
+Object.defineProperty(exports, "dispatchJobExecution", {
+	enumerable: true,
+	get: function() {
+		return dispatchJobExecution;
+	}
+});
+Object.defineProperty(exports, "parseSchedule", {
+	enumerable: true,
+	get: function() {
+		return parseSchedule;
+	}
+});
+Object.defineProperty(exports, "retryFailedExecutionById", {
+	enumerable: true,
+	get: function() {
+		return retryFailedExecutionById;
+	}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azlib/scheduler",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -9,28 +9,74 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "Dockerfile",
+    "compose.yaml"
   ],
   "sideEffects": false,
+  "bin": {
+    "azlib-scheduler-dashboard": "./dist/dashboard/cli.mjs"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
+    },
+    "./dashboard": {
+      "types": "./dist/dashboard.d.mts",
+      "import": "./dist/dashboard.mjs",
+      "require": "./dist/dashboard.cjs"
     }
   },
   "dependencies": {
     "@azlib/cache": "0.2.2",
     "@azlib/logger": "0.2.2",
-    "@azlib/persistence": "0.5.0",
     "@azlib/queue": "1.0.5",
+    "@azlib/persistence": "0.5.0",
     "@azlib/std": "0.5.0"
   },
+  "peerDependencies": {
+    "better-sqlite3": ">=9.0.0",
+    "mssql": ">=10.0.0",
+    "mysql2": ">=3.0.0",
+    "pg": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "mssql": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
     "@types/node": "^22.20.1",
+    "@types/pg": "^8.15.5",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "@vitejs/plugin-react": "^6.0.4",
+    "@vitest/browser-playwright": "^4.1.11",
+    "jsdom": "^29.1.1",
+    "pg": "^8.16.3",
+    "playwright": "^1.62.1",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
     "tsdown": "^0.22.14",
     "typescript": "7.0.2",
-    "vitest": "^4.1.10",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.11",
+    "vitest-browser-react": "^2.2.0",
+    "@azlib/react": "0.10.5",
     "@azlib/ts-config": "0.0.0"
   },
   "publishConfig": {
@@ -38,10 +84,12 @@
     "registry": "https://registry.npmjs.org"
   },
   "scripts": {
-    "build": "rm -rf dist && tsdown",
+    "build": "rm -rf dist && tsdown && vite build --config dashboard-app/vite.config.ts",
     "dev": "tsdown --watch",
-    "lint": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json --noEmit && tsc -p dashboard-app/tsconfig.json --noEmit",
+    "test": "vitest run --project unit --project ui",
+    "test:browser": "vitest run --project browser",
+    "test:browser:headed": "vitest run --project browser --browser.headless=false",
     "clean": "rm -rf .turbo node_modules dist"
   }
 }