lazypock 0.1.3 → 0.1.6

package/dist/index.js

@@ -4,25 +4,37 @@ import {
   fieldTypeScriptType,
   generateTypes,
   schemaFieldType
-} from "./chunk-3MZJ5HCD.js";
+} from "./chunk-Y6PMBL2S.js";
 
 // 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);
@@ -59,20 +71,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();
@@ -92,7 +157,7 @@ var HttpClient = class {
     const init = {
       method,
       headers,
-      signal: options?.signal
+      signal
     };
     if (body != null && method !== "GET" && method !== "DELETE") {
       if (body instanceof FormData) {
@@ -101,8 +166,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 = {};
@@ -321,17 +403,68 @@ var CollectionService = class {
     return encodeURIComponent(id);
   }
   /**
-   * List records with optional filter/sort/pagination.
-   * @param params Query parameters including `filter`, `sort`, `page`, `perPage`, `expand`.
-   * @param options Optional request options.
+   * Fetch a paginated list of records (PocketBase `getList`).
+   *
+   * @param page Page number (default 1).
+   * @param perPage Records per page (default 30).
+   * @param options Query params (`filter`, `sort`, `expand`, `fields`) + request options.
    */
-  list(params, options) {
-    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+  getList(page = 1, perPage = 30, 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)])
+      )
+    ).toString();
     return this.http.get(
-      "/" + this.encodeId(this.collectionName) + qs,
-      options
+      "/" + this.encodeId(this.collectionName) + "?" + qs,
+      { requestKey, autoCancel, cancelKey }
     );
   }
+  /**
+   * Fetch all records at once (auto-paginates). Mirrors PocketBase's
+   * `pb.collection(name).getFullList()`.
+   *
+   * @param options Query params (`sort`, `filter`, `batch`, etc.) + request options.
+   */
+  async getFullList(options) {
+    const { batch = 1e3, ...rest } = options ?? {};
+    const items = [];
+    let page = 1;
+    for (; ; ) {
+      const res = await this.getList(
+        page,
+        batch,
+        {
+          // 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);
+      if (page >= (res.totalPages ?? page)) break;
+      page += 1;
+    }
+    return items;
+  }
+  /**
+   * Fetch the first record matching a filter (PocketBase `getFirstListItem`).
+   *
+   * @param filter Filter expression (e.g. `title = 'x'`).
+   * @param options Optional request options.
+   */
+  async getFirstListItem(filter, options) {
+    const res = await this.getList(1, 1, {
+      ...options,
+      filter
+    });
+    return res?.items?.[0] ?? null;
+  }
   /**
    * Get a single record by ID.
    * @param id Record ID.
@@ -716,6 +849,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;
@@ -747,6 +886,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.
@@ -776,6 +934,135 @@ var FilesService = class {
   }
 };
 
+// src/collections.ts
+var REGISTRY_TOPIC = "collections";
+var CollectionsService = class {
+  /** @internal */
+  constructor(http, realtime) {
+    this.http = http;
+    this.realtime = realtime;
+  }
+  /**
+   * Fetch a paginated list of collections (admin).
+   *
+   * @param params Optional query params (`page`, `perPage`, `filter`, `sort`).
+   * @param options Optional request options.
+   */
+  async getList(params, options) {
+    const qs = params ? "?" + new URLSearchParams(
+      Object.fromEntries(
+        Object.entries(params).map(([k, v]) => [k, String(v)])
+      )
+    ).toString() : "";
+    return this.http?.get("/collections" + qs, options) ?? null;
+  }
+  /**
+   * Fetch all collections at once (auto-paginates). Mirrors PocketBase's
+   * `pb.collections.getFullList()` — defaults to listing everything.
+   *
+   * @param options Query params (`sort`, `batch`, etc.) or request options.
+   */
+  async getFullList(options) {
+    if (!this.http) return [];
+    const { batch = 1e3, ...rest } = options ?? {};
+    const items = [];
+    let page = 1;
+    for (; ; ) {
+      const res = await this.getList({
+        ...rest,
+        page,
+        perPage: batch
+      });
+      if (!res || !res.items || res.items.length === 0) break;
+      items.push(...res.items);
+      if (page >= (res.totalPages ?? page)) break;
+      page += 1;
+    }
+    return items;
+  }
+  /**
+   * Get a single collection by ID or name (admin).
+   *
+   * @param id Collection ID or name.
+   * @param options Optional request options.
+   */
+  async getOne(id, options) {
+    return this.http?.get("/collections/" + encodeURIComponent(id), options) ?? null;
+  }
+  /**
+   * Create a new collection (admin).
+   *
+   * @param data Collection definition (name, type, fields, options, rules, etc.).
+   * @param options Optional request options.
+   */
+  async create(data, options) {
+    return this.http?.post("/collections", data, options) ?? null;
+  }
+  /**
+   * Update an existing collection (admin).
+   *
+   * @param id Collection ID or name.
+   * @param data Updated collection fields.
+   * @param options Optional request options.
+   */
+  async update(id, data, options) {
+    return this.http?.patch(
+      "/collections/" + encodeURIComponent(id),
+      data,
+      options
+    ) ?? null;
+  }
+  /**
+   * Delete a collection (admin).
+   *
+   * @param id Collection ID or name.
+   * @param options Optional request options.
+   */
+  async delete(id, options) {
+    const res = this.http?.delete(
+      "/collections/" + encodeURIComponent(id),
+      options
+    );
+    return res == null ? false : true;
+  }
+  /**
+   * Subscribe to collection registry changes.
+   *
+   * @param callback Received on every collection create/update/delete.
+   * @returns A function that unsubscribes this callback.
+   */
+  subscribe(callback) {
+    if (!this.realtime) {
+      console.warn("[lazypock] No realtime service configured.");
+      return () => {
+      };
+    }
+    const handler = (raw) => {
+      callback({
+        action: normalizeAction2(raw.event),
+        collection: raw.payload ?? {},
+        topic: raw.topic
+      });
+    };
+    this.realtime.ensureConnected();
+    this.realtime.subscribe(REGISTRY_TOPIC, handler);
+    return () => this.realtime?.unsubscribe(REGISTRY_TOPIC, handler);
+  }
+  /**
+   * Unsubscribe all callbacks from the registry channel.
+   */
+  unsubscribe() {
+    this.realtime?.unsubscribe(REGISTRY_TOPIC);
+  }
+};
+function normalizeAction2(event) {
+  const e = event.toLowerCase();
+  if (e === "create") return "create";
+  if (e === "update") return "update";
+  if (e === "delete") return "delete";
+  return "update";
+}
+
 // src/lazypock.ts
 var LazypockClient = class {
   /**
@@ -792,6 +1079,7 @@ var LazypockClient = class {
       this.realtime.setUrl(wsUrlFromBaseUrl(baseUrl));
     }
     this.files = new FilesService(this.http);
+    this.collections = new CollectionsService(this.http, this.realtime);
     if (options.types?.schemas) {
       this.schemaByName = new Map(
         options.types.schemas.map((s) => [s.name, s])
@@ -841,6 +1129,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() {
@@ -952,129 +1271,6 @@ var LazypockClient = class {
   health(options) {
     return this.http.get("/health", options);
   }
-  // ── Collection Management (admin) ──
-  /**
-   * List all collections (admin).
-   * @param q URL query string (e.g. `page=1&perPage=200`).
-   * @param options Optional request options.
-   */
-  listCollections(q, options) {
-    return this.http.get(
-      "/collections" + (q ? "?" + q : ""),
-      options
-    );
-  }
-  /**
-   * Get a single collection by ID or name.
-   * @param id Collection ID or name.
-   * @param options Optional request options.
-   */
-  getCollection(id, options) {
-    return this.http.get(
-      "/collections/" + encodeURIComponent(id),
-      options
-    );
-  }
-  /**
-   * Create a new collection (admin).
-   * @param data Collection definition (name, type, fields, options, rules, etc.).
-   * @param options Optional request options.
-   */
-  createCollection(data, options) {
-    return this.http.post("/collections", data, options);
-  }
-  /**
-   * Update an existing collection (admin).
-   * @param id Collection ID or name.
-   * @param data Updated collection fields.
-   * @param options Optional request options.
-   */
-  updateCollection(id, data, options) {
-    return this.http.patch(
-      "/collections/" + encodeURIComponent(id),
-      data,
-      options
-    );
-  }
-  /**
-   * Delete a collection (admin).
-   * @param id Collection ID or name.
-   * @param options Optional request options.
-   */
-  deleteCollection(id, options) {
-    return this.http.delete("/collections/" + encodeURIComponent(id), options);
-  }
-  // ── Records (dynamic collection) ──
-  /**
-   * List records from a dynamic collection with optional filter/sort/pagination.
-   *
-   * @param coll Collection name.
-   * @param params Query parameters including:
-   *   - `filter` — PocketBase filter syntax (e.g. `title~'hello' && published=true`)
-   *   - `sort` — Comma-separated, `-` prefix for DESC (e.g. `-created,title`)
-   *   - `page` — Page number (default: 1)
-   *   - `perPage` — Items per page (default: 30, max: 200)
-   *   - `expand` — Comma-separated relation fields (e.g. `author,category`)
-   * @param options Optional request options.
-   */
-  listRecords(coll, params, options) {
-    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
-    return this.http.get(
-      "/" + encodeURIComponent(coll) + qs,
-      options
-    );
-  }
-  /**
-   * Get a single record by ID.
-   * @param coll Collection name.
-   * @param id Record ID.
-   * @param options Optional request options.
-   */
-  getRecord(coll, id, options) {
-    return this.http.get(
-      "/" + encodeURIComponent(coll) + "/" + encodeURIComponent(id),
-      options
-    );
-  }
-  /**
-   * Create a record in a dynamic collection.
-   * @param coll Collection name.
-   * @param data Record fields.
-   * @param options Optional request options.
-   */
-  createRecord(coll, data, options) {
-    return this.http.post(
-      "/" + encodeURIComponent(coll),
-      data,
-      options
-    );
-  }
-  /**
-   * Update a record in a dynamic collection.
-   * @param coll Collection name.
-   * @param id Record ID.
-   * @param data Updated record fields.
-   * @param options Optional request options.
-   */
-  updateRecord(coll, id, data, options) {
-    return this.http.patch(
-      "/" + encodeURIComponent(coll) + "/" + encodeURIComponent(id),
-      data,
-      options
-    );
-  }
-  /**
-   * Delete a record from a dynamic collection.
-   * @param coll Collection name.
-   * @param id Record ID.
-   * @param options Optional request options.
-   */
-  deleteRecord(coll, id, options) {
-    return this.http.delete(
-      "/" + encodeURIComponent(coll) + "/" + encodeURIComponent(id),
-      options
-    );
-  }
 };
 
 // src/client.ts
@@ -1090,7 +1286,9 @@ export {
   ApiError,
   AuthStore,
   CollectionService,
+  CollectionsService,
   FilesService,
+  HttpClient,
   LazypockClient,
   RealtimeService,
   TypedClient,
@@ -1100,6 +1298,8 @@ export {
   fieldTypeScriptType,
   generateTypes,
   getFileUrl,
+  getScaleUrl,
+  getThumbUrl,
   schemaFieldType,
   wsUrlFromBaseUrl
 };