@onmax/nuxt-better-auth 0.0.2-alpha.31 → 0.0.2-alpha.32

package/dist/runtime/app/components/BetterAuthState.d.vue.ts

@@ -1,8 +1,8 @@
 declare var __VLS_1: {
-    loggedIn: any;
-    user: any;
-    session: any;
-    signOut: any;
+    loggedIn: boolean;
+    user: import("../../types.js").AuthUser | null;
+    session: import("../../types.js").AuthSession | null;
+    signOut: (options?: import("../composables/useUserSession.js").SignOutOptions) => Promise<void>;
 }, __VLS_3: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;

package/dist/runtime/app/components/BetterAuthState.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { useUserSession } from "#imports";
+import { useUserSession } from "../composables/useUserSession";
 const { loggedIn, user, session, signOut, ready } = useUserSession();
 </script>
 

package/dist/runtime/app/components/BetterAuthState.vue.d.ts

@@ -1,8 +1,8 @@
 declare var __VLS_1: {
-    loggedIn: any;
-    user: any;
-    session: any;
-    signOut: any;
+    loggedIn: boolean;
+    user: import("../../types.js").AuthUser | null;
+    session: import("../../types.js").AuthSession | null;
+    signOut: (options?: import("../composables/useUserSession.js").SignOutOptions) => Promise<void>;
 }, __VLS_3: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;

package/dist/runtime/app/composables/useAuthClient.d.ts

@@ -0,0 +1,9 @@
+import type { AppAuthClient } from '#nuxt-better-auth';
+interface RuntimeFlags {
+    client: boolean;
+    server: boolean;
+}
+export declare function getAuthRuntimeFlags(): RuntimeFlags;
+export declare function useRawAuthClient(): AppAuthClient | null;
+export declare function useAuthClient(): AppAuthClient | null;
+export {};

package/dist/runtime/app/composables/useAuthClient.js

@@ -0,0 +1,34 @@
+import createAppAuthClient from "#auth/client";
+import { useRequestURL, useRuntimeConfig } from "#imports";
+import { createVueSafeAuthProxy } from "../internal/vue-safe-auth-proxy.js";
+let _client = null;
+let _clientFacade = null;
+export function getAuthRuntimeFlags() {
+  const globalFlags = globalThis.__NUXT_BETTER_AUTH_TEST_FLAGS__;
+  if (globalFlags)
+    return globalFlags;
+  return { client: Boolean(import.meta.client), server: Boolean(import.meta.server) };
+}
+function getClient(baseURL) {
+  if (!_client)
+    _client = createAppAuthClient(baseURL);
+  return _client;
+}
+function getClientFacade(client) {
+  if (!_clientFacade)
+    _clientFacade = createVueSafeAuthProxy(client);
+  return _clientFacade;
+}
+export function useRawAuthClient() {
+  const runtimeFlags = getAuthRuntimeFlags();
+  if (!runtimeFlags.client)
+    return null;
+  const runtimeConfig = useRuntimeConfig();
+  const requestURL = useRequestURL();
+  const siteUrl = typeof runtimeConfig.public.siteUrl === "string" ? runtimeConfig.public.siteUrl : requestURL.origin;
+  return getClient(siteUrl);
+}
+export function useAuthClient() {
+  const rawClient = useRawAuthClient();
+  return rawClient ? getClientFacade(rawClient) : null;
+}

package/dist/runtime/app/composables/useAuthClientAction.d.ts

@@ -1,5 +1,3 @@
+import type { AppAuthClient } from '#nuxt-better-auth';
 import type { UserAuthActionHandle } from '../internal/auth-action-handles.js';
-import type { UseUserSessionReturn } from './useUserSession.js';
-type AppAuthClient = NonNullable<UseUserSessionReturn['client']>;
 export declare function useAuthClientAction<TArgs extends unknown[], TResult>(select: (client: AppAuthClient) => (...args: TArgs) => Promise<TResult>): UserAuthActionHandle<TArgs, TResult>;
-export {};

package/dist/runtime/app/composables/useAuthClientAction.js

@@ -1,10 +1,10 @@
-import { useUserSession } from "#imports";
 import { useAction } from "./useAction.js";
+import { useAuthClient } from "./useAuthClient.js";
 export function useAuthClientAction(select) {
   if (typeof select !== "function")
     throw new TypeError("useAuthClientAction(select) requires a selector function");
   return useAction(async (...args) => {
-    const { client } = useUserSession();
+    const client = useAuthClient();
     if (!client)
       throw new Error("Auth client is unavailable. This action can only run on client-side.");
     const method = select(client);

package/dist/runtime/app/composables/useAuthRequestFetch.d.ts

@@ -1,5 +1,5 @@
-import type { AuthApiEndpointMethod, AuthApiEndpointPath, AuthApiEndpointResponse } from '#nuxt-better-auth';
 import type { NitroFetchOptions } from 'nitropack/types';
+import type { AuthApiEndpointMethod, AuthApiEndpointPath, AuthApiEndpointResponse } from '#nuxt-better-auth';
 import { useRequestFetch } from '#imports';
 type AuthRequestFetchExtractedMethod<Options> = Options extends undefined ? 'get' : Lowercase<Extract<Exclude<Options extends {
     method?: infer Method;

package/dist/runtime/app/composables/useSignIn.js

@@ -1,8 +1,8 @@
-import { useUserSession } from "#imports";
 import { createActionHandles } from "../internal/auth-action-handles.js";
+import { useAuthActionNamespaces } from "./useUserSession.js";
 export function useSignIn(method) {
   if (method === void 0 || method === null)
     throw new TypeError("useSignIn(method) requires a sign-in method key");
-  const handles = createActionHandles(() => useUserSession().signIn, "signIn");
+  const handles = createActionHandles(() => useAuthActionNamespaces().signIn, "signIn");
   return handles[method];
 }

package/dist/runtime/app/composables/useSignUp.js

@@ -1,8 +1,8 @@
-import { useUserSession } from "#imports";
 import { createActionHandles } from "../internal/auth-action-handles.js";
+import { useAuthActionNamespaces } from "./useUserSession.js";
 export function useSignUp(method) {
   if (method === void 0 || method === null)
     throw new TypeError("useSignUp(method) requires a sign-up method key");
-  const handles = createActionHandles(() => useUserSession().signUp, "signUp");
+  const handles = createActionHandles(() => useAuthActionNamespaces().signUp, "signUp");
   return handles[method];
 }

package/dist/runtime/app/composables/useUserSession.d.ts

@@ -1,16 +1,13 @@
-import type { AppAuthClient, AuthSession, AuthUser } from '#nuxt-better-auth';
 import type { ComputedRef, Ref } from 'vue';
+import type { AuthSession, AuthUser } from '#nuxt-better-auth';
 export interface SignOutOptions {
     onSuccess?: () => void | Promise<void>;
 }
 export interface UseUserSessionReturn {
-    client: AppAuthClient | null;
     session: Ref<AuthSession | null>;
     user: Ref<AuthUser | null>;
     loggedIn: ComputedRef<boolean>;
     ready: ComputedRef<boolean>;
-    signIn: NonNullable<AppAuthClient>['signIn'];
-    signUp: NonNullable<AppAuthClient>['signUp'];
     signOut: (options?: SignOutOptions) => Promise<void>;
     waitForSession: () => Promise<void>;
     fetchSession: (options?: {
@@ -20,3 +17,7 @@ export interface UseUserSessionReturn {
     updateUser: (updates: Partial<AuthUser>) => Promise<void>;
 }
 export declare function useUserSession(): UseUserSessionReturn;
+export declare function useAuthActionNamespaces(): {
+    signIn: any;
+    signUp: any;
+};

package/dist/runtime/app/composables/useUserSession.js

@@ -1,24 +1,27 @@
-import createAppAuthClient from "#auth/client";
 import { computed, navigateTo, nextTick, useNuxtApp, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
 import { normalizeAuthActionError } from "../internal/auth-action-error.js";
 import { resolvePostAuthSuccessRedirect, withFallbackSocialCallbackURL } from "../internal/redirect-helpers.js";
 import { fetchSessionClient, fetchSessionServer, stripToken } from "../internal/session-fetch.js";
 import { isRecord } from "../internal/utils.js";
+import { createVueSafeAuthFacade, isAuthProxyProbeKey } from "../internal/vue-safe-auth-proxy.js";
 import { wrapAuthMethod } from "../internal/wrap-auth-method.js";
+import { getAuthRuntimeFlags, useRawAuthClient } from "./useAuthClient.js";
 let _sessionSignalListenerBound = false;
 let _signOutPromise = null;
-let _client = null;
-function getClient(baseURL) {
-  if (!_client)
-    _client = createAppAuthClient(baseURL);
-  return _client;
-}
-function getRuntimeFlags() {
-  const globalFlags = globalThis.__NUXT_BETTER_AUTH_TEST_FLAGS__;
-  if (globalFlags)
-    return globalFlags;
-  return { client: Boolean(import.meta.client), server: Boolean(import.meta.server) };
+function createServerOnlyActionNamespace(path) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (isAuthProxyProbeKey(prop))
+        return void 0;
+      const key = prop;
+      return async () => {
+        throw new Error(`${path}.${key}() can only be called on client-side`);
+      };
+    }
+  });
 }
+const _signInServerOnly = createServerOnlyActionNamespace("signIn");
+const _signUpServerOnly = createServerOnlyActionNamespace("signUp");
 function ensureSessionSignalListener(client, onSignal) {
   if (_sessionSignalListenerBound)
     return;
@@ -38,11 +41,10 @@ function ensureSessionSignalListener(client, onSignal) {
   });
 }
 export function useUserSession() {
-  const runtimeFlags = getRuntimeFlags();
+  const runtimeFlags = getAuthRuntimeFlags();
   const runtimeConfig = useRuntimeConfig();
-  const requestURL = useRequestURL();
   const nuxtApp = useNuxtApp();
-  const client = runtimeFlags.client ? getClient(runtimeConfig.public.siteUrl || requestURL.origin) : null;
+  const rawClient = useRawAuthClient();
   const session = useState("auth:session", () => null);
   const user = useState("auth:user", () => null);
   const authReady = useState("auth:ready", () => false);
@@ -93,18 +95,18 @@ export function useUserSession() {
   async function fetchSession(options = {}) {
     if (runtimeFlags.server)
       return fetchSessionServer(session, user, authReady, options);
-    if (client)
-      return fetchSessionClient(client, session, user, authReady, options);
+    if (rawClient)
+      return fetchSessionClient(rawClient, session, user, authReady, options);
   }
   async function updateUser(updates) {
     if (!user.value)
       return;
     const previousUser = user.value;
     user.value = { ...user.value, ...updates };
-    if (!client)
+    if (!rawClient)
       return;
     try {
-      const clientWithUpdateUser = client;
+      const clientWithUpdateUser = rawClient;
       const result = await clientWithUpdateUser.updateUser(updates);
       if (result?.error) {
         if (result.error instanceof Error)
@@ -121,8 +123,8 @@ export function useUserSession() {
       throw error;
     }
   }
-  if (runtimeFlags.client && client && !shouldSkipInitialClientSessionFetch.value) {
-    const clientSession = client.useSession();
+  if (runtimeFlags.client && rawClient && !shouldSkipInitialClientSessionFetch.value) {
+    const clientSession = rawClient.useSession();
     watch(
       () => clientSession.value,
       (newSession) => {
@@ -170,59 +172,18 @@ export function useUserSession() {
       }, 5e3);
     });
   }
-  const wrapDeps = {
-    fetchSession,
-    loggedIn,
-    waitForSession,
-    resolvePostAuthSuccessRedirect: () => resolvePostAuthSuccessRedirect(requestURL)
-  };
-  const signIn = client?.signIn ? new Proxy(client.signIn, {
-    get(target, prop) {
-      const targetRecord = target;
-      const method = targetRecord[prop];
-      if (typeof method !== "function")
-        return method;
-      const shouldSkipSessionSync = prop === "social" ? (data) => {
-        const socialData = isRecord(data) ? data : void 0;
-        return socialData?.disableRedirect !== true;
-      } : void 0;
-      const transformData = prop === "social" ? (data) => withFallbackSocialCallbackURL(data, requestURL) : void 0;
-      return wrapAuthMethod(
-        (...args) => targetRecord[prop](...args),
-        wrapDeps,
-        { shouldSkipSessionSync, transformData }
-      );
-    }
-  }) : new Proxy({}, {
-    get: (_, prop) => {
-      throw new Error(`signIn.${String(prop)}() can only be called on client-side`);
-    }
-  });
-  const signUp = client?.signUp ? new Proxy(client.signUp, {
-    get(target, prop) {
-      const targetRecord = target;
-      const method = targetRecord[prop];
-      if (typeof method !== "function")
-        return method;
-      return wrapAuthMethod((...args) => targetRecord[prop](...args), wrapDeps);
-    }
-  }) : new Proxy({}, {
-    get: (_, prop) => {
-      throw new Error(`signUp.${String(prop)}() can only be called on client-side`);
-    }
-  });
-  if (runtimeFlags.client && client && shouldSkipInitialClientSessionFetch.value) {
-    ensureSessionSignalListener(client, () => fetchSession({ force: true }));
+  if (runtimeFlags.client && rawClient && shouldSkipInitialClientSessionFetch.value) {
+    ensureSessionSignalListener(rawClient, () => fetchSession({ force: true }));
   }
   async function signOut(options) {
-    if (!client)
+    if (!rawClient)
       throw new Error("signOut can only be called on client-side");
     if (_signOutPromise) {
       await _signOutPromise;
       return;
     }
     _signOutPromise = (async () => {
-      await client.signOut();
+      await rawClient.signOut();
       clearSession();
       if (options?.onSuccess) {
         await options.onSuccess();
@@ -240,16 +201,48 @@ export function useUserSession() {
     await _signOutPromise;
   }
   return {
-    client,
     session,
     user,
     loggedIn,
     ready,
-    signIn,
-    signUp,
     signOut,
     waitForSession,
     fetchSession,
     updateUser
   };
 }
+export function useAuthActionNamespaces() {
+  const rawClient = useRawAuthClient();
+  const auth = useUserSession();
+  const requestURL = useRequestURL();
+  const wrapDeps = {
+    fetchSession: auth.fetchSession,
+    loggedIn: auth.loggedIn,
+    waitForSession: auth.waitForSession,
+    resolvePostAuthSuccessRedirect: () => resolvePostAuthSuccessRedirect(requestURL)
+  };
+  const signIn = rawClient?.signIn ? createVueSafeAuthFacade((prop) => {
+    const targetRecord = rawClient.signIn;
+    const method = targetRecord[prop];
+    if (typeof method !== "function")
+      return method;
+    const shouldSkipSessionSync = prop === "social" ? (data) => {
+      const socialData = isRecord(data) ? data : void 0;
+      return socialData?.disableRedirect !== true;
+    } : void 0;
+    const transformData = prop === "social" ? (data) => withFallbackSocialCallbackURL(data, requestURL) : void 0;
+    return wrapAuthMethod(
+      (...args) => targetRecord[prop](...args),
+      wrapDeps,
+      { shouldSkipSessionSync, transformData }
+    );
+  }) : _signInServerOnly;
+  const signUp = rawClient?.signUp ? createVueSafeAuthFacade((prop) => {
+    const targetRecord = rawClient.signUp;
+    const method = targetRecord[prop];
+    if (typeof method !== "function")
+      return method;
+    return wrapAuthMethod((...args) => targetRecord[prop](...args), wrapDeps);
+  }) : _signUpServerOnly;
+  return { signIn, signUp };
+}

package/dist/runtime/app/composables/useUserSessionState.d.ts

@@ -0,0 +1,3 @@
+import type { UseUserSessionReturn } from './useUserSession.js';
+export type UseUserSessionStateReturn = UseUserSessionReturn;
+export declare function useUserSessionState(): UseUserSessionStateReturn;

package/dist/runtime/app/composables/useUserSessionState.js

@@ -0,0 +1,4 @@
+import { useUserSession } from "./useUserSession.js";
+export function useUserSessionState() {
+  return useUserSession();
+}

package/dist/runtime/app/internal/session-fetch.d.ts

@@ -1,5 +1,5 @@
-import type { AppAuthClient, AuthSession, AuthUser } from '#nuxt-better-auth';
 import type { Ref } from 'vue';
+import type { AppAuthClient, AuthSession, AuthUser } from '#nuxt-better-auth';
 export declare function stripToken(session: AuthSession & {
     token?: string;
 }): AuthSession;

package/dist/runtime/app/internal/vue-safe-auth-proxy.d.ts

@@ -0,0 +1,3 @@
+export declare function isAuthProxyProbeKey(prop: PropertyKey): boolean;
+export declare function createVueSafeAuthFacade<T extends object>(resolve: (prop: PropertyKey, receiver: object) => unknown): T;
+export declare function createVueSafeAuthProxy<T>(target: T): T;

package/dist/runtime/app/internal/vue-safe-auth-proxy.js

@@ -0,0 +1,68 @@
+const promiseProbeKeys = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
+export function isAuthProxyProbeKey(prop) {
+  return typeof prop !== "string" || promiseProbeKeys.has(prop) || prop.startsWith("__v");
+}
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+export function createVueSafeAuthFacade(resolve) {
+  const propertyCache = /* @__PURE__ */ new Map();
+  const facadeTarget = {};
+  Object.defineProperty(facadeTarget, "__v_skip", {
+    value: true,
+    configurable: true
+  });
+  return new Proxy(facadeTarget, {
+    get(_target, prop, receiver) {
+      if (prop === "__v_skip")
+        return true;
+      if (isAuthProxyProbeKey(prop))
+        return void 0;
+      if (propertyCache.has(prop))
+        return propertyCache.get(prop);
+      const value = resolve(prop, receiver);
+      propertyCache.set(prop, value);
+      return value;
+    }
+  });
+}
+export function createVueSafeAuthProxy(target) {
+  if (!isObjectLike(target))
+    return target;
+  const cache = /* @__PURE__ */ new WeakMap();
+  const wrap = (value) => {
+    if (!isObjectLike(value))
+      return value;
+    const cached = cache.get(value);
+    if (cached)
+      return cached;
+    const propertyCache = /* @__PURE__ */ new Map();
+    const handler = {
+      get(target2, prop, receiver) {
+        if (prop === "__v_skip")
+          return true;
+        if (isAuthProxyProbeKey(prop))
+          return void 0;
+        if (propertyCache.has(prop))
+          return propertyCache.get(prop);
+        const wrapped = wrap(Reflect.get(target2, prop, receiver));
+        propertyCache.set(prop, wrapped);
+        return wrapped;
+      }
+    };
+    if (typeof value === "function") {
+      handler.apply = (target2, thisArg, args) => Reflect.apply(target2, thisArg, args);
+    }
+    const proxy = new Proxy(value, handler);
+    cache.set(value, proxy);
+    return proxy;
+  };
+  const createRootFacade = (value) => {
+    if (!isObjectLike(value))
+      return value;
+    const proxy = createVueSafeAuthFacade((prop, receiver) => wrap(Reflect.get(value, prop, receiver)));
+    cache.set(value, proxy);
+    return proxy;
+  };
+  return createRootFacade(target);
+}

package/dist/runtime/app/middleware/auth.global.js

@@ -1,7 +1,8 @@
-import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useNuxtApp, useRequestHeaders, useRuntimeConfig, useUserSession } from "#imports";
 import { defu } from "defu";
 import { createRouter, toRouteMatcher } from "radix3";
+import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useNuxtApp, useRequestHeaders, useRuntimeConfig } from "#imports";
 import { matchesUser } from "../../utils/match-user.js";
+import { useUserSession } from "../composables/useUserSession.js";
 let authRouteRulesPromise = null;
 let routeRulesMatcherPromise = null;
 export default defineNuxtRouteMiddleware(async (to) => {
@@ -25,13 +26,13 @@ export default defineNuxtRouteMiddleware(async (to) => {
     return;
   const config = useRuntimeConfig().public.auth;
   const { fetchSession, user, loggedIn } = useUserSession();
-  if (!loggedIn.value) {
+  const mode = typeof auth === "string" ? auth : auth?.only ?? "user";
+  const redirectTo = typeof auth === "object" ? auth.redirectTo : void 0;
+  if (!loggedIn.value || mode === "guest") {
     const headers = import.meta.server ? useRequestHeaders(["cookie"]) : void 0;
     const isHydratedPrerenderPayload = (import.meta.client || !import.meta.server) && nuxtApp.isHydrating && Boolean(nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached);
     await fetchSession({ headers, ...isHydratedPrerenderPayload ? { force: true } : {} });
   }
-  const mode = typeof auth === "string" ? auth : auth?.only ?? "user";
-  const redirectTo = typeof auth === "object" ? auth.redirectTo : void 0;
   if (mode === "guest") {
     if (loggedIn.value)
       return navigateTo(redirectTo ?? config?.redirects?.guest ?? "/");

package/dist/runtime/app/plugins/session.client.js

@@ -1,4 +1,5 @@
-import { defineNuxtPlugin, useUserSession } from "#imports";
+import { defineNuxtPlugin } from "#imports";
+import { useUserSession } from "../composables/useUserSession.js";
 export default defineNuxtPlugin(async (nuxtApp) => {
   const { fetchSession } = useUserSession();
   const safeFetch = async () => {

package/dist/runtime/composables.d.ts

@@ -0,0 +1,11 @@
+export { useAction } from './app/composables/useAction.js';
+export { useAuthAsyncData } from './app/composables/useAuthAsyncData.js';
+export { useAuthClient } from './app/composables/useAuthClient.js';
+export { useAuthClientAction } from './app/composables/useAuthClientAction.js';
+export { useAuthRequestFetch } from './app/composables/useAuthRequestFetch.js';
+export { useSignIn } from './app/composables/useSignIn.js';
+export { useSignUp } from './app/composables/useSignUp.js';
+export { useUserSession } from './app/composables/useUserSession.js';
+export type { SignOutOptions, UseUserSessionReturn } from './app/composables/useUserSession.js';
+export { useUserSessionState } from './app/composables/useUserSessionState.js';
+export type { UseUserSessionStateReturn } from './app/composables/useUserSessionState.js';

package/dist/runtime/composables.js

@@ -0,0 +1,9 @@
+export { useAction } from "./app/composables/useAction.js";
+export { useAuthAsyncData } from "./app/composables/useAuthAsyncData.js";
+export { useAuthClient } from "./app/composables/useAuthClient.js";
+export { useAuthClientAction } from "./app/composables/useAuthClientAction.js";
+export { useAuthRequestFetch } from "./app/composables/useAuthRequestFetch.js";
+export { useSignIn } from "./app/composables/useSignIn.js";
+export { useSignUp } from "./app/composables/useSignUp.js";
+export { useUserSession } from "./app/composables/useUserSession.js";
+export { useUserSessionState } from "./app/composables/useUserSessionState.js";

package/dist/runtime/config.d.ts

@@ -1,9 +1,11 @@
 import type { BetterAuthOptions, BetterAuthPlugin } from 'better-auth';
 import type { BetterAuthClientOptions } from 'better-auth/client';
 import type { Casing } from 'drizzle-orm/utils';
-import type { ServerAuthContext } from './types/augment.js';
+import type { ServerAuthContext as BaseServerAuthContext } from './types/augment.js';
 import { createAuthClient } from 'better-auth/vue';
-export type { ServerAuthContext };
+export interface ServerAuthContextExtension {
+}
+export type ServerAuthContext = BaseServerAuthContext & ServerAuthContextExtension;
 export interface ClientAuthContext {
     siteUrl: string;
 }

package/dist/runtime/server/api/_better-auth/_schema.d.ts

@@ -1,8 +1,4 @@
 import { z } from 'zod';
-export declare const paginationQuerySchema: z.ZodObject<{
-    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    search: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>;
+export declare const paginationQuerySchema: any;
 export type PaginationQuery = z.infer<typeof paginationQuerySchema>;
 export declare function sanitizeSearchPattern(search: string): string;

package/dist/runtime/server/api/_better-auth/accounts.get.d.ts

@@ -7,8 +7,8 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | {
     accounts: any;
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

package/dist/runtime/server/api/_better-auth/config.get.js

@@ -1,5 +1,5 @@
 import { defineEventHandler } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
+import { useRuntimeConfig } from "#imports";
 import { serverAuth } from "../../utils/auth.js";
 export default defineEventHandler(async (event) => {
   try {

package/dist/runtime/server/api/_better-auth/sessions.get.d.ts

@@ -9,8 +9,8 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | {
     sessions: SafeSession[];
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

package/dist/runtime/server/api/_better-auth/users.get.d.ts

@@ -7,8 +7,8 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | {
     users: any;
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

package/dist/runtime/server/middleware/route-access.js

@@ -1,5 +1,5 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
-import { getRouteRules } from "nitropack/runtime";
+import { getRouteRules } from "#imports";
 import { matchesUser } from "../../utils/match-user.js";
 import { getUserSession, requireUserSession } from "../utils/session.js";
 export default defineEventHandler(async (event) => {

package/dist/runtime/server/utils/auth.d.ts

@@ -1,8 +1,19 @@
+import type { BetterAuthOptions } from 'better-auth';
 import type { H3Event } from 'h3';
-import createServerAuth from '#auth/server';
 import { betterAuth } from 'better-auth';
+import createServerAuth from '#auth/server';
 type AuthOptions = ReturnType<typeof createServerAuth>;
-type AuthInstance = ReturnType<typeof betterAuth<AuthOptions>>;
+type UserAuthConfig = AuthOptions & {
+    trustedOrigins?: BetterAuthOptions['trustedOrigins'];
+    secondaryStorage?: BetterAuthOptions['secondaryStorage'];
+};
+type ResolvedAuthOptions = UserAuthConfig & {
+    secret: string;
+    baseURL: string;
+    trustedOrigins?: BetterAuthOptions['trustedOrigins'];
+    database?: BetterAuthOptions['database'];
+};
+type AuthInstance = ReturnType<typeof betterAuth<ResolvedAuthOptions>>;
 /** Returns Better Auth instance. Caches per resolved host (or single instance when siteUrl is explicit). */
 export declare function serverAuth(event?: H3Event): AuthInstance;
 export {};