@runappsai/sdk 0.7.5 → 0.7.6

package/src/sync/engine.ts

@@ -176,6 +176,12 @@ interface StoreSchema {
 }
 
 const TOMBSTONE_TTL_MS = 30 * 24 * 3600 * 1000;
+/** Shards one push writes at a time. Each is a read-merge-write against
+ *  the files API, so the push is latency bound: done one by one, a few
+ *  hundred records over every shard took a minute and a half. */
+const PUSH_CONCURRENCY = 6;
+/** Shard copies kept, with their etags, so a write needs no read first. */
+const SHARD_CACHE_MAX = 256;
 const MAX_PUSH_DELAY_MS = 10_000;
 const BACKOFF_MIN_MS = 5_000;
 const BACKOFF_MAX_MS = 5 * 60_000;
@@ -208,6 +214,15 @@ export class SyncEngine {
   private readonly clock = new Clock();
   private readonly schemas = new Map<string, Map<string, StoreSchema>>();
   private readonly etags = new Map<string, string>();
+  /** The last copy of a shard this engine read or wrote, with its etag:
+   *  the next write merges into it and sends If-Match, and only a 412
+   *  (someone else wrote in between) costs a read. Oldest first. */
+  private readonly shardCache = new Map<string, { etag: string; shard: Shard }>();
+  /** Every shard path the last listing showed, and the prefixes that
+   *  listing covered: a path under a covered prefix that isn't listed
+   *  does not exist, and is created with If-None-Match, unread. */
+  private readonly listedPaths = new Set<string>();
+  private readonly listedPrefixes = new Set<string>();
   private readonly conns = new Map<string, Promise<IDBDatabase>>();
   private state: SyncState = { state: "off", pending: 0 };
   private paused = false;
@@ -576,6 +591,9 @@ export class SyncEngine {
       }
       await this.log.clearAll();
       this.etags.clear();
+      this.shardCache.clear();
+      this.listedPaths.clear();
+      this.listedPrefixes.clear();
       this.metaLoaded = null;
       await this.loadMeta();
     }
@@ -647,13 +665,23 @@ export class SyncEngine {
       if (!g) groups.set(k, (g = []));
       g.push(op);
     }
-    const done: number[] = [];
-    const etagUpdates: Record<string, unknown> = {};
+    const idsOf = (list: LoggedOp[]) => list.map((op) => op.id).filter((id): id is number => id !== undefined);
+    // Ops leave the log as soon as the shard holding them is written, so
+    // `pending` counts down while a long push runs, and a push cut short
+    // keeps only what really is still unsent.
+    const settle = async (ids: number[]) => {
+      if (ids.length === 0) return;
+      await this.log.remove(ids);
+      this.moved = true;
+      await this.refreshPending();
+    };
+    const limit = limiter(PUSH_CONCURRENCY);
+    const work: Promise<void>[] = [];
     for (const [, g] of groups) {
       const db = g[0]!.db;
       const store = g[0]!.store;
       if (this.storeExcluded(db, store)) {
-        for (const op of g) if (op.id !== undefined) done.push(op.id);
+        work.push(settle(idsOf(g)));
         continue;
       }
       // A clear drops everything written before it; ops after the last
@@ -675,19 +703,22 @@ export class SyncEngine {
         list.push(op);
       }
       const shards = clearedAt > 0 ? Array.from({ length: this.options.shards }, (_, i) => i) : Array.from(byShard.keys());
-      for (const n of shards) {
-        const path = this.shardPath(db, store, n);
-        const shardOps = byShard.get(n) ?? [];
-        const encoded = await Promise.all(shardOps.map((op) => this.encodeOp(op)));
-        const etag = await this.writeShard(path, clearedAt, encoded);
-        etagUpdates["etag:" + path] = etag;
-      }
-      for (const op of g) if (op.id !== undefined) done.push(op.id);
+      const written = shards.map((n) =>
+        limit(async () => {
+          const path = this.shardPath(db, store, n);
+          const shardOps = byShard.get(n) ?? [];
+          const encoded = await Promise.all(shardOps.map((op) => this.encodeOp(op)));
+          const etag = await this.writeShard(path, clearedAt, encoded);
+          await this.log.setMeta({ ["etag:" + path]: etag });
+          await settle(idsOf(shardOps));
+        }),
+      );
+      // The clear itself, and what it superseded, once every shard is.
+      work.push(Promise.all(written).then(() => settle(idsOf(g.slice(0, lastClear + 1)))));
     }
-    await this.log.setMeta(etagUpdates);
-    await this.log.remove(done);
-    if (done.length > 0) this.moved = true;
-    await this.refreshPending();
+    const results = await Promise.allSettled(work);
+    const failed = results.find((r): r is PromiseRejectedResult => r.status === "rejected");
+    if (failed) throw failed.reason;
   }
 
   private async encodeOp(op: LoggedOp): Promise<ShardOp> {
@@ -696,10 +727,17 @@ export class SyncEngine {
     return { kid: op.kid, rec: { k: op.key, v, t: op.ts }, changed: op.changed };
   }
 
-  /** Merge ops into one shard and write it; retried on a 412. */
+  /** Merge ops into one shard and write it; retried on a 412. The first
+   *  try starts from the cached copy, or from nothing when the last
+   *  listing showed no such shard — no read either way. */
   private async writeShard(path: string, clearedAt: number, ops: ShardOp[]): Promise<string> {
     for (let attempt = 0; attempt < 5; attempt++) {
-      const { shard, etag } = await this.readShard(path);
+      const cached = attempt === 0 ? this.shardCache.get(path) : undefined;
+      const { shard, etag } = cached
+        ? { shard: copyShard(cached.shard), etag: cached.etag }
+        : attempt === 0 && this.knownAbsent(path)
+          ? { shard: { v: 1 as const, cleared: 0, r: {} }, etag: undefined }
+          : await this.readShard(path);
       const now = this.clock.now();
       if (clearedAt > shard.cleared) {
         shard.cleared = clearedAt;
@@ -721,13 +759,40 @@ export class SyncEngine {
       if (r.status === "ok") {
         if (r.serverTime) this.clock.observe(r.serverTime, before, Date.now());
         this.etags.set(path, r.etag);
+        this.cacheShard(path, r.etag, shard);
+        this.listedPaths.add(path);
         return r.etag;
       }
       this.etags.delete(path);
+      this.shardCache.delete(path);
+      this.listedPaths.add(path); // it exists after all
     }
     throw new Error(`could not write ${path}: too many concurrent writers`);
   }
 
+  private cacheShard(path: string, etag: string, shard: Shard): void {
+    this.shardCache.delete(path);
+    this.shardCache.set(path, { etag, shard });
+    while (this.shardCache.size > SHARD_CACHE_MAX) {
+      const oldest = this.shardCache.keys().next().value;
+      if (oldest === undefined) break;
+      this.shardCache.delete(oldest);
+    }
+  }
+
+  private knownAbsent(path: string): boolean {
+    if (this.listedPaths.has(path)) return false;
+    for (const p of this.listedPrefixes) if (path.startsWith(p)) return true;
+    return false;
+  }
+
+  /** Remember what a listing of `prefix` showed (see listedPaths). */
+  private rememberListing(prefix: string, listing: { path: string }[]): void {
+    for (const p of [...this.listedPaths]) if (p.startsWith(prefix)) this.listedPaths.delete(p);
+    for (const e of listing) this.listedPaths.add(e.path);
+    this.listedPrefixes.add(prefix);
+  }
+
   private async storeBlob(blob: Blob): Promise<BlobRef> {
     const bytes = new Uint8Array(await blob.arrayBuffer());
     const digest = await crypto.subtle.digest("SHA-256", bytes);
@@ -740,14 +805,18 @@ export class SyncEngine {
   // ── Pull ─────────────────────────────────────────────────────────
 
   private async pull(): Promise<void> {
-    const listing = await this.deps.remote.list(this.options.prefix + "/");
+    const prefix = this.options.prefix + "/";
+    const listing = await this.deps.remote.list(prefix);
+    this.rememberListing(prefix, listing);
     await this.applyListing(listing);
   }
 
   private async pullDatabase(name: string): Promise<void> {
     if (!this.deps.userId()) return;
     await this.loadMeta();
-    const listing = await this.deps.remote.list(`${this.options.prefix}/${pathSeg(name)}/`);
+    const prefix = `${this.options.prefix}/${pathSeg(name)}/`;
+    const listing = await this.deps.remote.list(prefix);
+    this.rememberListing(prefix, listing);
     await this.applyListing(listing);
   }
 
@@ -775,6 +844,8 @@ export class SyncEngine {
       }
       const s = r.value as Partial<Shard> | null;
       const shard: Shard = { v: 1, cleared: s?.cleared ?? 0, r: s?.r ?? {} };
+      // Cached before applying: applyShard annotates the records.
+      this.cacheShard(entry.path, r.etag, copyShard(shard));
       await this.applyShard(db, store, shard, pending);
       this.etags.set(entry.path, r.etag);
       etagUpdates["etag:" + entry.path] = r.etag;
@@ -894,3 +965,32 @@ export class SyncEngine {
 }
 
 export { idbRequest };
+
+/** A shard is plain JSON: a deep copy is a JSON round trip. */
+function copyShard(shard: Shard): Shard {
+  return JSON.parse(JSON.stringify(shard)) as Shard;
+}
+
+/** Run at most `n` of the given tasks at once. */
+function limiter(n: number): <T>(task: () => Promise<T>) => Promise<T> {
+  let active = 0;
+  const queue: (() => void)[] = [];
+  const next = () => {
+    if (active >= n) return;
+    const start = queue.shift();
+    if (start) start();
+  };
+  return (task) =>
+    new Promise((resolve, reject) => {
+      queue.push(() => {
+        active++;
+        task()
+          .then(resolve, reject)
+          .finally(() => {
+            active--;
+            next();
+          });
+      });
+      next();
+    });
+}