better-auth-instantdb 1.3.0

package/src/adapter/instant-adapter.ts

@@ -0,0 +1,422 @@
+import type { BetterAuthDBSchema } from "@better-auth/core/db"
+import {
+  type InstantAdminDatabase,
+  type InstaQLParams,
+  id
+} from "@instantdb/admin"
+import {
+  createAdapterFactory,
+  type DBAdapterDebugLogOption,
+  type Where
+} from "better-auth/adapters"
+
+import { fieldNameToLabel, prettyObject } from "../lib/utils"
+import { createSchema } from "./create-schema"
+
+type Direction = "asc" | "desc"
+type Order = { [key: string]: Direction }
+
+/**
+ * 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
+}
+
+/**
+ * Builds entity name mapping from schema
+ */
+function buildEntityNameMap(
+  schema: BetterAuthDBSchema,
+  usePlural: boolean
+): Record<string, string> {
+  const entityNameMap: Record<string, string> = {}
+  for (const [key, table] of Object.entries(schema)) {
+    const { modelName } = table
+    entityNameMap[modelName] = getEntityName(modelName, key, usePlural)
+  }
+  return entityNameMap
+}
+
+/**
+ * Creates link transactions for fields with references
+ */
+function createLinkTransactions({
+  db,
+  model,
+  modelSchema,
+  data,
+  entityNameMap
+}: {
+  db: InstantAdminDatabase<any, any>
+  model: string
+  modelSchema: BetterAuthDBSchema[string]
+  data: Record<string, unknown>
+  entityNameMap: Record<string, string>
+}): any[] {
+  const linkTransactions: any[] = []
+  const { fields, modelName } = modelSchema
+
+  for (const [fieldKey, field] of Object.entries(fields)) {
+    const { references } = field
+
+    if (references) {
+      const { model: targetModel } = references
+      const targetEntityName = entityNameMap[targetModel]
+
+      if (!targetEntityName) {
+        console.warn(
+          `Warning: Could not find entity name for model "${targetModel}" referenced by ${modelName}.${fieldKey}`
+        )
+        continue
+      }
+
+      // Check if data has a value for this reference field
+      const fieldValue = data[fieldKey]
+      if (fieldValue != null) {
+        // Generate forward label from field name, using target model if field doesn't end with "id"
+        const forwardLabel = fieldNameToLabel(fieldKey, targetModel)
+
+        // Create link transaction
+        const linkParams: Record<string, string | string[]> = {
+          [forwardLabel]: fieldValue as string | string[]
+        }
+        const linkTransaction = db.tx[model][data.id as string].link(linkParams)
+
+        linkTransactions.push(linkTransaction)
+      }
+    }
+  }
+
+  return linkTransactions
+}
+
+/**
+ * The InstantDB adapter config options.
+ */
+interface InstantAdapterConfig {
+  /**
+   * The InstantDB admin database instance.
+   */
+  db: InstantAdminDatabase<any, any>
+  /**
+   * If the table names in the schema are plural.
+   */
+  usePlural?: boolean
+  /**
+   * Helps you debug issues with the adapter.
+   */
+  debugLogs?: DBAdapterDebugLogOption
+}
+
+/**
+ * The InstantDB adapter.
+ */
+export const instantAdapter = ({
+  db,
+  usePlural = true,
+  debugLogs = false
+}: InstantAdapterConfig) => {
+  return createAdapterFactory({
+    config: {
+      customIdGenerator: id,
+      adapterId: "instantdb-adapter", // A unique identifier for the adapter.
+      adapterName: "InstantDB Adapter", // The name of the adapter.
+      usePlural, // Whether the table names in the schema are plural.
+      debugLogs, // Whether to enable debug logs.
+      supportsJSON: true, // Whether the database supports JSON. (Default: false)
+      supportsDates: false, // Whether the database supports dates. (Default: true)
+      supportsBooleans: true, // Whether the database supports booleans. (Default: true)
+      supportsNumericIds: false // Whether the database supports auto-incrementing numeric IDs. (Default: true)
+    },
+    adapter: ({ debugLog, getDefaultModelName, getFieldName, schema }) => {
+      return {
+        create: async ({ data, model }) => {
+          const defaultModelName = getDefaultModelName(model)
+          const modelSchema = schema[defaultModelName]
+
+          // Create the InstantDB token and override session.token
+          if (defaultModelName === "session") {
+            // Get the $users entity for this session's userId
+            const result = await db.query({
+              $users: { $: { where: { id: data.userId } } }
+            })
+
+            const $users = result.$users
+
+            if (!$users.length) {
+              throw new Error(`$users entity not found: ${data.userId}`)
+            }
+
+            const $user = $users[0]
+
+            // Create the InstantDB token and override session.token
+
+            debugLog("Create Token", $user.email)
+
+            const token = await db.auth.createToken($user.email as string)
+            const tokenField = getFieldName({ model, field: "token" })
+
+            Object.assign(data, { [tokenField]: token })
+          }
+
+          if (defaultModelName === "user") {
+            model = "$users"
+          }
+
+          debugLog("Create", model, prettyObject(data))
+
+          // Build entity name map for link resolution
+          const entityNameMap = buildEntityNameMap(schema, usePlural)
+
+          // Create the main entity transaction
+          const createTransaction = db.tx[model][data.id].create(data)
+
+          // Create link transactions for fields with references
+          const linkTransactions = createLinkTransactions({
+            db,
+            model,
+            modelSchema,
+            data,
+            entityNameMap
+          })
+
+          // Combine all transactions and execute in a single transaction
+          const allTransactions = [createTransaction, ...linkTransactions]
+          await db.transact(allTransactions)
+
+          return data
+        },
+        update: async ({ update, model, where }) => {
+          if (getDefaultModelName(model) === "user") {
+            model = "$users"
+          }
+
+          const entities = await fetchEntities({ db, model, where, debugLog })
+
+          if (!entities.length) return null
+
+          debugLog(
+            "Update:",
+            entities.map((entity) => entity.id),
+            prettyObject(update)
+          )
+
+          const transactions = entities.map((entity) =>
+            db.tx[model][entity.id].update(update as Record<string, unknown>)
+          )
+
+          await db.transact(transactions)
+
+          return { ...entities[0], ...update }
+        },
+        updateMany: async ({ update, model, where }) => {
+          if (getDefaultModelName(model) === "user") {
+            model = "$users"
+          }
+
+          const entities = await fetchEntities({ db, model, where, debugLog })
+
+          if (!entities.length) return 0
+
+          debugLog(
+            "Update:",
+            entities.map((entity) => entity.id),
+            prettyObject(update)
+          )
+
+          const transactions = entities.map((entity) =>
+            db.tx[model][entity.id].update(update)
+          )
+
+          await db.transact(transactions)
+
+          return entities.length
+        },
+        delete: async ({ model, where }) => {
+          if (getDefaultModelName(model) === "user") {
+            model = "$users"
+          }
+
+          const entities = await fetchEntities({ db, model, where, debugLog })
+
+          if (!entities.length) return
+
+          const transactions = entities.map((entity) =>
+            db.tx[model][entity.id].delete()
+          )
+
+          await db.transact(transactions)
+
+          if (getDefaultModelName(model) === "session") {
+            Promise.all(
+              entities.map(async (entity) => {
+                try {
+                  const tokenField = getFieldName({ model, field: "token" })
+                  await db.auth.signOut({
+                    refresh_token: entity[tokenField]
+                  })
+                } catch {}
+              })
+            )
+          }
+        },
+        deleteMany: async ({ model, where }) => {
+          if (getDefaultModelName(model) === "user") {
+            model = "$users"
+          }
+
+          const entities = await fetchEntities({ db, model, where, debugLog })
+
+          if (!entities.length) return 0
+
+          const transactions = entities.map((entity) =>
+            db.tx[model][entity.id].delete()
+          )
+
+          await db.transact(transactions)
+
+          if (getDefaultModelName(model) === "session") {
+            Promise.all(
+              entities.map(async (entity) => {
+                try {
+                  const tokenField = getFieldName({ model, field: "token" })
+                  await db.auth.signOut({
+                    refresh_token: entity[tokenField]
+                  })
+                } catch {}
+              })
+            )
+          }
+
+          return entities.length
+        },
+        findOne: async ({ model, where }) => {
+          if (getDefaultModelName(model) === "user") {
+            model = "$users"
+          }
+
+          const entities = await fetchEntities({ db, model, where, debugLog })
+
+          if (entities.length) return entities[0]
+
+          return null
+        },
+        findMany: async ({ model, where, limit, sortBy, offset }) => {
+          if (getDefaultModelName(model) === "user") {
+            model = "$users"
+          }
+
+          const entities = await fetchEntities({
+            db,
+            model,
+            where,
+            limit,
+            sortBy,
+            offset,
+            debugLog
+          })
+
+          return entities
+        },
+        count: async ({ model, where }) => {
+          if (getDefaultModelName(model) === "user") {
+            model = "$users"
+          }
+
+          const entities = await fetchEntities({ db, model, where, debugLog })
+
+          return entities.length
+        },
+        createSchema: async ({ file = "./auth.schema.ts", tables }) => {
+          const code = createSchema(tables, usePlural)
+          return { code, path: file }
+        }
+      }
+    }
+  })
+}
+
+async function fetchEntities({
+  db,
+  debugLog,
+  model,
+  where,
+  limit,
+  offset,
+  sortBy
+}: {
+  db: InstantAdminDatabase<any, any>
+  debugLog: (...args: any[]) => void
+  model: string
+  where?: Where[]
+  limit?: number
+  offset?: number
+  sortBy?: { field: string; direction: "asc" | "desc" }
+}) {
+  let order: Order | undefined
+  if (sortBy) {
+    order = {
+      [sortBy.field]: sortBy.direction
+    }
+  }
+
+  const query = {
+    [model]: { $: { where: parseWhere(where), limit, offset, order } }
+  } as InstaQLParams<any>
+
+  debugLog("Query", prettyObject(query))
+
+  const result = await db.query(query)
+
+  debugLog("Result", prettyObject(result))
+
+  return result[model] as any[]
+}
+
+export function parseWhere(where?: Where[]) {
+  const whereQuery = {} as Record<string, unknown>
+  where?.forEach((item) => {
+    switch (item.operator) {
+      case "eq":
+        whereQuery[item.field] = item.value
+        break
+      case "in":
+        whereQuery[item.field] = { $in: item.value }
+        break
+      case "contains":
+        whereQuery[item.field] = { $like: `%${item.value}%` }
+        break
+      case "starts_with":
+        whereQuery[item.field] = { $like: `${item.value}%` }
+        break
+      case "ends_with":
+        whereQuery[item.field] = { $like: `%${item.value}` }
+        break
+      case "ne":
+        whereQuery[item.field] = { $not: item.value }
+        break
+      case "gt":
+        whereQuery[item.field] = { $gt: item.value }
+        break
+      case "gte":
+        whereQuery[item.field] = { $gte: item.value }
+        break
+      case "lt":
+        whereQuery[item.field] = { $lt: item.value }
+        break
+      case "lte":
+        whereQuery[item.field] = { $lte: item.value }
+        break
+    }
+  })
+
+  return whereQuery
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./adapter/instant-adapter"
+export * from "./shared/instant-auth"

package/src/lib/utils.ts

@@ -0,0 +1,24 @@
+import util from "node:util"
+
+/**
+ * Pretty an object.
+ * @param object - The object to pretty.
+ * @returns The pretty object.
+ */
+export function prettyObject(object: unknown) {
+  return util.inspect(object, { colors: true, depth: null })
+}
+
+/**
+ * Converts a field name to a relationship label
+ * e.g., "userId" -> "user", "organizationId" -> "organization"
+ * If field doesn't end with "id", uses the target model name
+ */
+export function fieldNameToLabel(fieldName: string, targetModel: string): string {
+  // Remove "Id" suffix if present
+  if (fieldName.toLowerCase().endsWith("id")) {
+    return fieldName.slice(0, -2)
+  }
+  // If it doesn't end with "id", use the target model name
+  return targetModel
+}

package/src/react/index.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/src/react/instant-auth.tsx

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

package/src/react/types.ts

@@ -0,0 +1,9 @@
+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/src/react/use-hydrated.ts

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

package/src/react/use-instant-auth.ts

@@ -0,0 +1,28 @@
+import type { InstantReactWebDatabase } from "@instantdb/react"
+import { useEffect } from "react"
+
+import { instantAuth } from "../shared/instant-auth"
+import type { MinimalAuthClient, SessionResult } from "./types"
+import { usePersistentSession } from "./use-persistent-session"
+
+export interface InstantAuthProps<TSessionResult extends SessionResult> {
+  db: InstantReactWebDatabase<any, any>
+  authClient: MinimalAuthClient<TSessionResult>
+  persistent?: boolean
+}
+
+export function useInstantAuth<TSessionResult extends SessionResult>({
+  db,
+  authClient,
+  persistent
+}: InstantAuthProps<TSessionResult>) {
+  const { isPending, data } = persistent
+    ? usePersistentSession(authClient)
+    : authClient.useSession()
+
+  useEffect(() => {
+    if (isPending) return
+
+    instantAuth(db, data?.session)
+  }, [db, isPending, data?.session])
+}

package/src/react/use-instant-session.ts

@@ -0,0 +1,46 @@
+import type { BetterFetchError } from "better-auth/react"
+
+import type { SessionResult } from "./types"
+import type { InstantAuthProps } from "./use-instant-auth"
+import { usePersistentSession } from "./use-persistent-session"
+
+export function useInstantSession<TSessionResult extends SessionResult>({
+  db,
+  authClient,
+  persistent
+}: InstantAuthProps<TSessionResult>) {
+  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 (data?.$users?.length) {
+    const user = data.$users[0]
+
+    if (sessionData?.user?.id === user.id) {
+      sessionData.user = user as typeof sessionData.user
+    }
+  }
+
+  return {
+    data: !authError && !authPending ? sessionData : null,
+    isPending: authPending || isPending,
+    isRefetching: authPending || isRefetching,
+    error: (authError as BetterFetchError) || error,
+    ...rest
+  }
+}

package/src/react/use-persistent-session.ts

@@ -0,0 +1,64 @@
+import { useEffect } from "react"
+
+import type { MinimalAuthClient, SessionResult } from "./types"
+import { useHydrated } from "./use-hydrated"
+
+let lastPersisted: any | undefined | null
+let restoredData: any | undefined | null
+
+export function usePersistentSession<
+  TSessionResult extends SessionResult,
+  TAuthClient extends MinimalAuthClient<TSessionResult>
+>(authClient: TAuthClient) {
+  const { data, isPending, isRefetching, error, ...rest } =
+    authClient.useSession()
+  const hydrated = useHydrated()
+
+  useEffect(() => {
+    if (isPending) return
+
+    const persistSession = () => {
+      if (!data || lastPersisted?.session.id === 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) as TSessionResult
+        restoredData = data
+      } else {
+        restoredData = null
+      }
+    }
+
+    if (restoredData) {
+      return {
+        data: restoredData,
+        isPending: false,
+        isRefetching: false,
+        error: null,
+        ...rest
+      } as TSessionResult
+    }
+  }
+
+  return { data, isPending, isRefetching, error, ...rest }
+}

package/src/shared/instant-auth.ts

@@ -0,0 +1,18 @@
+import type { InstantCoreDatabase } from "@instantdb/core"
+import type { InstantReactWebDatabase } from "@instantdb/react"
+import type { Session } from "better-auth"
+
+export async function instantAuth(
+  db: InstantCoreDatabase<any, any> | InstantReactWebDatabase<any, any>,
+  session?: Session
+) {
+  const user = await db.getAuth()
+
+  if (session && user?.id !== session?.userId) {
+    db.auth.signInWithToken(session.token)
+  }
+
+  if (!session && user) {
+    db.auth.signOut()
+  }
+}