From 30b47ee3e1797024376813ec7ed235a20cc5dff5 Mon Sep 17 00:00:00 2001 From: benitav Date: Thu, 13 Feb 2025 14:17:07 +0200 Subject: [PATCH 01/11] Prioritized sync draft --- usage/use-case-examples/prioritized-sync.mdx | 88 +++++++++++++------- 1 file changed, 58 insertions(+), 30 deletions(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index 9286cee9..55930732 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -3,48 +3,76 @@ title: "Prioritized Sync" description: "In some scenarios, you may want to sync tables using different priorities. For example, you may want to sync a subset of all tables first to log a user in as fast as possible, then sync the remaining tables in the background." --- - - Note that this strategy is specifically to prioritize data on initial sync, and cannot be used for incremental sync after that. - +# Overview -## Overview +PowerSync supports defining [sync bucket](/usage/sync-rules/organize-data-into-buckets) priorities, which allows you to control the sync order for different data sets. Use this to load critical data first while syncing bulk data in the background. -The general approach is as follows: +# How It Works -1. Define how many priority types you want - typically only two are needed: "high priority" and "the rest" +Each sync bucket can be assigned a priority (0–3): -2. Create a sync bucket for each priority type +- 0 – Highest priority; syncs immediately, even if uploads are pending. +- 1 – Default priority. +- 2-3 – Lower priority; syncs only after higher-priority buckets. -3. Use [client parameters](/usage/sync-rules/advanced-topics/client-parameters) to control which priorities you want the client to sync +Sync priorities are best-effort, meaning higher-priority buckets may sync first, but no guarantee exists if sync conditions change. In general, sync follows this order: -## Example +- 1️⃣ Sync all buckets with priority 0. +- 2️⃣ Sync all buckets with priority 0 or 1. +- 3️⃣ Sync all buckets with priority 0, 1, or 2. +- 4️⃣ Sync all buckets with priority 0, 1, 2, or 3. -Suppose we have two tables: `lists` and `todos` (as per the standard todolist demo app [schema](/integration-guides/supabase-+-powersync#create-the-demo-database-schema)). Further, suppose we want the sync priority to behave as follows: +# Example: Syncing Lists Before Todos -1. First, sync all the user's lists, enabling us to render the initial screen in the app +Consider a scenario where you want to display lists immediately while loading todos in the background. This approach allows users to view and interact with lists right away without waiting for todos to sync. Here's how to configure sync priorities in your Sync Rules to achieve this: -2. Then, sync the user's todos - -Below are the sync rules that will enable this: - -```yaml +```sql bucket_definitions: - # always sync high priority tables (first), in this case the user's lists - high_priority: - parameters: select id as list_id from lists where owner_id = token_parameters.user_id + user_lists: + # Sync the user's lists with a higher priority + parameters: select id as list_id, 1 as _priority from lists where user_id = request.user_id() data: - - select * from lists where id = bucket.list_id - # sync any remaining tables, in this case todo items - remaining: - parameters: select id as list_id from lists where owner_id = token_parameters.user_id and (request.parameters() ->> 'remaining_tables' = true) - data: - - select * from todos where list_id = bucket.list_id + - select * from lists where id = bucket.list_id + + user_todos: + # Sync the user's todos with a lower priority + parameters: select id as todo_id, 2 as _priority from todos where list_id in (select id from lists where user_id = request.user_id()) + data: + - select * from todos where list_id = bucket.todo_id ``` -It is recommended to set Client Parameters in the [Diagnostics App](https://github.com/powersync-ja/powersync-js/tree/main/tools/diagnostics-app) to verify functionality at this point: +In this configuration: + +The `lists` bucket has the default priority of 1, meaning it syncs early but allows for consistency. + +The `todos` bucket is assigned a priority of 2, meaning it will sync only after the lists have been synced. + + + +# Behavioral Considerations + +- **Interruption for Higher Priority Data**: If new data arrives for a higher-priority bucket, ongoing syncs for lower-priority buckets may be interrupted. +- **Local Changes & Consistency**: If local writes fail due to validation or permission issues, they are only reverted after all buckets sync. +- **Deleted Data**: Data deletion is deferred until all buckets sync, ensuring consistency. Future updates may improve this behavior. +- **Data Ordering**: Data in lower-priority buckets will never appear before higher-priority data. + +## Special Case: Priority 0 + +Priority 0 buckets sync regardless of pending uploads. + +For example, in a collaborative document editing app (e.g., using Yjs), each change is stored as a separate row. Since out-of-order updates don’t affect document integrity, Priority 0 can ensure immediate availability of updates. + +Caution: If misused, Priority 0 may cause flickering or inconsistencies, as updates could arrive out of order. + +# Consistency Considerations + +Priority levels ensure consistency within each level but not across different levels. Consider the following example: + +Example: Todo List Syncing + +Imagine a task management app where users create lists and todos. Some users have millions of todos. To improve first-load speed: - - - +- Lists are assigned Priority 1, syncing first to allow UI rendering. +- Todos are assigned Priority 2, loading in the background. -If everything checks out, you can then proceed to implement the client parameter switching accordingly in your app. \ No newline at end of file +Now, if another user adds new todos, it’s possible for the list count (synced at Priority 1) to temporarily not match the actual todos (synced at Priority 2). If real-time accuracy is required, both lists and todos should use the same priority. \ No newline at end of file From 1a182d5d87401cbb167f8ef22e5a64c3274ba7e9 Mon Sep 17 00:00:00 2001 From: benitav Date: Wed, 19 Feb 2025 17:53:44 +0200 Subject: [PATCH 02/11] Updates / PR feedback --- usage/use-case-examples/prioritized-sync.mdx | 83 +++++++++++++++----- 1 file changed, 62 insertions(+), 21 deletions(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index 55930732..8808c8a1 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -5,55 +5,83 @@ description: "In some scenarios, you may want to sync tables using different pri # Overview -PowerSync supports defining [sync bucket](/usage/sync-rules/organize-data-into-buckets) priorities, which allows you to control the sync order for different data sets. Use this to load critical data first while syncing bulk data in the background. +PowerSync supports defining [Sync Bucket](/usage/sync-rules/organize-data-into-buckets) Priorities, which allows you to control the sync order for different data sets. This is particularly useful when certain data should be available sooner than others. + +# Why Use Sync Bucket Priorities? + +PowerSync's standard sync protocol ensures that: +- The local data view is only updated when a fully consistent checkpoint is available. +- All pending local changes must be uploaded, acknowledged, and synced back before new data is applied. + +While this guarantees consistency, it can lead to delays, especially for large datasets or continuous client-side updates. Sync Bucket Priorities provide a way to speed up syncing of high-priority data while still maintaining overall integrity. # How It Works -Each sync bucket can be assigned a priority (0–3): +Each sync bucket is assigned a priority value between 0 and 3, where: + +- 0 is the highest priority and has special behavior (detailed below). +- 3 is the default and lowest priority. +- Lower numbers indicate higher priority. -- 0 – Highest priority; syncs immediately, even if uploads are pending. -- 1 – Default priority. -- 2-3 – Lower priority; syncs only after higher-priority buckets. +Buckets with higher priorities sync first, and lower-priority buckets sync later. It's worth noting that if you only use a single priority, there is no difference between priorities 1-3. The difference only comes in if you use multiple different priorities. -Sync priorities are best-effort, meaning higher-priority buckets may sync first, but no guarantee exists if sync conditions change. In general, sync follows this order: +# Syntax and Configuration -- 1️⃣ Sync all buckets with priority 0. -- 2️⃣ Sync all buckets with priority 0 or 1. -- 3️⃣ Sync all buckets with priority 0, 1, or 2. -- 4️⃣ Sync all buckets with priority 0, 1, 2, or 3. +Priorities can be defined for a bucket using the `priority` YAML key, or with the `_priority` attribute inside parameter queries: + +```yaml +bucket_definitions: + # Using the `priority` YAML key + user_data: + priority: 1 + parameters: SELECT request.user_id() as id where...; + data: + # ... + + # Using the `_priority` attribute + project_data: + parameters: select id as project_id, 2 as _priority from projects where ...; # This approach is useful when you have multiple parameter queries with different priorities. + data: + # ... +``` + +Note: +- If multiple parameter queries specify different priorities for the same bucket, the highest priority (lowest number) is used. +- Priorities must be static and cannot depend on row values within a parameter query. # Example: Syncing Lists Before Todos Consider a scenario where you want to display lists immediately while loading todos in the background. This approach allows users to view and interact with lists right away without waiting for todos to sync. Here's how to configure sync priorities in your Sync Rules to achieve this: -```sql +```yaml bucket_definitions: user_lists: # Sync the user's lists with a higher priority - parameters: select id as list_id, 1 as _priority from lists where user_id = request.user_id() + priority: 1 + parameters: select id as list_id from lists where user_id = request.user_id() data: - select * from lists where id = bucket.list_id user_todos: # Sync the user's todos with a lower priority - parameters: select id as todo_id, 2 as _priority from todos where list_id in (select id from lists where user_id = request.user_id()) + priority: 3 + parameters: select id as todo_id from todos where list_id in (select id from lists where user_id = request.user_id()) data: - select * from todos where list_id = bucket.todo_id ``` In this configuration: -The `lists` bucket has the default priority of 1, meaning it syncs early but allows for consistency. - -The `todos` bucket is assigned a priority of 2, meaning it will sync only after the lists have been synced. +The `lists` bucket has the default priority of 1, meaning it syncs first. +The `todos` bucket is assigned a priority of 2, meaning it may sync only after the lists have been synced. # Behavioral Considerations -- **Interruption for Higher Priority Data**: If new data arrives for a higher-priority bucket, ongoing syncs for lower-priority buckets may be interrupted. -- **Local Changes & Consistency**: If local writes fail due to validation or permission issues, they are only reverted after all buckets sync. -- **Deleted Data**: Data deletion is deferred until all buckets sync, ensuring consistency. Future updates may improve this behavior. +- **Interruption for Higher Priority Data**: Syncing lower-priority buckets _may_ be interrupted if new data for higher-priority buckets arrives. +- **Local Changes & Consistency**: If local writes fail due to validation or permission issues, they are only reverted after _all_ buckets sync. +- **Deleted Data**: Deleted data may only be removed after _all_ buckets have synced. Future updates may improve this behavior. - **Data Ordering**: Data in lower-priority buckets will never appear before higher-priority data. ## Special Case: Priority 0 @@ -66,7 +94,11 @@ Caution: If misused, Priority 0 may cause flickering or inconsistencies, as upda # Consistency Considerations -Priority levels ensure consistency within each level but not across different levels. Consider the following example: +PowerSync's full consistency guarantees only apply once all buckets have completed syncing. + +When higher-priority buckets are synced, all inserts and updates within the buckets for the specific priority will be consistent. However, deletes are only applied when the full sync completes, so you may still have some stale data within those buckets. + +Consider the following example: Example: Todo List Syncing @@ -75,4 +107,13 @@ Imagine a task management app where users create lists and todos. Some users hav - Lists are assigned Priority 1, syncing first to allow UI rendering. - Todos are assigned Priority 2, loading in the background. -Now, if another user adds new todos, it’s possible for the list count (synced at Priority 1) to temporarily not match the actual todos (synced at Priority 2). If real-time accuracy is required, both lists and todos should use the same priority. \ No newline at end of file +Now, if another user adds new todos, it’s possible for the list count (synced at Priority 1) to temporarily not match the actual todos (synced at Priority 2). If real-time accuracy is required, both lists and todos should use the same priority. + +# Client-Side Considerations + +PowerSync's client SDKs provide APIs to allow applications to track sync status at different priority levels. This includes: + +- `waitForFirstSync(priority: int)` to allow waiting for a specific priority level. +- `SyncStatus.statusForPriority(priority: int)` providing details on the last sync time per priority level. + +Developers can leverage these methods to ensure critical data is available before proceeding with UI updates or background processing. \ No newline at end of file From af6db348607e76485f3c5c4f4ad97944888e01d4 Mon Sep 17 00:00:00 2001 From: benitav Date: Thu, 20 Feb 2025 12:03:11 +0200 Subject: [PATCH 03/11] Client-side polish --- usage/use-case-examples/prioritized-sync.mdx | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index 8808c8a1..741e5092 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -111,9 +111,12 @@ Now, if another user adds new todos, it’s possible for the list count (synced # Client-Side Considerations -PowerSync's client SDKs provide APIs to allow applications to track sync status at different priority levels. This includes: +PowerSync's client SDKs provide APIs to allow applications to track sync status at different priority levels. Developers can leverage these to ensure critical data is available before proceeding with UI updates or background processing. This includes: -- `waitForFirstSync(priority: int)` to allow waiting for a specific priority level. -- `SyncStatus.statusForPriority(priority: int)` providing details on the last sync time per priority level. +## The `waitForFirstSync(priority: int)` method to allow waiting for a specific priority level. -Developers can leverage these methods to ensure critical data is available before proceeding with UI updates or background processing. \ No newline at end of file +TODO: add example + +## The `SyncStatus.statusInPriority(priority: int)` property providing details on the last sync time per priority level. + +TODO: add example From 23f770c37cbae392476b58ab8861e9363df26d3c Mon Sep 17 00:00:00 2001 From: benitav Date: Thu, 20 Feb 2025 12:08:43 +0200 Subject: [PATCH 04/11] Typo --- migration-guides/mongodb-atlas.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/migration-guides/mongodb-atlas.mdx b/migration-guides/mongodb-atlas.mdx index 1c884e54..674d09da 100644 --- a/migration-guides/mongodb-atlas.mdx +++ b/migration-guides/mongodb-atlas.mdx @@ -443,7 +443,7 @@ PowerSync supports "live queries" or "watch queries" which automatically refresh MongoDB Atlas Device Sync provides built-in writes/uploads to the backend MongoDB database. -PowerSync offers full custommizability regarding how writes are applied. This gives you control to apply your own business logic, data validations, authorization and conflict resolution logic. +PowerSync offers full customizability regarding how writes are applied. This gives you control to apply your own business logic, data validations, authorization and conflict resolution logic. There are two options: From 628f97be5ca540a72d19ef46dd5a7ea3d4c7daec Mon Sep 17 00:00:00 2001 From: benitav Date: Thu, 20 Feb 2025 12:14:46 +0200 Subject: [PATCH 05/11] Example scaffolding --- usage/use-case-examples/prioritized-sync.mdx | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index 741e5092..7e88cca7 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -113,10 +113,20 @@ Now, if another user adds new todos, it’s possible for the list count (synced PowerSync's client SDKs provide APIs to allow applications to track sync status at different priority levels. Developers can leverage these to ensure critical data is available before proceeding with UI updates or background processing. This includes: -## The `waitForFirstSync(priority: int)` method to allow waiting for a specific priority level. +## `waitForFirstSync(priority: int)`. -TODO: add example +Use this method to wait for a specific priority level to complete syncing. In this example we are rendering a lists component only once the user's lists (with priority 1) have completed syncing: -## The `SyncStatus.statusInPriority(priority: int)` property providing details on the last sync time per priority level. +```dart -TODO: add example + +``` + +## `SyncStatus.statusInPriority(priority: int)` + +This property provides details on the last sync time per priority level. + +```dart + + +``` From 8293a517942d7b6cf0c64fec50d1e8be579b9df9 Mon Sep 17 00:00:00 2001 From: benitav Date: Thu, 20 Feb 2025 12:24:10 +0200 Subject: [PATCH 06/11] Restructure the client-side example --- usage/use-case-examples/prioritized-sync.mdx | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index 7e88cca7..d6fc126f 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -113,20 +113,13 @@ Now, if another user adds new todos, it’s possible for the list count (synced PowerSync's client SDKs provide APIs to allow applications to track sync status at different priority levels. Developers can leverage these to ensure critical data is available before proceeding with UI updates or background processing. This includes: -## `waitForFirstSync(priority: int)`. +1. `waitForFirstSync(priority: int)`. When passing the optional `priority` parameter to this method, it will wait for specific priority level to complete syncing. +2. `SyncStatus.statusInPriority(priority: int)` This method provides details on the last sync state and time per priority level. -Use this method to wait for a specific priority level to complete syncing. In this example we are rendering a lists component only once the user's lists (with priority 1) have completed syncing: +## Example +Using the above we can render a lists component only once the user's lists (with priority 1) have completed syncing, else show a loading spinner: ```dart - - -``` - -## `SyncStatus.statusInPriority(priority: int)` - -This property provides details on the last sync time per priority level. - -```dart - +# todo ``` From 60c6e146492e8894ebee10e1994e5779ace7571c Mon Sep 17 00:00:00 2001 From: benitav Date: Wed, 26 Feb 2025 12:59:27 +0200 Subject: [PATCH 07/11] Add dart example --- usage/use-case-examples/prioritized-sync.mdx | 44 ++++++++++++++++++-- 1 file changed, 41 insertions(+), 3 deletions(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index d6fc126f..f990f880 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -114,12 +114,50 @@ Now, if another user adds new todos, it’s possible for the list count (synced PowerSync's client SDKs provide APIs to allow applications to track sync status at different priority levels. Developers can leverage these to ensure critical data is available before proceeding with UI updates or background processing. This includes: 1. `waitForFirstSync(priority: int)`. When passing the optional `priority` parameter to this method, it will wait for specific priority level to complete syncing. -2. `SyncStatus.statusInPriority(priority: int)` This method provides details on the last sync state and time per priority level. +2. `SyncStatus.priorityStatusEntries()` A list containing sync information for each priority that was seen by the PowerSync Service. +3. `SyncStatus.statusForPriority(priority: int)` This method takes a fixed priority and returns the sync state for that priority by looking it up in `priorityStatusEntries`. ## Example -Using the above we can render a lists component only once the user's lists (with priority 1) have completed syncing, else show a loading spinner: +Using the above we can render a lists component only once the user's lists (with priority 1) have completed syncing, else display a message indicating that the sync is still in progress: ```dart -# todo + // Define the priority level of the lists bucket + static final _listsPriority = BucketPriority(1); + + @override + Widget build(BuildContext context) { + // Use FutureBuilder to wait for the first sync of the specified priority to complete + return FutureBuilder( + future: db.waitForFirstSync(priority: _listsPriority), + builder: (context, snapshot) { + if (snapshot.connectionState == ConnectionState.done) { + // Use StreamBuilder to render the lists once the sync completes + return StreamBuilder( + stream: TodoList.watchListsWithStats(), + builder: (context, snapshot) { + if (snapshot.data case final todoLists?) { + return ListView( + padding: const EdgeInsets.symmetric(vertical: 8.0), + children: todoLists.map((list) { + return ListItemWidget(list: list); + }).toList(), + ); + } else { + return const CircularProgressIndicator(); + } + }, + ); + } else { + return const Text('Busy with sync...'); + } + }, + ); + } ``` + +Example implementations of prioritized sync are also available in the following apps: +- Dart: +- React Native: +- JavaScript/Web: +- Kotlin: \ No newline at end of file From 362d1e02a06ad46fbd1599d8e5133c953774ea84 Mon Sep 17 00:00:00 2001 From: benitav Date: Mon, 3 Mar 2025 16:41:21 +0200 Subject: [PATCH 08/11] Add example apps --- usage/use-case-examples/prioritized-sync.mdx | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index f990f880..6f439158 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -157,7 +157,10 @@ Using the above we can render a lists component only once the user's lists (with ``` Example implementations of prioritized sync are also available in the following apps: -- Dart: -- React Native: -- JavaScript/Web: -- Kotlin: \ No newline at end of file +- Flutter: [Supabase To-Do List](https://github.com/powersync-ja/powersync.dart/tree/main/demos/supabase-todolist) +- React Native: Coming soon. +- JavaScript/Web: Coming soon. +- Kotlin Multiplatform: + - [Supabase To-Do List (KMP)](https://github.com/powersync-ja/powersync-kotlin/blob/main/demos/supabase-todolist/shared/src/commonMain/kotlin/com/powersync/demos/App.kt#L46) + - [Supabase To-Do List (Android)](https://github.com/powersync-ja/powersync-kotlin/blob/main/demos/android-supabase-todolist/app/src/main/java/com/powersync/androidexample/screens/HomeScreen.kt#L69) +- Swift: Coming soon. \ No newline at end of file From 829d534b661d63c3fdb44f1289d7e3fbf7f1d86b Mon Sep 17 00:00:00 2001 From: benitav Date: Mon, 3 Mar 2025 17:06:31 +0200 Subject: [PATCH 09/11] Add some notes for this initial release --- usage/use-case-examples/prioritized-sync.mdx | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index 6f439158..9abea49a 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -7,6 +7,17 @@ description: "In some scenarios, you may want to sync tables using different pri PowerSync supports defining [Sync Bucket](/usage/sync-rules/organize-data-into-buckets) Priorities, which allows you to control the sync order for different data sets. This is particularly useful when certain data should be available sooner than others. + +**Availability** + +This feature is currently available in the [**Beta** channel](/resources/feature-status#cloud-edition) for Cloud instances, and was released in version **1.7.1** of the [PowerSync Service](https://hub.docker.com/r/journeyapps/powersync-service) for self-hosted deployments. + +It will be released to the **Stable** channel of the PowerSync Service in a few days. + +The new client-side APIs are available in our [Flutter SDK](/client-sdk-references/flutter) and [Kotlin Multiplatform SDK](/client-sdk-references/kotlin-multiplatform) and support in our other SDKs will follow soon. + + + # Why Use Sync Bucket Priorities? PowerSync's standard sync protocol ensures that: @@ -49,6 +60,10 @@ Note: - If multiple parameter queries specify different priorities for the same bucket, the highest priority (lowest number) is used. - Priorities must be static and cannot depend on row values within a parameter query. + +Your Sync Rules file in the PowerSync Dashboard may show a "must NOT have additional properties" error which can safely be ignored. Your Sync Rules should still pass validation. We will improve this error in a future release. + + # Example: Syncing Lists Before Todos Consider a scenario where you want to display lists immediately while loading todos in the background. This approach allows users to view and interact with lists right away without waiting for todos to sync. Here's how to configure sync priorities in your Sync Rules to achieve this: From 162780c65f218730cb24855db796871846d672a1 Mon Sep 17 00:00:00 2001 From: benitav Date: Mon, 3 Mar 2025 17:16:56 +0200 Subject: [PATCH 10/11] Remove old heading --- usage/use-case-examples/prioritized-sync.mdx | 2 -- 1 file changed, 2 deletions(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index 9abea49a..4b045301 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -115,8 +115,6 @@ When higher-priority buckets are synced, all inserts and updates within the buck Consider the following example: -Example: Todo List Syncing - Imagine a task management app where users create lists and todos. Some users have millions of todos. To improve first-load speed: - Lists are assigned Priority 1, syncing first to allow UI rendering. From 6cb53abf3297be993aed789b60207283bc8fdf1b Mon Sep 17 00:00:00 2001 From: benitav Date: Mon, 3 Mar 2025 17:23:31 +0200 Subject: [PATCH 11/11] Remove a note based on PR feedback --- usage/use-case-examples/prioritized-sync.mdx | 1 - 1 file changed, 1 deletion(-) diff --git a/usage/use-case-examples/prioritized-sync.mdx b/usage/use-case-examples/prioritized-sync.mdx index 4b045301..692a2362 100644 --- a/usage/use-case-examples/prioritized-sync.mdx +++ b/usage/use-case-examples/prioritized-sync.mdx @@ -57,7 +57,6 @@ bucket_definitions: ``` Note: -- If multiple parameter queries specify different priorities for the same bucket, the highest priority (lowest number) is used. - Priorities must be static and cannot depend on row values within a parameter query.