lazypock 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -22,7 +22,6 @@ var index_exports = {};
 __export(index_exports, {
   ApiError: () => ApiError,
   AuthStore: () => AuthStore,
-  CacheStore: () => CacheStore,
   CollectionService: () => CollectionService,
   CollectionsService: () => CollectionsService,
   FilesService: () => FilesService,
@@ -38,7 +37,6 @@ __export(index_exports, {
   getFileUrl: () => getFileUrl,
   getScaleUrl: () => getScaleUrl,
   getThumbUrl: () => getThumbUrl,
-  resolveCacheDirective: () => resolveCacheDirective,
   schemaFieldType: () => schemaFieldType,
   wsUrlFromBaseUrl: () => wsUrlFromBaseUrl
 });
@@ -55,201 +53,6 @@ var ApiError = class extends Error {
   }
 };
 
-// src/cache.ts
-var CacheStore = class {
-  constructor(config = {}) {
-    this.memory = /* @__PURE__ */ new Map();
-    this.hits = 0;
-    this.misses = 0;
-    this.namespaceEntries = /* @__PURE__ */ new Map();
-    /** Key → set of prefix tags registered for that key (e.g. `getList:posts`). */
-    this.prefixEntries = /* @__PURE__ */ new Map();
-    this.ttl = config.defaultTTL ?? 6e4;
-    this.persistence = config.store;
-    this.maxEntries = config.maxEntries ?? 500;
-  }
-  /** Resolve the effective TTL: request override → global default. */
-  resolveTTL(ttl) {
-    return ttl && ttl > 0 ? ttl : this.ttl;
-  }
-  /**
-   * Read a cached value. Fast sync path (memory) with async persistence
-   * fallback for adapters whose `get` returns a Promise.
-   * @param key Cache key (e.g. `"GET /posts?page=1"`).
-   * @returns The cached value, or undefined when absent/expired (the hit is
-   * cleared on expiry so a stale value is never served).
-   */
-  async get(key) {
-    const mem = this.memory.get(key);
-    if (mem !== void 0) {
-      if (Date.now() > mem.expiresAt) {
-        this.delete(key);
-        this.misses++;
-        return void 0;
-      }
-      this.memory.delete(key);
-      this.memory.set(key, mem);
-      this.hits++;
-      return mem.value;
-    }
-    if (this.persistence) {
-      const entry = await this.readPersisted(key);
-      if (entry) {
-        if (Date.now() > entry.expiresAt) {
-          this.delete(key);
-          this.misses++;
-          return void 0;
-        }
-        this.hits++;
-        return entry.value;
-      }
-    }
-    this.misses++;
-    return void 0;
-  }
-  /**
-   * Store a value.
-   * @param key Cache key.
-   * @param value The response payload.
-   * @param ttlOverride Optional TTL override (ms).
-   * @param namespace Optional namespace for group invalidation.
-   */
-  set(key, value, ttlOverride, namespace, tags) {
-    const expiresAt = Date.now() + this.resolveTTL(ttlOverride);
-    const entry = { value, expiresAt, namespace, tags };
-    this.memory.set(key, entry);
-    if (this.memory.size > this.maxEntries) {
-      const oldest = this.memory.keys().next().value;
-      if (oldest !== void 0) this.delete(oldest);
-    }
-    if (namespace) {
-      let keys = this.namespaceEntries.get(namespace);
-      if (!keys) {
-        keys = /* @__PURE__ */ new Set();
-        this.namespaceEntries.set(namespace, keys);
-      }
-      keys.add(key);
-    }
-    for (const tag of tags ?? []) {
-      let keys = this.prefixEntries.get(tag);
-      if (!keys) {
-        keys = /* @__PURE__ */ new Set();
-        this.prefixEntries.set(tag, keys);
-      }
-      keys.add(key);
-    }
-    if (this.persistence) {
-      void this.persistence.set(this.persistKey(key), JSON.stringify(entry));
-    }
-  }
-  /**
-   * Invalidate entries belonging to a namespace (e.g. a collection name).
-   * Also clears the namespace index entry.
-   */
-  invalidate(namespace) {
-    const keys = Array.from(this.namespaceEntries.get(namespace) ?? []);
-    for (const key of keys) this.delete(key);
-    this.namespaceEntries.delete(namespace);
-  }
-  /** Remove a single key. */
-  delete(key) {
-    const entry = this.memory.get(key);
-    if (entry?.namespace) {
-      const set = this.namespaceEntries.get(entry.namespace);
-      if (set) {
-        set.delete(key);
-        if (set.size === 0) this.namespaceEntries.delete(entry.namespace);
-      }
-    }
-    for (const tag of entry?.tags ?? []) {
-      const set = this.prefixEntries.get(tag);
-      if (set) {
-        set.delete(key);
-        if (set.size === 0) this.prefixEntries.delete(tag);
-      }
-    }
-    this.memory.delete(key);
-    if (this.persistence) {
-      void this.persistence.remove(this.persistKey(key));
-    }
-  }
-  /**
-   * Delete every entry whose key starts with `prefix`.
-   *
-   * Useful for fine-grained invalidation, e.g.:
-   * ```ts
-   * client.cache.deleteByPrefix('getList:posts'); // delete all getList cache
-   * client.cache.deleteByPrefix('getOne:posts');  // delete all getOne cache
-   * ```
-   */
-  deleteByPrefix(prefix) {
-    if (!prefix) return;
-    const tagged = this.prefixEntries.get(prefix);
-    if (tagged) {
-      for (const key of Array.from(tagged)) this.delete(key);
-      this.prefixEntries.delete(prefix);
-      return;
-    }
-    for (const key of Array.from(this.memory.keys())) {
-      if (key.startsWith(prefix)) this.delete(key);
-    }
-  }
-  /** Drop every cached entry (memory + persistence). */
-  clear() {
-    this.memory.clear();
-    this.namespaceEntries.clear();
-    this.prefixEntries.clear();
-  }
-  /** Cache hit/miss/entry statistics. */
-  stats() {
-    return { hits: this.hits, misses: this.misses, entries: this.memory.size };
-  }
-  persistKey(key) {
-    return "lazypock:cache:" + key;
-  }
-  async readPersisted(key) {
-    if (!this.persistence) return void 0;
-    const raw = await this.persistence.get(this.persistKey(key));
-    if (raw == null) return void 0;
-    try {
-      const entry = JSON.parse(raw);
-      this.memory.set(key, entry);
-      if (entry.namespace) {
-        let keys = this.namespaceEntries.get(entry.namespace);
-        if (!keys) {
-          keys = /* @__PURE__ */ new Set();
-          this.namespaceEntries.set(entry.namespace, keys);
-        }
-        keys.add(key);
-      }
-      for (const tag of entry.tags ?? []) {
-        let keys = this.prefixEntries.get(tag);
-        if (!keys) {
-          keys = /* @__PURE__ */ new Set();
-          this.prefixEntries.set(tag, keys);
-        }
-        keys.add(key);
-      }
-      return entry;
-    } catch {
-      void this.persistence.remove(this.persistKey(key));
-      return void 0;
-    }
-  }
-};
-function resolveCacheDirective(opts) {
-  if (!opts) return null;
-  if (typeof opts.ttl === "number" && opts.ttl > 0) {
-    return { enabled: true, ttl: opts.ttl };
-  }
-  const c = opts.cache;
-  if (c === void 0) return null;
-  if (c === true) return { enabled: true };
-  if (c === false) return { enabled: false };
-  if (typeof c === "number") return { enabled: true, ttl: c > 0 ? c : void 0 };
-  return { enabled: true, ttl: c.ttl, key: c.key };
-}
-
 // src/http.ts
 function isAbortError(err) {
   return err instanceof Error && (err.name === "AbortError" || err.message === "Aborted");
@@ -260,32 +63,25 @@ var HttpClient = class {
    * @param authStore The auth store providing the token for Authorization headers.
    */
   constructor(baseUrl, authStore) {
-    /** Master switch resolved from CacheConfig.enabled. */
-    this.cacheEnabled = false;
     /**
      * 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 = {};
+    /**
+     * 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).
+     */
+    this.inflight = {};
     /** 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);
   }
-  /**
-   * Attach a cache store + master switch.
-   * Called by the client constructor when cache config is present.
-   */
-  setCache(cache, enabled) {
-    this.cache = cache;
-    this.cacheEnabled = enabled;
-  }
-  /** Whether the global cache flag is on (requests opt in/out individually too). */
-  get cacheIsEnabled() {
-    return this.cacheEnabled;
-  }
   async refreshAuth() {
     const collection = this.authStore.collectionName;
     if (!collection) return null;
@@ -362,27 +158,18 @@ var HttpClient = class {
    * @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) {
-    this.cache?.invalidate(namespace);
-  }
-  /** Current cache statistics (hits/misses/entries), or null when disabled. */
-  cacheStats() {
-    return this.cache ? this.cache.stats() : null;
-  }
   async request(method, path, body, options) {
     if (this.authStore.isExpired && this.authStore.collectionName) {
       await this.refreshAuth();
     }
-    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 !== void 0) return hit;
-    }
     let requestKey = options?.requestKey === void 0 ? options?.cancelKey ?? `${method} ${path}` : options.requestKey;
     if (options?.autoCancel === false) requestKey = null;
+    if (options?.singleFlight && requestKey !== null) {
+      const pending = this.inflight[requestKey];
+      if (pending !== void 0) {
+        return pending;
+      }
+    }
     let controller = null;
     const externalSignal = options?.signal;
     if (requestKey !== null) {
@@ -400,6 +187,36 @@ var HttpClient = class {
       }
     }
     const signal = controller?.signal ?? externalSignal;
+    const perform = async () => {
+      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.
+   */
+  async doRequest(method, path, body, options, signal, requestKey, controller) {
     let url = this.baseUrl + path;
     if (options?.params) {
       const qs = new URLSearchParams(options.params).toString();
@@ -464,63 +281,8 @@ var HttpClient = class {
         res.status
       );
     }
-    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 ?? void 0,
-        tags
-      );
-    }
-    if (method !== "GET" && this.cache) {
-      const namespaces = /* @__PURE__ */ new Set();
-      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;
   }
-  // ── Cache key/namespace helpers ──
-  /** Build a token-scoped cache key: `METHOD path|token-hash|params`. */
-  cacheKeyFor(method, path, params) {
-    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. */
-  namespaceFromPath(path) {
-    const clean = path.split("?")[0];
-    const parts = clean.split("/").filter(Boolean);
-    if (parts.length === 0) return void 0;
-    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`
-   */
-  cacheTagsFor(path, namespace) {
-    if (!namespace) return [];
-    const clean = path.split("?")[0];
-    const parts = clean.split("/").filter(Boolean);
-    if (parts[0] === "collections" || parts[0] === "_superusers") {
-      const op2 = parts.length >= 2 ? "getOne" : "getList";
-      return [`${namespace}:${op2}`];
-    }
-    const op = parts.length >= 2 ? "getOne" : "getList";
-    return [`${op}:${namespace}`];
-  }
   /**
    * HTTP GET.
    * @param path URL path.
@@ -696,6 +458,30 @@ var memoryStorage = {
 };
 
 // src/collection.ts
+function stableStringify(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const sort = (v) => {
+    if (Array.isArray(v)) return v.map(sort);
+    if (v && typeof v === "object") {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+      const out = {};
+      for (const k of Object.keys(v).sort()) {
+        if (k === "requestKey" || k === "singleFlight" || k === "fetch" || k === "signal") {
+          continue;
+        }
+        out[k] = sort(v[k]);
+      }
+      return out;
+    }
+    return v;
+  };
+  try {
+    return JSON.stringify(sort(value));
+  } catch {
+    return String(value);
+  }
+}
 function normalizeAction(event, rawAction) {
   if (typeof rawAction === "string") {
     const a = rawAction.toLowerCase();
@@ -708,17 +494,104 @@ function normalizeAction(event, rawAction) {
   if (event === "delete" || event === "record_delete") return "delete";
   return "update";
 }
-var CollectionService = class {
+var CollectionService = class _CollectionService {
   /** @internal */
-  constructor(http, collectionName, authStore, realtime) {
+  constructor(http, collectionName, authStore, realtime, schema) {
     this.http = http;
     this.collectionName = collectionName;
     this.authStore = authStore;
     this.realtime = realtime;
+    this.schema = schema;
   }
   encodeId(id) {
     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(...fields) {
+    const preset = fields.length === 0 ? "*" : fields.join(",");
+    const derived = new _CollectionService(
+      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
+   */
+  effectiveFields(optionsFields) {
+    if (optionsFields !== void 0) return optionsFields;
+    if (this.fieldsPreset !== void 0) {
+      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() {
+    if (!this.schema?.fields) return void 0;
+    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(",") : void 0;
+  }
+  /** Warn once when an expand field is not a relation (schema known). */
+  validateExpand(expand) {
+    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`).
    *
@@ -734,12 +607,17 @@ var CollectionService = class {
       fetch,
       headers,
       signal,
-      cache,
-      ttl,
-      invalidate,
+      singleFlight,
       params,
       ...queryParams
     } = options ?? {};
+    const fields = this.effectiveFields(queryParams.fields);
+    if (fields !== void 0 && queryParams.fields === void 0) {
+      queryParams.fields = fields;
+    }
+    if (typeof queryParams.expand === "string") {
+      this.validateExpand(queryParams.expand);
+    }
     const qs = new URLSearchParams(
       Object.fromEntries(
         Object.entries({
@@ -758,9 +636,7 @@ var CollectionService = class {
         fetch,
         headers,
         signal,
-        cache,
-        ttl,
-        invalidate,
+        singleFlight,
         params
       }
     );
@@ -773,6 +649,7 @@ var CollectionService = class {
    */
   async getFullList(options) {
     const { batch = 1e3, ...rest } = options ?? {};
+    const effectiveKey = typeof rest.requestKey === "string" ? rest.requestKey : `getFullList:${this.collectionName}:${stableStringify(rest)}`;
     const items = [];
     let page = 1;
     for (; ; ) {
@@ -780,9 +657,9 @@ var CollectionService = class {
         page,
         batch,
         {
-          // disable auto-cancellation across pages — each page request is unique
           ...rest,
-          requestKey: null
+          requestKey: effectiveKey,
+          singleFlight: true
         }
       );
       if (!res || !res.items || res.items.length === 0) break;
@@ -811,8 +688,16 @@ var CollectionService = class {
    * @param options Optional request options.
    */
   getOne(id, options) {
+    const fields = this.effectiveFields(options?.fields);
+    if (typeof options?.expand === "string") {
+      this.validateExpand(options.expand);
+    }
+    const qs = new URLSearchParams();
+    if (fields !== void 0) qs.set("fields", fields);
+    if (typeof options?.expand === "string") qs.set("expand", options.expand);
+    const qsStr = qs.toString();
     return this.http.get(
-      "/" + this.encodeId(this.collectionName) + "/" + this.encodeId(id),
+      "/" + this.encodeId(this.collectionName) + "/" + this.encodeId(id) + (qsStr ? "?" + qsStr : ""),
       options
     );
   }
@@ -887,6 +772,22 @@ var CollectionService = class {
   typed() {
     return this;
   }
+  /**
+   * 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) {
+    const derived = new _CollectionService(
+      this.http,
+      this.collectionName,
+      this.authStore,
+      this.realtime,
+      schema
+    );
+    derived.fieldsPreset = this.fieldsPreset;
+    return derived;
+  }
   // ── Realtime Subscriptions (PocketBase-style) ──
   /**
    * Subscribe to realtime changes for this collection.
@@ -1305,14 +1206,34 @@ var CollectionsService = class {
   async getFullList(options) {
     if (!this.http) return [];
     const { batch = 1e3, ...rest } = options ?? {};
+    const {
+      requestKey: reqKey,
+      singleFlight: _singleFlight,
+      fetch: fetchFn,
+      headers: hdrs,
+      signal: sig,
+      params: passthroughParams,
+      ...queryParams
+    } = rest;
+    const effectiveKey = typeof reqKey === "string" ? reqKey : `getFullList:collections:${stableStringify(rest)}`;
     const items = [];
     let page = 1;
     for (; ; ) {
-      const res = await this.getList({
-        ...rest,
-        page,
-        perPage: batch
-      });
+      const res = await this.getList(
+        {
+          ...queryParams,
+          ...passthroughParams ?? {},
+          page,
+          perPage: batch
+        },
+        {
+          requestKey: effectiveKey,
+          singleFlight: true,
+          ...fetchFn ? { fetch: fetchFn } : {},
+          ...hdrs ? { headers: hdrs } : {},
+          ...sig ? { signal: sig } : {}
+        }
+      );
       if (!res || !res.items || res.items.length === 0) break;
       items.push(...res.items);
       if (page >= (res.totalPages ?? page)) break;
@@ -1551,15 +1472,39 @@ function generateTypes(collections, options = {}) {
   sections.push(`export interface LazypockCollections {
 ${mapEntries}
 }`);
+  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) \u2014 hidden-field exclusion + query validation.
+export const lazypockSchema: import("${packageName}").CollectionSchema[] = [
+${schemaEntries}
+];`);
   sections.push(`import { LazypockClient, type LazypockClientOptions, type CollectionService } from "${packageName}";
 
 /**
  * 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 {
@@ -1580,6 +1525,7 @@ ${opts.body}
 }`;
 }
 function memberLine(f) {
+  if (f.hidden) return "";
   const key = fieldKey(f.name);
   const req = f.required || f.type === "password" ? "" : "?";
   const type = fieldTypeScriptType(f);
@@ -1595,50 +1541,6 @@ var LazypockClient = class {
    */
   constructor(options) {
     this.collectionCache = /* @__PURE__ */ new Map();
-    /** Namespace → realtime unsubscribe; used for realtime-driven invalidation. */
-    this.realtimeInvalidators = /* @__PURE__ */ new Map();
-    // ── Query cache (opt-in by default; opt-out per request) ──
-    /**
-     * Configure the query cache at runtime (also a namespace for cache
-     * management methods).
-     *
-     * ```ts
-     * client.cache({ enabled: true, defaultTTL: 30_000 });
-     * client.cache.deleteByPrefix('getList:posts');  // all list caches for posts
-     * client.cache.deleteByPrefix('getOne:posts');   // all one-record caches
-     * ```
-     *
-     * When enabled, GET requests cache their payload; mutations invalidate the
-     * affected collection automatically. Individual requests can opt out with
-     * `{ cache: false }` or override the TTL with `{ ttl: ms }`.
-     */
-    this.cache = Object.assign(
-      ((config) => {
-        if (!this.cacheStore) {
-          this.cacheStore = new CacheStore({
-            defaultTTL: config?.defaultTTL,
-            store: config?.store,
-            maxEntries: config?.maxEntries
-          });
-          this.http.setCache(this.cacheStore, config?.enabled ?? true);
-        } else {
-          if (config?.enabled !== void 0) {
-            this.http.setCache(this.cacheStore, config.enabled);
-          }
-        }
-        return this;
-      }),
-      {
-        deleteByPrefix: (prefix) => this.cacheStore?.deleteByPrefix(prefix),
-        invalidate: (namespace) => this.cacheStore?.invalidate(namespace),
-        clear: () => {
-          this.cacheStore?.clear();
-          for (const unsub of this.realtimeInvalidators.values()) unsub();
-          this.realtimeInvalidators.clear();
-        },
-        stats: () => this.cacheStore ? this.cacheStore.stats() : null
-      }
-    );
     const baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.authStore = options.authStore ?? new AuthStore(options.storage ?? memoryStorage);
     this.http = new HttpClient(baseUrl, this.authStore);
@@ -1648,14 +1550,6 @@ var LazypockClient = class {
     }
     this.files = new FilesService(this.http);
     this.collections = new CollectionsService(this.http, this.realtime);
-    if (options.cache) {
-      this.cacheStore = new CacheStore({
-        defaultTTL: options.cache.defaultTTL,
-        store: options.cache.store,
-        maxEntries: options.cache.maxEntries
-      });
-      this.http.setCache(this.cacheStore, options.cache.enabled ?? false);
-    }
     if (options.types?.schemas) {
       this.schemaByName = new Map(
         options.types.schemas.map((s) => [s.name, s])
@@ -1673,14 +1567,16 @@ var LazypockClient = class {
    * @param name The collection name.
    * @returns A {@link CollectionService} instance.
    */
-  collection(name) {
+  collection(name, schema) {
     let svc = this.collectionCache.get(name);
     if (!svc) {
       svc = new CollectionService(
         this.http,
         name,
         this.authStore,
-        this.realtime
+        this.realtime,
+        // Prefer the explicit schema, then the client-level `types.schemas`.
+        schema ?? this.schemaByName?.get(name)
       );
       this.collectionCache.set(name, svc);
     }
@@ -1736,49 +1632,6 @@ var LazypockClient = class {
     this.http.cancelAllRequests();
     return this;
   }
-  /**
-   * Drop every cached entry (all collections / namespaces).
-   * Also disables realtime-driven invalidation subscriptions.
-   */
-  clearCache() {
-    this.cacheStore?.clear();
-    for (const unsub of this.realtimeInvalidators.values()) unsub();
-    this.realtimeInvalidators.clear();
-    return this;
-  }
-  /**
-   * Invalidate cached entries for a collection (or custom namespace).
-   * Runs automatically on mutations — call explicitly when data changed
-   * out-of-band (e.g. another client wrote to the same collection).
-   */
-  invalidateCache(namespace) {
-    this.cacheStore?.invalidate(namespace);
-    return this;
-  }
-  /**
-   * Cache hit/miss/entry statistics.
-   * Returns null when caching was never configured.
-   */
-  cacheStats() {
-    return this.cacheStore ? this.cacheStore.stats() : null;
-  }
-  /**
-   * Subscribe a collection's cache to realtime invalidation: any inbound
-   * create/update/delete event for the collection clears its cached entries.
-   * Returns an unsubscribe function.
-   */
-  invalidateCacheOnRealtime(collectionName) {
-    if (!this.cacheStore) {
-      this.cache({ enabled: false });
-    }
-    const existing = this.realtimeInvalidators.get(collectionName);
-    if (existing) return existing;
-    const unsub = this.collection(collectionName).subscribe(() => {
-      this.cacheStore?.invalidate(collectionName);
-    });
-    this.realtimeInvalidators.set(collectionName, unsub);
-    return unsub;
-  }
   // ── Auth ──
   /** Check whether any superuser exists (for login vs setup screen routing). */
   async checkSuperuser() {
@@ -1916,7 +1769,6 @@ function createClient(options) {
 0 && (module.exports = {
   ApiError,
   AuthStore,
-  CacheStore,
   CollectionService,
   CollectionsService,
   FilesService,
@@ -1932,7 +1784,6 @@ function createClient(options) {
   getFileUrl,
   getScaleUrl,
   getThumbUrl,
-  resolveCacheDirective,
   schemaFieldType,
   wsUrlFromBaseUrl
 });