> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Base44 Coder

> Créez des applications sur la plateforme Base44 avec le SDK JavaScript Base44.

<Warning>
  Cette page fait partie d'une compétence d'agent de code IA et est écrite pour les agents, pas pour les humains. Pour la documentation Base44 lisible par un humain, consultez la [documentation développeur](/developers).
</Warning>

# Base44 Coder

Créez des applications sur la plateforme Base44 avec le SDK JavaScript Base44.

## ⚡ ACTION IMMÉDIATE REQUISE - À lire en premier

Cette compétence s'active à toute mention de « base44 » ou lorsqu'un dossier `base44/` existe. **Ne lisez PAS les fichiers de documentation et ne recherchez PAS sur le web avant d'agir.**

**Votre première action DOIT être :**

1. Vérifier si `base44/config.jsonc` existe dans le répertoire courant
2. Si **OUI** (scénario projet existant) :
   * Cette compétence (base44-sdk) traite la requête
   * Implémentez les fonctionnalités avec le SDK Base44
   * N'utilisez PAS base44-cli sauf si l'utilisateur demande explicitement des commandes CLI
3. Si **NON** (scénario nouveau projet) :
   * Transférez à la compétence base44-cli pour l'initialisation du projet
   * Cette compétence ne peut pas aider tant que le projet n'est pas initialisé

## Quand utiliser cette compétence par rapport à base44-cli

**Utilisez base44-sdk quand :**

* Construire des fonctionnalités dans un projet Base44 **EXISTANT**
* `base44/config.jsonc` existe déjà dans le projet
* Des imports du SDK Base44 sont présents (`@base44/sdk`)
* Écrire du code JavaScript/TypeScript utilisant les modules du SDK Base44
* Implémenter des fonctionnalités, composants ou features
* L'utilisateur mentionne : « implémenter », « construire une fonctionnalité », « ajouter une fonctionnalité », « écrire du code pour »
* L'utilisateur dit « créer une application de \[type] » **et** un projet Base44 existe déjà

**N'UTILISEZ PAS base44-sdk pour :**

* ❌ Initialiser de nouveaux projets Base44 (utilisez `base44-cli` à la place)
* ❌ Répertoires vides sans configuration Base44
* ❌ Quand l'utilisateur dit « créer un nouveau projet/application/site Base44 » et qu'aucun projet n'existe
* ❌ Commandes CLI comme `npx base44 create`, `npx base44 deploy`, `npx base44 login` (utilisez `base44-cli`)

**Dépendances entre compétences :**

* `base44-sdk` suppose qu'un projet Base44 est **déjà initialisé**
* `base44-cli` est un **prérequis** de `base44-sdk` pour les nouveaux projets
* Si l'utilisateur veut « créer une application » et qu'aucun projet Base44 n'existe, utilisez d'abord `base44-cli`

**Logique de vérification d'état :**
Avant de sélectionner cette compétence, vérifiez :

* SI (l'utilisateur mentionne « créer/construire une application » OU « faire un projet ») :
  * SI (le répertoire est vide OU aucun `base44/config.jsonc` n'existe) :
    → Utilisez **base44-cli** (initialisation de projet nécessaire)
  * SINON :
    → Utilisez **base44-sdk** (le projet existe, construisez des fonctionnalités)

## Démarrage rapide

```javascript theme={null}
// In Base44-generated apps, base44 client is pre-configured and available

// CRUD operations
const task = await base44.entities.Task.create({ title: "New task", status: "pending" });
const tasks = await base44.entities.Task.list();
await base44.entities.Task.update(task.id, { status: "done" });

// Get current user
const user = await base44.auth.me();
```

```javascript theme={null}
// External apps
import { createClient } from "@base44/sdk";

// IMPORTANT: Use 'appId' (NOT 'clientId' or 'id')
const base44 = createClient({ appId: "your-app-id" });
await base44.auth.loginViaEmailPassword("user@example.com", "password");
```

## ⚠️ CRITIQUE : ne pas halluciner d'API

**Avant d'écrire N'IMPORTE QUEL code Base44, vérifiez les noms de méthode dans ce tableau ou dans [QUICK\_REFERENCE.md](https://docs.base44.com/developers/skills/base44-sdk/references/QUICK_REFERENCE.md).**

Le SDK Base44 a des noms de méthode uniques. Ne présumez PAS de motifs venant de Firebase, Supabase ou d'autres SDK.

### Authentification — MAUVAIS vs CORRECT

| ❌ MAUVAIS (halluciné)                   | ✅ CORRECT                                   |
| --------------------------------------- | ------------------------------------------- |
| `signInWithGoogle()`                    | `loginWithProvider('google')`               |
| `signInWithProvider('google')`          | `loginWithProvider('google')`               |
| `auth.google()`                         | `loginWithProvider('google')`               |
| `signInWithEmailAndPassword(email, pw)` | `loginViaEmailPassword(email, pw)`          |
| `signIn(email, pw)`                     | `loginViaEmailPassword(email, pw)`          |
| `createUser()` / `signUp()`             | `register({email, password})`               |
| `onAuthStateChanged()`                  | `me()` (pas de listener, appelez au besoin) |
| `currentUser`                           | `await auth.me()`                           |

### Functions — MAUVAIS vs CORRECT

| ❌ MAUVAIS (halluciné)          | ✅ CORRECT                        |
| ------------------------------ | -------------------------------- |
| `functions.call('name', data)` | `functions.invoke('name', data)` |
| `functions.run('name', data)`  | `functions.invoke('name', data)` |
| `callFunction('name', data)`   | `functions.invoke('name', data)` |
| `httpsCallable('name')(data)`  | `functions.invoke('name', data)` |

### Integrations — MAUVAIS vs CORRECT

| ❌ MAUVAIS (halluciné)          | ✅ CORRECT                                          |
| ------------------------------ | -------------------------------------------------- |
| `ai.generate(prompt)`          | `integrations.Core.InvokeLLM({prompt})`            |
| `openai.chat(prompt)`          | `integrations.Core.InvokeLLM({prompt})`            |
| `llm(prompt)`                  | `integrations.Core.InvokeLLM({prompt})`            |
| `sendEmail(to, subject, body)` | `integrations.Core.SendEmail({to, subject, body})` |
| `email.send()`                 | `integrations.Core.SendEmail({to, subject, body})` |
| `uploadFile(file)`             | `integrations.Core.UploadFile({file})`             |
| `storage.upload(file)`         | `integrations.Core.UploadFile({file})`             |

### Entities — MAUVAIS vs CORRECT

| ❌ MAUVAIS (halluciné)        | ✅ CORRECT                     |
| ---------------------------- | ----------------------------- |
| `entities.Task.find({...})`  | `entities.Task.filter({...})` |
| `entities.Task.findOne(id)`  | `entities.Task.get(id)`       |
| `entities.Task.insert(data)` | `entities.Task.create(data)`  |
| `entities.Task.remove(id)`   | `entities.Task.delete(id)`    |
| `entities.Task.onChange(cb)` | `entities.Task.subscribe(cb)` |

## Modules du SDK

| Module                     | Objet                                                               | Référence                                                                                            |
| -------------------------- | ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| `entities`                 | Opérations CRUD sur les modèles de données                          | [entities.md](https://docs.base44.com/developers/skills/base44-sdk/references/entities.md)           |
| `auth`                     | Connexion, inscription, gestion des utilisateurs                    | [auth.md](https://docs.base44.com/developers/skills/base44-sdk/references/auth.md)                   |
| `agents`                   | Conversations et messages IA                                        | [base44-agents.md](https://docs.base44.com/developers/skills/base44-sdk/references/base44-agents.md) |
| `functions`                | Invocation de fonctions backend                                     | [functions.md](https://docs.base44.com/developers/skills/base44-sdk/references/functions.md)         |
| `integrations`             | IA, e-mail, envois de fichiers, API personnalisées                  | [integrations.md](https://docs.base44.com/developers/skills/base44-sdk/references/integrations.md)   |
| `analytics`                | Suivre des événements personnalisés et l'activité utilisateur       | [analytics.md](https://docs.base44.com/developers/skills/base44-sdk/references/analytics.md)         |
| `appLogs`                  | Enregistrer l'activité utilisateur dans l'application               | [app-logs.md](https://docs.base44.com/developers/skills/base44-sdk/references/app-logs.md)           |
| `users`                    | Inviter des utilisateurs à l'application                            | [users.md](https://docs.base44.com/developers/skills/base44-sdk/references/users.md)                 |
| `asServiceRole.connectors` | Tokens OAuth à l'échelle de l'application (service role uniquement) | [connectors.md](https://docs.base44.com/developers/skills/base44-sdk/references/connectors.md)       |
| `asServiceRole.sso`        | Génération de tokens SSO (service role uniquement)                  | [sso.md](https://docs.base44.com/developers/skills/base44-sdk/references/sso.md)                     |

Pour la configuration du client et les modes d'authentification, consultez [client.md](https://docs.base44.com/developers/skills/base44-sdk/references/client.md).

### TypeScript et registres de types

Chaque fichier de référence inclut une section « Type Definitions » avec les interfaces et types TypeScript pour les méthodes, paramètres et valeurs de retour du module.

**Obtenir entités, fonctions et agents typés :** le CLI Base44 génère les types à partir des ressources du projet (entités, fonctions, agents), y compris les augmentations de `EntityTypeRegistry`, `FunctionNameRegistry` et `AgentNameRegistry`, et les intègre à votre projet pour vous fournir autocomplétion et vérification de types sans configuration manuelle. Pour la génération de types, utilisez la compétence **base44-cli**.

**Augmentation manuelle :** vous pouvez à la place augmenter les registres vous-même dans un fichier `.d.ts` ; consultez les sections Type Definitions dans [entities.md](https://docs.base44.com/developers/skills/base44-sdk/references/entities.md), [functions.md](https://docs.base44.com/developers/skills/base44-sdk/references/functions.md) et [base44-agents.md](https://docs.base44.com/developers/skills/base44-sdk/references/base44-agents.md).

## Installation

Installez le SDK Base44 :

```bash theme={null}
npm install @base44/sdk
```

**Important :** ne supposez ni ne codez en dur la version du paquet `@base44/sdk`. Installez toujours sans spécification de version pour obtenir la dernière.

## Créer un client (applications externes)

Lors de la création d'un client dans les applications externes, **utilisez TOUJOURS `appId` comme nom de paramètre** :

```javascript theme={null}
import { createClient } from "@base44/sdk";

// ✅ CORRECT
const base44 = createClient({ appId: "your-app-id" });

// ❌ WRONG - Do NOT use these:
// const base44 = createClient({ clientId: "your-app-id" });  // WRONG
// const base44 = createClient({ id: "your-app-id" });        // WRONG
```

**Paramètre requis :** `appId` (string) — l'ID de votre application Base44

**Paramètres facultatifs :**

* `token` (string) — token utilisateur préauthentifié
* `options` (object) — options de configuration
  * `options.onError` (function) — gestionnaire d'erreurs global

**Exemple avec gestionnaire d'erreurs :**

```javascript theme={null}
const base44 = createClient({
  appId: "your-app-id",
  options: {
    onError: (error) => {
      console.error("Base44 error:", error);
    }
  }
});
```

## Sélection de module

**Travailler avec les données de l'application ?**

* Créer/lire/mettre à jour/supprimer des enregistrements → `entities`
* Importer des données depuis un fichier → `entities.importEntities()`
* Mises à jour en temps réel → `entities.EntityName.subscribe()`

**Gestion des utilisateurs ?**

* Connexion/inscription/déconnexion → `auth`
* Obtenir l'utilisateur courant → `auth.me()`
* Mettre à jour le profil utilisateur → `auth.updateMe()`
* Inviter des utilisateurs → `users.inviteUser()`

**Fonctionnalités IA ?**

* Discuter avec des agents IA → `agents` (nécessite un utilisateur connecté)
* Créer une nouvelle conversation → `agents.createConversation()`
* Gérer les conversations → `agents.getConversations()`
* Générer du texte/JSON avec l'IA → `integrations.Core.InvokeLLM()`
* Générer des images → `integrations.Core.GenerateImage()`

**Logique backend personnalisée ?**

* Exécuter du code côté serveur → `functions.invoke()`
* Besoin d'accès administrateur → `base44.asServiceRole.functions.invoke()`

**Services externes ?**

* Envoyer des e-mails → `integrations.Core.SendEmail()`
* Envoyer des fichiers → `integrations.Core.UploadFile()`
* API personnalisées → `integrations.custom.call()`
* OAuth à l'échelle de l'application (compte du builder) → `asServiceRole.connectors.getConnection()` (backend uniquement)

**Suivi et analyses ?**

* Suivre des événements personnalisés → `analytics.track()`
* Enregistrer les vues de pages/l'activité → `appLogs.logUserInApp()`

## Motifs courants

### Filtrer et trier les données

```javascript theme={null}
const pendingTasks = await base44.entities.Task.filter(
  { status: "pending", assignedTo: userId },  // query
  "-created_date",                             // sort (descending)
  10,                                          // limit
  0                                            // skip
);
```

### Routes protégées (vérifier l'authentification)

```javascript theme={null}
const user = await base44.auth.me();
if (!user) {
  // Navigate to your custom login page
  navigate('/login', { state: { returnTo: window.location.pathname } });
  return;
}
```

### Appel de fonction backend

```javascript theme={null}
// Frontend
// ⚠️ invoke() returns the RAW axios response — your function's JSON is on `.data`,
//    NOT the top-level object. It also THROWS on non-2xx (error body at err.response.data).
const res = await base44.functions.invoke("processOrder", {
  orderId: "123",
  action: "ship"
});
const result = res.data; // ✅ e.g. res.data.success  (res itself is { data, status, headers, … })

// Backend function (Deno)
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  const { orderId, action } = await req.json();
  // Process with service role for admin access
  const order = await base44.asServiceRole.entities.Orders.get(orderId);
  return Response.json({ success: true });
});
```

### Accès Service Role

Utilisez `asServiceRole` dans les fonctions backend pour les opérations niveau administrateur :

```javascript theme={null}
// User mode - respects permissions
const myTasks = await base44.entities.Task.list();

// Service role - full access (backend only)
const allTasks = await base44.asServiceRole.entities.Task.list();
const token = await base44.asServiceRole.connectors.getAccessToken("slack");
```

## Frontend vs Backend

| Capacité                                         | Frontend | Backend |
| ------------------------------------------------ | -------- | ------- |
| `entities` (données de l'utilisateur)            | Oui      | Oui     |
| `auth`                                           | Oui      | Oui     |
| `agents`                                         | Oui      | Oui     |
| `functions.invoke()`                             | Oui      | Oui     |
| `functions.fetch()`                              | Oui      | Oui     |
| `integrations`                                   | Oui      | Oui     |
| `analytics`                                      | Oui      | Oui     |
| `appLogs`                                        | Oui      | Oui     |
| `users`                                          | Oui      | Oui     |
| `asServiceRole.*`                                | Non      | Oui     |
| `asServiceRole.connectors` (OAuth d'application) | Non      | Oui     |
| `asServiceRole.sso`                              | Non      | Oui     |

Les fonctions backend utilisent `Deno.serve()` et `createClientFromRequest(req)` pour obtenir un client authentifié correctement.

<Note>Cette page a été traduite à l'aide de l'IA. Pour les informations les plus précises et à jour, consultez la [version anglaise](/). </Note>