Sync

// prisma.config.ts
contract: prismaIdbContract("schema.prisma", { projection: "client" }),

npx prisma contract emit
npx prisma-next-idb migration plan   # auto-detects baseline vs. incremental
npx prisma-next-idb migration contract-space
npx prisma-next-idb migration preflight

import { createManagedAutoSyncIdbClient } from "@prisma-next-idb/sync-extension-idb/client";
import { idbSyncExtension } from "@prisma-next-idb/sync-extension-idb/control";
import { contractSpace } from "./prisma/contract-space.generated";

const managedDb = createManagedAutoSyncIdbClient({
  contractSpace,
  dbName: "my-app",
  extensions: [idbSyncExtension],
});

export const getDb = () => managedDb.get();
export const resetDb = () => managedDb.reset(); // e.g. on logout

const db = await getDb();
await db.orm.board.create({ id: "b1", name: "My Board", userId: "u1" });

// prisma.config.postgres.ts
import { definePrismaConfig } from "@prisma/cli-engine";
import { defineConfig as ormConfig } from "@prisma/orm-postgres/config";
import { writeSqlSchemaWithSync } from "@prisma-next-idb/sync-server/schema";

export default definePrismaConfig({
  orm: ormConfig({
    contract: writeSqlSchemaWithSync("schema.prisma", "schema.postgres.generated.prisma"),
    db: { connection: process.env.DATABASE_URL },
    migrations: { dir: "migrations-postgres" }, // keep this separate from the IDB side's migrations/
  }),
});

npx prisma contract emit --config prisma.config.postgres.ts
npx prisma db init --config prisma.config.postgres.ts       # first time only
npx prisma migration new --config prisma.config.postgres.ts
npx prisma db update --config prisma.config.postgres.ts

import { createSyncServer } from "@prisma-next-idb/sync-server";
import { createSqlSyncAdapter, sqlGetKeyField } from "@prisma-next-idb/sync-server-sql";
import type { Contract as ServerContract } from "./prisma/schema.postgres.generated";
import type { Contract as ClientContract } from "./prisma/contract";
import serverContractJson from "./prisma/schema.postgres.generated.json" with { type: "json" };
import clientContractJson from "./prisma/contract.json" with { type: "json" };

const serverContract = serverContractJson as unknown as ServerContract;

export const syncServer = createSyncServer({
  contract: serverContract, // your full server contract (from step above)
  clientContract: clientContractJson as unknown as ClientContract, // the client-projected contract from step 3
  rootModel: "User",
  getKeyField: sqlGetKeyField, // SQL contracts keep their primary key on the table, not model.storage.keyPath
});

export const sqlSyncAdapter = createSqlSyncAdapter({ contract: serverContract });

// POST /api/sync/push
import { pushRequestBodySchema } from "@prisma-next-idb/sync-extension-idb/schemas";
import { syncServer, sqlSyncAdapter } from "./sync"; // built above
import { getAuthenticatedUserId } from "./auth"; // your own session lookup
import { db } from "./db"; // your own database client

export async function POST(req: Request) {
  const scopeKey = await getAuthenticatedUserId(req);
  // `req.json()` is untrusted network input — `pushRequestBodySchema` (zod)
  // validates it and narrows `operation` to the union sync-server expects,
  // so no manual cast is needed below. See Server for the full picture.
  const parsed = pushRequestBodySchema.safeParse(await req.json());
  if (!parsed.success) return new Response("Malformed request body", { status: 400 });
  const { events } = parsed.data;

  const pushEvents = events.map((e) => ({
    id: e.id,
    model: e.entityType,
    operation: e.operation,
    payload: sqlSyncAdapter.toSyncPushPayload(e.operation, e.payload, sqlSyncAdapter.getKeyField(e.entityType)),
  }));
  const checks = syncServer.validatePush(pushEvents, { scopeKey });

  const results = [];
  for (const { eventId, model, check } of checks) {
    // ... apply each authorized event — full loop (including why it's
    // sequential, not Promise.all) is in Server
    results.push(
      await sqlSyncAdapter.applyPushEvent(
        db,
        events.find((e) => e.id === eventId)!,
        model,
        check,
        scopeKey
      )
    );
  }
  return Response.json(results);
}

// GET /api/sync/pull?since=<changelogId>
import { syncServer, sqlSyncAdapter } from "./sync"; // built above
import { getAuthenticatedUserId } from "./auth"; // your own session lookup
import { db } from "./db"; // your own database client — built from the SQL contract, see Server#gotchas

export async function GET(req: Request) {
  const scopeKey = await getAuthenticatedUserId(req);
  const since = new URL(req.url).searchParams.get("since");
  const sinceId = since !== null ? Number(since) : null;
  if (sinceId !== null && !Number.isInteger(sinceId)) {
    return new Response("since must be an integer", { status: 400 });
  }

  // Your own query, scoped + cursored on your changelog storage — sync-server
  // has no opinion on it, but cap it with `.take()`: without a limit, a
  // client that's been offline a long time pulls its entire history at once.
  const ordered = db.orm.public.Changelog.where({ scopeKey })
    .select("id", "model", "keyPath", "operation")
    .orderBy((c) => c.id.asc());
  const rows = await (sinceId !== null ? ordered.cursor({ id: sinceId }) : ordered).take(50).all();

  const checks = syncServer.buildPullQueries(
    rows.map((r) => ({ changelogId: String(r.id), model: r.model, key: r.keyPath })),
    { scopeKey }
  );

  // One LogWithRecord per row (@prisma-next-idb/sync-extension-idb/client)
  // — the shape pullHandler's response is parsed as, client-side.
  const logs = await Promise.all(
    checks.map(async ({ changelogId, model, check }) => {
      const row = rows.find((r) => String(r.id) === changelogId)!;
      const operation = row.operation as "create" | "update" | "delete";
      const record = await sqlSyncAdapter.resolvePullRecord(db, model, check, row.keyPath, operation);
      return { changelogId, model, operation, keyPath: row.keyPath, record };
    })
  );
  return Response.json(logs);
}