better-auth-instantdb 1.3.0

package/dist/react/client-plugin.js

@@ -0,0 +1,21 @@
+export const instantDBPluginClient = ({ authClient }) => {
+    // Store the original useSession hook
+    const originalUseSession = authClient.useSession;
+    // Override useSession with custom implementation using Object.defineProperty
+    // This ensures it works even if useSession is a getter or non-writable property
+    Object.defineProperty(authClient, "useSession", {
+        value: () => {
+            // Call the original hook to get session data
+            const sessionResult = originalUseSession.call(authClient);
+            // You can add custom logic here
+            // For example, sync with InstantDB, transform data, etc.
+            console.log("useSession override called!", sessionResult);
+            // Return the session result (or modified version)
+            return sessionResult;
+        },
+        writable: true,
+        configurable: true,
+        enumerable: true
+    });
+    return authClient;
+};

package/dist/react/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./instant-auth";
+export * from "./use-instant-auth";
+export * from "./use-instant-session";
+export * from "./use-persistent-session";

package/dist/react/index.js

@@ -0,0 +1,4 @@
+export * from "./instant-auth";
+export * from "./use-instant-auth";
+export * from "./use-instant-session";
+export * from "./use-persistent-session";

package/dist/react/instant-auth.d.ts

@@ -0,0 +1,7 @@
+import type { InstantReactWebDatabase } from "@instantdb/react";
+import type { MinimalAuthClient, SessionResult } from "./types";
+export declare function InstantAuth<TSessionResult extends SessionResult>({ db, authClient, persistent }: {
+    db: InstantReactWebDatabase<any, any>;
+    authClient: MinimalAuthClient<TSessionResult>;
+    persistent?: boolean;
+}): null;

package/dist/react/instant-auth.js

@@ -0,0 +1,5 @@
+import { useInstantAuth } from "./use-instant-auth";
+export function InstantAuth({ db, authClient, persistent }) {
+    useInstantAuth({ db, authClient, persistent });
+    return null;
+}

package/dist/react/react.d.ts

@@ -0,0 +1,2 @@
+export * from "./react/instant-auth";
+export * from "./react/use-instant-auth";

package/dist/react/react.js

@@ -0,0 +1,2 @@
+export * from "./react/instant-auth";
+export * from "./react/use-instant-auth";

package/dist/react/types.d.ts

@@ -0,0 +1,6 @@
+import type { createAuthClient } from "better-auth/react";
+export type SessionResult = ReturnType<AuthClient["useSession"]>;
+export type MinimalAuthClient<TSessionResult extends SessionResult> = {
+    useSession: () => TSessionResult;
+};
+export type AuthClient = ReturnType<typeof createAuthClient>;

package/dist/react/types.js

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

package/dist/react/use-hydrated.d.ts

@@ -0,0 +1 @@
+export declare function useHydrated(): boolean;

package/dist/react/use-hydrated.js

@@ -0,0 +1,7 @@
+import { useSyncExternalStore } from "react";
+function subscribe() {
+    return () => { };
+}
+export function useHydrated() {
+    return useSyncExternalStore(subscribe, () => true, () => false);
+}

package/dist/react/use-instant-auth.d.ts

@@ -0,0 +1,8 @@
+import type { InstantReactWebDatabase } from "@instantdb/react";
+import type { MinimalAuthClient, SessionResult } from "./types";
+export interface InstantAuthProps<TSessionResult extends SessionResult> {
+    db: InstantReactWebDatabase<any, any>;
+    authClient: MinimalAuthClient<TSessionResult>;
+    persistent?: boolean;
+}
+export declare function useInstantAuth<TSessionResult extends SessionResult>({ db, authClient, persistent }: InstantAuthProps<TSessionResult>): void;

package/dist/react/use-instant-auth.js

@@ -0,0 +1,13 @@
+import { useEffect } from "react";
+import { instantAuth } from "../shared/instant-auth";
+import { usePersistentSession } from "./use-persistent-session";
+export function useInstantAuth({ db, authClient, persistent }) {
+    const { isPending, data } = persistent
+        ? usePersistentSession(authClient)
+        : authClient.useSession();
+    useEffect(() => {
+        if (isPending)
+            return;
+        instantAuth(db, data === null || data === void 0 ? void 0 : data.session);
+    }, [db, isPending, data === null || data === void 0 ? void 0 : data.session]);
+}

package/dist/react/use-instant-session.d.ts

@@ -0,0 +1,32 @@
+import type { BetterFetchError } from "better-auth/react";
+import type { SessionResult } from "./types";
+import type { InstantAuthProps } from "./use-instant-auth";
+export declare function useInstantSession<TSessionResult extends SessionResult>({ db, authClient, persistent }: InstantAuthProps<TSessionResult>): {
+    refetch: (queryParams?: {
+        query?: import("better-auth/types").SessionQueryParams;
+    }) => void;
+    data: {
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+        session: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+        };
+    } | null;
+    isPending: boolean;
+    isRefetching: boolean;
+    error: BetterFetchError;
+};

package/dist/react/use-instant-session.js

@@ -0,0 +1,25 @@
+import { usePersistentSession } from "./use-persistent-session";
+export function useInstantSession({ db, authClient, persistent }) {
+    var _a, _b;
+    const { data: sessionData, isPending, error, isRefetching, ...rest } = persistent ? usePersistentSession(authClient) : authClient.useSession();
+    const { user: authUser, error: authError } = db.useAuth();
+    const authPending = sessionData && !authUser && !authError;
+    const { data } = db.useQuery(authUser
+        ? {
+            $users: { $: { where: { id: authUser.id } } }
+        }
+        : null);
+    if ((_a = data === null || data === void 0 ? void 0 : data.$users) === null || _a === void 0 ? void 0 : _a.length) {
+        const user = data.$users[0];
+        if (((_b = sessionData === null || sessionData === void 0 ? void 0 : sessionData.user) === null || _b === void 0 ? void 0 : _b.id) === user.id) {
+            sessionData.user = user;
+        }
+    }
+    return {
+        data: !authError && !authPending ? sessionData : null,
+        isPending: authPending || isPending,
+        isRefetching: authPending || isRefetching,
+        error: authError || error,
+        ...rest
+    };
+}

package/dist/react/use-persistent-session.d.ts

@@ -0,0 +1,27 @@
+import type { MinimalAuthClient, SessionResult } from "./types";
+export declare function usePersistentSession<TSessionResult extends SessionResult, TAuthClient extends MinimalAuthClient<TSessionResult>>(authClient: TAuthClient): TSessionResult | ({
+    data: {
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+        session: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+        };
+    } | null;
+    isPending: boolean;
+    isRefetching: boolean;
+    error: import("better-auth/react").BetterFetchError | null;
+} & Omit<TSessionResult, "data" | "error" | "isPending" | "isRefetching">);

package/dist/react/use-persistent-session.js

@@ -0,0 +1,49 @@
+import { useEffect } from "react";
+import { useHydrated } from "./use-hydrated";
+let lastPersisted;
+let restoredData;
+export function usePersistentSession(authClient) {
+    const { data, isPending, isRefetching, error, ...rest } = authClient.useSession();
+    const hydrated = useHydrated();
+    useEffect(() => {
+        if (isPending)
+            return;
+        const persistSession = () => {
+            if (!data || (lastPersisted === null || lastPersisted === void 0 ? void 0 : lastPersisted.session.id) === (data === null || data === void 0 ? void 0 : data.session.id))
+                return;
+            lastPersisted = data;
+            localStorage.setItem("ba-instant-session", JSON.stringify(data));
+        };
+        const unpersistSession = () => {
+            if (data || error || (lastPersisted === null && restoredData === null))
+                return;
+            localStorage.removeItem("ba-instant-session");
+            lastPersisted = null;
+            restoredData = null;
+        };
+        persistSession();
+        unpersistSession();
+    }, [data, isPending, error]);
+    if (hydrated && !data) {
+        if (restoredData === undefined) {
+            const persisted = localStorage.getItem("ba-instant-session");
+            if (persisted) {
+                const data = JSON.parse(persisted);
+                restoredData = data;
+            }
+            else {
+                restoredData = null;
+            }
+        }
+        if (restoredData) {
+            return {
+                data: restoredData,
+                isPending: false,
+                isRefetching: false,
+                error: null,
+                ...rest
+            };
+        }
+    }
+    return { data, isPending, isRefetching, error, ...rest };
+}

package/dist/react/use-session.js

@@ -0,0 +1 @@
+"use strict";

package/dist/react/with-instant.d.ts

@@ -0,0 +1,3 @@
+import type { InstantReactWebDatabase } from "@instantdb/react";
+import type { createAuthClient } from "better-auth/react";
+export declare const withInstant: <T extends ReturnType<typeof createAuthClient>>(db: InstantReactWebDatabase<any>, authClient: T) => T;

package/dist/react/with-instant.js

@@ -0,0 +1,47 @@
+let authLoading = false;
+let auth = null;
+export const withInstant = (
+// biome-ignore lint/suspicious/noExplicitAny: any thing goes
+db, authClient) => {
+    if (typeof window === "undefined")
+        return authClient;
+    db.core.subscribeAuth((authResult) => {
+        auth = authResult;
+    });
+    authClient.$store.atoms.session.subscribe(async (value, oldValue) => {
+        const { isPending, data, error } = value;
+        if (isPending || error) {
+            const cachedSessionResult = localStorage.getItem("cached-session-result");
+            if (cachedSessionResult && !cachedSessionResult.error) {
+                authClient.$store.atoms.session.set(JSON.parse(cachedSessionResult));
+            }
+            return;
+        }
+        while (authLoading) {
+            await new Promise((resolve) => requestAnimationFrame(resolve));
+        }
+        const user = auth === null || auth === void 0 ? void 0 : auth.user;
+        if ((user === null || user === void 0 ? void 0 : user.id) === (data === null || data === void 0 ? void 0 : data.user.id))
+            return;
+        if (user && !data) {
+            authLoading = true;
+            console.log("signing out");
+            await db.auth.signOut();
+            authLoading = false;
+        }
+        if (data) {
+            authLoading = true;
+            authClient.$store.atoms.session.set(oldValue);
+            console.log("signing in with token", data.session.token);
+            await db.auth.signInWithToken(data.session.token);
+            authClient.$store.atoms.session.set(value);
+            authLoading = false;
+        }
+        localStorage.setItem("cached-session-result", JSON.stringify(value));
+    });
+    const cachedSessionResult = localStorage.getItem("cached-session-result");
+    if (cachedSessionResult) {
+        authClient.$store.atoms.session.set(JSON.parse(cachedSessionResult));
+    }
+    return authClient;
+};

package/dist/react.d.ts

@@ -0,0 +1,2 @@
+export * from "./react/instant-auth";
+export * from "./react/use-instant-auth";

package/dist/react.js

@@ -0,0 +1,2 @@
+export * from "./react/instant-auth";
+export * from "./react/use-instant-auth";

package/dist/shared/instant-auth.d.ts

@@ -0,0 +1,4 @@
+import type { InstantCoreDatabase } from "@instantdb/core";
+import type { InstantReactWebDatabase } from "@instantdb/react";
+import type { Session } from "better-auth";
+export declare function instantAuth(db: InstantCoreDatabase<any, any> | InstantReactWebDatabase<any, any>, session?: Session): Promise<void>;

package/dist/shared/instant-auth.js

@@ -0,0 +1,9 @@
+export async function instantAuth(db, session) {
+    const user = await db.getAuth();
+    if (session && (user === null || user === void 0 ? void 0 : user.id) !== (session === null || session === void 0 ? void 0 : session.userId)) {
+        db.auth.signInWithToken(session.token);
+    }
+    if (!session && user) {
+        db.auth.signOut();
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pretty prints an object.
+ * @param object - The object to pretty print.
+ * @returns The pretty printed object.
+ */
+export declare function prettyPrint(object: unknown): string;

package/dist/utils.js

@@ -0,0 +1,9 @@
+import util from "node:util";
+/**
+ * Pretty prints an object.
+ * @param object - The object to pretty print.
+ * @returns The pretty printed object.
+ */
+export function prettyPrint(object) {
+    return util.inspect(object, { colors: true, depth: null });
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "better-auth-instantdb",
+  "homepage": "https://github.com/daveycodez/better-auth-instantdb",
+  "version": "1.3.0",
+  "description": "Better Auth InstantDB Adapter",
+  "type": "module",
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "keywords": [
+    "typescript",
+    "instantdb",
+    "better",
+    "better-auth",
+    "auth",
+    "authentication",
+    "adapter"
+  ],
+  "author": "daveycodez",
+  "license": "MIT",
+  "devDependencies": {
+    "@better-auth/core": "^1.3.34",
+    "@instantdb/admin": "^0.22.51",
+    "@instantdb/core": "^0.22.51",
+    "@instantdb/react": "^0.22.51",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.5",
+    "@types/react-dom": "^19.2.3",
+    "better-auth": "^1.3.34",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@instantdb/admin": ">=0.22.0",
+    "better-auth": ">=1.3.0"
+  },
+  "peerDependenciesOptional": {
+    "@instantdb/react": ">=0.22.0",
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@instantdb/react": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "packageManager": "pnpm@10.22.0"
+}

package/src/adapter/create-schema.ts

@@ -0,0 +1,232 @@
+import type { BetterAuthDBSchema, DBFieldAttribute } from "@better-auth/core/db"
+
+import { fieldNameToLabel } from "../lib/utils"
+
+/**
+ * Converts a Better Auth field type to InstantDB field type
+ */
+function convertFieldType(
+  field: DBFieldAttribute,
+  modelName: string,
+  fieldKey: string
+) {
+  const { type, required, unique, sortable } = field
+
+  // Handle type as string or array
+  const typeStr = Array.isArray(type) ? type[0] : type
+
+  let fieldType: string
+
+  switch (typeStr) {
+    case "string":
+      fieldType = "i.string()"
+      break
+    case "boolean":
+      fieldType = "i.boolean()"
+      break
+    case "date":
+      fieldType = "i.date()"
+      break
+    case "number":
+      fieldType = "i.number()"
+      break
+    case "json":
+      fieldType = "i.json()"
+      break
+    case "number[]":
+      fieldType = "i.json()"
+      break
+    case "string[]":
+      fieldType = "i.json()"
+      break
+    default:
+      fieldType = "i.string()" // Default to string for unknown types
+  }
+
+  // Apply modifiers
+  if (unique) {
+    fieldType += ".unique()"
+  }
+
+  // Only make optional if required is explicitly false
+  // If required is true, never make it optional (even if defaultValue exists)
+  if (required === false) {
+    fieldType += ".optional()"
+  }
+
+  // Add indexed if sortable
+  if (sortable) {
+    fieldType += ".indexed()"
+  }
+
+  // For user model, ensure all fields except email end with optional()
+  if (
+    modelName === "user" &&
+    fieldKey !== "email" &&
+    !fieldType.endsWith(".optional()")
+  ) {
+    fieldType += ".optional()"
+  }
+
+  return fieldType
+}
+
+/**
+ * Gets the InstantDB entity name for a given model name
+ */
+function getEntityName(
+  modelName: string,
+  tableKey: string,
+  usePlural: boolean
+): string {
+  if (modelName === "user") {
+    return "$users"
+  }
+  return usePlural ? `${tableKey}s` : tableKey
+}
+
+/**
+ * Converts a table/model name to camelCase for link names
+ */
+function toCamelCase(str: string): string {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+}
+
+/**
+ * Creates InstantDB links from Better Auth schema references
+ */
+export function createLinks(
+  tables: BetterAuthDBSchema,
+  usePlural: boolean
+): Record<string, any> {
+  const links: Record<string, any> = {}
+  const entityNameMap: Record<string, string> = {}
+
+  // First pass: build entity name mapping
+  for (const [key, table] of Object.entries(tables)) {
+    const { modelName } = table
+    entityNameMap[modelName] = getEntityName(modelName, key, usePlural)
+  }
+
+  // Second pass: find all references and create links
+  for (const [key, table] of Object.entries(tables)) {
+    const { modelName, fields } = table
+    const sourceEntityName = getEntityName(modelName, key, usePlural)
+
+    for (const [fieldKey, field] of Object.entries(fields)) {
+      const { references } = field
+
+      if (references) {
+        const { model: targetModel, onDelete } = references
+        const targetEntityName = entityNameMap[targetModel]
+
+        if (!targetEntityName) {
+          console.warn(
+            `Warning: Could not find entity name for model "${targetModel}" referenced by ${modelName}.${fieldKey}`
+          )
+          continue
+        }
+
+        // Generate forward label from field name, using target model if field doesn't end with "id"
+        const forwardLabel = fieldNameToLabel(fieldKey, targetModel)
+
+        // Generate link name: {sourceTable}{forwardLabel}
+        // e.g., "invitations" + "Inviter" -> "invitationsInviter"
+        const sourceTableName = sourceEntityName.replace("$", "")
+        const forwardLabelCapitalized =
+          forwardLabel.charAt(0).toUpperCase() +
+          toCamelCase(forwardLabel.slice(1))
+        const linkName = `${sourceTableName}${forwardLabelCapitalized}`
+
+        // Generate reverse label (use source entity name without $ prefix)
+        const reverseLabel = sourceEntityName.replace("$", "")
+
+        // Create link definition
+        links[linkName] = {
+          forward: {
+            on: sourceEntityName,
+            has: "one",
+            label: forwardLabel,
+            onDelete: onDelete || "cascade"
+          },
+          reverse: {
+            on: targetEntityName,
+            has: "many",
+            label: reverseLabel
+          }
+        }
+      }
+    }
+  }
+
+  return links
+}
+
+/**
+ * Creates an InstantDB schema file from Better Auth schema format
+ */
+export function createSchema(
+  tables: BetterAuthDBSchema,
+  usePlural: boolean
+): string {
+  const entities: Record<string, string> = {}
+
+  for (const [key, table] of Object.entries(tables)) {
+    const { modelName, fields } = table
+
+    // For other tables, use the key as entity name
+    const entityFields: string[] = []
+
+    for (const [fieldKey, field] of Object.entries(fields)) {
+      const fieldType = convertFieldType(field, modelName, fieldKey)
+      entityFields.push(`${fieldKey}: ${fieldType}`)
+    }
+
+    // Pluralize table name if usePlural is true
+    const namespace =
+      modelName === "user" ? "$users" : usePlural ? `${key}s` : key
+    entities[namespace] =
+      `i.entity({\n      ${entityFields.join(",\n      ")}\n    })`
+  }
+
+  // Generate links from references
+  const links = createLinks(tables, usePlural)
+
+  // Generate the schema file content
+  const entitiesString = Object.entries(entities)
+    .map(([name, definition]) => `    ${name}: ${definition}`)
+    .join(",\n")
+
+  // Format links as string
+  const linksString = Object.entries(links)
+    .map(([linkName, linkDef]) => {
+      const forward = linkDef.forward
+      const reverse = linkDef.reverse
+      return `    ${linkName}: {
+      forward: {
+        on: "${forward.on}",
+        has: "${forward.has}",
+        label: "${forward.label}"${forward.onDelete ? `,\n        onDelete: "${forward.onDelete}"` : ""}
+      },
+      reverse: {
+        on: "${reverse.on}",
+        has: "${reverse.has}",
+        label: "${reverse.label}"
+      }
+    }`
+    })
+    .join(",\n")
+
+  const linksSection = linksString ? `,\n  links: {\n${linksString}\n  }` : ""
+
+  return `// Docs: https://www.instantdb.com/docs/modeling-data
+
+import { i } from "@instantdb/react"
+
+export const authSchema = i.schema({
+  entities: {
+${entitiesString}
+  }${linksSection}
+})
+`
+}