better-auth-nuxt 0.0.1 → 0.0.3

package/README.md

@@ -1,13 +1,4 @@
-<!--
-Get your module up and running quickly.
-
-Find and replace all on all files (CMD+SHIFT+F):
-- Name: My Module
-- Package name: my-module
-- Description: My new Nuxt module
--->
-
-# My Module
+# Better Auth Nuxt
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
@@ -71,14 +62,14 @@ That's it! You can now use My Module in your Nuxt app ✨
 
 
 <!-- Badges -->
-[npm-version-src]: https://img.shields.io/npm/v/my-module/latest.svg?style=flat&colorA=020420&colorB=00DC82
-[npm-version-href]: https://npmjs.com/package/my-module
+[npm-version-src]: https://img.shields.io/npm/v/better-auth-nuxt/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/better-auth-nuxt
 
-[npm-downloads-src]: https://img.shields.io/npm/dm/my-module.svg?style=flat&colorA=020420&colorB=00DC82
-[npm-downloads-href]: https://npm.chart.dev/my-module
+[npm-downloads-src]: https://img.shields.io/npm/dm/better-auth-nuxt.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/better-auth-nuxt
 
-[license-src]: https://img.shields.io/npm/l/my-module.svg?style=flat&colorA=020420&colorB=00DC82
-[license-href]: https://npmjs.com/package/my-module
+[license-src]: https://img.shields.io/npm/l/better-auth-nuxt.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/better-auth-nuxt
 
 [nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
 [nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -1,9 +1,48 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { ClientOptions, BetterAuthOptions } from 'better-auth';
 
+interface ModuleServerOptions extends Pick<BetterAuthOptions, 'appName' | 'baseURL' | 'basePath' | 'secret'> {
+}
+interface ModuleClientOptions extends Pick<ClientOptions, 'baseURL' | 'basePath' | 'disableDefaultFetchPlugins'> {
+}
 interface ModuleOptions {
-    baseUrl?: string;
+    baseUrl: string;
+    /**
+     * auth endpoint
+     * @default 'api/auth/**'
+     */
+    endpoint: string;
+    /**
+     * @default ['*.better-auth']
+     */
+    serverConfigs?: string[];
+    /**
+     * @default ['*.better-auth-client']
+     */
+    clientConfigs?: string[];
+    options: {
+        /**
+         * client options object or path to client setup script
+         */
+        client: ModuleClientOptions;
+        /**
+         * server options object or path to server setup script
+         */
+        server: ModuleServerOptions;
+    };
+    /**
+     * redirect options
+     */
+    redirectOptions: {
+        redirectUserTo: string;
+        redirectGuestTo: string;
+        redirectUnauthorizedTo: string;
+    };
+}
+interface ModulePublicRuntimeConfig {
+    betterAuth: ModuleOptions;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 export { _default as default };
-export type { ModuleOptions };
+export type { ModuleClientOptions, ModuleOptions, ModulePublicRuntimeConfig, ModuleServerOptions };

package/dist/module.json

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

package/dist/module.mjs

@@ -1,4 +1,150 @@
-import { defineNuxtModule, createResolver, addPlugin } from '@nuxt/kit';
+import fs from 'node:fs';
+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';
+import { glob } from 'tinyglobby';
+import { pascalCase } from 'scule';
+
+async function serverAuth({ options }) {
+  return [
+    'import mergeDeep from "@fastify/deepmerge"',
+    'import { betterAuth } from "better-auth"',
+    ...options.configs.map((config) => {
+      return `import ${config.key} from "${config.path}"`;
+    }),
+    "const betterAuthConfigs = mergeDeep({all: true})({},",
+    ...options.configs.map((config) => {
+      return `${config.key},`;
+    }),
+    ")",
+    "",
+    "let _auth",
+    "",
+    "export function useAuth() {",
+    "  if (!_auth) {",
+    "    _auth = betterAuth(betterAuthConfigs)",
+    "  }",
+    "  return _auth",
+    "}",
+    "",
+    "export const auth = useAuth()",
+    ""
+  ].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: {
@@ -6,9 +152,191 @@ const module = defineNuxtModule({
     configKey: "betterAuth"
   },
   // Default configuration options of the Nuxt module
-  defaults: {},
-  setup(_options, _nuxt) {
+  defaults: {
+    endpoint: "/api/auth/**",
+    serverConfigs: [],
+    redirectOptions: {
+      redirectUserTo: "/profile",
+      redirectGuestTo: "/signin",
+      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");
+    }
+    nuxt.options.runtimeConfig.public.betterAuth = defu(nuxt.options.runtimeConfig.public.betterAuth, {
+      baseUrl: options.baseUrl,
+      endpoint: options.endpoint,
+      redirectOptions: options.redirectOptions
+    });
+    nuxt.options.alias["#better-auth"] = resolve("./runtime");
+    addServerHandler({
+      route: options.endpoint,
+      handler: resolver.resolve("./runtime/server/handler")
+    });
+    const registerTemplate = (options2) => {
+      const name = options2.filename.replace(/\.m?js$/, "");
+      const alias = "#" + name;
+      const results = addTemplate({
+        ...options2,
+        write: true
+        // Write to disk for Nitro to consume
+      });
+      nuxt.options.nitro.alias ||= {};
+      nuxt.options.nitro.externals ||= {};
+      nuxt.options.nitro.externals.inline ||= [];
+      nuxt.options.alias[alias] = results.dst;
+      nuxt.options.nitro.alias[alias] = nuxt.options.alias[alias];
+      nuxt.options.nitro.externals.inline.push(nuxt.options.alias[alias]);
+      nuxt.options.nitro.externals.inline.push(alias);
+      return results;
+    };
+    const serverConfigs = [
+      {
+        key: pascalCase(hash("better-auth-configs")),
+        path: resolver.resolve("./runtime/server")
+      }
+    ];
+    for (const layer of nuxt.options._layers) {
+      const paths = await glob([
+        "**/*.better-auth.ts",
+        ...options.serverConfigs?.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)) {
+          serverConfigs.push({
+            key: pascalCase(hash(path)),
+            path
+          });
+        }
+      }
+    }
+    const server = registerTemplate({
+      filename: "better-auth/server.mjs",
+      getContents: serverAuth,
+      options: { configs: serverConfigs }
+    });
+    addTypeTemplate({
+      filename: "better-auth/server.d.ts",
+      getContents: () => {
+        return [
+          'import { betterAuth } from "better-auth"',
+          'import mergeDeep from "@fastify/deepmerge"',
+          ...serverConfigs.map((config) => {
+            return `import ${config.key} from "${config.path}"`;
+          }),
+          "const betterAuthConfigs = mergeDeep({all: true})({},",
+          ...serverConfigs.map((config) => {
+            return `${config.key},`;
+          }),
+          ")",
+          "export type BetterAuth = ReturnType<typeof betterAuth<typeof betterAuthConfigs>>",
+          "export declare const useAuth: () => BetterAuth",
+          "export declare const auth: BetterAuth"
+        ].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: server.dst,
+        name: "useAuth"
+      },
+      {
+        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/plugin.js

@@ -1,4 +1,3 @@
 import { defineNuxtPlugin } from "#app";
 export default defineNuxtPlugin((_nuxtApp) => {
-  console.log("Plugin injected by my-module!");
 });

package/dist/runtime/server/handler.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/handler.js

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

package/dist/runtime/server.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    disabledPaths: never[];
+    plugins: never[];
+    trustedOrigins: never[];
+};
+export default _default;

package/dist/runtime/server.js

@@ -0,0 +1,5 @@
+export default {
+  disabledPaths: [],
+  plugins: [],
+  trustedOrigins: []
+};

package/dist/types.d.mts

@@ -1,3 +1,9 @@
+import type { ModulePublicRuntimeConfig } from './module.mjs'
+
+declare module '@nuxt/schema' {
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
 export { default } from './module.mjs'
 
-export { type ModuleOptions } from './module.mjs'
+export { type ModuleClientOptions, type ModuleOptions, type ModulePublicRuntimeConfig, type ModuleServerOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "better-auth-nuxt",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Better Auth Nuxt Module",
   "repository": "productdevbook/better-auth-nuxt",
   "license": "MIT",
@@ -34,8 +34,17 @@
     "test:watch": "vitest watch",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
   },
+  "peerDependencies": {
+    "better-auth": ">=1.2.7"
+  },
   "dependencies": {
-    "@nuxt/kit": "^3.16.2"
+    "@fastify/deepmerge": "^3.1.0",
+    "@nuxt/kit": "^3.16.2",
+    "defu": "^6.1.4",
+    "ohash": "^2.0.11",
+    "pathe": "^2.0.3",
+    "scule": "^1.3.0",
+    "tinyglobby": "^0.2.12"
   },
   "devDependencies": {
     "@nuxt/devtools": "^2.4.0",
@@ -43,7 +52,10 @@
     "@nuxt/module-builder": "^1.0.1",
     "@nuxt/schema": "^3.16.2",
     "@nuxt/test-utils": "^3.17.2",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "latest",
+    "better-auth": "^1.2.7",
+    "better-sqlite3": "^11.9.1",
     "changelogen": "^0.6.1",
     "eslint": "^9.24.0",
     "nuxt": "^3.16.2",