nuxt-bearer-auth 0.1.0

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

@@ -0,0 +1,207 @@
+import crypto from "node:crypto";
+import { createClient } from "redis";
+import {
+  createError,
+  deleteCookie,
+  getCookie,
+  getHeaders,
+  getRequestIP,
+  setCookie
+} from "h3";
+import {
+  getBearerAuthConfig,
+  getSessionCookieName,
+  isProductionRuntime
+} from "./config.js";
+const SESSION_PREFIX = "session:";
+const USER_SESSIONS_PREFIX = "user_sessions:";
+const globalForRedis = globalThis;
+export function getBearerAuthRedisClient() {
+  if (!globalForRedis.__nuxtBearerAuthRedis) {
+    const config = getBearerAuthConfig();
+    const client = createClient({
+      url: config.redisUrl || process.env.REDIS_URL || "redis://127.0.0.1:6379",
+      socket: {
+        reconnectStrategy: (retries) => Math.min(retries * 100, 3e3),
+        connectTimeout: 1e4
+      }
+    });
+    client.on("error", (error) => {
+      console.error("[nuxt-bearer-auth] Redis error:", error);
+    });
+    globalForRedis.__nuxtBearerAuthRedis = client;
+  }
+  return globalForRedis.__nuxtBearerAuthRedis;
+}
+export async function ensureBearerAuthRedisConnection() {
+  const redis = getBearerAuthRedisClient();
+  if (!redis.isOpen && !redis.isReady) {
+    await redis.connect();
+  }
+  return redis;
+}
+function getSessionDuration() {
+  return getBearerAuthConfig().sessionCookie.maxAge;
+}
+function getCookieOptions() {
+  const config = getBearerAuthConfig();
+  const cookie = config.sessionCookie;
+  return {
+    httpOnly: true,
+    sameSite: cookie.sameSite,
+    secure: cookie.secure ?? isProductionRuntime(),
+    domain: cookie.domain,
+    path: cookie.path || "/",
+    maxAge: cookie.maxAge
+  };
+}
+export async function createBearerAuthSession(event, input) {
+  const redis = await ensureBearerAuthRedisConnection();
+  const sessionId = crypto.randomUUID();
+  const headers = getHeaders(event);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const duration = getSessionDuration();
+  const session = {
+    userId: input.userId,
+    token: input.token,
+    refreshToken: input.refreshToken || null,
+    profile: input.profile || null,
+    createdAt: now,
+    expiresAt: Date.now() + duration * 1e3,
+    lastActivity: now,
+    userAgent: headers["user-agent"],
+    ipAddress: getRequestIP(event, { xForwardedFor: true })
+  };
+  const multi = redis.multi();
+  multi.setEx(`${SESSION_PREFIX}${sessionId}`, duration, JSON.stringify(session));
+  multi.sAdd(`${USER_SESSIONS_PREFIX}${input.userId}`, sessionId);
+  multi.expire(`${USER_SESSIONS_PREFIX}${input.userId}`, duration);
+  await multi.exec();
+  setCookie(event, getSessionCookieName(), sessionId, getCookieOptions());
+  return sessionId;
+}
+export async function updateBearerAuthSession(event, updates) {
+  const sessionId = getBearerAuthSessionCookie(event);
+  if (!sessionId) return false;
+  const redis = await ensureBearerAuthRedisConnection();
+  const key = `${SESSION_PREFIX}${sessionId}`;
+  const data = await redis.get(key);
+  if (!data) return false;
+  const existing = JSON.parse(data);
+  if (Date.now() > existing.expiresAt) {
+    await destroyBearerAuthSession(event);
+    return false;
+  }
+  const duration = getSessionDuration();
+  const session = {
+    ...existing,
+    ...updates,
+    expiresAt: Date.now() + duration * 1e3,
+    lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await redis.setEx(key, duration, JSON.stringify(session));
+  event.context.auth = session;
+  return true;
+}
+export async function getBearerAuthSession(event) {
+  const sessionId = getBearerAuthSessionCookie(event);
+  if (!sessionId) return null;
+  const redis = await ensureBearerAuthRedisConnection();
+  const key = `${SESSION_PREFIX}${sessionId}`;
+  const data = await redis.get(key);
+  if (!data) {
+    deleteCookie(event, getSessionCookieName(), { path: "/" });
+    return null;
+  }
+  const session = JSON.parse(data);
+  if (Date.now() > session.expiresAt) {
+    await destroyBearerAuthSession(event);
+    return null;
+  }
+  updateSessionActivity(sessionId, session).catch(() => void 0);
+  return session;
+}
+async function updateSessionActivity(sessionId, session) {
+  const redis = await ensureBearerAuthRedisConnection();
+  const duration = getSessionDuration();
+  const updatedSession = {
+    ...session,
+    expiresAt: Date.now() + duration * 1e3,
+    lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await redis.setEx(
+    `${SESSION_PREFIX}${sessionId}`,
+    duration,
+    JSON.stringify(updatedSession)
+  );
+}
+export async function destroyBearerAuthSession(event) {
+  const sessionId = getBearerAuthSessionCookie(event);
+  if (!sessionId) {
+    deleteCookie(event, getSessionCookieName(), { path: "/" });
+    return;
+  }
+  const redis = await ensureBearerAuthRedisConnection();
+  const key = `${SESSION_PREFIX}${sessionId}`;
+  const data = await redis.get(key);
+  if (data) {
+    const session = JSON.parse(data);
+    await redis.sRem(`${USER_SESSIONS_PREFIX}${session.userId}`, sessionId);
+  }
+  await redis.del(key);
+  deleteCookie(event, getSessionCookieName(), { path: "/" });
+}
+export async function destroyAllBearerAuthSessions(userId) {
+  const redis = await ensureBearerAuthRedisConnection();
+  const key = `${USER_SESSIONS_PREFIX}${userId}`;
+  const sessionIds = await redis.sMembers(key);
+  if (!sessionIds.length) return;
+  const multi = redis.multi();
+  for (const sessionId of sessionIds) {
+    multi.del(`${SESSION_PREFIX}${sessionId}`);
+  }
+  multi.del(key);
+  await multi.exec();
+}
+export async function getUserBearerAuthSessions(userId) {
+  const redis = await ensureBearerAuthRedisConnection();
+  const sessionIds = await redis.sMembers(`${USER_SESSIONS_PREFIX}${userId}`);
+  const sessions = [];
+  for (const sessionId of sessionIds) {
+    const data = await redis.get(`${SESSION_PREFIX}${sessionId}`);
+    if (!data) continue;
+    const session = JSON.parse(data);
+    sessions.push({
+      id: sessionId,
+      createdAt: session.createdAt,
+      lastActivity: session.lastActivity,
+      userAgent: session.userAgent,
+      ipAddress: session.ipAddress
+    });
+  }
+  return sessions.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+}
+export async function deleteUserBearerAuthSession(userId, sessionId) {
+  const redis = await ensureBearerAuthRedisConnection();
+  const key = `${SESSION_PREFIX}${sessionId}`;
+  const data = await redis.get(key);
+  if (!data) {
+    throw createError({ statusCode: 404, statusMessage: "Session not found" });
+  }
+  const session = JSON.parse(data);
+  if (session.userId !== userId) {
+    throw createError({ statusCode: 403, statusMessage: "Unauthorized" });
+  }
+  await redis.del(key);
+  await redis.sRem(`${USER_SESSIONS_PREFIX}${userId}`, sessionId);
+}
+export function getBearerAuthSessionCookie(event) {
+  return getCookie(event, getSessionCookieName()) || null;
+}
+export function requireBearerAuthSession(event) {
+  const session = event.context.auth;
+  if (!session?.userId) {
+    throw createError({ statusCode: 401, statusMessage: "Unauthenticated" });
+  }
+  return session;
+}

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

@@ -0,0 +1,49 @@
+export type AuthStatus = "idle" | "loading" | "authenticated" | "unauthenticated";
+export interface BearerAuthUser {
+    id?: string | number;
+    uuid?: string;
+    email?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+export interface BearerAuthSession<User extends BearerAuthUser = BearerAuthUser> {
+    userId: string;
+    token: string;
+    refreshToken?: string | null;
+    profile: User | null;
+    createdAt: string;
+    expiresAt: number;
+    lastActivity: string;
+    userAgent?: string;
+    ipAddress?: string;
+}
+export interface PublicSession {
+    id: string;
+    createdAt: string;
+    lastActivity: string;
+    userAgent?: string;
+    ipAddress?: string;
+}
+export interface AuthApiResponse<T = unknown> {
+    success: boolean;
+    message?: string;
+    data?: T;
+    user?: BearerAuthUser | null;
+    code?: string | number;
+    nextAction?: string;
+}
+export interface LoginCredentials {
+    identifier: string;
+    password: string;
+    [key: string]: unknown;
+}
+export interface SocialLoginCredentials {
+    jwt?: string;
+    token?: string;
+    provider?: string;
+    [key: string]: unknown;
+}
+export interface FetchUserOptions {
+    refresh?: boolean;
+}
+//# sourceMappingURL=auth.d.ts.map

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

@@ -0,0 +1,7 @@
+import type { BearerAuthSession } from "./auth";
+
+declare module "h3" {
+  interface H3EventContext {
+    auth?: BearerAuthSession | null;
+  }
+}

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.js'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module'

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "nuxt-bearer-auth",
+  "version": "0.1.0",
+  "description": "Reusable Nuxt authentication module for bearer-token APIs with Redis sessions and CSRF protection.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Enoch Tetteh",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "auth",
+    "authentication",
+    "bearer-token",
+    "redis",
+    "csrf",
+    "laravel"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/module.d.ts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "types": "./dist/module.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "nuxt-module-build build",
+    "dev:prepare": "nuxt-module-build --stub",
+    "prepack": "nuxt-module-build build",
+    "typecheck": "vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "defu": "^6.1.4",
+    "ofetch": "^1.4.1",
+    "redis": "^5.11.0"
+  },
+  "peerDependencies": {
+    "nuxt": "^3.12.0 || ^4.0.0",
+    "nuxt-csurf": "^1.6.5"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^0.8.4",
+    "@nuxt/schema": "^3.12.0",
+    "@nuxt/kit": "^3.12.0",
+    "nuxt": "^3.12.0",
+    "typescript": "^5.5.0",
+    "vue-tsc": "^2.0.0"
+  },
+  "packageManager": "npm@10.0.0"
+}