lazypock 0.1.5 → 0.2.0

package/dist/index.global.js

@@ -26,6 +26,7 @@ var Lazypock = (() => {
     CollectionService: () => CollectionService,
     CollectionsService: () => CollectionsService,
     FilesService: () => FilesService,
+    HttpClient: () => HttpClient,
     LazypockClient: () => LazypockClient,
     RealtimeService: () => RealtimeService,
     TypedClient: () => TypedClient,
@@ -35,27 +36,41 @@ var Lazypock = (() => {
     fieldTypeScriptType: () => fieldTypeScriptType,
     generateTypes: () => generateTypes,
     getFileUrl: () => getFileUrl,
+    getScaleUrl: () => getScaleUrl,
+    getThumbUrl: () => getThumbUrl,
     schemaFieldType: () => schemaFieldType,
     wsUrlFromBaseUrl: () => wsUrlFromBaseUrl
   });
 
   // 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 Lazypock = (() => {
         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 Lazypock = (() => {
       const init = {
         method,
         headers,
-        signal: options?.signal
+        signal
       };
       if (body != null && method !== "GET" && method !== "DELETE") {
         if (body instanceof FormData) {
@@ -134,8 +202,25 @@ var Lazypock = (() => {
           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 Lazypock = (() => {
      * @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 Lazypock = (() => {
         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 Lazypock = (() => {
   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 Lazypock = (() => {
       );
       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 @@ ${opts.body}
       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() {
@@ -1276,10 +1423,17 @@ ${opts.body}
           this.authStore.set(data.token, data.record);
         }
       } else {
-        data = await this.http.post(
-          "/superusers/login",
-          { email, password }
-        );
+        try {
+          data = await this.http.post("/_superusers/auth-with-password", {
+            identity: email,
+            password
+          });
+        } catch {
+          data = null;
+        }
+        if (!data) {
+          data = await this.http.post("/superusers/login", { email, password });
+        }
         if (data) {
           this.authStore.setCollectionName(null);
           this.authStore.set(data.token, null);
@@ -1287,9 +1441,13 @@ ${opts.body}
       }
       return data;
     }
-    /** Fetch the current superuser profile and refresh the auth model. */
+    /**
+     * Fetch the current authenticated identity (superuser OR auth collection user).
+     * Uses `GET /api/me` (PocketBase parity) — works with both superuser tokens
+     * and auth collection user tokens.
+     */
     async me(options) {
-      const data = await this.http.get("/superusers/me", options);
+      const data = await this.http.get("/me", options);
       if (data) {
         this.authStore.set(this.authStore.token, data);
       }