@spooky-sync/core 0.0.1-canary.13 → 0.0.1-canary.131

package/dist/otel/index.d.ts

@@ -0,0 +1,21 @@
+import { u as PinoTransmit } from "../types.js";
+import { Level } from "pino";
+
+//#region src/otel/index.d.ts
+
+/**
+ * Creates a pino browser transmit object that forwards logs to an OpenTelemetry collector.
+ *
+ * @example
+ * ```ts
+ * import { createOtelTransmit } from '@spooky-sync/core/otel';
+ *
+ * new Sp00kyClient({
+ *   // ...
+ *   otelTransmit: createOtelTransmit('http://localhost:4318/v1/logs'),
+ * });
+ * ```
+ */
+declare function createOtelTransmit(endpoint: string, level?: Level): PinoTransmit;
+//#endregion
+export { createOtelTransmit };

package/dist/otel/index.js

@@ -0,0 +1,86 @@
+//#region src/otel/index.ts
+function mapLevelToSeverityNumber(level) {
+	switch (level) {
+		case "trace": return 1;
+		case "debug": return 5;
+		case "info": return 9;
+		case "warn": return 13;
+		case "error": return 17;
+		case "fatal": return 21;
+		default: return 9;
+	}
+}
+async function loadOtelModules(otelEndpoint) {
+	const [{ LoggerProvider, BatchLogRecordProcessor }, { OTLPLogExporter }, { resourceFromAttributes }, { ATTR_SERVICE_NAME }] = await Promise.all([
+		import("@opentelemetry/sdk-logs"),
+		import("@opentelemetry/exporter-logs-otlp-proto"),
+		import("@opentelemetry/resources"),
+		import("@opentelemetry/semantic-conventions")
+	]);
+	const loggerProvider = new LoggerProvider({
+		resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: "sp00ky-client" }),
+		processors: [new BatchLogRecordProcessor(new OTLPLogExporter({ url: otelEndpoint }))]
+	});
+	const otelLoggerCache = {};
+	return (category) => {
+		if (!otelLoggerCache[category]) otelLoggerCache[category] = loggerProvider.getLogger(category);
+		return otelLoggerCache[category];
+	};
+}
+/**
+* Creates a pino browser transmit object that forwards logs to an OpenTelemetry collector.
+*
+* @example
+* ```ts
+* import { createOtelTransmit } from '@spooky-sync/core/otel';
+*
+* new Sp00kyClient({
+*   // ...
+*   otelTransmit: createOtelTransmit('http://localhost:4318/v1/logs'),
+* });
+* ```
+*/
+function createOtelTransmit(endpoint, level = "info") {
+	const otelReady = loadOtelModules(endpoint);
+	return {
+		level,
+		send: (levelLabel, logEvent) => {
+			otelReady.then((getOtelLogger) => {
+				try {
+					const messages = [...logEvent.messages];
+					const severityNumber = mapLevelToSeverityNumber(levelLabel);
+					let body = "";
+					const lastMsg = messages.pop();
+					if (typeof lastMsg === "string") body = lastMsg;
+					else if (lastMsg) body = JSON.stringify(lastMsg);
+					let category = "sp00ky-client::unknown";
+					const attributes = {};
+					for (const msg of messages) if (typeof msg === "object") {
+						if (msg.Category) {
+							category = msg.Category;
+							delete msg.Category;
+						}
+						Object.assign(attributes, msg);
+					}
+					getOtelLogger(category).emit({
+						severityNumber,
+						severityText: levelLabel.toUpperCase(),
+						body,
+						attributes: {
+							...logEvent.bindings[0],
+							...attributes
+						},
+						timestamp: new Date(logEvent.ts)
+					});
+				} catch (e) {
+					console.warn("Failed to transmit log to OTEL endpoint", e);
+				}
+			}).catch((e) => {
+				console.warn("Failed to load OpenTelemetry modules", e);
+			});
+		}
+	};
+}
+
+//#endregion
+export { createOtelTransmit };

package/dist/sqlite-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sqlite-worker.js

@@ -0,0 +1,107 @@
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+
+//#region src/services/database/sqlite-worker.ts
+/**
+* Dedicated Web Worker that owns the SQLite-WASM handle. All DB access is
+* funnelled through here (the main thread never touches the wasm module), which
+* is also what the OPFS VFS requires — file access must happen off the main
+* thread. Persistence uses the **OPFS SAHPool VFS**: durable, and (unlike the
+* classic OPFS VFS) it does NOT require COOP/COEP cross-origin isolation
+* headers, so host apps embedding the client need no server changes. Falls back
+* to an in-memory DB when OPFS is unavailable.
+*
+* Message protocol (request/response keyed by `id`):
+*   { id, type: 'open',  payload: { dbName, useOpfs } }
+*   { id, type: 'exec',  payload: { sql, bind } }  -> { id, ok, rows }
+*   { id, type: 'run',   payload: { sql, bind } }  -> { id, ok }
+*   { id, type: 'batch', payload: [{ sql, bind }] } (atomic BEGIN/COMMIT)
+*   { id, type: 'close' }
+*/
+let db = null;
+async function open(dbName, useOpfs) {
+	const sqlite3 = await sqlite3InitModule();
+	let persisted = false;
+	if (useOpfs && sqlite3.installOpfsSAHPoolVfs) try {
+		db = new (await (sqlite3.installOpfsSAHPoolVfs({ name: `sp00ky-${dbName}` }))).OpfsSAHPoolDb(`/${dbName}.sqlite3`);
+		persisted = true;
+	} catch {}
+	if (!db) db = new sqlite3.oo1.DB(":memory:", "c");
+	try {
+		db.exec({ sql: "PRAGMA busy_timeout = 5000; PRAGMA cache_size = -32000;" });
+	} catch {}
+	return { persisted };
+}
+function exec(sql, bind) {
+	if (!db) throw new Error("sqlite: DB not open");
+	return db.exec({
+		sql,
+		bind,
+		rowMode: "object",
+		returnValue: "resultRows"
+	});
+}
+function run(sql, bind) {
+	if (!db) throw new Error("sqlite: DB not open");
+	db.exec({
+		sql,
+		bind
+	});
+}
+function batch(stmts) {
+	if (!db) throw new Error("sqlite: DB not open");
+	db.exec({ sql: "BEGIN" });
+	try {
+		for (const s of stmts) db.exec({
+			sql: s.sql,
+			bind: s.bind
+		});
+		db.exec({ sql: "COMMIT" });
+	} catch (e) {
+		try {
+			db.exec({ sql: "ROLLBACK" });
+		} catch {}
+		throw e;
+	}
+}
+self.onmessage = async (ev) => {
+	const { id, type, payload } = ev.data ?? {};
+	try {
+		let result;
+		switch (type) {
+			case "open":
+				result = await open(payload.dbName, payload.useOpfs);
+				break;
+			case "exec":
+				result = { rows: exec(payload.sql, payload.bind) };
+				break;
+			case "run":
+				run(payload.sql, payload.bind);
+				result = {};
+				break;
+			case "batch":
+				batch(payload);
+				result = {};
+				break;
+			case "close":
+				db?.close();
+				db = null;
+				result = {};
+				break;
+			default: throw new Error(`sqlite worker: unknown message ${type}`);
+		}
+		self.postMessage({
+			id,
+			ok: true,
+			...result
+		});
+	} catch (err) {
+		self.postMessage({
+			id,
+			ok: false,
+			error: err instanceof Error ? err.message : String(err)
+		});
+	}
+};
+
+//#endregion
+export {  };