Das Backend /Client-SDK

Ein Client.
Typisiert aus deinem Schema.

Daten, Auth, Storage, Realtime und deine eigenen Functions — aus jeder JavaScript- oder TypeScript-Umgebung, mit Collection-Namen und Feldtypen, die zur Compile-Zeit geprüft werden.

Typisiert aus deinem Schema

Ein Client, fünf Oberflächen, ein Connection-String

createRebaseClient gibt dir typisierten Zugriff auf Daten, Auth, Admin und Storage über eine einzige Instanz. Typen erzeugst du mit rebase generate-sdk für vollständiges IntelliSense.

import { createRebaseClient } from "@rebasepro/client";
import type { Database } from "./database.types";

const rebase = createRebaseClient<Database>({
  baseUrl: "https://api.myapp.com",
});

// Everything is dot-accessible:
rebase.data      // → collection queries
rebase.auth      // → sign in, sign up, sessions
rebase.admin     // → user/role management
rebase.storage   // → file upload/download
rebase.realtime  // → broadcast channels, presence

Deine Collections sind Properties, keine Strings

Greif auf jede Collection als typisierte Property zu. Keine String-Lookups, kein manuelles Tippen — einfach rebase.data.posts.

app.ts
1import { createRebaseClient } from '@rebasepro/client';
2import type { Database } from './generated/sdk/database.types';
3
4const client = createRebaseClient<Database>({ baseUrl: API_URL });
5
6const { data } = await client.data.
TypeScriptUTF-8Ln 6, Col 36
CRUD
// Find all published posts
const { data } = await rebase.data.posts.find({
  limit: 20,
  orderBy: ["createdAt", "desc"]
});

// Get single post
const post = await rebase.data.posts
  .findById("abc-123");

// Create
await rebase.data.posts.create({
  title: "Hello World",
  status: "draft"
});

// Update
await rebase.data.posts.update("abc-123", {
  status: "published"
});

// Delete
await rebase.data.posts.delete("abc-123");
Fluent Query Builder
// Chained queries
const { data } = await rebase.data.posts
  .where("status", "==", "published")
  .where("views", ">=", 100)
  .orderBy("createdAt", "desc")
  .limit(10)
  .find();

// Include relations
const { data: posts } = await rebase.data.posts
  .include("author", "tags")
  .find();

// Full-text search
const results = await rebase.data.posts
  .search("rebase tutorial")
  .limit(5)
  .find();

// Realtime listening
const unsub = rebase.data.posts
  .where("status", "==", "published")
  .listen(({ data }) => {
    console.log("Live update:", data);
  });

// Broadcast channel
const channel = rebase.realtime.channel("chat-room");

channel.onBroadcast("message", (payload) => {
  console.log("Received:", payload);
});

await channel.join();
rebase.auth

Sessions, ohne einen zweiten Auth-Dienst

Vollständiger Auth-Lebenszyklus — Anmelden, Registrieren, Google-OAuth, Token-Refresh, Passwort-Reset, E-Mail-Verifizierung und Session-Verwaltung. Läuft im Browser und in Node.js.

// Sign in
await rebase.auth.signInWithEmail(
  "user@app.com", "password"
);

// Google OAuth
await rebase.auth.signInWithGoogle(idToken);

// Listen for auth changes
rebase.auth.onAuthStateChange((event, session) => {
  console.log(event, session?.user);
});

// Session management
const sessions = await rebase.auth.getSessions();
await rebase.auth.revokeSession(sessionId);
rebase.admin + rebase.storage

Benutzer, Rollen und Dateien, aus demselben Client

Verwalte Benutzer, Rollen und Dateien programmatisch — ohne Panel.

// User management
const { users } = await rebase.admin.listUsers();
await rebase.admin.createUser({
  email: "new@app.com",
  roles: ["editor"]
});

// Role management
const { roles } = await rebase.admin.listRoles();

// File storage
const { key, bucket, storageUrl } = await rebase.storage.putObject({
  file: myFile,
  key: "uploads/avatar.jpg"
});

// short-lived signed URL, or a permanent one for public objects
const { url } = await rebase.storage
  .getSignedUrl("uploads/avatar.jpg");

await rebase.storage.deleteObject("old.pdf");
rebase generate-sdk

Die Typen kommen aus den Collections

Führe rebase generate-sdk aus, um aus deinen Collection-Definitionen eine database.types.ts zu erzeugen. Übergib sie als Generic an createRebaseClient<Database> für durchgehende Typsicherheit.

  • Automatisch aus deinen Collection-Definitionen erzeugt
  • Vollständiges IntelliSense für rebase.data.<collection>
  • Property-Typen, Enums und Relationen inklusive
  • Bei Schemaänderungen mit einem Befehl neu erzeugen
$ rebase generate-sdk
✓ Generated database.types.ts

// database.types.ts (auto-generated)
export interface Database {
  posts: {
    id: string;
    title: string;
    status: "draft" | "published";
    authorId: string;
    createdAt: Date;
  };
  users: {
    id: string;
    email: string;
    displayName: string | null;
  };
}

Typisiert aus deinem eigenen Schema.

Scaffolde ein Projekt, und der Client entsteht aus den Collections, die du definierst. Keine handgeschriebenen Typen, die driften.

~pnpm dlx @rebasepro/cli init
Demo testenDocs lesen