syncorejs 0.1.0 → 0.2.0

package/dist/_vendor/core/runtime/devtools.mjs

@@ -1,261 +1,416 @@
 import { createFunctionReference } from "./runtime.mjs";
 import { describeValidator } from "../../schema/index.js";
 //#region src/runtime/devtools.ts
-function createDevtoolsRequestHandler(deps) {
-	const { driver, schema, functions, runtime } = deps;
+function createDevtoolsCommandHandler(deps) {
+	const { driver, runtime, sql } = deps;
 	return async (payload) => {
+		await runtime.prepareForDirectAccess();
 		switch (payload.kind) {
-			case "fn.list": return {
-				kind: "fn.list.result",
-				functions: Object.entries(functions).filter((entry) => entry[1] !== void 0).map(([name, fn]) => {
-					const def = {
-						name,
-						type: fn.kind,
-						file: inferFileFromFunctionName(name)
-					};
-					const argsDesc = describeValidator(fn.argsValidator);
-					if (argsDesc.kind === "object") def.args = argsDesc.shape;
-					return def;
-				})
-			};
 			case "fn.run": {
 				const start = performance.now();
 				try {
 					let result;
 					switch (payload.functionType) {
-						case "query": {
-							const ref = createFunctionReference("query", payload.functionName);
-							result = await runtime.runQuery(ref, payload.args);
+						case "query":
+							result = await runtime.runQuery(createFunctionReference("query", payload.functionName), payload.args, { origin: "dashboard" });
 							break;
-						}
-						case "mutation": {
-							const ref = createFunctionReference("mutation", payload.functionName);
-							result = await runtime.runMutation(ref, payload.args);
+						case "mutation":
+							result = await runtime.runMutation(createFunctionReference("mutation", payload.functionName), payload.args, { origin: "dashboard" });
 							break;
-						}
-						case "action": {
-							const ref = createFunctionReference("action", payload.functionName);
-							result = await runtime.runAction(ref, payload.args);
+						case "action":
+							result = await runtime.runAction(createFunctionReference("action", payload.functionName), payload.args, { origin: "dashboard" });
 							break;
-						}
 					}
 					return {
 						kind: "fn.run.result",
 						result,
 						durationMs: performance.now() - start
 					};
-				} catch (err) {
+				} catch (error) {
 					return {
 						kind: "fn.run.result",
-						error: err instanceof Error ? err.message : String(err),
+						error: error instanceof Error ? error.message : String(error),
 						durationMs: performance.now() - start
 					};
 				}
 			}
-			case "schema.get": {
-				const tableNames = schema.tableNames();
-				return {
-					kind: "schema.result",
-					tables: await Promise.all(tableNames.map(async (name) => {
-						const table = schema.getTable(name);
-						const validatorDesc = describeValidator(table.validator);
-						const fields = validatorDesc.kind === "object" ? Object.entries(validatorDesc.shape).map(([fieldName, fieldDesc]) => {
-							const desc = fieldDesc;
-							const optional = desc.kind === "optional";
-							return {
-								name: fieldName,
-								type: optional ? desc.inner?.kind ?? "any" : desc.kind,
-								optional
-							};
-						}) : [];
-						fields.unshift({
-							name: "_id",
-							type: "string",
-							optional: false
-						}, {
-							name: "_creationTime",
-							type: "number",
-							optional: false
-						});
-						let documentCount = 0;
-						try {
-							const countRow = await driver.get(`SELECT COUNT(*) as count FROM "${name}"`);
-							if (countRow) documentCount = countRow.count;
-						} catch {}
-						return {
-							name,
-							fields,
-							indexes: table.indexes.map((idx) => ({
-								name: idx.name,
-								fields: idx.fields,
-								unique: false
-							})),
-							documentCount
-						};
-					}))
-				};
-			}
-			case "data.query": try {
-				let sql = `SELECT _id, _creationTime, _json FROM "${payload.table}"`;
-				const params = [];
-				if (payload.filters && payload.filters.length > 0) {
-					const conditions = payload.filters.map((filter) => {
-						const op = filterOperatorToSql(filter.operator);
-						params.push(normalizeFilterValue(filter));
-						return `json_extract(_json, '$.${filter.field}') ${op} ?`;
-					});
-					sql += ` WHERE ${conditions.join(" AND ")}`;
-				}
-				sql += " ORDER BY _creationTime DESC";
-				if (payload.limit) sql += ` LIMIT ${payload.limit}`;
-				return {
-					kind: "data.result",
-					rows: (await driver.all(sql, params)).map((row) => ({
-						_id: row._id,
-						_creationTime: row._creationTime,
-						...JSON.parse(row._json)
-					})),
-					totalCount: (await driver.get(`SELECT COUNT(*) as count FROM "${payload.table}"`))?.count ?? 0
-				};
-			} catch (err) {
-				return {
-					kind: "error",
-					message: err instanceof Error ? err.message : String(err)
-				};
-			}
 			case "data.insert": try {
-				const id = generateId();
-				const now = Date.now();
-				await driver.run(`INSERT INTO "${payload.table}" (_id, _creationTime, _json) VALUES (?, ?, ?)`, [
-					id,
-					now,
-					JSON.stringify(payload.document)
-				]);
 				return {
 					kind: "data.mutate.result",
 					success: true,
-					id
+					id: await runDevtoolsMutation(runtime, async (ctx) => ctx.db.insert(payload.table, payload.document), { origin: "dashboard" })
 				};
-			} catch (err) {
+			} catch (error) {
 				return {
 					kind: "data.mutate.result",
 					success: false,
-					error: err instanceof Error ? err.message : String(err)
+					error: error instanceof Error ? error.message : String(error)
 				};
 			}
 			case "data.patch": try {
-				const existing = await driver.get(`SELECT _json FROM "${payload.table}" WHERE _id = ?`, [payload.id]);
-				if (!existing) return {
-					kind: "data.mutate.result",
-					success: false,
-					error: `Document ${payload.id} not found`
-				};
-				const doc = {
-					...JSON.parse(existing._json),
-					...payload.fields
-				};
-				await driver.run(`UPDATE "${payload.table}" SET _json = ? WHERE _id = ?`, [JSON.stringify(doc), payload.id]);
+				await runDevtoolsMutation(runtime, async (ctx) => {
+					await ctx.db.patch(payload.table, payload.id, payload.fields);
+					return null;
+				}, { origin: "dashboard" });
 				return {
 					kind: "data.mutate.result",
 					success: true,
 					id: payload.id
 				};
-			} catch (err) {
+			} catch (error) {
 				return {
 					kind: "data.mutate.result",
 					success: false,
-					error: err instanceof Error ? err.message : String(err)
+					error: error instanceof Error ? error.message : String(error)
 				};
 			}
 			case "data.delete": try {
-				await driver.run(`DELETE FROM "${payload.table}" WHERE _id = ?`, [payload.id]);
+				await runDevtoolsMutation(runtime, async (ctx) => {
+					await ctx.db.delete(payload.table, payload.id);
+					return null;
+				}, { origin: "dashboard" });
 				return {
 					kind: "data.mutate.result",
 					success: true
 				};
-			} catch (err) {
+			} catch (error) {
 				return {
 					kind: "data.mutate.result",
 					success: false,
-					error: err instanceof Error ? err.message : String(err)
+					error: error instanceof Error ? error.message : String(error)
 				};
 			}
-			case "sql.execute": try {
-				const trimmed = payload.query.trim().toUpperCase();
-				if (trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || trimmed.startsWith("EXPLAIN")) {
-					const rows = await driver.all(payload.query);
-					const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
-					return {
-						kind: "sql.result",
-						columns,
-						rows: rows.map((row) => columns.map((col) => row[col])),
-						rowsAffected: 0
-					};
-				}
+			case "sql.read": try {
+				const sqlSupport = requireDevtoolsSqlSupport(sql);
+				const databasePath = runtime.getDriverDatabasePath();
+				if (!databasePath) throw new Error("SQL Read requires a file-backed database path.");
+				const { columns, rows } = sqlSupport.runReadonlyQuery(databasePath, payload.query);
 				return {
-					kind: "sql.result",
-					columns: [],
-					rows: [],
-					rowsAffected: (await driver.run(payload.query)).changes
+					kind: "sql.read.result",
+					columns,
+					rows
 				};
-			} catch (err) {
+			} catch (error) {
 				return {
-					kind: "sql.result",
+					kind: "sql.read.result",
 					columns: [],
 					rows: [],
-					rowsAffected: 0,
-					error: err instanceof Error ? err.message : String(err)
+					error: error instanceof Error ? error.message : String(error)
 				};
 			}
-			case "scheduler.list": try {
+			case "sql.write": try {
+				const analysis = requireDevtoolsSqlSupport(sql).analyzeSqlStatement(payload.query);
+				if (analysis.mode === "read") throw new Error("Use SQL Read or SQL Live for read-only statements.");
+				const result = await driver.run(payload.query);
+				runtime.notifyDevtoolsScopes(analysis.observedScopes);
+				await runtime.forceRefreshDevtools("SQL write executed from devtools dashboard.", { origin: "dashboard" });
 				return {
-					kind: "scheduler.list.result",
-					jobs: (await driver.all(`SELECT * FROM "_scheduled_functions" ORDER BY run_at DESC LIMIT 200`)).map((row) => {
-						const job = {
-							id: row.id,
-							functionName: row.function_name,
-							args: JSON.parse(row.args_json),
-							scheduledAt: row.created_at,
-							runAt: row.run_at,
-							status: mapJobStatus(row.status)
-						};
-						if (row.schedule_json) try {
-							const schedule = JSON.parse(row.schedule_json);
-							if (schedule.cron) job.cronSchedule = schedule.cron;
-						} catch {}
-						if (row.status === "completed" || row.status === "failed") job.completedAt = row.updated_at;
-						return job;
-					})
+					kind: "sql.write.result",
+					rowsAffected: result.changes,
+					invalidationScopes: [...analysis.observedScopes]
 				};
-			} catch {
+			} catch (error) {
 				return {
-					kind: "scheduler.list.result",
-					jobs: []
+					kind: "sql.write.result",
+					rowsAffected: 0,
+					invalidationScopes: [],
+					error: error instanceof Error ? error.message : String(error)
 				};
 			}
 			case "scheduler.cancel": try {
-				await driver.run(`UPDATE "_scheduled_functions" SET status = 'cancelled', updated_at = ? WHERE id = ? AND status = 'scheduled'`, [Date.now(), payload.jobId]);
 				return {
 					kind: "scheduler.cancel.result",
-					success: true
+					success: true,
+					cancelled: await runtime.cancelScheduledJob(payload.jobId)
 				};
-			} catch (err) {
+			} catch (error) {
 				return {
 					kind: "scheduler.cancel.result",
 					success: false,
-					error: err instanceof Error ? err.message : String(err)
+					cancelled: false,
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
+			case "scheduler.update": try {
+				const updated = await runtime.updateScheduledJob({
+					id: payload.jobId,
+					schedule: payload.schedule,
+					args: payload.args,
+					misfirePolicy: payload.misfirePolicy,
+					...payload.runAt !== void 0 ? { runAt: payload.runAt } : {}
+				});
+				const updatedJob = (updated ? await listSchedulerJobs(driver) : []).find((job) => job.id === payload.jobId);
+				return {
+					kind: "scheduler.update.result",
+					success: true,
+					updated,
+					...updated && updatedJob ? { job: updatedJob } : {}
+				};
+			} catch (error) {
+				return {
+					kind: "scheduler.update.result",
+					success: false,
+					updated: false,
+					error: error instanceof Error ? error.message : String(error)
 				};
 			}
 			default: return {
 				kind: "error",
-				message: `Unknown request kind: ${payload.kind}`
+				message: `Unknown devtools command: ${payload.kind}`
+			};
+		}
+	};
+}
+function createDevtoolsSubscriptionHost(deps) {
+	const { driver, schema, functions, runtime } = deps;
+	const subscriptions = /* @__PURE__ */ new Map();
+	const emit = async (payload, listener) => {
+		listener(await resolveSubscriptionPayload(payload, {
+			driver,
+			schema,
+			functions,
+			runtime,
+			...deps.sql ? { sql: deps.sql } : {}
+		}));
+	};
+	const handleInvalidation = async (scopes) => {
+		for (const record of subscriptions.values()) {
+			if (!intersects(scopes, record.scopes)) continue;
+			await emit(record.payload, record.listener);
+		}
+	};
+	return {
+		async subscribe(subscriptionId, payload, listener) {
+			if (payload.kind === "fn.watch") {
+				const definition = functions[payload.functionName];
+				if (!definition || definition.kind !== "query") {
+					listener({
+						kind: "fn.watch.result",
+						error: `Unknown query function: ${payload.functionName}`
+					});
+					return;
+				}
+				const watch = runtime.createClient().watchQuery(createFunctionReference("query", payload.functionName), payload.args);
+				const emitWatchResult = () => {
+					const error = watch.localQueryError();
+					listener({
+						kind: "fn.watch.result",
+						...error ? { error: error.message } : { result: watch.localQueryResult() }
+					});
+				};
+				const unsubscribeUpdates = watch.onUpdate(emitWatchResult);
+				subscriptions.set(subscriptionId, {
+					payload,
+					listener,
+					unsubscribeRuntime: () => {
+						unsubscribeUpdates();
+						watch.dispose?.();
+					},
+					scopes: new Set(["all"])
+				});
+				emitWatchResult();
+				return;
+			}
+			const unsubscribeRuntime = runtime.subscribeToDevtoolsInvalidations((scopes) => {
+				handleInvalidation(scopes);
+			});
+			const unsubscribeEvents = runtime.subscribeToDevtoolsEvents((event) => {
+				if (event.type === "runtime.disconnected") emit(payload, listener);
+			});
+			subscriptions.set(subscriptionId, {
+				payload,
+				listener,
+				unsubscribeRuntime: () => {
+					unsubscribeRuntime();
+					unsubscribeEvents();
+				},
+				scopes: scopesForSubscription(payload, deps.sql)
+			});
+			await emit(payload, listener);
+		},
+		unsubscribe(subscriptionId) {
+			const record = subscriptions.get(subscriptionId);
+			if (!record) return;
+			record.unsubscribeRuntime();
+			subscriptions.delete(subscriptionId);
+		},
+		dispose() {
+			for (const [subscriptionId, record] of subscriptions) {
+				record.unsubscribeRuntime();
+				subscriptions.delete(subscriptionId);
+			}
+		}
+	};
+}
+async function resolveSubscriptionPayload(payload, deps) {
+	const { driver, schema, functions, runtime } = deps;
+	await runtime.prepareForDirectAccess();
+	switch (payload.kind) {
+		case "runtime.summary": return {
+			kind: "runtime.summary.result",
+			summary: runtime.getRuntimeSummary()
+		};
+		case "runtime.activeQueries": return {
+			kind: "runtime.activeQueries.result",
+			activeQueries: runtime.getActiveQueryInfos()
+		};
+		case "fn.watch": throw new Error("Function watches are pushed incrementally and have no snapshot payload.");
+		case "schema.tables": {
+			const tables = await getSchemaTables(driver, schema);
+			console.debug("[devtools] schema.tables", {
+				runtimeId: runtime.getRuntimeId(),
+				tables: tables.map((table) => ({
+					name: table.name,
+					documentCount: table.documentCount
+				}))
+			});
+			return {
+				kind: "schema.tables.result",
+				tables
+			};
+		}
+		case "data.table": {
+			const result = await queryTable(driver, payload.table, payload.filters, payload.limit);
+			console.debug("[devtools] data.table", {
+				runtimeId: runtime.getRuntimeId(),
+				table: payload.table,
+				filters: payload.filters ?? [],
+				limit: payload.limit,
+				totalCount: result.totalCount,
+				rowCount: result.rows.length,
+				firstRow: result.rows[0] ?? null
+			});
+			return {
+				kind: "data.table.result",
+				rows: result.rows,
+				totalCount: result.totalCount,
+				...result.cursor ? { cursor: result.cursor } : {}
+			};
+		}
+		case "scheduler.jobs": return {
+			kind: "scheduler.jobs.result",
+			jobs: await listSchedulerJobs(driver)
+		};
+		case "functions.catalog": return {
+			kind: "functions.catalog.result",
+			functions: listFunctions(functions)
+		};
+		case "sql.watch": {
+			const sqlSupport = requireDevtoolsSqlSupport(deps.sql);
+			const databasePath = runtime.getDriverDatabasePath();
+			if (!databasePath) throw new Error("SQL Live requires a file-backed database path.");
+			const { columns, rows, observedTables } = sqlSupport.runReadonlyQuery(databasePath, payload.query);
+			return {
+				kind: "sql.watch.result",
+				columns,
+				rows,
+				observedTables
 			};
 		}
+	}
+}
+async function queryTable(driver, table, filters, limit) {
+	let sql = `SELECT _id, _creationTime, _json FROM "${table}"`;
+	const params = [];
+	if (filters && filters.length > 0) sql += ` WHERE ${filters.map((filter) => {
+		params.push(normalizeFilterValue(filter));
+		return `json_extract(_json, '$.${filter.field}') ${filterOperatorToSql(filter.operator)} ?`;
+	}).join(" AND ")}`;
+	sql += " ORDER BY _creationTime DESC";
+	if (limit) sql += ` LIMIT ${limit}`;
+	return {
+		rows: (await driver.all(sql, params)).map((row) => ({
+			_id: row._id,
+			_creationTime: row._creationTime,
+			...JSON.parse(row._json)
+		})),
+		totalCount: (await driver.get(`SELECT COUNT(*) as count FROM "${table}"`))?.count ?? 0
 	};
 }
+async function getSchemaTables(driver, schema) {
+	return Promise.all(schema.tableNames().map(async (name) => {
+		const table = schema.getTable(name);
+		const validatorDesc = describeValidator(table.validator);
+		const fields = validatorDesc.kind === "object" ? Object.entries(validatorDesc.shape).map(([fieldName, fieldDesc]) => {
+			const desc = fieldDesc;
+			const optional = desc.kind === "optional";
+			return {
+				name: fieldName,
+				type: optional ? desc.inner?.kind ?? "any" : desc.kind,
+				optional
+			};
+		}) : [];
+		fields.unshift({
+			name: "_id",
+			type: "string",
+			optional: false
+		}, {
+			name: "_creationTime",
+			type: "number",
+			optional: false
+		});
+		let documentCount = 0;
+		try {
+			documentCount = (await driver.get(`SELECT COUNT(*) as count FROM "${name}"`))?.count ?? 0;
+		} catch {
+			documentCount = 0;
+		}
+		return {
+			name,
+			fields,
+			indexes: table.indexes.map((index) => ({
+				name: index.name,
+				fields: index.fields,
+				unique: false
+			})),
+			documentCount
+		};
+	}));
+}
+async function listSchedulerJobs(driver) {
+	try {
+		return (await driver.all(`SELECT * FROM "_scheduled_functions" ORDER BY run_at DESC LIMIT 200`)).map((row) => {
+			const schedule = safeReadSchedule(row.schedule_json);
+			const scheduleLabel = schedule ? formatScheduleLabel(schedule) : void 0;
+			return {
+				id: row.id,
+				functionName: row.function_name,
+				args: JSON.parse(row.args_json),
+				scheduledAt: row.created_at,
+				runAt: row.run_at,
+				status: mapJobStatus(row.status),
+				...row.status === "completed" || row.status === "failed" ? { completedAt: row.updated_at } : {},
+				...row.recurring_name ? { recurringName: row.recurring_name } : {},
+				...schedule ? { schedule } : {},
+				...scheduleLabel ? {
+					scheduleLabel,
+					cronSchedule: scheduleLabel
+				} : {},
+				...row.timezone ? { timezone: row.timezone } : {},
+				...row.last_run_at !== null ? { lastRunAt: row.last_run_at } : {},
+				...row.updated_at ? { updatedAt: row.updated_at } : {},
+				misfirePolicy: readMisfirePolicy(row.misfire_policy, row.window_ms)
+			};
+		});
+	} catch {
+		return [];
+	}
+}
+function listFunctions(functions) {
+	return Object.entries(functions).filter((entry) => entry[1] !== void 0).map(([name, fn]) => {
+		const descriptor = {
+			name,
+			type: fn.kind,
+			file: inferFileFromFunctionName(name)
+		};
+		const argsDesc = describeValidator(fn.argsValidator);
+		if (argsDesc.kind === "object") descriptor.args = argsDesc.shape;
+		return descriptor;
+	});
+}
 function inferFileFromFunctionName(name) {
 	const parts = name.split(":");
-	if (parts.length > 1) return parts[0] + ".ts";
+	if (parts.length > 1) return `${parts[0]}.ts`;
 	return "unknown";
 }
 function normalizeFilterValue(filter) {
@@ -265,15 +420,15 @@ function normalizeFilterValue(filter) {
 		default: return filter.value;
 	}
 }
-function filterOperatorToSql(op) {
-	switch (op) {
+function filterOperatorToSql(operator) {
+	switch (operator) {
 		case "eq": return "=";
 		case "neq": return "!=";
 		case "gt": return ">";
 		case "gte": return ">=";
 		case "lt": return "<";
 		case "lte": return "<=";
-		case "contains": return "LIKE";
+		case "contains":
 		case "startsWith": return "LIKE";
 		default: return "=";
 	}
@@ -288,13 +443,73 @@ function mapJobStatus(status) {
 		default: return "pending";
 	}
 }
-function generateId() {
-	const chars = "0123456789abcdefghijklmnopqrstuvwxyz";
-	let id = "";
-	for (let i = 0; i < 24; i++) id += chars[Math.floor(Math.random() * 36)];
-	return id;
+function safeReadSchedule(scheduleJson) {
+	if (!scheduleJson) return;
+	try {
+		return JSON.parse(scheduleJson);
+	} catch {
+		return;
+	}
+}
+function formatScheduleLabel(schedule) {
+	switch (schedule.type) {
+		case "interval": {
+			const parts = [];
+			if (schedule.hours) parts.push(`${schedule.hours}h`);
+			if (schedule.minutes) parts.push(`${schedule.minutes}m`);
+			if (schedule.seconds) parts.push(`${schedule.seconds}s`);
+			return parts.length > 0 ? `Every ${parts.join(" ")}` : "Recurring";
+		}
+		case "daily": return `Daily ${padNumber(schedule.hour)}:${padNumber(schedule.minute)}${schedule.timezone ? ` ${schedule.timezone}` : ""}`;
+		case "weekly": return `Weekly ${capitalize(schedule.dayOfWeek)} ${padNumber(schedule.hour)}:${padNumber(schedule.minute)}${schedule.timezone ? ` ${schedule.timezone}` : ""}`;
+	}
+}
+function readMisfirePolicy(type, windowMs) {
+	if (type === "windowed") return {
+		type,
+		windowMs: windowMs ?? 0
+	};
+	if (type === "skip" || type === "run_once_if_missed") return { type };
+	return { type: "catch_up" };
+}
+function padNumber(value) {
+	return String(value).padStart(2, "0");
+}
+function capitalize(value) {
+	return value.slice(0, 1).toUpperCase() + value.slice(1);
+}
+async function runDevtoolsMutation(runtime, callback, meta) {
+	return runtime.runDevtoolsMutation(callback, meta);
+}
+function scopesForSubscription(payload, sql) {
+	switch (payload.kind) {
+		case "runtime.summary": return new Set(["runtime.summary"]);
+		case "runtime.activeQueries": return new Set(["runtime.activeQueries"]);
+		case "fn.watch": return new Set(["all"]);
+		case "schema.tables": return new Set(["schema.tables"]);
+		case "data.table": return new Set([`table:${payload.table}`]);
+		case "scheduler.jobs": return new Set(["scheduler.jobs"]);
+		case "functions.catalog": return new Set(["all"]);
+		case "sql.watch": try {
+			const sqlSupport = requireDevtoolsSqlSupport(sql);
+			const analysis = sqlSupport.analyzeSqlStatement(payload.query);
+			sqlSupport.ensureSqlMode(analysis, "watch");
+			return new Set(analysis.observedScopes);
+		} catch {
+			return new Set(["all"]);
+		}
+	}
+}
+function intersects(a, b) {
+	if (a.has("all") || b.has("all")) return true;
+	for (const value of a) if (b.has(value)) return true;
+	return false;
+}
+function requireDevtoolsSqlSupport(sql) {
+	if (!sql) throw new Error("SQL devtools are only available in Node-hosted runtimes.");
+	return sql;
 }
 //#endregion
-export { createDevtoolsRequestHandler };
+export { createDevtoolsCommandHandler, createDevtoolsSubscriptionHost };
 
 //# sourceMappingURL=devtools.mjs.map