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

package/dist/runtime/server/utils/session.js

@@ -1,13 +1,225 @@
 import { createError } from "h3";
 import { matchesUser } from "../../utils/match-user.js";
 import { serverAuth } from "./auth.js";
+const requestSessionLoadKey = Symbol.for("nuxt-better-auth.requestSessionLoad");
+const signingAlgorithm = { name: "HMAC", hash: "SHA-256" };
+const cookiePairSeparatorRE = /;\s*/;
+const fallbackRequestSessionContext = /* @__PURE__ */ new WeakMap();
+function getRequestSessionContext(event) {
+  const eventWithContext = event;
+  if (eventWithContext.context && typeof eventWithContext.context === "object")
+    return eventWithContext.context;
+  let context = fallbackRequestSessionContext.get(event);
+  if (!context) {
+    context = {};
+    fallbackRequestSessionContext.set(event, context);
+  }
+  return context;
+}
+function getRequestHeaders(event) {
+  return getRequestSessionContext(event).requestHeaders ?? event.headers;
+}
+function loadSession(event) {
+  const auth = serverAuth(event);
+  return auth.api.getSession({ headers: getRequestHeaders(event) });
+}
+function getServerAuthContext(event) {
+  const auth = serverAuth(event);
+  return auth.$context;
+}
+function getCookieName(name, prefix) {
+  if (prefix === "secure")
+    return name.startsWith("__Secure-") ? name : `__Secure-${name}`;
+  if (prefix === "host")
+    return name.startsWith("__Host-") ? name : `__Host-${name}`;
+  if (prefix)
+    return void 0;
+  return name;
+}
+function serializeCookieHeader(name, value, attributes = {}, valueIsEncoded = false) {
+  const cookieName = getCookieName(name, attributes.prefix);
+  if (!cookieName)
+    throw new Error(`Unsupported cookie prefix: ${attributes.prefix}`);
+  const cookieValue = valueIsEncoded ? value : encodeURIComponent(value);
+  const cookie = [`${cookieName}=${cookieValue}`];
+  const options = { ...attributes };
+  if (cookieName.startsWith("__Secure-") && !options.secure)
+    options.secure = true;
+  if (cookieName.startsWith("__Host-")) {
+    options.secure = true;
+    options.path = "/";
+    delete options.domain;
+  }
+  if (typeof options.maxAge === "number" && options.maxAge >= 0)
+    cookie.push(`Max-Age=${Math.floor(options.maxAge)}`);
+  if (options.domain && options.prefix !== "host")
+    cookie.push(`Domain=${options.domain}`);
+  if (options.path)
+    cookie.push(`Path=${options.path}`);
+  if (options.expires)
+    cookie.push(`Expires=${options.expires.toUTCString()}`);
+  if (options.httpOnly)
+    cookie.push("HttpOnly");
+  if (options.partitioned)
+    options.secure = true;
+  if (options.secure)
+    cookie.push("Secure");
+  if (options.sameSite) {
+    const normalizedSameSite = options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1);
+    cookie.push(`SameSite=${normalizedSameSite}`);
+  }
+  if (options.partitioned)
+    cookie.push("Partitioned");
+  return cookie.join("; ");
+}
+function serializeCookie(name, value, attributes = {}) {
+  return serializeCookieHeader(name, value, attributes);
+}
+async function signCookieValue(value, secret) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    signingAlgorithm,
+    false,
+    ["sign", "verify"]
+  );
+  const signature = await crypto.subtle.sign(
+    signingAlgorithm.name,
+    key,
+    new TextEncoder().encode(value)
+  );
+  return encodeURIComponent(`${value}.${btoa(String.fromCharCode(...new Uint8Array(signature)))}`);
+}
+async function serializeSignedCookie(name, value, secret, attributes = {}) {
+  return serializeCookieHeader(name, await signCookieValue(value, secret), attributes, true);
+}
+function appendCookieHeader(event, header) {
+  const nodeResponse = event.node?.res;
+  if (nodeResponse?.setHeader) {
+    const current = nodeResponse.getHeader?.("set-cookie");
+    if (Array.isArray(current))
+      nodeResponse.setHeader("set-cookie", [...current, header]);
+    else if (typeof current === "string")
+      nodeResponse.setHeader("set-cookie", [current, header]);
+    else
+      nodeResponse.setHeader("set-cookie", [header]);
+    return;
+  }
+  const responseHeaders = event.response?.headers;
+  responseHeaders?.append("set-cookie", header);
+}
+function parseRequestCookies(cookieHeader) {
+  const cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader)
+    return cookies;
+  for (const pair of cookieHeader.split(cookiePairSeparatorRE)) {
+    if (!pair)
+      continue;
+    const separatorIndex = pair.indexOf("=");
+    if (separatorIndex < 0)
+      continue;
+    cookies.set(pair.slice(0, separatorIndex), pair.slice(separatorIndex + 1));
+  }
+  return cookies;
+}
+function serializeRequestCookies(cookies) {
+  if (!cookies.size)
+    return null;
+  return Array.from(cookies.entries()).map(([name, value]) => `${name}=${value}`).join("; ");
+}
+function extractResponseCookieValue(header) {
+  const separatorIndex = header.indexOf(";");
+  const cookiePair = separatorIndex >= 0 ? header.slice(0, separatorIndex) : header;
+  return cookiePair.slice(cookiePair.indexOf("=") + 1);
+}
+function getChunkedCookieNames(event, cookieName) {
+  const cookieNames = /* @__PURE__ */ new Set([cookieName]);
+  for (const name of parseRequestCookies(event.headers.get("cookie")).keys()) {
+    if (name.startsWith(`${cookieName}.`))
+      cookieNames.add(name);
+  }
+  return Array.from(cookieNames);
+}
+function expireCookie(event, cookieName, attributes) {
+  appendCookieHeader(event, serializeCookie(cookieName, "", {
+    ...attributes,
+    expires: /* @__PURE__ */ new Date(0),
+    maxAge: 0
+  }));
+}
+function expireCookies(event, cookie) {
+  for (const cookieName of getChunkedCookieNames(event, cookie.name))
+    expireCookie(event, cookieName, cookie.attributes);
+}
+function updateRequestHeaders(event, sessionCookie, clearedCookieNames) {
+  const requestContext = getRequestSessionContext(event);
+  const requestHeaders = new Headers(event.headers);
+  const cookies = parseRequestCookies(event.headers.get("cookie"));
+  for (const name of clearedCookieNames)
+    cookies.delete(name);
+  const sessionTokenName = sessionCookie.slice(0, sessionCookie.indexOf("="));
+  cookies.set(sessionTokenName, extractResponseCookieValue(sessionCookie));
+  const nextCookieHeader = serializeRequestCookies(cookies);
+  if (nextCookieHeader)
+    requestHeaders.set("cookie", nextCookieHeader);
+  else
+    requestHeaders.delete("cookie");
+  requestContext.requestHeaders = requestHeaders;
+}
+export async function getRequestSession(event) {
+  const context = getRequestSessionContext(event);
+  if (context.requestSession !== void 0)
+    return context.requestSession;
+  const inFlight = context[requestSessionLoadKey];
+  if (inFlight)
+    return inFlight;
+  const load = loadSession(event);
+  context[requestSessionLoadKey] = load;
+  try {
+    const session = await load;
+    context.requestSession = session;
+    return session;
+  } finally {
+    delete context[requestSessionLoadKey];
+  }
+}
 export async function getUserSession(event) {
-  const auth = await serverAuth(event);
-  const session = await auth.api.getSession({ headers: event.headers });
-  return session;
+  const context = getRequestSessionContext(event);
+  if (context.requestSession !== void 0)
+    return context.requestSession;
+  const inFlight = context[requestSessionLoadKey];
+  if (inFlight)
+    return inFlight;
+  return loadSession(event);
+}
+export async function setSessionCookie(event, token) {
+  const context = await getServerAuthContext(event);
+  const sessionCookie = await serializeSignedCookie(
+    context.authCookies.sessionToken.name,
+    token,
+    context.secret,
+    {
+      ...context.authCookies.sessionToken.attributes,
+      maxAge: context.sessionConfig.expiresIn
+    }
+  );
+  appendCookieHeader(event, sessionCookie);
+  expireCookies(event, context.authCookies.sessionData);
+  expireCookies(event, context.authCookies.dontRememberToken);
+  const requestContext = getRequestSessionContext(event);
+  delete requestContext.requestSession;
+  delete requestContext[requestSessionLoadKey];
+  updateRequestHeaders(event, sessionCookie, [
+    ...getChunkedCookieNames(event, context.authCookies.sessionData.name),
+    ...getChunkedCookieNames(event, context.authCookies.dontRememberToken.name)
+  ]);
+}
+export async function createSession(event, userId) {
+  const context = await getServerAuthContext(event);
+  return context.internalAdapter.createSession?.(userId, false);
 }
 export async function requireUserSession(event, options) {
-  const session = await getUserSession(event);
+  const session = await getRequestSession(event);
   if (!session)
     throw createError({ statusCode: 401, statusMessage: "Authentication required" });
   if (options?.user) {

package/dist/runtime/server/virtual-modules.d.ts

@@ -0,0 +1,27 @@
+declare module '#auth/database' {
+  export const db: any
+  export function createDatabase(...args: any[]): any
+}
+
+declare module '#imports' {
+  export function getRouteRules(event: any): any
+  export function useRuntimeConfig(): any
+}
+
+declare module '#auth/secondary-storage' {
+  export function createSecondaryStorage(...args: any[]): any
+}
+
+declare module '#auth/schema' {
+  export const schema: any
+}
+
+declare module '#auth/server' {
+  const createServerAuth: any
+  export default createServerAuth
+}
+
+declare module '@nuxthub/db' {
+  export const db: any
+  export const schema: any
+}

package/dist/runtime/types/augment.d.ts

@@ -21,15 +21,15 @@ export interface AuthSession {
 export interface ServerAuthContext {
     runtimeConfig: Record<string, unknown>;
     db: unknown;
+    requestOrigin?: string;
+}
+export interface AuthSocialProviderRegistry {
 }
 export interface UserSessionComposable {
-    client: unknown;
     user: Ref<AuthUser | null>;
     session: Ref<AuthSession | null>;
     loggedIn: ComputedRef<boolean>;
     ready: ComputedRef<boolean>;
-    signIn: unknown;
-    signUp: unknown;
     fetchSession: (options?: {
         headers?: HeadersInit;
         force?: boolean;
@@ -38,5 +38,19 @@ export interface UserSessionComposable {
     signOut: (options?: {
         onSuccess?: () => void | Promise<void>;
     }) => Promise<void>;
-    updateUser: (updates: Partial<AuthUser>) => void;
+    updateUser: (updates: Partial<AuthUser>) => Promise<void>;
+}
+export type UserMatch<T> = {
+    [K in keyof T]?: T[K] | T[K][];
+};
+export interface AppSession {
+    user: AuthUser;
+    session: AuthSession;
+}
+export interface RequireSessionOptions {
+    user?: UserMatch<AuthUser>;
+    rule?: (ctx: {
+        user: AuthUser;
+        session: AuthSession;
+    }) => boolean | Promise<boolean>;
 }

package/dist/runtime/types.d.ts

@@ -1,11 +1,17 @@
 import type { NitroRouteRules } from 'nitropack/types';
-import type { AuthSession, AuthUser } from './types/augment.js';
-export type { AuthSession, AuthUser, ServerAuthContext, UserSessionComposable } from './types/augment.js';
-export type { Auth, InferSession, InferUser } from 'better-auth';
+import type { AuthSocialProviderRegistry, AuthUser, UserMatch } from '#nuxt-better-auth';
+export type { AppSession, AuthSession, AuthSocialProviderRegistry, AuthUser, RequireSessionOptions, ServerAuthContext, UserMatch, UserSessionComposable } from './types/augment.js';
+export type AuthSocialProviderId = AuthSocialProviderRegistry extends {
+    ids: infer T;
+} ? Extract<T, string> : never;
+export type { Auth, InferPluginTypes, InferSessionFromClient as InferSession, InferUserFromClient as InferUser } from 'better-auth';
+export interface AuthActionError {
+    message: string;
+    code?: string;
+    status?: number;
+    raw: unknown;
+}
 export type AuthMode = 'guest' | 'user';
-export type UserMatch<T> = {
-    [K in keyof T]?: T[K] | T[K][];
-};
 export type AuthMeta = false | AuthMode | {
     only?: AuthMode;
     redirectTo?: string;
@@ -14,10 +20,3 @@ export type AuthMeta = false | AuthMode | {
 export type AuthRouteRules = NitroRouteRules & {
     auth?: AuthMeta;
 };
-export interface RequireSessionOptions {
-    user?: UserMatch<AuthUser>;
-    rule?: (ctx: {
-        user: AuthUser;
-        session: AuthSession;
-    }) => boolean | Promise<boolean>;
-}

package/dist/types.d.mts

@@ -6,6 +6,6 @@ export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<
 
 export { type BetterAuthModuleOptions, type defineClientAuth, type defineServerAuth } from '../dist/runtime/config.js'
 
-export { type Auth, type AuthMeta, type AuthMode, type AuthRouteRules, type AuthSession, type AuthUser, type InferSession, type InferUser, type RequireSessionOptions, type ServerAuthContext, type UserMatch } from '../dist/runtime/types.js'
+export { type AppSession, type Auth, type AuthActionError, type AuthMeta, type AuthMode, type AuthRouteRules, type AuthSession, type AuthSocialProviderId, type AuthUser, type InferSession, type InferUser, type RequireSessionOptions, type ServerAuthContext, type UserMatch } from '../dist/runtime/types.js'
 
 export { default } from './module.mjs'

package/package.json

@@ -1,20 +1,25 @@
 {
   "name": "@onmax/nuxt-better-auth",
   "type": "module",
-  "version": "0.0.2-alpha.9",
-  "packageManager": "pnpm@10.15.1",
+  "version": "0.0.2",
+  "packageManager": "pnpm@11.1.0",
   "description": "Nuxt module for Better Auth integration with NuxtHub, route protection, session management, and role-based access",
   "author": "onmax",
   "license": "MIT",
+  "homepage": "https://better-auth.nuxt.dev",
   "repository": {
     "type": "git",
-    "url": "https://github.com/onmax/nuxt-better-auth"
+    "url": "https://github.com/nuxt-modules/better-auth"
   },
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs"
     },
+    "./composables": {
+      "types": "./dist/runtime/composables.d.ts",
+      "import": "./dist/runtime/composables.js"
+    },
     "./config": {
       "types": "./dist/runtime/config.d.ts",
       "import": "./dist/runtime/config.js"
@@ -26,6 +31,9 @@
       ".": [
         "./dist/types.d.mts"
       ],
+      "composables": [
+        "./dist/runtime/composables.d.ts"
+      ],
       "config": [
         "./dist/runtime/config.d.ts"
       ]
@@ -41,16 +49,17 @@
     "dev:prepare": "nuxt-module-build build --stub && nuxi prepare playground",
     "dev:docs": "nuxi dev docs",
     "build:docs": "nuxi build docs",
-    "release": "bumpp --push",
+    "release": "bumpp --push --no-push-all",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "typecheck": "vue-tsc --noEmit",
-    "typecheck:playground": "cd playground && vue-tsc --noEmit",
+    "typecheck:runtime-server": "cd test/cases/plugins-type-inference && nuxi prepare && vue-tsc --noEmit --pretty false -p .nuxt/tsconfig.server.json",
+    "typecheck:playground": "pnpm -C playground exec nuxi prepare && pnpm -C playground exec vue-tsc --noEmit -p .nuxt/tsconfig.app.json",
     "test": "vitest run",
     "test:watch": "vitest watch"
   },
   "peerDependencies": {
-    "@nuxthub/core": ">=0.10.0",
+    "@nuxthub/core": ">=0.10.5",
     "better-auth": ">=1.0.0"
   },
   "peerDependenciesMeta": {
@@ -59,56 +68,51 @@
     }
   },
   "dependencies": {
-    "@nuxt/kit": "^4.2.2",
+    "@better-auth/cli": "1.5.0-beta.13",
+    "@nuxt/kit": "^4.3.1",
+    "@nuxt/ui": "^4.5.0",
     "defu": "^6.1.4",
-    "jiti": "^2.4.2",
+    "h3": "^1.15.11",
+    "jiti": "^2.6.1",
     "pathe": "^2.0.3",
-    "pluralize": "^8.0.0",
-    "radix3": "^1.1.2"
+    "radix3": "^1.1.2",
+    "std-env": "^4.0.0",
+    "ufo": "^1.6.4"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.12.0",
-    "@better-auth/cli": "^1.4.6",
-    "@libsql/client": "^0.15.15",
-    "@nuxt/devtools": "^3.1.1",
-    "@nuxt/devtools-kit": "^3.1.1",
+    "@antfu/eslint-config": "^9.0.0",
+    "@libsql/client": "^0.17.3",
+    "@libsql/linux-x64-gnu": "0.5.29",
+    "@nuxt/devtools": "^3.2.3",
+    "@nuxt/devtools-kit": "^3.2.4",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "^4.2.2",
-    "@nuxt/test-utils": "^3.21.0",
-    "@nuxthub/core": "^0.10.3",
+    "@nuxt/schema": "^4.3.1",
+    "@nuxt/test-utils": "^4.0.0",
+    "@nuxthub/core": "^0.10.6",
+    "@pinia/nuxt": "^0.11.3",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "latest",
-    "@types/pluralize": "^0.0.33",
-    "better-auth": "^1.4.7",
-    "better-sqlite3": "^11.9.1",
-    "bumpp": "^10.3.2",
+    "better-auth": "1.5.5",
+    "better-call": "1.3.2",
+    "better-sqlite3": "^12.6.2",
+    "bumpp": "^11.0.0",
     "changelogen": "^0.6.2",
     "consola": "^3.4.2",
-    "drizzle-kit": "^0.31.8",
-    "drizzle-orm": "^0.38.4",
-    "eslint": "^9.39.1",
-    "nuxt": "^4.2.2",
-    "tinyexec": "^1.0.2",
+    "drizzle-kit": "^0.31.10",
+    "drizzle-orm": "^0.45.1",
+    "eslint": "^10.0.3",
+    "nitropack": "2.13.1",
+    "npm-agentskills": "https://pkg.pr.new/onmax/npm-agentskills@394499e",
+    "nuxt": "^4.3.1",
+    "pinia": "^3.0.4",
+    "postgres": "^3.4.9",
+    "tinyexec": "^1.1.1",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.15",
-    "vitest-package-exports": "^0.1.1",
-    "vue-tsc": "^3.1.7",
-    "yaml": "^2.8.2"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "@parcel/watcher",
-      "better-sqlite3",
-      "esbuild",
-      "sharp",
-      "workerd"
-    ],
-    "patchedDependencies": {
-      "@peculiar/x509@1.14.2": "patches/@peculiar__x509@1.14.2.patch",
-      "unenv@2.0.0-rc.24": "patches/unenv@2.0.0-rc.24.patch"
-    },
-    "overrides": {
-      "reka-ui": "^2.6.1"
-    }
+    "unstorage": "^1.17.5",
+    "vitest": "^4.0.18",
+    "vitest-package-exports": "^1.2.0",
+    "vue": "3.5.29",
+    "vue-tsc": "^3.2.7",
+    "yaml": "^2.8.3"
   }
 }