El backend /SDK cliente

Un cliente.
Tipado desde tu esquema.

Datos, auth, almacenamiento, realtime y tus propias funciones — desde cualquier entorno JavaScript o TypeScript, con los nombres de colección y los tipos de campo comprobados en tiempo de compilación.

Tipado desde tu esquema

Un cliente, cinco superficies, una cadena de conexión

createRebaseClient te da acceso tipado a datos, auth, admin y almacenamiento desde una sola instancia. Genera los tipos con rebase generate-sdk para IntelliSense completo.

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

Tus colecciones son propiedades, no cadenas

Accede a cualquier colección como propiedad tipada. Sin búsquedas por cadena, sin escribir tipos a mano — solo 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");
Constructor de consultas fluido
// 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

Sesiones, sin un segundo servicio de auth

Ciclo de vida de auth completo: inicio de sesión, registro, OAuth de Google, refresco de tokens, restablecimiento de contraseña, verificación de correo y gestión de sesiones. Funciona en el navegador y en 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

Usuarios, roles y archivos, desde el mismo cliente

Gestiona usuarios, roles y archivos programáticamente — sin necesidad de 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

Los tipos salen de las colecciones

Ejecuta rebase generate-sdk para producir un archivo database.types.ts desde tus definiciones de colección. Pásalo como genérico a createRebaseClient<Database> para seguridad de tipos de extremo a extremo.

  • Generado automáticamente desde tus definiciones de collection
  • IntelliSense completo para rebase.data.<collection>
  • Incluye tipos de property, enums y relaciones
  • Regenera con un solo comando cuando cambia el esquema
$ 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;
  };
}

Tipado desde tu propio esquema.

Genera un proyecto y el cliente se genera desde las colecciones que defines. Sin tipos escritos a mano que se desvíen.

~pnpm dlx @rebasepro/cli init
Probar la demoLeer la documentación