@rivetkit/rivetkit-native 0.0.0-pr.4614.822b57f → 0.0.0-pr.4646.1725d01

package/index.d.ts

@@ -27,7 +27,6 @@ export interface JsEnvoyConfig {
   poolName: string
   version: number
   metadata?: any
-  notGlobal: boolean
   /**
    * Log level for the Rust tracing subscriber (e.g. "trace", "debug", "info", "warn", "error").
    * Falls back to RIVET_LOG_LEVEL, then LOG_LEVEL, then RUST_LOG env vars. Defaults to "warn".

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rivetkit/rivetkit-native",
-	"version": "0.0.0-pr.4614.822b57f",
+	"version": "0.0.0-pr.4646.1725d01",
 	"description": "Native N-API addon for RivetKit providing envoy client and SQLite access",
 	"license": "Apache-2.0",
 	"main": "index.js",
@@ -49,15 +49,15 @@
 	},
 	"dependencies": {
 		"@napi-rs/cli": "^2.18.4",
-		"@rivetkit/engine-envoy-protocol": "0.0.0-pr.4614.822b57f"
+		"@rivetkit/engine-envoy-protocol": "0.0.0-pr.4646.1725d01"
 	},
 	"optionalDependencies": {
-		"@rivetkit/rivetkit-native-darwin-arm64": "0.0.0-pr.4614.822b57f",
-		"@rivetkit/rivetkit-native-darwin-x64": "0.0.0-pr.4614.822b57f",
-		"@rivetkit/rivetkit-native-linux-arm64-gnu": "0.0.0-pr.4614.822b57f",
-		"@rivetkit/rivetkit-native-linux-arm64-musl": "0.0.0-pr.4614.822b57f",
-		"@rivetkit/rivetkit-native-linux-x64-gnu": "0.0.0-pr.4614.822b57f",
-		"@rivetkit/rivetkit-native-linux-x64-musl": "0.0.0-pr.4614.822b57f",
-		"@rivetkit/rivetkit-native-win32-x64-msvc": "0.0.0-pr.4614.822b57f"
+		"@rivetkit/rivetkit-native-darwin-arm64": "0.0.0-pr.4646.1725d01",
+		"@rivetkit/rivetkit-native-darwin-x64": "0.0.0-pr.4646.1725d01",
+		"@rivetkit/rivetkit-native-linux-arm64-gnu": "0.0.0-pr.4646.1725d01",
+		"@rivetkit/rivetkit-native-linux-arm64-musl": "0.0.0-pr.4646.1725d01",
+		"@rivetkit/rivetkit-native-linux-x64-gnu": "0.0.0-pr.4646.1725d01",
+		"@rivetkit/rivetkit-native-linux-x64-musl": "0.0.0-pr.4646.1725d01",
+		"@rivetkit/rivetkit-native-win32-x64-msvc": "0.0.0-pr.4646.1725d01"
 	}
 }

package/wrapper.d.ts

@@ -136,4 +136,9 @@ export interface NativeRawDatabase {
 	close: () => Promise<void>;
 }
 
+export declare function openRawDatabaseFromEnvoy(
+	handle: EnvoyHandle,
+	actorId: string,
+): Promise<NativeRawDatabase>;
+
 export declare const utils: {};

package/wrapper.js

@@ -8,6 +8,18 @@
 
 const native = require("./index");
 
+// CloseEvent was added to Node.js in v22. Polyfill for older versions.
+if (typeof CloseEvent === "undefined") {
+	global.CloseEvent = class CloseEvent extends Event {
+		constructor(type, init = {}) {
+			super(type);
+			this.code = init.code ?? 0;
+			this.reason = init.reason ?? "";
+			this.wasClean = init.wasClean ?? false;
+		}
+	};
+}
+
 // Re-export protocol for consumers that need protocol types at runtime
 let _protocol;
 try {
@@ -99,9 +111,8 @@ function wrapHandle(jsHandle) {
 				Buffer.from(requestId),
 				clientMessageIndex,
 			),
-		startServerlessActor: (payload) => {
-			jsHandle.startServerless(Buffer.from(payload));
-		},
+		startServerlessActor: async (payload) =>
+			await jsHandle.startServerless(Buffer.from(payload)),
 		// Internal: expose raw handle for openDatabaseFromEnvoy
 		_raw: jsHandle,
 	};
@@ -123,7 +134,7 @@ function startEnvoySync(config) {
 			poolName: config.poolName,
 			version: config.version,
 			metadata: config.metadata || null,
-			notGlobal: config.notGlobal ?? false,
+			notGlobal: config.notGlobal,
 		},
 		(event) => {
 			handleEvent(event, config, wrappedHandle);
@@ -152,6 +163,152 @@ async function openDatabaseFromEnvoy(handle, actorId) {
 	return native.openDatabaseFromEnvoy(rawHandle, actorId);
 }
 
+function isPlainObject(value) {
+	return (
+		!!value &&
+		typeof value === "object" &&
+		!Array.isArray(value) &&
+		Object.getPrototypeOf(value) === Object.prototype
+	);
+}
+
+function toNativeBinding(value) {
+	if (value === null || value === undefined) {
+		return { kind: "null" };
+	}
+	if (typeof value === "bigint") {
+		return { kind: "int", intValue: Number(value) };
+	}
+	if (typeof value === "number") {
+		return Number.isInteger(value)
+			? { kind: "int", intValue: value }
+			: { kind: "float", floatValue: value };
+	}
+	if (typeof value === "string") {
+		return { kind: "text", textValue: value };
+	}
+	if (value instanceof ArrayBuffer) {
+		return { kind: "blob", blobValue: Buffer.from(value) };
+	}
+	if (ArrayBuffer.isView(value)) {
+		return {
+			kind: "blob",
+			blobValue: Buffer.from(value.buffer, value.byteOffset, value.byteLength),
+		};
+	}
+
+	throw new Error(`unsupported sqlite binding type: ${typeof value}`);
+}
+
+function extractNamedSqliteParameters(sql) {
+	return [...sql.matchAll(/([:@$][A-Za-z_][A-Za-z0-9_]*)/g)].map(
+		(match) => match[1],
+	);
+}
+
+function getNamedSqliteBinding(bindings, name) {
+	if (name in bindings) {
+		return bindings[name];
+	}
+
+	const bareName = name.slice(1);
+	if (bareName in bindings) {
+		return bindings[bareName];
+	}
+
+	for (const prefix of [":", "@", "$"]) {
+		const candidate = `${prefix}${bareName}`;
+		if (candidate in bindings) {
+			return bindings[candidate];
+		}
+	}
+
+	return undefined;
+}
+
+function normalizeBindings(sql, args) {
+	if (!args || args.length === 0) {
+		return [];
+	}
+
+	if (
+		args.length === 1 &&
+		isPlainObject(args[0]) &&
+		!(args[0] instanceof Uint8Array)
+	) {
+		const names = extractNamedSqliteParameters(sql);
+		if (names.length === 0) {
+			throw new Error(
+				"native sqlite object bindings require named placeholders in the SQL statement",
+			);
+		}
+		return names.map((name) => {
+			const value = getNamedSqliteBinding(args[0], name);
+			if (value === undefined) {
+				throw new Error(`missing bind parameter: ${name}`);
+			}
+			return toNativeBinding(value);
+		});
+	}
+
+	return args.map(toNativeBinding);
+}
+
+function mapRows(rows, columns) {
+	return rows.map((row) => {
+		const rowObject = {};
+		for (let i = 0; i < columns.length; i++) {
+			rowObject[columns[i]] = row[i];
+		}
+		return rowObject;
+	});
+}
+
+async function openRawDatabaseFromEnvoy(handle, actorId) {
+	const nativeDb = await openDatabaseFromEnvoy(handle, actorId);
+	let closed = false;
+
+	const ensureOpen = () => {
+		if (closed) {
+			throw new Error("database is closed");
+		}
+	};
+
+	return {
+		execute: async (query, ...args) => {
+			ensureOpen();
+
+			if (args.length > 0) {
+				const bindings = normalizeBindings(query, args);
+				const token = query.trimStart().slice(0, 16).toUpperCase();
+				const returnsRows =
+					token.startsWith("SELECT") ||
+					token.startsWith("PRAGMA") ||
+					token.startsWith("WITH") ||
+					/\bRETURNING\b/i.test(query);
+
+				if (returnsRows) {
+					const result = await nativeDb.query(query, bindings);
+					return mapRows(result.rows, result.columns);
+				}
+
+				await nativeDb.run(query, bindings);
+				return [];
+			}
+
+			const result = await nativeDb.exec(query);
+			return mapRows(result.rows, result.columns);
+		},
+		close: async () => {
+			if (closed) {
+				return;
+			}
+			closed = true;
+			await nativeDb.close();
+		},
+	};
+}
+
 /**
  * Route callback envelopes from the native addon to EnvoyConfig callbacks.
  */
@@ -176,15 +333,15 @@ function handleEvent(event, config, wrappedHandle) {
 					null, // preloadedKv
 				),
 			).then(
-				() => {
+				async () => {
 					if (handle._raw) {
-						handle._raw.respondCallback(event.responseId, {});
+						await handle._raw.respondCallback(event.responseId, {});
 					}
 				},
-				(err) => {
+				async (err) => {
 					console.error("onActorStart error:", err);
 					if (handle._raw) {
-						handle._raw.respondCallback(event.responseId, {
+						await handle._raw.respondCallback(event.responseId, {
 							error: String(err),
 						});
 					}
@@ -201,15 +358,15 @@ function handleEvent(event, config, wrappedHandle) {
 					event.reason || "stopped",
 				),
 			).then(
-				() => {
+				async () => {
 					if (handle._raw) {
-						handle._raw.respondCallback(event.responseId, {});
+						await handle._raw.respondCallback(event.responseId, {});
 					}
 				},
-				(err) => {
+				async (err) => {
 					console.error("onActorStop error:", err);
 					if (handle._raw) {
-						handle._raw.respondCallback(event.responseId, {
+						await handle._raw.respondCallback(event.responseId, {
 							error: String(err),
 						});
 					}
@@ -246,17 +403,17 @@ function handleEvent(event, config, wrappedHandle) {
 						const respBody = response.body
 							? Buffer.from(await response.arrayBuffer()).toString("base64")
 							: undefined;
-						handle._raw.respondCallback(event.responseId, {
+						await handle._raw.respondCallback(event.responseId, {
 							status: response.status || 200,
 							headers: respHeaders,
 							body: respBody,
 						});
 					}
 				},
-				(err) => {
+				async (err) => {
 					console.error("fetch callback error:", err);
 					if (handle._raw) {
-						handle._raw.respondCallback(event.responseId, {
+						await handle._raw.respondCallback(event.responseId, {
 							status: 500,
 							headers: { "content-type": "text/plain" },
 							body: Buffer.from(String(err)).toString("base64"),
@@ -335,7 +492,6 @@ function handleEvent(event, config, wrappedHandle) {
 					)
 					: false;
 
-				console.log("[wrapper] websocket_open actorId:", event.actorId?.slice(0, 12), "path:", event.path);
 				Promise.resolve(
 					config.websocket(
 						handle,
@@ -350,9 +506,7 @@ function handleEvent(event, config, wrappedHandle) {
 						false,
 					),
 				).then(() => {
-					console.log("[wrapper] websocket callback resolved, dispatching open event");
 					ws.dispatchEvent(new Event("open"));
-					console.log("[wrapper] open event dispatched");
 				}).catch((err) => {
 					console.error("[wrapper] websocket callback error:", err);
 				});
@@ -420,3 +574,4 @@ function handleEvent(event, config, wrappedHandle) {
 module.exports.startEnvoy = startEnvoy;
 module.exports.startEnvoySync = startEnvoySync;
 module.exports.openDatabaseFromEnvoy = openDatabaseFromEnvoy;
+module.exports.openRawDatabaseFromEnvoy = openRawDatabaseFromEnvoy;