lazypock 0.1.0

package/dist/index.cjs

@@ -0,0 +1,971 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  AuthStore: () => AuthStore,
+  FilesService: () => FilesService,
+  LazypockClient: () => LazypockClient,
+  RealtimeService: () => RealtimeService,
+  getFileUrl: () => getFileUrl,
+  wsUrlFromBaseUrl: () => wsUrlFromBaseUrl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var ApiError = class extends Error {
+  constructor(message, data, status) {
+    super(message);
+    this.name = "ApiError";
+    this.data = data;
+    this.status = status;
+  }
+};
+
+// src/http.ts
+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) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.authStore = authStore;
+    this.defaultFetch = globalThis.fetch.bind(globalThis);
+  }
+  async refreshAuth() {
+    const collection = this.authStore.collectionName;
+    if (!collection) return null;
+    try {
+      const url = this.baseUrl + "/" + encodeURIComponent(collection) + "/auth-refresh";
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.authStore.token) {
+        headers["Authorization"] = "Bearer " + this.authStore.token;
+      }
+      const res = await this.defaultFetch(url, {
+        method: "POST",
+        headers
+      });
+      if (!res.ok) {
+        this.authStore.clear();
+        return null;
+      }
+      const data = await res.json();
+      if (data && typeof data.token === "string") {
+        this.authStore.set(
+          data.token,
+          data.record ?? null
+        );
+        return data;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Make an HTTP request with automatic auth token injection and optional auto-refresh.
+   *
+   * @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.
+   */
+  async request(method, path, body, options) {
+    if (this.authStore.isExpired && this.authStore.collectionName) {
+      await this.refreshAuth();
+    }
+    let url = this.baseUrl + path;
+    if (options?.params) {
+      const qs = new URLSearchParams(options.params).toString();
+      if (qs) {
+        url += (path.includes("?") ? "&" : "?") + qs;
+      }
+    }
+    const headers = {
+      ...options?.headers
+    };
+    if (!(body instanceof FormData)) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.authStore.token) {
+      headers["Authorization"] = "Bearer " + this.authStore.token;
+    }
+    const init = {
+      method,
+      headers,
+      signal: options?.signal
+    };
+    if (body != null && method !== "GET" && method !== "DELETE") {
+      if (body instanceof FormData) {
+        init.body = body;
+      } else {
+        init.body = JSON.stringify(body);
+      }
+    }
+    const fetcher = options?.fetch ?? this.defaultFetch;
+    const res = await fetcher(url, init);
+    if (res.status === 204) return null;
+    let bodyText = "";
+    let data = {};
+    try {
+      bodyText = await res.text();
+      if (bodyText) {
+        data = JSON.parse(bodyText);
+      }
+    } catch {
+    }
+    if (!res.ok) {
+      throw new ApiError(
+        (typeof data.message === "string" ? data.message : res.statusText) || `Request failed with status ${res.status}`,
+        data,
+        res.status
+      );
+    }
+    return data;
+  }
+  /**
+   * HTTP GET.
+   * @param path URL path.
+   * @param options Optional request options.
+   */
+  get(path, options) {
+    return this.request("GET", path, void 0, options);
+  }
+  /**
+   * HTTP POST.
+   * @param path URL path.
+   * @param body Optional request body.
+   * @param options Optional request options.
+   */
+  post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  /**
+   * HTTP PATCH.
+   * @param path URL path.
+   * @param body Optional request body.
+   * @param options Optional request options.
+   */
+  patch(path, body, options) {
+    return this.request("PATCH", path, body, options);
+  }
+  /**
+   * HTTP DELETE.
+   * @param path URL path.
+   * @param options Optional request options.
+   */
+  delete(path, options) {
+    return this.request("DELETE", path, void 0, options);
+  }
+};
+
+// src/auth.ts
+var TOKEN_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var AuthStore = class {
+  /**
+   * Create an AuthStore with optional custom storage adapter.
+   * @param storage Persistence backend. Defaults to `memoryStorage` (localStorage fallback).
+   */
+  constructor(storage) {
+    this._token = "";
+    this._model = null;
+    this._tokenExpiresAt = null;
+    this._collectionName = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.storage = storage ?? {
+      get: (_key) => null,
+      set: () => {
+      },
+      remove: () => {
+      }
+    };
+  }
+  /** The current JWT token string, or empty string if not authenticated. */
+  get token() {
+    return this._token;
+  }
+  /** The current authenticated user record, or null. */
+  get model() {
+    return this._model;
+  }
+  /** Whether a token exists (does not check expiry). */
+  get isValid() {
+    return !!this._token;
+  }
+  /**
+   * Whether the current token has expired (with a 30-second buffer).
+   * Returns false when no expiry has been recorded (e.g. superuser tokens).
+   */
+  get isExpired() {
+    return this._tokenExpiresAt !== null && Date.now() >= this._tokenExpiresAt - 3e4;
+  }
+  /** The auth collection name used for automatic token refresh. */
+  get collectionName() {
+    return this._collectionName;
+  }
+  /**
+   * Set the auth collection name (used internally by auto-refresh).
+   * @param name The collection name, or null for superuser tokens.
+   */
+  setCollectionName(name) {
+    this._collectionName = name;
+  }
+  /**
+   * Load persisted auth state from storage.
+   * Should be called once at application startup.
+   */
+  async init() {
+    const [token, model, expiresAt] = await Promise.all([
+      this.storage.get("auth_token"),
+      this.storage.get("auth_model"),
+      this.storage.get("auth_expires_at")
+    ]);
+    if (token) this._token = token;
+    if (expiresAt) this._tokenExpiresAt = parseInt(expiresAt, 10) || null;
+    if (model) {
+      try {
+        this._model = JSON.parse(model);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Update the current auth token and model, persist to storage, and notify listeners.
+   * @param token The JWT token string.
+   * @param model The authenticated user record, or null for superusers.
+   */
+  set(token, model) {
+    this._token = token;
+    this._model = model;
+    this._tokenExpiresAt = Date.now() + TOKEN_TTL_MS;
+    void Promise.all([
+      this.storage.set("auth_token", token),
+      this.storage.set("auth_expires_at", String(this._tokenExpiresAt)),
+      model ? this.storage.set("auth_model", JSON.stringify(model)) : this.storage.remove("auth_model")
+    ]);
+    this.notify();
+  }
+  /**
+   * Clear all auth state (token, model, expiry) and notify listeners.
+   */
+  clear() {
+    this._token = "";
+    this._model = null;
+    this._tokenExpiresAt = null;
+    this._collectionName = null;
+    void Promise.all([
+      this.storage.remove("auth_token"),
+      this.storage.remove("auth_expires_at"),
+      this.storage.remove("auth_model")
+    ]);
+    this.notify();
+  }
+  /**
+   * Register a listener for auth state changes.
+   * @param fn Callback invoked with (model, token) on every change.
+   * @returns An unsubscribe function.
+   */
+  onChange(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  notify() {
+    for (const fn of this.listeners) {
+      fn(this._model, this._token);
+    }
+  }
+};
+var memoryStorage = {
+  get(key) {
+    try {
+      return localStorage.getItem(key);
+    } catch {
+      return null;
+    }
+  },
+  set(key, value) {
+    try {
+      localStorage.setItem(key, value);
+    } catch {
+    }
+  },
+  remove(key) {
+    try {
+      localStorage.removeItem(key);
+    } catch {
+    }
+  }
+};
+
+// src/collection.ts
+var CollectionService = class {
+  /** @internal */
+  constructor(http, collectionName, authStore) {
+    this.http = http;
+    this.collectionName = collectionName;
+    this.authStore = authStore;
+  }
+  encodeId(id) {
+    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.
+   */
+  list(params, options) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.http.get(
+      "/" + this.encodeId(this.collectionName) + qs,
+      options
+    );
+  }
+  /**
+   * Get a single record by ID.
+   * @param id Record ID.
+   * @param options Optional request options.
+   */
+  getOne(id, options) {
+    return this.http.get(
+      "/" + this.encodeId(this.collectionName) + "/" + this.encodeId(id),
+      options
+    );
+  }
+  /**
+   * Create a new record.
+   * @param data Record fields.
+   * @param options Optional request options.
+   */
+  create(data, options) {
+    return this.http.post(
+      "/" + this.encodeId(this.collectionName),
+      data,
+      options
+    );
+  }
+  /**
+   * Update a record by ID.
+   * @param id Record ID.
+   * @param data Updated record fields.
+   * @param options Optional request options.
+   */
+  update(id, data, options) {
+    return this.http.patch(
+      "/" + this.encodeId(this.collectionName) + "/" + this.encodeId(id),
+      data,
+      options
+    );
+  }
+  /**
+   * Delete a record by ID.
+   * @param id Record ID.
+   * @param options Optional request options.
+   */
+  delete(id, options) {
+    return this.http.delete(
+      "/" + this.encodeId(this.collectionName) + "/" + this.encodeId(id),
+      options
+    );
+  }
+  // ── Expand / Relation Fields ──
+  /**
+   * Get a list of expandable (relation) fields for this collection.
+   * Useful for constructing `expand` query parameters.
+   */
+  async expandFields(options) {
+    const data = await this.http.get(
+      "/collections/" + this.encodeId(this.collectionName),
+      options
+    );
+    if (!data?.fields) return null;
+    return data.fields.filter((f) => f.type === "relation" && f.options?.collection).map((f) => ({
+      field: f.name,
+      targetCollection: f.options.collection
+    }));
+  }
+  // ── Auth Collection Methods ──
+  /**
+   * Authenticate with email/password against this auth collection.
+   * Stores the returned token and user model in the auth store.
+   */
+  async authWithPassword(identity, password, options) {
+    const data = await this.http.post(
+      "/" + this.encodeId(this.collectionName) + "/auth-with-password",
+      { identity, password },
+      options
+    );
+    if (data && this.authStore) {
+      this.authStore.setCollectionName(this.collectionName);
+      this.authStore.set(data.token, data.record);
+    }
+    return data;
+  }
+  /**
+   * Refresh the auth token for the currently authenticated user.
+   * Updates the stored token and user model.
+   */
+  async authRefresh(options) {
+    const data = await this.http.post(
+      "/" + this.encodeId(this.collectionName) + "/auth-refresh",
+      void 0,
+      options
+    );
+    if (data && this.authStore) {
+      this.authStore.setCollectionName(this.collectionName);
+      this.authStore.set(data.token, data.record);
+    }
+    return data;
+  }
+  /**
+   * Get available auth methods for this collection.
+   */
+  async authMethods(options) {
+    return this.http.get(
+      "/" + this.encodeId(this.collectionName) + "/auth-methods",
+      options
+    );
+  }
+};
+
+// src/realtime.ts
+function wsUrlFromBaseUrl(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    const protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    return `${protocol}//${url.host}/socket/websocket`;
+  } catch {
+    return `${baseUrl.replace(/^http/, "ws").replace(/\/api$/, "")}/socket/websocket`;
+  }
+}
+var RealtimeService = class {
+  constructor() {
+    this.ws = null;
+    this.refCounter = 0;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.reconnectTimer = null;
+    this.reconnectAttempt = 0;
+    this.maxReconnectDelay = 5e3;
+    this.url = "";
+    // ── Heartbeat ──
+    this.heartbeatInterval = null;
+  }
+  connect(opts) {
+    this.url = opts.url;
+    this.token = opts.token;
+    this.reconnectAttempt = 0;
+    this.doConnect();
+  }
+  disconnect() {
+    this.clearReconnectTimer();
+    this.ws?.close();
+    this.ws = null;
+  }
+  /**
+   * Subscribe to a topic (e.g. "collection:posts" or "collection:posts:*").
+   * The backend Channel authorizes via listRule on join.
+   */
+  subscribe(topic, callback) {
+    const subs = this.subscriptions.get(topic) || [];
+    subs.push({ topic, callback });
+    this.subscriptions.set(topic, subs);
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.joinTopic(topic);
+    }
+  }
+  /**
+   * Unsubscribe a specific callback from a topic.
+   */
+  unsubscribe(topic, callback) {
+    if (!callback) {
+      this.subscriptions.delete(topic);
+      return;
+    }
+    const subs = this.subscriptions.get(topic)?.filter((s) => s.callback !== callback);
+    if (subs && subs.length > 0) {
+      this.subscriptions.set(topic, subs);
+    } else {
+      this.subscriptions.delete(topic);
+    }
+  }
+  resubscribeAll() {
+    for (const topic of this.subscriptions.keys()) {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.joinTopic(topic);
+      }
+    }
+  }
+  doConnect() {
+    if (typeof WebSocket === "undefined") {
+      console.warn(
+        "[lazypock] WebSocket not available \u2014 realtime subscriptions disabled"
+      );
+      return;
+    }
+    let url = this.url;
+    if (this.token) {
+      url += (url.includes("?") ? "&" : "?") + "token=" + encodeURIComponent(this.token);
+    }
+    this.ws = new WebSocket(url);
+    this.ws.onopen = () => {
+      this.reconnectAttempt = 0;
+      this.resubscribeAll();
+      this.startHeartbeat();
+    };
+    this.ws.onmessage = (msg) => {
+      this.handleMessage(msg.data);
+    };
+    this.ws.onclose = () => {
+      this.stopHeartbeat();
+      this.onDisconnect?.();
+      this.scheduleReconnect();
+    };
+    this.ws.onerror = (err) => {
+      this.onError?.(err);
+    };
+  }
+  handleMessage(data) {
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (typeof parsed !== "object" || !parsed.topic || !parsed.event) return;
+    const topic = parsed.topic;
+    const event = parsed.event;
+    const payload = parsed.payload || {};
+    if (event === "phx_reply") return;
+    const subs = this.subscriptions.get(topic);
+    if (subs) {
+      const e = {
+        event,
+        topic,
+        payload
+      };
+      for (const s of subs) {
+        try {
+          s.callback(e);
+        } catch {
+        }
+      }
+    }
+  }
+  joinTopic(topic) {
+    const ref = this.nextRef();
+    const msg = JSON.stringify({
+      topic,
+      event: "phx_join",
+      payload: {},
+      ref
+    });
+    this.ws?.send(msg);
+  }
+  nextRef() {
+    this.refCounter++;
+    return this.refCounter.toString();
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        const ref = this.nextRef();
+        const msg = JSON.stringify({
+          topic: "phoenix",
+          event: "heartbeat",
+          payload: {},
+          ref
+        });
+        this.ws.send(msg);
+      }
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  // ── Reconnect ──
+  scheduleReconnect() {
+    this.clearReconnectTimer();
+    const delay = Math.min(
+      1e3 * 2 ** this.reconnectAttempt,
+      this.maxReconnectDelay
+    );
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.onReconnect?.();
+      this.doConnect();
+    }, delay);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+// src/files.ts
+function getFileUrl(baseUrl, fileId) {
+  return baseUrl.replace(/\/+$/, "") + "/files/" + encodeURIComponent(fileId);
+}
+var FilesService = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Upload a file or blob.
+   *
+   * @param file The File or Blob to upload.
+   * @param filename Optional filename (required if `file` is a Blob without a name).
+   * @param options Optional request options (signal, custom fetch).
+   * @param meta Optional metadata: collectionName, recordId, fieldName for ownership tracking.
+   */
+  async upload(file, filename, options, meta) {
+    if (typeof FormData === "undefined") {
+      throw new Error("FormData is not available in this environment");
+    }
+    const formData = new FormData();
+    const name = filename || (file instanceof File ? file.name : "file");
+    formData.append("file", file, name);
+    if (meta?.collectionName)
+      formData.append("collection_name", meta.collectionName);
+    if (meta?.recordId) formData.append("record_id", meta.recordId);
+    if (meta?.fieldName) formData.append("field_name", meta.fieldName);
+    const data = await this.http.request(
+      "POST",
+      "/files",
+      formData,
+      options
+    );
+    return data;
+  }
+  /**
+   * Fetch file metadata including URL.
+   * @param fileId The file ID.
+   */
+  async getUrl(fileId) {
+    const data = await this.http.request(
+      "GET",
+      "/files/" + encodeURIComponent(fileId)
+    );
+    if (data && typeof data === "object" && "url" in data) {
+      return data.url;
+    }
+    return null;
+  }
+  /**
+   * Delete a file by ID.
+   * @param fileId The file ID.
+   * @param options Optional request options.
+   */
+  async delete(fileId, options) {
+    return this.http.request(
+      "DELETE",
+      "/files/" + encodeURIComponent(fileId),
+      void 0,
+      options
+    );
+  }
+};
+
+// src/index.ts
+var LazypockClient = class {
+  /**
+   * Create a new Lazypock client.
+   * @param options Configuration options.
+   */
+  constructor(options) {
+    this.collectionCache = /* @__PURE__ */ new Map();
+    const baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.authStore = options.authStore ?? new AuthStore(options.storage ?? memoryStorage);
+    this.http = new HttpClient(baseUrl, this.authStore);
+    this.realtime = options.realtime ?? new RealtimeService();
+    this.files = new FilesService(this.http);
+  }
+  /**
+   * Get or create a typed service for the given collection.
+   * Services are cached after first access.
+   *
+   * @param name The collection name.
+   * @returns A {@link CollectionService} instance.
+   */
+  collection(name) {
+    let svc = this.collectionCache.get(name);
+    if (!svc) {
+      svc = new CollectionService(this.http, name, this.authStore);
+      this.collectionCache.set(name, svc);
+    }
+    return svc;
+  }
+  // ── Auth ──
+  /** Check whether any superuser exists (for login vs setup screen routing). */
+  async checkSuperuser() {
+    return this.http.get("/superusers/check");
+  }
+  /**
+   * Create the initial superuser account.
+   * Only works when no superuser exists yet.
+   * Stores the returned token in the auth store.
+   * @param email Superuser email.
+   * @param password Superuser password (min 8 chars).
+   */
+  async setup(email, password) {
+    const data = await this.http.post("/superusers/setup", { email, password });
+    if (data) {
+      this.authStore.setCollectionName(null);
+      this.authStore.set(data.token, null);
+    }
+    return data;
+  }
+  /**
+   * Authenticate as a superuser or auth collection user.
+   *
+   * When `collection` is provided, authenticates against
+   * `/{collection}/auth-with-password`. Otherwise logs in as superuser.
+   * Stores the returned token in the auth store.
+   *
+   * @param email User email or identity.
+   * @param password User password.
+   * @param collection Optional auth collection name.
+   */
+  async login(email, password, collection) {
+    let data;
+    if (collection) {
+      data = await this.http.post("/" + encodeURIComponent(collection) + "/auth-with-password", {
+        identity: email,
+        password
+      });
+      if (data && data.record) {
+        this.authStore.setCollectionName(collection);
+        this.authStore.set(data.token, data.record);
+      }
+    } else {
+      data = await this.http.post(
+        "/superusers/login",
+        { email, password }
+      );
+      if (data) {
+        this.authStore.setCollectionName(null);
+        this.authStore.set(data.token, null);
+      }
+    }
+    return data;
+  }
+  /** Fetch the current superuser profile and refresh the auth model. */
+  async me(options) {
+    const data = await this.http.get("/superusers/me", options);
+    if (data) {
+      this.authStore.set(this.authStore.token, data);
+    }
+    return data;
+  }
+  /**
+   * Authenticate against an auth collection with email/password.
+   * Stores the returned token and user record in the auth store.
+   *
+   * @param collection The auth collection name.
+   * @param identity Email or username.
+   * @param password Password.
+   * @param options Optional request options.
+   */
+  async authWithPassword(collection, identity, password, options) {
+    const data = await this.http.post(
+      "/" + encodeURIComponent(collection) + "/auth-with-password",
+      { identity, password },
+      options
+    );
+    if (data) {
+      this.authStore.setCollectionName(collection);
+      this.authStore.set(data.token, data.record);
+    }
+    return data;
+  }
+  /**
+   * Refresh an auth collection token.
+   * Uses the currently stored auth token.
+   *
+   * @param collection The auth collection name.
+   * @param options Optional request options.
+   */
+  async authRefresh(collection, options) {
+    const data = await this.http.post(
+      "/" + encodeURIComponent(collection) + "/auth-refresh",
+      void 0,
+      options
+    );
+    if (data) {
+      this.authStore.setCollectionName(collection);
+      this.authStore.set(data.token, data.record);
+    }
+    return data;
+  }
+  /** Clear the current auth state and remove persisted tokens. */
+  logout() {
+    this.authStore.clear();
+  }
+  // ── Health ──
+  /** Ping the API health endpoint. */
+  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
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AuthStore,
+  FilesService,
+  LazypockClient,
+  RealtimeService,
+  getFileUrl,
+  wsUrlFromBaseUrl
+});
+//# sourceMappingURL=index.cjs.map