@meistrari/auth-nuxt 0.2.0 → 1.0.0

package/dist/runtime/plugin.js

@@ -1,105 +1,90 @@
-import { defineNuxtPlugin, useCookie, useRequestHeaders, useRuntimeConfig } from "#app";
+import { defineNuxtPlugin, useCookie, useRuntimeConfig, useRequestURL } from "#app";
 import { watch } from "vue";
-import { createAuthClient, isTokenExpired } from "@meistrari/auth-core";
-import { useMeistrariAuth } from "./composable.js";
+import { useTelaSession } from "./composables/session.js";
+import { createNuxtAuthClient } from "./shared.js";
+import { useRoute, navigateTo } from "#imports";
 export default defineNuxtPlugin({
-  name: "meistrari-auth",
-  parallel: true,
+  name: "tela-auth",
+  enforce: "pre",
+  env: {
+    islands: false
+  },
   async setup() {
-    const config = useRuntimeConfig().public.auth;
-    const authClient = createAuthClient(config.apiUrl);
-    const { user, session } = useMeistrariAuth();
-    async function getToken() {
-      const token = useCookie(config.jwtCookieName);
-      if (token.value) {
-        if (!isTokenExpired(token.value)) {
-          return token.value;
-        }
-      }
-      try {
-        return await refreshToken();
-      } catch (error) {
-        throw new Error("Failed to get token: " + (error instanceof Error ? error.message : String(error)));
-      }
-    }
-    async function refreshToken() {
-      const token = useCookie(config.jwtCookieName);
-      const headers = useRequestHeaders();
-      const session2 = await authClient.getSession({
-        fetchOptions: {
-          // on the client side we include credentials
-          credentials: "include",
-          // on the server side we forward the cookies
-          headers,
-          onSuccess: (ctx) => {
-            const jwt = ctx.response.headers.get("set-auth-jwt");
-            if (jwt) {
-              token.value = jwt;
-            }
+    const authConfig = useRuntimeConfig().public.telaAuth;
+    const { session, user, getToken } = useTelaSession();
+    const tokenCookie = useCookie(authConfig.jwtCookieName);
+    tokenCookie.value = null;
+    const authClient = createNuxtAuthClient(authConfig.apiUrl, () => tokenCookie.value ?? null);
+    const query = useRoute().query;
+    const nonce = query.nonce;
+    const origin = useRequestURL();
+    if (import.meta.server) {
+      if (nonce && typeof nonce === "string") {
+        if (nonce !== "null") {
+          try {
+            const payload = await authClient.session.getNoncePayload(nonce);
+            tokenCookie.value = payload.token;
+          } catch {
+            await navigateTo(`${authConfig.apiUrl}/api/auth/handshake?origin=${origin.toString()}`, {
+              external: true,
+              redirectCode: 302
+            });
+            return;
           }
         }
-      });
-      if (session2.error || !session2.data?.session) {
-        throw new Error("Failed to refresh token");
+      } else {
+        await navigateTo(`${authConfig.apiUrl}/api/auth/handshake?origin=${origin.toString()}`, {
+          external: true,
+          redirectCode: 302
+        });
+        return;
+      }
+    } else if (import.meta.client && !session.value) {
+      const token = await getToken();
+      if (token) {
+        tokenCookie.value = token;
       }
-      return token.value;
     }
     async function initializeSession() {
       if (session.value && user.value)
         return;
-      const token = useCookie(config.jwtCookieName);
-      const headers = import.meta.server ? useRequestHeaders() : void 0;
-      const { data: sessionData, error: sessionError } = await authClient.getSession(
-        {
-          fetchOptions: {
-            // on the client side we include credentials
-            credentials: "include",
-            // on the server side we forward the cookies
-            headers,
-            ...config.useJwt && {
-              onSuccess: (context) => {
-                const jwt = context.response.headers.get("Set-Auth-Jwt");
-                if (jwt) {
-                  token.value = jwt;
-                }
-              }
-            }
-          }
-        }
-      );
-      if (sessionError || !sessionData) {
+      const sessionData = await authClient.session.getSession();
+      if (!sessionData) {
         return;
       }
       user.value = sessionData.user;
       session.value = sessionData.session;
     }
-    await initializeSession();
+    if (tokenCookie.value) {
+      await initializeSession();
+    }
     if (import.meta.client) {
-      if (config.useJwt) {
-        let tokenRefreshInterval = null;
-        watch(session, async (newVal) => {
-          if (tokenRefreshInterval) {
-            clearTimeout(tokenRefreshInterval);
-            tokenRefreshInterval = null;
-          }
-          if (newVal) {
-            async function createTokenRefreshInterval() {
-              await refreshToken();
-              tokenRefreshInterval = window.setTimeout(createTokenRefreshInterval, 6e4);
+      let tokenRefreshInterval = null;
+      watch(session, async (newVal) => {
+        if (tokenRefreshInterval) {
+          clearTimeout(tokenRefreshInterval);
+          tokenRefreshInterval = null;
+        }
+        if (newVal) {
+          async function createTokenRefreshInterval() {
+            const token = await getToken();
+            if (token) {
+              tokenCookie.value = token;
             }
-            createTokenRefreshInterval();
+            tokenRefreshInterval = window.setTimeout(createTokenRefreshInterval, 6e4);
           }
-        }, { immediate: true });
-      }
-    }
-    return {
-      provide: {
-        auth: {
-          client: authClient,
-          getToken,
-          refreshToken
+          createTokenRefreshInterval();
         }
-      }
-    };
+      }, { immediate: true });
+    }
+  },
+  hooks: {
+    "app:mounted": () => {
+      const url = new URL(window.location.href);
+      url.searchParams.delete("session");
+      url.searchParams.delete("session_data");
+      url.searchParams.delete("nonce");
+      window.history.replaceState({}, "", url.pathname + url.search + url.hash);
+    }
   }
 });

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

@@ -1,26 +1,21 @@
+import { validateToken, extractTokenPayload } from "@meistrari/auth-core";
 import { defineEventHandler, getCookie } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime/config";
-import { createAuthClient } from "@meistrari/auth-core";
 async function setAuthContext(event) {
   event.context.auth = {
-    session: null,
-    user: null
+    user: null,
+    workspace: null
   };
-  const sessionCookie = getCookie(event, "__Secure-__session");
-  if (!sessionCookie)
+  const authConfig = useRuntimeConfig(event).public.telaAuth;
+  const tokenCookie = getCookie(event, authConfig.jwtCookieName);
+  if (!tokenCookie)
     return;
-  const authConfig = useRuntimeConfig(event).public.auth;
-  const authClient = createAuthClient(authConfig.apiUrl);
-  const { data: sessionData, error: sessionError } = await authClient.getSession({
-    fetchOptions: {
-      headers: event.headers
-    }
-  });
-  if (sessionError || !sessionData) {
+  const isValid = await validateToken(tokenCookie, authConfig.apiUrl);
+  if (!isValid)
     return;
-  }
-  event.context.auth.session = sessionData.session;
-  event.context.auth.user = sessionData.user;
+  const payload = extractTokenPayload(tokenCookie);
+  event.context.auth.user = { email: payload.email, ...payload.user };
+  event.context.auth.workspace = payload.workspace;
 }
 export function meistrariAuthMiddleware(callback) {
   return defineEventHandler(async (event) => {

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,6 @@
 {
-  "extends": "../../../.nuxt/tsconfig.server.json",
+    "extends": [
+        "../../../../../../node_modules/@meistrari/mise-en-place/tsconfig.base.json",
+        "../../../.nuxt/tsconfig.server.json"
+    ],
 }

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

@@ -1,22 +1,22 @@
-import type { User, Session } from '@meistrari/auth-core'
+import type { JWTTokenPayload } from '@meistrari/auth-core'
 import type { H3Event, H3EventContext } from 'h3'
 
 declare module 'h3' {
-  interface H3EventContext {
-    auth?: {
-      user: User | null
-      session: Session | null
+    interface H3EventContext {
+        auth?: {
+            user: { email: string } & JWTTokenPayload['user'] | null
+            workspace: JWTTokenPayload['workspace'] | null
+        }
     }
-  }
 }
 
 export interface AuthenticatedH3EventContext extends H3EventContext {
-  auth: {
-    user: User | null
-    session: Session | null
-  }
+    auth: {
+        user: { email: string } & JWTTokenPayload['user'] | null
+        workspace: JWTTokenPayload['workspace'] | null
+    }
 }
 
 export interface AuthenticatedH3Event extends H3Event {
-  context: AuthenticatedH3EventContext
-}
+    context: AuthenticatedH3EventContext
+}

package/dist/runtime/shared.d.ts

@@ -0,0 +1 @@
+export declare function createNuxtAuthClient(apiUrl: string, getAuthToken: () => string | null): any;

package/dist/runtime/shared.js

@@ -0,0 +1,19 @@
+import { AuthClient } from "@meistrari/auth-core";
+const version = "__PACKAGE_VERSION__";
+export function createNuxtAuthClient(apiUrl, getAuthToken) {
+  const serviceName = typeof process !== "undefined" ? process.env.SERVICE_NAME : "";
+  const userAgent = `auth-sdk:nuxt:${version}${serviceName ? `@${serviceName}` : ""}`;
+  return new AuthClient(apiUrl, {
+    headers: {
+      "X-User-Agent": userAgent
+    },
+    onRequest: (context) => {
+      const requestUrl = new URL(context.url);
+      const token = getAuthToken();
+      const isTokenRequest = requestUrl.pathname.endsWith("/api/auth/token");
+      if (token && !isTokenRequest) {
+        context.headers.set("Authorization", `Bearer ${token}`);
+      }
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/auth-nuxt",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "type": "module",
   "exports": {
     ".": {
@@ -31,7 +31,7 @@
     "build": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt-module-build build"
   },
   "dependencies": {
-    "@meistrari/auth-core": "0.1.1"
+    "@meistrari/auth-core": "1.4.0"
   },
   "peerDependencies": {
     "nuxt": "^3.0.0 || ^4.0.0"
@@ -45,11 +45,10 @@
     "@nuxt/test-utils": "3.19.2",
     "@types/node": "latest",
     "changelogen": "0.6.2",
-    "eslint": "9.34.0",
     "nuxt": "4.0.3",
     "typescript": "5.9.2",
     "unbuild": "3.6.1",
     "vitest": "3.2.4",
     "vue-tsc": "3.0.6"
   }
-}
+}

package/dist/runtime/composable.d.ts

@@ -1,5 +0,0 @@
-export declare function useMeistrariAuth(): {
-    user: import("vue").Ref<any, any>;
-    session: import("vue").Ref<any, any>;
-    signOut: (callback?: () => void) => Promise<void>;
-};

package/dist/runtime/composable.js

@@ -1,29 +0,0 @@
-import { useCookie, useState, useRuntimeConfig, useNuxtApp } from "#app";
-export function useMeistrariAuth() {
-  const user = useState("user", () => null);
-  const session = useState("session", () => null);
-  const { useJwt, jwtCookieName, isDevelopment } = useRuntimeConfig().public.auth;
-  const { $auth } = useNuxtApp();
-  async function signOut(callback) {
-    await $auth.client.signOut({
-      fetchOptions: {
-        onSuccess: async () => {
-          if (useJwt) {
-            useCookie(jwtCookieName).value = null;
-          }
-          if (isDevelopment) {
-            await $fetch("/api/meistrari-auth/sign-out");
-          }
-          user.value = null;
-          session.value = null;
-          callback?.();
-        }
-      }
-    });
-  }
-  return {
-    user,
-    session,
-    signOut
-  };
-}

package/dist/runtime/server/api/sign-out.d.ts

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

package/dist/runtime/server/api/sign-out.js

@@ -1,16 +0,0 @@
-import { defineEventHandler, deleteCookie, sendNoContent } from "h3";
-export default defineEventHandler(async (event) => {
-  deleteCookie(event, "__Secure-__session", {
-    httpOnly: true,
-    secure: true,
-    sameSite: "lax",
-    path: "/"
-  });
-  deleteCookie(event, "__Secure-__session_data", {
-    httpOnly: true,
-    secure: true,
-    sameSite: "lax",
-    path: "/"
-  });
-  return sendNoContent(event);
-});

package/dist/runtime/server/middleware/set-cookies.d.ts

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

package/dist/runtime/server/middleware/set-cookies.js

@@ -1,42 +0,0 @@
-import { defineEventHandler, getQuery, setCookie, sendRedirect, getRequestURL } from "h3";
-export default defineEventHandler(async (event) => {
-  const query = getQuery(event);
-  const hasSessionParam = query.session && typeof query.session === "string";
-  const hasSessionDataParam = query.session_data && typeof query.session_data === "string";
-  if (hasSessionParam || hasSessionDataParam) {
-    if (hasSessionParam) {
-      setCookie(event, "__Secure-__session", query.session, {
-        httpOnly: true,
-        secure: true,
-        sameSite: "lax",
-        path: "/",
-        maxAge: 60 * 60 * 24 * 7
-        // 1 week in seconds
-      });
-    }
-    if (hasSessionDataParam) {
-      setCookie(event, "__Secure-__session_data", query.session_data, {
-        httpOnly: true,
-        secure: true,
-        sameSite: "lax",
-        path: "/",
-        maxAge: 60 * 60 * 24 * 7
-        // 1 week in seconds
-      });
-    }
-    const url = getRequestURL(event);
-    const newQuery = new URLSearchParams();
-    for (const [key, value] of Object.entries(query)) {
-      if (key !== "session" && key !== "session_data" && value !== void 0 && value !== null) {
-        if (Array.isArray(value)) {
-          value.forEach((v) => newQuery.append(key, String(v)));
-        } else {
-          newQuery.append(key, String(value));
-        }
-      }
-    }
-    const queryString = newQuery.toString();
-    const redirectUrl = `${url.pathname}${queryString ? `?${queryString}` : ""}`;
-    return sendRedirect(event, redirectUrl, 302);
-  }
-});