lazypock 0.3.0 → 0.4.0

package/dist/index.d.cts

@@ -87,6 +87,17 @@ interface RequestOptions {
      * Alias of `requestKey` (PocketBase `$cancelKey` compat).
      */
     cancelKey?: string;
+    /**
+     * Coalesce concurrent identical requests (same `requestKey`) onto a single
+     * in-flight promise instead of aborting the earlier one.
+     *
+     * When enabled, a request arriving while another with the same key is still
+     * pending awaits the same result — no duplicate network request, and the
+     * caller of the first request never sees an abort rejection.
+     *
+     * @default false (auto-cancellation aborts the earlier duplicate)
+     */
+    singleFlight?: boolean;
 }
 declare class ApiError extends Error {
     readonly data: unknown;
@@ -320,6 +331,13 @@ declare class HttpClient {
      * previous one — PocketBase-style auto-cancellation of duplicated requests.
      */
     private 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).
+     */
+    private inflight;
     /** Global toggle for the auto-cancellation behaviour (default: on). */
     private enableAutoCancellation;
     /**
@@ -372,6 +390,11 @@ declare class HttpClient {
         entries: number;
     } | null;
     request<T = unknown>(method: Method, path: string, body?: unknown, options?: RequestOptions): Promise<T | null>;
+    /**
+     * 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.
+     */
+    private doRequest;
     /** Build a token-scoped cache key: `METHOD path|token-hash|params`. */
     private cacheKeyFor;
     /** Best-effort namespace (collection name) from a REST path. */

package/dist/index.d.ts

@@ -87,6 +87,17 @@ interface RequestOptions {
      * Alias of `requestKey` (PocketBase `$cancelKey` compat).
      */
     cancelKey?: string;
+    /**
+     * Coalesce concurrent identical requests (same `requestKey`) onto a single
+     * in-flight promise instead of aborting the earlier one.
+     *
+     * When enabled, a request arriving while another with the same key is still
+     * pending awaits the same result — no duplicate network request, and the
+     * caller of the first request never sees an abort rejection.
+     *
+     * @default false (auto-cancellation aborts the earlier duplicate)
+     */
+    singleFlight?: boolean;
 }
 declare class ApiError extends Error {
     readonly data: unknown;
@@ -320,6 +331,13 @@ declare class HttpClient {
      * previous one — PocketBase-style auto-cancellation of duplicated requests.
      */
     private 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).
+     */
+    private inflight;
     /** Global toggle for the auto-cancellation behaviour (default: on). */
     private enableAutoCancellation;
     /**
@@ -372,6 +390,11 @@ declare class HttpClient {
         entries: number;
     } | null;
     request<T = unknown>(method: Method, path: string, body?: unknown, options?: RequestOptions): Promise<T | null>;
+    /**
+     * 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.
+     */
+    private doRequest;
     /** Build a token-scoped cache key: `METHOD path|token-hash|params`. */
     private cacheKeyFor;
     /** Best-effort namespace (collection name) from a REST path. */

package/dist/index.global.js

@@ -268,6 +268,13 @@ var Lazypock = (() => {
        * 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 Lazypock = (() => {
       }
       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 Lazypock = (() => {
         }
       }
       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 Lazypock = (() => {
   };
 
   // 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 Lazypock = (() => {
         cache,
         ttl,
         invalidate,
+        singleFlight,
         params,
         ...queryParams
       } = options ?? {};
@@ -761,6 +831,7 @@ var Lazypock = (() => {
           cache,
           ttl,
           invalidate,
+          singleFlight,
           params
         }
       );
@@ -773,6 +844,7 @@ var Lazypock = (() => {
      */
     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 Lazypock = (() => {
           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 Lazypock = (() => {
     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;