silgi 0.1.0-beta.7 → 0.1.0-beta.8

package/dist/core/handler.mjs

@@ -1,6 +1,7 @@
 import { routerCache } from "./router-utils.mjs";
 import { compileRouter, createContext, releaseContext } from "../compile.mjs";
 import { applyContext } from "./dispatch.mjs";
+import { analyticsTraceMap } from "../plugins/analytics.mjs";
 import { detectResponseFormat, encodeResponse, makeErrorResponse } from "./codec.mjs";
 import { parseInput } from "./input.mjs";
 import { iteratorToEventStream } from "./sse.mjs";
@@ -116,6 +117,8 @@ function createFetchHandler(routerDef, contextFactory, hooks) {
 			const baseCtxResult = contextFactory(request);
 			applyContext(ctx, baseCtxResult instanceof Promise ? await baseCtxResult : baseCtxResult);
 			if (match.params) ctx.params = match.params;
+			const reqTrace = analyticsTraceMap.get(request);
+			if (reqTrace) ctx.__analyticsTrace = reqTrace;
 			if (!route.passthrough) rawInput = await parseInput(request, url, qMark);
 			callHook("request", {
 				path: pathname,

package/dist/core/storage.d.mts

@@ -3,16 +3,15 @@ import { Driver, Storage, StorageValue } from "unstorage";
 //#region src/core/storage.d.ts
 /** Storage config — map of mount path → driver instance, or a pre-built Storage */
 type StorageConfig = Storage | Record<string, Driver>;
-/**
- * Initialize storage from config — called once at startup.
- * Accepts either a pre-built Storage or a map of mount paths → drivers.
- */
-declare function initStorage(config?: StorageConfig): Storage;
 /**
  * Get the storage instance with optional prefix.
- * Creates default in-memory if not initialized.
+ * Creates default storage with `data` and `cache` mounts on first call.
  */
 declare function useStorage<T extends StorageValue = StorageValue>(base?: string): Storage<T>;
+/**
+ * Initialize storage from config — call once at startup.
+ */
+declare function initStorage(config?: StorageConfig): Storage;
 /**
  * Reset storage — for testing.
  */

package/dist/core/storage.mjs

@@ -1,63 +1,61 @@
 import { createStorage, prefixStorage } from "unstorage";
+import memoryDriver from "unstorage/drivers/memory";
 //#region src/core/storage.ts
 /**
-* Storage integration — unstorage with type-safe driver config.
+* Storage — Nitro-style global storage with unstorage.
 *
-* Two usage modes:
+* Two default mounts are created automatically:
+* - `data`  — persistent data (analytics, sessions, etc.)
+* - `cache` — ephemeral cache (query results, SWR, etc.)
+*
+* Both use in-memory drivers by default. Override with custom drivers:
 *
-* 1. Declarative config (type-safe driver options):
 * ```ts
 * import redisDriver from 'unstorage/drivers/redis'
-* import memoryDriver from 'unstorage/drivers/memory'
+* import fsDriver from 'unstorage/drivers/fs'
 *
 * const s = silgi({
 *   context: () => ({}),
 *   storage: {
+*     data: fsDriver({ base: '.data' }),
 *     cache: redisDriver({ url: 'redis://localhost' }),
-*     sessions: memoryDriver(),
 *   },
 * })
-* ```
-*
-* 2. Bring your own storage instance:
-* ```ts
-* const storage = createStorage({})
-* storage.mount('cache', redisDriver({ ... }))
 *
-* const s = silgi({
-*   context: () => ({}),
-*   storage,
-* })
+* // In procedures:
+* const data = useStorage('data')
+* const cache = useStorage('cache')
 * ```
 */
-let _storage;
-/**
-* Initialize storage from config — called once at startup.
-* Accepts either a pre-built Storage or a map of mount paths → drivers.
-*/
-function initStorage(config) {
-	if (_storage) return _storage;
-	if (config && "getItem" in config) {
-		_storage = config;
-		return _storage;
-	}
-	_storage = createStorage({});
-	if (config) for (const [path, driver] of Object.entries(config)) _storage.mount(path, driver);
-	return _storage;
+function _initStorage(config) {
+	if (config && "getItem" in config) return config;
+	const storage = createStorage({});
+	storage.mount("data", memoryDriver());
+	storage.mount("cache", memoryDriver());
+	if (config) for (const [path, driver] of Object.entries(config)) storage.mount(path, driver);
+	return storage;
 }
 /**
 * Get the storage instance with optional prefix.
-* Creates default in-memory if not initialized.
+* Creates default storage with `data` and `cache` mounts on first call.
 */
 function useStorage(base = "") {
-	const storage = _storage ?? initStorage();
+	const storage = useStorage._storage ??= _initStorage();
 	return base ? prefixStorage(storage, base) : storage;
 }
 /**
+* Initialize storage from config — call once at startup.
+*/
+function initStorage(config) {
+	const storage = _initStorage(config);
+	useStorage._storage = storage;
+	return storage;
+}
+/**
 * Reset storage — for testing.
 */
 function resetStorage() {
-	_storage = void 0;
+	useStorage._storage = void 0;
 }
 //#endregion
 export { initStorage, resetStorage, useStorage };

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { SilgiError, isDefinedError, toSilgiError } from "./core/error.mjs";
 import { ValidationError, type, validateSchema } from "./core/schema.mjs";
 import { compileProcedure, compileRouter, createContext } from "./compile.mjs";
+import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
 import { getEventMeta, withEventMeta } from "./core/sse.mjs";
 import { silgi } from "./silgi.mjs";
@@ -8,6 +9,5 @@ import { callable } from "./callable.mjs";
 import { lifecycleWrap } from "./lifecycle.mjs";
 import { mapInput } from "./map-input.mjs";
 import { isLazy, lazy, resolveLazy } from "./lazy.mjs";
-import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { generateOpenAPI, scalarHTML } from "./scalar.mjs";
 export { AsyncIteratorClass, SilgiError, ValidationError, callable, compileProcedure, compileRouter, createContext, generateOpenAPI, getEventMeta, initStorage, isDefinedError, isLazy, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, scalarHTML, silgi, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/dist/plugins/analytics.d.mts

@@ -91,6 +91,8 @@ interface AnalyticsOptions {
    * - `undefined` — no auth (open access, NOT recommended in production)
    */
   auth?: string | ((req: Request) => boolean | Promise<boolean>);
+  /** Interval in ms between storage flushes (default: 5000) */
+  flushInterval?: number;
 }
 interface ProcedureSnapshot {
   count: number;
@@ -165,8 +167,9 @@ declare class AnalyticsCollector {
   recordError(path: string, durationMs: number, errorMsg: string): void;
   recordDetailedError(entry: Omit<ErrorEntry, 'id'>): void;
   recordDetailedRequest(entry: Omit<RequestEntry, 'id'>): void;
-  getErrors(): ErrorEntry[];
-  getRequests(): RequestEntry[];
+  getErrors(): Promise<ErrorEntry[]>;
+  getRequests(): Promise<RequestEntry[]>;
+  dispose(): Promise<void>;
   toJSON(): AnalyticsSnapshot;
 }
 declare class RequestAccumulator {
@@ -193,7 +196,7 @@ declare function sanitizeHeaders(headers: Headers): Record<string, string>;
 /** Return auth-failure response for analytics routes. */
 declare function analyticsAuthResponse(pathname: string): Response;
 /** Serve analytics dashboard and API routes. */
-declare function serveAnalyticsRoute(pathname: string, collector: AnalyticsCollector, dashboardHtml: string | undefined): Response;
+declare function serveAnalyticsRoute(pathname: string, collector: AnalyticsCollector, dashboardHtml: string | undefined): Promise<Response>;
 /**
  * Wrap a fetch handler with analytics collection.
  * Intercepts analytics dashboard routes and instruments every request.

package/dist/plugins/analytics.mjs

@@ -1,9 +1,10 @@
 import { SilgiError, toSilgiError } from "../core/error.mjs";
 import { ValidationError } from "../core/schema.mjs";
-import { parse } from "cookie-es";
+import { useStorage } from "../core/storage.mjs";
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { parse } from "cookie-es";
 //#region src/plugins/analytics.ts
 /**
 * Built-in analytics plugin — zero-dependency monitoring with deep error tracing.
@@ -142,6 +143,86 @@ async function trace(ctx, name, fn, opts) {
 	if (reqTrace) return reqTrace.trace(name, fn, opts);
 	return fn();
 }
+var AnalyticsStore = class {
+	#storage;
+	#pendingRequests = [];
+	#pendingErrors = [];
+	#maxRequests;
+	#maxErrors;
+	#timer = null;
+	#flushing = false;
+	constructor(maxRequests, maxErrors, flushInterval) {
+		this.#storage = useStorage("data");
+		this.#maxRequests = maxRequests;
+		this.#maxErrors = maxErrors;
+		this.#timer = setInterval(() => this.flush(), flushInterval);
+		if (typeof this.#timer === "object" && "unref" in this.#timer) this.#timer.unref();
+	}
+	enqueueRequest(entry) {
+		this.#pendingRequests.push(entry);
+	}
+	enqueueError(entry) {
+		this.#pendingErrors.push(entry);
+	}
+	async flush() {
+		if (this.#flushing) return;
+		const requests = this.#pendingRequests.splice(0);
+		const errors = this.#pendingErrors.splice(0);
+		if (requests.length === 0 && errors.length === 0) return;
+		this.#flushing = true;
+		try {
+			if (requests.length > 0) {
+				const merged = [...await this.#storage.getItem("analytics:requests") ?? [], ...requests].slice(-this.#maxRequests);
+				await this.#storage.setItem("analytics:requests", merged);
+			}
+			if (errors.length > 0) {
+				const merged = [...await this.#storage.getItem("analytics:errors") ?? [], ...errors].slice(-this.#maxErrors);
+				await this.#storage.setItem("analytics:errors", merged);
+			}
+		} catch {
+			this.#pendingRequests.unshift(...requests);
+			this.#pendingErrors.unshift(...errors);
+		} finally {
+			this.#flushing = false;
+		}
+	}
+	async getRequests() {
+		const stored = await this.#storage.getItem("analytics:requests") ?? [];
+		if (this.#pendingRequests.length === 0) return stored;
+		return [...stored, ...this.#pendingRequests].slice(-this.#maxRequests);
+	}
+	async getErrors() {
+		const stored = await this.#storage.getItem("analytics:errors") ?? [];
+		if (this.#pendingErrors.length === 0) return stored;
+		return [...stored, ...this.#pendingErrors].slice(-this.#maxErrors);
+	}
+	async hydrate() {
+		try {
+			return await this.#storage.getItem("analytics:counters") ?? {
+				totalRequests: 0,
+				totalErrors: 0
+			};
+		} catch {
+			return {
+				totalRequests: 0,
+				totalErrors: 0
+			};
+		}
+	}
+	async saveCounters(totalRequests, totalErrors) {
+		try {
+			await this.#storage.setItem("analytics:counters", {
+				totalRequests,
+				totalErrors
+			});
+		} catch {}
+	}
+	async dispose() {
+		if (this.#timer) clearInterval(this.#timer);
+		this.#timer = null;
+		await this.flush();
+	}
+};
 var AnalyticsCollector = class {
 	#procedures = /* @__PURE__ */ new Map();
 	#startTime = Date.now();
@@ -157,6 +238,8 @@ var AnalyticsCollector = class {
 	#nextErrorId = 1;
 	#requests = [];
 	#nextRequestId = 1;
+	#store;
+	#counterFlushCounter = 0;
 	constructor(options = {}) {
 		this.#bufferSize = options.bufferSize ?? 1024;
 		this.#historySeconds = options.historySeconds ?? 120;
@@ -167,6 +250,11 @@ var AnalyticsCollector = class {
 			count: 0,
 			errors: 0
 		};
+		this.#store = new AnalyticsStore(this.#maxRequests, this.#maxErrors, options.flushInterval ?? 5e3);
+		this.#store.hydrate().then((c) => {
+			this.#totalRequests += c.totalRequests;
+			this.#totalErrors += c.totalErrors;
+		});
 	}
 	record(path, durationMs) {
 		this.#totalRequests++;
@@ -187,18 +275,23 @@ var AnalyticsCollector = class {
 		this.#tick(true);
 	}
 	recordDetailedError(entry) {
-		this.#errors.push({
+		const full = {
 			...entry,
 			id: this.#nextErrorId++
-		});
+		};
+		this.#errors.push(full);
 		if (this.#errors.length > this.#maxErrors) this.#errors.shift();
+		this.#store.enqueueError(full);
 	}
 	recordDetailedRequest(entry) {
-		this.#requests.push({
+		const full = {
 			...entry,
 			id: this.#nextRequestId++
-		});
+		};
+		this.#requests.push(full);
 		if (this.#requests.length > this.#maxRequests) this.#requests.shift();
+		this.#store.enqueueRequest(full);
+		this.#flushCountersIfNeeded();
 	}
 	#getOrCreate(path) {
 		let entry = this.#procedures.get(path);
@@ -231,10 +324,17 @@ var AnalyticsCollector = class {
 		if (isError) this.#currentWindow.errors++;
 	}
 	getErrors() {
-		return this.#errors;
+		return this.#store.getErrors();
 	}
 	getRequests() {
-		return this.#requests;
+		return this.#store.getRequests();
+	}
+	#flushCountersIfNeeded() {
+		if (++this.#counterFlushCounter % 50 === 0) this.#store.saveCounters(this.#totalRequests, this.#totalErrors);
+	}
+	async dispose() {
+		await this.#store.saveCounters(this.#totalRequests, this.#totalErrors);
+		await this.#store.dispose();
 	}
 	toJSON() {
 		const uptimeSeconds = (Date.now() - this.#startTime) / 1e3;
@@ -539,7 +639,7 @@ function analyticsAuthResponse(pathname) {
 	});
 }
 /** Serve analytics dashboard and API routes. */
-function serveAnalyticsRoute(pathname, collector, dashboardHtml) {
+async function serveAnalyticsRoute(pathname, collector, dashboardHtml) {
 	const jsonCacheHeaders = {
 		"content-type": "application/json",
 		"cache-control": "no-cache"
@@ -549,22 +649,28 @@ function serveAnalyticsRoute(pathname, collector, dashboardHtml) {
 		"cache-control": "no-cache"
 	};
 	if (pathname === "analytics/_api/stats") return new Response(JSON.stringify(collector.toJSON()), { headers: jsonCacheHeaders });
-	if (pathname === "analytics/_api/errors") return new Response(JSON.stringify(collector.getErrors()), { headers: jsonCacheHeaders });
-	if (pathname === "analytics/_api/requests") return new Response(JSON.stringify(collector.getRequests()), { headers: jsonCacheHeaders });
+	if (pathname === "analytics/_api/errors") {
+		const errors = await collector.getErrors();
+		return new Response(JSON.stringify(errors), { headers: jsonCacheHeaders });
+	}
+	if (pathname === "analytics/_api/requests") {
+		const requests = await collector.getRequests();
+		return new Response(JSON.stringify(requests), { headers: jsonCacheHeaders });
+	}
 	if (pathname.startsWith("analytics/_api/requests/") && pathname.endsWith("/md")) {
 		const id = Number(pathname.slice(24, -3));
-		const entry = collector.getRequests().find((r) => r.id === id);
+		const entry = (await collector.getRequests()).find((r) => r.id === id);
 		if (entry) return new Response(requestToMarkdown(entry), { headers: mdHeaders });
 		return new Response("not found", { status: 404 });
 	}
 	if (pathname.startsWith("analytics/_api/errors/") && pathname.endsWith("/md")) {
 		const id = Number(pathname.slice(22, -3));
-		const entry = collector.getErrors().find((e) => e.id === id);
+		const entry = (await collector.getErrors()).find((e) => e.id === id);
 		if (entry) return new Response(errorToMarkdown(entry), { headers: mdHeaders });
 		return new Response("not found", { status: 404 });
 	}
 	if (pathname === "analytics/_api/errors/md") {
-		const errors = collector.getErrors();
+		const errors = await collector.getErrors();
 		const md = errors.length === 0 ? "No errors.\n" : `# Errors (${errors.length})\n\n` + errors.map((e) => errorToMarkdown(e)).join("\n\n---\n\n");
 		return new Response(md, { headers: mdHeaders });
 	}

package/dist/plugins/index.mjs

@@ -1,3 +1,4 @@
+import { AnalyticsCollector, RequestTrace, analyticsHTML, errorToMarkdown, trace } from "./analytics.mjs";
 import { cors, corsHeaders } from "./cors.mjs";
 import { otelWrap } from "./otel.mjs";
 import { loggingHooks } from "./pino.mjs";
@@ -10,5 +11,4 @@ import { coerceGuard, coerceObject, coerceValue } from "./coerce.mjs";
 import { createBatchHandler } from "./batch-server.mjs";
 import { MemoryPubSub, createPublisher } from "./pubsub.mjs";
 import { fileGuard, parseMultipart } from "./file-upload.mjs";
-import { AnalyticsCollector, RequestTrace, analyticsHTML, errorToMarkdown, trace } from "./analytics.mjs";
 export { AnalyticsCollector, MemoryPubSub, MemoryRateLimiter, RequestTrace, analyticsHTML, bodyLimitGuard, coerceGuard, coerceObject, coerceValue, cors, corsHeaders, createBatchHandler, createPublisher, decrypt, deleteCookie, encrypt, errorToMarkdown, fileGuard, getCookie, loggingHooks, otelWrap, parseCookies, parseMultipart, rateLimitGuard, setCookie, sign, strictGetGuard, trace, unsign };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.1.0-beta.7",
+  "version": "0.1.0-beta.8",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [