lazypock 0.1.2 → 0.1.5

package/src/collections.ts

@@ -0,0 +1,200 @@
+// ── Collections Service ─────────────────────────────────
+// Registry-level service for collections (CRUD + realtime registry events),
+// mirroring PocketBase's `pb.collections` service.
+//
+// Get an instance via {@link LazypockClient.collections}.
+//
+// This is distinct from `CollectionService` (single collection record
+// events) — it operates on the *collections* themselves: listing / creating /
+// updating / deleting collections via `/api/collections`, and subscribing to
+// the `collections` registry channel (AdminChannel), which fires when
+// collections themselves are created / updated / deleted.
+
+import type { HttpClient } from "./http";
+import type { RealtimeService } from "./realtime";
+import type { ListResult, RequestOptions, ApiRecord } from "./types";
+
+const REGISTRY_TOPIC = "collections";
+
+/**
+ * Registry-level realtime events for the collections admin channel.
+ * The backend (AdminChannel) broadcasts the action as the *event name*,
+ * with the collection JSON as the payload.
+ */
+export interface CollectionsMessage {
+	action: "create" | "update" | "delete";
+	/** The collection payload (id + metadata), or {} when unavailable. */
+	collection: Record<string, unknown>;
+	topic?: string;
+}
+
+/**
+ * Registry service for collections (list/create/update/delete + realtime
+ * registry events). Mirrors PocketBase's `pb.collections`.
+ */
+export class CollectionsService {
+	private http?: HttpClient;
+	private realtime?: RealtimeService;
+
+	/** @internal */
+	constructor(http?: HttpClient, realtime?: RealtimeService) {
+		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<T = ApiRecord>(
+		params?: Record<string, unknown>,
+		options?: RequestOptions,
+	): Promise<ListResult<T> | null> {
+		const qs = params
+			? "?" +
+				new URLSearchParams(
+					Object.fromEntries(
+						Object.entries(params).map(([k, v]) => [k, String(v)]),
+					),
+				).toString()
+			: "";
+		return this.http?.get<ListResult<T>>("/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<T = ApiRecord>(
+		options?: Record<string, unknown> & RequestOptions,
+	): Promise<Array<T>> {
+		if (!this.http) return [];
+		const { batch = 1000, ...rest } = options ?? {};
+		const items: T[] = [];
+		let page = 1;
+		// Auto-paginate until empty (bounded by perPage and totalPages).
+		for (;;) {
+			const res = await this.getList<T>({
+				...rest,
+				page,
+				perPage: batch,
+			} as Record<string, unknown>);
+			if (!res || !res.items || res.items.length === 0) break;
+			items.push(...(res.items as T[]));
+			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<T = ApiRecord>(
+		id: string,
+		options?: RequestOptions,
+	): Promise<T | null> {
+		return (
+			this.http?.get<T>("/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<T = ApiRecord>(
+		data: Record<string, unknown>,
+		options?: RequestOptions,
+	): Promise<T | null> {
+		return this.http?.post<T>("/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<T = ApiRecord>(
+		id: string,
+		data: Record<string, unknown>,
+		options?: RequestOptions,
+	): Promise<T | null> {
+		return (
+			this.http?.patch<T>(
+				"/collections/" + encodeURIComponent(id),
+				data,
+				options,
+			) ?? null
+		);
+	}
+
+	/**
+	 * Delete a collection (admin).
+	 *
+	 * @param id Collection ID or name.
+	 * @param options Optional request options.
+	 */
+	async delete(id: string, options?: RequestOptions): Promise<boolean> {
+		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: (e: CollectionsMessage) => void): () => void {
+		if (!this.realtime) {
+			console.warn("[lazypock] No realtime service configured.");
+			return () => {};
+		}
+		const handler = (raw: {
+			event: string;
+			topic: string;
+			payload?: Record<string, unknown>;
+		}) => {
+			callback({
+				action: normalizeAction(raw.event),
+				collection: (raw.payload ?? {}) as Record<string, unknown>,
+				topic: raw.topic,
+			});
+		};
+		this.realtime.ensureConnected();
+		this.realtime.subscribe(REGISTRY_TOPIC, handler as never);
+		return () => this.realtime?.unsubscribe(REGISTRY_TOPIC, handler as never);
+	}
+
+	/**
+	 * Unsubscribe all callbacks from the registry channel.
+	 */
+	unsubscribe(): void {
+		this.realtime?.unsubscribe(REGISTRY_TOPIC);
+	}
+}
+
+/** Map a registry event name (create/update/delete) to an action. */
+function normalizeAction(event: string): CollectionsMessage["action"] {
+	const e = event.toLowerCase();
+	if (e === "create") return "create";
+	if (e === "update") return "update";
+	if (e === "delete") return "delete";
+	return "update";
+}

package/src/index.ts

@@ -14,6 +14,7 @@ export {
 	getFileUrl,
 	LazypockClient,
 	CollectionService,
+	CollectionsService,
 	generateTypes,
 	collectionTypeName,
 	fieldTypeScriptType,
@@ -42,3 +43,4 @@ export type {
 } from "./lazypock";
 export type { LazypockCollections } from "./client";
 export type { RealtimeMessage, RealtimeCallback } from "./collection";
+export type { CollectionsMessage } from "./collections";

package/src/lazypock.ts

@@ -22,6 +22,7 @@ import {
 } from "./types";
 import { RealtimeService, wsUrlFromBaseUrl } from "./realtime";
 import { FilesService, getFileUrl, type FileRecord } from "./files";
+import { CollectionsService } from "./collections";
 import type { CollectionSchema, SchemaField } from "./schema";
 import { generateTypes, collectionTypeName } from "./codegen";
 import { fieldTypeScriptType, fieldTypeKind, schemaFieldType } from "./typegen";
@@ -34,6 +35,7 @@ export {
 	FilesService,
 	getFileUrl,
 	CollectionService,
+	CollectionsService,
 	generateTypes,
 	collectionTypeName,
 	fieldTypeScriptType,
@@ -88,13 +90,14 @@ export interface LazypockClientOptions {
  * ```ts
  * const client = new LazypockClient({ baseUrl: 'http://localhost:4000/api' });
  * await client.login('admin@example.com', 'password');
- * const posts = await client.collection('posts').list();
+ * const posts = await client.collection('posts').getList();
  * ```
  */
 export class LazypockClient {
 	readonly http: HttpClient;
 	readonly authStore: AuthStore;
 	readonly realtime: RealtimeService;
+	readonly collections: CollectionsService;
 	readonly files: FilesService;
 	private collectionCache = new Map<string, CollectionService>();
 	private schemaByName?: Map<string, CollectionSchema>;
@@ -114,6 +117,7 @@ export class LazypockClient {
 			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]),
@@ -318,173 +322,4 @@ export class LazypockClient {
 	health(options?: RequestOptions): Promise<Record<string, unknown> | null> {
 		return this.http.get<Record<string, unknown>>("/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?: string,
-		options?: RequestOptions,
-	): Promise<ListResult<ApiRecord> | null> {
-		return this.http.get<ListResult<ApiRecord>>(
-			"/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: string,
-		options?: RequestOptions,
-	): Promise<ApiRecord | null> {
-		return this.http.get<ApiRecord>(
-			"/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: Record<string, unknown>,
-		options?: RequestOptions,
-	): Promise<ApiRecord | null> {
-		return this.http.post<ApiRecord>("/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: string,
-		data: Record<string, unknown>,
-		options?: RequestOptions,
-	): Promise<ApiRecord | null> {
-		return this.http.patch<ApiRecord>(
-			"/collections/" + encodeURIComponent(id),
-			data,
-			options,
-		);
-	}
-
-	/**
-	 * Delete a collection (admin).
-	 * @param id Collection ID or name.
-	 * @param options Optional request options.
-	 */
-	deleteCollection(id: string, options?: RequestOptions): Promise<null> {
-		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: string,
-		params?: Record<string, string>,
-		options?: RequestOptions,
-	): Promise<ListResult<ApiRecord> | null> {
-		const qs = params ? "?" + new URLSearchParams(params).toString() : "";
-		return this.http.get<ListResult<ApiRecord>>(
-			"/" + 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: string,
-		id: string,
-		options?: RequestOptions,
-	): Promise<ApiRecord | null> {
-		return this.http.get<ApiRecord>(
-			"/" + 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: string,
-		data: Record<string, unknown>,
-		options?: RequestOptions,
-	): Promise<ApiRecord | null> {
-		return this.http.post<ApiRecord>(
-			"/" + 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: string,
-		id: string,
-		data: Record<string, unknown>,
-		options?: RequestOptions,
-	): Promise<ApiRecord | null> {
-		return this.http.patch<ApiRecord>(
-			"/" + 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: string,
-		id: string,
-		options?: RequestOptions,
-	): Promise<null> {
-		return this.http.delete(
-			"/" + encodeURIComponent(coll) + "/" + encodeURIComponent(id),
-			options,
-		);
-	}
 }