import { ShapeManager, SyncEngine } from '@dotdo/electric'

const shapes = new ShapeManager(pglite)
const sync = new SyncEngine({ url: 'https://db.postgres.do/mydb' })

// Subscribe to a shape - data syncs automatically
await shapes.subscribe({
  table: 'todos',
  where: { userId: currentUser.id }
})

// Changes sync in real-time. Offline? No problem.
await pglite.query(`INSERT INTO todos (title) VALUES ('Ship it')`)

import { PGlite } from '@dotdo/pglite'
import { ShapeManager, SyncEngine } from '@dotdo/electric'

// Local PGLite database (browser or edge)
const pglite = new PGlite()

// Shape manager handles partial replication
const shapes = new ShapeManager(pglite)

// Subscribe to shapes you care about
await shapes.subscribe({
  table: 'todos',
  where: { userId: 'user_123' }
})

// Data is now local - queries are instant
const todos = await pglite.query('SELECT * FROM todos')

// Local changes sync automatically
await pglite.query(`
  INSERT INTO todos (title, completed) VALUES ('New task', false)
`)

// Simple table subscription
await shapes.subscribe({ table: 'todos' })

// With filters
await shapes.subscribe({
  table: 'todos',
  where: { userId: currentUser.id, completed: false }
})

// With relations
await shapes.subscribe({
  table: 'posts',
  include: {
    comments: { where: { approved: true } },
    author: true
  }
})

// Unsubscribe when done
await shapes.unsubscribe('todos')

import { DurableStreamProducer, DurableStreamConsumer } from '@dotdo/electric/streams'

// Producer - emit events
const producer = new DurableStreamProducer({
  streamId: 'chat-room-123',
  url: 'https://db.postgres.do/mydb'
})

await producer.emit({
  type: 'message',
  data: { text: 'Hello!', userId: 'user_123' }
})

// Consumer - receive events
const consumer = new DurableStreamConsumer({
  streamId: 'chat-room-123',
  url: 'https://db.postgres.do/mydb',
  fromSequence: 0  // Resume from any point
})

for await (const event of consumer) {
  console.log('Received:', event)
}

import { SessionManager } from '@dotdo/electric/sessions'

const sessions = new SessionManager({
  url: 'https://db.postgres.do/mydb'
})

// Create or join a session
const session = await sessions.create({
  sessionId: 'doc-edit-123',
  initialState: { document: '', cursors: {} }
})

// Participants join
await session.join({ userId: 'user_456', name: 'Jane' })

// Apply mutations (synced to all participants)
await session.mutate({
  type: 'cursor_move',
  data: { userId: 'user_456', position: 42 }
})

// Subscribe to state changes
session.subscribe((state, change) => {
  renderDocument(state.document)
  renderCursors(state.cursors)
})

import { SyncEngine } from '@dotdo/electric/sync'

const sync = new SyncEngine({
  local: pglite,
  remote: 'https://db.postgres.do/mydb',
  tables: ['todos', 'projects']
})

// Start sync
await sync.start()

// Monitor status
sync.onStateChange((state) => {
  if (state.status === 'synced') showGreenDot()
  if (state.status === 'syncing') showYellowDot()
  if (state.status === 'offline') showGrayDot()
})

// Handle conflicts
sync.onConflict((local, remote) => {
  // Return the winner
  return local.updatedAt > remote.updatedAt ? local : remote
})

// Pause/resume for battery saving
await sync.pause()
await sync.resume()

import { OfflineManager } from '@dotdo/electric/offline'

const offline = new OfflineManager({
  sync,
  storage: 'indexeddb'  // Persist across browser sessions
})

// Queue mutations when offline
await offline.mutate({
  sql: 'INSERT INTO todos (title) VALUES ($1)',
  params: ['Offline task']
})

// Mutations apply immediately to local state
// Sync when back online - automatically

// Check connectivity
console.log(offline.isOnline)  // false
console.log(offline.pendingCount)  // 3 mutations queued

// Last-write-wins (default)
sync.setConflictStrategy('last-write-wins')

// Server always wins
sync.setConflictStrategy('server-wins')

// Client always wins
sync.setConflictStrategy('client-wins')

// Custom logic
sync.onConflict((local, remote, base) => {
  // Merge intelligently
  return {
    ...remote,
    title: local.title,  // Keep client's title
    updatedAt: Math.max(local.updatedAt, remote.updatedAt)
  }
})

import { Postgres } from '@dotdo/postgres'
import { SyncEngine } from '@dotdo/electric'

// Your postgres.do database
const db = new Postgres({ url: 'https://db.postgres.do/mydb' })

// Add real-time sync
const sync = new SyncEngine({
  local: pglite,
  remote: db
})

// Server-side changes flow to clients
// Client-side changes flow to server
// Offline mutations queue and sync