lazypock 0.1.5 → 0.2.0

package/src/http.ts

@@ -8,11 +8,29 @@ import type { AuthStore } from "./auth";
  * Low-level HTTP client wrapping `fetch` with automatic auth token injection.
  * Only relies on `globalThis.fetch` — works in browser, React Native, and Node 18+.
  */
+/** Detect whether an unknown thrown value is an abort/`AbortError`-style error. */
+function isAbortError(err: unknown): boolean {
+	return (
+		err instanceof Error &&
+		(err.name === "AbortError" || err.message === "Aborted")
+	);
+}
+
 export class HttpClient {
 	private baseUrl: string;
 	private authStore: AuthStore;
 	private defaultFetch: typeof globalThis.fetch;
 
+	/**
+	 * 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.
+	 */
+	private cancelControllers: Record<string, AbortController> = {};
+
+	/** Global toggle for the auto-cancellation behaviour (default: on). */
+	private enableAutoCancellation = true;
+
 	/**
 	 * @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.
@@ -60,15 +78,52 @@ export class HttpClient {
 		}
 	}
 
+	/**
+	 * Globally enable or disable auto-cancellation of duplicated pending requests.
+	 * Fluent — returns `this` for chaining.
+	 */
+	autoCancellation(enable: boolean): this {
+		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: string): this {
+		const controller = this.cancelControllers[requestKey];
+		if (controller) {
+			controller.abort();
+			delete this.cancelControllers[requestKey];
+		}
+		return this;
+	}
+
+	/** Abort all pending requests. */
+	cancelAllRequests(): this {
+		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<T = unknown>(
 		method: Method,
@@ -81,6 +136,39 @@ export class HttpClient {
 			await this.refreshAuth();
 		}
 
+		// Resolve the auto-cancellation key (PocketBase `requestKey` semantics):
+		// - options.requestKey null  → disabled for this request
+		// - options.requestKey string → use it verbatim
+		// - options.autoCancel false → disabled (legacy compat)
+		// - options.cancelKey string → use it verbatim (legacy compat)
+		// - otherwise → default to `${method} ${path}`
+		let requestKey: string | null =
+			options?.requestKey === undefined
+				? (options?.cancelKey ?? `${method} ${path}`)
+				: options.requestKey;
+		if (options?.autoCancel === false) requestKey = null;
+
+		// Wire a fresh AbortController for this request, merging any caller signal.
+		// When auto-cancellation is enabled, the previous pending request sharing
+		// our key is aborted first (only the last duplicate executes).
+		let controller: AbortController | null = 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();
@@ -104,7 +192,7 @@ export class HttpClient {
 		const init: RequestInit = {
 			method,
 			headers,
-			signal: options?.signal,
+			signal,
 		};
 
 		if (body != null && method !== "GET" && method !== "DELETE") {
@@ -115,10 +203,34 @@ export class HttpClient {
 			}
 		}
 
+		let res: Response | null = null;
 		const fetcher = options?.fetch ?? this.defaultFetch;
-		const res = await fetcher(url, init);
+		try {
+			res = await fetcher(url, init);
+		} catch (err) {
+			// Aborted (auto-cancelled duplicate, manual cancel, or external signal)
+			// → normalized ApiError with isAbort === true, like PocketBase.
+			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 {
+			// The request has settled — no longer pending, so drop the controller
+			// unless a newer request already replaced it (same key).
+			if (
+				requestKey !== null &&
+				this.cancelControllers[requestKey] === controller
+			) {
+				delete this.cancelControllers[requestKey];
+			}
+		}
 
-		if (res.status === 204) return null;
+		if (res!.status === 204) return null;
 
 		// Safely parse JSON — some errored responses may have empty or non-JSON bodies
 		let bodyText = "";
@@ -132,12 +244,12 @@ export class HttpClient {
 			// Not JSON — keep data as empty object
 		}
 
-		if (!res.ok) {
+		if (!res!.ok) {
 			throw new ApiError(
-				(typeof data.message === "string" ? data.message : res.statusText) ||
-					`Request failed with status ${res.status}`,
+				(typeof data.message === "string" ? data.message : res!.statusText) ||
+					`Request failed with status ${res!.status}`,
 				data,
-				res.status,
+				res!.status,
 			);
 		}
 

package/src/index.ts

@@ -8,10 +8,13 @@ export {
 	// LazypockClient + options + everything it re-exports
 	AuthStore,
 	ApiError,
+	HttpClient,
 	RealtimeService,
 	wsUrlFromBaseUrl,
 	FilesService,
 	getFileUrl,
+	getThumbUrl,
+	getScaleUrl,
 	LazypockClient,
 	CollectionService,
 	CollectionsService,

package/src/lazypock.ts

@@ -21,7 +21,13 @@ import {
 	type RequestOptions,
 } from "./types";
 import { RealtimeService, wsUrlFromBaseUrl } from "./realtime";
-import { FilesService, getFileUrl, type FileRecord } from "./files";
+import {
+	FilesService,
+	getFileUrl,
+	getThumbUrl,
+	getScaleUrl,
+	type FileRecord,
+} from "./files";
 import { CollectionsService } from "./collections";
 import type { CollectionSchema, SchemaField } from "./schema";
 import { generateTypes, collectionTypeName } from "./codegen";
@@ -30,10 +36,13 @@ import { fieldTypeScriptType, fieldTypeKind, schemaFieldType } from "./typegen";
 export {
 	AuthStore,
 	ApiError,
+	HttpClient,
 	RealtimeService,
 	wsUrlFromBaseUrl,
 	FilesService,
 	getFileUrl,
+	getThumbUrl,
+	getScaleUrl,
 	CollectionService,
 	CollectionsService,
 	generateTypes,
@@ -171,6 +180,41 @@ export class LazypockClient {
 		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: boolean): this {
+		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: string): this {
+		this.http.cancelRequest(requestKey);
+		return this;
+	}
+
+	/** Abort all pending requests. */
+	cancelAllRequests(): this {
+		this.http.cancelAllRequests();
+		return this;
+	}
+
 	// ── Auth ──
 
 	/** Check whether any superuser exists (for login vs setup screen routing). */
@@ -230,11 +274,24 @@ export class LazypockClient {
 				this.authStore.setCollectionName(collection);
 				this.authStore.set(data.token, data.record as unknown as AuthModel);
 			}
-		} else {
-			data = await this.http.post<{ token: string } & Record<string, unknown>>(
-				"/superusers/login",
-				{ email, password },
-			);
+	} else {
+			// Superuser login — PocketBase parity: `_superusers` is an auth collection.
+			// Falls back to the legacy /superusers/login for older servers.
+			try {
+				data = await this.http.post<
+					{ token: string; record: ApiRecord } & Record<string, unknown>
+				>("/_superusers/auth-with-password", {
+					identity: email,
+					password,
+				});
+			} catch {
+				data = null;
+			}
+			if (!data) {
+				data = await this.http.post<
+					{ token: string } & Record<string, unknown>
+				>("/superusers/login", { email, password });
+			}
 			if (data) {
 				this.authStore.setCollectionName(null);
 				this.authStore.set(data.token, null);
@@ -243,9 +300,13 @@ export class LazypockClient {
 		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<T = ApiRecord>(options?: RequestOptions): Promise<T | null> {
-		const data = await this.http.get<T>("/superusers/me", options);
+		const data = await this.http.get<T>("/me", options);
 		if (data) {
 			// Update the auth model with fresh data
 			this.authStore.set(this.authStore.token, data as unknown as AuthModel);

package/src/types.ts

@@ -65,16 +65,45 @@ export interface RequestOptions {
 	signal?: AbortSignal;
 	/** Custom fetch implementation (for RN or test mocking) */
 	fetch?: typeof globalThis.fetch;
+	/**
+	 * Request identifier used by the auto-cancellation mechanism.
+	 *
+	 * Pending requests sharing the same key cancel each other — only the
+	 * last one is executed (PocketBase `requestKey` semantics).
+	 *
+	 * - `string` — use this exact key instead of the default `METHOD + path`.
+	 * - `null` — disable auto-cancellation for this request (never auto-cancelled).
+	 *
+	 * @default `${method} ${path}`
+	 */
+	requestKey?: string | null;
+	/**
+	 * Disable auto-cancellation for this request.
+	 * Alias of `requestKey: null` (PocketBase `$autoCancel: false` compat).
+	 */
+	autoCancel?: boolean;
+	/**
+	 * Custom request key used for auto-cancellation.
+	 * Alias of `requestKey` (PocketBase `$cancelKey` compat).
+	 */
+	cancelKey?: string;
 }
 
 export class ApiError extends Error {
 	readonly data: unknown;
 	readonly status: number;
+	/**
+	 * `true` when this error was caused by an aborted/cancelled request
+	 * (auto-cancelled duplicate, or manually via `cancelRequest()` /
+	 * `cancelAllRequests()` / an external AbortSignal).
+	 */
+	readonly isAbort: boolean;
 
-	constructor(message: string, data: unknown, status: number) {
+	constructor(message: string, data: unknown, status: number, isAbort = false) {
 		super(message);
 		this.name = "ApiError";
 		this.data = data;
 		this.status = status;
+		this.isAbort = isAbort;
 	}
 }