lazypock 0.1.5 → 0.2.0

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() {
@@ -1276,10 +1423,17 @@ var LazypockClient = class {
         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 @@ var LazypockClient = class {
     }
     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);
     }
@@ -1362,6 +1520,7 @@ function createClient(options) {
   CollectionService,
   CollectionsService,
   FilesService,
+  HttpClient,
   LazypockClient,
   RealtimeService,
   TypedClient,
@@ -1371,6 +1530,8 @@ function createClient(options) {
   fieldTypeScriptType,
   generateTypes,
   getFileUrl,
+  getScaleUrl,
+  getThumbUrl,
   schemaFieldType,
   wsUrlFromBaseUrl
 });