syncorejs 0.2.1 → 0.2.3

package/dist/_vendor/platform-node/index.mjs

@@ -1,105 +1,43 @@
 import { SyncoreRendererClient, attachNodeIpcRuntime, createNodeIpcMessageEndpoint, createRendererSyncoreBridgeClient, createRendererSyncoreClient, createRendererSyncoreWindowClient, installSyncoreWindowBridge } from "./ipc.mjs";
-import { createRequire } from "node:module";
 import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import WebSocket from "ws";
+import { SYNCORE_DEVTOOLS_MAX_SUPPORTED_PROTOCOL_VERSION, SYNCORE_DEVTOOLS_MIN_SUPPORTED_PROTOCOL_VERSION, SYNCORE_DEVTOOLS_PROTOCOL_VERSION } from "../devtools-protocol/index.js";
 import { SyncoreRuntime, createDevtoolsCommandHandler, createDevtoolsSubscriptionHost } from "../core/index.mjs";
 //#region src/index.ts
-const { Parser: NodeSqlParser } = createRequire(import.meta.url)("node-sql-parser");
-const nodeSqlParser = new NodeSqlParser();
-const nodeDevtoolsSqlSupport = {
-	analyzeSqlStatement(query) {
-		const ast = nodeSqlParser.astify(query, { database: "sqlite" });
-		if (Array.isArray(ast)) throw new Error("Only a single SQL statement is supported.");
-		switch (ast.type) {
-			case "select": return buildReadAnalysis(ast);
-			case "update":
-			case "delete":
-			case "insert":
-			case "replace": return buildWriteAnalysis(extractTables(ast.table), false);
-			case "create":
-			case "drop":
-			case "alter": return buildWriteAnalysis(extractTables(ast.table), true);
-			default: throw new Error(`Unsupported SQL statement type: ${String(ast.type)}`);
-		}
-	},
-	ensureSqlMode(analysis, expected) {
-		if (expected === "watch") {
-			if (analysis.mode !== "read") throw new Error("Live mode supports read-only SQL only.");
-			return;
-		}
-		if (analysis.mode !== expected) {
-			if (expected === "read") throw new Error("Use SQL Write for mutating statements.");
-			throw new Error("Use SQL Read or SQL Live for read-only statements.");
-		}
-	},
-	runReadonlyQuery(databasePath, query) {
-		const analysis = this.analyzeSqlStatement(query);
-		this.ensureSqlMode(analysis, "read");
-		const database = new DatabaseSync(databasePath, { readOnly: true });
-		try {
-			const statement = database.prepare(query);
-			const rows = statement.all();
-			const columnsMeta = statement.columns();
-			const columns = columnsMeta.map((column) => column.name);
-			const observedTables = Array.from(new Set(columnsMeta.map((column) => column.table).filter((table) => typeof table === "string")));
-			return {
-				columns,
-				rows: rows.map((row) => columns.map((column) => row[column])),
-				observedTables: observedTables.length > 0 ? observedTables : analysis.readTables
-			};
-		} finally {
-			database.close();
-		}
-	}
-};
+const DEVTOOLS_META_DIRECTORY = ".syncore-devtools";
+const DATA_SOURCE_ALIAS_PREFIX = "data-source-alias";
 function normalizeData(input) {
 	if (typeof input === "string") return Buffer.from(input);
 	if (input instanceof Uint8Array) return input;
 	return new Uint8Array(input);
 }
-function buildReadAnalysis(ast) {
-	const readTables = Array.from(new Set(extractReadTables(ast)));
-	return {
-		mode: "read",
-		readTables,
-		writeTables: [],
-		schemaChanged: false,
-		observedScopes: readTables.length > 0 ? readTables.map((table) => `table:${table}`) : ["all"]
-	};
-}
-function buildWriteAnalysis(tables, schemaChanged) {
-	const uniqueTables = Array.from(new Set(tables));
-	return {
-		mode: schemaChanged ? "ddl" : "write",
-		readTables: [],
-		writeTables: uniqueTables,
-		schemaChanged,
-		observedScopes: schemaChanged ? ["schema.tables", ...uniqueTables.map((table) => `table:${table}`)] : uniqueTables.length > 0 ? uniqueTables.map((table) => `table:${table}`) : ["all"]
-	};
-}
-function extractReadTables(ast) {
-	return (ast.from ?? []).flatMap((entry) => {
-		if (entry.table) return [entry.table];
-		if (entry.expr?.ast) return extractReadTables(entry.expr.ast);
-		return [];
-	}).filter((table) => table !== "dual");
-}
-function extractTables(table) {
-	if (Array.isArray(table)) return table.map((entry) => entry?.table).filter((value) => typeof value === "string");
-	if (table && typeof table === "object") return typeof table.table === "string" ? [table.table] : [];
-	if (typeof table === "string") return [table];
-	return [];
-}
 function toSqlParameters(params) {
 	return params;
 }
+/**
+* SQLite driver backed by Node.js’s built-in `node:sqlite` module (Node 22+).
+*
+* Opens the database at `databasePath` with `WAL` journal mode and foreign-key
+* enforcement enabled. The file is created if it does not exist.
+*
+* ```ts
+* const driver = new NodeSqliteDriver("./data/app.db");
+* ```
+*
+* In most cases you should use {@link createNodeSyncoreRuntime} which
+* instantiates this driver automatically from your `databasePath` option.
+*/
 var NodeSqliteDriver = class {
+	databasePath;
 	database;
 	transactionDepth = 0;
-	constructor(filename) {
-		this.database = new DatabaseSync(filename);
+	constructor(databasePath) {
+		this.databasePath = databasePath;
+		this.database = new DatabaseSync(databasePath);
 		this.database.exec("PRAGMA foreign_keys = ON;");
 		this.database.exec("PRAGMA journal_mode = WAL;");
 	}
@@ -151,7 +89,21 @@ var NodeSqliteDriver = class {
 		this.database.close();
 	}
 };
+/**
+* Blob storage adapter that reads and writes files in a local directory.
+*
+* Each stored object is saved as a flat file named by its ID inside
+* `directory`. The directory is created automatically on first write.
+*
+* ```ts
+* const storage = new NodeFileStorageAdapter("./data/storage");
+* ```
+*
+* In most cases you should use {@link createNodeSyncoreRuntime} which
+* instantiates this adapter automatically from your `storageDirectory` option.
+*/
 var NodeFileStorageAdapter = class {
+	directory;
 	constructor(directory) {
 		this.directory = directory;
 	}
@@ -211,11 +163,137 @@ var NodeFileStorageAdapter = class {
 		}
 	}
 };
+const SESSION_ADJECTIVES = [
+	"Acrobatic",
+	"Bold",
+	"Cosmic",
+	"Daring",
+	"Electric",
+	"Fierce",
+	"Golden",
+	"Hidden",
+	"Iron",
+	"Jade",
+	"Keen",
+	"Lunar",
+	"Mystic",
+	"Noble",
+	"Orbital",
+	"Primal",
+	"Quick",
+	"Radiant",
+	"Shadow",
+	"Turbo",
+	"Ultra",
+	"Vivid",
+	"Wicked",
+	"Xenon",
+	"Zen",
+	"Arctic",
+	"Binary",
+	"Cyber",
+	"Digital",
+	"Ember",
+	"Frozen",
+	"Galactic",
+	"Hyper",
+	"Infra",
+	"Jumbo",
+	"Kinetic",
+	"Liquid",
+	"Magnetic",
+	"Neon",
+	"Onyx",
+	"Phantom",
+	"Quantum",
+	"Rapid",
+	"Sonic",
+	"Titan",
+	"Velvet",
+	"Wild",
+	"Blazing",
+	"Crystal",
+	"Dynamic"
+];
+const SESSION_NOUNS = [
+	"Phoenix",
+	"Dragon",
+	"Developer",
+	"Hacker",
+	"Wizard",
+	"Runner",
+	"Ranger",
+	"Maverick",
+	"Spartan",
+	"Viking",
+	"Sentinel",
+	"Guardian",
+	"Nomad",
+	"Cipher",
+	"Vector",
+	"Matrix",
+	"Prism",
+	"Nebula",
+	"Comet",
+	"Pulse",
+	"Vertex",
+	"Flux",
+	"Storm",
+	"Blaze",
+	"Frost",
+	"Thunder",
+	"Drift"
+];
+function generateUniqueSessionName() {
+	return `${SESSION_ADJECTIVES[Math.floor(Math.random() * SESSION_ADJECTIVES.length)]} ${SESSION_NOUNS[Math.floor(Math.random() * SESSION_NOUNS.length)]}`;
+}
+function resolvePersistedDataSourceAlias(storageDirectory, storageIdentity) {
+	const metaDirectory = path.join(storageDirectory, DEVTOOLS_META_DIRECTORY);
+	const aliasId = createHash("sha256").update(storageIdentity).digest("hex").slice(0, 16);
+	const aliasPath = path.join(metaDirectory, `${DATA_SOURCE_ALIAS_PREFIX}-${aliasId}.txt`);
+	try {
+		const existing = readFileSync(aliasPath, "utf8").trim();
+		if (existing.length > 0) return existing;
+	} catch {}
+	const nextValue = generateUniqueSessionName();
+	try {
+		mkdirSync(metaDirectory, { recursive: true });
+		writeFileSync(aliasPath, nextValue, "utf8");
+	} catch {}
+	return nextValue;
+}
 /**
-* Create a Node or Electron runtime backed by SQLite and local file storage.
+* Create a Syncore runtime for Node.js (or Electron’s main process) backed by
+* the built-in `node:sqlite` driver and local file storage.
+*
+* This is the recommended entry point for Node and Electron apps. It wires up
+* the SQL driver, storage adapter, devtools WebSocket connection, and
+* cross-process change signals automatically.
+*
+* ```ts
+* import path from "node:path";
+* import { createNodeSyncoreRuntime } from "syncorejs/node";
+* import schema from "./syncore/schema";
+* import { functions } from "./syncore/_generated/functions";
+*
+* const runtime = createNodeSyncoreRuntime({
+*   databasePath: path.join(app.getPath("userData"), "db.sqlite"),
+*   storageDirectory: path.join(app.getPath("userData"), "storage"),
+*   schema,
+*   functions,
+* });
+*
+* await runtime.start();
+* const client = runtime.createClient();
+* ```
+*
+* @param options - Configuration object. See {@link CreateNodeRuntimeOptions}.
+* @returns A configured (but not yet started) {@link SyncoreRuntime}. Call
+*   `await runtime.start()` before using the client.
 */
 function createNodeSyncoreRuntime(options) {
 	const resolvedDevtoolsUrl = options.devtoolsUrl ?? resolveDefaultNodeDevtoolsUrl();
+	const storageIdentity = `file::${path.resolve(options.databasePath)}`;
 	const websocketDevtools = options.devtools === void 0 && resolvedDevtoolsUrl && shouldAutoConnectNodeDevtools() ? createNodeWebSocketDevtoolsSink({
 		url: resolvedDevtoolsUrl,
 		...options.appName ? { appName: options.appName } : {},
@@ -224,19 +302,23 @@ function createNodeSyncoreRuntime(options) {
 		targetKind: "client",
 		storageProtocol: "file",
 		databaseLabel: path.basename(options.databasePath),
-		storageIdentity: `file::${path.resolve(options.databasePath)}`
+		dataSourceAlias: resolvePersistedDataSourceAlias(options.storageDirectory, storageIdentity),
+		storageIdentity,
+		runtimeRole: "app",
+		capabilities: createNodeDevtoolsCapabilities()
 	}) : void 0;
 	const runtimeOptions = {
 		schema: options.schema,
 		functions: options.functions,
+		...options.components ? { components: options.components } : {},
 		driver: new NodeSqliteDriver(options.databasePath),
 		storage: new NodeFileStorageAdapter(options.storageDirectory),
 		platform: options.platform ?? "node"
 	};
 	if (options.capabilities) runtimeOptions.capabilities = options.capabilities;
-	if (options.experimentalPlugins) runtimeOptions.experimentalPlugins = options.experimentalPlugins;
 	const resolvedDevtools = options.devtools === false ? void 0 : options.devtools ?? websocketDevtools;
 	if (resolvedDevtools) runtimeOptions.devtools = resolvedDevtools;
+	if (websocketDevtools?.externalChangeSignal) runtimeOptions.externalChangeSignal = websocketDevtools.externalChangeSignal;
 	if (options.scheduler) runtimeOptions.scheduler = options.scheduler;
 	const runtime = new SyncoreRuntime(runtimeOptions);
 	websocketDevtools?.attachRuntime(runtime);
@@ -245,15 +327,13 @@ function createNodeSyncoreRuntime(options) {
 			driver: runtimeOptions.driver,
 			schema: options.schema,
 			functions: options.functions,
-			runtime,
-			sql: nodeDevtoolsSqlSupport
+			admin: runtime.getAdmin()
 		}));
 		websocketDevtools.attachSubscriptionHost(createDevtoolsSubscriptionHost({
 			driver: runtimeOptions.driver,
 			schema: options.schema,
 			functions: options.functions,
-			runtime,
-			sql: nodeDevtoolsSqlSupport
+			admin: runtime.getAdmin()
 		}));
 		const stop = runtime.stop.bind(runtime);
 		runtime.stop = async () => {
@@ -323,7 +403,8 @@ function bindElectronWindowToSyncoreRuntime(options) {
 	if (!options.onRendererMessage) {
 		if (!options.ipcMain) throw new Error("bindElectronWindowToSyncoreRuntime requires either onRendererMessage() or ipcMain.");
 		const listeners = /* @__PURE__ */ new Set();
-		const handleRendererMessage = (_event, message) => {
+		const handleRendererMessage = (event, message) => {
+			if (event.sender !== options.window.webContents) return;
 			for (const listener of listeners) listener(message);
 		};
 		options.ipcMain.on(channel, handleRendererMessage);
@@ -361,6 +442,7 @@ function createNodeWebSocketDevtoolsSink(options) {
 	let getSummary;
 	let onCommand;
 	let subscriptionHost;
+	const externalChangeListeners = /* @__PURE__ */ new Set();
 	const pendingMessages = [];
 	let latestHello;
 	const connect = () => {
@@ -369,15 +451,21 @@ function createNodeWebSocketDevtoolsSink(options) {
 		socket.on("open", () => {
 			if (latestHello) sendNow({
 				type: "hello",
+				protocolVersion: SYNCORE_DEVTOOLS_PROTOCOL_VERSION,
+				minSupportedProtocolVersion: SYNCORE_DEVTOOLS_MIN_SUPPORTED_PROTOCOL_VERSION,
+				maxSupportedProtocolVersion: SYNCORE_DEVTOOLS_MAX_SUPPORTED_PROTOCOL_VERSION,
 				runtimeId: latestHello.runtimeId,
 				platform: latestHello.platform,
 				...options.appName ? { appName: options.appName } : {},
 				...options.origin ? { origin: options.origin } : {},
 				...options.sessionLabel ? { sessionLabel: options.sessionLabel } : {},
 				...options.targetKind ? { targetKind: options.targetKind } : {},
+				...options.runtimeRole ? { runtimeRole: options.runtimeRole } : {},
 				...options.storageProtocol ? { storageProtocol: options.storageProtocol } : {},
 				...options.databaseLabel ? { databaseLabel: options.databaseLabel } : {},
-				...options.storageIdentity ? { storageIdentity: options.storageIdentity } : {}
+				...options.dataSourceAlias ? { dataSourceAlias: options.dataSourceAlias } : {},
+				...options.storageIdentity ? { storageIdentity: options.storageIdentity } : {},
+				capabilities: options.capabilities ?? createNodeDevtoolsCapabilities()
 			});
 			flushPendingMessages();
 		});
@@ -386,6 +474,7 @@ function createNodeWebSocketDevtoolsSink(options) {
 			if (rawPayload.length === 0) return;
 			const message = JSON.parse(rawPayload);
 			if (message.type === "ping") send({ type: "pong" });
+			else if (message.type === "external.change") for (const listener of externalChangeListeners) listener(message.event);
 			else if (message.type === "command" && onCommand) onCommand(message.payload).then((responsePayload) => {
 				const runtimeId = latestHello?.runtimeId ?? getSummary?.().runtimeId;
 				if (!runtimeId) return;
@@ -448,7 +537,7 @@ function createNodeWebSocketDevtoolsSink(options) {
 		pendingMessages.push(message);
 	};
 	connect();
-	return {
+	const sink = {
 		emit(event) {
 			if (event.type === "runtime.connected") {
 				latestHello = {
@@ -457,15 +546,21 @@ function createNodeWebSocketDevtoolsSink(options) {
 				};
 				send({
 					type: "hello",
+					protocolVersion: SYNCORE_DEVTOOLS_PROTOCOL_VERSION,
+					minSupportedProtocolVersion: SYNCORE_DEVTOOLS_MIN_SUPPORTED_PROTOCOL_VERSION,
+					maxSupportedProtocolVersion: SYNCORE_DEVTOOLS_MAX_SUPPORTED_PROTOCOL_VERSION,
 					runtimeId: event.runtimeId,
 					platform: event.platform,
 					...options.appName ? { appName: options.appName } : {},
 					...options.origin ? { origin: options.origin } : {},
 					...options.sessionLabel ? { sessionLabel: options.sessionLabel } : {},
 					...options.targetKind ? { targetKind: options.targetKind } : {},
+					...options.runtimeRole ? { runtimeRole: options.runtimeRole } : {},
 					...options.storageProtocol ? { storageProtocol: options.storageProtocol } : {},
 					...options.databaseLabel ? { databaseLabel: options.databaseLabel } : {},
-					...options.storageIdentity ? { storageIdentity: options.storageIdentity } : {}
+					...options.dataSourceAlias ? { dataSourceAlias: options.dataSourceAlias } : {},
+					...options.storageIdentity ? { storageIdentity: options.storageIdentity } : {},
+					capabilities: options.capabilities ?? createNodeDevtoolsCapabilities()
 				});
 			}
 			send({
@@ -474,7 +569,7 @@ function createNodeWebSocketDevtoolsSink(options) {
 			});
 		},
 		attachRuntime(runtime) {
-			getSummary = () => withRuntimeSummaryMeta(runtime.getRuntimeSummary(), options);
+			getSummary = () => withRuntimeSummaryMeta(runtime.getAdmin().getRuntimeSummary(), options);
 		},
 		attachCommandHandler(handler) {
 			onCommand = handler;
@@ -489,6 +584,28 @@ function createNodeWebSocketDevtoolsSink(options) {
 			socket?.close();
 		}
 	};
+	if (options.storageIdentity) sink.externalChangeSignal = {
+		subscribe(listener) {
+			externalChangeListeners.add(listener);
+			return () => {
+				externalChangeListeners.delete(listener);
+			};
+		},
+		publish(event) {
+			const runtimeId = latestHello?.runtimeId ?? getSummary?.().runtimeId;
+			if (!runtimeId) return;
+			send({
+				type: "external.change",
+				runtimeId,
+				storageIdentity: options.storageIdentity,
+				event
+			});
+		},
+		close() {
+			externalChangeListeners.clear();
+		}
+	};
+	return sink;
 }
 function withRuntimeSummaryMeta(summary, options) {
 	return {
@@ -497,9 +614,31 @@ function withRuntimeSummaryMeta(summary, options) {
 		...options.origin ? { origin: options.origin } : {},
 		...options.sessionLabel ? { sessionLabel: options.sessionLabel } : {},
 		...options.targetKind ? { targetKind: options.targetKind } : {},
+		...options.runtimeRole ? { runtimeRole: options.runtimeRole } : {},
 		...options.storageProtocol ? { storageProtocol: options.storageProtocol } : {},
 		...options.databaseLabel ? { databaseLabel: options.databaseLabel } : {},
-		...options.storageIdentity ? { storageIdentity: options.storageIdentity } : {}
+		...options.dataSourceAlias ? { dataSourceAlias: options.dataSourceAlias } : {},
+		...options.storageIdentity ? { storageIdentity: options.storageIdentity } : {},
+		capabilities: options.capabilities ?? createNodeDevtoolsCapabilities()
+	};
+}
+function createNodeDevtoolsCapabilities() {
+	return {
+		sql: {
+			read: false,
+			write: false,
+			live: false,
+			reason: "SQL Console is provided by the Project Target for this data source."
+		},
+		data: {
+			browse: true,
+			mutate: true,
+			importExport: true
+		},
+		scheduler: {
+			read: true,
+			edit: true
+		}
 	};
 }
 function shouldAutoConnectNodeDevtools() {