nodestack-client 1.0.0

package/dist/index.mjs

@@ -0,0 +1,948 @@
+// src/auth/BaseAuthStore.ts
+function decodeJwtPayload(token) {
+  if (!token || typeof token !== "string") return null;
+  const parts = token.split(".");
+  if (parts.length !== 3) return null;
+  try {
+    let b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    while (b64.length % 4) {
+      b64 += "=";
+    }
+    let jsonStr;
+    const globalObj = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {};
+    if (typeof globalObj.atob === "function") {
+      jsonStr = decodeURIComponent(
+        Array.prototype.map.call(globalObj.atob(b64), (c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+      );
+    } else if (typeof globalObj.Buffer !== "undefined") {
+      jsonStr = globalObj.Buffer.from(b64, "base64").toString("utf8");
+    } else {
+      return null;
+    }
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+var BaseAuthStore = class {
+  _token = "";
+  _model = null;
+  _listeners = /* @__PURE__ */ new Set();
+  get token() {
+    return this._token;
+  }
+  get model() {
+    return this._model;
+  }
+  /**
+   * Returns true if a token exists and has not yet expired.
+   */
+  get isValid() {
+    if (!this._token) {
+      return false;
+    }
+    const payload = decodeJwtPayload(this._token);
+    if (!payload) {
+      return false;
+    }
+    if (payload.exp && typeof payload.exp === "number") {
+      const now = Math.floor(Date.now() / 1e3);
+      return payload.exp > now;
+    }
+    return true;
+  }
+  /**
+   * Saves the token and associated user or admin model.
+   */
+  save(token, model) {
+    this._token = token || "";
+    this._model = model || null;
+    this.notify();
+  }
+  /**
+   * Clears the current authentication state.
+   */
+  clear() {
+    this._token = "";
+    this._model = null;
+    this.notify();
+  }
+  /**
+   * Subscribes to changes in authentication state (token or model).
+   * Returns an unbind function.
+   */
+  onChange(callback, fireImmediately = false) {
+    this._listeners.add(callback);
+    if (fireImmediately) {
+      try {
+        callback(this._token, this._model);
+      } catch (err) {
+        console.error("[AuthStore] Error in immediate onChange listener:", err);
+      }
+    }
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  /**
+   * Triggers all subscribed change listeners.
+   */
+  notify() {
+    for (const listener of this._listeners) {
+      try {
+        listener(this._token, this._model);
+      } catch (err) {
+        console.error("[AuthStore] Error in onChange listener:", err);
+      }
+    }
+  }
+};
+
+// src/auth/LocalAuthStore.ts
+var DEFAULT_STORAGE_KEY = "nodestack_auth";
+var LocalAuthStore = class extends BaseAuthStore {
+  storageKey;
+  storage;
+  constructor(storageKey = DEFAULT_STORAGE_KEY, customStorage) {
+    super();
+    this.storageKey = storageKey;
+    if (customStorage) {
+      this.storage = customStorage;
+    } else if (typeof window !== "undefined" && window.localStorage) {
+      this.storage = window.localStorage;
+    }
+    this.loadInitial();
+  }
+  loadInitial() {
+    if (!this.storage) return;
+    try {
+      const raw = this.storage.getItem(this.storageKey);
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.token === "string") {
+          this._token = parsed.token;
+          this._model = parsed.model || null;
+        }
+      }
+    } catch {
+    }
+  }
+  save(token, model) {
+    super.save(token, model);
+    if (this.storage) {
+      try {
+        this.storage.setItem(
+          this.storageKey,
+          JSON.stringify({
+            token: this._token,
+            model: this._model
+          })
+        );
+      } catch {
+      }
+    }
+  }
+  clear() {
+    super.clear();
+    if (this.storage) {
+      try {
+        this.storage.removeItem(this.storageKey);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/errors/ClientResponseError.ts
+var ClientResponseError = class _ClientResponseError extends Error {
+  url;
+  status;
+  data;
+  isAbort;
+  originalError;
+  constructor(options = {}) {
+    const status = options.status || 0;
+    const message = options.message || options.data?.message || (status > 0 ? `NodeStack request failed with status ${status}` : "NodeStack network request failed");
+    super(message);
+    this.name = "ClientResponseError";
+    this.url = options.url || "";
+    this.status = status;
+    this.data = options.data || {};
+    this.isAbort = Boolean(options.isAbort);
+    this.originalError = options.originalError;
+    Object.setPrototypeOf(this, _ClientResponseError.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      url: this.url,
+      status: this.status,
+      data: this.data,
+      isAbort: this.isAbort
+    };
+  }
+};
+
+// src/services/BaseService.ts
+var BaseService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  send(path, options = {}) {
+    return this.client.send(path, options);
+  }
+};
+
+// src/services/RecordService.ts
+var RecordService = class extends BaseService {
+  constructor(client, collectionName) {
+    super(client);
+    this.collectionName = collectionName;
+  }
+  collectionName;
+  get clientWithRealtime() {
+    return this.client;
+  }
+  /**
+   * Returns a paginated list of records matching the query options.
+   */
+  async getList(page = 1, perPage = 30, options = {}) {
+    return this.send(
+      `/api/collections/${encodeURIComponent(this.collectionName)}/records`,
+      {
+        method: "GET",
+        query: {
+          page,
+          perPage,
+          ...options
+        }
+      }
+    );
+  }
+  /**
+   * Fetches and aggregates all records in the collection across multiple pages.
+   */
+  async getFullList(options = {}) {
+    const batch = Math.max(1, Math.min(500, options.batch || 200));
+    const query = { ...options };
+    delete query.batch;
+    const firstPage = await this.getList(1, batch, query);
+    const items = [...firstPage.items];
+    if (firstPage.totalPages <= 1) {
+      return items;
+    }
+    for (let page = 2; page <= firstPage.totalPages; page++) {
+      const result = await this.getList(page, batch, query);
+      items.push(...result.items);
+    }
+    return items;
+  }
+  /**
+   * Returns the first record matching the specified filter expression.
+   * Throws ClientResponseError(404) if no record matches.
+   */
+  async getFirstListItem(filter, options = {}) {
+    const list = await this.getList(1, 1, {
+      ...options,
+      filter
+    });
+    if (!list.items || list.items.length === 0) {
+      throw new ClientResponseError({
+        status: 404,
+        url: `/api/collections/${this.collectionName}/records`,
+        message: `The requested record was not found in collection '${this.collectionName}'.`
+      });
+    }
+    return list.items[0];
+  }
+  /**
+   * Retrieves a single record by its ID.
+   */
+  async getOne(id, options = {}) {
+    return this.send(
+      `/api/collections/${encodeURIComponent(this.collectionName)}/records/${encodeURIComponent(id)}`,
+      {
+        method: "GET",
+        query: options
+      }
+    );
+  }
+  /**
+   * Creates a new record in the collection.
+   * Accepts a plain object or FormData (for file uploads).
+   */
+  async create(data, options = {}) {
+    return this.send(
+      `/api/collections/${encodeURIComponent(this.collectionName)}/records`,
+      {
+        method: "POST",
+        body: data,
+        query: options
+      }
+    );
+  }
+  /**
+   * Updates an existing record by its ID.
+   * Accepts a plain object or FormData (for file updates).
+   */
+  async update(id, data, options = {}) {
+    return this.send(
+      `/api/collections/${encodeURIComponent(this.collectionName)}/records/${encodeURIComponent(id)}`,
+      {
+        method: "PATCH",
+        body: data,
+        query: options
+      }
+    );
+  }
+  /**
+   * Deletes a record by its ID.
+   */
+  async delete(id) {
+    await this.send(
+      `/api/collections/${encodeURIComponent(this.collectionName)}/records/${encodeURIComponent(id)}`,
+      {
+        method: "DELETE"
+      }
+    );
+    return true;
+  }
+  /**
+   * Authenticates against an auth collection using identity/email and password.
+   * On success, automatically persists the token and record to authStore.
+   */
+  async authWithPassword(identity, password) {
+    const result = await this.send(
+      `/api/collections/${encodeURIComponent(this.collectionName)}/auth-with-password`,
+      {
+        method: "POST",
+        body: { identity, password }
+      }
+    );
+    if (result && result.token) {
+      this.client.authStore.save(result.token, result.record);
+    }
+    return result;
+  }
+  /**
+   * Exports records from the collection as CSV or JSON.
+   */
+  async export(format = "csv", options = {}) {
+    return this.send(
+      `/api/collections/${encodeURIComponent(this.collectionName)}/export`,
+      {
+        method: "GET",
+        query: {
+          ...options,
+          format
+        }
+      }
+    );
+  }
+  /**
+   * Imports records into the collection.
+   */
+  async import(data, options = {}) {
+    return this.send(
+      `/api/collections/${encodeURIComponent(this.collectionName)}/import`,
+      {
+        method: "POST",
+        body: data,
+        query: options
+      }
+    );
+  }
+  /**
+   * Subscribes to realtime events on this collection or a specific record ID.
+   *
+   * Example:
+   *   // Listen to all records in collection:
+   *   client.collection('posts').subscribe('*', (e) => console.log(e.action, e.record));
+   *
+   *   // Listen to single record changes:
+   *   client.collection('posts').subscribe('record_id_123', (e) => console.log(e.action, e.record));
+   */
+  async subscribe(topicOrCallback, callback) {
+    let topic = "*";
+    let cb;
+    if (typeof topicOrCallback === "function") {
+      topic = "*";
+      cb = topicOrCallback;
+    } else {
+      topic = topicOrCallback;
+      cb = callback;
+    }
+    const fullTopic = topic === "*" ? this.collectionName : `${this.collectionName}/${topic}`;
+    return this.clientWithRealtime.realtime.subscribe(fullTopic, cb);
+  }
+  /**
+   * Unsubscribes from realtime events for this collection.
+   */
+  async unsubscribe(topic) {
+    const fullTopic = !topic || topic === "*" ? this.collectionName : `${this.collectionName}/${topic}`;
+    return this.clientWithRealtime.realtime.unsubscribe(fullTopic);
+  }
+};
+
+// src/services/FileService.ts
+var FileService = class extends BaseService {
+  /**
+   * Generates a fully qualified URL to an uploaded file.
+   *
+   * @param record - Record object or record ID string
+   * @param filename - Name of the file stored on the record
+   * @param options - Additional options (download flag, auth token, collection override)
+   */
+  getUrl(record, filename, options = {}) {
+    if (!filename) return "";
+    let recordId = "";
+    let collectionName = options.collection || "";
+    if (typeof record === "string") {
+      recordId = record;
+    } else if (record && typeof record === "object") {
+      recordId = record.id || "";
+      collectionName = collectionName || record.collection || record.collectionName || record["@collectionName"] || "";
+    }
+    if (!recordId) {
+      throw new Error("[FileService] A valid record or recordId is required to construct a file URL.");
+    }
+    if (!collectionName) {
+      throw new Error(
+        "[FileService] Collection name is required. Either provide a record with collection info or pass options.collection."
+      );
+    }
+    const cleanBase = (this.client.baseUrl || "").replace(/\/+$/, "");
+    const cleanCol = encodeURIComponent(collectionName);
+    const cleanId = encodeURIComponent(recordId);
+    const cleanFile = encodeURIComponent(filename);
+    let url = `${cleanBase}/api/files/${cleanCol}/${cleanId}/${cleanFile}`;
+    const queryParts = [];
+    if (options.download) {
+      queryParts.push("download=1");
+    }
+    if (typeof options.token === "string" && options.token) {
+      queryParts.push(`token=${encodeURIComponent(options.token)}`);
+    } else if (options.token === true && this.client.authStore.token) {
+      queryParts.push(`token=${encodeURIComponent(this.client.authStore.token)}`);
+    }
+    if (queryParts.length > 0) {
+      url += `?${queryParts.join("&")}`;
+    }
+    return url;
+  }
+};
+
+// src/services/RealtimeService.ts
+var RealtimeService = class extends BaseService {
+  eventSource = null;
+  clientId = "";
+  isConnecting = false;
+  connectPromise = null;
+  reconnectTimeout = null;
+  reconnectAttempts = 0;
+  customEventSource;
+  // Map of topic -> Set of callbacks
+  subscriptions = /* @__PURE__ */ new Map();
+  // Set of registered event names on the active EventSource
+  registeredEventNames = /* @__PURE__ */ new Set();
+  constructor(client, customEventSource) {
+    super(client);
+    this.customEventSource = customEventSource;
+  }
+  /**
+   * Returns whether there is an active EventSource connection.
+   */
+  get isConnected() {
+    return Boolean(this.eventSource && this.clientId);
+  }
+  /**
+   * Resolves the EventSource constructor available in the current environment.
+   */
+  getEventSourceConstructor() {
+    if (this.customEventSource) {
+      return this.customEventSource;
+    }
+    if (typeof window !== "undefined" && window.EventSource) {
+      return window.EventSource;
+    }
+    if (typeof globalThis !== "undefined" && globalThis.EventSource) {
+      return globalThis.EventSource;
+    }
+    throw new Error(
+      '[RealtimeService] EventSource is not supported natively in this environment. Please pass an EventSource polyfill to ClientOptions (e.g. from the "eventsource" package).'
+    );
+  }
+  /**
+   * Connects to the SSE stream if not already connected.
+   * Returns the connected clientId.
+   */
+  async connect() {
+    if (this.clientId && this.eventSource) {
+      return this.clientId;
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = new Promise((resolve, reject) => {
+      try {
+        const EventSourceClass = this.getEventSourceConstructor();
+        const base = (this.client.baseUrl || "").replace(/\/+$/, "");
+        let url = `${base}/api/realtime`;
+        if (this.client.authStore.token) {
+          url += `?token=${encodeURIComponent(this.client.authStore.token)}`;
+        }
+        this.eventSource = new EventSourceClass(url);
+        const handleConnect = async (event) => {
+          try {
+            const data = JSON.parse(event.data);
+            this.clientId = data.clientId;
+            this.reconnectAttempts = 0;
+            await this.syncSubscriptions();
+            resolve(this.clientId);
+          } catch (err) {
+            reject(err);
+          }
+        };
+        this.eventSource.addEventListener("NS_CONNECT", handleConnect);
+        this.eventSource.addEventListener("NB_CONNECT", handleConnect);
+        this.eventSource.onerror = (err) => {
+          if (!this.clientId) {
+            reject(err);
+          }
+          this.handleDisconnect();
+        };
+        this.bindActiveTopics();
+      } catch (err) {
+        this.connectPromise = null;
+        reject(err);
+      }
+    }).finally(() => {
+      this.connectPromise = null;
+    });
+    return this.connectPromise;
+  }
+  /**
+   * Subscribes to realtime updates for a collection or record.
+   *
+   * @param topic - Collection name ('posts'), wildcard ('*'), or specific record ('posts/rec_123')
+   * @param callback - Event listener callback
+   * @returns Unsubscribe function
+   */
+  async subscribe(topic, callback) {
+    const cleanTopic = (topic || "*").trim();
+    if (!this.subscriptions.has(cleanTopic)) {
+      this.subscriptions.set(cleanTopic, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(cleanTopic).add(callback);
+    if (this.isConnected) {
+      this.bindTopicListener(cleanTopic);
+      await this.syncSubscriptions();
+    } else {
+      await this.connect();
+    }
+    return () => this.unsubscribe(cleanTopic, callback);
+  }
+  /**
+   * Unsubscribes from a topic or specific callback.
+   */
+  async unsubscribe(topic, callback) {
+    if (!topic) {
+      this.subscriptions.clear();
+      if (this.isConnected) {
+        await this.syncSubscriptions();
+      }
+      return;
+    }
+    const cleanTopic = topic.trim();
+    if (!this.subscriptions.has(cleanTopic)) {
+      return;
+    }
+    if (callback) {
+      this.subscriptions.get(cleanTopic).delete(callback);
+      if (this.subscriptions.get(cleanTopic).size === 0) {
+        this.subscriptions.delete(cleanTopic);
+      }
+    } else {
+      this.subscriptions.delete(cleanTopic);
+    }
+    if (this.isConnected) {
+      await this.syncSubscriptions();
+    }
+  }
+  /**
+   * Closes the SSE connection and clears state.
+   */
+  disconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.eventSource) {
+      try {
+        this.eventSource.close();
+      } catch {
+      }
+      this.eventSource = null;
+    }
+    this.clientId = "";
+    this.registeredEventNames.clear();
+  }
+  /**
+   * Synchronizes active subscriptions with the backend via POST /api/realtime.
+   */
+  async syncSubscriptions() {
+    if (!this.clientId) return;
+    const topics = Array.from(this.subscriptions.keys());
+    try {
+      await this.client.send("/api/realtime", {
+        method: "POST",
+        body: {
+          clientId: this.clientId,
+          subscriptions: topics.length > 0 ? topics : ["__noop__"]
+        }
+      });
+    } catch (err) {
+      console.warn("[RealtimeService] Failed to sync subscriptions with server:", err);
+    }
+  }
+  /**
+   * Binds an EventSource listener for the collection corresponding to a topic.
+   */
+  bindTopicListener(topic) {
+    if (!this.eventSource) return;
+    const collectionName = topic.includes("/") ? topic.split("/")[0] : topic;
+    if (this.registeredEventNames.has(collectionName)) {
+      return;
+    }
+    this.registeredEventNames.add(collectionName);
+    this.eventSource.addEventListener(collectionName, (event) => {
+      try {
+        const payload = JSON.parse(event.data);
+        this.dispatchEvent(collectionName, payload);
+      } catch (err) {
+        console.error(`[RealtimeService] Error handling event for ${collectionName}:`, err);
+      }
+    });
+  }
+  bindActiveTopics() {
+    for (const topic of this.subscriptions.keys()) {
+      this.bindTopicListener(topic);
+    }
+  }
+  /**
+   * Dispatches received SSE events to matching subscribed listeners.
+   */
+  dispatchEvent(collectionName, event) {
+    const recordId = event.record?.id;
+    this.triggerListeners("*", event);
+    this.triggerListeners(collectionName, event);
+    this.triggerListeners(`${collectionName}/*`, event);
+    if (recordId) {
+      this.triggerListeners(`${collectionName}/${recordId}`, event);
+    }
+  }
+  triggerListeners(topic, event) {
+    const callbacks = this.subscriptions.get(topic);
+    if (!callbacks || callbacks.size === 0) return;
+    for (const cb of callbacks) {
+      try {
+        cb(event);
+      } catch (err) {
+        console.error(`[RealtimeService] Error in realtime listener for ${topic}:`, err);
+      }
+    }
+  }
+  /**
+   * Handles disconnections and schedules automatic reconnection.
+   */
+  handleDisconnect() {
+    if (this.reconnectTimeout) return;
+    this.disconnect();
+    const delay = Math.min(1e4, 500 * Math.pow(1.5, this.reconnectAttempts));
+    this.reconnectAttempts++;
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      if (this.subscriptions.size > 0) {
+        this.connect().catch(() => {
+        });
+      }
+    }, delay);
+  }
+};
+
+// src/services/AdminService.ts
+var AdminService = class extends BaseService {
+  /**
+   * Checks whether at least one superuser / admin account exists in NodeStack.
+   */
+  async hasAdmins() {
+    const res = await this.send("/api/admins/has-admins", {
+      method: "GET"
+    });
+    return Boolean(res?.hasAdmins);
+  }
+  /**
+   * Creates the initial superuser account during first-time setup.
+   * Automatically persists the returned admin token and model to authStore.
+   */
+  async createInitial(email, password) {
+    const res = await this.send("/api/admins/create-initial", {
+      method: "POST",
+      body: { email, password }
+    });
+    if (res?.token) {
+      this.client.authStore.save(res.token, res.admin);
+    }
+    return res;
+  }
+  /**
+   * Authenticates a superuser / admin using email and password.
+   * Automatically persists the returned admin token and model to authStore.
+   */
+  async authWithPassword(identity, password) {
+    const res = await this.send("/api/admins/auth-with-password", {
+      method: "POST",
+      body: { identity, password }
+    });
+    if (res?.token) {
+      this.client.authStore.save(res.token, res.admin);
+    }
+    return res;
+  }
+  /**
+   * Retrieves the currently authenticated superuser's profile.
+   */
+  async getMe() {
+    return this.send("/api/admins/me", {
+      method: "GET"
+    });
+  }
+};
+
+// src/services/CollectionService.ts
+var CollectionService = class extends BaseService {
+  /**
+   * Retrieves all collection schema models.
+   */
+  async getList() {
+    const res = await this.send("/api/collections", {
+      method: "GET"
+    });
+    return Array.isArray(res) ? res : res?.items || [];
+  }
+  /**
+   * Retrieves a single collection schema by name or ID.
+   */
+  async getOne(nameOrId) {
+    return this.send(`/api/collections/${encodeURIComponent(nameOrId)}`, {
+      method: "GET"
+    });
+  }
+  /**
+   * Creates a new collection schema.
+   */
+  async create(data) {
+    return this.send("/api/collections", {
+      method: "POST",
+      body: data
+    });
+  }
+  /**
+   * Updates an existing collection schema.
+   */
+  async update(nameOrId, data) {
+    return this.send(`/api/collections/${encodeURIComponent(nameOrId)}`, {
+      method: "PATCH",
+      body: data
+    });
+  }
+  /**
+   * Deletes a collection schema and its corresponding SQLite table.
+   */
+  async delete(nameOrId) {
+    await this.send(`/api/collections/${encodeURIComponent(nameOrId)}`, {
+      method: "DELETE"
+    });
+    return true;
+  }
+};
+
+// src/Client.ts
+var NodeStackClient = class {
+  baseUrl;
+  authStore;
+  files;
+  realtime;
+  admins;
+  collections;
+  customFetch;
+  defaultHeaders;
+  defaultTimeout;
+  recordServices = /* @__PURE__ */ new Map();
+  constructor(baseUrl = "/", options = {}) {
+    this.baseUrl = (baseUrl || "/").replace(/\/+$/, "");
+    this.authStore = options.authStore || new LocalAuthStore();
+    this.customFetch = options.fetch;
+    this.defaultHeaders = options.headers || {};
+    this.defaultTimeout = options.timeout || 12e4;
+    this.files = new FileService(this);
+    this.realtime = new RealtimeService(this, options.EventSource);
+    this.admins = new AdminService(this);
+    this.collections = new CollectionService(this);
+  }
+  collection(name) {
+    const colName = String(name);
+    let service = this.recordServices.get(colName);
+    if (!service) {
+      service = new RecordService(this, colName);
+      this.recordServices.set(colName, service);
+    }
+    return service;
+  }
+  /**
+   * Sends an HTTP request to NodeStack with automatic authentication,
+   * header injection, query serialization, and standardized error handling.
+   */
+  async send(path, options = {}) {
+    const fetchFn = this.customFetch || (typeof fetch !== "undefined" ? fetch : null);
+    if (!fetchFn) {
+      throw new Error(
+        "[NodeStackClient] fetch is not available in this environment. Please pass a custom fetch implementation to ClientOptions."
+      );
+    }
+    let url = path.startsWith("http://") || path.startsWith("https://") ? path : `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    if (options.query) {
+      const searchParams = new URLSearchParams();
+      for (const [key, val] of Object.entries(options.query)) {
+        if (val === void 0 || val === null) continue;
+        searchParams.append(key, String(val));
+      }
+      const queryStr = searchParams.toString();
+      if (queryStr) {
+        url += (url.includes("?") ? "&" : "?") + queryStr;
+      }
+    }
+    const headers = {
+      ...this.defaultHeaders,
+      ...options.headers || {}
+    };
+    if (this.authStore.token && !headers["Authorization"] && !headers["authorization"]) {
+      headers["Authorization"] = `Bearer ${this.authStore.token}`;
+    }
+    let body = options.body;
+    const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+    const isBlob = typeof Blob !== "undefined" && body instanceof Blob;
+    if (body !== void 0 && body !== null) {
+      if (isFormData) {
+        delete headers["Content-Type"];
+        delete headers["content-type"];
+      } else if (isBlob || typeof body === "string") {
+      } else if (typeof body === "object") {
+        headers["Content-Type"] = "application/json";
+        body = JSON.stringify(body);
+      }
+    }
+    let signal = options.signal;
+    let timeoutId = null;
+    if (!signal && this.defaultTimeout > 0 && typeof AbortController !== "undefined") {
+      const controller = new AbortController();
+      signal = controller.signal;
+      timeoutId = setTimeout(() => controller.abort(), this.defaultTimeout);
+    }
+    try {
+      const response = await fetchFn(url, {
+        ...options,
+        headers,
+        body,
+        signal
+      });
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (response.status === 204) {
+        return null;
+      }
+      const contentType = response.headers.get("content-type") || "";
+      let data;
+      if (contentType.includes("application/json")) {
+        data = await response.json().catch(() => ({}));
+      } else {
+        data = await response.text();
+      }
+      if (!response.ok) {
+        throw new ClientResponseError({
+          url,
+          status: response.status,
+          data,
+          message: typeof data === "object" && data?.message ? data.message : void 0
+        });
+      }
+      return data;
+    } catch (err) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (err instanceof ClientResponseError) {
+        throw err;
+      }
+      const isAbort = err?.name === "AbortError" || signal && signal.aborted || Boolean(options.signal && options.signal.aborted);
+      throw new ClientResponseError({
+        url,
+        status: isAbort ? 0 : 0,
+        isAbort,
+        originalError: err,
+        message: isAbort ? "Request was aborted" : err?.message || "Network request failed"
+      });
+    }
+  }
+  /**
+   * Checks backend system health.
+   */
+  async health() {
+    return this.send("/api/health", { method: "GET" });
+  }
+  /**
+   * Retrieves server runtime settings.
+   */
+  async settings() {
+    return this.send("/api/settings", { method: "GET" });
+  }
+  /**
+   * Fetches request logs (Admin only).
+   */
+  async logs(page = 1, perPage = 50) {
+    return this.send("/api/logs", {
+      method: "GET",
+      query: { page, perPage }
+    });
+  }
+  /**
+   * Fetches system metrics & analytics (Admin only).
+   */
+  async metrics() {
+    return this.send("/api/metrics", { method: "GET" });
+  }
+};
+
+// src/auth/MemoryAuthStore.ts
+var MemoryAuthStore = class extends BaseAuthStore {
+  // Inherits default in-memory behavior of BaseAuthStore
+};
+export {
+  AdminService,
+  BaseAuthStore,
+  BaseService,
+  ClientResponseError,
+  CollectionService,
+  FileService,
+  LocalAuthStore,
+  MemoryAuthStore,
+  NodeStackClient,
+  RealtimeService,
+  RecordService,
+  decodeJwtPayload,
+  NodeStackClient as default
+};
+//# sourceMappingURL=index.mjs.map