> ## 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.

# Créer des fonctions

> Les fonctions Base44 sont des fonctions backend serverless qui s'exécutent sur Deno. Elles sont définies localement dans votre projet et déployées vers le backend 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>

# Créer des fonctions

Les fonctions Base44 sont des fonctions backend serverless qui s'exécutent sur Deno. Elles sont définies localement dans votre projet et déployées vers le backend Base44.

## Répertoire des fonctions

Toutes les définitions de fonctions doivent être placées dans le dossier `base44/functions/` de votre projet. La fonction la plus simple est un dossier avec un fichier `entry.ts` ou `entry.js` à l'intérieur.

Structure d'exemple :

```
my-app/
  base44/
    functions/
      process-order/
        entry.ts
      send-notification/
        entry.ts
```

## Comment créer une fonction

1. Créez un nouveau répertoire dans `base44/functions/` avec le nom de votre fonction (utilisez kebab-case)
2. Créez `entry.ts` (ou `entry.js`) dans ce répertoire
3. Déployez la fonction avec le CLI

## Découverte des fonctions

Le CLI découvre les fonctions à partir des fichiers `entry.ts` ou `entry.js`. Un dossier contenant l'un de ces fichiers est une fonction :

```
base44/
  functions/
    process-order/
      entry.ts
```

Le nom de la fonction est le chemin depuis la racine des fonctions jusqu'à ce dossier. Par exemple :

| Fichier                                    | Nom de la fonction |
| ------------------------------------------ | ------------------ |
| `base44/functions/process-order/entry.ts`  | `process-order`    |
| `base44/functions/orders/process/entry.ts` | `orders/process`   |

Règles :

* `entry.ts` ou `entry.js` doit se trouver dans un sous-dossier nommé, pas directement dans `base44/functions/`
* tous les fichiers `*.js`, `*.ts` et `*.json` sous le dossier de la fonction sont inclus lors du déploiement
* les chemins de fonctions comportant un point dans un segment sont ignorés

## Fichier d'entrée

Les fonctions s'exécutent sur Deno et doivent exporter via `Deno.serve()`. Utilisez le préfixe `npm:` pour les paquets npm.

```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  // Get authenticated client from request
  const base44 = createClientFromRequest(req);
  
  // Parse input
  const { orderId, action } = await req.json();
  
  // Your logic here
  const order = await base44.entities.Orders.get(orderId);
  
  // Return response
  return Response.json({
    success: true,
    order: order
  });
});
```

### Objet Request

La fonction reçoit un objet Deno `Request` standard :

* `req.json()` - Parser le corps JSON
* `req.text()` - Obtenir le corps texte brut
* `req.headers` - Accéder aux en-têtes de la requête
* `req.method` - Méthode HTTP

### Objet Response

Retournez avec `Response.json()` pour des réponses JSON :

```typescript theme={null}
// Success response
return Response.json({ data: result });

// Error response with status code
return Response.json({ error: "Something went wrong" }, { status: 400 });

// Not found
return Response.json({ error: "Order not found" }, { status: 404 });
```

## Exemple complet

### Structure du répertoire

```
base44/
  functions/
    process-order/
      entry.ts
```

### entry.ts

```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  try {
    const base44 = createClientFromRequest(req);
    const { orderId } = await req.json();
    
    // Validate input
    if (!orderId) {
      return Response.json(
        { error: "Order ID is required" },
        { status: 400 }
      );
    }
    
    // Fetch and process the order
    const order = await base44.entities.Orders.get(orderId);
    if (!order) {
      return Response.json(
        { error: "Order not found" },
        { status: 404 }
      );
    }
    
    return Response.json({
      success: true,
      orderId: order.id,
      processedAt: new Date().toISOString()
    });
    
  } catch (error) {
    return Response.json(
      { error: error.message },
      { status: 500 }
    );
  }
});
```

## Utiliser l'accès service role

Pour les opérations administrateur, utilisez `asServiceRole` :

```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  
  // Check user is authenticated
  const user = await base44.auth.me();
  if (!user) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }
  
  // Use service role for admin operations
  const allOrders = await base44.asServiceRole.entities.Orders.list();
  
  return Response.json({ orders: allOrders });
});
```

## Utiliser des secrets

Accédez aux variables d'environnement configurées dans le tableau de bord de l'application :

```typescript theme={null}
Deno.serve(async (req) => {
  // Access environment variables (configured in app settings)
  const apiKey = Deno.env.get("STRIPE_API_KEY");
  
  const response = await fetch("https://api.stripe.com/v1/charges", {
    headers: {
      "Authorization": `Bearer ${apiKey}`
    }
  });
  
  return Response.json(await response.json());
});
```

## Conventions de nommage

* **Nom du répertoire** : utilisez le kebab-case (par exemple, `process-order`, `send-notification`)
* **Nom de la fonction** : provient du chemin du répertoire sous `base44/functions/`
  * Valides : `process-order`, `orders/process`, `send_notification`, `myFunction`
  * Invalides : `process.order`, `send.notification.v2`
* **Fichier d'entrée** : utilisez `entry.ts` ou `entry.js`

## Déployer les fonctions

Après la création de votre fonction, déployez-la vers Base44 :

```bash theme={null}
npx base44 functions deploy
```

Pour plus de détails sur le déploiement, consultez [functions-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-deploy.md).

## Remarques

* Les fonctions s'exécutent sur le runtime Deno, pas Node.js
* Utilisez le préfixe `npm:` pour les paquets npm (par exemple, `npm:@base44/sdk`)
* Utilisez `createClientFromRequest(req)` pour obtenir un client qui hérite du contexte d'authentification de l'appelant
* Configurez les secrets via le tableau de bord de l'application pour les clés API
* Gérez les erreurs proprement et retournez les codes de statut HTTP appropriés

## Erreurs courantes

| Mauvais                                           | Correct                                 | Pourquoi                                                       |
| ------------------------------------------------- | --------------------------------------- | -------------------------------------------------------------- |
| `base44/functions/myFunction.js` (fichier unique) | `base44/functions/my-function/entry.ts` | Les fonctions doivent se trouver dans un sous-répertoire nommé |
| `base44/functions/entry.ts`                       | `base44/functions/my-function/entry.ts` | Le nom de la fonction provient du chemin du sous-répertoire    |
| `import { ... } from "@base44/sdk"`               | `import { ... } from "npm:@base44/sdk"` | Deno exige le préfixe `npm:` pour les paquets npm              |
| Répertoire `MyFunction` ou `myFunction`           | Répertoire `my-function`                | Utilisez le kebab-case pour les noms de répertoires            |

<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>