@innertia-solutions/innertia-nuxt 0.1.62 → 0.1.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@innertia-solutions/innertia-nuxt",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "description": "Innertia Solutions — Nuxt layer unificada: core, auth, multitenancy, theme y app contexts",
   "keywords": [
     "nuxt",
@@ -54,7 +54,8 @@
     "tailwindcss": "^4.0.0",
     "uuid": "^13.0.0",
     "vanilla-calendar-pro": "^3.1.0",
-    "vue3-apexcharts": "^1.11.1"
+    "vue3-apexcharts": "^1.11.1",
+    "iron-webcrypto": "^1.2.1"
   },
   "scripts": {
     "test": "vitest run"

package/server/routes/_auth/platform/login.post.ts

@@ -0,0 +1,27 @@
+import { defineEventHandler, readBody, createError } from 'h3'
+import { writeSession } from '../../../utils/session'
+import { normalizeLoginResponse } from '../../../utils/login'
+
+// Login de plataforma (identidad separada, sin contexto de tenant). Llama a
+// Laravel /platform/auth/login server-to-server; en éxito sella el JWT en la
+// sesión httpOnly (igual que /_auth/login) y devuelve el body SIN token. Es
+// imprescindible que pase por acá y no por el BFF catch-all /api/**, que solo
+// proxea y NO sella la cookie → la sesión nunca quedaría establecida.
+export default defineEventHandler(async (event) => {
+  const { email, password } = await readBody(event)
+  const config = useRuntimeConfig(event)
+  let data: any
+  try {
+    data = await $fetch(`${config.apiInternalUrl}/platform/auth/login`, {
+      method: 'POST',
+      body: { email, password },
+      headers: { Accept: 'application/json' },
+    })
+  } catch (err: any) {
+    const status = err?.response?.status ?? err?.statusCode ?? 500
+    throw createError({ statusCode: status, data: err?.data ?? null, statusMessage: 'login_failed' })
+  }
+  const { token, body } = normalizeLoginResponse(data)
+  await writeSession(event, { token })
+  return body
+})

package/server/utils/session.ts

@@ -1,5 +1,15 @@
-import { useSession } from 'h3'
+import { getCookie, setCookie, deleteCookie } from 'h3'
 import type { H3Event } from 'h3'
+import { seal, unseal, defaults as ironDefaults } from 'iron-webcrypto'
+
+// Sesión httpOnly sellada con iron (el token nunca llega al JS del browser).
+//
+// IMPORTANTE: NO usamos `useSession` de h3. Su `getSession` bajo la concurrencia de
+// Nitro devolvía sesión vacía en ~60% de requests paralelos y, peor, REESCRIBÍA la
+// cookie vacía cuando el unseal fallaba (envenenaba la sesión → logout aleatorio).
+// iron (seal/unseal) es concurrency-safe por sí solo (probado 40× paralelo sin fallos);
+// el bug vivía en la maquinaria de useSession. Acá hacemos lectura PURA: getCookie +
+// unseal, sin tocar la cookie en fallo. Escritura explícita solo en login/logout/context.
 
 export const SESSION_COOKIE = 'innertia_session'
 
@@ -8,7 +18,7 @@ export interface SessionData {
   currentContext?: string
 }
 
-/** Opciones de la sesión sellada. Pura y testeable. */
+/** Opciones de cookie sellada. `sessionOptions` se conserva para los tests (pura). */
 export function sessionOptions(password: string, opts: { secure?: boolean } = {}) {
   if (!password || password.length < 32) {
     throw new Error('[innertia-auth] NUXT_SESSION_PASSWORD debe tener ≥32 caracteres')
@@ -26,28 +36,45 @@ export function sessionOptions(password: string, opts: { secure?: boolean } = {}
   }
 }
 
-// Secure cookie en qa/prod (HTTPS); en dev local (http) debe ir sin Secure o el
-// browser la descarta silenciosamente → logout loop.
-function secureCookie(): boolean {
-  return process.env.NODE_ENV !== 'development'
+function password(event: H3Event): string {
+  const p = useRuntimeConfig(event).session.password
+  if (!p || p.length < 32) {
+    throw new Error('[innertia-auth] NUXT_SESSION_PASSWORD debe tener ≥32 caracteres')
+  }
+  return p
 }
 
-function password(event: H3Event): string {
-  // runtimeConfig.session.password (privado), llenado desde NUXT_SESSION_PASSWORD.
-  return useRuntimeConfig(event).session.password
+// Secure en qa/prod (HTTPS); en dev local (http) sin Secure o el browser la descarta.
+function secureCookie(): boolean {
+  return process.env.NODE_ENV !== 'development'
 }
 
+/** Lectura PURA: getCookie + iron unseal. Nunca reescribe la cookie (ni en fallo). */
 export async function readSession(event: H3Event): Promise<SessionData> {
-  const s = await useSession<SessionData>(event, sessionOptions(password(event), { secure: secureCookie() }))
-  return s.data
+  const raw = getCookie(event, SESSION_COOKIE)
+  if (!raw) return {}
+  try {
+    const d = (await unseal(globalThis.crypto as Crypto, raw, password(event), ironDefaults)) as any
+    if (!d || typeof d !== 'object') return {}
+    // Compat: sesiones viejas selladas por useSession envuelven en {id,createdAt,data}.
+    return (d.data && typeof d.data === 'object') ? d.data : d
+  } catch {
+    return {}
+  }
 }
 
+/** Sella {token, currentContext} y setea la cookie httpOnly. */
 export async function writeSession(event: H3Event, data: SessionData): Promise<void> {
-  const s = await useSession<SessionData>(event, sessionOptions(password(event), { secure: secureCookie() }))
-  await s.update(data)
+  const sealed = await seal(globalThis.crypto as Crypto, data, password(event), ironDefaults)
+  setCookie(event, SESSION_COOKIE, sealed, {
+    httpOnly: true,
+    sameSite: 'lax',
+    secure: secureCookie(),
+    path: '/',
+    maxAge: 60 * 60 * 24 * 7,
+  })
 }
 
 export async function clearSession(event: H3Event): Promise<void> {
-  const s = await useSession<SessionData>(event, sessionOptions(password(event), { secure: secureCookie() }))
-  await s.clear()
+  deleteCookie(event, SESSION_COOKIE, { path: '/' })
 }