@onmax/nuxt-better-auth 0.0.2-alpha.9 → 0.0.3

package/dist/runtime/composables.d.ts

@@ -0,0 +1,12 @@
+export { runWithSessionRefresh } from './app/composables/runWithSessionRefresh.js';
+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,10 @@
+export { runWithSessionRefresh } from "./app/composables/runWithSessionRefresh.js";
+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,44 +1,98 @@
-import type { BetterAuthOptions } from 'better-auth';
-import type { ClientOptions } from 'better-auth/client';
-import type { CasingOption } from '../schema-generator.js';
-import type { ServerAuthContext } from './types/augment.js';
-export type { ServerAuthContext };
+import type { BetterAuthOptions, BetterAuthPlugin } from 'better-auth';
+import type { BetterAuthClientOptions } from 'better-auth/client';
+import type { Casing } from 'drizzle-orm/utils';
+import type { ServerAuthContext as BaseServerAuthContext } from './types/augment.js';
+import { createAuthClient } from 'better-auth/vue';
+export interface ServerAuthContextExtension {
+}
+export type ServerAuthContext = BaseServerAuthContext & ServerAuthContextExtension;
 export interface ClientAuthContext {
     siteUrl: string;
 }
-type ServerAuthConfig = Omit<BetterAuthOptions, 'database' | 'secret' | 'baseURL'>;
-type ClientAuthConfig = Omit<ClientOptions, 'baseURL'> & {
+export type ServerAuthConfig = Omit<BetterAuthOptions, 'secret' | 'baseURL'> & {
+    plugins?: readonly BetterAuthPlugin[];
+};
+export type ClientAuthConfig = Omit<BetterAuthClientOptions, 'baseURL'> & {
     baseURL?: string;
 };
 export type ServerAuthConfigFn = (ctx: ServerAuthContext) => ServerAuthConfig;
 export type ClientAuthConfigFn = (ctx: ClientAuthContext) => ClientAuthConfig;
+export type ModuleDatabaseProviderId = 'none' | 'nuxthub' | (string & {});
+export type EffectiveDatabaseProviderId = 'user' | ModuleDatabaseProviderId;
 export interface BetterAuthModuleOptions {
-    /** Server config path relative to rootDir. Default: 'server/auth.config' */
+    /** Client-only mode - skip server setup for external auth backends */
+    clientOnly?: boolean;
+    /** Server config path. Relative paths resolve from the layer that declares them. Default: 'server/auth.config' */
     serverConfig?: string;
-    /** Client config path relative to rootDir. Default: 'app/auth.config' */
+    /** Client config path. Relative paths resolve from the layer that declares them. Default: 'app/auth.config' */
     clientConfig?: string;
     redirects?: {
+        /** Where to redirect unauthenticated users. Default: '/login' */
         login?: string;
+        /** Where to redirect authenticated users on guest-only routes. Default: '/' */
         guest?: string;
+        /** Where to navigate after successful signIn/signUp when no onSuccess is provided. Default: no automatic navigation */
+        authenticated?: string;
+        /** Where to navigate after logout. Default: no automatic navigation */
+        logout?: string;
     };
-    /** Enable KV secondary storage for sessions. Requires hub.kv: true */
-    secondaryStorage?: boolean;
+    /**
+     * When redirecting unauthenticated users to the login route, append a query param
+     * containing the originally requested path (for safe "return-to" redirects).
+     *
+     * Default: true
+     */
+    preserveRedirect?: boolean;
+    /**
+     * Query param key used by preserveRedirect.
+     *
+     * Default: 'redirect'
+     */
+    redirectQueryKey?: string;
+    session?: {
+        /**
+         * When enabled, and session/user are already hydrated from SSR, skip the initial
+         * client `/api/auth/get-session` bootstrap request. This also skips Better Auth's
+         * session refresh manager on those pages.
+         *
+         * Default: false
+         */
+        skipHydratedSsrGetSession?: boolean;
+    };
+    /**
+     * Enable secondary storage for sessions.
+     * - `true`: Use NuxtHub KV (requires hub.kv: true)
+     * - `'custom'`: User provides own secondaryStorage in defineServerAuth()
+     * - `false` (default): No secondary storage from module
+     */
+    hubSecondaryStorage?: boolean | 'custom';
     /** Schema generation options. Must match drizzleAdapter config. */
     schema?: {
         /** Plural table names: user → users. Default: false */
         usePlural?: boolean;
         /** Column/table name casing. Explicit value takes precedence over hub.db.casing. */
-        casing?: CasingOption;
+        casing?: Casing;
     };
 }
 export interface AuthRuntimeConfig {
     redirects: {
         login: string;
         guest: string;
+        authenticated?: string;
+        logout?: string;
+    };
+    preserveRedirect: boolean;
+    redirectQueryKey: string;
+    useDatabase: boolean;
+    databaseProvider: EffectiveDatabaseProviderId;
+    clientOnly: boolean;
+    session: {
+        skipHydratedSsrGetSession: boolean;
     };
 }
 export interface AuthPrivateRuntimeConfig {
-    secondaryStorage: boolean;
+    hubSecondaryStorage: boolean | 'custom';
 }
-export declare function defineServerAuth<T extends ServerAuthConfig>(config: (ctx: ServerAuthContext) => T): (ctx: ServerAuthContext) => T;
-export declare function defineClientAuth(config: ClientAuthConfigFn): ClientAuthConfigFn;
+export declare function defineServerAuth<const R>(config: (ctx: ServerAuthContext) => R & ServerAuthConfig): (ctx: ServerAuthContext) => R;
+export declare function defineServerAuth<const R>(config: R & ServerAuthConfig): (ctx: ServerAuthContext) => R;
+export declare function defineClientAuth<T extends ClientAuthConfig>(config: T | ((ctx: ClientAuthContext) => T)): (baseURL: string) => ReturnType<typeof createAuthClient<T>>;

package/dist/runtime/config.js

@@ -1,6 +1,13 @@
+import { createAuthClient } from "better-auth/vue";
 export function defineServerAuth(config) {
-  return config;
+  return typeof config === "function" ? config : () => config;
 }
 export function defineClientAuth(config) {
-  return config;
+  return (baseURL) => {
+    const ctx = { siteUrl: baseURL };
+    const resolved = typeof config === "function" ? config(ctx) : config;
+    const { baseURL: configuredBaseURL, ...resolvedOptions } = resolved;
+    const clientOptions = { ...resolvedOptions, baseURL: configuredBaseURL ?? baseURL };
+    return createAuthClient(clientOptions);
+  };
 }

package/dist/runtime/internal/auth-route-rules.d.ts

@@ -0,0 +1 @@
+export declare function shouldSkipAuthRouteRules(path: string): boolean;

package/dist/runtime/internal/auth-route-rules.js

@@ -0,0 +1,24 @@
+const internalRouteRuleAuthPaths = /* @__PURE__ */ new Set([
+  "/_ipx",
+  "/_nuxt",
+  "/__better-auth-devtools",
+  "/__nuxt_devtools__",
+  "/__nuxt_error",
+  "/__nuxt_vite_node__",
+  "/api/_better-auth",
+  "/api/_nuxt_icon",
+  "/api/auth"
+]);
+const internalRouteRuleAuthPrefixes = [
+  "/_ipx/",
+  "/_nuxt/",
+  "/__nuxt_devtools__/",
+  "/__nuxt_vite_node__/",
+  "/api/_better-auth/",
+  "/api/_nuxt_icon/",
+  "/api/auth/"
+];
+export function shouldSkipAuthRouteRules(path) {
+  const pathname = path.split(/[?#]/, 1)[0] || "/";
+  return internalRouteRuleAuthPaths.has(pathname) || internalRouteRuleAuthPrefixes.some((prefix) => pathname.startsWith(prefix));
+}

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/_schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+const SQL_LIKE_ESCAPE_RE = /[%_\\]/g;
 export const paginationQuerySchema = z.object({
   page: z.coerce.number().int().min(1).default(1),
   limit: z.coerce.number().int().min(1).max(100).default(20),
@@ -7,5 +8,5 @@ export const paginationQuerySchema = z.object({
 export function sanitizeSearchPattern(search) {
   if (!search)
     return "";
-  return `%${search.replace(/[%_\\]/g, "\\$&")}%`;
+  return `%${search.replace(SQL_LIKE_ESCAPE_RE, "\\$&")}%`;
 }

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/accounts.get.js

@@ -2,8 +2,9 @@ import { defineEventHandler, getQuery } from "h3";
 import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
 export default defineEventHandler(async (event) => {
   try {
-    const { db, schema } = await import("hub:db");
-    if (!schema.account)
+    const { db } = await import("@nuxthub/db");
+    const { schema } = await import("#auth/schema");
+    if (!schema?.account)
       return { accounts: [], total: 0, error: "Account table not found" };
     const query = paginationQuerySchema.parse(getQuery(event));
     const { page, limit, search } = query;

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

@@ -2,11 +2,16 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     config: {
         module: {
             redirects: {
-                login?: string;
-                guest?: string;
+                login: string;
+                guest: string;
+                authenticated: string | undefined;
+                logout: string | undefined;
             };
-            secondaryStorage: boolean;
+            preserveRedirect: boolean;
+            redirectQueryKey: string;
+            hubSecondaryStorage: boolean | "custom";
             useDatabase: boolean;
+            databaseProvider: "none" | "nuxthub";
         };
         server: {
             baseURL: any;
@@ -14,6 +19,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
             socialProviders: string[];
             plugins: any;
             trustedOrigins: any;
+            configuredTrustedOrigins: any;
             session: {
                 expiresIn: string;
                 updateAge: string;

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

@@ -1,13 +1,16 @@
 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 {
-    const auth = await serverAuth(event);
+    const auth = serverAuth(event);
     const options = auth.options;
+    const authContext = await auth.$context;
     const runtimeConfig = useRuntimeConfig();
     const publicAuth = runtimeConfig.public?.auth;
     const privateAuth = runtimeConfig.auth;
+    const configuredTrustedOrigins = Array.isArray(options.trustedOrigins) ? options.trustedOrigins : [];
+    const effectiveTrustedOrigins = authContext?.trustedOrigins || configuredTrustedOrigins;
     const sessionConfig = options.session || {};
     const expiresInDays = sessionConfig.expiresIn ? Math.round(sessionConfig.expiresIn / 86400) : 7;
     const updateAgeDays = sessionConfig.updateAge ? Math.round(sessionConfig.updateAge / 86400) : 1;
@@ -15,9 +18,17 @@ export default defineEventHandler(async (event) => {
       config: {
         // Module config (nuxt.config.ts)
         module: {
-          redirects: publicAuth?.redirects || { login: "/login", guest: "/" },
-          secondaryStorage: privateAuth?.secondaryStorage ?? false,
-          useDatabase: publicAuth?.useDatabase ?? false
+          redirects: {
+            login: publicAuth?.redirects?.login ?? "/login",
+            guest: publicAuth?.redirects?.guest ?? "/",
+            authenticated: publicAuth?.redirects?.authenticated,
+            logout: publicAuth?.redirects?.logout
+          },
+          preserveRedirect: publicAuth?.preserveRedirect ?? true,
+          redirectQueryKey: publicAuth?.redirectQueryKey ?? "redirect",
+          hubSecondaryStorage: privateAuth?.hubSecondaryStorage ?? false,
+          useDatabase: publicAuth?.useDatabase ?? false,
+          databaseProvider: publicAuth?.databaseProvider ?? "none"
         },
         // Server config (server/auth.config.ts)
         server: {
@@ -25,7 +36,8 @@ export default defineEventHandler(async (event) => {
           basePath: options.basePath || "/api/auth",
           socialProviders: Object.keys(options.socialProviders || {}),
           plugins: (options.plugins || []).map((p) => p.id || "unknown"),
-          trustedOrigins: options.trustedOrigins || [],
+          trustedOrigins: effectiveTrustedOrigins,
+          configuredTrustedOrigins,
           session: {
             expiresIn: `${expiresInDays} days`,
             updateAge: `${updateAgeDays} days`,

package/dist/runtime/server/api/_better-auth/sessions.delete.js

@@ -6,8 +6,9 @@ const deleteSessionSchema = z.object({
 export default defineEventHandler(async (event) => {
   try {
     const body = deleteSessionSchema.parse(await readBody(event));
-    const { db, schema } = await import("hub:db");
-    if (!schema.session)
+    const { db } = await import("@nuxthub/db");
+    const { schema } = await import("#auth/schema");
+    if (!schema?.session)
       throw createError({ statusCode: 500, message: "Session table not found" });
     const { eq } = await import("drizzle-orm");
     await db.delete(schema.session).where(eq(schema.session.id, body.id));

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

@@ -1,3 +1,5 @@
+import type { Session } from 'better-auth/types';
+type SafeSession = Pick<Session, 'id' | 'userId' | 'createdAt' | 'updatedAt' | 'expiresAt' | 'ipAddress' | 'userAgent'>;
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     sessions: never[];
     total: number;
@@ -5,10 +7,10 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     page?: undefined;
     limit?: undefined;
 } | {
-    sessions: any;
+    sessions: SafeSession[];
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

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

@@ -2,8 +2,9 @@ import { defineEventHandler, getQuery } from "h3";
 import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
 export default defineEventHandler(async (event) => {
   try {
-    const { db, schema } = await import("hub:db");
-    if (!schema.session)
+    const { db } = await import("@nuxthub/db");
+    const { schema } = await import("#auth/schema");
+    if (!schema?.session)
       return { sessions: [], total: 0, error: "Session table not found" };
     const query = paginationQuerySchema.parse(getQuery(event));
     const { page, limit, search } = query;

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/api/_better-auth/users.get.js

@@ -2,8 +2,9 @@ import { defineEventHandler, getQuery } from "h3";
 import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
 export default defineEventHandler(async (event) => {
   try {
-    const { db, schema } = await import("hub:db");
-    if (!schema.user)
+    const { db } = await import("@nuxthub/db");
+    const { schema } = await import("#auth/schema");
+    if (!schema?.user)
       return { users: [], total: 0, error: "User table not found" };
     const query = paginationQuerySchema.parse(getQuery(event));
     const { page, limit, search } = query;

package/dist/runtime/server/api/auth/[...all].js

@@ -1,6 +1,6 @@
 import { defineEventHandler, toWebRequest } from "h3";
 import { serverAuth } from "../../utils/auth.js";
 export default defineEventHandler(async (event) => {
-  const auth = await serverAuth(event);
+  const auth = serverAuth(event);
   return auth.handler(toWebRequest(event));
 });

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

@@ -1,11 +1,13 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
-import { getRouteRules } from "nitropack/runtime";
+import { getRouteRules } from "#imports";
+import { shouldSkipAuthRouteRules } from "../../internal/auth-route-rules.js";
 import { matchesUser } from "../../utils/match-user.js";
+import { getUserSession, requireUserSession } from "../utils/session.js";
 export default defineEventHandler(async (event) => {
   const path = getRequestURL(event).pathname;
   if (!path.startsWith("/api/"))
     return;
-  if (path.startsWith("/api/auth/"))
+  if (shouldSkipAuthRouteRules(path))
     return;
   const rules = getRouteRules(event);
   if (!rules.auth)

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,11 @@
 {
-  "extends": "../../../.nuxt/tsconfig.server.json"
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "#nuxt-better-auth": ["../types/augment"]
+    }
+  },
+  "include": ["./**/*.ts", "./**/*.d.ts"],
+  "exclude": ["node_modules"]
 }

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

@@ -1,11 +1,19 @@
-import type { Auth } from 'better-auth';
+import type { BetterAuthOptions } from 'better-auth';
 import type { H3Event } from 'h3';
+import { betterAuth } from 'better-auth';
 import createServerAuth from '#auth/server';
-type AuthInstance = Auth<ReturnType<typeof createServerAuth>>;
-declare module 'h3' {
-    interface H3EventContext {
-        _betterAuth?: AuthInstance;
-    }
-}
-export declare function serverAuth(event: H3Event): Promise<AuthInstance>;
+type AuthOptions = ReturnType<typeof createServerAuth>;
+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 {};