Todo-App Backend-Vorlage
React Native — Schema, API & KI-Leitfaden
Ein produktionsbereites React Native Todo Backend-Schema und Starter-Kit auf Back4app: ER-Diagramm, Datenwörterbuch, JSON-Schema, API-Spielplatz, JavaScript/React Native Codebeispiele, offline-first Anheftung und ein One-Click KI-Agent Prompt zur Bereitstellung in Minuten.
Wichtige Erkenntnisse
Auf dieser Seite erhalten Sie ein produktionsbereites Schema, einen One-Click KI-Prompt und schrittweise React Native-Code — damit Sie eine Todo-App ohne Backend-Entwicklung bereitstellen können.
- In Minuten bereitstellen — Fügen Sie die AI-Agent-Eingabeaufforderung ein und erhalten Sie eine laufende App mit Frontend, Backend und Datenbank.
- Standardmäßig sicher — Row-Level-ACLs stellen sicher, dass jeder Benutzer nur seine eigenen Todos sieht.
- React Native-native SDK — Parse React Native SDK mit async/await, lokalem Pinnen und Live Queries sofort einsatzbereit.
- REST + GraphQL — beide APIs werden automatisch generiert; keine benutzerdefinierten Endpunkte zu schreiben.
- Zwei Klassen — _User (eingebaute Authentifizierung) und Todo (Aufgaben mit Titel, erledigt, Fälligkeitsdatum, Priorität, Eigentümer).
Was ist die React Native Todo App Backend-Vorlage?
Die React Native Todo App Backend-Vorlage ist ein vorgefertigtes, produktionsbereites Backend-Schema, das auf Back4app gehostet wird. Es bietet Ihnen zwei Datenbankklassen (_User und Todo), besitzbasierte ACLs, REST- und GraphQL-APIs sowie eine Ein-Klick-AI-Agent-Eingabeaufforderung — damit Sie eine React Native-App verbinden und in Minuten anstelle von Tagen eine funktionierende Todo-App mit Offline-Unterstützung bereitstellen können.
Am besten geeignet für:
Übersicht
Eine Todo-App ist einer der häufigsten Ausgangspunkte für das Erlernen der Backend-Entwicklung. Im Hintergrund benötigt sie Benutzerregistrierung, Aufgaben-CRUD, besitzbasierten Zugriffskontrolle und optional Echtzeitsynchronisierung sowie Offline-Unterstützung.
Das folgende Schema definiert zwei Klassen — _User (integriert) und Todo — die durch einen Pointer verbunden sind. Mit dem Parse React Native SDK (Back4app) können Sie direkt aus Ihrem JavaScript oder TypeScript-Code mit diesem Backend interagieren — Abfragen, Erstellen, Aktualisieren und Löschen von Objekten sowie das Anheften für Offline — ohne eine benutzerdefinierte API-Schicht zu schreiben.
Warum Ihr React Native Todo-Backend mit Back4app erstellen?
Back4app bietet Ihnen ein fertiges Backend und das Parse React Native SDK, sodass Sie sich auf UX und Leistung konzentrieren können, anstatt sich um REST-Verkabelung und Authentifizierung zu kümmern.
- •Offline-first & Synchronisierung: Pin Todo-Objekte im lokalen Datenspeicher, sodass die Liste offline funktioniert und synchronisiert, wenn die App wieder online ist — ideal für mobile Anwendungen.
- •Komponenten & Hooks: Verwenden Sie das SDK mit React-Hooks und -Kontext; halten Sie den Zustand mit Parse-Abfragen und Live Queries für Echtzeitaktualisierungen synchron.
- •Plattformübergreifend, ein Backend: Dasselbe Schema und dieselben APIs für iOS und Android; ideal für React Native-Teams, die Expo oder den Bare-Workflow verwenden.
Ideal für React Native-Entwickler, die Expo oder den Bare-Workflow verwenden — ein Backend, beide Plattformen.
Kernvorteile
Ein produktionsbereites Todo-Backend, damit Sie schneller liefern und sich auf Ihre App konzentrieren können.
Schneller liefern, kein Backend-Code
REST- und GraphQL-APIs sowie ein einsatzbereites Schema — verbinden Sie Ihre App und legen Sie los.
Standardmäßig sicher
ACLs und Berechtigungen auf Klassenebene, damit Benutzer nur auf ihre eigenen Daten zugreifen können.
Echtzeit-Updates
Live Queries über WebSockets für sofortige UI-Updates.
Integrierte Authentifizierung
Benutzerregistrierung, -anmeldung und Sitzungsverwaltung sofort einsatzbereit — keine benutzerdefinierte Authentifizierungsschicht.
Offline-Funktionalität
Lokales Pinnen hält Daten offline verfügbar und synchronisiert, wenn Sie sich wieder verbinden.
In Minuten bereitstellen
Verwenden Sie den KI-Agenten, um Ihre Todo-App aus dieser Vorlage zu erstellen und bereitzustellen.
Bereit, es auszuprobieren?
Lassen Sie den Back4app KI-Agenten Ihr Todo-App-Backend erstellen, das React Native-Frontend verbinden und bereitstellen – alles aus einem einzigen Prompt.
Kostenlos starten – 50 KI-Agenten-Prompts/Monat, keine Kreditkarte erforderlich
Technologiestack
Alles, was dieses Todo-App-Template auf einen Blick antreibt.
ER-Diagramm
Entitäts-Beziehungsdiagramm für das React Native Todo-App-Datenmodell.
Die _User-Klasse enthält objectId, username, email, password, createdAt und updatedAt. Die Todo-Klasse enthält objectId, title, done, dueDate, priority und einen Owner-Pointer zu _User, sowie createdAt und updatedAt. Jeder _User besitzt null oder viele Todo-Elemente.
Diagrammquelle anzeigen
erDiagram
_User {
String objectId PK
String username
String email
String password
Date createdAt
Date updatedAt
}
Todo {
String objectId PK
String title
Boolean done
Date dueDate
Number priority
Pointer owner FK
Date createdAt
Date updatedAt
}
_User ||--o{ Todo : "owns"
Integrationsfluss
Auth-to-CRUD-Sequenz: wie Ihre React Native-App mit Back4app kommuniziert – anmelden, dann Todos abfragen und erstellen.
Diagrammquelle anzeigen
sequenceDiagram
participant User
participant App as React Native App
participant Back4app as Back4app Cloud
User->>App: Login
App->>Back4app: Parse.User.logIn(username, password)
Back4app-->>App: Session token
App-->>User: Logged in
User->>App: Load todos
App->>Back4app: new Parse.Query('Todo').find()
Back4app-->>App: Array of Todo
App-->>User: Show list
User->>App: Create todo
App->>Back4app: todo.save()
Back4app-->>App: Todo (objectId)
App-->>User: Updated listDatenwörterbuch
Vollständige Feldreferenz für jede Klasse im Schema.
| Feld | Typ | Beschreibung | Erforderlich |
|---|---|---|---|
| objectId | String | Auto-generated unique identifier | auto |
| title | String | Short description of the task | |
| done | Boolean | Whether the task is completed | — |
| dueDate | Date | Optional deadline for the task | — |
| priority | Number | Priority level (1 = high, 3 = low) | — |
| owner | Pointer<_User> | User who owns this task | — |
| createdAt | Date | Auto-generated creation timestamp | auto |
| updatedAt | Date | Auto-generated last-update timestamp | auto |
8 Felder in Todo
Sicherheit & Berechtigungen
Wie Eigentum, ACLs und Klassenberechtigungen Daten in diesem Schema schützen.
Zeilenebene ACLs
Jede Todo erhält eine ACL, die mit ihrem Eigentümer verknüpft ist. Nur der Ersteller kann seine eigenen Aufgaben lesen, aktualisieren oder löschen.
Klassenebene Berechtigungen
CLPs beschränken, welche Rollen oder Benutzer Objekte auf Klassenebene erstellen, lesen, aktualisieren oder löschen können — Ihre erste Verteidigungslinie.
Pointer-basiertes Eigentum
Der Eigentümer-Pointer verknüpft jede Todo mit seinem _User. Cloud Code-Trigger können das Eigentum automatisch festlegen und ACLs beim Speichern durchsetzen.
Schema (JSON)
Rohe JSON-Schema-Definition — kopieren und in Ihrer Back4app-App verwenden oder über die API importieren.
{
"classes": [
{
"className": "Todo",
"fields": {
"objectId": {
"type": "String",
"required": false
},
"title": {
"type": "String",
"required": true
},
"done": {
"type": "Boolean",
"required": false,
"defaultValue": false
},
"dueDate": {
"type": "Date",
"required": false
},
"priority": {
"type": "Number",
"required": false,
"defaultValue": 3
},
"owner": {
"type": "Pointer",
"targetClass": "_User",
"required": false
},
"createdAt": {
"type": "Date",
"required": false
},
"updatedAt": {
"type": "Date",
"required": false
}
}
},
{
"className": "_User",
"fields": {
"objectId": {
"type": "String",
"required": false
},
"username": {
"type": "String",
"required": true
},
"email": {
"type": "String",
"required": true
},
"password": {
"type": "String",
"required": true
},
"createdAt": {
"type": "Date",
"required": false
},
"updatedAt": {
"type": "Date",
"required": false
}
}
}
]
}Mit AI-Agenten erstellen
Verwenden Sie den Back4app AI-Agenten, um eine echte Todo-App aus dieser Vorlage zu erstellen: Er wird das Frontend, das Backend (dieses Schema, Authentifizierung und APIs) erstellen und bereitstellen — keine manuelle Einrichtung. Die folgende Eingabeaufforderung beschreibt diesen Todo-Stack, damit der Agent eine produktionsbereite App auf einmal generieren kann.
Create a Todo app on Back4app with this exact schema and behavior. Schema: 1. _User (use Back4app built-in): username (String, required), email (String, required), password (String, required); objectId, createdAt, updatedAt (system). 2. Todo: title (String, required), done (Boolean, default: false), dueDate (Date, optional), priority (Number, default: 3; 1=high, 2=medium, 3=low), owner (Pointer to _User; set to current user on create); objectId, createdAt, updatedAt (system). Security: - Set ACLs on every Todo so only the owner has read and write. No public read/write. - On create, set Todo.owner to the current user (e.g. via Cloud Code beforeSave or client-side). - Use Class-Level Permissions so only authenticated users can create/read/update/delete Todo. Auth: - Sign-up (username, email, password) and login; support logout/session. - After login, the app should only show and allow CRUD for the current user's todos. Behavior: - Full CRUD for Todo: create, list (only owner's), get one, update (toggle done, edit title, dueDate, priority), delete. - List todos with sort (e.g. by priority then dueDate or createdAt). Default priority for new todos: 3 (low). Deliver: - Create the Back4app app with the schema above, ACLs, and any Cloud Code needed (e.g. beforeSave on Todo to set owner). - Generate the frontend and connect it to this backend; deploy so the app is runnable end-to-end.
Drücken Sie die Schaltfläche unten, um den Agenten mit der vorausgefüllten Eingabeaufforderung dieser Vorlage zu öffnen.
API-Spielplatz
Testen Sie die REST- und GraphQL-Endpunkte für das Todo-Schema. Antworten aus den obigen Beispieldaten — kein Back4app-Konto erforderlich.
Verwendet dasselbe Todo-Schema wie diese Vorlage.
Schritt-für-Schritt React Native Integration
Verbinden Sie sich mit Ihrem Back4app Backend von einer React Native App aus mit dem Parse React Native SDK.
Schritt 1: Installieren Sie das Parse React Native SDK
Fügen Sie das Parse React Native SDK (oder React-native-Parse) mit npm oder yarn zu Ihrem Projekt hinzu.
JavaScriptnpm install parse --save # or: yarn add parseSchritt 2: Initialisieren Sie Parse in Ihrer App
Initialisieren Sie das Parse SDK in Ihrem App-Einstieg (z.B. App.js oder index.js) mit Ihrer Anwendungs-ID, Server-URL und JavaScript Schlüssel.
JavaScriptimport Parse from 'parse/react-native'; Parse.setAsyncStorage(AsyncStorage); Parse.initialize('YOUR_APP_ID', 'YOUR_JS_KEY'); Parse.serverURL = 'https://parseapi.back4app.com';Schritt 3: Alle Todos abfragen
Erstellen Sie eine Parse Abfrage für die Todo-Klasse, fügen Sie eine aufsteigende Sortierung nach Priorität hinzu und rufen Sie find() (oder findWithCount()) auf.
JavaScriptasync function getTodos() { const query = new Parse.Query('Todo').ascending('priority'); const results = await query.find(); return results; }Schritt 4: Ein Todo erstellen
Erstellen Sie ein neues Parse.Object('Todo'), setzen Sie Titel, erledigt und Priorität, und rufen Sie dann save() auf.
JavaScriptasync function createTodo(title, priority = 3) { const Todo = Parse.Object.extend('Todo'); const todo = new Todo(); todo.set('title', title); todo.set('done', false); todo.set('priority', priority); await todo.save(); return todo; }Schritt 5: Todos aktualisieren und löschen
Holen Sie ein Todo anhand der objectId, setzen Sie die Felder und rufen Sie save() auf, um zu aktualisieren, oder rufen Sie destroy() auf, um zu löschen.
JavaScriptasync function markDone(objectId) { const query = new Parse.Query('Todo'); const todo = await query.get(objectId); todo.set('done', true); await todo.save(); } async function deleteTodo(objectId) { const query = new Parse.Query('Todo'); const todo = await query.get(objectId); await todo.destroy(); }
Zustandsverwaltung
Verwenden Sie React-Hooks (useState, useReducer, useContext) oder einen kleinen Store, um den Zustand der Todo-Liste zu halten und das Parse SDK aufzurufen.
Vollständiges JavaScript/TypeScript Datenmodell
Kopiere einen vollständigen Todo-Typ und Hilfsfunktionen für typensichere Serialisierung mit dem Parse SDK.
/** @typedef {{ objectId?: string, title: string, done: boolean, dueDate?: string, priority: number, owner?: { objectId: string }, createdAt?: string, updatedAt?: string }} Todo */
/**
* @param {Parse.Object} obj
* @returns {Todo}
*/
function todoFromParse(obj) {
return {
objectId: obj.id,
title: obj.get('title'),
done: obj.get('done') ?? false,
dueDate: obj.get('dueDate')?.toISOString?.() ?? undefined,
priority: obj.get('priority') ?? 3,
owner: obj.get('owner') ? { objectId: obj.get('owner').id } : undefined,
createdAt: obj.get('createdAt')?.toISOString?.() ?? undefined,
updatedAt: obj.get('updatedAt')?.toISOString?.() ?? undefined,
};
}Offline-First & Lokaler Datenspeicher
Verwende pinAll() und unpin, damit Daten offline verfügbar sind und synchronisiert werden, wenn du wieder online bist.
Das Parse React Native SDK unterstützt einen lokalen Datenspeicher. Nachdem du Todo-Objekte abgerufen hast, pinne sie, damit die Liste offline verfügbar ist; führe dieselbe Abfrage mit fromLocalDatastore() aus, wenn das Gerät offline ist. Wenn die App wieder online ist, speichere Änderungen und synchronisiere.
Unten: Ergebnisse nach dem Abrufen pinnen und unpin, wenn du keine lokalen Kopien mehr benötigst.
// Pin todos after fetch (offline-first)
async function fetchAndPinTodos() {
const query = new Parse.Query('Todo').ascending('priority');
const results = await query.find();
await Parse.Object.pinAll(results);
// When offline, read from local datastore:
// const localQuery = new Parse.Query('Todo').fromLocalDatastore();
// const localResults = await localQuery.find();
}
async function unpinAllTodos() {
await Parse.Object.unpinAll('Todo');
}Häufig gestellte Fragen
Häufige Fragen zum Backend-Template der Todo-App.
Bereit, deine Todo-App zu erstellen?
Starte dein React Native Projekt in wenigen Minuten. Keine Kreditkarte erforderlich.