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

> Apps auf der Base44-Plattform mit dem Base44-JavaScript-SDK erstellen.

<Warning>
  Diese Seite ist Teil eines KI-Coding-Agent-Skills und für Agenten geschrieben, nicht für Menschen. Für die menschenlesbare Base44-Dokumentation siehe die [Entwicklerdokumentation](/developers).
</Warning>

# Base44 Coder

Apps auf der Base44-Plattform mit dem Base44-JavaScript-SDK erstellen.

## ⚡ SOFORTIGE HANDLUNG ERFORDERLICH — Lies das zuerst

Dieser Skill aktiviert sich bei jeder Erwähnung von "base44" oder wenn ein `base44/`-Ordner existiert. **Lies keine Dokumentationsdateien und suche nicht im Web, bevor du handelst.**

**Deine erste Aktion MUSS sein:**

1. Prüfe, ob `base44/config.jsonc` im aktuellen Verzeichnis existiert
2. Wenn **JA** (bestehendes Projektszenario):
   * Dieser Skill (base44-sdk) übernimmt die Anfrage
   * Implementiere Funktionen mit dem Base44-SDK
   * Verwende base44-cli NICHT, außer der Nutzer verlangt ausdrücklich CLI-Befehle
3. Wenn **NEIN** (neues Projektszenario):
   * Übergib an den base44-cli-Skill zur Projektinitialisierung
   * Dieser Skill kann nicht helfen, bis das Projekt initialisiert ist

## Wann diesen Skill vs base44-cli verwenden

**Verwende base44-sdk, wenn:**

* Du Funktionen in einem **BESTEHENDEN** Base44-Projekt baust
* `base44/config.jsonc` im Projekt bereits existiert
* Base44-SDK-Imports vorhanden sind (`@base44/sdk`)
* Du JavaScript/TypeScript-Code mit Base44-SDK-Modulen schreibst
* Du Funktionalität, Komponenten oder Features implementierst
* Der Nutzer erwähnt: "implementieren", "Feature bauen", "Funktionalität hinzufügen", "Code schreiben für"
* Der Nutzer sagt "create a \[type] app" **und** ein Base44-Projekt existiert bereits

**Verwende base44-sdk NICHT für:**

* ❌ Initialisierung neuer Base44-Projekte (nutze stattdessen `base44-cli`)
* ❌ Leere Verzeichnisse ohne Base44-Konfiguration
* ❌ Wenn der Nutzer sagt "create a new Base44 project/app/site" und kein Projekt existiert
* ❌ CLI-Befehle wie `npx base44 create`, `npx base44 deploy`, `npx base44 login` (nutze `base44-cli`)

**Skill-Abhängigkeiten:**

* `base44-sdk` setzt voraus, dass ein Base44-Projekt **bereits initialisiert** ist
* `base44-cli` ist eine **Voraussetzung** für `base44-sdk` in neuen Projekten
* Wenn der Nutzer "eine App erstellen" möchte und kein Base44-Projekt existiert, verwende zuerst `base44-cli`

**Statusprüfungs-Logik:**
Vor der Auswahl dieses Skills prüfe:

* WENN (Nutzer erwähnt "App erstellen/bauen" ODER "Projekt machen"):
  * WENN (Verzeichnis leer ODER keine `base44/config.jsonc` existiert):
    → Verwende **base44-cli** (Projektinitialisierung nötig)
  * SONST:
    → Verwende **base44-sdk** (Projekt existiert, Features bauen)

## Schnellstart

```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");
```

## ⚠️ KRITISCH: APIs nicht halluzinieren

**Bevor du IRGENDEINEN Base44-Code schreibst, prüfe Methodennamen gegen diese Tabelle oder [QUICK\_REFERENCE.md](https://docs.base44.com/developers/skills/base44-sdk/references/QUICK_REFERENCE.md).**

Das Base44-SDK hat einzigartige Methodennamen. Nimm KEINE Muster von Firebase, Supabase oder anderen SDKs an.

### Authentifizierung — FALSCH vs RICHTIG

| ❌ FALSCH (halluziniert)                 | ✅ RICHTIG                                   |
| --------------------------------------- | ------------------------------------------- |
| `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()` (kein Listener, bei Bedarf aufrufen) |
| `currentUser`                           | `await auth.me()`                           |

### Funktionen — FALSCH vs RICHTIG

| ❌ FALSCH (halluziniert)        | ✅ RICHTIG                        |
| ------------------------------ | -------------------------------- |
| `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)` |

### Integrationen — FALSCH vs RICHTIG

| ❌ FALSCH (halluziniert)        | ✅ RICHTIG                                          |
| ------------------------------ | -------------------------------------------------- |
| `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})`             |

### Entitäten — FALSCH vs RICHTIG

| ❌ FALSCH (halluziniert)      | ✅ RICHTIG                     |
| ---------------------------- | ----------------------------- |
| `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)` |

## SDK-Module

| Modul                      | Zweck                                                       | Referenz                                                                                             |
| -------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| `entities`                 | CRUD-Operationen auf Datenmodellen                          | [entities.md](https://docs.base44.com/developers/skills/base44-sdk/references/entities.md)           |
| `auth`                     | Login, Registrierung, Nutzerverwaltung                      | [auth.md](https://docs.base44.com/developers/skills/base44-sdk/references/auth.md)                   |
| `agents`                   | KI-Konversationen und -Nachrichten                          | [base44-agents.md](https://docs.base44.com/developers/skills/base44-sdk/references/base44-agents.md) |
| `functions`                | Backend-Funktionsaufruf                                     | [functions.md](https://docs.base44.com/developers/skills/base44-sdk/references/functions.md)         |
| `integrations`             | KI, E-Mail, Dateiuploads, benutzerdefinierte APIs           | [integrations.md](https://docs.base44.com/developers/skills/base44-sdk/references/integrations.md)   |
| `analytics`                | Benutzerdefinierte Ereignisse und Nutzeraktivität verfolgen | [analytics.md](https://docs.base44.com/developers/skills/base44-sdk/references/analytics.md)         |
| `appLogs`                  | Nutzeraktivität in der App loggen                           | [app-logs.md](https://docs.base44.com/developers/skills/base44-sdk/references/app-logs.md)           |
| `users`                    | Nutzer zur App einladen                                     | [users.md](https://docs.base44.com/developers/skills/base44-sdk/references/users.md)                 |
| `asServiceRole.connectors` | App-bezogene OAuth-Tokens (nur Service-Rolle)               | [connectors.md](https://docs.base44.com/developers/skills/base44-sdk/references/connectors.md)       |
| `asServiceRole.sso`        | SSO-Token-Generierung (nur Service-Rolle)                   | [sso.md](https://docs.base44.com/developers/skills/base44-sdk/references/sso.md)                     |

Für Client-Setup und Authentifizierungsmodi siehe [client.md](https://docs.base44.com/developers/skills/base44-sdk/references/client.md).

### TypeScript und Type-Registries

Jede Referenzdatei enthält einen Abschnitt "Type Definitions" mit TypeScript-Interfaces und -Typen für die Methoden, Parameter und Rückgabewerte des Moduls.

**Typisierte Entitäten, Funktionen und Agenten erhalten:** Die Base44-CLI generiert Typen aus deinen Projektressourcen (Entitäten, Funktionen, Agenten), inklusive Erweiterungen von `EntityTypeRegistry`, `FunctionNameRegistry` und `AgentNameRegistry`, und verdrahtet sie in dein Projekt, sodass du Autocomplete und Typprüfung ohne manuelles Setup bekommst. Wie du Typen generierst, siehe den Skill **base44-cli**.

**Manuelle Erweiterung:** Du kannst die Registries stattdessen selbst in einer `.d.ts`-Datei erweitern; siehe die "Type Definitions"-Abschnitte in [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) und [base44-agents.md](https://docs.base44.com/developers/skills/base44-sdk/references/base44-agents.md).

## Installation

Installiere das Base44-SDK:

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

**Wichtig:** Nimm nie eine Version des Pakets `@base44/sdk` an oder codiere sie fest. Installiere immer ohne Versionsspezifizierer, um die neueste Version zu erhalten.

## Client erstellen (externe Apps)

Beim Erstellen eines Clients in externen Apps **verwende IMMER `appId` als Parametername**:

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

**Erforderlicher Parameter:** `appId` (string) — Die ID deiner Base44-Anwendung

**Optionale Parameter:**

* `token` (string) — Vorauthentifizierter Nutzer-Token
* `options` (object) — Konfigurationsoptionen
  * `options.onError` (function) — Globaler Fehler-Handler

**Beispiel mit Fehler-Handler:**

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

## Modulauswahl

**Mit App-Daten arbeiten?**

* Datensätze erstellen/lesen/aktualisieren/löschen → `entities`
* Daten aus Datei importieren → `entities.importEntities()`
* Echtzeit-Updates → `entities.EntityName.subscribe()`

**Nutzerverwaltung?**

* Login/Registrierung/Logout → `auth`
* Aktuellen Nutzer holen → `auth.me()`
* Nutzerprofil aktualisieren → `auth.updateMe()`
* Nutzer einladen → `users.inviteUser()`

**KI-Funktionen?**

* Mit KI-Agenten chatten → `agents` (erfordert eingeloggten Nutzer)
* Neue Konversation erstellen → `agents.createConversation()`
* Konversationen verwalten → `agents.getConversations()`
* Text/JSON mit KI generieren → `integrations.Core.InvokeLLM()`
* Bilder generieren → `integrations.Core.GenerateImage()`

**Benutzerdefinierte Backend-Logik?**

* Serverseitigen Code ausführen → `functions.invoke()`
* Admin-Zugriff nötig → `base44.asServiceRole.functions.invoke()`

**Externe Dienste?**

* E-Mails senden → `integrations.Core.SendEmail()`
* Dateien hochladen → `integrations.Core.UploadFile()`
* Benutzerdefinierte APIs → `integrations.custom.call()`
* App-bezogenes OAuth (Konto des App-Builders) → `asServiceRole.connectors.getConnection()` (nur Backend)

**Tracking und Analytik?**

* Benutzerdefinierte Ereignisse verfolgen → `analytics.track()`
* Seitenaufrufe/Aktivität loggen → `appLogs.logUserInApp()`

## Häufige Muster

### Daten filtern und sortieren

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

### Geschützte Routen (Auth prüfen)

```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;
}
```

### Backend-Funktionsaufruf

```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 });
});
```

### Service-Rollen-Zugriff

Verwende `asServiceRole` in Backend-Funktionen für Admin-Operationen:

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

| Fähigkeit                              | Frontend | Backend |
| -------------------------------------- | -------- | ------- |
| `entities` (Nutzerdaten)               | Ja       | Ja      |
| `auth`                                 | Ja       | Ja      |
| `agents`                               | Ja       | Ja      |
| `functions.invoke()`                   | Ja       | Ja      |
| `functions.fetch()`                    | Ja       | Ja      |
| `integrations`                         | Ja       | Ja      |
| `analytics`                            | Ja       | Ja      |
| `appLogs`                              | Ja       | Ja      |
| `users`                                | Ja       | Ja      |
| `asServiceRole.*`                      | Nein     | Ja      |
| `asServiceRole.connectors` (App-OAuth) | Nein     | Ja      |
| `asServiceRole.sso`                    | Nein     | Ja      |

Backend-Funktionen verwenden `Deno.serve()` und `createClientFromRequest(req)`, um einen ordnungsgemäß authentifizierten Client zu erhalten.

<Note>Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die [englische Version](/). </Note>