lazypock 0.3.0 → 0.4.0

package/README.md

@@ -358,6 +358,34 @@ client.cancelRequest('GET /api/posts?page=1');
 client.cancelAllRequests();
 ```
 
+#### Single-flight dedup (`getFullList`)
+
+`getFullList()` (and `collections.getFullList()`) are **single-flight**: concurrent
+calls with the same effective options share one in-flight request instead of
+firing duplicates. This means the common pattern below results in **one**
+network request, and **both** callers resolve with the same data — no abort
+rejection:
+
+```typescript
+const [a, b] = await Promise.all([
+  client.collection('posts').getFullList(),
+  client.collection('posts').getFullList(),
+]);
+// one GET fired; a === b
+```
+
+Calls with **different** options (e.g. different `sort`/`filter`) are still
+distinct requests. Multi-page fetches continue to work normally — each page
+request is unique (page number is part of the URL), so pages never cancel each
+other.
+
+The underlying `singleFlight` option is also available on any request when you
+want to coalesce concurrent identical calls yourself:
+
+```typescript
+await client.collection('posts').getList(1, 20, { singleFlight: true });
+```
+
 ## Query Cache
 
 Lazypock has a built-in query cache for **GET** requests — disabled by default.

package/dist/index.cjs

@@ -268,6 +268,13 @@ var HttpClient = class {
      * previous one — PocketBase-style auto-cancellation of duplicated requests.
      */
     this.cancelControllers = {};
+    /**
+     * In-flight request promises, keyed by cancellation key. When auto-cancellation
+     * would abort a pending duplicate, the newer request instead awaits the same
+     * promise — single-flight coalescing (no duplicate network request, no
+     * spurious abort rejection for the caller).
+     */
+    this.inflight = {};
     /** Global toggle for the auto-cancellation behaviour (default: on). */
     this.enableAutoCancellation = true;
     this.baseUrl = baseUrl.replace(/\/+$/, "");
@@ -383,6 +390,12 @@ var HttpClient = class {
     }
     let requestKey = options?.requestKey === void 0 ? options?.cancelKey ?? `${method} ${path}` : options.requestKey;
     if (options?.autoCancel === false) requestKey = null;
+    if (options?.singleFlight && requestKey !== null) {
+      const pending = this.inflight[requestKey];
+      if (pending !== void 0) {
+        return pending;
+      }
+    }
     let controller = null;
     const externalSignal = options?.signal;
     if (requestKey !== null) {
@@ -400,6 +413,38 @@ var HttpClient = class {
       }
     }
     const signal = controller?.signal ?? externalSignal;
+    const perform = async () => {
+      try {
+        return await this.doRequest(
+          method,
+          path,
+          body,
+          options,
+          signal,
+          requestKey,
+          controller,
+          cacheKey,
+          cacheDirective
+        );
+      } finally {
+        if (requestKey !== null) {
+          if (this.inflight[requestKey] === promise) {
+            delete this.inflight[requestKey];
+          }
+        }
+      }
+    };
+    const promise = perform();
+    if (requestKey !== null) {
+      this.inflight[requestKey] = promise;
+    }
+    return promise;
+  }
+  /**
+   * Execute the actual HTTP request (fetch + parse + cache). Called by {@link request}
+   * as the inner in-flight unit so single-flight callers can reuse the promise.
+   */
+  async doRequest(method, path, body, options, signal, requestKey, controller, cacheKey, cacheDirective) {
     let url = this.baseUrl + path;
     if (options?.params) {
       const qs = new URLSearchParams(options.params).toString();
@@ -696,6 +741,30 @@ var memoryStorage = {
 };
 
 // src/collection.ts
+function stableStringify(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const sort = (v) => {
+    if (Array.isArray(v)) return v.map(sort);
+    if (v && typeof v === "object") {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+      const out = {};
+      for (const k of Object.keys(v).sort()) {
+        if (k === "requestKey" || k === "singleFlight" || k === "fetch" || k === "signal") {
+          continue;
+        }
+        out[k] = sort(v[k]);
+      }
+      return out;
+    }
+    return v;
+  };
+  try {
+    return JSON.stringify(sort(value));
+  } catch {
+    return String(value);
+  }
+}
 function normalizeAction(event, rawAction) {
   if (typeof rawAction === "string") {
     const a = rawAction.toLowerCase();
@@ -737,6 +806,7 @@ var CollectionService = class {
       cache,
       ttl,
       invalidate,
+      singleFlight,
       params,
       ...queryParams
     } = options ?? {};
@@ -761,6 +831,7 @@ var CollectionService = class {
         cache,
         ttl,
         invalidate,
+        singleFlight,
         params
       }
     );
@@ -773,6 +844,7 @@ var CollectionService = class {
    */
   async getFullList(options) {
     const { batch = 1e3, ...rest } = options ?? {};
+    const effectiveKey = typeof rest.requestKey === "string" ? rest.requestKey : `getFullList:${this.collectionName}:${stableStringify(rest)}`;
     const items = [];
     let page = 1;
     for (; ; ) {
@@ -780,9 +852,9 @@ var CollectionService = class {
         page,
         batch,
         {
-          // disable auto-cancellation across pages — each page request is unique
           ...rest,
-          requestKey: null
+          requestKey: effectiveKey,
+          singleFlight: true
         }
       );
       if (!res || !res.items || res.items.length === 0) break;
@@ -1305,14 +1377,40 @@ var CollectionsService = class {
   async getFullList(options) {
     if (!this.http) return [];
     const { batch = 1e3, ...rest } = options ?? {};
+    const {
+      requestKey: reqKey,
+      singleFlight: _singleFlight,
+      fetch: fetchFn,
+      headers: hdrs,
+      signal: sig,
+      cache: cacheOpt,
+      ttl: ttlOpt,
+      invalidate: inval,
+      params: passthroughParams,
+      ...queryParams
+    } = rest;
+    const effectiveKey = typeof reqKey === "string" ? reqKey : `getFullList:collections:${stableStringify(rest)}`;
     const items = [];
     let page = 1;
     for (; ; ) {
-      const res = await this.getList({
-        ...rest,
-        page,
-        perPage: batch
-      });
+      const res = await this.getList(
+        {
+          ...queryParams,
+          ...passthroughParams ?? {},
+          page,
+          perPage: batch
+        },
+        {
+          requestKey: effectiveKey,
+          singleFlight: true,
+          ...fetchFn ? { fetch: fetchFn } : {},
+          ...hdrs ? { headers: hdrs } : {},
+          ...sig ? { signal: sig } : {},
+          ...cacheOpt !== void 0 ? { cache: cacheOpt } : {},
+          ...ttlOpt !== void 0 ? { ttl: ttlOpt } : {},
+          ...inval ? { invalidate: inval } : {}
+        }
+      );
       if (!res || !res.items || res.items.length === 0) break;
       items.push(...res.items);
       if (page >= (res.totalPages ?? page)) break;