lazypock 0.1.5 → 0.1.6

package/README.md

@@ -180,6 +180,12 @@ The main client class.
 | `authStore` | `AuthStore` | auto-created | Explicit auth store instance |
 | `realtime` | `RealtimeService` | auto-created | Real-time service for WebSocket subscriptions |
 
+#### Auto-Cancellation Methods
+
+- `autoCancellation(enable)` — Globally enable/disable auto-cancellation of duplicated pending requests
+- `cancelRequest(requestKey)` — Abort a single pending request by key (default `HTTP_METHOD + path`)
+- `cancelAllRequests()` — Abort all pending requests
+
 #### Authentication Methods
 
 - `login(email, password, collection?)` — Login as superuser or auth collection user
@@ -291,6 +297,58 @@ interface RequestOptions {
 }
 ```
 
+## Auto Cancellation
+
+The SDK auto-cancels duplicated pending requests for you (PocketBase-compatible
+behaviour). When a new request is issued with the same request key as a
+still-pending request, the previous one is aborted — only the last request
+executes:
+
+```typescript
+// Only the last call will execute; the first two are auto-cancelled
+await client.collection('posts').getList(1, 20); // cancelled
+await client.collection('posts').getList(2, 20); // cancelled
+await client.collection('posts').getList(3, 20); // executed
+```
+
+By default the request key is `HTTP_METHOD + path` (e.g. `"GET /api/posts?page=1"`), so
+duplicate calls with identical URLs cancel each other. Cancelled requests reject
+with an `ApiError` whose `isAbort` is `true`:
+
+```typescript
+try {
+  await client.collection('posts').getList(1, 20);
+} catch (err) {
+  if (err instanceof ApiError && err.isAbort) {
+    // superseded by a newer request — safe to ignore
+  }
+}
+```
+
+#### Per-request control
+
+Pass `requestKey` in the request options to customize the key, or disable
+auto-cancellation for a specific request:
+
+```typescript
+await client.collection('posts').getList(1, 20, { requestKey: 'my-list' }); // cancelled
+await client.collection('posts').getList(1, 20, { requestKey: 'my-list' }); // executed
+
+await client.collection('posts').getList(1, 20, { requestKey: null });   // executed
+await client.collection('posts').getList(1, 20, { requestKey: null });   // executed
+```
+
+#### Global control
+
+```typescript
+// Disable auto-cancellation globally
+client.autoCancellation(false);
+
+// Manually cancel pending requests
+client.cancelRequest('GET /api/posts?page=1');
+client.cancelAllRequests();
+```
+
 ## Error Handling
 
 The SDK throws `ApiError` on non-2xx responses:

package/dist/index.cjs

@@ -25,6 +25,7 @@ __export(index_exports, {
   CollectionService: () => CollectionService,
   CollectionsService: () => CollectionsService,
   FilesService: () => FilesService,
+  HttpClient: () => HttpClient,
   LazypockClient: () => LazypockClient,
   RealtimeService: () => RealtimeService,
   TypedClient: () => TypedClient,
@@ -34,6 +35,8 @@ __export(index_exports, {
   fieldTypeScriptType: () => fieldTypeScriptType,
   generateTypes: () => generateTypes,
   getFileUrl: () => getFileUrl,
+  getScaleUrl: () => getScaleUrl,
+  getThumbUrl: () => getThumbUrl,
   schemaFieldType: () => schemaFieldType,
   wsUrlFromBaseUrl: () => wsUrlFromBaseUrl
 });
@@ -41,21 +44,33 @@ module.exports = __toCommonJS(index_exports);
 
 // src/types.ts
 var ApiError = class extends Error {
-  constructor(message, data, status) {
+  constructor(message, data, status, isAbort = false) {
     super(message);
     this.name = "ApiError";
     this.data = data;
     this.status = status;
+    this.isAbort = isAbort;
   }
 };
 
 // src/http.ts
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.message === "Aborted");
+}
 var HttpClient = class {
   /**
    * @param baseUrl The API base URL (e.g. `http://localhost:4000/api`). Trailing slash stripped.
    * @param authStore The auth store providing the token for Authorization headers.
    */
   constructor(baseUrl, authStore) {
+    /**
+     * Abort controllers for in-flight requests, keyed by their cancellation key
+     * (default `METHOD path`). A new request with the same key aborts the
+     * previous one — PocketBase-style auto-cancellation of duplicated requests.
+     */
+    this.cancelControllers = {};
+    /** Global toggle for the auto-cancellation behaviour (default: on). */
+    this.enableAutoCancellation = true;
     this.baseUrl = baseUrl.replace(/\/+$/, "");
     this.authStore = authStore;
     this.defaultFetch = globalThis.fetch.bind(globalThis);
@@ -92,20 +107,73 @@ var HttpClient = class {
       return null;
     }
   }
+  /**
+   * Globally enable or disable auto-cancellation of duplicated pending requests.
+   * Fluent — returns `this` for chaining.
+   */
+  autoCancellation(enable) {
+    this.enableAutoCancellation = !!enable;
+    return this;
+  }
+  /**
+   * Abort a pending request identified by its cancellation key
+   * (default `METHOD path`, e.g. `"GET /api/posts"`). No-op if not pending.
+   */
+  cancelRequest(requestKey) {
+    const controller = this.cancelControllers[requestKey];
+    if (controller) {
+      controller.abort();
+      delete this.cancelControllers[requestKey];
+    }
+    return this;
+  }
+  /** Abort all pending requests. */
+  cancelAllRequests() {
+    for (const key in this.cancelControllers) {
+      this.cancelControllers[key].abort();
+    }
+    this.cancelControllers = {};
+    return this;
+  }
   /**
    * Make an HTTP request with automatic auth token injection and optional auto-refresh.
    *
+   * Auto-cancellation: a request keyed by `options.requestKey` (default
+   * `METHOD path`) aborts any previous pending request with the same key,
+   * so only the last duplicate executes. Set `requestKey: null` or
+   * `autoCancel: false` to opt out per request.
+   *
    * @param method HTTP method.
    * @param path URL path (appended to baseUrl).
    * @param body JSON-serializable body, or FormData for file uploads.
    * @param options Optional request options.
    * @returns Parsed JSON response, or null for 204 No Content.
-   * @throws {ApiError} On non-2xx responses.
+   * @throws {ApiError} On non-2xx responses or when the request is aborted
+   * (aborted requests throw an `ApiError` with `isAbort === true`).
    */
   async request(method, path, body, options) {
     if (this.authStore.isExpired && this.authStore.collectionName) {
       await this.refreshAuth();
     }
+    let requestKey = options?.requestKey === void 0 ? options?.cancelKey ?? `${method} ${path}` : options.requestKey;
+    if (options?.autoCancel === false) requestKey = null;
+    let controller = null;
+    const externalSignal = options?.signal;
+    if (requestKey !== null) {
+      if (this.enableAutoCancellation) {
+        this.cancelRequest(requestKey);
+      }
+      controller = new AbortController();
+      this.cancelControllers[requestKey] = controller;
+      if (externalSignal?.aborted) {
+        controller.abort();
+      } else if (externalSignal) {
+        externalSignal.addEventListener("abort", () => controller?.abort(), {
+          once: true
+        });
+      }
+    }
+    const signal = controller?.signal ?? externalSignal;
     let url = this.baseUrl + path;
     if (options?.params) {
       const qs = new URLSearchParams(options.params).toString();
@@ -125,7 +193,7 @@ var HttpClient = class {
     const init = {
       method,
       headers,
-      signal: options?.signal
+      signal
     };
     if (body != null && method !== "GET" && method !== "DELETE") {
       if (body instanceof FormData) {
@@ -134,8 +202,25 @@ var HttpClient = class {
         init.body = JSON.stringify(body);
       }
     }
+    let res = null;
     const fetcher = options?.fetch ?? this.defaultFetch;
-    const res = await fetcher(url, init);
+    try {
+      res = await fetcher(url, init);
+    } catch (err) {
+      if (isAbortError(err)) {
+        throw new ApiError(
+          "The request was aborted (most likely auto-cancelled by a newer request with the same requestKey)",
+          {},
+          0,
+          true
+        );
+      }
+      throw err;
+    } finally {
+      if (requestKey !== null && this.cancelControllers[requestKey] === controller) {
+        delete this.cancelControllers[requestKey];
+      }
+    }
     if (res.status === 204) return null;
     let bodyText = "";
     let data = {};
@@ -361,17 +446,19 @@ var CollectionService = class {
    * @param options Query params (`filter`, `sort`, `expand`, `fields`) + request options.
    */
   getList(page = 1, perPage = 30, options) {
-    const { ...rest } = options ?? {};
+    const { requestKey, autoCancel, cancelKey, ...rest } = options ?? {};
     const qs = new URLSearchParams(
       Object.fromEntries(
-        Object.entries({ page: String(page), perPage: String(perPage), ...rest }).map(
-          ([k, v]) => [k, String(v)]
-        )
+        Object.entries({
+          page: String(page),
+          perPage: String(perPage),
+          ...rest
+        }).map(([k, v]) => [k, String(v)])
       )
     ).toString();
     return this.http.get(
       "/" + this.encodeId(this.collectionName) + "?" + qs,
-      options
+      { requestKey, autoCancel, cancelKey }
     );
   }
   /**
@@ -388,7 +475,11 @@ var CollectionService = class {
       const res = await this.getList(
         page,
         batch,
-        rest
+        {
+          // disable auto-cancellation across pages — each page request is unique
+          ...rest,
+          requestKey: null
+        }
       );
       if (!res || !res.items || res.items.length === 0) break;
       items.push(...res.items);
@@ -794,6 +885,12 @@ var RealtimeService = class {
 function getFileUrl(baseUrl, fileId) {
   return baseUrl.replace(/\/+$/, "") + "/files/" + encodeURIComponent(fileId);
 }
+function getThumbUrl(baseUrl, fileId, size) {
+  return baseUrl.replace(/\/+$/, "") + "/files/" + encodeURIComponent(fileId) + "/thumbs/" + encodeURIComponent(size);
+}
+function getScaleUrl(baseUrl, fileId, size) {
+  return baseUrl.replace(/\/+$/, "") + "/files/" + encodeURIComponent(fileId) + "/scale/" + encodeURIComponent(size);
+}
 var FilesService = class {
   constructor(http) {
     this.http = http;
@@ -825,6 +922,25 @@ var FilesService = class {
     );
     return data;
   }
+  /**
+   * List uploaded files (newest first), with optional filters.
+   *
+   * @param options Filters and pagination.
+   */
+  async list(options) {
+    const params = {};
+    if (options?.page !== void 0) params["page"] = String(options.page);
+    if (options?.perPage !== void 0) params["perPage"] = String(options.perPage);
+    if (options?.collectionName) params["collectionName"] = options.collectionName;
+    if (options?.fieldName) params["fieldName"] = options.fieldName;
+    if (options?.mime) params["mime"] = options.mime;
+    const data = await this.http.request("GET", "/files", void 0, { params });
+    return data ?? { items: [], page: 1, perPage: 50, total: 0 };
+  }
+  /**
+   * Fetch file metadata including URL.
+   * @param fileId The file ID.
+   */
   /**
    * Fetch file metadata including URL.
    * @param fileId The file ID.
@@ -1233,6 +1349,37 @@ var LazypockClient = class {
     const schemas = this.schemaByName ? [...this.schemaByName.values()] : [];
     return generateTypes(schemas, options);
   }
+  // ── Auto-cancellation (PocketBase `autoCancellation` parity) ──
+  /**
+   * Globally enable or disable auto-cancellation of duplicated pending requests.
+   *
+   * When enabled (default), a new request whose `requestKey` (default
+   * `HTTP_METHOD + path`) matches a still-pending request aborts the previous
+   * one — only the last duplicate executes.
+   *
+   * @example
+   * ```ts
+   * client.autoCancellation(false); // keep every request
+   * ```
+   */
+  autoCancellation(enable) {
+    this.http.autoCancellation(enable);
+    return this;
+  }
+  /**
+   * Abort a single pending request by its cancellation key
+   * (default `HTTP_METHOD + path`, e.g. `"GET /api/posts?page=1"`).
+   * The request rejects with an `ApiError` whose `isAbort` is `true`.
+   */
+  cancelRequest(requestKey) {
+    this.http.cancelRequest(requestKey);
+    return this;
+  }
+  /** Abort all pending requests. */
+  cancelAllRequests() {
+    this.http.cancelAllRequests();
+    return this;
+  }
   // ── Auth ──
   /** Check whether any superuser exists (for login vs setup screen routing). */
   async checkSuperuser() {
@@ -1362,6 +1509,7 @@ function createClient(options) {
   CollectionService,
   CollectionsService,
   FilesService,
+  HttpClient,
   LazypockClient,
   RealtimeService,
   TypedClient,
@@ -1371,6 +1519,8 @@ function createClient(options) {
   fieldTypeScriptType,
   generateTypes,
   getFileUrl,
+  getScaleUrl,
+  getThumbUrl,
   schemaFieldType,
   wsUrlFromBaseUrl
 });