npm package: @lastbrain/core
Description: Utilitaires et types partagés pour LastBrain
Latest version: 2.0.31

# @lastbrain/core

Package de base pour toutes les applications LastBrain. Fournit les types, helpers Supabase et hooks essentiels.

## 🎯 Vue d'ensemble

`@lastbrain/core` est la fondation de l'écosystème LastBrain. Il contient :

- 🔧 **Clients Supabase** - Configuration pour browser et server
- 📝 **Types TypeScript** - Types partagés pour toute l'application
- 🔄 **Hooks realtime** - Système de synchronisation en temps réel
- 🛠️ **Helpers utilitaires** - Fonctions communes pour tous les modules

## 🚀 Démarrage rapide

> **Recommandé :** Utilisez le CLI LastBrain pour créer une application complète

```bash
# Créer une nouvelle application avec @lastbrain/core inclus
pnpx @lastbrain/app@latest init mon-app
cd mon-app
pnpm dev
```

## 📦 Installation manuelle

Si vous intégrez LastBrain dans un projet existant :

```bash
pnpm add @lastbrain/core @lastbrain/ui
```

## 🔧 Composants exportés

### Clients Supabase

```typescript
import {
  supabaseBrowserClient,
  getSupabaseServerClient,
  createMiddlewareClient,
} from "@lastbrain/core";

// Client côté browser (React components)
const { data } = await supabaseBrowserClient.from("users").select("*");

// Client côté server (API routes, Server Components)
const supabase = await getSupabaseServerClient();

// Client middleware (protection de routes)
const { supabase, response } = createMiddlewareClient(request);
```

### Hooks de base

```typescript
import {
  useAuth,
  useSupabaseClient,
  useRealtimeListener
} from "@lastbrain/core";

function MyComponent() {
  const { user, session } = useAuth();
  const supabase = useSupabaseClient();
  const { data, loading } = useRealtimeListener("users", {
    event: "*",
    schema: "public"
  });

  return <div>Hello {user?.email}</div>;
}
```

### Types TypeScript

```typescript
import type {
  Database,
  Tables,
  ModuleConfig,
  RealtimeConfig
} from "@lastbrain/core";

// Types de base de données auto-générés
type User = Tables<"users">;
type Profile = Tables<"user_profil">;

// Configuration des modules
const moduleConfig: ModuleConfig = {
  name: "auth",
  version: "1.0.0",
  pages: [...]
};
```

### Event Bus

```typescript
import { eventBus } from "@lastbrain/core";

// Émettre un événement
eventBus.emit("user:updated", { userId: "123", data: {...} });

// Écouter un événement
eventBus.on("user:updated", (payload) => {
  console.log("Utilisateur mis à jour:", payload);
});

// Se désabonner
eventBus.off("user:updated", handler);
```

## 🔄 Système Realtime

LastBrain inclut un système de synchronisation en temps réel basé sur Supabase Realtime :

```typescript
import { useRealtimeSignal, useNotificationRealtime } from "@lastbrain/core";

// Hook générique pour n'importe quelle table
const signal = useRealtimeSignal("users", {
  event: "*",
  schema: "public",
  filter: "id=eq.123",
});

// Hook spécialisé pour les notifications
const notificationSignal = useNotificationRealtime();

// Dans votre composant
useEffect(() => {
  if (signal.hasUpdates) {
    // Recharger les données
    refetchUsers();
  }
}, [signal.tick]);
```

## 🛠️ Configuration

### Variables d'environnement

```bash
# .env.local
NEXT_PUBLIC_SUPABASE_URL=your_supabase_url
NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key
SUPABASE_SERVICE_ROLE_KEY=your_service_role_key
```

### Configuration TypeScript

```json
// tsconfig.json
{
  "compilerOptions": {
    "types": ["@lastbrain/core/types"]
  }
}
```

## 🔐 Authentification

```typescript
import { supabaseBrowserClient } from "@lastbrain/core";

// Connexion
const { data, error } = await supabaseBrowserClient.auth.signInWithPassword({
  email: "user@example.com",
  password: "password",
});

// Déconnexion
await supabaseBrowserClient.auth.signOut();

// Récupérer l'utilisateur actuel
const {
  data: { user },
} = await supabaseBrowserClient.auth.getUser();
```

## 📊 Base de données

```typescript
import { supabaseBrowserClient } from "@lastbrain/core";
import type { Tables } from "@lastbrain/core";

type User = Tables<"users">;

// CRUD operations
const { data: users } = await supabaseBrowserClient
  .from("users")
  .select("*")
  .eq("active", true);

const { data: newUser } = await supabaseBrowserClient
  .from("users")
  .insert({ email: "new@example.com" })
  .select()
  .single();
```

## 🏗️ Architecture

```
@lastbrain/core/
├── src/
│   ├── supabase/          # Clients et configuration Supabase
│   ├── types/             # Types TypeScript
│   ├── hooks/             # Hooks React
│   ├── realtime/          # Système temps réel
│   ├── eventBus.ts        # Event bus global
│   └── index.ts           # Exports principaux
└── server.ts              # Exports server-only
```

## 🔗 Intégration avec les modules

`@lastbrain/core` est conçu pour être étendu par des modules :

```typescript
// Dans un module (ex: @lastbrain/module-auth)
import { supabaseBrowserClient, eventBus } from "@lastbrain/core";

export function useAuthActions() {
  const signIn = async (email: string, password: string) => {
    const result = await supabaseBrowserClient.auth.signInWithPassword({
      email,
      password,
    });

    if (result.data.user) {
      eventBus.emit("auth:signin", result.data.user);
    }

    return result;
  };

  return { signIn };
}
```

## 🤝 Contribuer

Ce package fait partie du monorepo LastBrain. Voir le [CONTRIBUTING.md](../../CONTRIBUTING.md) principal.

## 📄 Licence

MIT - Voir [LICENSE](../../LICENSE)