@syncular/server 0.0.6-202 → 0.0.6-205

package/src/subscriptions/cache.ts

@@ -37,6 +37,11 @@ export interface ScopeCacheBackend {
   get<DB extends SyncCoreDb, Auth extends SyncServerAuth>(
     args: ScopeCacheContext<DB, Auth>
   ): Promise<ScopeValues | null>;
+  getOrResolve?<DB extends SyncCoreDb, Auth extends SyncServerAuth>(
+    args: ScopeCacheContext<DB, Auth> & {
+      load: () => Promise<ScopeValues | null>;
+    }
+  ): Promise<ScopeValues | null>;
   set<DB extends SyncCoreDb, Auth extends SyncServerAuth>(
     args: ScopeCacheSetContext<DB, Auth>
   ): Promise<void>;
@@ -117,6 +122,10 @@ export function createMemoryScopeCache(
     options?.maxEntries ?? DEFAULT_MEMORY_SCOPE_CACHE_MAX_ENTRIES;
   const now = options?.now ?? Date.now;
   const buckets = new WeakMap<object, Map<string, MemoryScopeCacheEntry>>();
+  const inflightByDb = new WeakMap<
+    object,
+    Map<string, Promise<ScopeValues | null>>
+  >();
 
   function getBucket(db: object): Map<string, MemoryScopeCacheEntry> {
     const existing = buckets.get(db);
@@ -128,6 +137,18 @@ export function createMemoryScopeCache(
     return created;
   }
 
+  function getInflightBucket(
+    db: object
+  ): Map<string, Promise<ScopeValues | null>> {
+    const existing = inflightByDb.get(db);
+    if (existing) {
+      return existing;
+    }
+    const created = new Map<string, Promise<ScopeValues | null>>();
+    inflightByDb.set(db, created);
+    return created;
+  }
+
   function evictOldest(bucket: Map<string, MemoryScopeCacheEntry>): void {
     while (bucket.size > maxEntries) {
       const oldestKey = bucket.keys().next().value;
@@ -155,6 +176,43 @@ export function createMemoryScopeCache(
 
       return cloneScopeValues(entry.scopes);
     },
+    async getOrResolve(args) {
+      const cached = await this.get(args);
+      if (cached !== null) {
+        return cached;
+      }
+
+      const inflightBucket = getInflightBucket(args.db);
+      const inflight = inflightBucket.get(args.cacheKey);
+      if (inflight) {
+        const resolved = await inflight;
+        return resolved ? cloneScopeValues(resolved) : null;
+      }
+
+      const pending = args
+        .load()
+        .then(async (resolved) => {
+          if (resolved !== null && ttlMs > 0) {
+            const bucket = getBucket(args.db);
+            if (bucket.has(args.cacheKey)) {
+              bucket.delete(args.cacheKey);
+            }
+            bucket.set(args.cacheKey, {
+              scopes: cloneScopeValues(resolved),
+              expiresAt: now() + ttlMs,
+            });
+            evictOldest(bucket);
+          }
+          return resolved;
+        })
+        .finally(() => {
+          inflightBucket.delete(args.cacheKey);
+        });
+
+      inflightBucket.set(args.cacheKey, pending);
+      const resolved = await pending;
+      return resolved ? cloneScopeValues(resolved) : null;
+    },
     async set(args) {
       const bucket = getBucket(args.db);
       if (ttlMs <= 0) {

package/src/subscriptions/resolve.test.ts

@@ -7,7 +7,11 @@ import {
   createServerHandlerCollection,
 } from '../handlers';
 import type { SyncCoreDb } from '../schema';
-import { createDatabaseScopeCache, createDefaultScopeCacheKey } from './cache';
+import {
+  createDatabaseScopeCache,
+  createDefaultScopeCacheKey,
+  createMemoryScopeCache,
+} from './cache';
 import { resolveEffectiveScopesForSubscriptions } from './resolve';
 
 interface TasksTable {
@@ -145,6 +149,72 @@ describe('resolveEffectiveScopesForSubscriptions cache behavior', () => {
     expect(resolved.every((entry) => entry.status === 'active')).toBe(true);
   });
 
+  it('dedupes concurrent resolveScopes calls through shared memory cache', async () => {
+    let resolveCalls = 0;
+    let releaseLoad: (() => void) | null = null;
+    const loadReleased = new Promise<void>((resolve) => {
+      releaseLoad = resolve;
+    });
+    let firstLoadStarted = false;
+    let markFirstLoadStarted: (() => void) | null = null;
+    const firstLoadStartedPromise = new Promise<void>((resolve) => {
+      markFirstLoadStarted = resolve;
+    });
+
+    const handler = createServerHandler<TestDb, ClientDb, 'tasks'>({
+      table: 'tasks',
+      scopes: ['user:{user_id}'],
+      resolveScopes: async (ctx) => {
+        resolveCalls += 1;
+        if (!firstLoadStarted) {
+          firstLoadStarted = true;
+          if (!markFirstLoadStarted) {
+            throw new Error('Missing first-load start resolver');
+          }
+          markFirstLoadStarted();
+          await loadReleased;
+        }
+        return { user_id: [ctx.actorId] };
+      },
+    });
+    const handlers = createServerHandlerCollection<TestDb>([handler]);
+    const scopeCache = createMemoryScopeCache();
+
+    const firstResolve = resolveEffectiveScopesForSubscriptions({
+      db,
+      auth: { actorId: 'u1' },
+      handlers,
+      scopeCache,
+      subscriptions: [
+        { id: 'sub-1', table: 'tasks', scopes: { user_id: 'u1' }, cursor: -1 },
+      ],
+    });
+    await firstLoadStartedPromise;
+    const secondResolve = resolveEffectiveScopesForSubscriptions({
+      db,
+      auth: { actorId: 'u1' },
+      handlers,
+      scopeCache,
+      subscriptions: [
+        { id: 'sub-2', table: 'tasks', scopes: { user_id: 'u1' }, cursor: -1 },
+      ],
+    });
+
+    if (!releaseLoad) {
+      throw new Error('Missing load-release resolver');
+    }
+    releaseLoad();
+
+    const [firstResult, secondResult] = await Promise.all([
+      firstResolve,
+      secondResolve,
+    ]);
+
+    expect(resolveCalls).toBe(1);
+    expect(firstResult[0]?.status).toBe('active');
+    expect(secondResult[0]?.status).toBe('active');
+  });
+
   it('roundtrips values through database scope cache', async () => {
     const scopeCache = createDatabaseScopeCache();
     const auth = { actorId: 'u1', partitionId: 'tenant-1' };

package/src/subscriptions/resolve.ts

@@ -177,72 +177,99 @@ export async function resolveEffectiveScopesForSubscriptions<
     if (requestScopeCache.has(scopeCacheKey)) {
       allowed = requestScopeCache.get(scopeCacheKey) ?? null;
     } else {
-      allowed = null;
-      let sharedCacheHit = false;
+      let resolveFailed = false;
 
-      if (args.scopeCache) {
+      const loadAllowedScopes = async (): Promise<ScopeValues> => {
         try {
-          const cachedAllowed = await args.scopeCache.get({
+          return await handler.resolveScopes({
             db: args.db,
+            actorId: args.auth.actorId,
             auth: args.auth,
-            table: sub.table,
-            cacheKey: scopeCacheKey,
           });
-          if (cachedAllowed !== null) {
-            allowed = cachedAllowed;
-            sharedCacheHit = true;
-          }
-        } catch (cacheErr) {
+        } catch (resolveErr) {
+          resolveFailed = true;
           console.error(
-            `[scopeCache.get] Failed for table ${sub.table}, subscription ${sub.id}:`,
-            cacheErr
+            `[resolveScopes] Failed for table ${sub.table}, subscription ${sub.id}:`,
+            resolveErr
           );
+          throw resolveErr;
         }
-      }
+      };
 
-      if (!sharedCacheHit) {
+      if (args.scopeCache?.getOrResolve) {
         try {
-          allowed = await handler.resolveScopes({
+          allowed = await args.scopeCache.getOrResolve({
             db: args.db,
-            actorId: args.auth.actorId,
             auth: args.auth,
-          });
-        } catch (resolveErr) {
-          // Scope resolution failed - mark subscription as revoked
-          // rather than failing the entire pull
-          console.error(
-            `[resolveScopes] Failed for table ${sub.table}, subscription ${sub.id}:`,
-            resolveErr
-          );
-          requestScopeCache.set(scopeCacheKey, null);
-          out.push({
-            id: sub.id,
             table: sub.table,
-            scopes: {},
-            params: sub.params,
-            cursor: sub.cursor,
-            bootstrapState: sub.bootstrapState ?? null,
-            status: 'revoked',
+            cacheKey: scopeCacheKey,
+            load: loadAllowedScopes,
           });
-          continue;
+        } catch {
+          allowed = null;
         }
+      } else {
+        allowed = null;
+        let sharedCacheHit = false;
 
-        if (args.scopeCache && allowed !== null) {
+        if (args.scopeCache) {
           try {
-            await args.scopeCache.set({
+            const cachedAllowed = await args.scopeCache.get({
               db: args.db,
               auth: args.auth,
               table: sub.table,
               cacheKey: scopeCacheKey,
-              scopes: allowed,
             });
+            if (cachedAllowed !== null) {
+              allowed = cachedAllowed;
+              sharedCacheHit = true;
+            }
           } catch (cacheErr) {
             console.error(
-              `[scopeCache.set] Failed for table ${sub.table}, subscription ${sub.id}:`,
+              `[scopeCache.get] Failed for table ${sub.table}, subscription ${sub.id}:`,
               cacheErr
             );
           }
         }
+
+        if (!sharedCacheHit) {
+          try {
+            allowed = await loadAllowedScopes();
+          } catch {
+            allowed = null;
+          }
+
+          if (args.scopeCache && allowed !== null) {
+            try {
+              await args.scopeCache.set({
+                db: args.db,
+                auth: args.auth,
+                table: sub.table,
+                cacheKey: scopeCacheKey,
+                scopes: allowed,
+              });
+            } catch (cacheErr) {
+              console.error(
+                `[scopeCache.set] Failed for table ${sub.table}, subscription ${sub.id}:`,
+                cacheErr
+              );
+            }
+          }
+        }
+      }
+
+      if (resolveFailed) {
+        requestScopeCache.set(scopeCacheKey, null);
+        out.push({
+          id: sub.id,
+          table: sub.table,
+          scopes: {},
+          params: sub.params,
+          cursor: sub.cursor,
+          bootstrapState: sub.bootstrapState ?? null,
+          status: 'revoked',
+        });
+        continue;
       }
 
       requestScopeCache.set(scopeCacheKey, allowed);