lazypock 0.3.0 → 0.5.0

package/src/codegen.ts

@@ -106,6 +106,27 @@ export function generateTypes(
 ${mapEntries}
 }`);
 
+	// Runtime schema snapshot — lets the client exclude hidden fields by
+	// default, validate select/expand, and derive visible field lists.
+	const schemaEntries = collections
+		.map(
+			(c) =>
+				`  {
+    id: ${JSON.stringify(c.id ?? null)},
+    name: ${JSON.stringify(c.name)},
+    type: ${JSON.stringify(c.type)},
+    system: ${JSON.stringify(c.system ?? false)},
+    fields: ${JSON.stringify(c.fields ?? [], null, 2)},
+    rules: ${JSON.stringify(c.rules ?? {})},
+    options: ${JSON.stringify(c.options ?? {})},
+  }`,
+		)
+		.join(",\n");
+	sections.push(`// Schema snapshot (runtime) — hidden-field exclusion + query validation.
+export const lazypockSchema: import("${packageName}").CollectionSchema[] = [
+${schemaEntries}
+];`);
+
 	// createClient factory
 	sections.push(`import { LazypockClient, type LazypockClientOptions, type CollectionService } from "${packageName}";
 
@@ -113,9 +134,18 @@ ${mapEntries}
  * Create a Lazypock client typed against this schema snapshot.
  * Collection access is fully type-checked:
  *   client.collection("posts").create({ title: "x" }) // title must exist
+ *
+ * The schema snapshot is wired into the client automatically, so hidden
+ * fields are excluded from responses and select/expand are validated.
  */
 export function createClient(options: LazypockClientOptions): TypedClient {
-  return new TypedClient(options);
+  return new TypedClient({
+    ...options,
+    types: {
+      ...options.types,
+      schemas: options.types?.schemas ?? lazypockSchema,
+    },
+  });
 }
 
 export class TypedClient extends LazypockClient {
@@ -142,6 +172,9 @@ function renderInterface(opts: { extends?: string; body: string }): string {
 
 /** Render a single interface member line for a field. */
 function memberLine(f: SchemaField): string {
+	// Hidden fields are excluded from API responses by the schema-aware
+	// client default — don't expose them on the read model either.
+	if (f.hidden) return "";
 	const key = fieldKey(f.name);
 	const req = f.required || f.type === "password" ? "" : "?";
 	const type = fieldTypeScriptType(f);

package/src/collection.ts

@@ -9,8 +9,43 @@ import type {
 	RequestOptions,
 	CreateData,
 	UpdateData,
+	ListOptions,
+	ReadOptions,
+	FilterString,
+	FieldKey,
 } from "./types";
 import type { RealtimeService } from "./realtime";
+import type { CollectionSchema } from "./schema";
+
+/**
+ * Deterministic JSON stringify for building a stable cache/dedup key.
+ * Strips request-transport keys (`requestKey`, `singleFlight`, `fetch`,
+ * `signal`) so functionally-identical calls share one key.
+ */
+export function stableStringify(value: unknown): string {
+	const seen = new Set<object>();
+	const sort = (v: unknown): unknown => {
+		if (Array.isArray(v)) return v.map(sort);
+		if (v && typeof v === "object") {
+			if (seen.has(v as object)) return "[Circular]";
+			seen.add(v as object);
+			const out: Record<string, unknown> = {};
+			for (const k of Object.keys(v as object).sort()) {
+				if (k === "requestKey" || k === "singleFlight" || k === "fetch" || k === "signal") {
+					continue;
+				}
+				out[k] = sort((v as Record<string, unknown>)[k]);
+			}
+			return out;
+		}
+		return v;
+	};
+	try {
+		return JSON.stringify(sort(value));
+	} catch {
+		return String(value);
+	}
+}
 
 /**
  * A realtime record-change event delivered to subscription callbacks.
@@ -60,6 +95,14 @@ export class CollectionService<T = ApiRecord> {
 	private collectionName: string;
 	private authStore?: AuthStore;
 	private realtime?: RealtimeService;
+	/** Optional schema for this collection (from client `types.schemas`). */
+	private schema?: CollectionSchema;
+	/**
+	 * Active field projection from {@link select}. `"*"` (or unset) means
+	 * "all visible (non-hidden) fields" — resolved against the schema when
+	 * one is available, otherwise left to the server.
+	 */
+	private fieldsPreset?: string;
 
 	/** @internal */
 	constructor(
@@ -67,17 +110,117 @@ export class CollectionService<T = ApiRecord> {
 		collectionName: string,
 		authStore?: AuthStore,
 		realtime?: RealtimeService,
+		schema?: CollectionSchema,
 	) {
 		this.http = http;
 		this.collectionName = collectionName;
 		this.authStore = authStore;
 		this.realtime = realtime;
+		this.schema = schema;
 	}
 
 	private encodeId(id: string): string {
 		return encodeURIComponent(id);
 	}
 
+	// ── Field projection (`.select`) ──
+
+	/**
+	 * Project list/read responses to the given fields (PocketBase `fields`
+	 * param). Field names are type-checked when this service is typed
+	 * (codegen / `typed<T>()`).
+	 *
+	 * Returns a derived service — the original is untouched.
+	 *
+	 * @example
+	 * ```ts
+	 * const t = await client.collection("posts").select("id", "title").getList();
+	 * // GET /api/posts?fields=id,title
+	 *
+	 * // All visible fields (hidden fields are excluded server-side)
+	 * const all = await client.collection("posts").select("*").getList();
+	 * // GET /api/posts?fields=id,title,published,… (schema known)
+	 * ```
+	 *
+	 * When no schema is known, the default (no `select()` call) sends no
+	 * `fields` param — the server returns every non-password field.
+	 * Pass `select("*")` to restore the default after a projection.
+	 */
+	select<K extends FieldKey<T> | "*">(...fields: K[]): CollectionService<T> {
+		const preset = fields.length === 0 ? "*" : fields.join(",");
+		const derived = new CollectionService<T>(
+			this.http,
+			this.collectionName,
+			this.authStore,
+			this.realtime,
+			this.schema,
+		);
+		derived.fieldsPreset = preset;
+		if (this.schema && preset !== "*") {
+			const known = new Set(this.schema.fields?.map((f) => f.name) ?? []);
+			for (const f of fields) {
+				if (!known.has(f)) {
+					console.warn(
+						`[lazypock] select("${f}"): unknown field on collection "${this.collectionName}"`,
+					);
+				}
+			}
+		}
+		return derived;
+	}
+
+	/**
+	 * Fields to send with reads:
+	 * 1. explicit `options.fields` (caller wins)
+	 * 2. `select()` preset
+	 * 3. schema default — all visible (non-hidden, non-system) fields
+	 */
+	private effectiveFields(optionsFields?: string): string | undefined {
+		if (optionsFields !== undefined) return optionsFields;
+		if (this.fieldsPreset !== undefined) {
+			if (this.fieldsPreset === "*") {
+				return this.visibleFields();
+			}
+			return this.fieldsPreset;
+		}
+		return this.visibleFields();
+	}
+
+	/**
+	 * All non-hidden, non-system, non-password field names from the schema.
+	 * `undefined` when no schema is available (server decides).
+	 */
+	visibleFields(): string | undefined {
+		if (!this.schema?.fields) return undefined;
+		const visible = this.schema.fields
+			.filter(
+				(f) =>
+					!f.hidden &&
+					f.type !== "password" &&
+					f.type !== "autodate",
+			)
+			.map((f) => f.name);
+		return visible.length > 0 ? visible.join(",") : undefined;
+	}
+
+	/** Warn once when an expand field is not a relation (schema known). */
+	private validateExpand(expand: string | undefined): void {
+		if (!expand || !this.schema?.fields) return;
+		const relations = new Set(
+			this.schema.fields
+				.filter((f) => f.type === "relation")
+				.map((f) => f.name),
+		);
+		for (const f of expand.split(",")) {
+			const name = f.trim();
+			if (name && !relations.has(name)) {
+				console.warn(
+					`[lazypock] expand("${name}"): field is not a relation on collection "${this.collectionName}"`,
+				);
+			}
+		}
+	}
+
 	/**
 	 * Fetch a paginated list of records (PocketBase `getList`).
 	 *
@@ -88,7 +231,7 @@ export class CollectionService<T = ApiRecord> {
 	getList<T2 = T>(
 		page = 1,
 		perPage = 30,
-		options?: Record<string, unknown> & RequestOptions,
+		options?: ListOptions<T> & RequestOptions,
 	): Promise<ListResult<T2> | null> {
 		const {
 			requestKey,
@@ -97,12 +240,19 @@ export class CollectionService<T = ApiRecord> {
 			fetch,
 			headers,
 			signal,
-			cache,
-			ttl,
-			invalidate,
+			singleFlight,
 			params,
 			...queryParams
 		} = options ?? {};
+		// Resolve the effective `fields` projection (select() preset or schema
+		// default) unless the caller passed an explicit `fields`.
+		const fields = this.effectiveFields(queryParams.fields as string | undefined);
+		if (fields !== undefined && queryParams.fields === undefined) {
+			queryParams.fields = fields;
+		}
+		if (typeof queryParams.expand === "string") {
+			this.validateExpand(queryParams.expand);
+		}
 		const qs = new URLSearchParams(
 			Object.fromEntries(
 				Object.entries({
@@ -121,9 +271,7 @@ export class CollectionService<T = ApiRecord> {
 				fetch,
 				headers,
 				signal,
-				cache,
-				ttl,
-				invalidate,
+				singleFlight,
 				params,
 			} as RequestOptions,
 		);
@@ -136,9 +284,20 @@ export class CollectionService<T = ApiRecord> {
 	 * @param options Query params (`sort`, `filter`, `batch`, etc.) + request options.
 	 */
 	async getFullList<T2 = T>(
-		options?: Record<string, unknown> & RequestOptions,
+		options?: ListOptions<T> & RequestOptions,
 	): Promise<Array<T2>> {
 		const { batch = 1000, ...rest } = options ?? {};
+
+		// Build a stable request key for the whole full-list fetch (NOT per page,
+		// which would break dedup). Concurrent identical getFullList() calls share
+		// this key via single-flight, so they don't fire duplicate requests. Pages
+		// still advance correctly: each page's URL differs (page=N in the query),
+		// so the underlying default key is unique per page — no cross-page cancel.
+		const effectiveKey =
+			typeof rest.requestKey === "string"
+				? rest.requestKey
+				: `getFullList:${this.collectionName}:${stableStringify(rest)}`;
+
 		const items: T2[] = [];
 		let page = 1;
 		for (;;) {
@@ -146,10 +305,10 @@ export class CollectionService<T = ApiRecord> {
 				page,
 				batch as number,
 				{
-					// disable auto-cancellation across pages — each page request is unique
 					...rest,
-					requestKey: null,
-				} as Record<string, unknown> & RequestOptions,
+					requestKey: effectiveKey,
+					singleFlight: true,
+				} as ListOptions<T> & RequestOptions,
 			);
 			if (!res || !res.items || res.items.length === 0) break;
 			items.push(...(res.items as T2[]));
@@ -166,8 +325,8 @@ export class CollectionService<T = ApiRecord> {
 	 * @param options Optional request options.
 	 */
 	async getFirstListItem<T2 = T>(
-		filter: string,
-		options?: RequestOptions,
+		filter: FilterString<T>,
+		options?: ListOptions<T> & RequestOptions,
 	): Promise<T2 | null> {
 		const res = await this.getList<T2>(1, 1, {
 			...options,
@@ -181,9 +340,21 @@ export class CollectionService<T = ApiRecord> {
 	 * @param id Record ID.
 	 * @param options Optional request options.
 	 */
-	getOne(id: string, options?: RequestOptions): Promise<T | null> {
+	getOne(id: string, options?: ReadOptions<T> & RequestOptions): Promise<T | null> {
+		const fields = this.effectiveFields(options?.fields);
+		if (typeof options?.expand === "string") {
+			this.validateExpand(options.expand);
+		}
+		const qs = new URLSearchParams();
+		if (fields !== undefined) qs.set("fields", fields);
+		if (typeof options?.expand === "string") qs.set("expand", options.expand);
+		const qsStr = qs.toString();
 		return this.http.get<T>(
-			"/" + this.encodeId(this.collectionName) + "/" + this.encodeId(id),
+			"/" +
+				this.encodeId(this.collectionName) +
+				"/" +
+				this.encodeId(id) +
+				(qsStr ? "?" + qsStr : ""),
 			options,
 		);
 	}
@@ -281,6 +452,23 @@ export class CollectionService<T = ApiRecord> {
 		return this as unknown as CollectionService<TRecord>;
 	}
 
+	/**
+	 * Explicitly bind a schema for this service (overrides the client-level
+	 * `types.schemas`). Enables schema-aware defaults: hidden fields are
+	 * excluded from responses, select/expand are validated.
+	 */
+	withSchema(schema: CollectionSchema): CollectionService<T> {
+		const derived = new CollectionService<T>(
+			this.http,
+			this.collectionName,
+			this.authStore,
+			this.realtime,
+			schema,
+		);
+		derived.fieldsPreset = this.fieldsPreset;
+		return derived;
+	}
+
 	// ── Realtime Subscriptions (PocketBase-style) ──
 
 	/**

package/src/collections.ts

@@ -12,6 +12,7 @@
 
 import type { HttpClient } from "./http";
 import type { RealtimeService } from "./realtime";
+import { stableStringify } from "./collection";
 import type { ListResult, RequestOptions, ApiRecord } from "./types";
 
 const REGISTRY_TOPIC = "collections";
@@ -74,15 +75,44 @@ export class CollectionsService {
 	): Promise<Array<T>> {
 		if (!this.http) return [];
 		const { batch = 1000, ...rest } = options ?? {};
+
+		// Extract request-transport options so they never leak into query params.
+		const {
+			requestKey: reqKey,
+			singleFlight: _singleFlight,
+			fetch: fetchFn,
+			headers: hdrs,
+			signal: sig,
+			params: passthroughParams,
+			...queryParams
+		} = rest as Record<string, unknown> & RequestOptions;
+
+		// Stable key for the whole full-list fetch — see CollectionService.getFullList
+		// for the rationale (single-flight dedup, per-page paths stay unique).
+		const effectiveKey =
+			typeof reqKey === "string"
+				? reqKey
+				: `getFullList:collections:${stableStringify(rest)}`;
+
 		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>);
+			const res = await this.getList<T>(
+				{
+					...queryParams,
+					...(passthroughParams ?? {}),
+					page,
+					perPage: batch,
+				},
+				{
+					requestKey: effectiveKey,
+					singleFlight: true,
+					...(fetchFn ? { fetch: fetchFn } : {}),
+					...(hdrs ? { headers: hdrs } : {}),
+					...(sig ? { signal: sig } : {}),
+				} as RequestOptions,
+			);
 			if (!res || !res.items || res.items.length === 0) break;
 			items.push(...(res.items as T[]));
 			if (page >= (res.totalPages ?? page)) break;

package/src/http.ts

@@ -3,8 +3,6 @@
 
 import { ApiError, type Method, type RequestOptions } from "./types";
 import type { AuthStore } from "./auth";
-import type { CacheStore } from "./cache";
-import { resolveCacheDirective } from "./cache";
 
 /**
  * Low-level HTTP client wrapping `fetch` with automatic auth token injection.
@@ -22,10 +20,6 @@ export class HttpClient {
 	private baseUrl: string;
 	private authStore: AuthStore;
 	private defaultFetch: typeof globalThis.fetch;
-	/** Optional query cache store (wired when the client enables caching). */
-	private cache?: CacheStore;
-	/** Master switch resolved from CacheConfig.enabled. */
-	private cacheEnabled = false;
 
 	/**
 	 * Abort controllers for in-flight requests, keyed by their cancellation key
@@ -34,6 +28,14 @@ export class HttpClient {
 	 */
 	private cancelControllers: Record<string, AbortController> = {};
 
+	/**
+	 * In-flight request promises, keyed by cancellation key. When auto-cancellation
+	 * would abort a pending duplicate, the newer request instead awaits the same
+	 * promise — single-flight coalescing (no duplicate network request, no
+	 * spurious abort rejection for the caller).
+	 */
+	private inflight: Record<string, Promise<unknown>> = {};
+
 	/** Global toggle for the auto-cancellation behaviour (default: on). */
 	private enableAutoCancellation = true;
 
@@ -47,20 +49,6 @@ export class HttpClient {
 		this.defaultFetch = globalThis.fetch.bind(globalThis);
 	}
 
-	/**
-	 * Attach a cache store + master switch.
-	 * Called by the client constructor when cache config is present.
-	 */
-	setCache(cache: CacheStore, enabled: boolean): void {
-		this.cache = cache;
-		this.cacheEnabled = enabled;
-	}
-
-	/** Whether the global cache flag is on (requests opt in/out individually too). */
-	get cacheIsEnabled(): boolean {
-		return this.cacheEnabled;
-	}
-
 	private async refreshAuth(): Promise<{
 		token: string;
 		record: Record<string, unknown>;
@@ -145,16 +133,6 @@ export class HttpClient {
 	 * @throws {ApiError} On non-2xx responses or when the request is aborted
 	 * (aborted requests throw an `ApiError` with `isAbort === true`).
 	 */
-	/** Invalidate a namespace (collection name). No-op when cache is off. */
-	invalidateCache(namespace: string): void {
-		this.cache?.invalidate(namespace);
-	}
-
-	/** Current cache statistics (hits/misses/entries), or null when disabled. */
-	cacheStats(): { hits: number; misses: number; entries: number } | null {
-		return this.cache ? this.cache.stats() : null;
-	}
-
 	async request<T = unknown>(
 		method: Method,
 		path: string,
@@ -166,28 +144,6 @@ export class HttpClient {
 			await this.refreshAuth();
 		}
 
-		// ── Cache resolution (read path) ────────────────────────────────
-		// Only cacheable reads (GET) participate. Cache keys are scoped by auth
-		// token so user A's cached list can never leak to user B (or anonymous).
-		//
-		// Effective caching for this request:
-		//   - per-request { cache } / { ttl } present → use it (true enables,
-		//     false bypasses, number/object sets TTL)
-		//   - otherwise → fall back to the global cache.enabled flag
-		const cacheDirective = resolveCacheDirective(options);
-		const wantCache =
-			cacheDirective !== null
-				? cacheDirective.enabled
-				: this.cacheEnabled;
-		const cacheKey =
-			method === "GET" && this.cache && wantCache
-				? this.cacheKeyFor(method, path, options?.params)
-				: null;
-		if (cacheKey !== null) {
-			const hit = await this.cache?.get(cacheKey);
-			if (hit !== undefined) return hit as T;
-		}
-
 		// Resolve the auto-cancellation key (PocketBase `requestKey` semantics):
 		// - options.requestKey null  → disabled for this request
 		// - options.requestKey string → use it verbatim
@@ -200,6 +156,16 @@ export class HttpClient {
 				: options.requestKey;
 		if (options?.autoCancel === false) requestKey = null;
 
+		// Single-flight coalescing: when the same requestKey is already in-flight
+		// and the caller opted in, reuse that promise instead of firing a duplicate
+		// request (no abort rejection for either caller).
+		if (options?.singleFlight && requestKey !== null) {
+			const pending = this.inflight[requestKey];
+			if (pending !== undefined) {
+				return pending as Promise<T | 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).
@@ -221,6 +187,48 @@ export class HttpClient {
 		}
 		const signal = controller?.signal ?? externalSignal;
 
+		// Register the in-flight promise so later single-flight callers reuse it.
+		// The promise is created from an inner async fn that performs the request
+		// and clears itself from the inflight map on settle.
+		const perform = async (): Promise<T | null> => {
+			try {
+				return await this.doRequest(
+					method,
+					path,
+					body,
+					options,
+					signal,
+					requestKey,
+					controller,
+				);
+			} finally {
+				if (requestKey !== null) {
+					if (this.inflight[requestKey] === promise) {
+						delete this.inflight[requestKey];
+					}
+				}
+			}
+		};
+		const promise = perform();
+		if (requestKey !== null) {
+			this.inflight[requestKey] = promise;
+		}
+		return promise;
+	}
+
+	/**
+	 * Execute the actual HTTP request (fetch + parse). Called by {@link request}
+	 * as the inner in-flight unit so single-flight callers can reuse the promise.
+	 */
+	private async doRequest<T = unknown>(
+		method: Method,
+		path: string,
+		body: unknown,
+		options: RequestOptions | undefined,
+		signal: AbortSignal | null | undefined,
+		requestKey: string | null,
+		controller: AbortController | null,
+	): Promise<T | null> {
 		let url = this.baseUrl + path;
 		if (options?.params) {
 			const qs = new URLSearchParams(options.params).toString();
@@ -305,83 +313,9 @@ export class HttpClient {
 			);
 		}
 
-		// ── Cache store (read path) ─────────────────────────────────────
-		// Persist successful GET payloads when the directive wants caching.
-		if (cacheKey !== null && this.cache) {
-			const namespace = this.namespaceFromPath(path);
-			const ttl = cacheDirective?.ttl;
-			const tags = this.cacheTagsFor(path, namespace);
-			this.cache.set(
-				cacheKey,
-				data,
-				ttl,
-				namespace ?? undefined,
-				tags,
-			);
-		}
-
-		// ── Cache invalidation (write path) ────────────────────────────
-		// Mutations invalidate the affected collection's cached entries so
-		// subsequent reads don't serve stale lists. The current collection is
-		// always invalidated; `options.invalidate` adds extra namespaces.
-		if (method !== "GET" && this.cache) {
-			const namespaces = new Set<string>();
-			const ns = this.namespaceFromPath(path);
-			if (ns) namespaces.add(ns);
-			for (const extra of options?.invalidate ?? []) {
-				if (extra) namespaces.add(extra);
-			}
-			for (const nsName of namespaces) this.cache.invalidate(nsName);
-		}
-
 		return data as T;
 	}
 
-	// ── Cache key/namespace helpers ──
-
-	/** Build a token-scoped cache key: `METHOD path|token-hash|params`. */
-	private cacheKeyFor(
-		method: Method,
-		path: string,
-		params?: Record<string, string>,
-	): string {
-		const token = this.authStore.token || "anon";
-		const qs = params ? "?" + new URLSearchParams(params).toString() : "";
-		return `${method} ${path}${qs}|${token}`;
-	}
-
-	/** Best-effort namespace (collection name) from a REST path. */
-	private namespaceFromPath(path: string): string | undefined {
-		// /posts/abc-123 → posts ; /collections/xyz → collections
-		// strip any query string first (/posts?page=1 → /posts)
-		const clean = path.split("?")[0];
-		const parts = clean.split("/").filter(Boolean);
-		if (parts.length === 0) return undefined;
-		if (parts[0] === "collections" || parts[0] === "_superusers") {
-			return parts[0];
-		}
-		return parts[0];
-	}
-
-	/**
-	 * Semantic prefix tags for `deleteByPrefix`, derived from the REST shape:
-	 * - `/{collection}?...` → `getList:{collection}`
-	 * - `/{collection}/{id}` → `getOne:{collection}`
-	 * - `/collections?...` / `/collections/{id}` → `collections:getList` / `collections:getOne`
-	 */
-	private cacheTagsFor(path: string, namespace: string | undefined): string[] {
-		if (!namespace) return [];
-		const clean = path.split("?")[0];
-		const parts = clean.split("/").filter(Boolean);
-		if (parts[0] === "collections" || parts[0] === "_superusers") {
-			const op = parts.length >= 2 ? "getOne" : "getList";
-			return [`${namespace}:${op}`];
-		}
-		// /posts (list) vs /posts/{id} (one)
-		const op = parts.length >= 2 ? "getOne" : "getList";
-		return [`${op}:${namespace}`];
-	}
-
 	/**
 	 * HTTP GET.
 	 * @param path URL path.

package/src/index.ts

@@ -23,8 +23,6 @@ export {
 	fieldTypeScriptType,
 	fieldTypeKind,
 	schemaFieldType,
-	CacheStore,
-	resolveCacheDirective,
 } from "./lazypock";
 export { TypedClient, createClient } from "./client";
 
@@ -40,12 +38,17 @@ export type {
 	SystemFields,
 	RequestOptions,
 	FileRecord,
-	// cache
-	CacheConfig,
-	CacheRequestOptions,
 	// schema
 	CollectionSchema,
 	SchemaField,
+	// schema-driven query typing
+	ListOptions,
+	ReadOptions,
+	FilterString,
+	SortString,
+	ExpandString,
+	FilterOp,
+	FieldKey,
 	// options
 	LazypockClientOptions,
 } from "./lazypock";