silgi 0.0.14 → 0.1.0-beta.10

package/dist/integrations/ai/index.mjs

@@ -0,0 +1,117 @@
+import { compileProcedure } from "../../compile.mjs";
+import { jsonSchema, tool } from "ai";
+//#region src/integrations/ai/index.ts
+/**
+* Vercel AI SDK integration — expose silgi procedures as AI tools.
+*
+* Converts silgi router procedures into AI SDK tools that can be
+* called by LLMs via function calling / tool use.
+*
+* @example
+* ```ts
+* import { generateText } from "ai"
+* import { openai } from "@ai-sdk/openai"
+* import { routerToTools } from "silgi/ai"
+*
+* const tools = routerToTools(appRouter)
+*
+* const { text } = await generateText({
+*   model: openai("gpt-4o"),
+*   tools,
+*   prompt: "List all users with limit 5",
+* })
+* ```
+*/
+/**
+* Convert a single silgi procedure into an AI SDK tool.
+*/
+function procedureToTool(name, procedure, options) {
+	const handler = compileProcedure(procedure);
+	return tool({
+		description: options?.description ?? procedure.route?.description ?? procedure.route?.summary ?? `Call ${name}`,
+		parameters: jsonSchema(procedure.input ? zodToJsonSchemaSimple(procedure.input) : {
+			type: "object",
+			properties: {}
+		}),
+		execute: async (input, execOptions) => {
+			const ctx = Object.create(null);
+			const signal = execOptions?.abortSignal ?? new AbortController().signal;
+			const result = handler(ctx, input ?? {}, signal);
+			return result instanceof Promise ? await result : result;
+		}
+	});
+}
+/**
+* Convert all procedures in a silgi router into AI SDK tools.
+* Nested routers are flattened with underscore separators.
+*
+* @example
+* ```ts
+* // Router: { users: { list, create }, health }
+* // Tools: { users_list, users_create, health }
+* ```
+*/
+function routerToTools(router, options) {
+	const tools = {};
+	collectProcedures(router, [], (path, proc) => {
+		const flatName = path.join("_");
+		if (options?.filter && !options.filter(flatName, proc)) return;
+		tools[flatName] = procedureToTool(flatName, proc, { description: options?.descriptions?.[flatName] });
+	});
+	return tools;
+}
+function isProcedureDef(v) {
+	return typeof v === "object" && v !== null && "type" in v && "resolve" in v;
+}
+function collectProcedures(node, path, cb) {
+	if (isProcedureDef(node)) {
+		cb(path, node);
+		return;
+	}
+	if (typeof node === "object" && node !== null) for (const [key, child] of Object.entries(node)) collectProcedures(child, [...path, key], cb);
+}
+/** Simple Zod → JSON Schema for AI tool parameters */
+function zodToJsonSchemaSimple(schema) {
+	const zod = schema?._zod ?? schema?._def;
+	if (!zod) return {
+		type: "object",
+		properties: {}
+	};
+	return convertDef(zod.def ?? zod);
+}
+function convertDef(def) {
+	if (!def) return {};
+	switch (def.type ?? def.typeName) {
+		case "string": return { type: "string" };
+		case "number":
+		case "float": return { type: "number" };
+		case "int": return { type: "integer" };
+		case "boolean": return { type: "boolean" };
+		case "object": {
+			const props = {};
+			const required = [];
+			if (def.shape) for (const [k, v] of Object.entries(def.shape)) {
+				props[k] = zodToJsonSchemaSimple(v);
+				const fz = v?._zod?.def ?? v?._def;
+				if (fz?.type !== "optional" && fz?.typeName !== "ZodOptional") required.push(k);
+			}
+			return {
+				type: "object",
+				properties: props,
+				...required.length ? { required } : {}
+			};
+		}
+		case "array": return {
+			type: "array",
+			...def.element ? { items: zodToJsonSchemaSimple(def.element) } : {}
+		};
+		case "optional": return zodToJsonSchemaSimple(def.innerType ?? def.inner);
+		case "enum": return {
+			type: "string",
+			enum: def.values ?? def.entries
+		};
+		default: return {};
+	}
+}
+//#endregion
+export { procedureToTool, routerToTools };

package/dist/integrations/better-auth/index.d.mts

@@ -0,0 +1,61 @@
+//#region src/integrations/better-auth/index.d.ts
+/**
+ * Silgi + Better Auth tracing integration.
+ *
+ * Provides a Better Auth plugin factory that auto-traces all auth operations
+ * (sign-in, sign-up, OAuth, session management, etc.) into silgi analytics.
+ *
+ * The silgi request context is passed via `request.__silgiCtx`, set by
+ * the silgi auth handler before calling `auth.handler(request)`.
+ *
+ * @example
+ * ```ts
+ * import { tracing } from 'silgi/better-auth'
+ *
+ * const auth = betterAuth({
+ *   plugins: [
+ *     tracing(),  // auto-traces all auth operations
+ *   ],
+ * })
+ * ```
+ */
+interface TracingConfig {
+  /** Capture request body as span input (default: true) */
+  captureInput?: boolean;
+  /** Capture response data as span output (default: true) */
+  captureOutput?: boolean;
+  /** Pass `createAuthMiddleware` from `better-auth/api` to wrap hooks handler */
+  createAuthMiddleware?: (handler: any) => any;
+}
+/**
+ * Creates a Better Auth plugin that auto-traces all auth operations
+ * into silgi analytics spans.
+ *
+ * @param config - Optional configuration
+ * @returns A Better Auth plugin (typed as `any` to avoid requiring better-auth types at build time)
+ */
+declare function tracing(config?: TracingConfig): any;
+/**
+ * Instrument a Better Auth instance to trace all `auth.api.*` method calls.
+ * Works with `withCtx` — programmatic calls from background jobs,
+ * server-side session fetches etc. are traced when context is available.
+ *
+ * @example
+ * ```ts
+ * import { instrumentBetterAuth, withCtx } from 'silgi/better-auth'
+ *
+ * const auth = instrumentBetterAuth(betterAuth({ ... }))
+ *
+ * // In a silgi procedure:
+ * const me = s.$resolve(async ({ ctx }) => {
+ *   return withCtx(ctx, () => auth.api.getSession({ headers: ctx.headers }))
+ * })
+ * ```
+ */
+declare function instrumentBetterAuth<T extends Record<string, any>>(auth: T): T;
+/**
+ * Run a function with silgi context available to instrumented Better Auth API calls.
+ */
+declare function withCtx<T>(ctx: Record<string, unknown>, fn: () => T): T;
+//#endregion
+export { TracingConfig, instrumentBetterAuth, tracing, withCtx };

package/dist/integrations/better-auth/index.mjs

@@ -0,0 +1,332 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/integrations/better-auth/index.ts
+/**
+* Silgi + Better Auth tracing integration.
+*
+* Provides a Better Auth plugin factory that auto-traces all auth operations
+* (sign-in, sign-up, OAuth, session management, etc.) into silgi analytics.
+*
+* The silgi request context is passed via `request.__silgiCtx`, set by
+* the silgi auth handler before calling `auth.handler(request)`.
+*
+* @example
+* ```ts
+* import { tracing } from 'silgi/better-auth'
+*
+* const auth = betterAuth({
+*   plugins: [
+*     tracing(),  // auto-traces all auth operations
+*   ],
+* })
+* ```
+*/
+const ctxStorage = new AsyncLocalStorage();
+function matchOperation(path) {
+	const normalized = path.replace(/^\/+/, "");
+	if (normalized.endsWith("/sign-up/email") || normalized === "sign-up/email") return {
+		spanName: "auth.signup.email",
+		operation: "signup",
+		method: "email"
+	};
+	if (normalized.endsWith("/sign-in/email") || normalized === "sign-in/email") return {
+		spanName: "auth.signin.email",
+		operation: "signin",
+		method: "email"
+	};
+	if (normalized.endsWith("/sign-out") || normalized === "sign-out") return {
+		spanName: "auth.signout",
+		operation: "signout"
+	};
+	if (normalized.endsWith("/get-session") || normalized === "get-session") return {
+		spanName: "auth.get_session",
+		operation: "get_session"
+	};
+	if (normalized.endsWith("/update-user") || normalized === "update-user") return {
+		spanName: "auth.update_user",
+		operation: "update_user"
+	};
+	if (normalized.endsWith("/delete-user") || normalized === "delete-user") return {
+		spanName: "auth.delete_user",
+		operation: "delete_user"
+	};
+	if (normalized.endsWith("/change-password") || normalized === "change-password") return {
+		spanName: "auth.change_password",
+		operation: "change_password"
+	};
+	if (normalized.endsWith("/change-email") || normalized === "change-email") return {
+		spanName: "auth.change_email",
+		operation: "change_email"
+	};
+	if (normalized.endsWith("/verify-email") || normalized === "verify-email") return {
+		spanName: "auth.verify_email",
+		operation: "verify_email"
+	};
+	if (normalized.endsWith("/forget-password") || normalized === "forget-password") return {
+		spanName: "auth.forgot_password",
+		operation: "forgot_password"
+	};
+	if (normalized.endsWith("/reset-password") || normalized === "reset-password") return {
+		spanName: "auth.reset_password",
+		operation: "reset_password"
+	};
+	if (normalized.endsWith("/list-sessions") || normalized === "list-sessions") return {
+		spanName: "auth.list_sessions",
+		operation: "list_sessions"
+	};
+	if (normalized.endsWith("/revoke-session") || normalized === "revoke-session") return {
+		spanName: "auth.revoke_session",
+		operation: "revoke_session"
+	};
+	const callbackMatch = normalized.match(/\/callback\/([^/?]+)/);
+	if (callbackMatch) {
+		const provider = callbackMatch[1];
+		return {
+			spanName: `auth.oauth.callback.${provider}`,
+			operation: "oauth_callback",
+			method: "oauth",
+			provider
+		};
+	}
+	const signinMatch = normalized.match(/\/sign-in\/([^/?]+)$/);
+	if (signinMatch && signinMatch[1] !== "email") {
+		const provider = signinMatch[1];
+		return {
+			spanName: `auth.oauth.initiate.${provider}`,
+			operation: "oauth_initiate",
+			method: "oauth",
+			provider
+		};
+	}
+	const segments = normalized.split("/");
+	return {
+		spanName: `auth.${(segments[segments.length - 1] || "unknown").replace(/-/g, "_")}`,
+		operation: "unknown"
+	};
+}
+function round(n) {
+	return Math.round(n * 100) / 100;
+}
+function extractUserData(returned) {
+	const result = {};
+	if (!returned || typeof returned !== "object") return result;
+	const data = returned.data ?? returned;
+	if (data.user?.id) result.userId = String(data.user.id);
+	if (data.user?.email) result.userEmail = String(data.user.email);
+	if (data.session?.id) result.sessionId = String(data.session.id);
+	if (!result.userId && returned.id && returned.email) {
+		result.userId = String(returned.id);
+		result.userEmail = String(returned.email);
+	}
+	return result;
+}
+const requestMetas = /* @__PURE__ */ new WeakMap();
+/**
+* Creates a Better Auth plugin that auto-traces all auth operations
+* into silgi analytics spans.
+*
+* @param config - Optional configuration
+* @returns A Better Auth plugin (typed as `any` to avoid requiring better-auth types at build time)
+*/
+function tracing(config) {
+	const captureInput = config?.captureInput ?? true;
+	const captureOutput = config?.captureOutput ?? true;
+	return {
+		id: "silgi-tracing",
+		onRequest: async (request, _ctx) => {
+			try {
+				const path = new URL(request.url).pathname;
+				const match = matchOperation(path);
+				requestMetas.set(request, {
+					startTime: performance.now(),
+					path,
+					operation: match.operation,
+					method: match.method,
+					provider: match.provider,
+					spanName: match.spanName
+				});
+			} catch {}
+		},
+		hooks: { after: [{
+			matcher: () => true,
+			handler: (config?.createAuthMiddleware ?? ((fn) => fn))(async (ctx) => {
+				try {
+					const request = ctx.request;
+					if (!request) return;
+					const silgiCtx = request.__silgiCtx;
+					if (!silgiCtx) return;
+					const reqTrace = silgiCtx.__analyticsTrace;
+					if (!reqTrace) return;
+					const meta = requestMetas.get(request);
+					requestMetas.delete(request);
+					const path = ctx.path || "";
+					const match = meta ? {
+						spanName: meta.spanName,
+						operation: meta.operation,
+						method: meta.method,
+						provider: meta.provider
+					} : matchOperation(path);
+					const startTime = meta?.startTime ?? performance.now();
+					const durationMs = round(performance.now() - startTime);
+					const returned = ctx.context?.returned;
+					const newSession = ctx.context?.newSession;
+					const userData = extractUserData(returned);
+					if (!userData.userId && newSession?.user?.id) userData.userId = String(newSession.user.id);
+					if (!userData.userEmail && newSession?.user?.email) userData.userEmail = String(newSession.user.email);
+					if (!userData.sessionId && newSession?.session?.id) userData.sessionId = String(newSession.session.id);
+					const success = !returned?.error && !ctx.context?.error;
+					const attributes = {
+						"auth.operation": match.operation,
+						"auth.success": success
+					};
+					if (match.method) attributes["auth.method"] = match.method;
+					if (match.provider) attributes["auth.provider"] = match.provider;
+					if (userData.userId) attributes["user.id"] = userData.userId;
+					if (userData.userEmail) attributes["user.email"] = userData.userEmail;
+					if (userData.sessionId) attributes["session.id"] = userData.sessionId;
+					const span = {
+						name: match.spanName,
+						kind: "http",
+						durationMs,
+						startOffsetMs: round(startTime - reqTrace.t0),
+						attributes
+					};
+					if (captureInput && ctx.body) span.input = ctx.body;
+					if (captureOutput && returned && typeof returned === "object") span.output = returned;
+					if (!success && returned?.error) span.error = typeof returned.error === "string" ? returned.error : returned.error?.message ?? "error";
+					reqTrace.spans.push(span);
+					if (captureInput && ctx.body) reqTrace.procedureInput = ctx.body;
+					if (captureOutput && returned && typeof returned === "object") reqTrace.procedureOutput = returned;
+				} catch {}
+			})
+		}] }
+	};
+}
+const API_METHOD_METADATA = {
+	getSession: { operation: "get_session" },
+	signOut: { operation: "signout" },
+	signInEmail: {
+		operation: "signin",
+		method: "email"
+	},
+	signUpEmail: {
+		operation: "signup",
+		method: "email"
+	},
+	signInSocial: {
+		operation: "signin",
+		method: "oauth"
+	},
+	callbackOAuth: {
+		operation: "oauth_callback",
+		method: "oauth"
+	},
+	linkSocialAccount: {
+		operation: "link_social_account",
+		method: "oauth"
+	},
+	unlinkAccount: { operation: "unlink_account" },
+	listUserAccounts: { operation: "list_user_accounts" },
+	updateUser: { operation: "update_user" },
+	deleteUser: { operation: "delete_user" },
+	changePassword: { operation: "change_password" },
+	setPassword: { operation: "set_password" },
+	changeEmail: { operation: "change_email" },
+	verifyEmail: { operation: "verify_email" },
+	sendVerificationEmail: { operation: "send_verification_email" },
+	forgetPassword: { operation: "forget_password" },
+	resetPassword: { operation: "reset_password" },
+	listSessions: { operation: "list_sessions" },
+	revokeSession: { operation: "revoke_session" },
+	revokeSessions: { operation: "revoke_sessions" },
+	revokeOtherSessions: { operation: "revoke_other_sessions" },
+	refreshToken: { operation: "refresh_token" },
+	getAccessToken: { operation: "get_access_token" }
+};
+const AUTH_INSTRUMENTED = "__silgiBetterAuthInstrumented";
+/**
+* Instrument a Better Auth instance to trace all `auth.api.*` method calls.
+* Works with `withCtx` — programmatic calls from background jobs,
+* server-side session fetches etc. are traced when context is available.
+*
+* @example
+* ```ts
+* import { instrumentBetterAuth, withCtx } from 'silgi/better-auth'
+*
+* const auth = instrumentBetterAuth(betterAuth({ ... }))
+*
+* // In a silgi procedure:
+* const me = s.$resolve(async ({ ctx }) => {
+*   return withCtx(ctx, () => auth.api.getSession({ headers: ctx.headers }))
+* })
+* ```
+*/
+function instrumentBetterAuth(auth) {
+	if (!auth || auth[AUTH_INSTRUMENTED]) return auth;
+	const api = auth.api;
+	if (!api || typeof api !== "object") return auth;
+	const instrumented = /* @__PURE__ */ new Set();
+	for (const [methodName, metadata] of Object.entries(API_METHOD_METADATA)) if (typeof api[methodName] === "function") {
+		api[methodName] = wrapApiMethod(api[methodName], metadata.operation, metadata.method);
+		instrumented.add(methodName);
+	}
+	for (const key of Object.keys(api)) if (typeof api[key] === "function" && !instrumented.has(key) && !key.startsWith("$") && !key.startsWith("_")) {
+		const operation = key.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+		api[key] = wrapApiMethod(api[key], operation);
+		instrumented.add(key);
+	}
+	auth[AUTH_INSTRUMENTED] = true;
+	return auth;
+}
+/**
+* Run a function with silgi context available to instrumented Better Auth API calls.
+*/
+function withCtx(ctx, fn) {
+	return ctxStorage.run(ctx, fn);
+}
+function wrapApiMethod(originalFn, operation, method) {
+	return async function instrumented(...args) {
+		const reqTrace = ctxStorage.getStore()?.__analyticsTrace;
+		if (!reqTrace) return originalFn.apply(this, args);
+		const spanName = `auth.api.${operation}`;
+		const start = performance.now();
+		const attributes = {
+			"auth.operation": operation,
+			"auth.success": true
+		};
+		if (method) attributes["auth.method"] = method;
+		try {
+			const result = await originalFn.apply(this, args);
+			const data = result?.data ?? result;
+			if (data?.user?.id) attributes["user.id"] = String(data.user.id);
+			if (data?.user?.email) attributes["user.email"] = String(data.user.email);
+			if (data?.session?.id) attributes["session.id"] = String(data.session.id);
+			if (result?.error) {
+				attributes["auth.success"] = false;
+				attributes["auth.error"] = typeof result.error === "string" ? result.error : result.error?.message ?? "unknown";
+			}
+			reqTrace.spans.push({
+				name: spanName,
+				kind: "http",
+				durationMs: round(performance.now() - start),
+				startOffsetMs: round(start - reqTrace.t0),
+				attributes,
+				output: result && typeof result === "object" ? result : void 0
+			});
+			return result;
+		} catch (error) {
+			attributes["auth.success"] = false;
+			attributes["auth.error"] = error instanceof Error ? error.message : String(error);
+			reqTrace.spans.push({
+				name: spanName,
+				kind: "http",
+				durationMs: round(performance.now() - start),
+				startOffsetMs: round(start - reqTrace.t0),
+				attributes,
+				error: error instanceof Error ? error.stack ?? error.message : String(error)
+			});
+			throw error;
+		}
+	};
+}
+//#endregion
+export { instrumentBetterAuth, tracing, withCtx };

package/dist/integrations/drizzle/index.d.mts

@@ -0,0 +1,27 @@
+//#region src/integrations/drizzle/index.d.ts
+interface InstrumentDrizzleConfig {
+  /** Logical database name (e.g. 'auth', 'ecommerce') */
+  dbName?: string;
+  /** Database system identifier. Default: 'postgresql' */
+  dbSystem?: string;
+  /** Capture SQL query text in spans. Default: true */
+  captureQueryText?: boolean;
+  /** Max query text length before truncation. Default: 1000 */
+  maxQueryTextLength?: number;
+  /** Database host */
+  peerName?: string;
+  /** Database port */
+  peerPort?: number;
+}
+/**
+ * Instrument a Drizzle db instance to record query spans in silgi analytics.
+ * Returns the same db instance (mutated). Safe to call multiple times.
+ */
+declare function instrumentDrizzle<T extends Record<string, any>>(db: T, config?: InstrumentDrizzleConfig): T;
+/**
+ * Run a function with silgi context available to instrumented Drizzle instances.
+ * All Drizzle queries inside `fn` will be recorded as trace spans.
+ */
+declare function withCtx<T>(ctx: Record<string, unknown>, fn: () => T): T;
+//#endregion
+export { InstrumentDrizzleConfig, instrumentDrizzle, withCtx };