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.

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:

Prüfe, ob base44/config.jsonc im aktuellen Verzeichnis existiert
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
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

// 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();

// 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. 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
`auth`	Login, Registrierung, Nutzerverwaltung	auth.md
`agents`	KI-Konversationen und -Nachrichten	base44-agents.md
`functions`	Backend-Funktionsaufruf	functions.md
`integrations`	KI, E-Mail, Dateiuploads, benutzerdefinierte APIs	integrations.md
`analytics`	Benutzerdefinierte Ereignisse und Nutzeraktivität verfolgen	analytics.md
`appLogs`	Nutzeraktivität in der App loggen	app-logs.md
`users`	Nutzer zur App einladen	users.md
`asServiceRole.connectors`	App-bezogene OAuth-Tokens (nur Service-Rolle)	connectors.md
`asServiceRole.sso`	SSO-Token-Generierung (nur Service-Rolle)	sso.md

Für Client-Setup und Authentifizierungsmodi siehe 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, functions.md und base44-agents.md.

Installation

Installiere das Base44-SDK:

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:

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:

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

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)

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

Backend-Funktionsaufruf

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

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

Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die englische Version.

​Base44 Coder

​⚡ SOFORTIGE HANDLUNG ERFORDERLICH — Lies das zuerst

​Wann diesen Skill vs base44-cli verwenden

​Schnellstart

​⚠️ KRITISCH: APIs nicht halluzinieren

​Authentifizierung — FALSCH vs RICHTIG

​Funktionen — FALSCH vs RICHTIG

​Integrationen — FALSCH vs RICHTIG

​Entitäten — FALSCH vs RICHTIG

​SDK-Module

​TypeScript und Type-Registries

​Installation

​Client erstellen (externe Apps)

​Modulauswahl

​Häufige Muster

​Daten filtern und sortieren

​Geschützte Routen (Auth prüfen)

​Backend-Funktionsaufruf

​Service-Rollen-Zugriff

​Frontend vs Backend

Base44 Coder

⚡ SOFORTIGE HANDLUNG ERFORDERLICH — Lies das zuerst

Wann diesen Skill vs base44-cli verwenden

Schnellstart

⚠️ KRITISCH: APIs nicht halluzinieren

Authentifizierung — FALSCH vs RICHTIG

Funktionen — FALSCH vs RICHTIG

Integrationen — FALSCH vs RICHTIG

Entitäten — FALSCH vs RICHTIG

SDK-Module

TypeScript und Type-Registries

Installation

Client erstellen (externe Apps)

Modulauswahl

Häufige Muster

Daten filtern und sortieren

Geschützte Routen (Auth prüfen)

Backend-Funktionsaufruf

Service-Rollen-Zugriff

Frontend vs Backend