loadSubset fn return promise or true

Author: samwillis

packages/db/src/collection/subscription.ts

@@ -174,18 +174,18 @@ export class CollectionSubscription
 
     // Request the sync layer to load more data
     // don't await it, we will load the data into the collection when it comes in
-    const syncPromise = this.collection._sync.loadSubset({
+    const syncResult = this.collection._sync.loadSubset({
       where: stateOpts.where,
       subscription: this,
     })
 
-    // Track the promise if it exists
-    if (syncPromise) {
-      this.pendingLoadSubsetPromises.add(syncPromise)
+    // Track the promise if it's actually a promise (async work)
+    if (syncResult instanceof Promise) {
+      this.pendingLoadSubsetPromises.add(syncResult)
       this.setStatus(`loadingMore`)
 
-      syncPromise.finally(() => {
-        this.pendingLoadSubsetPromises.delete(syncPromise)
+      syncResult.finally(() => {
+        this.pendingLoadSubsetPromises.delete(syncResult)
         if (this.pendingLoadSubsetPromises.size === 0) {
           this.setStatus(`ready`)
         }
@@ -282,20 +282,20 @@ export class CollectionSubscription
 
     // Request the sync layer to load more data
     // don't await it, we will load the data into the collection when it comes in
-    const syncPromise = this.collection._sync.loadSubset({
+    const syncResult = this.collection._sync.loadSubset({
       where: whereWithValueFilter,
       limit,
       orderBy,
       subscription: this,
     })
 
-    // Track the promise if it exists
-    if (syncPromise) {
-      this.pendingLoadSubsetPromises.add(syncPromise)
+    // Track the promise if it's actually a promise (async work)
+    if (syncResult instanceof Promise) {
+      this.pendingLoadSubsetPromises.add(syncResult)
       this.setStatus(`loadingMore`)
 
-      syncPromise.finally(() => {
-        this.pendingLoadSubsetPromises.delete(syncPromise)
+      syncResult.finally(() => {
+        this.pendingLoadSubsetPromises.delete(syncResult)
         if (this.pendingLoadSubsetPromises.size === 0) {
           this.setStatus(`ready`)
         }

packages/db/src/collection/sync.ts

@@ -39,7 +39,7 @@ export class CollectionSyncManager<
   public preloadPromise: Promise<void> | null = null
   public syncCleanupFn: (() => void) | null = null
   public syncLoadSubsetFn:
-    | ((options: LoadSubsetOptions) => void | Promise<void>)
+    | ((options: LoadSubsetOptions) => true | Promise<void>)
     | null = null
 
   private pendingLoadSubsetPromises: Set<Promise<void>> = new Set()
@@ -302,27 +302,24 @@ export class CollectionSyncManager<
    * Requests the sync layer to load more data.
    * @param options Options to control what data is being loaded
    * @returns If data loading is asynchronous, this method returns a promise that resolves when the data is loaded.
-   *          If data loading is synchronous, the data is loaded when the method returns.
-   *          Returns undefined if no sync function is configured or if syncMode is 'eager'.
+   *          Returns true if no sync function is configured, if syncMode is 'eager', or if there is no work to do.
    */
-  public loadSubset(options: LoadSubsetOptions): Promise<void> | undefined {
+  public loadSubset(options: LoadSubsetOptions): Promise<void> | true {
     // Bypass loadSubset when syncMode is 'eager'
     if (this.syncMode === `eager`) {
-      return undefined
+      return true
     }
 
     if (this.syncLoadSubsetFn) {
       const result = this.syncLoadSubsetFn(options)
-
-      // If the result is void (synchronous), wrap in Promise.resolve()
-      const promise = result === undefined ? Promise.resolve() : result
-
-      // Track the promise
-      this.trackLoadPromise(promise)
-
-      return promise
+      // If the result is a promise, track it
+      if (result instanceof Promise) {
+        this.trackLoadPromise(result)
+        return result
+      }
     }
-    return undefined
+
+    return true
   }
 
   public cleanup(): void {

packages/db/src/types.ts

@@ -221,7 +221,7 @@ export type LoadSubsetOptions = {
   subscription?: Subscription
 }
 
-export type LoadSubsetFn = (options: LoadSubsetOptions) => void | Promise<void>
+export type LoadSubsetFn = (options: LoadSubsetOptions) => true | Promise<void>
 
 export type CleanupFn = () => void
 

packages/db/tests/collection.test.ts

@@ -1567,4 +1567,28 @@ describe(`Collection isLoadingMore property`, () => {
 
     expect(collection.isLoadingMore).toBe(false)
   })
+
+  it(`isLoadingMore stays false when loadSubset returns true (no work to do)`, () => {
+    const collection = createCollection<{ id: string; value: string }>({
+      id: `test`,
+      getKey: (item) => item.id,
+      syncMode: `on-demand`,
+      startSync: true,
+      sync: {
+        sync: ({ markReady }) => {
+          markReady()
+          return {
+            loadSubset: () => true, // No work to do
+          }
+        },
+      },
+    })
+
+    expect(collection.isLoadingMore).toBe(false)
+
+    // Call loadSubset - it should return true and not track any promise
+    const result = collection._sync.loadSubset({})
+    expect(result).toBe(true)
+    expect(collection.isLoadingMore).toBe(false)
+  })
 })