sonamu 0.9.3 → 0.9.5

package/dist/auth/audit-log/plugin.js

@@ -0,0 +1,427 @@
+import { DB, init_db } from "../../database/db.js";
+import { ROUTES } from "./events.js";
+import { buildAuditEventCatalog } from "./builders.js";
+import { ingestAuditEvent } from "../audit-log-ingestor.js";
+import { getLogger } from "@logtape/logtape";
+import { createAuthMiddleware } from "better-auth/api";
+
+//#region src/auth/audit-log/plugin.ts
+init_db();
+const stripQuery = (value) => value.split("?")[0] || value;
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const routeToRegex = (route) => {
+	const pattern = escapeRegex(stripQuery(route)).replace(/\/:([^/]+)/g, "/[^/]+");
+	return new RegExp(`${pattern}(?:$|[/?])`);
+};
+const matchesAnyRoute = (routePath, routes) => {
+	if (!routePath) return false;
+	const cleanPath = stripQuery(routePath);
+	return routes.some((route) => routeToRegex(route).test(cleanPath));
+};
+const LOGIN_PATHS = [
+	ROUTES.SIGN_IN_SOCIAL_CALLBACK,
+	ROUTES.SIGN_IN_OAUTH_CALLBACK,
+	ROUTES.SIGN_IN_EMAIL,
+	ROUTES.SIGN_IN_SOCIAL,
+	ROUTES.SIGN_IN_EMAIL_OTP,
+	ROUTES.SIGN_UP_EMAIL
+];
+const getLoginMethod = (ctxPath, paramsId) => {
+	if (!ctxPath) return null;
+	if (matchesAnyRoute(ctxPath, LOGIN_PATHS)) {
+		if (paramsId) return paramsId;
+		return ctxPath.split("/").pop() ?? null;
+	}
+	return null;
+};
+const getTriggerInfo = (ctxPath, sessionUserId, userId) => {
+	const resolved = sessionUserId ?? userId;
+	const triggerContext = resolved === userId ? "user" : matchesAnyRoute(ctxPath, [ROUTES.ADMIN_ROUTE]) ? "admin" : matchesAnyRoute(ctxPath, [ROUTES.DASH_ROUTE]) ? "dashboard" : resolved === "unknown" ? "user" : "unknown";
+	return {
+		triggeredBy: resolved,
+		triggerContext
+	};
+};
+const getOrganizationTriggerInfo = (user) => ({
+	triggeredBy: user?.id ?? "unknown",
+	triggerContext: "organization"
+});
+const narrowRequestCtx = (raw) => {
+	if (!raw || typeof raw !== "object") return null;
+	const candidate = raw;
+	if (!candidate.context || typeof candidate.context !== "object") return null;
+	return raw;
+};
+const fetchUserBy = async (ctx, field, value) => {
+	if (!value) return null;
+	const adapter = ctx.context.adapter;
+	if (!adapter) return null;
+	try {
+		const row = await adapter.findOne({
+			model: "user",
+			select: [
+				"id",
+				"name",
+				"email"
+			],
+			where: [{
+				field,
+				value
+			}]
+		});
+		if (!row) return null;
+		return {
+			id: String(row.id),
+			name: typeof row.name === "string" ? row.name : undefined,
+			email: typeof row.email === "string" ? row.email : undefined
+		};
+	} catch {
+		return null;
+	}
+};
+const isNonEmptyString = (v) => typeof v === "string" && v.length > 0;
+const IP_HEADER_ORDER = [
+	"cf-connecting-ip",
+	"x-forwarded-for",
+	"x-real-ip",
+	"x-vercel-forwarded-for"
+];
+const readHeader = (headers, key) => {
+	if (!headers) return null;
+	if (headers instanceof Headers) {
+		return headers.get(key);
+	}
+	if (typeof headers === "object") {
+		const map = headers;
+		const v = map[key] ?? map[key.toLowerCase()];
+		if (typeof v === "string") return v;
+		if (Array.isArray(v) && typeof v[0] === "string") return v[0];
+	}
+	return null;
+};
+const extractLocationFromHeaders = (headers) => {
+	let ipAddress = null;
+	for (const key of IP_HEADER_ORDER) {
+		const raw = readHeader(headers, key);
+		if (typeof raw === "string" && raw.length > 0) {
+			const first = raw.split(",")[0]?.trim();
+			if (first) {
+				ipAddress = first;
+				break;
+			}
+		}
+	}
+	const countryCode = readHeader(headers, "cf-ipcountry");
+	const city = readHeader(headers, "cf-ipcity");
+	return {
+		ipAddress: ipAddress ?? undefined,
+		city: city ?? undefined,
+		country: undefined,
+		countryCode: countryCode ?? undefined
+	};
+};
+const wrapOrgHook = (hooks, name, handler) => {
+	const prev = hooks[name];
+	hooks[name] = async (...args) => {
+		await handler(args[0]);
+		if (prev) return prev(...args);
+		return undefined;
+	};
+};
+/**
+* Better Auth databaseHooks/organizationHooks/middleware에서 수집한
+* 이벤트를 `DB.getDB("w")`로 얻은 knex에 `ingestAuditEvent`로 적재한다.
+*
+* - dash(@better-auth/infra)의 audit-event 수집 훅 구조를 참고해 Sonamu 내부 적재 경로로 포팅한다.
+* - dash의 infra 연결/API endpoint 제공 범위는 포함하지 않고, audit-event emit/ingest 경로만 유지한다.
+* - security 4종은 R1 결정에 따라 scope out (builders.ts의 TODO 주석 참조).
+*/
+function sonamuAuditLog() {
+	const logger = getLogger(["sonamu", "audit-log"]);
+	const catalog = buildAuditEventCatalog();
+	const processedBulkOperationContexts = new WeakSet();
+	const emit = async (event) => {
+		try {
+			await ingestAuditEvent(DB.getDB("w"), event);
+		} catch (err) {
+			logger.error("audit event ingest failed: {error}", { error: err });
+		}
+	};
+	const triggerFor = (ctx, subjectUserId) => getTriggerInfo(ctx.path, ctx.context.session?.session?.userId ?? null, subjectUserId);
+	const locationFor = (ctx) => ctx.context.location ?? undefined;
+	return {
+		id: "sonamu-audit-log",
+		init(pluginCtx) {
+			installOrganizationHooks(pluginCtx, catalog, emit, logger);
+			return { options: { databaseHooks: {
+				user: {
+					create: { after: async (rawUser, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						const user = rawUser;
+						await emit(catalog.user.trackUserSignedUp(user, triggerFor(ctx, user.id), locationFor(ctx)));
+					} },
+					update: { after: async (rawUser, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						const user = rawUser;
+						const path = ctx.path;
+						const trigger = triggerFor(ctx, user.id);
+						const location = locationFor(ctx);
+						if (matchesAnyRoute(path, [ROUTES.UPDATE_USER, ROUTES.DASH_UPDATE_USER])) {
+							const updatedFields = Object.keys(ctx.body ?? {});
+							const isOnlyImageUpdate = updatedFields.length === 1 && updatedFields[0] === "image";
+							const isOnlyEmailVerifiedUpdate = updatedFields.length === 1 && updatedFields[0] === "emailVerified";
+							const hasEmailVerifiedUpdate = updatedFields.includes("emailVerified");
+							if (isOnlyEmailVerifiedUpdate && user.emailVerified) {
+								await emit(catalog.user.trackUserEmailVerified(user, trigger, location));
+							} else if (isOnlyImageUpdate && user.image) {
+								await emit(catalog.user.trackUserProfileImageUpdated(user, trigger, location));
+							} else if (!isOnlyImageUpdate && !isOnlyEmailVerifiedUpdate) {
+								await emit(catalog.user.trackUserProfileUpdated(user, updatedFields, trigger, location));
+								if (hasEmailVerifiedUpdate && user.emailVerified) {
+									await emit(catalog.user.trackUserEmailVerified(user, trigger, location));
+								}
+							}
+						} else if (matchesAnyRoute(path, [ROUTES.CHANGE_EMAIL])) {
+							const updatedFields = Object.keys(ctx.body ?? {});
+							await emit(catalog.user.trackUserProfileUpdated(user, updatedFields, trigger, location));
+						}
+						if (matchesAnyRoute(path, [ROUTES.VERIFY_EMAIL]) && user.emailVerified) {
+							await emit(catalog.user.trackUserEmailVerified(user, trigger, location));
+						}
+						if (matchesAnyRoute(path, [ROUTES.ADMIN_BAN_USER]) && "banned" in user && user.banned) {
+							await emit(catalog.user.trackUserBanned(user, trigger, location));
+						}
+						if (matchesAnyRoute(path, [ROUTES.ADMIN_UNBAN_USER]) && "banned" in user && !user.banned) {
+							await emit(catalog.user.trackUserUnBanned(user, trigger, location));
+						}
+					} },
+					delete: { after: async (rawUser, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						const user = rawUser;
+						await emit(catalog.user.trackUserDeleted(user, triggerFor(ctx, user.id), locationFor(ctx)));
+					} }
+				},
+				session: {
+					create: {
+						before: async (rawSession, rawCtx) => {
+							void rawSession;
+							const ctx = narrowRequestCtx(rawCtx);
+							if (!ctx) return undefined;
+							return { data: { loginMethod: getLoginMethod(ctx.path, ctx.params?.id) } };
+						},
+						after: async (rawSession, rawCtx) => {
+							const ctx = narrowRequestCtx(rawCtx);
+							if (!ctx) return;
+							const session = rawSession;
+							if (!session.userId) return;
+							const location = locationFor(ctx);
+							const loginMethod = getLoginMethod(ctx.path, ctx.params?.id) ?? undefined;
+							const enrichedSession = {
+								...session,
+								loginMethod: loginMethod ?? session.loginMethod ?? null
+							};
+							const user = await fetchUserBy(ctx, "id", session.userId);
+							let trigger;
+							if (matchesAnyRoute(ctx.path, [
+								ROUTES.SIGN_IN,
+								ROUTES.SIGN_UP,
+								ROUTES.SIGN_IN_SOCIAL_CALLBACK,
+								ROUTES.SIGN_IN_OAUTH_CALLBACK
+							])) {
+								trigger = getTriggerInfo(ctx.path, session.userId, session.userId);
+								await emit(catalog.session.trackUserSignedIn(enrichedSession, user, trigger, location));
+							} else {
+								trigger = triggerFor(ctx, session.userId);
+							}
+							await emit(catalog.session.trackSessionCreated(enrichedSession, user, trigger, location));
+							if (isNonEmptyString(session.impersonatedBy)) {
+								const impersonator = await fetchUserBy(ctx, "id", session.impersonatedBy);
+								await emit(catalog.session.trackUserImpersonated(enrichedSession, user, impersonator, {
+									triggeredBy: session.impersonatedBy,
+									triggerContext: trigger.triggerContext
+								}, location));
+							}
+						}
+					},
+					delete: { after: async (rawSession, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						const session = rawSession;
+						const location = locationFor(ctx);
+						const enrichedSession = { ...session };
+						const user = await fetchUserBy(ctx, "id", session.userId);
+						const trigger = triggerFor(ctx, session.userId);
+						if (matchesAnyRoute(ctx.path, [
+							ROUTES.REVOKE_ALL_SESSIONS,
+							ROUTES.ADMIN_REVOKE_USER_SESSIONS,
+							ROUTES.DASH_REVOKE_SESSIONS_ALL,
+							ROUTES.DASH_BAN_USER
+						])) {
+							if (!processedBulkOperationContexts.has(ctx)) {
+								await emit(catalog.session.trackSessionRevokedAll(enrichedSession, user, trigger));
+								processedBulkOperationContexts.add(ctx);
+							}
+						} else if (matchesAnyRoute(ctx.path, [ROUTES.SIGN_OUT])) {
+							await emit(catalog.session.trackUserSignedOut(enrichedSession, user, trigger, location));
+						} else {
+							await emit(catalog.session.trackSessionRevoked(enrichedSession, user, trigger, location));
+						}
+						if (isNonEmptyString(session.impersonatedBy)) {
+							const impersonator = await fetchUserBy(ctx, "id", session.impersonatedBy);
+							await emit(catalog.session.trackUserImpersonationStop(enrichedSession, user, impersonator, trigger, location));
+						}
+					} }
+				},
+				account: {
+					create: { after: async (rawAccount, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						const account = rawAccount;
+						if (!account.userId) return;
+						const user = await fetchUserBy(ctx, "id", account.userId);
+						await emit(catalog.account.trackAccountLinking(account, user, triggerFor(ctx, account.userId), locationFor(ctx)));
+					} },
+					update: { after: async (rawAccount, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						const account = rawAccount;
+						if (!account.userId) return;
+						if (!matchesAnyRoute(ctx.path, [
+							ROUTES.CHANGE_PASSWORD,
+							ROUTES.SET_PASSWORD,
+							ROUTES.RESET_PASSWORD,
+							ROUTES.ADMIN_SET_PASSWORD
+						])) {
+							return;
+						}
+						const user = await fetchUserBy(ctx, "id", account.userId);
+						await emit(catalog.account.trackAccountPasswordChange(account, user, triggerFor(ctx, account.userId), locationFor(ctx)));
+					} },
+					delete: { after: async (rawAccount, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						const account = rawAccount;
+						if (!account.userId) return;
+						const user = await fetchUserBy(ctx, "id", account.userId);
+						await emit(catalog.account.trackAccountUnlink(account, user, triggerFor(ctx, account.userId), locationFor(ctx)));
+					} }
+				},
+				verification: {
+					create: { after: async (rawVerification, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						if (!matchesAnyRoute(ctx.path, [ROUTES.REQUEST_PASSWORD_RESET])) return;
+						const verification = rawVerification;
+						const sessionUserId = ctx.context.session?.user?.id ?? "unknown";
+						const trigger = getTriggerInfo(ctx.path, sessionUserId, sessionUserId);
+						const user = await fetchUserBy(ctx, "id", verification.value);
+						await emit(catalog.verification.trackPasswordResetRequest(verification, user, trigger, locationFor(ctx)));
+					} },
+					delete: { after: async (rawVerification, rawCtx) => {
+						const ctx = narrowRequestCtx(rawCtx);
+						if (!ctx) return;
+						if (!matchesAnyRoute(ctx.path, [ROUTES.RESET_PASSWORD])) return;
+						const verification = rawVerification;
+						const sessionUserId = ctx.context.session?.user?.id ?? "unknown";
+						const trigger = getTriggerInfo(ctx.path, sessionUserId, sessionUserId);
+						const user = await fetchUserBy(ctx, "id", verification.value);
+						await emit(catalog.verification.trackPasswordResetRequestCompletion(verification, user, trigger, locationFor(ctx)));
+					} }
+				}
+			} } };
+		},
+		hooks: {
+			before: [{
+				matcher: () => true,
+				handler: createAuthMiddleware(async (rawCtx) => {
+					const ctx = rawCtx;
+					if (!ctx.context) return;
+					const headers = ctx.headers ?? ctx.request?.headers;
+					ctx.context.location = extractLocationFromHeaders(headers);
+				})
+			}],
+			after: [{
+				matcher: (ctx) => {
+					const c = ctx;
+					if (c.request?.method !== "GET") return true;
+					if (!c.request.url) return false;
+					try {
+						const p = new URL(c.request.url).pathname;
+						return matchesAnyRoute(p, [ROUTES.SIGN_IN_SOCIAL_CALLBACK, ROUTES.SIGN_IN_OAUTH_CALLBACK]);
+					} catch {
+						return false;
+					}
+				},
+				handler: createAuthMiddleware(async (rawCtx) => {
+					const ctx = narrowRequestCtx(rawCtx);
+					if (!ctx) return;
+					const sessionUser = ctx.context.session?.user;
+					const sessionUserId = sessionUser?.id ?? "unknown";
+					const trigger = getTriggerInfo(ctx.path, sessionUserId, sessionUserId);
+					const location = locationFor(ctx);
+					const returned = ctx.context.returned;
+					const isErrored = returned instanceof Error;
+					if (matchesAnyRoute(ctx.path, [ROUTES.SEND_VERIFICATION_EMAIL]) && ctx.context.session && !isErrored) {
+						const sessionEntity = ctx.context.session.session;
+						const user = ctx.context.session.user;
+						if (sessionEntity && user) {
+							await emit(catalog.session.trackEmailVerificationSent(sessionEntity, user, trigger));
+						}
+					}
+					const body = ctx.body ?? null;
+					if (matchesAnyRoute(ctx.path, [ROUTES.SIGN_IN_EMAIL, ROUTES.SIGN_IN_EMAIL_OTP]) && isErrored && body?.email) {
+						const user = await fetchUserBy(ctx, "email", body.email);
+						await emit(catalog.session.trackEmailSignInAttempt({
+							email: body.email,
+							loginMethod: getLoginMethod(ctx.path, ctx.params?.id)
+						}, user, trigger, location));
+					}
+					if (matchesAnyRoute(ctx.path, [ROUTES.SIGN_IN_SOCIAL]) && isErrored && body?.provider && body?.idToken) {
+						await emit(catalog.session.trackSocialSignInAttempt({ loginMethod: getLoginMethod(ctx.path, ctx.params?.id) }, null, trigger, location));
+					}
+					if (matchesAnyRoute(ctx.path, [ROUTES.SIGN_IN_SOCIAL_CALLBACK]) && isErrored) {
+						await emit(catalog.session.trackSocialSignInRedirectionAttempt({ loginMethod: getLoginMethod(ctx.path, ctx.params?.id) }, null, trigger, location));
+					}
+				})
+			}]
+		}
+	};
+}
+function installOrganizationHooks(pluginCtx, catalog, emit, logger) {
+	const getPlugin = pluginCtx?.getPlugin;
+	const organizationPlugin = typeof getPlugin === "function" ? getPlugin.call(pluginCtx, "organization") : null;
+	if (!organizationPlugin || typeof organizationPlugin !== "object") {
+		logger.debug("organization plugin not active; skipping instrumentation");
+		return;
+	}
+	const orgPlugin = organizationPlugin;
+	orgPlugin.options = orgPlugin.options ?? {};
+	const hooks = orgPlugin.options.organizationHooks = orgPlugin.options.organizationHooks ?? {};
+	wrapOrgHook(hooks, "afterCreateOrganization", async (p) => emit(catalog.organization.trackOrganizationCreated(p.organization, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterUpdateOrganization", async (p) => {
+		if (!p.organization) return;
+		await emit(catalog.organization.trackOrganizationUpdated(p.organization, getOrganizationTriggerInfo(p.user)));
+	});
+	wrapOrgHook(hooks, "afterAddMember", async (p) => emit(catalog.member.trackOrganizationMemberAdded(p.organization, p.member, p.user, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterRemoveMember", async (p) => emit(catalog.member.trackOrganizationMemberRemoved(p.organization, p.member, p.user, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterUpdateMemberRole", async (p) => emit(catalog.member.trackOrganizationMemberRoleUpdated(p.organization, p.member, p.user, p.previousRole, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterCreateInvitation", async (p) => emit(catalog.invitation.trackOrganizationMemberInvited(p.organization, p.invitation, p.inviter, getOrganizationTriggerInfo(p.inviter))));
+	wrapOrgHook(hooks, "afterAcceptInvitation", async (p) => emit(catalog.invitation.trackOrganizationMemberInviteAccepted(p.organization, p.invitation, p.member, p.user, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterRejectInvitation", async (p) => emit(catalog.invitation.trackOrganizationMemberInviteRejected(p.organization, p.invitation, p.user, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterCancelInvitation", async (p) => emit(catalog.invitation.trackOrganizationMemberInviteCanceled(p.organization, p.invitation, p.cancelledBy, getOrganizationTriggerInfo(p.cancelledBy))));
+	wrapOrgHook(hooks, "afterCreateTeam", async (p) => emit(catalog.team.trackOrganizationTeamCreated(p.organization, p.team, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterUpdateTeam", async (p) => {
+		if (!p.team) return;
+		await emit(catalog.team.trackOrganizationTeamUpdated(p.organization, p.team, getOrganizationTriggerInfo(p.user)));
+	});
+	wrapOrgHook(hooks, "afterDeleteTeam", async (p) => emit(catalog.team.trackOrganizationTeamDeleted(p.organization, p.team, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterAddTeamMember", async (p) => emit(catalog.team.trackOrganizationTeamMemberAdded(p.organization, p.team, p.user, p.teamMember, getOrganizationTriggerInfo(p.user))));
+	wrapOrgHook(hooks, "afterRemoveTeamMember", async (p) => emit(catalog.team.trackOrganizationTeamMemberRemoved(p.organization, p.team, p.user, p.teamMember, getOrganizationTriggerInfo(p.user))));
+}
+
+//#endregion
+export { sonamuAuditLog };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugin.js","names":["ipAddress: string | null","enrichedSession: SessionSnapshot","trigger: BuilderTrigger"],"sources":["../../../src/auth/audit-log/plugin.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport { type BetterAuthPlugin } from \"better-auth\";\nimport { createAuthMiddleware } from \"better-auth/api\";\n\nimport { DB } from \"../../database/db\";\nimport { ingestAuditEvent } from \"../audit-log-ingestor\";\nimport { buildAuditEventCatalog } from \"./builders\";\nimport {\n  type AccountSnapshot,\n  type AuditLogEvent,\n  type BuilderLocation,\n  type BuilderTrigger,\n  type InvitationSnapshot,\n  type MemberSnapshot,\n  type OrganizationSnapshot,\n  ROUTES,\n  type SessionSnapshot,\n  type TeamSnapshot,\n  type UserProfileLite,\n  type UserSnapshot,\n  type VerificationSnapshot,\n} from \"./events\";\n\n// ============================================================================\n// 라우팅/트리거 유틸\n// ============================================================================\nconst stripQuery = (value: string): string => value.split(\"?\")[0] || value;\nconst escapeRegex = (value: string): string => value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\nconst routeToRegex = (route: string): RegExp => {\n  const pattern = escapeRegex(stripQuery(route)).replace(/\\/:([^/]+)/g, \"/[^/]+\");\n  return new RegExp(`${pattern}(?:$|[/?])`);\n};\nconst matchesAnyRoute = (routePath: string | undefined, routes: readonly string[]): boolean => {\n  if (!routePath) return false;\n  const cleanPath = stripQuery(routePath);\n  return routes.some((route) => routeToRegex(route).test(cleanPath));\n};\n\nconst LOGIN_PATHS = [\n  ROUTES.SIGN_IN_SOCIAL_CALLBACK,\n  ROUTES.SIGN_IN_OAUTH_CALLBACK,\n  ROUTES.SIGN_IN_EMAIL,\n  ROUTES.SIGN_IN_SOCIAL,\n  ROUTES.SIGN_IN_EMAIL_OTP,\n  ROUTES.SIGN_UP_EMAIL,\n] as const;\n\n// dash 319-323 미러: 현재 요청 path에서 로그인 방식을 추출한다.\nconst getLoginMethod = (ctxPath: string | undefined, paramsId?: string): string | null => {\n  if (!ctxPath) return null;\n  if (matchesAnyRoute(ctxPath, LOGIN_PATHS)) {\n    if (paramsId) return paramsId;\n    return ctxPath.split(\"/\").pop() ?? null;\n  }\n  return null;\n};\n\n// dash 797-803 미러: 세션/요청에서 트리거 주체와 컨텍스트를 도출한다.\nconst getTriggerInfo = (\n  ctxPath: string | undefined,\n  sessionUserId: string | null,\n  userId: string,\n): BuilderTrigger => {\n  const resolved = sessionUserId ?? userId;\n  const triggerContext =\n    resolved === userId\n      ? \"user\"\n      : matchesAnyRoute(ctxPath, [ROUTES.ADMIN_ROUTE])\n        ? \"admin\"\n        : matchesAnyRoute(ctxPath, [ROUTES.DASH_ROUTE])\n          ? \"dashboard\"\n          : resolved === \"unknown\"\n            ? \"user\"\n            : \"unknown\";\n  return { triggeredBy: resolved, triggerContext };\n};\n\n// dash 809-814 미러: organization hook은 인증 컨텍스트 없이도 호출되므로\n// 주어진 user 객체로부터 트리거 정보를 합성한다.\nconst getOrganizationTriggerInfo = (user: { id?: string } | null | undefined): BuilderTrigger => ({\n  triggeredBy: user?.id ?? \"unknown\",\n  triggerContext: \"organization\",\n});\n\n// ============================================================================\n// better-auth ctx 타입 helpers (내부 shape은 런타임 구조를 기준으로 좁혀 사용한다)\n// ============================================================================\ntype BetterAuthRequestCtx = {\n  path?: string;\n  body?: Record<string, unknown> | null | undefined;\n  params?: Record<string, string | undefined> | null | undefined;\n  context: {\n    session?: {\n      session?: { userId?: string };\n      user?: { id?: string };\n    } | null;\n    location?: BuilderLocation | null;\n    adapter?: {\n      findOne: (args: {\n        model: string;\n        select?: string[];\n        where: { field: string; value: unknown }[];\n      }) => Promise<Record<string, unknown> | null>;\n    };\n    returned?: unknown;\n  };\n};\n\n// databaseHooks after 콜백의 ctx는 선택적이며 shape을 런타임에서 좁힌다.\nconst narrowRequestCtx = (raw: unknown): BetterAuthRequestCtx | null => {\n  if (!raw || typeof raw !== \"object\") return null;\n  const candidate = raw as { context?: unknown };\n  if (!candidate.context || typeof candidate.context !== \"object\") return null;\n  return raw as BetterAuthRequestCtx;\n};\n\n// adapter.findOne 호출 실패 시 null을 반환한다. dash 헬퍼와 동일 정책.\nconst fetchUserBy = async (\n  ctx: BetterAuthRequestCtx,\n  field: \"id\" | \"email\",\n  value: string | null | undefined,\n): Promise<UserProfileLite> => {\n  if (!value) return null;\n  const adapter = ctx.context.adapter;\n  if (!adapter) return null;\n  try {\n    const row = await adapter.findOne({\n      model: \"user\",\n      select: [\"id\", \"name\", \"email\"],\n      where: [{ field, value }],\n    });\n    if (!row) return null;\n    return {\n      id: String(row.id),\n      name: typeof row.name === \"string\" ? row.name : undefined,\n      email: typeof row.email === \"string\" ? row.email : undefined,\n    };\n  } catch {\n    return null;\n  }\n};\n\nconst isNonEmptyString = (v: unknown): v is string => typeof v === \"string\" && v.length > 0;\n\n// dash 제거 시 함께 사라진 location 공급 경로를 대체한다.\n// 우선순위: cf-connecting-ip > x-forwarded-for(첫 항목) > x-real-ip > x-vercel-forwarded-for\n// (sonamu.ts IP_HEADERS 상수와 동일)\nconst IP_HEADER_ORDER = [\n  \"cf-connecting-ip\",\n  \"x-forwarded-for\",\n  \"x-real-ip\",\n  \"x-vercel-forwarded-for\",\n] as const;\n\nconst readHeader = (headers: unknown, key: string): string | null => {\n  if (!headers) return null;\n  if (headers instanceof Headers) {\n    return headers.get(key);\n  }\n  if (typeof headers === \"object\") {\n    const map = headers as Record<string, unknown>;\n    const v = map[key] ?? map[key.toLowerCase()];\n    if (typeof v === \"string\") return v;\n    if (Array.isArray(v) && typeof v[0] === \"string\") return v[0];\n  }\n  return null;\n};\n\nconst extractLocationFromHeaders = (headers: unknown): BuilderLocation => {\n  let ipAddress: string | null = null;\n  for (const key of IP_HEADER_ORDER) {\n    const raw = readHeader(headers, key);\n    if (typeof raw === \"string\" && raw.length > 0) {\n      const first = raw.split(\",\")[0]?.trim();\n      if (first) {\n        ipAddress = first;\n        break;\n      }\n    }\n  }\n  const countryCode = readHeader(headers, \"cf-ipcountry\");\n  const city = readHeader(headers, \"cf-ipcity\");\n  return {\n    ipAddress: ipAddress ?? undefined,\n    city: city ?? undefined,\n    country: undefined,\n    countryCode: countryCode ?? undefined,\n  };\n};\n\n// ============================================================================\n// Organization hook 래핑 헬퍼\n// ============================================================================\ntype OrgHookFn = (...args: unknown[]) => Promise<unknown>;\n\n// 주어진 organizationHooks 레코드에 대해 해당 name의 기존 hook을 chain한다.\n// handler는 payload 객체(첫 번째 인자)만 받아서 audit emit을 수행한다.\nconst wrapOrgHook = <Payload>(\n  hooks: Record<string, unknown>,\n  name: string,\n  handler: (payload: Payload) => Promise<void>,\n): void => {\n  const prev = hooks[name] as OrgHookFn | undefined;\n  hooks[name] = async (...args: unknown[]): Promise<unknown> => {\n    await handler(args[0] as Payload);\n    if (prev) return prev(...args);\n    return undefined;\n  };\n};\n\n// ============================================================================\n// Plugin entry\n// ============================================================================\n/**\n * Better Auth databaseHooks/organizationHooks/middleware에서 수집한\n * 이벤트를 `DB.getDB(\"w\")`로 얻은 knex에 `ingestAuditEvent`로 적재한다.\n *\n * - dash(@better-auth/infra)의 audit-event 수집 훅 구조를 참고해 Sonamu 내부 적재 경로로 포팅한다.\n * - dash의 infra 연결/API endpoint 제공 범위는 포함하지 않고, audit-event emit/ingest 경로만 유지한다.\n * - security 4종은 R1 결정에 따라 scope out (builders.ts의 TODO 주석 참조).\n */\nexport function sonamuAuditLog(): BetterAuthPlugin {\n  const logger = getLogger([\"sonamu\", \"audit-log\"]);\n  const catalog = buildAuditEventCatalog();\n\n  // dash 7394: 동일 요청에서 세션 벌크 삭제가 다회 발생할 때 all_sessions_revoked를\n  // 한 번만 emit하도록 처리 컨텍스트를 기억한다.\n  const processedBulkOperationContexts = new WeakSet<object>();\n\n  const emit = async (event: AuditLogEvent): Promise<void> => {\n    try {\n      await ingestAuditEvent(DB.getDB(\"w\"), event);\n    } catch (err) {\n      logger.error(\"audit event ingest failed: {error}\", { error: err });\n    }\n  };\n\n  // ctx.path + session에서 사용자 트리거를 도출한다(entity.id를 subject로 사용).\n  const triggerFor = (ctx: BetterAuthRequestCtx, subjectUserId: string): BuilderTrigger =>\n    getTriggerInfo(ctx.path, ctx.context.session?.session?.userId ?? null, subjectUserId);\n\n  const locationFor = (ctx: BetterAuthRequestCtx): BuilderLocation | undefined =>\n    ctx.context.location ?? undefined;\n\n  return {\n    id: \"sonamu-audit-log\",\n\n    init(pluginCtx: unknown) {\n      installOrganizationHooks(pluginCtx, catalog, emit, logger);\n\n      // dash 7283-7449 미러: databaseHooks (user/session/account/verification).\n      return {\n        options: {\n          databaseHooks: {\n            user: {\n              create: {\n                after: async (rawUser: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  const user = rawUser as UserSnapshot;\n                  await emit(\n                    catalog.user.trackUserSignedUp(\n                      user,\n                      triggerFor(ctx, user.id),\n                      locationFor(ctx),\n                    ),\n                  );\n                },\n              },\n              update: {\n                after: async (rawUser: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  const user = rawUser as UserSnapshot & {\n                    emailVerified?: boolean;\n                    image?: string | null;\n                  };\n                  const path = ctx.path;\n                  const trigger = triggerFor(ctx, user.id);\n                  const location = locationFor(ctx);\n\n                  if (matchesAnyRoute(path, [ROUTES.UPDATE_USER, ROUTES.DASH_UPDATE_USER])) {\n                    const updatedFields = Object.keys((ctx.body as object) ?? {});\n                    const isOnlyImageUpdate =\n                      updatedFields.length === 1 && updatedFields[0] === \"image\";\n                    const isOnlyEmailVerifiedUpdate =\n                      updatedFields.length === 1 && updatedFields[0] === \"emailVerified\";\n                    const hasEmailVerifiedUpdate = updatedFields.includes(\"emailVerified\");\n                    if (isOnlyEmailVerifiedUpdate && user.emailVerified) {\n                      await emit(catalog.user.trackUserEmailVerified(user, trigger, location));\n                    } else if (isOnlyImageUpdate && user.image) {\n                      await emit(\n                        catalog.user.trackUserProfileImageUpdated(user, trigger, location),\n                      );\n                    } else if (!isOnlyImageUpdate && !isOnlyEmailVerifiedUpdate) {\n                      await emit(\n                        catalog.user.trackUserProfileUpdated(\n                          user,\n                          updatedFields,\n                          trigger,\n                          location,\n                        ),\n                      );\n                      if (hasEmailVerifiedUpdate && user.emailVerified) {\n                        await emit(catalog.user.trackUserEmailVerified(user, trigger, location));\n                      }\n                    }\n                  } else if (matchesAnyRoute(path, [ROUTES.CHANGE_EMAIL])) {\n                    const updatedFields = Object.keys((ctx.body as object) ?? {});\n                    await emit(\n                      catalog.user.trackUserProfileUpdated(user, updatedFields, trigger, location),\n                    );\n                  }\n                  if (matchesAnyRoute(path, [ROUTES.VERIFY_EMAIL]) && user.emailVerified) {\n                    await emit(catalog.user.trackUserEmailVerified(user, trigger, location));\n                  }\n                  if (\n                    matchesAnyRoute(path, [ROUTES.ADMIN_BAN_USER]) &&\n                    \"banned\" in user &&\n                    user.banned\n                  ) {\n                    await emit(catalog.user.trackUserBanned(user, trigger, location));\n                  }\n                  if (\n                    matchesAnyRoute(path, [ROUTES.ADMIN_UNBAN_USER]) &&\n                    \"banned\" in user &&\n                    !user.banned\n                  ) {\n                    await emit(catalog.user.trackUserUnBanned(user, trigger, location));\n                  }\n                },\n              },\n              delete: {\n                after: async (rawUser: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  const user = rawUser as UserSnapshot;\n                  await emit(\n                    catalog.user.trackUserDeleted(user, triggerFor(ctx, user.id), locationFor(ctx)),\n                  );\n                },\n              },\n            },\n            session: {\n              create: {\n                before: async (\n                  rawSession: unknown,\n                  rawCtx?: unknown,\n                ): Promise<{ data: { loginMethod: string | null } } | undefined> => {\n                  void rawSession;\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return undefined;\n                  return { data: { loginMethod: getLoginMethod(ctx.path, ctx.params?.id) } };\n                },\n                after: async (rawSession: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  const session = rawSession as SessionSnapshot;\n                  if (!session.userId) return;\n                  const location = locationFor(ctx);\n                  const loginMethod = getLoginMethod(ctx.path, ctx.params?.id) ?? undefined;\n                  const enrichedSession: SessionSnapshot = {\n                    ...session,\n                    loginMethod: loginMethod ?? session.loginMethod ?? null,\n                  };\n                  const user = await fetchUserBy(ctx, \"id\", session.userId);\n\n                  let trigger: BuilderTrigger;\n                  if (\n                    matchesAnyRoute(ctx.path, [\n                      ROUTES.SIGN_IN,\n                      ROUTES.SIGN_UP,\n                      ROUTES.SIGN_IN_SOCIAL_CALLBACK,\n                      ROUTES.SIGN_IN_OAUTH_CALLBACK,\n                    ])\n                  ) {\n                    trigger = getTriggerInfo(ctx.path, session.userId, session.userId);\n                    await emit(\n                      catalog.session.trackUserSignedIn(enrichedSession, user, trigger, location),\n                    );\n                  } else {\n                    trigger = triggerFor(ctx, session.userId);\n                  }\n                  await emit(\n                    catalog.session.trackSessionCreated(enrichedSession, user, trigger, location),\n                  );\n                  if (isNonEmptyString(session.impersonatedBy)) {\n                    const impersonator = await fetchUserBy(ctx, \"id\", session.impersonatedBy);\n                    await emit(\n                      catalog.session.trackUserImpersonated(\n                        enrichedSession,\n                        user,\n                        impersonator,\n                        {\n                          triggeredBy: session.impersonatedBy,\n                          triggerContext: trigger.triggerContext,\n                        },\n                        location,\n                      ),\n                    );\n                  }\n                },\n              },\n              delete: {\n                after: async (rawSession: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  const session = rawSession as SessionSnapshot;\n                  const location = locationFor(ctx);\n                  const enrichedSession: SessionSnapshot = { ...session };\n                  const user = await fetchUserBy(ctx, \"id\", session.userId);\n                  const trigger = triggerFor(ctx, session.userId);\n                  if (\n                    matchesAnyRoute(ctx.path, [\n                      ROUTES.REVOKE_ALL_SESSIONS,\n                      ROUTES.ADMIN_REVOKE_USER_SESSIONS,\n                      ROUTES.DASH_REVOKE_SESSIONS_ALL,\n                      ROUTES.DASH_BAN_USER,\n                    ])\n                  ) {\n                    if (!processedBulkOperationContexts.has(ctx)) {\n                      await emit(\n                        catalog.session.trackSessionRevokedAll(enrichedSession, user, trigger),\n                      );\n                      processedBulkOperationContexts.add(ctx);\n                    }\n                  } else if (matchesAnyRoute(ctx.path, [ROUTES.SIGN_OUT])) {\n                    await emit(\n                      catalog.session.trackUserSignedOut(enrichedSession, user, trigger, location),\n                    );\n                  } else {\n                    await emit(\n                      catalog.session.trackSessionRevoked(enrichedSession, user, trigger, location),\n                    );\n                  }\n                  if (isNonEmptyString(session.impersonatedBy)) {\n                    const impersonator = await fetchUserBy(ctx, \"id\", session.impersonatedBy);\n                    await emit(\n                      catalog.session.trackUserImpersonationStop(\n                        enrichedSession,\n                        user,\n                        impersonator,\n                        trigger,\n                        location,\n                      ),\n                    );\n                  }\n                },\n              },\n            },\n            account: {\n              create: {\n                after: async (rawAccount: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  const account = rawAccount as AccountSnapshot;\n                  if (!account.userId) return;\n                  const user = await fetchUserBy(ctx, \"id\", account.userId);\n                  await emit(\n                    catalog.account.trackAccountLinking(\n                      account,\n                      user,\n                      triggerFor(ctx, account.userId),\n                      locationFor(ctx),\n                    ),\n                  );\n                },\n              },\n              update: {\n                after: async (rawAccount: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  const account = rawAccount as AccountSnapshot;\n                  if (!account.userId) return;\n                  if (\n                    !matchesAnyRoute(ctx.path, [\n                      ROUTES.CHANGE_PASSWORD,\n                      ROUTES.SET_PASSWORD,\n                      ROUTES.RESET_PASSWORD,\n                      ROUTES.ADMIN_SET_PASSWORD,\n                    ])\n                  ) {\n                    return;\n                  }\n                  const user = await fetchUserBy(ctx, \"id\", account.userId);\n                  await emit(\n                    catalog.account.trackAccountPasswordChange(\n                      account,\n                      user,\n                      triggerFor(ctx, account.userId),\n                      locationFor(ctx),\n                    ),\n                  );\n                },\n              },\n              delete: {\n                after: async (rawAccount: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  const account = rawAccount as AccountSnapshot;\n                  if (!account.userId) return;\n                  const user = await fetchUserBy(ctx, \"id\", account.userId);\n                  await emit(\n                    catalog.account.trackAccountUnlink(\n                      account,\n                      user,\n                      triggerFor(ctx, account.userId),\n                      locationFor(ctx),\n                    ),\n                  );\n                },\n              },\n            },\n            verification: {\n              create: {\n                after: async (rawVerification: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  if (!matchesAnyRoute(ctx.path, [ROUTES.REQUEST_PASSWORD_RESET])) return;\n                  const verification = rawVerification as VerificationSnapshot;\n                  const sessionUserId = ctx.context.session?.user?.id ?? \"unknown\";\n                  const trigger = getTriggerInfo(ctx.path, sessionUserId, sessionUserId);\n                  const user = await fetchUserBy(ctx, \"id\", verification.value);\n                  await emit(\n                    catalog.verification.trackPasswordResetRequest(\n                      verification,\n                      user,\n                      trigger,\n                      locationFor(ctx),\n                    ),\n                  );\n                },\n              },\n              delete: {\n                after: async (rawVerification: unknown, rawCtx?: unknown): Promise<void> => {\n                  const ctx = narrowRequestCtx(rawCtx);\n                  if (!ctx) return;\n                  if (!matchesAnyRoute(ctx.path, [ROUTES.RESET_PASSWORD])) return;\n                  const verification = rawVerification as VerificationSnapshot;\n                  const sessionUserId = ctx.context.session?.user?.id ?? \"unknown\";\n                  const trigger = getTriggerInfo(ctx.path, sessionUserId, sessionUserId);\n                  const user = await fetchUserBy(ctx, \"id\", verification.value);\n                  await emit(\n                    catalog.verification.trackPasswordResetRequestCompletion(\n                      verification,\n                      user,\n                      trigger,\n                      locationFor(ctx),\n                    ),\n                  );\n                },\n              },\n            },\n          },\n        },\n      };\n    },\n\n    hooks: {\n      before: [\n        {\n          // dash 제거로 사라진 location 공급 경로를 복구한다.\n          // 모든 요청에서 ctx.context.location을 채워 이후 빌더들이 ipAddress/city/countryCode를 기록할 수 있게 한다.\n          matcher: () => true,\n          handler: createAuthMiddleware(async (rawCtx) => {\n            const ctx = rawCtx as {\n              headers?: unknown;\n              request?: { headers?: unknown } | undefined;\n              context?: { location?: BuilderLocation | null } & Record<string, unknown>;\n            };\n            if (!ctx.context) return;\n            const headers = ctx.headers ?? ctx.request?.headers;\n            ctx.context.location = extractLocationFromHeaders(headers);\n          }),\n        },\n      ],\n      after: [\n        {\n          // dash 7462-7487 미러: verification email send, sign-in attempts.\n          // GET 요청은 콜백 경로만 통과시킨다.\n          matcher: (ctx: unknown): boolean => {\n            const c = ctx as { request?: { method?: string; url?: string } };\n            if (c.request?.method !== \"GET\") return true;\n            if (!c.request.url) return false;\n            try {\n              const p = new URL(c.request.url).pathname;\n              return matchesAnyRoute(p, [\n                ROUTES.SIGN_IN_SOCIAL_CALLBACK,\n                ROUTES.SIGN_IN_OAUTH_CALLBACK,\n              ]);\n            } catch {\n              return false;\n            }\n          },\n          handler: createAuthMiddleware(async (rawCtx) => {\n            const ctx = narrowRequestCtx(rawCtx);\n            if (!ctx) return;\n            const sessionUser = ctx.context.session?.user;\n            const sessionUserId = sessionUser?.id ?? \"unknown\";\n            const trigger = getTriggerInfo(ctx.path, sessionUserId, sessionUserId);\n            const location = locationFor(ctx);\n            const returned = ctx.context.returned;\n            const isErrored = returned instanceof Error;\n\n            // verification email sent\n            if (\n              matchesAnyRoute(ctx.path, [ROUTES.SEND_VERIFICATION_EMAIL]) &&\n              ctx.context.session &&\n              !isErrored\n            ) {\n              const sessionEntity = ctx.context.session.session as SessionSnapshot | undefined;\n              const user = ctx.context.session.user as\n                | { name?: string; email?: string }\n                | undefined;\n              if (sessionEntity && user) {\n                await emit(\n                  catalog.session.trackEmailVerificationSent(sessionEntity, user, trigger),\n                );\n              }\n            }\n\n            const body =\n              (ctx.body as { email?: string; provider?: string; idToken?: string } | null) ?? null;\n            // email sign-in attempt failed\n            if (\n              matchesAnyRoute(ctx.path, [ROUTES.SIGN_IN_EMAIL, ROUTES.SIGN_IN_EMAIL_OTP]) &&\n              isErrored &&\n              body?.email\n            ) {\n              const user = await fetchUserBy(ctx, \"email\", body.email);\n              await emit(\n                catalog.session.trackEmailSignInAttempt(\n                  { email: body.email, loginMethod: getLoginMethod(ctx.path, ctx.params?.id) },\n                  user,\n                  trigger,\n                  location,\n                ),\n              );\n            }\n            // social sign-in attempt failed (POST)\n            if (\n              matchesAnyRoute(ctx.path, [ROUTES.SIGN_IN_SOCIAL]) &&\n              isErrored &&\n              body?.provider &&\n              body?.idToken\n            ) {\n              await emit(\n                catalog.session.trackSocialSignInAttempt(\n                  { loginMethod: getLoginMethod(ctx.path, ctx.params?.id) },\n                  null,\n                  trigger,\n                  location,\n                ),\n              );\n            }\n            // social redirection callback failed (GET)\n            if (matchesAnyRoute(ctx.path, [ROUTES.SIGN_IN_SOCIAL_CALLBACK]) && isErrored) {\n              await emit(\n                catalog.session.trackSocialSignInRedirectionAttempt(\n                  { loginMethod: getLoginMethod(ctx.path, ctx.params?.id) },\n                  null,\n                  trigger,\n                  location,\n                ),\n              );\n            }\n          }),\n        },\n      ],\n    },\n  };\n}\n\n// ============================================================================\n// Organization hook 합성 (organization 플러그인이 활성화된 경우에만)\n// dash 7192-7281 미러.\n// ============================================================================\ntype EventEmitter = (event: AuditLogEvent) => Promise<void>;\ntype AuditLogger = ReturnType<typeof getLogger>;\n\nfunction installOrganizationHooks(\n  pluginCtx: unknown,\n  catalog: ReturnType<typeof buildAuditEventCatalog>,\n  emit: EventEmitter,\n  logger: AuditLogger,\n): void {\n  const getPlugin = (pluginCtx as { getPlugin?: (id: string) => unknown })?.getPlugin;\n  const organizationPlugin =\n    typeof getPlugin === \"function\" ? getPlugin.call(pluginCtx, \"organization\") : null;\n\n  if (!organizationPlugin || typeof organizationPlugin !== \"object\") {\n    logger.debug(\"organization plugin not active; skipping instrumentation\");\n    return;\n  }\n\n  const orgPlugin = organizationPlugin as {\n    options?: { organizationHooks?: Record<string, unknown> };\n  };\n  orgPlugin.options = orgPlugin.options ?? {};\n  const hooks = (orgPlugin.options.organizationHooks = orgPlugin.options.organizationHooks ?? {});\n\n  wrapOrgHook<{ organization: OrganizationSnapshot; user: UserSnapshot }>(\n    hooks,\n    \"afterCreateOrganization\",\n    async (p) =>\n      emit(\n        catalog.organization.trackOrganizationCreated(\n          p.organization,\n          getOrganizationTriggerInfo(p.user),\n        ),\n      ),\n  );\n\n  wrapOrgHook<{ organization?: OrganizationSnapshot; user: UserSnapshot }>(\n    hooks,\n    \"afterUpdateOrganization\",\n    async (p) => {\n      if (!p.organization) return;\n      await emit(\n        catalog.organization.trackOrganizationUpdated(\n          p.organization,\n          getOrganizationTriggerInfo(p.user),\n        ),\n      );\n    },\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    member: MemberSnapshot;\n    user: UserSnapshot;\n  }>(hooks, \"afterAddMember\", async (p) =>\n    emit(\n      catalog.member.trackOrganizationMemberAdded(\n        p.organization,\n        p.member,\n        p.user,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    member: MemberSnapshot;\n    user: UserSnapshot;\n  }>(hooks, \"afterRemoveMember\", async (p) =>\n    emit(\n      catalog.member.trackOrganizationMemberRemoved(\n        p.organization,\n        p.member,\n        p.user,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    member: MemberSnapshot;\n    user: UserSnapshot;\n    previousRole: string;\n  }>(hooks, \"afterUpdateMemberRole\", async (p) =>\n    emit(\n      catalog.member.trackOrganizationMemberRoleUpdated(\n        p.organization,\n        p.member,\n        p.user,\n        p.previousRole,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    invitation: InvitationSnapshot;\n    inviter: UserSnapshot;\n  }>(hooks, \"afterCreateInvitation\", async (p) =>\n    emit(\n      catalog.invitation.trackOrganizationMemberInvited(\n        p.organization,\n        p.invitation,\n        p.inviter,\n        getOrganizationTriggerInfo(p.inviter),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    invitation: InvitationSnapshot;\n    member: MemberSnapshot;\n    user: UserSnapshot;\n  }>(hooks, \"afterAcceptInvitation\", async (p) =>\n    emit(\n      catalog.invitation.trackOrganizationMemberInviteAccepted(\n        p.organization,\n        p.invitation,\n        p.member,\n        p.user,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    invitation: InvitationSnapshot;\n    user: UserSnapshot;\n  }>(hooks, \"afterRejectInvitation\", async (p) =>\n    emit(\n      catalog.invitation.trackOrganizationMemberInviteRejected(\n        p.organization,\n        p.invitation,\n        p.user,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    invitation: InvitationSnapshot;\n    cancelledBy: UserSnapshot;\n  }>(hooks, \"afterCancelInvitation\", async (p) =>\n    emit(\n      catalog.invitation.trackOrganizationMemberInviteCanceled(\n        p.organization,\n        p.invitation,\n        p.cancelledBy,\n        getOrganizationTriggerInfo(p.cancelledBy),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    team: TeamSnapshot;\n    user: UserSnapshot;\n  }>(hooks, \"afterCreateTeam\", async (p) =>\n    emit(\n      catalog.team.trackOrganizationTeamCreated(\n        p.organization,\n        p.team,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    team?: TeamSnapshot;\n    user: UserSnapshot;\n  }>(hooks, \"afterUpdateTeam\", async (p) => {\n    if (!p.team) return;\n    await emit(\n      catalog.team.trackOrganizationTeamUpdated(\n        p.organization,\n        p.team,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    );\n  });\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    team: TeamSnapshot;\n    user: UserSnapshot;\n  }>(hooks, \"afterDeleteTeam\", async (p) =>\n    emit(\n      catalog.team.trackOrganizationTeamDeleted(\n        p.organization,\n        p.team,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    team: TeamSnapshot;\n    user: UserSnapshot;\n    teamMember: { teamId: string; userId: string };\n  }>(hooks, \"afterAddTeamMember\", async (p) =>\n    emit(\n      catalog.team.trackOrganizationTeamMemberAdded(\n        p.organization,\n        p.team,\n        p.user,\n        p.teamMember,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n\n  wrapOrgHook<{\n    organization: OrganizationSnapshot;\n    team: TeamSnapshot;\n    user: UserSnapshot;\n    teamMember: { teamId: string; userId: string };\n  }>(hooks, \"afterRemoveTeamMember\", async (p) =>\n    emit(\n      catalog.team.trackOrganizationTeamMemberRemoved(\n        p.organization,\n        p.team,\n        p.user,\n        p.teamMember,\n        getOrganizationTriggerInfo(p.user),\n      ),\n    ),\n  );\n}\n"],"mappings":"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"}

package/dist/auth/audit-log-ingestor.d.ts

@@ -1,9 +1,9 @@
 import { type Knex } from "knex";
-import { type AuditLogEvent } from "./audit-log-proxy-types";
+import { type AuditLogEvent } from "./audit-log/events";
 /**
- * Better Auth dash() 이벤트를 audit_events 테이블에 적재합니다.
+ * sonamuAuditLog 플러그인이 구성한 AuditLogEvent를 audit_events 테이블에 적재합니다.
  * ON CONFLICT (dedupe_key) DO NOTHING으로 중복을 silent 무시합니다.
- * auth.auditLog: true 설정 시 sonamu 내부에서 자동으로 호출됩니다.
+ * auth.plugins에 sonamuAuditLog() 추가 시 sonamu 내부에서 자동으로 호출됩니다.
  */
 export declare function ingestAuditEvent(db: Knex, event: AuditLogEvent): Promise<void>;
 //# sourceMappingURL=audit-log-ingestor.d.ts.map

package/dist/auth/audit-log-ingestor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audit-log-ingestor.d.ts","sourceRoot":"","sources":["../../src/auth/audit-log-ingestor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAwI7D;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAwFpF"}
+{"version":3,"file":"audit-log-ingestor.d.ts","sourceRoot":"","sources":["../../src/auth/audit-log-ingestor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAuIxD;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAwFpF"}