Le backend /SDK client

Un client.
Typé depuis votre schéma.

Données, auth, stockage, temps réel et vos propres fonctions — depuis n'importe quel environnement JavaScript ou TypeScript, avec les noms de collection et les types de champ vérifiés à la compilation.

Typé depuis votre schéma

Un client, cinq surfaces, une chaîne de connexion

createRebaseClient vous donne un accès typé aux données, à l'auth, à l'admin et au stockage depuis une seule instance. Générez les types avec rebase generate-sdk pour un IntelliSense complet.

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

Vos collections sont des propriétés, pas des chaînes

Accédez à n'importe quelle collection comme à une propriété typée. Pas de recherche par chaîne, pas de typage manuel — juste 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");
Constructeur de requêtes fluide
// 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

Des sessions, sans second service d'auth

Cycle de vie d'auth complet — connexion, inscription, OAuth Google, rafraîchissement de jeton, réinitialisation de mot de passe, vérification d'e-mail et gestion des sessions. Fonctionne dans le navigateur et sous 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

Utilisateurs, rôles et fichiers, depuis le même client

Gérez utilisateurs, rôles et fichiers par programmation — sans panneau.

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

Les types sortent des collections

Lancez rebase generate-sdk pour produire un fichier database.types.ts depuis vos définitions de collection. Passez-le en générique à createRebaseClient<Database> pour une sûreté de typage de bout en bout.

  • Généré automatiquement depuis vos définitions de collection
  • IntelliSense complet pour rebase.data.<collection>
  • Types de property, enums et relations inclus
  • Régénérez en une commande à chaque changement de schéma
$ 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;
  };
}

Typé depuis votre propre schéma.

Échafaudez un projet et le client est généré depuis les collections que vous définissez. Aucun type écrit à la main qui dérive.

~pnpm dlx @rebasepro/cli init
Tester la démoLire la doc