sync vs Firebase

// BEFORE — Firestore real-time listener.
import { onSnapshot, collection, query, where } from 'firebase/firestore';
import { db } from './firebase';

useEffect(() => {
  const q = query(
    collection(db, 'tasks'),
    where('ownerId', '==', userId),
  );
  const unsubscribe = onSnapshot(q, (snap) => {
    setTasks(snap.docs.map((d) => ({ id: d.id, ...d.data() })));
  });
  return unsubscribe;
}, [userId]);

// AFTER — sync collection subscription.
import { useSyncCollection } from '@absolutejs/sync/react';

const { data: tasks } = useSyncCollection({
  url: 'ws://localhost:3000/sync/ws',
  collection: 'tasks_for_owner',
  params: { ownerId: userId },
});

// Reconnect catch-up is on by default — the WebSocket re-resolves
// after background-tab sleep, network flap, etc., with bounded ~4-6 ms
// catch-up regardless of missed-writes count. No silent drops the way
// onSnapshot can on long disconnects.

// Server side — define the 'tasks_for_owner' collection ONCE.
// This is the bit Firestore's security rules + onSnapshot try to do
// implicitly; in sync it's an explicit TypeScript function you can
// test, log, and version-control.

import { defineCollection } from '@absolutejs/sync/engine';

defineCollection({
  name: 'tasks_for_owner',
  key: (row) => row.id,
  hydrate: ({ db, params }) =>
    db.all('tasks WHERE owner_id = ?', [params.ownerId]),
  match: (row, params, ctx) =>
    row.ownerId === params.ownerId && row.tenant === ctx.tenant,
});

// 'match' is the per-row predicate the engine re-evaluates on every
// change. Conceptually equivalent to a Firestore security rule, but
// in TypeScript with full context access — no DSL to learn.

// BEFORE — Firestore write with offline persistence + optimistic UX.
import { doc, setDoc, serverTimestamp } from 'firebase/firestore';

const addTask = async (text) => {
  // Optimistic UI happens "for free" via the local cache, but if the
  // write violates security rules the SDK silently rolls back with no
  // app-visible signal. You have to wire your own error handler.
  await setDoc(doc(db, 'tasks', crypto.randomUUID()), {
    text,
    ownerId: currentUser.uid,
    createdAt: serverTimestamp(),
  });
};

// AFTER — sync mutation with optimistic draft.
const { mutate } = useSyncCollection({ url, collection: 'tasks_for_owner' });

const addTask = (text) => mutate({
  name: 'addTask',
  args: { text },
  optimistic: (draft) => {
    draft.set({ id: crypto.randomUUID(), text, ownerId: userId, n: 0 });
  },
});

// Server side — the handler authoritatively decides the id, timestamp,
// and any computed fields. If it throws, the optimistic draft rolls
// back AND the caller's promise rejects with the real error.

import { defineMutation } from '@absolutejs/sync/engine';

defineMutation({
  name: 'addTask',
  handler: async (args, ctx, actions) => {
    if (typeof args.text !== 'string' || args.text.length === 0) {
      throw new Error('text required');
    }
    return actions.insert('tasks', {
      id: crypto.randomUUID(),
      text: args.text.trim(),
      ownerId: ctx.userId,
      createdAt: actions.now(),
    });
  },
});

import { defineGraphCollection } from '@absolutejs/sync/engine';

defineGraphCollection({
  name: 'feed_with_authors',
  graph: (g) =>
    g.from('posts')
     .leftJoin('users', { from: 'authorId', to: 'id' })
     .select({
       id: 'posts.id',
       title: 'posts.title',
       authorName: 'users.name',
     })
     .orderBy('posts.createdAt', 'desc')
     .limit(20),
});

import { Elysia } from 'elysia';
import { syncSocket } from '@absolutejs/sync';
import { auth } from 'firebase-admin';

new Elysia()
  .derive(async ({ headers }) => {
    const token = headers['authorization']?.replace(/^Bearer /, '');
    if (!token) return { ctx: null };
    const decoded = await auth().verifyIdToken(token);
    return { ctx: { userId: decoded.uid, tenant: decoded.firebase?.tenant } };
  })
  .use(syncSocket({ engine }))
  .listen(3000);

// One-shot migration: 'tasks' Firestore collection → 'tasks' Postgres table.

import { drizzle } from 'drizzle-orm/postgres-js';
import postgres from 'postgres';
import { readFileSync } from 'node:fs';
import { tasks } from './schema';

const sql = postgres(process.env.DATABASE_URL);
const db = drizzle(sql);

// firebase firestore:export gs://my-bucket/dump
// gcloud storage cp -r gs://my-bucket/dump/all_namespaces/...tasks ./tasks
// jq -c '.documents[] | { id: .name, ...(.fields | with_entries(...)) }' \
//   ./tasks/output-0 > tasks.jsonl

for (const line of readFileSync('./tasks.jsonl', 'utf8').trim().split('\n')) {
  const doc = JSON.parse(line);
  await db.insert(tasks).values({
    id: doc.id,
    text: doc.text,
    ownerId: doc.ownerId,
    createdAt: new Date(doc.createdAt),
  }).onConflictDoNothing();
}