better-auth-nuxt 0.0.2 → 0.0.3

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

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "better-auth",
   "configKey": "betterAuth",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "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",
@@ -50,6 +163,12 @@ const module = defineNuxtModule({
   },
   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")
@@ -113,13 +231,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 +256,87 @@ 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]) {
+        console.log("path", path);
+        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: "better-auth",
+      path: resolver.resolve("./runtime/middleware/auth.global"),
+      global: true
+    });
     addPlugin(resolver.resolve("./runtime/plugin"));
   }
 });

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

@@ -0,0 +1,27 @@
+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;
+    }
+}
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

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

@@ -0,0 +1,35 @@
+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);
+  if (import.meta.client) {
+    await fetchSession();
+  }
+  if (loggedIn.value && to.path.startsWith("/auth/")) {
+    if (to.path === redirectUserTo) {
+      return;
+    }
+    return navigateTo(redirectUserTo);
+  }
+  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" && session.value) {
+    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.3",
   "description": "Better Auth Nuxt Module",
   "repository": "productdevbook/better-auth-nuxt",
   "license": "MIT",