@lastbrain/module-auth 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,504 @@
+# Module Auth (@lastbrain/module-auth)
+
+Module d'authentification complet pour LastBrain avec Supabase. Ce module fournit des pages web, des API routes et une gestion complète de l'authentification utilisateur, du profil et de l'administration.
+
+## Table des matières
+
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Pages Web Fournies](#pages-web-fournies)
+- [Routes API](#routes-api)
+- [Schéma de Base de Données](#schéma-de-base-de-données)
+- [Intégration dans une Application](#intégration-dans-une-application)
+- [Sécurité](#sécurité)
+
+## Installation
+
+```bash
+npm install @lastbrain/module-auth
+# or
+pnpm add @lastbrain/module-auth
+```
+
+## Configuration
+
+### Prérequis
+
+1. **Supabase configuré** : Vous devez avoir un projet Supabase avec les variables d'environnement suivantes :
+   ```env
+   NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
+   NEXT_PUBLIC_SUPABASE_ANON_KEY=your-anon-key
+   ```
+
+2. **Migrations appliquées** : Appliquez la migration fournie dans `supabase/migrations/20251112000000_user_init.sql` pour créer les tables nécessaires.
+
+3. **Fonction RPC is_superadmin** : Assurez-vous que la fonction `is_superadmin` est disponible (généralement fournie par la migration de base de l'app).
+
+### Configuration de la fonction is_superadmin
+
+La fonction `is_superadmin` vérifie si un utilisateur a le rôle d'administrateur. Elle est définie dans la migration de base et examine les métadonnées utilisateur :
+
+```sql
+CREATE OR REPLACE FUNCTION public.is_superadmin(user_id uuid)
+RETURNS boolean
+LANGUAGE sql
+STABLE
+SECURITY DEFINER
+SET search_path = public, auth
+AS $function$
+  SELECT COALESCE((
+    SELECT
+      COALESCE((raw_app_meta_data ->> 'is_super_admin')::boolean, FALSE)
+      OR COALESCE((raw_user_meta_data ->> 'is_super_admin')::boolean, FALSE)
+      OR COALESCE((raw_app_meta_data -> 'roles') ? 'admin', FALSE)
+      OR COALESCE((raw_user_meta_data -> 'roles') ? 'admin', FALSE)
+    FROM auth.users
+    WHERE id = user_id
+  ), FALSE);
+$function$;
+```
+
+## Pages Web Fournies
+
+Le module fournit plusieurs composants React prêts à l'emploi utilisant HeroUI :
+
+### Pages Utilisateur Authentifié
+
+#### 1. Dashboard (`/auth/dashboard`)
+**Component**: `DashboardPage`
+
+Tableau de bord utilisateur affichant :
+- Résumé du profil avec avatar
+- Email et date de création du compte
+- Statut du compte
+- Statistiques rapides (projets, tâches, etc.)
+
+**Usage** :
+```tsx
+import { DashboardPage } from "@lastbrain/module-auth";
+
+export default function Dashboard() {
+  return <DashboardPage />;
+}
+```
+
+#### 2. Profil (`/auth/profile`)
+**Component**: `ProfilePage`
+
+Page de modification du profil utilisateur permettant de mettre à jour :
+- Informations personnelles (nom, prénom, téléphone, bio)
+- Informations professionnelles (entreprise, site web, localisation)
+- Préférences (langue, timezone, avatar)
+
+**Usage** :
+```tsx
+import { ProfilePage } from "@lastbrain/module-auth";
+
+export default function Profile() {
+  return <ProfilePage />;
+}
+```
+
+#### 3. Paramètres (`/auth/settings`)
+**Component**: `ReglagePage`
+
+Page de configuration du compte avec :
+- Notifications (email, push, marketing)
+- Apparence (thème)
+- Langue et région (langue, timezone)
+
+**Usage** :
+```tsx
+import { ReglagePage } from "@lastbrain/module-auth";
+
+export default function Settings() {
+  return <ReglagePage />;
+}
+```
+
+### Pages Publiques
+
+#### 4. Connexion (`/signin`)
+**Component**: `SignInPage`
+
+Page de connexion avec gestion des erreurs et redirection.
+
+**Usage** :
+```tsx
+import { SignInPage } from "@lastbrain/module-auth";
+
+export default function SignIn() {
+  return <SignInPage />;
+}
+```
+
+#### 5. Inscription (`/signup`)
+**Component**: `SignUpPage`
+
+Page d'inscription avec validation des champs.
+
+**Usage** :
+```tsx
+import { SignUpPage } from "@lastbrain/module-auth";
+
+export default function SignUp() {
+  return <SignUpPage />;
+}
+```
+
+### Pages Administration
+
+#### 6. Gestion des Utilisateurs (`/admin/users`)
+**Component**: `AdminUsersPage`
+
+Page d'administration pour lister et gérer tous les utilisateurs.
+**Accès réservé aux super admins uniquement.**
+
+Fonctionnalités :
+- Liste de tous les utilisateurs
+- Recherche par email ou nom
+- Pagination
+- Affichage des informations (email, rôle, date de création)
+
+**Usage** :
+```tsx
+import { AdminUsersPage } from "@lastbrain/module-auth";
+
+export default function AdminUsers() {
+  return <AdminUsersPage />;
+}
+```
+
+## Routes API
+
+Le module expose plusieurs routes API pour la gestion des utilisateurs et profils.
+
+### API Authentification (`/api/auth/*`)
+
+#### GET `/api/auth/me`
+Récupère les informations de l'utilisateur connecté et son profil.
+
+**Réponse** :
+```json
+{
+  "data": {
+    "id": "uuid",
+    "email": "user@example.com",
+    "created_at": "2024-01-01T00:00:00Z",
+    "profile": {
+      "first_name": "John",
+      "last_name": "Doe",
+      "avatar_url": "https://...",
+      "bio": "...",
+      "phone": "...",
+      "company": "...",
+      "website": "...",
+      "location": "...",
+      "language": "en",
+      "timezone": "UTC",
+      "preferences": {}
+    }
+  }
+}
+```
+
+**Erreurs** :
+- `401` : Utilisateur non authentifié
+
+#### GET `/api/auth/profile`
+Récupère le profil de l'utilisateur connecté.
+
+**Réponse** :
+```json
+{
+  "data": {
+    "id": "uuid",
+    "owner_id": "uuid",
+    "first_name": "John",
+    "last_name": "Doe",
+    ...
+  }
+}
+```
+
+#### PUT/PATCH `/api/auth/profile`
+Met à jour le profil de l'utilisateur. Crée le profil s'il n'existe pas.
+
+**Body** :
+```json
+{
+  "first_name": "John",
+  "last_name": "Doe",
+  "avatar_url": "https://...",
+  "bio": "...",
+  "phone": "...",
+  "company": "...",
+  "website": "...",
+  "location": "...",
+  "language": "fr",
+  "timezone": "Europe/Paris",
+  "preferences": {
+    "email_notifications": true,
+    "theme": "dark"
+  }
+}
+```
+
+**Réponse** :
+```json
+{
+  "data": {
+    "id": "uuid",
+    "owner_id": "uuid",
+    "first_name": "John",
+    ...
+  }
+}
+```
+
+### API Administration (`/api/admin/*`)
+
+⚠️ **Toutes les routes admin nécessitent un accès super admin.**
+
+#### GET `/api/admin/users`
+Liste tous les utilisateurs (paginé).
+
+**Query Parameters** :
+- `page` (optionnel, défaut: 1) : Numéro de page
+- `per_page` (optionnel, défaut: 20) : Nombre d'éléments par page
+- `search` (optionnel) : Recherche par email ou nom
+
+**Réponse** :
+```json
+{
+  "data": [
+    {
+      "id": "uuid",
+      "email": "user@example.com",
+      "created_at": "2024-01-01T00:00:00Z",
+      "profile": {
+        "first_name": "John",
+        "last_name": "Doe",
+        ...
+      }
+    }
+  ],
+  "pagination": {
+    "page": 1,
+    "per_page": 20,
+    "total": 100,
+    "total_pages": 5
+  }
+}
+```
+
+**Erreurs** :
+- `401` : Utilisateur non authentifié
+- `403` : Accès refusé (non super admin)
+
+### Utilisation dans une API Route Next.js
+
+```typescript
+// app/api/auth/me/route.ts
+export { GET } from "@lastbrain/module-auth/api/auth/me";
+
+// app/api/auth/profile/route.ts
+export { GET, PUT, PATCH } from "@lastbrain/module-auth/api/auth/profile";
+
+// app/api/admin/users/route.ts
+export { GET } from "@lastbrain/module-auth/api/admin/users";
+```
+
+## Schéma de Base de Données
+
+Le module utilise les tables suivantes (créées par la migration `20251112000000_user_init.sql`) :
+
+### Table `user_profil`
+
+Stocke les informations de profil utilisateur.
+
+```sql
+CREATE TABLE public.user_profil (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  owner_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  first_name TEXT,
+  last_name TEXT,
+  avatar_url TEXT,
+  bio TEXT,
+  phone TEXT,
+  company TEXT,
+  website TEXT,
+  location TEXT,
+  language TEXT DEFAULT 'en',
+  timezone TEXT,
+  preferences JSONB DEFAULT '{}'::jsonb,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+**Index** :
+- `idx_user_profil_owner_id` sur `owner_id`
+
+**RLS (Row Level Security)** :
+- Les utilisateurs peuvent lire, créer, modifier et supprimer leur propre profil
+- Les super admins ont accès à tous les profils
+
+### Table `user_address`
+
+Stocke les adresses des utilisateurs.
+
+```sql
+CREATE TABLE public.user_address (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  owner_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  street TEXT NOT NULL,
+  street2 TEXT,
+  city TEXT NOT NULL,
+  state TEXT,
+  postal_code TEXT,
+  country TEXT NOT NULL,
+  is_default BOOLEAN DEFAULT false,
+  address_type TEXT DEFAULT 'billing',
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### Table `user_notifications`
+
+Stocke les notifications des utilisateurs.
+
+```sql
+CREATE TABLE public.user_notifications (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  owner_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  title TEXT NOT NULL,
+  body TEXT,
+  type TEXT NOT NULL DEFAULT 'primary',
+  read BOOLEAN NOT NULL DEFAULT false,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+## Intégration dans une Application
+
+### 1. Installer les dépendances
+
+```bash
+pnpm add @lastbrain/module-auth @lastbrain/core @lastbrain/ui
+```
+
+### 2. Appliquer les migrations Supabase
+
+Copiez les migrations du module dans votre projet Supabase et appliquez-les :
+
+```bash
+cp node_modules/@lastbrain/module-auth/supabase/migrations/* supabase/migrations/
+supabase db push
+```
+
+### 3. Créer les pages Next.js
+
+Créez les pages dans votre application Next.js :
+
+```typescript
+// app/auth/dashboard/page.tsx
+import { DashboardPage } from "@lastbrain/module-auth";
+export default DashboardPage;
+
+// app/auth/profile/page.tsx
+import { ProfilePage } from "@lastbrain/module-auth";
+export default ProfilePage;
+
+// app/auth/settings/page.tsx
+import { ReglagePage } from "@lastbrain/module-auth";
+export default ReglagePage;
+
+// app/admin/users/page.tsx
+import { AdminUsersPage } from "@lastbrain/module-auth";
+export default AdminUsersPage;
+```
+
+### 4. Créer les routes API
+
+```typescript
+// app/api/auth/me/route.ts
+export { GET } from "@lastbrain/module-auth/api/auth/me";
+
+// app/api/auth/profile/route.ts
+export { GET, PUT, PATCH } from "@lastbrain/module-auth/api/auth/profile";
+
+// app/api/admin/users/route.ts
+export { GET } from "@lastbrain/module-auth/api/admin/users";
+```
+
+### 5. Configurer les variables d'environnement
+
+```env
+NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
+NEXT_PUBLIC_SUPABASE_ANON_KEY=your-anon-key
+```
+
+## Sécurité
+
+### Row Level Security (RLS)
+
+Toutes les tables sont protégées par RLS :
+- Les utilisateurs ne peuvent accéder qu'à leurs propres données
+- Les super admins ont accès à toutes les données
+
+### Vérification Super Admin
+
+Les routes admin vérifient l'accès super admin via la RPC Supabase :
+
+```typescript
+const { data: isSuperAdmin } = await supabase.rpc("is_superadmin", {
+  user_id: user.id,
+});
+
+if (!isSuperAdmin) {
+  return NextResponse.json(
+    { error: "Forbidden" },
+    { status: 403 }
+  );
+}
+```
+
+### Authentification
+
+Les routes API vérifient l'authentification :
+
+```typescript
+const { data: { user }, error } = await supabase.auth.getUser();
+
+if (error || !user) {
+  return NextResponse.json(
+    { error: "Unauthorized" },
+    { status: 401 }
+  );
+}
+```
+
+## Développement
+
+### Build
+
+```bash
+pnpm build
+```
+
+### Watch mode
+
+```bash
+pnpm dev
+```
+
+## Support
+
+Pour des questions ou des problèmes, ouvrez une issue sur [GitHub](https://github.com/lastpublication/starter).
+
+## Licence
+
+MIT

package/dist/api/admin/users.d.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * GET /api/admin/users
+ * Returns all users (superadmin only)
+ * Supports pagination via query params: page, per_page
+ * Supports search via query param: search (email)
+ */
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    error: string;
+    message: string;
+}> | NextResponse<{
+    data: {
+        id: any;
+        email: string;
+        created_at: any;
+        profile: {
+            first_name: any;
+            last_name: any;
+            avatar_url: any;
+            bio: any;
+            phone: any;
+            company: any;
+            website: any;
+            location: any;
+            language: any;
+            timezone: any;
+        };
+    }[];
+    pagination: {
+        page: number;
+        per_page: number;
+        total: number;
+        total_pages: number;
+    };
+}>>;
+//# sourceMappingURL=users.d.ts.map

package/dist/api/admin/users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../../src/api/admin/users.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGxD;;;;;GAKG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkH7C"}

package/dist/api/admin/users.js

@@ -0,0 +1,90 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+/**
+ * GET /api/admin/users
+ * Returns all users (superadmin only)
+ * Supports pagination via query params: page, per_page
+ * Supports search via query param: search (email)
+ */
+export async function GET(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Check authentication
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Unauthorized", message: "User not authenticated" }, { status: 401 });
+        }
+        // Check if user is superadmin
+        const { data: isSuperAdmin } = await supabase.rpc("is_superadmin", {
+            user_id: user.id,
+        });
+        if (!isSuperAdmin) {
+            return NextResponse.json({ error: "Forbidden", message: "Superadmin access required" }, { status: 403 });
+        }
+        // Get query parameters
+        const searchParams = request.nextUrl.searchParams;
+        const page = parseInt(searchParams.get("page") || "1");
+        const perPage = parseInt(searchParams.get("per_page") || "20");
+        const search = searchParams.get("search") || "";
+        // Note: We can only get public user data from auth.users via RPC or service role
+        // For now, we'll query user_profil which has owner_id references
+        let query = supabase
+            .from("user_profil")
+            .select("*, owner_id", { count: "exact" })
+            .order("created_at", { ascending: false });
+        // Add search filter if provided - using Supabase's built-in parameterized query
+        if (search) {
+            // Using .ilike with % wildcards - Supabase handles escaping
+            query = query.or(`first_name.ilike.%${search}%,last_name.ilike.%${search}%`);
+        }
+        // Apply pagination
+        const start = (page - 1) * perPage;
+        query = query.range(start, start + perPage - 1);
+        const { data: profiles, error: profileError, count } = await query;
+        if (profileError) {
+            console.error("Error fetching users:", profileError);
+            return NextResponse.json({ error: "Database Error", message: profileError.message }, { status: 500 });
+        }
+        // Get auth users data in batch - more efficient than individual calls
+        // Note: auth.admin methods require service role, so results may be limited
+        // In production, consider creating a database view or RPC function to join
+        // user_profil with auth.users for better performance
+        const users = await Promise.all((profiles || []).map(async (profile) => {
+            // Get basic auth info - this is limited to what's available
+            const { data: authData } = await supabase.auth.admin.getUserById(profile.owner_id);
+            return {
+                id: profile.owner_id,
+                email: authData?.user?.email || "N/A",
+                created_at: authData?.user?.created_at || profile.created_at,
+                profile: {
+                    first_name: profile.first_name,
+                    last_name: profile.last_name,
+                    avatar_url: profile.avatar_url,
+                    bio: profile.bio,
+                    phone: profile.phone,
+                    company: profile.company,
+                    website: profile.website,
+                    location: profile.location,
+                    language: profile.language,
+                    timezone: profile.timezone,
+                },
+            };
+        }));
+        return NextResponse.json({
+            data: users,
+            pagination: {
+                page,
+                per_page: perPage,
+                total: count || 0,
+                total_pages: Math.ceil((count || 0) / perPage),
+            },
+        });
+    }
+    catch (error) {
+        console.error("Error in admin users endpoint:", error);
+        return NextResponse.json({
+            error: "Internal Server Error",
+            message: "Failed to fetch users",
+        }, { status: 500 });
+    }
+}

package/dist/api/auth/me.d.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from "next/server";
+/**
+ * GET /api/auth/me
+ * Returns the current authenticated user and their profile
+ */
+export declare function GET(): Promise<NextResponse<{
+    error: string;
+    message: string;
+}> | NextResponse<{
+    data: {
+        id: string;
+        email: string | undefined;
+        created_at: string;
+        profile: any;
+    };
+}>>;
+//# sourceMappingURL=me.d.ts.map

package/dist/api/auth/me.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"me.d.ts","sourceRoot":"","sources":["../../../src/api/auth/me.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C;;;GAGG;AACH,wBAAsB,GAAG;;;;;;;;;;IAwCxB"}

package/dist/api/auth/me.js

@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+/**
+ * GET /api/auth/me
+ * Returns the current authenticated user and their profile
+ */
+export async function GET() {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Get the authenticated user
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Unauthorized", message: "User not authenticated" }, { status: 401 });
+        }
+        // Get user profile
+        const { data: profile, error: profileError } = await supabase
+            .from("user_profil")
+            .select("*")
+            .eq("owner_id", user.id)
+            .single();
+        // Profile might not exist yet, that's OK
+        const userData = {
+            id: user.id,
+            email: user.email,
+            created_at: user.created_at,
+            profile: profile || null,
+        };
+        return NextResponse.json({ data: userData });
+    }
+    catch (error) {
+        console.error("Error fetching user:", error);
+        return NextResponse.json({ error: "Internal Server Error", message: "Failed to fetch user data" }, { status: 500 });
+    }
+}