better-auth-nuxt 0.0.2 → 0.0.4

package/dist/module.d.mts

@@ -16,6 +16,10 @@ interface ModuleOptions {
      * @default ['*.better-auth']
      */
     serverConfigs?: string[];
+    /**
+     * @default ['*.better-auth-client']
+     */
+    clientConfigs?: string[];
     options: {
         /**
          * client options object or path to client setup script
@@ -30,9 +34,9 @@ interface ModuleOptions {
      * redirect options
      */
     redirectOptions: {
-        redirectUserTo: string;
-        redirectGuestTo: string;
-        redirectUnauthorizedTo: string;
+        redirectUserTo?: string;
+        redirectGuestTo?: string;
+        redirectUnauthorizedTo?: string;
     };
 }
 interface ModulePublicRuntimeConfig {

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "better-auth",
   "configKey": "betterAuth",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "builder": {
     "@nuxt/module-builder": "1.0.1",
     "unbuild": "3.5.0"

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { defineNuxtModule, createResolver, logger, addImportsDir, addServerHandler, addTypeTemplate, addServerImports, addPlugin, addTemplate } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, logger, addServerHandler, addTypeTemplate, addServerImports, addImports, addRouteMiddleware, addPlugin, addTemplate } from '@nuxt/kit';
 import { defu } from 'defu';
 import { resolve } from 'pathe';
 import { hash } from 'ohash';
@@ -33,6 +33,119 @@ async function serverAuth({ options }) {
   ].join("\n");
 }
 
+async function useUserSession({ options }) {
+  return [
+    "import { createAuthClient } from 'better-auth/vue'",
+    ...options.configs.map((config) => {
+      return `import ${config.key} from "${config.path}"`;
+    }),
+    "import { defu } from 'defu'",
+    "import { computed, ref } from 'vue'",
+    "import { navigateTo, useRequestHeaders, useRequestURL, useRuntimeConfig, useState } from '#app'",
+    "",
+    "let _authInstance",
+    "",
+    "export function createAuthInstance() {",
+    "  const url = useRequestURL()",
+    "  const headers = import.meta.server ? useRequestHeaders() : undefined",
+    "  const config = useRuntimeConfig()",
+    "",
+    "  const authClient = createAuthClient({",
+    "    baseURL: url.origin,",
+    "    fetchOptions: {",
+    ...options.configs.map((config) => {
+      return `    ...${config.key}?.fetchOptions || {},`;
+    }),
+    "      headers,",
+    "    },",
+    ...options.configs.map((config) => {
+      return `    ${config.key},`;
+    }),
+    "   plugins: [",
+    ...options.configs.map((config) => {
+      return `    ...${config.key}?.plugins || [],`;
+    }),
+    " ],",
+    "  })",
+    "",
+    "  const options = defu(config.public.betterAuth.redirectOptions || {}, {",
+    "    redirectUserTo: '/profile',",
+    "    redirectGuestTo: '/signin',",
+    "    redirectUnauthorizedTo: '/401',",
+    "  })",
+    "",
+    "  const session = useState('auth:session', () => null)",
+    "  const user = useState('auth:user', () => null)",
+    "  const sessionFetching = import.meta.server ? ref(false) : useState('auth:sessionFetching', () => false)",
+    "",
+    "  const fetchSession = async () => {",
+    "    if (sessionFetching.value) {",
+    "      return",
+    "    }",
+    "    sessionFetching.value = true",
+    "    const { data } = await authClient.getSession({",
+    "      fetchOptions: {",
+    "        headers,",
+    "      },",
+    "    })",
+    "    session.value = data?.session || null",
+    "    user.value = data?.user || null",
+    "    sessionFetching.value = false",
+    "    return data",
+    "  }",
+    "",
+    "  return {",
+    "    session,",
+    "    user,",
+    "    loggedIn: computed(() => !!session.value),",
+    "    signIn: authClient.signIn,",
+    "    signUp: authClient.signUp,",
+    "    options,",
+    "    fetchSession,",
+    "    client: authClient,",
+    "    signOut: async (options = {}) => {",
+    "      try {",
+    "        await authClient.signOut()",
+    "        if (options.redirectTo)",
+    "          await navigateTo(options.redirectTo)",
+    "      }",
+    "      catch (error) {",
+    "        console.error('Sign out failed:', error)",
+    "        throw error",
+    "      }",
+    "    },",
+    "  }",
+    "}",
+    "",
+    "// Setup session listener for client-side updates",
+    "function setupSessionListener(client) {",
+    "  if (!import.meta.client)",
+    "    return",
+    "",
+    "  client.$store.listen('$sessionSignal', async (signal) => {",
+    "    if (!signal)",
+    "      return",
+    "    await client.useSession($fetch)",
+    "  })",
+    "}",
+    "",
+    "export function useUserSession() {",
+    "  if (_authInstance && import.meta.client)",
+    "    return _authInstance",
+    "",
+    "  const auth = createAuthInstance()",
+    "",
+    "  if (import.meta.client) {",
+    "    setupSessionListener(auth.client)",
+    "    _authInstance = auth",
+    "  }",
+    "",
+    "  return auth",
+    "}",
+    ""
+  ].join("\n");
+}
+
 const module = defineNuxtModule({
   meta: {
     name: "better-auth",
@@ -43,13 +156,19 @@ const module = defineNuxtModule({
     endpoint: "/api/auth/**",
     serverConfigs: [],
     redirectOptions: {
-      redirectUserTo: "/profile",
-      redirectGuestTo: "/signin",
+      redirectUserTo: "/auth/login",
+      redirectGuestTo: "/",
       redirectUnauthorizedTo: "/401"
     }
   },
   async setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
+    nuxt.options.vite.optimizeDeps ??= {};
+    nuxt.options.vite.optimizeDeps.include ??= [];
+    nuxt.options.vite.optimizeDeps.include.push(...[
+      "better-auth/client",
+      "better-auth/vue"
+    ]);
     if (!options.endpoint) {
       logger.withTag("better-auth").error("Missing endpoint option");
     }
@@ -59,7 +178,6 @@ const module = defineNuxtModule({
       redirectOptions: options.redirectOptions
     });
     nuxt.options.alias["#better-auth"] = resolve("./runtime");
-    addImportsDir(resolve("./runtime/composables"));
     addServerHandler({
       route: options.endpoint,
       handler: resolver.resolve("./runtime/server/handler")
@@ -104,7 +222,6 @@ const module = defineNuxtModule({
         continue;
       }
       for (const path of [...paths, ...pathsJS]) {
-        console.log("path", path);
         if (fs.existsSync(path)) {
           serverConfigs.push({
             key: pascalCase(hash(path)),
@@ -113,13 +230,13 @@ const module = defineNuxtModule({
         }
       }
     }
-    registerTemplate({
-      filename: "better-auth-configs.mjs",
+    const server = registerTemplate({
+      filename: "better-auth/server.mjs",
       getContents: serverAuth,
       options: { configs: serverConfigs }
     });
     addTypeTemplate({
-      filename: "better-auth-configs.d.ts",
+      filename: "better-auth/server.d.ts",
       getContents: () => {
         return [
           'import { betterAuth } from "better-auth"',
@@ -138,16 +255,124 @@ const module = defineNuxtModule({
         ].join("\n");
       }
     });
+    const clientConfigs = [];
+    for (const layer of nuxt.options._layers) {
+      const paths = await glob([
+        "**/*.better-auth-client.ts",
+        ...options.clientConfigs?.map((pattern) => {
+          return `**/${pattern}.ts`;
+        }) || []
+      ], { onlyFiles: true, ignore: nuxt.options.ignore, dot: true, cwd: layer.config.rootDir, absolute: true });
+      const pathsJS = await glob([
+        "**/*.better-auth.js",
+        ...options.serverConfigs?.map((pattern) => {
+          return `**/${pattern}.js`;
+        }) || []
+      ], { cwd: layer.config.serverDir });
+      if (paths.length === 0 && pathsJS.length === 0) {
+        continue;
+      }
+      for (const path of [...paths, ...pathsJS]) {
+        if (fs.existsSync(path)) {
+          clientConfigs.push({
+            key: pascalCase(hash(path)),
+            path
+          });
+        }
+      }
+    }
+    const client = registerTemplate({
+      filename: "better-auth/client.mjs",
+      getContents: useUserSession,
+      options: { configs: clientConfigs }
+    });
+    addTypeTemplate({
+      filename: "better-auth/client.d.ts",
+      getContents: () => {
+        return [
+          'import { createAuthInstance } from "./client.mjs"',
+          'import type { ClientOptions, InferSessionFromClient, InferUserFromClient } from "better-auth"',
+          'import type { RouteLocationRaw } from "vue-router"',
+          'import { Ref, ComputedRef } from "vue"',
+          ...clientConfigs.map((config) => {
+            return `import ${config.key} from "${config.path}"`;
+          }),
+          "export interface RuntimeAuthConfig {",
+          "  redirectUserTo: RouteLocationRaw | string",
+          "  redirectGuestTo: RouteLocationRaw | string",
+          "  redirectUnauthorizedTo: RouteLocationRaw | string",
+          "}",
+          "export interface AuthSignOutOptions {",
+          "  redirectTo?: RouteLocationRaw",
+          "}",
+          "export type AuthClient = ReturnType<typeof createAuthInstance>",
+          "export declare const useUserSession: () => AuthClient"
+        ].join("\n");
+      }
+    });
     addServerImports([
       {
-        from: "#better-auth-configs",
+        from: server.dst,
         name: "useAuth"
       },
       {
-        from: "#better-auth-configs",
+        from: server.dst,
         name: "auth"
       }
     ]);
+    addImports([
+      {
+        from: client.dst,
+        name: "useUserSession"
+      },
+      {
+        from: client.dst,
+        name: "createAuthInstance"
+      }
+    ]);
+    addRouteMiddleware({
+      name: "auth",
+      path: resolver.resolve("./runtime/middleware/auth.ts"),
+      global: true
+    });
+    addTypeTemplate({
+      filename: "types/better-auth-middleware.d.ts",
+      getContents: () => {
+        return [
+          " type MiddlewareOptions = false | {",
+          "   /**",
+          "    * Only apply auth middleware to guest or user",
+          "    */",
+          "   only?:",
+          '     | "guest"',
+          '     | "user"',
+          '     | "member"',
+          '     | "admin"',
+          "   /**",
+          "    * Redirect authenticated user to this route",
+          "    */",
+          "   redirectUserTo?: string",
+          "   /**",
+          "    * Redirect guest to this route",
+          "    */",
+          "   redirectGuestTo?: string",
+          "   redirectUnauthorizedTo?: string",
+          " }",
+          ' declare module "#app" {',
+          "   interface PageMeta {",
+          "     auth?: MiddlewareOptions",
+          "   }",
+          " }",
+          ' declare module "vue-router" {',
+          "   interface RouteMeta {",
+          "     auth?: MiddlewareOptions",
+          "   }",
+          " }",
+          "export {}"
+        ].join("\n");
+      },
+      write: true
+    });
     addPlugin(resolver.resolve("./runtime/plugin"));
   }
 });

package/dist/runtime/middleware/auth.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/auth.js

@@ -0,0 +1,31 @@
+import { defu } from "defu";
+import { defineNuxtRouteMiddleware, navigateTo } from "#app";
+import { useUserSession } from "#imports";
+export default defineNuxtRouteMiddleware(async (to) => {
+  if (to.meta?.auth === false) {
+    return;
+  }
+  const { loggedIn, options, fetchSession, session } = useUserSession();
+  const { only, redirectUserTo, redirectGuestTo, redirectUnauthorizedTo } = defu(to.meta.auth, options);
+  await fetchSession();
+  if (only === "guest" && loggedIn.value) {
+    if (to.path === redirectUserTo) {
+      return;
+    }
+    return navigateTo(redirectUserTo);
+  }
+  if (only && only !== "guest" && !loggedIn.value) {
+    if (to.path === redirectGuestTo)
+      return;
+    return navigateTo(redirectGuestTo);
+  }
+  if (only && only !== "guest" && loggedIn.value && session.value) {
+    const userRole = session.value.role || "user";
+    const requiredRoles = Array.isArray(only) ? only : [only];
+    if (!requiredRoles.includes(userRole) && !requiredRoles.includes("user")) {
+      if (to.path === redirectUnauthorizedTo)
+        return;
+      return navigateTo(redirectUnauthorizedTo ?? "/401");
+    }
+  }
+});

package/dist/runtime/plugin.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/server/handler.js

@@ -1,5 +1,5 @@
 import { defineEventHandler, toWebRequest } from "h3";
-import { auth } from "#better-auth-configs";
+import { auth } from "#better-auth/server";
 export default defineEventHandler((event) => {
   return auth.handler(toWebRequest(event));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "better-auth-nuxt",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Better Auth Nuxt Module",
   "repository": "productdevbook/better-auth-nuxt",
   "license": "MIT",
@@ -52,6 +52,7 @@
     "@nuxt/module-builder": "^1.0.1",
     "@nuxt/schema": "^3.16.2",
     "@nuxt/test-utils": "^3.17.2",
+    "@tailwindcss/vite": "^4.1.4",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "latest",
     "better-auth": "^1.2.7",