Swift: Subscribe to channel

• By default, Broadcast and Presence are enabled for all projects.
• By default, listening to database changes is disabled for new projects due to database performance and security concerns. You can turn it on by managing Realtime's replication.
• You can receive the "previous" data for updates and deletes by setting the table's REPLICA IDENTITY to FULL (e.g., ALTER TABLE your_table REPLICA IDENTITY FULL;).
• Row level security is not applied to delete statements. When RLS is enabled and replica identity is set to full, only the primary key is sent to clients.
• Use AsyncStream or callbacks for listening to changes.

Examples

Listen to broadcast messages

let channel = supabase.channel("room1")

let broadcastStream = channel.broadcastStream(event: "cursor-pos")

await channel.subscribe()

Task {
  for await message in broadcastStream {
    print("Cursor position received", message)
  }
}

await channel.broadcast(
  event: "cursor-pos",
  message: [
    "x": .double(.random(in: 0...1)),
    "y": .double(.random(in: 0...1))
  ]
)

Listen to broadcast messages using callback

let channel = supabase.channel("room1")

let subscription = channel.onBroadcast(event: "cursor-pos") { message in
  print("Cursor position received", message)
}

await channel.subscribe()

await channel.broadcast(
  event: "cursor-pos",
  message: [
    "x": .double(.random(in: 0...1)),
    "y": .double(.random(in: 0...1))
  ]
)

// remove subscription some time later
subscription.cancel()

Listen to presence updates

struct PresenceState: Codable {
  let username: String
}

let channel = supabase.channel("channelId")

let presenceChange = channel.presenceChange()

await channel.subscribe()

Task {
  for await presence in presenceChange {
    let joins = try presence.decodeJoins(as: PresenceState.self)
    let leaves = try presence.decodeLeaves(as: PresenceState.self)
  }
}

// Send your own state
try await channel.track(PresenceState(username: "John"))

Listen to presence updates using callback

struct PresenceState: Codable {
  let username: String
}

let channel = supabase.channel("channelId")

let subscription = channel.onPresenceChange() { presence in
  do {
    let joins = try presence.decodeJoins(as: PresenceState.self)
    let leaves = try presence.decodeLeaves(as: PresenceState.self)
  } catch {
    // Handle decoding error
  }
}

await channel.subscribe()

// Send your own state
try await channel.track(PresenceState(username: "John"))

// remove subscription some time later
subscription.cancel()

Listen to all database changes

let channel = supabase.channel("channelId")

let changeStream = channel.postgresChange(AnyAction.self, schema: "public")

await channel.subscribe()

for await change in changeStream {
  switch change {
  case .delete(let action): print("Deleted: \(action.oldRecord)")
  case .insert(let action): print("Inserted: \(action.record)")
  case .select(let action): print("Selected: \(action.record)")
  case .update(let action): print("Updated: \(action.oldRecord) with \(action.record)")
  }
}

Listen to all database changes using callback

let channel = supabase.channel("channelId")

let subscription = channel.onPostgresChange(AnyAction.self, schema: "public") { change in
  switch change {
  case .delete(let action): print("Deleted: \(action.oldRecord)")
  case .insert(let action): print("Inserted: \(action.record)")
  case .select(let action): print("Selected: \(action.record)")
  case .update(let action): print("Updated: \(action.oldRecord) with \(action.record)")
  }
}

await channel.subscribe()

// remove subscription some time later
subscription.cancel()

Listen to a specific table

let channel = supabase.channel("channelId")

let changeStream = channel.postgresChange(
  AnyAction.self,
  schema: "public",
  table: "users"
)

await channel.subscribe()

for await change in changeStream {
  switch change {
    case .delete(let action): print("Deleted: \(action.oldRecord)")
    case .insert(let action): print("Inserted: \(action.record)")
    case .select(let action): print("Selected: \(action.record)")
    case .update(let action): print("Updated: \(action.oldRecord) with \(action.record)")
  }
}

Listen to a specific table using callback

let channel = supabase.channel("channelId")

let subscription = channel.onPostgresChange(
  AnyAction.self,
  schema: "public",
  table: "users"
) { change in
  switch change {
  case .delete(let action): print("Deleted: \(action.oldRecord)")
  case .insert(let action): print("Inserted: \(action.record)")
  case .select(let action): print("Selected: \(action.record)")
  case .update(let action): print("Updated: \(action.oldRecord) with \(action.record)")
  }
}

await channel.subscribe()

// remove subscription some time later
subscription.cancel()

Listen to inserts

let channel = supabase.channel("channelId")

let insertions = channel.postgresChange(
  InsertAction.self,
  schema: "public",
  table: "users"
)

await channel.subscribe()

for await insert in insertions {
  print("Inserted: \(insert.record)")
}

Listen to inserts using callback

let channel = supabase.channel("channelId")

let subscription = channel.onPostgresChange(
  InsertAction.self,
  schema: "public",
  table: "users"
) { insert in
  print("Inserted: \(insert.record)")
}

await channel.subscribe()

// remove subscription some time later
subscription.cancel()

Listen to updates

 let channel = supabase.channel("channelId")

 let updates = channel.postgresChange(
   UpdateAction.self,
   schema: "public",
   table: "users"
 )

 await channel.subscribe()

 for await update in updates {
   print("Updated: \(update.oldRecord) with \(update.record)")
 }

Listen to updates using callback

 let channel = supabase.channel("channelId")

 let subscription = channel.onPostgresChange(
   UpdateAction.self,
   schema: "public",
   table: "users"
 ) { update in
  print("Updated: \(update.oldRecord) with \(update.record)")
 }

 await channel.subscribe()

 // remove subscription some time later
subscription.cancel()

Listen to deletes

let channel = supabase.channel("channelId")

let deletions = channel.postgresChange(
  DeleteAction.self,
  schema: "public",
  table: "users"
)

await channel.subscribe()

for await deletion in deletions {
  print("Deleted: \(deletion.oldRecord)")
}

Listen to deletes using callback

let channel = supabase.channel("channelId")

let subscription = channel.onPostgresChange(
  DeleteAction.self,
  schema: "public",
  table: "users"
) { deletion in
  print("Deleted: \(deletion.oldRecord)")
}

await channel.subscribe()

// remove subscription some time later
subscription.cancel()

Listen to row level changes

let channel = supabase.channel("channelId")

let deletions = channel.postgresChange(
  DeleteAction.self,
  schema: "public",
  table: "users",
  filter: .eq(id, value: 1)
)

await channel.subscribe()

for await deletion in deletions {
  print("Deleted: \(deletion.oldRecord)")
}

Listen to row level changes using callback

let channel = supabase.channel("channelId")

let subscription = channel.onPostgresChange(
  DeleteAction.self,
  schema: "public",
  table: "users",
  filter: .eq(id, value: 1)
) { deletion in
  print("Deleted: \(deletion.oldRecord)")
}

await channel.subscribe()

// remove subscription some time later
subscription.cancel()