@stotles/better-auth-audit-logs 0.4.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ejiro Asiuwhu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,319 @@
+# @stotles/better-auth-audit-logs
+
+[![npm version](https://img.shields.io/npm/v/@stotles/better-auth-audit-logs)](https://www.npmjs.com/package/@stotles/better-auth-audit-logs)
+[![npm downloads](https://img.shields.io/npm/dm/@stotles/better-auth-audit-logs)](https://www.npmjs.com/package/@stotles/better-auth-audit-logs)
+[![license](https://img.shields.io/npm/l/@stotles/better-auth-audit-logs)](https://github.com/Stotles/better-auth-audit-logs/blob/main/LICENSE)
+
+Audit log plugin for [Better Auth](https://better-auth.com). Automatically captures auth events with IP, user agent, and severity — zero config required.
+
+**Requires** `better-auth >= 1.0.0` and `typescript >= 5`.
+
+## Quick start
+
+```bash
+npm install @stotles/better-auth-audit-logs
+```
+
+```ts
+import { betterAuth } from "better-auth";
+import { auditLog } from "@stotles/better-auth-audit-logs";
+
+export const auth = betterAuth({
+  plugins: [auditLog()],
+});
+```
+
+Then generate and run the migration:
+
+```bash
+npx @better-auth/cli generate
+```
+
+That's it. All auth events are now logged automatically.
+
+## Schema
+
+The plugin adds an `auditLog` table. If you prefer to manage your schema manually, copy the relevant definition:
+
+<details>
+<summary>Prisma</summary>
+
+```prisma
+model AuditLog {
+  id        String   @id @default(cuid())
+  userId    String?
+  action    String
+  status    String
+  severity  String
+  ipAddress String?
+  userAgent String?
+  metadata  String?
+  createdAt DateTime @default(now())
+
+  user User? @relation(fields: [userId], references: [id], onDelete: SetNull)
+
+  @@index([userId])
+  @@index([action])
+  @@index([createdAt])
+  @@map("auditLog")
+}
+```
+
+</details>
+
+<details>
+<summary>Drizzle</summary>
+
+```ts
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { user } from "./auth-schema"; // your existing user table
+
+export const auditLog = sqliteTable("auditLog", {
+  id: text("id").primaryKey(),
+  userId: text("userId").references(() => user.id, { onDelete: "set null" }),
+  action: text("action").notNull(),
+  status: text("status").notNull(),
+  severity: text("severity").notNull(),
+  ipAddress: text("ipAddress"),
+  userAgent: text("userAgent"),
+  metadata: text("metadata"),
+  createdAt: integer("createdAt", { mode: "timestamp" }).notNull(),
+});
+```
+
+</details>
+
+<details>
+<summary>MongoDB</summary>
+
+```ts
+// Collection: auditLog
+{
+  _id: ObjectId,
+  userId: String | null,       // references user collection
+  action: String,              // e.g. "sign-in:email"
+  status: String,              // "success" | "failed"
+  severity: String,            // "low" | "medium" | "high" | "critical"
+  ipAddress: String | null,
+  userAgent: String | null,
+  metadata: String | null,     // JSON string
+  createdAt: Date
+}
+
+// Recommended indexes
+db.auditLog.createIndex({ userId: 1 })
+db.auditLog.createIndex({ action: 1 })
+db.auditLog.createIndex({ createdAt: 1 })
+```
+
+</details>
+
+## Client plugin
+
+```ts
+import { createAuthClient } from "better-auth/client";
+import { auditLogClient } from "@stotles/better-auth-audit-logs/client";
+
+export const authClient = createAuthClient({
+  plugins: [auditLogClient()],
+});
+```
+
+```ts
+// List recent failed sign-ins
+const { data } = await authClient.auditLog.listAuditLogs({
+  query: { status: "failed", limit: 20 },
+});
+
+// Single entry by ID
+const { data: entry } = await authClient.auditLog.getAuditLog({
+  params: { id: "log-entry-id" },
+});
+
+// Manually log custom events (admin actions, data exports, etc.)
+await authClient.auditLog.insertAuditLog({
+  action: "admin:user-export",
+  status: "success",
+  severity: "high",
+  metadata: { exportedCount: 500 },
+});
+```
+
+## What gets logged
+
+All auth `POST` endpoints are captured by default:
+
+| Event | Path | Hook |
+|---|---|---|
+| Sign in | `/sign-in/email`, `/sign-in/social` | after |
+| Sign up | `/sign-up/email` | after |
+| Change/reset password | `/change-password`, `/reset-password` | after |
+| Change email | `/change-email` | after |
+| Two-factor | `/two-factor/*` | after |
+| OAuth callback | `/oauth/callback` | after |
+| Sign out | `/sign-out` | **before** |
+| Delete account | `/delete-user` | **before** |
+| Revoke session | `/revoke-session`, `/revoke-sessions`, `/revoke-other-sessions` | **before** |
+
+"Before" hooks fire for destructive events where the session would be lost after execution.
+
+Severity is inferred automatically (`critical` for ban/impersonate, `high` for delete/revoke/failed sign-in, `medium` for sign-in/out, `low` for everything else) and can be overridden per-path.
+
+## Configuration
+
+All options are optional:
+
+```ts
+auditLog({
+  enabled: true,             // disable without removing the plugin
+  nonBlocking: false,        // fire-and-forget — never blocks auth responses
+
+  // restrict to specific paths (empty = capture all)
+  paths: [
+    "/sign-in/email",
+    { path: "/delete-user", config: { severity: "high", capture: { requestBody: true } } },
+  ],
+
+  capture: {
+    ipAddress: true,         // capture client IP
+    userAgent: true,         // capture User-Agent header
+    requestBody: false,      // include request body in metadata
+  },
+
+  piiRedaction: {
+    enabled: false,          // redact sensitive fields when requestBody is captured
+    strategy: "mask",        // "mask" (***) | "hash" (SHA-256) | "remove" (delete key)
+    fields: ["password"],    // defaults: password, token, secret, apiKey, otp, etc.
+  },
+
+  retention: {
+    enabled: false,          // enable scheduled cleanup
+    days: 90,                // delete entries older than N days
+  },
+
+  // intercept before write — return null to suppress. Receives the endpoint
+  // ctx as a second argument, so you can resolve the session or read the request.
+  beforeLog: async (entry, ctx) => {
+    if (entry.userId === "service-account") return null;
+    return entry;
+  },
+
+  // called after each successful write
+  afterLog: async (entry) => {
+    await analytics.track("auth.event", entry);
+  },
+
+  storage: undefined,        // custom storage backend (see below)
+})
+```
+
+To override the DB model name, pass `schema: { auditLog: { modelName: "your_table_name" } }`.
+
+## Adding additional metadata to log entries
+
+`beforeLog` is the injection point for extra per-entry data. Because it receives the
+endpoint `ctx`, you can resolve the session and stash a value such as the active
+organization into `metadata` — which is stored as JSON and returned intact:
+
+```ts
+import { getSessionFromCtx } from "better-auth/api";
+
+auditLog({
+  beforeLog: async (entry, ctx) => {
+    const session = await getSessionFromCtx(ctx);
+    return {
+      ...entry,
+      metadata: {
+        ...entry.metadata,
+        activeOrganizationId: session?.session?.activeOrganizationId ?? null,
+      },
+    };
+  },
+});
+```
+
+## Custom storage
+
+Route writes to any external backend instead of Better Auth's database:
+
+```ts
+import { auditLog, type AuditLogStorage } from "@stotles/better-auth-audit-logs";
+
+const clickhouse: AuditLogStorage = {
+  async write(entry) {
+    await fetch("https://ch.example.com/insert", {
+      method: "POST",
+      body: JSON.stringify(entry),
+    });
+  },
+  // Optional — enables the query endpoints to work with your backend
+  async read(options) { /* ... */ },
+  async readById(id) { /* ... */ },
+};
+
+auditLog({ storage: clickhouse })
+```
+
+A `MemoryStorage` adapter is included for testing:
+
+```ts
+import { auditLog, MemoryStorage } from "@stotles/better-auth-audit-logs";
+
+const storage = new MemoryStorage();
+const auth = betterAuth({ plugins: [auditLog({ storage })] });
+
+// assert in tests
+expect(storage.entries).toHaveLength(1);
+expect(storage.entries[0].action).toBe("sign-in:email");
+```
+
+## API endpoints
+
+Three endpoints are registered under `/audit-log/`, all requiring an active session. Rate limited to 60 req/min.
+
+| Endpoint | Method | Description |
+|---|---|---|
+| `/audit-log/list` | `GET` | Paginated entries |
+| `/audit-log/:id` | `GET` | Single entry by ID |
+| `/audit-log/insert` | `POST` | Manually insert a custom event |
+
+**Query parameters** for `GET /audit-log/list`:
+
+| Parameter | Type | Default |
+|---|---|---|
+| `userId` | `string` | session user |
+| `action` | `string` | — |
+| `status` | `"success" \| "failed"` | — |
+| `from` | ISO date string | — |
+| `to` | ISO date string | — |
+| `limit` | `number` | `50` (max 500) |
+| `offset` | `number` | `0` |
+
+## Design decisions
+
+- **Entries survive user deletion** — `userId` uses `ON DELETE SET NULL`. Deleting a user does not erase their audit trail.
+- **`userAgent` is not returned in API responses** — stored for forensics but excluded from client queries by default.
+- **Failed sign-ins have `userId: null`** — the user isn't authenticated yet, so there's no session to pull from.
+
+## Recommended production config
+
+```ts
+auditLog({
+  nonBlocking: true,
+  piiRedaction: { enabled: true, strategy: "hash" },
+  retention: { enabled: true, days: 90 },
+  afterLog: async (entry) => {
+    if (entry.severity === "critical" || entry.severity === "high") {
+      await alerting.emit(entry);
+    }
+  },
+})
+```
+
+## Acknowledgments
+
+This plugin was inspired by the audit log design shared by [@Re4GD](https://github.com/Re4GD) in [better-auth/better-auth#1184](https://github.com/better-auth/better-auth/issues/1184). Additional inspiration from [@issamwahbi](https://github.com/issamwahbi) ([#3592](https://github.com/better-auth/better-auth/discussions/3592)) and [@ItsProless](https://github.com/ItsProless) ([#7952](https://github.com/better-auth/better-auth/discussions/7952)).
+
+## License
+
+[MIT](./LICENSE)

package/dist/adapters/index.d.ts

@@ -0,0 +1 @@
+export { MemoryStorage } from "./memory";

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC"}

package/dist/adapters/memory.d.ts

@@ -0,0 +1,13 @@
+import type { AuditLogEntry, AuditLogStorage, StorageReadOptions, StorageReadResult } from "../types";
+export interface MemoryStorageOptions {
+    maxEntries?: number;
+}
+export declare class MemoryStorage implements AuditLogStorage {
+    readonly entries: AuditLogEntry[];
+    private readonly maxEntries;
+    constructor(opts?: MemoryStorageOptions);
+    write(entry: AuditLogEntry): Promise<void>;
+    read(opts: StorageReadOptions): Promise<StorageReadResult>;
+    readById(id: string): Promise<AuditLogEntry | null>;
+    deleteOlderThan(date: Date): Promise<number>;
+}

package/dist/adapters/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/adapters/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,oBAAoB;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID,qBAAa,aAAc,YAAW,eAAe;IACnD,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,CAAM;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,IAAI,CAAC,EAAE,oBAAoB;IAIjC,KAAK,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1C,IAAI,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAmB1D,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAInD,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;CAOnD"}

package/dist/client.cjs

@@ -0,0 +1,77 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/client.ts
+var exports_client = {};
+__export(exports_client, {
+  auditLogClient: () => auditLogClient
+});
+module.exports = __toCommonJS(exports_client);
+var auditLogClient = () => ({
+  id: "audit-log",
+  $InferServerPlugin: {},
+  pathMethods: {
+    "/audit-log/list": "GET",
+    "/audit-log/:id": "GET",
+    "/audit-log/insert": "POST"
+  }
+});

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+import type { auditLog } from "./plugin";
+export declare const auditLogClient: () => {
+    id: "audit-log";
+    $InferServerPlugin: ReturnType<typeof auditLog>;
+    pathMethods: {
+        "/audit-log/list": "GET";
+        "/audit-log/:id": "GET";
+        "/audit-log/insert": "POST";
+    };
+};

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,eAAO,MAAM,cAAc;;wBAGG,UAAU,CAAC,OAAO,QAAQ,CAAC;;;;;;CAMpB,CAAC"}

package/dist/client.js

@@ -0,0 +1,13 @@
+// src/client.ts
+var auditLogClient = () => ({
+  id: "audit-log",
+  $InferServerPlugin: {},
+  pathMethods: {
+    "/audit-log/list": "GET",
+    "/audit-log/:id": "GET",
+    "/audit-log/insert": "POST"
+  }
+});
+export {
+  auditLogClient
+};

package/dist/endpoints/get-log.d.ts

@@ -0,0 +1,27 @@
+import type { AuditLogEntry, ResolvedOptions } from "../types";
+export declare function createGetLogEndpoint(opts: ResolvedOptions, modelName: string): import("better-call").StrictEndpoint<"/audit-log/:id", {
+    method: "GET";
+    use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+        session: {
+            session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+            };
+        };
+    }>)[];
+}, AuditLogEntry>;

package/dist/endpoints/get-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-log.d.ts","sourceRoot":"","sources":["../../src/endpoints/get-log.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG/D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;yBAkEgG,CAAC;yBAA4C,CAAC;;;;;;;;;qBAAwN,CAAC;;;;kBADnb"}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,3 @@
+export { createListLogsEndpoint } from "./list-logs";
+export { createGetLogEndpoint } from "./get-log";
+export { createInsertLogEndpoint } from "./insert-log";

package/dist/endpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC"}

package/dist/endpoints/insert-log.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import type { ResolvedOptions } from "../types";
+export declare function createInsertLogEndpoint(opts: ResolvedOptions, modelName: string): import("better-call").StrictEndpoint<"/audit-log/insert", {
+    method: "POST";
+    use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+        session: {
+            session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+            };
+        };
+    }>)[];
+    body: z.ZodObject<{
+        action: z.ZodString;
+        status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+        }>>>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+        metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>;
+}, {
+    success: boolean;
+}>;

package/dist/endpoints/insert-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-log.d.ts","sourceRoot":"","sources":["../../src/endpoints/insert-log.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIhD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;yBAmDkU,CAAC;yBAA4C,CAAC;;;;;;;;;qBAAwN,CAAC;;;;;;;;;;;;;;;;;;;;GADxpB"}

package/dist/endpoints/list-logs.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { ResolvedOptions } from "../types";
+export declare function createListLogsEndpoint(opts: ResolvedOptions, modelName: string): import("better-call").StrictEndpoint<"/audit-log/list", {
+    method: "GET";
+    use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+        session: {
+            session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+            };
+        };
+    }>)[];
+    query: z.ZodObject<{
+        userId: z.ZodOptional<z.ZodString>;
+        action: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+        }>>;
+        from: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+        offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    }, z.core.$strip>;
+}, import("..").StorageReadResult>;

package/dist/endpoints/list-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-logs.d.ts","sourceRoot":"","sources":["../../src/endpoints/list-logs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAiB,eAAe,EAAsB,MAAM,UAAU,CAAC;AAGnF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;yBA0DhB,CAAC;yBAGtD,CAAT;;;;;;;;;qBAMS,CAAJ;;;;;;;;;;;;;;;;mCAyCL"}

package/dist/hooks/after.d.ts

@@ -0,0 +1,6 @@
+import type { HookEndpointContext } from "@better-auth/core";
+import type { ResolvedOptions } from "../types";
+export declare function createAfterHooks(opts: ResolvedOptions, modelName: string): {
+    matcher: (context: HookEndpointContext) => boolean;
+    handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+}[];

package/dist/hooks/after.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"after.d.ts","sourceRoot":"","sources":["../../src/hooks/after.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAkB,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM;uBAGhD,mBAAmB;;IAmD3C"}

package/dist/hooks/before.d.ts

@@ -0,0 +1,6 @@
+import type { HookEndpointContext } from "@better-auth/core";
+import type { ResolvedOptions } from "../types";
+export declare function createBeforeHooks(opts: ResolvedOptions, modelName: string): {
+    matcher: (context: HookEndpointContext) => boolean;
+    handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+}[];

package/dist/hooks/before.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"before.d.ts","sourceRoot":"","sources":["../../src/hooks/before.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM;uBAGjD,mBAAmB;;IA2B3C"}

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { createBeforeHooks } from "./before";
+export { createAfterHooks } from "./after";

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC"}