@innertia-solutions/innertia-nuxt 0.1.46 → 0.1.48

package/app.config.ts

@@ -149,7 +149,7 @@ export default defineAppConfig({
 // ─── Tipos públicos ──────────────────────────────────────────────────────────
 // Re-exportados desde acá para que cualquier composable / componente los importe.
 
-export type InnertiaMode = 'saas' | 'app'
+export type InnertiaMode = 'saas' | 'app' | 'open'
 
 export type ContextMobileMode = 'allow' | 'block' | 'redirect'
 

package/components/App/NotificationBell.vue

@@ -30,7 +30,8 @@ const items = computed(() => tab.value === 'unread'
   ? store.notifications.filter(n => !n.read_at)
   : store.notifications)
 
-const badge = computed(() => serverUnread.value > 9 ? '9+' : String(serverUnread.value))
+const liveUnread = computed(() => Math.max(serverUnread.value, store.unreadCount))
+const badge = computed(() => liveUnread.value > 9 ? '9+' : String(liveUnread.value))
 
 async function load() {
   loading.value = true

package/composables/useAuth.js

@@ -1,4 +1,4 @@
-// useAuthStore, useApi, useOrganizationStore auto-imported
+// useAuthStore, useApi, useOrganizationStore, useInnertiaMode, useGymSelection, useGymStore auto-imported
 
 export function useAuth() {
   const authStore = useAuthStore()
@@ -20,6 +20,15 @@ export function useAuth() {
     authStore.setCurrentContext(context)
     queryClient.clear()
     await fetchMe()
+
+    // En modo 'open' el tenant se resuelve por selección: cargamos los gyms del
+    // usuario y devolvemos un destino (0/1/2+). saas/app conservan su return.
+    if (useInnertiaMode().isOpen()) {
+      const { resolveAfterLogin } = useGymSelection()
+      const gymDestination = await resolveAfterLogin() // 'onboarding' | 'ready' | 'picker'
+      return { ...(data ?? {}), gymDestination }
+    }
+
     return data
   }
 
@@ -68,6 +77,8 @@ export function useAuth() {
     queryClient.clear()
     authStore.logout()
     organizationStore.reset()
+    // En open, limpiar también el gym seleccionado
+    if (useInnertiaMode().isOpen()) useGymStore().reset()
     await navigateTo(loginPath)
   }
 

package/composables/useGymSelection.ts

@@ -0,0 +1,35 @@
+// useApi, useGymStore auto-imported.
+// Selección de gym en modo 'open': carga los gyms del usuario y resuelve
+// el destino post-login según cuántos tenga (0 / 1 / 2+).
+
+export function useGymSelection() {
+  const api = useApi()
+  const gym = useGymStore()
+
+  /** Carga los gyms del usuario autenticado y los guarda en el store. */
+  async function load() {
+    // Shape esperado: { gyms: [{ key, name, status, contexts }] }
+    const data = await api.get('auth/my-gyms')
+    gym.setGyms(data?.gyms || [])
+    return gym.gyms
+  }
+
+  /**
+   * Resuelve a dónde llevar al usuario tras el login.
+   *   'onboarding' → 0 gyms (debe crear/unirse a uno)
+   *   'ready'      → 1 gym (auto-seleccionado) o ya tenía uno activo válido
+   *   'picker'     → 2+ gyms sin selección válida previa
+   */
+  async function resolveAfterLogin() {
+    await load()
+    if (gym.gyms.length === 0) return 'onboarding'
+    if (gym.gyms.length === 1) { gym.setActive(gym.gyms[0].key); return 'ready' }
+    if (gym.activeKey && gym.gyms.some((g) => g.key === gym.activeKey)) return 'ready'
+    return 'picker'
+  }
+
+  /** Cambia el gym activo (switcher). */
+  function switchTo(key) { gym.setActive(key) }
+
+  return { load, resolveAfterLogin, switchTo }
+}

package/composables/useInnertiaMode.ts

@@ -1,7 +1,7 @@
 import type { InnertiaMode } from '../app.config'
 
 /**
- * Devuelve el modo activo de la librería: 'saas' | 'app'.
+ * Devuelve el modo activo de la librería: 'saas' | 'app' | 'open'.
  * Default: 'saas' (compatibilidad con productos existentes).
  *
  * Se configura en `nuxt.config.ts` del producto:
@@ -10,7 +10,9 @@ import type { InnertiaMode } from '../app.config'
  * Helpers de conveniencia:
  *   isSaas()    → true si mode === 'saas'
  *   isApp()     → true si mode === 'app'
- *   hasTenant() → true si mode === 'saas' (solo saas usa multitenancy)
+ *   isOpen()    → true si mode === 'open'
+ *   hasTenant() → true si mode === 'saas' | 'open' (usan multitenancy;
+ *                 saas resuelve por subdominio, open por gym seleccionado)
  */
 export function useInnertiaMode() {
   const appConfig = useAppConfig()
@@ -20,6 +22,7 @@ export function useInnertiaMode() {
     mode,
     isSaas:    () => mode === 'saas',
     isApp:     () => mode === 'app',
-    hasTenant: () => mode === 'saas',
+    isOpen:    () => mode === 'open',
+    hasTenant: () => mode === 'saas' || mode === 'open',
   }
 }

package/composables/useRealtime.js

@@ -53,6 +53,29 @@ export function useRealtime() {
       options.wssPort = pusherWsPort ? Number(pusherWsPort) : 443
     }
 
+    // Authorizer para canales private-*: postea al /broadcasting/auth del backend
+    // con headers frescos (Bearer + X-Tenant) reconstruidos en cada intento.
+    const apiBase = config.public.apiBaseUrl || '/api'
+    options.channelAuthorization = {
+      transport: 'ajax',
+      endpoint: `${apiBase}/broadcasting/auth`,
+      // Handler propio: reconstruye headers (token/X-Tenant) en cada auth.
+      customHandler: async ({ socketId, channelName }, callback) => {
+        try {
+          const headers = {}
+          run(headers)
+          const res = await $fetch(`${apiBase}/broadcasting/auth`, {
+            method: 'POST',
+            headers,
+            body: { socket_id: socketId, channel_name: channelName },
+          })
+          callback(null, res)
+        } catch (err) {
+          callback(err, null)
+        }
+      },
+    }
+
     pusher.value = new Pusher(pusherAppKey, options)
 
     pusher.value.connection.bind('connected', () => {

package/middleware/01.detect-subdomain.global.ts

@@ -2,8 +2,8 @@
 // Server-only: lee el hostname de la request para extraer el subdomain del tenant.
 // Solo activo en mode === 'saas'.
 export default defineNuxtRouteMiddleware((to) => {
-  // Modo no-saas → no hay tenant que detectar
-  if (!useInnertiaMode().hasTenant()) return
+  // Solo saas resuelve el tenant por subdominio (open lo hace por selección in-app)
+  if (!useInnertiaMode().isSaas()) return
 
   // Evitar loop infinito: si ya estamos en la página de error de tenant, no redirigir de nuevo.
   if (to.path === '/tenant-error') return

package/middleware/02.validate-tenant.global.ts

@@ -3,8 +3,8 @@
 // Usa la URL interna del backend (apiInternalUrl) para evitar pasar por el proxy de Nitro.
 // Solo activo en mode === 'saas'.
 export default defineNuxtRouteMiddleware(async (to) => {
-  // Modo no-saas → no hay tenant que validar
-  if (!useInnertiaMode().hasTenant()) return
+  // Solo saas valida el tenant por subdominio (open lo hace por selección in-app)
+  if (!useInnertiaMode().isSaas()) return
 
   if (!import.meta.server) return
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@innertia-solutions/innertia-nuxt",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "Innertia Solutions — Nuxt layer unificada: core, auth, multitenancy, theme y app contexts",
   "keywords": [
     "nuxt",

package/plugins/api-tenant.client.ts

@@ -1,19 +1,29 @@
 // Registra el interceptor del header X-Tenant.
-// El backend (ResolveTenantFromHeader) identifica el tenant por su key/slug,
-// no por UUID. Solo se envía cuando el tenant está validado (tenantId != null)
-// para evitar enviar el slug 'local' de dev que no existe en la DB.
+// El backend (ResolveTenantFromHeader) identifica el tenant por su key/slug, no por UUID.
+//   - saas: slug del tenant resuelto por subdominio (tenantStore); solo se envía
+//     cuando el tenant está validado (tenantId != null) para evitar el 'local' de dev.
+//   - open: key del gym seleccionado in-app (gymStore.activeKey).
 // useRequestInterceptors auto-imported desde nuxt-core.
-// useTenantStore auto-imported desde saas stores.
-// Solo activo en mode === 'saas'.
+// useTenantStore / useGymStore auto-imported desde stores.
+// Activo en mode === 'saas' | 'open'.
 export default defineNuxtPlugin(() => {
-  // Modo no-saas → no inyectar header de tenant
-  if (!useInnertiaMode().hasTenant()) return
+  const { isOpen, hasTenant } = useInnertiaMode()
+
+  // Modo sin tenant (app) → no inyectar header de tenant
+  if (!hasTenant()) return
 
   const { add } = useRequestInterceptors()
-  const tenantStore = useTenantStore()
 
   add((headers: Record<string, string>) => {
-    // Solo enviar si el tenant fue validado (tiene id) y tiene slug
+    // open: tenant por gym seleccionado
+    if (isOpen()) {
+      const gymStore = useGymStore()
+      if (gymStore.activeKey) headers['X-Tenant'] = gymStore.activeKey
+      return
+    }
+
+    // saas: tenant por subdominio — solo si fue validado (tiene id) y tiene slug
+    const tenantStore = useTenantStore()
     if (tenantStore.tenantId && tenantStore.tenantSlug) {
       headers['X-Tenant'] = tenantStore.tenantSlug
     }

package/stores/gym.js

@@ -0,0 +1,29 @@
+import { defineStore } from 'pinia'
+
+/**
+ * Gym activo en modo 'open'.
+ * A diferencia de saas (tenant por subdominio), open resuelve el tenant por
+ * selección in-app: el usuario elige entre sus gyms y esa key viaja como X-Tenant.
+ * gyms: [{ key, name, status, contexts }]
+ */
+export const useGymStore = defineStore('gym', {
+  state: () => ({ activeKey: null, activeContext: null, gyms: [] }),
+
+  getters: {
+    active: (s) => s.gyms.find((g) => g.key === s.activeKey) || null,
+    hasMultiple: (s) => s.gyms.length > 1,
+  },
+
+  actions: {
+    setGyms(gyms) { this.gyms = gyms || [] },
+    setActive(key) { this.activeKey = key },
+    // Contexto elegido (backoffice/student/…) — un gym puede otorgar varios.
+    setActiveContext(context) { this.activeContext = context },
+    reset() { this.activeKey = null; this.activeContext = null; this.gyms = [] },
+  },
+
+  persist: {
+    // Key + contexto activos sobreviven el refresh; la lista se recarga del backend.
+    pick: ['activeKey', 'activeContext'],
+  },
+})