alsabase 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1428 @@
+"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, {
+  AlsaBase: () => AlsaBase,
+  AsyncAuthStore: () => AsyncAuthStore,
+  BaseAuthStore: () => BaseAuthStore,
+  BaseService: () => BaseService,
+  Client: () => AlsaBase,
+  ClientResponseError: () => ClientResponseError,
+  CollectionService: () => CollectionService,
+  FileService: () => FileService,
+  HooksService: () => HooksService,
+  LocalAuthStore: () => LocalAuthStore,
+  LogService: () => LogService,
+  RealtimeService: () => RealtimeService,
+  RecordService: () => RecordService,
+  SuperuserService: () => SuperuserService,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/stores/BaseAuthStore.ts
+var BaseAuthStore = class {
+  _token = "";
+  _model = null;
+  _listeners = /* @__PURE__ */ new Set();
+  get token() {
+    return this._token;
+  }
+  get model() {
+    return this._model;
+  }
+  get isValid() {
+    if (!this.token) return false;
+    const jwt = this.parseJwt(this.token);
+    if (!jwt || !jwt.exp) return true;
+    const now = Math.floor(Date.now() / 1e3);
+    return jwt.exp > now;
+  }
+  get isSuperuser() {
+    if (!this.model) return false;
+    return !!this.model.email && this.model.collectionName === void 0;
+  }
+  get isAdmin() {
+    return this.isSuperuser;
+  }
+  save(token, model) {
+    this._token = token || "";
+    this._model = model || null;
+    this.triggerChange();
+  }
+  clear() {
+    this._token = "";
+    this._model = null;
+    this.triggerChange();
+  }
+  onChange(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  triggerChange() {
+    for (const listener of this._listeners) {
+      try {
+        listener(this._token, this._model);
+      } catch (err) {
+        console.error("AuthStore change listener error:", err);
+      }
+    }
+  }
+  parseJwt(token) {
+    if (!token) return null;
+    try {
+      const base64Url = token.split(".")[1];
+      if (!base64Url) return null;
+      const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+      let jsonPayload;
+      if (typeof atob === "function") {
+        jsonPayload = decodeURIComponent(
+          atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+        );
+      } else if (typeof globalThis.Buffer !== "undefined") {
+        jsonPayload = globalThis.Buffer.from(base64, "base64").toString("utf8");
+      } else {
+        return null;
+      }
+      return JSON.parse(jsonPayload);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/stores/LocalAuthStore.ts
+var DEFAULT_STORAGE_KEY = "alsabase_auth";
+var LocalAuthStore = class extends BaseAuthStore {
+  storageKey;
+  constructor(storageKey = DEFAULT_STORAGE_KEY) {
+    super();
+    this.storageKey = storageKey;
+    this.loadInitial();
+  }
+  loadInitial() {
+    if (typeof window === "undefined" || !window.localStorage) return;
+    try {
+      const raw = window.localStorage.getItem(this.storageKey);
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") {
+        this._token = parsed.token || "";
+        this._model = parsed.model || null;
+      }
+    } catch {
+    }
+  }
+  save(token, model) {
+    super.save(token, model);
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        window.localStorage.setItem(
+          this.storageKey,
+          JSON.stringify({ token: this._token, model: this._model })
+        );
+      } catch {
+      }
+    }
+  }
+  clear() {
+    super.clear();
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        window.localStorage.removeItem(this.storageKey);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/ClientResponseError.ts
+var ClientResponseError = class _ClientResponseError extends Error {
+  url = "";
+  status = 0;
+  response = {};
+  data = {};
+  isAbort = false;
+  originalError = null;
+  constructor(errData) {
+    super("ClientResponseError");
+    if (errData !== null && typeof errData === "object") {
+      this.url = errData.url || "";
+      this.status = errData.status || 0;
+      this.data = errData.data || {};
+      this.response = errData.response || this.data;
+      this.isAbort = !!errData.isAbort;
+      this.originalError = errData.originalError || null;
+      if (errData.message) {
+        this.message = errData.message;
+      } else if (this.data?.message) {
+        this.message = this.data.message;
+      } else if (this.data?.error) {
+        this.message = this.data.error;
+      } else if (this.status) {
+        this.message = `Response error. Status code: ${this.status}`;
+      }
+    }
+    if (typeof DOMException !== "undefined" && errData instanceof DOMException && errData.name === "AbortError") {
+      this.isAbort = true;
+      this.message = "The request was autocancelled or aborted.";
+    }
+    Object.setPrototypeOf(this, _ClientResponseError.prototype);
+  }
+  toJSON() {
+    return {
+      url: this.url,
+      status: this.status,
+      data: this.data,
+      response: this.response,
+      isAbort: this.isAbort,
+      message: this.message
+    };
+  }
+};
+
+// src/services/BaseService.ts
+var BaseService = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async send(path, options) {
+    return this.client.send(path, options);
+  }
+};
+
+// src/services/RecordService.ts
+var RecordService = class extends BaseService {
+  collectionIdOrName;
+  constructor(client, collectionIdOrName) {
+    super(client);
+    this.collectionIdOrName = collectionIdOrName;
+  }
+  /**
+   * Base API endpoint path for the collection records
+   */
+  get baseCrudPath() {
+    return `/api/collections/${encodeURIComponent(this.collectionIdOrName)}/records`;
+  }
+  /**
+   * Returns the current schema and column definitions of this table/collection (Requires Superuser authentication)
+   */
+  async getSchema(options) {
+    return this.client.collections.getOne(this.collectionIdOrName, options);
+  }
+  /**
+   * Returns the schema of this table/collection (Requires Superuser authentication)
+   * Alias for getSchema()
+   */
+  async schema(options) {
+    return this.getSchema(options);
+  }
+  /**
+   * Returns the schema of this table/collection (Requires Superuser authentication)
+   * Alias for getSchema()
+   */
+  async getTableSchema(options) {
+    return this.getSchema(options);
+  }
+  /**
+   * Returns a paginated list of records
+   */
+  async getList(page = 1, perPage = 30, options) {
+    const query = {
+      page,
+      limit: perPage,
+      ...options
+    };
+    return this.send(this.baseCrudPath, {
+      method: "GET",
+      query,
+      ...options
+    });
+  }
+  /**
+   * Returns a list of all records in batches
+   */
+  async getFullList(options) {
+    const batchSize = options?.batch || 200;
+    let page = 1;
+    let result = [];
+    let hasMore = true;
+    while (hasMore) {
+      const list = await this.getList(page, batchSize, {
+        ...options,
+        skipTotal: true
+      });
+      result = result.concat(list.items);
+      if (list.items.length < batchSize || list.totalPages && page >= list.totalPages) {
+        hasMore = false;
+      } else {
+        page++;
+      }
+    }
+    return result;
+  }
+  /**
+   * Returns the first record matching the specified filter expression
+   */
+  async getFirstListItem(filter, options) {
+    const list = await this.getList(1, 1, {
+      ...options,
+      filter
+    });
+    if (!list.items || list.items.length === 0) {
+      throw new Error(`Record not found for filter: ${filter}`);
+    }
+    return list.items[0];
+  }
+  /**
+   * Returns a single record by its ID
+   */
+  async getOne(id, options) {
+    return this.send(`${this.baseCrudPath}/${encodeURIComponent(id)}`, {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Creates a new record in the collection
+   */
+  async create(body, options) {
+    return this.send(this.baseCrudPath, {
+      method: "POST",
+      body,
+      ...options
+    });
+  }
+  /**
+   * Updates an existing record by its ID
+   */
+  async update(id, body, options) {
+    return this.send(`${this.baseCrudPath}/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body,
+      ...options
+    });
+  }
+  /**
+   * Deletes a record by its ID
+   */
+  async delete(id, options) {
+    await this.send(`${this.baseCrudPath}/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      ...options
+    });
+    return true;
+  }
+  /**
+   * Truncates (deletes all records) in the collection (Requires superuser access)
+   */
+  async truncate(options) {
+    await this.send(
+      `/api/collections/${encodeURIComponent(this.collectionIdOrName)}/truncate`,
+      {
+        method: "DELETE",
+        ...options
+      }
+    );
+    return true;
+  }
+  // --- Auth Methods ---
+  /**
+   * Authenticates a user with username/email and password
+   */
+  async authWithPassword(identity, password, options) {
+    const res = await this.send("/api/auth/users/login", {
+      method: "POST",
+      body: { identity, password },
+      ...options
+    });
+    const authResponse = {
+      token: res.token,
+      record: res.user || res.record,
+      meta: res.meta
+    };
+    this.client.authStore.save(authResponse.token, authResponse.record);
+    return authResponse;
+  }
+  /**
+   * Authenticates a user with a one-time password (OTP)
+   */
+  async authWithOTP(otp, email, options) {
+    const res = await this.send("/api/auth/verify-otp", {
+      method: "POST",
+      body: { otp, email },
+      ...options
+    });
+    const authResponse = {
+      token: res.token,
+      record: res.user || res.record,
+      meta: res.meta
+    };
+    this.client.authStore.save(authResponse.token, authResponse.record);
+    return authResponse;
+  }
+  /**
+   * Sends an OTP verification email to the user
+   */
+  async requestOTP(email, options) {
+    return this.send("/api/auth/request-otp", {
+      method: "POST",
+      body: { email },
+      ...options
+    });
+  }
+  /**
+   * Refreshes the currently authenticated record token and profile
+   */
+  async authRefresh(options) {
+    const user = await this.send("/api/auth/users/me", {
+      method: "GET",
+      ...options
+    });
+    const token = this.client.authStore.token;
+    const authResponse = {
+      token,
+      record: user
+    };
+    this.client.authStore.save(token, user);
+    return authResponse;
+  }
+  /**
+   * Sends a password reset email
+   */
+  async requestPasswordReset(email, options) {
+    await this.send("/api/auth/request-password-reset", {
+      method: "POST",
+      body: { email },
+      ...options
+    });
+    return true;
+  }
+  /**
+   * Confirms a password reset request with a token and new password
+   */
+  async confirmPasswordReset(token, password, _passwordConfirm, options) {
+    await this.send("/api/auth/confirm-password-reset", {
+      method: "POST",
+      body: { token, password },
+      ...options
+    });
+    return true;
+  }
+  /**
+   * Sends an email verification request
+   */
+  async requestVerification(email, options) {
+    await this.send("/api/auth/request-verification", {
+      method: "POST",
+      body: { email },
+      ...options
+    });
+    return true;
+  }
+  /**
+   * Confirms an email verification request
+   */
+  async confirmVerification(token, options) {
+    await this.send("/api/auth/confirm-verification", {
+      method: "POST",
+      body: { token },
+      ...options
+    });
+    return true;
+  }
+  /**
+   * Sends an email change verification request
+   */
+  async requestEmailChange(newEmail, options) {
+    await this.send("/api/auth/request-email-change", {
+      method: "POST",
+      body: { newEmail },
+      ...options
+    });
+    return true;
+  }
+  /**
+   * Confirms an email change request
+   */
+  async confirmEmailChange(token, password, options) {
+    await this.send("/api/auth/confirm-email-change", {
+      method: "POST",
+      body: { token, password },
+      ...options
+    });
+    return true;
+  }
+  // --- Realtime Subscriptions ---
+  /**
+   * Subscribes to realtime events for this collection or a specific record ID
+   */
+  async subscribe(topicOrListener, listener) {
+    let topic;
+    let cb;
+    if (typeof topicOrListener === "function") {
+      topic = this.collectionIdOrName;
+      cb = topicOrListener;
+    } else {
+      topic = `${this.collectionIdOrName}/${topicOrListener}`;
+      cb = listener;
+    }
+    return this.client.realtime.subscribe(topic, cb);
+  }
+  /**
+   * Unsubscribes from realtime events for this collection or a specific record ID
+   */
+  async unsubscribe(topic) {
+    const fullTopic = topic ? `${this.collectionIdOrName}/${topic}` : this.collectionIdOrName;
+    return this.client.realtime.unsubscribe(fullTopic);
+  }
+};
+
+// src/services/CollectionService.ts
+var CollectionService = class extends BaseService {
+  /**
+   * Returns a list of all collections (Superuser required)
+   */
+  async getFullList(options) {
+    const res = await this.send(
+      "/api/collections",
+      {
+        method: "GET",
+        ...options
+      }
+    );
+    return res.items || [];
+  }
+  /**
+   * Returns a paginated list of collections
+   */
+  async getList(page = 1, perPage = 30, options) {
+    const all = await this.getFullList(options);
+    const start = (page - 1) * perPage;
+    const end = start + perPage;
+    const items = all.slice(start, end);
+    const total = all.length;
+    const totalPages = Math.ceil(total / perPage) || 1;
+    return {
+      page,
+      perPage,
+      totalItems: total,
+      totalPages,
+      items
+    };
+  }
+  /**
+   * Returns a single collection schema by its name or ID (Superuser required)
+   */
+  async getOne(idOrName, options) {
+    return this.send(
+      `/api/collections/${encodeURIComponent(idOrName)}/schema`,
+      {
+        method: "GET",
+        ...options
+      }
+    );
+  }
+  /**
+   * Returns the schema and column definitions of a table/collection (Superuser required)
+   * Alias for getOne()
+   */
+  async getSchema(idOrName, options) {
+    return this.getOne(idOrName, options);
+  }
+  /**
+   * Returns the schema of a table/collection (Superuser required)
+   * Alias for getOne()
+   */
+  async getTableSchema(idOrName, options) {
+    return this.getOne(idOrName, options);
+  }
+  /**
+   * Creates a new collection schema
+   */
+  async create(data, options) {
+    return this.send("/api/collections", {
+      method: "POST",
+      body: data,
+      ...options
+    });
+  }
+  /**
+   * Updates an existing collection schema
+   */
+  async update(idOrName, data, options) {
+    return this.send(
+      `/api/collections/${encodeURIComponent(idOrName)}`,
+      {
+        method: "PATCH",
+        body: data,
+        ...options
+      }
+    );
+  }
+  /**
+   * Deletes a collection schema
+   */
+  async delete(idOrName, options) {
+    await this.send(`/api/collections/${encodeURIComponent(idOrName)}`, {
+      method: "DELETE",
+      ...options
+    });
+    return true;
+  }
+  /**
+   * Truncates all records in a collection
+   */
+  async truncate(idOrName, options) {
+    await this.send(
+      `/api/collections/${encodeURIComponent(idOrName)}/truncate`,
+      {
+        method: "DELETE",
+        ...options
+      }
+    );
+    return true;
+  }
+};
+
+// src/services/SuperuserService.ts
+var SuperuserService = class extends BaseService {
+  /**
+   * Authenticates a superuser with email and password
+   */
+  async authWithPassword(email, password, options) {
+    const res = await this.send(
+      "/api/auth/superusers/login",
+      {
+        method: "POST",
+        body: { email, password },
+        ...options
+      }
+    );
+    this.client.authStore.save(res.token, res.user);
+    return res;
+  }
+  /**
+   * Checks if an initial superuser exists in the system
+   */
+  async hasInitialSuperuser(options) {
+    return this.send(
+      "/api/auth/superusers/has-initial",
+      {
+        method: "GET",
+        ...options
+      }
+    );
+  }
+  /**
+   * Sets up the first superuser account (Only available when no superusers exist)
+   */
+  async setupInitialSuperuser(email, password, options) {
+    const res = await this.send(
+      "/api/auth/superusers/setup",
+      {
+        method: "POST",
+        body: { email, password },
+        ...options
+      }
+    );
+    this.client.authStore.save(res.token, res.user);
+    return res;
+  }
+  /**
+   * Returns current authenticated superuser profile
+   */
+  async getMe(options) {
+    return this.send("/api/auth/superusers/me", {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Refreshes superuser auth state
+   */
+  async authRefresh(options) {
+    const user = await this.getMe(options);
+    const token = this.client.authStore.token;
+    const res = {
+      token,
+      user
+    };
+    this.client.authStore.save(token, user);
+    return res;
+  }
+  /**
+   * Requests a password reset email for superuser
+   */
+  async requestPasswordReset(email, options) {
+    await this.send("/api/auth/request-password-reset", {
+      method: "POST",
+      body: { email },
+      ...options
+    });
+    return true;
+  }
+  /**
+   * Confirms a password reset with token
+   */
+  async confirmPasswordReset(token, password, _passwordConfirm, options) {
+    await this.send("/api/auth/confirm-password-reset", {
+      method: "POST",
+      body: { token, password },
+      ...options
+    });
+    return true;
+  }
+};
+
+// src/services/LogService.ts
+var LogService = class extends BaseService {
+  /**
+   * Returns a paginated list of system access and error logs (Superuser required)
+   */
+  async getList(page = 1, perPage = 50, options) {
+    const query = {
+      page,
+      limit: perPage,
+      ...options
+    };
+    const res = await this.send("/api/logs", {
+      method: "GET",
+      query,
+      ...options
+    });
+    return {
+      page: res.page,
+      perPage: res.limit,
+      totalItems: res.total,
+      totalPages: res.totalPages,
+      items: res.items
+    };
+  }
+  /**
+   * Returns timeline distribution of system requests and errors
+   */
+  async getTimeline(options) {
+    return this.send("/api/logs/timeline", {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Returns summary stats for server logs
+   */
+  async getStats(options) {
+    return this.send("/api/logs/stats", {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Deletes a batch of logs by IDs or all matching filter criteria
+   */
+  async deleteBatch(params, options) {
+    return this.send("/api/logs/delete-batch", {
+      method: "POST",
+      body: params,
+      ...options
+    });
+  }
+  /**
+   * Clears all system logs
+   */
+  async clear(options) {
+    await this.send("/api/logs", {
+      method: "DELETE",
+      ...options
+    });
+    return true;
+  }
+};
+
+// src/services/RealtimeService.ts
+var import_socket = require("socket.io-client");
+var RealtimeService = class extends BaseService {
+  subscriptions = /* @__PURE__ */ new Map();
+  socket = null;
+  isConnecting = false;
+  /**
+   * Checks if realtime is currently connected
+   */
+  get isConnected() {
+    return !!(this.socket && this.socket.connected);
+  }
+  /**
+   * Subscribes a listener callback to a specific topic or collection
+   */
+  async subscribe(topic, listener) {
+    const trimmedTopic = (topic || "*").trim();
+    if (!this.subscriptions.has(trimmedTopic)) {
+      this.subscriptions.set(trimmedTopic, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(trimmedTopic).add(listener);
+    this.ensureConnection();
+    if (this.socket && this.socket.connected) {
+      this.socket.emit("subscribe", trimmedTopic);
+    }
+    return () => {
+      this.unsubscribeFromTopic(trimmedTopic, listener);
+    };
+  }
+  /**
+   * Unsubscribes all listeners or a specific listener from a topic
+   */
+  async unsubscribe(topic) {
+    if (!topic) {
+      if (this.socket && this.socket.connected && this.subscriptions.size > 0) {
+        this.socket.emit("unsubscribe", Array.from(this.subscriptions.keys()));
+      }
+      this.subscriptions.clear();
+      this.disconnect();
+      return;
+    }
+    const trimmedTopic = topic.trim();
+    this.subscriptions.delete(trimmedTopic);
+    if (this.socket && this.socket.connected) {
+      this.socket.emit("unsubscribe", trimmedTopic);
+    }
+    if (this.subscriptions.size === 0) {
+      this.disconnect();
+    }
+  }
+  /**
+   * Publishes a custom event to a realtime topic
+   */
+  async publish(topic, data, event) {
+    if (this.socket && this.socket.connected) {
+      this.socket.emit("publish", { topic, data, event });
+      return;
+    }
+    await this.send("/api/realtime/publish", {
+      method: "POST",
+      body: {
+        topic,
+        data,
+        event
+      }
+    });
+  }
+  unsubscribeFromTopic(topic, listener) {
+    const set = this.subscriptions.get(topic);
+    if (set) {
+      set.delete(listener);
+      if (set.size === 0) {
+        this.subscriptions.delete(topic);
+        if (this.socket && this.socket.connected) {
+          this.socket.emit("unsubscribe", topic);
+        }
+      }
+    }
+    if (this.subscriptions.size === 0) {
+      this.disconnect();
+    }
+  }
+  ensureConnection() {
+    if (this.isConnecting || this.isConnected) return;
+    this.connect();
+  }
+  connect() {
+    if (this.socket) return;
+    this.isConnecting = true;
+    const socketUrl = this.client.baseUrl;
+    this.socket = (0, import_socket.io)(socketUrl, {
+      path: "/api/socket.io",
+      auth: {
+        token: this.client.authStore.token
+      },
+      transports: ["websocket", "polling"],
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3
+    });
+    this.socket.on("connect", () => {
+      this.isConnecting = false;
+      const topics = Array.from(this.subscriptions.keys());
+      if (topics.length > 0) {
+        this.socket.emit("subscribe", topics);
+      }
+    });
+    this.socket.on("disconnect", () => {
+      this.isConnecting = false;
+    });
+    this.socket.on("connect_error", () => {
+      this.isConnecting = false;
+    });
+    this.socket.on("logs", (data) => {
+      const logData = data?.log || data;
+      this.dispatchMessage(logData, "logs");
+    });
+    this.socket.on("log", (data) => {
+      const logData = data?.log || data;
+      this.dispatchMessage(logData, "logs");
+    });
+    this.socket.on("record", (data) => {
+      const collection = data?.collection;
+      this.dispatchMessage(data, collection);
+    });
+    this.socket.onAny((eventName, ...args) => {
+      if ([
+        "connect",
+        "disconnect",
+        "connect_error",
+        "connected",
+        "subscriptions",
+        "pong"
+      ].includes(eventName)) {
+        return;
+      }
+      const data = args[0];
+      this.dispatchMessage(data, eventName);
+    });
+  }
+  dispatchMessage(data, explicitTopic) {
+    if (!data) return;
+    const collection = explicitTopic || data.collection || data.topic;
+    const recordId = data.record?.id;
+    for (const [topic, listeners] of this.subscriptions.entries()) {
+      let isMatch = false;
+      if (topic === "*" || topic === collection) {
+        isMatch = true;
+      } else if (recordId && topic === `${collection}/${recordId}`) {
+        isMatch = true;
+      } else if (topic === `${collection}/*`) {
+        isMatch = true;
+      }
+      if (isMatch) {
+        for (const listener of listeners) {
+          try {
+            listener(data);
+          } catch (err) {
+            console.error("[AlsaBase Realtime] Listener error:", err);
+          }
+        }
+      }
+    }
+  }
+  disconnect() {
+    this.isConnecting = false;
+    if (this.socket) {
+      try {
+        this.socket.disconnect();
+      } catch {
+      }
+      this.socket = null;
+    }
+  }
+};
+
+// src/services/FileService.ts
+var FileService = class extends BaseService {
+  /**
+   * Generates a URL for accessing an uploaded record file asset
+   * 
+   * @param record Record object or record ID string
+   * @param filename Filename of the uploaded asset
+   * @param queryParams Optional query parameters (e.g. thumb, download)
+   */
+  getUrl(record, filename, queryParams) {
+    if (!filename) return "";
+    let fileUrlPath;
+    if (typeof record === "object" && record !== null) {
+      const col = record.collectionName || record.collectionId || "";
+      const id = record.id || "";
+      if (col && id) {
+        fileUrlPath = `/api/static-files/file/${encodeURIComponent(col)}/${encodeURIComponent(id)}/${encodeURIComponent(filename)}`;
+      } else if (id) {
+        fileUrlPath = `/api/static-files/file/${encodeURIComponent(id)}/${encodeURIComponent(filename)}`;
+      } else {
+        fileUrlPath = `/api/static-files/file/${encodeURIComponent(filename)}`;
+      }
+    } else if (typeof record === "string" && record) {
+      fileUrlPath = `/api/static-files/file/${encodeURIComponent(record)}/${encodeURIComponent(filename)}`;
+    } else {
+      fileUrlPath = `/api/static-files/file/${encodeURIComponent(filename)}`;
+    }
+    return this.client.buildUrl(fileUrlPath, queryParams);
+  }
+  /**
+   * Generates a URL for a public website static asset hosted in _public
+   * 
+   * @param relPath Relative path inside _public (e.g. 'images/banner.png' or 'maps/mafia/lost-heaven/')
+   */
+  getPublicUrl(relPath) {
+    const clean = relPath.replace(/^[\/\\]+/, "");
+    return `${this.client.baseUrl.replace(/\/+$/, "")}/${clean}`;
+  }
+  /**
+   * Lists all files in the _public directory
+   */
+  async listPublicFiles(options) {
+    return this.send("/api/static-files", {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Gets a folder tree for the _public directory
+   */
+  async getPublicTree(dir = "", options) {
+    return this.send(`/api/static-files/tree?dir=${encodeURIComponent(dir)}`, {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Reads a file's content from the _public directory
+   */
+  async readPublicFile(path, options) {
+    return this.send(`/api/static-files/file?path=${encodeURIComponent(path)}`, {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Saves or updates a file in the _public directory (Superuser required)
+   */
+  async savePublicFile(name, content, isBase64 = false, options) {
+    return this.send("/api/static-files/file", {
+      method: "POST",
+      body: { name, content, isBase64 },
+      ...options
+    });
+  }
+  /**
+   * Uploads a batch of files to the _public directory (Superuser required)
+   */
+  async uploadPublicBatch(files, options) {
+    return this.send("/api/static-files/upload-batch", {
+      method: "POST",
+      body: { files },
+      ...options
+    });
+  }
+  /**
+   * Deletes a file in the _public directory (Superuser required)
+   */
+  async deletePublicFile(path, options) {
+    return this.send(`/api/static-files/file?path=${encodeURIComponent(path)}`, {
+      method: "DELETE",
+      ...options
+    });
+  }
+  /**
+   * Creates a folder inside the _public directory (Superuser required)
+   */
+  async createPublicFolder(path, options) {
+    return this.send("/api/static-files/folder", {
+      method: "POST",
+      body: { path },
+      ...options
+    });
+  }
+  /**
+   * Deletes a folder and all its contents inside the _public directory (Superuser required)
+   */
+  async deletePublicFolder(path, options) {
+    return this.send(`/api/static-files/folder?path=${encodeURIComponent(path)}`, {
+      method: "DELETE",
+      ...options
+    });
+  }
+};
+
+// src/services/HooksService.ts
+var HooksService = class extends BaseService {
+  /**
+   * Returns an overview of all active hooks, routes, crons, and commands (Superuser required)
+   */
+  async getOverview(options) {
+    return this.send("/api/hooks", {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Lists all files in the _hooks directory (Superuser required)
+   */
+  async listFiles(options) {
+    return this.send("/api/hooks/files", {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Gets a folder tree for the _hooks directory (Superuser required)
+   */
+  async getTree(dir = "", options) {
+    return this.send(`/api/hooks/tree?dir=${encodeURIComponent(dir)}`, {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Reads a file's content from the _hooks directory (Superuser required)
+   */
+  async readFile(path, options) {
+    return this.send(`/api/hooks/files/file?path=${encodeURIComponent(path)}`, {
+      method: "GET",
+      ...options
+    });
+  }
+  /**
+   * Saves or updates a file in the _hooks directory (Superuser required)
+   */
+  async saveFile(name, content, isBase64 = false, options) {
+    return this.send("/api/hooks/files", {
+      method: "POST",
+      body: { name, content, isBase64 },
+      ...options
+    });
+  }
+  /**
+   * Uploads a batch of files to the _hooks directory (Superuser required)
+   */
+  async uploadBatch(files, options) {
+    return this.send("/api/hooks/files/upload-batch", {
+      method: "POST",
+      body: { files },
+      ...options
+    });
+  }
+  /**
+   * Deletes a file in the _hooks directory (Superuser required)
+   */
+  async deleteFile(path, options) {
+    return this.send(`/api/hooks/files/file?path=${encodeURIComponent(path)}`, {
+      method: "DELETE",
+      ...options
+    });
+  }
+  /**
+   * Creates a folder inside the _hooks directory (Superuser required)
+   */
+  async createFolder(path, options) {
+    return this.send("/api/hooks/files/folder", {
+      method: "POST",
+      body: { path },
+      ...options
+    });
+  }
+  /**
+   * Deletes a folder and all its contents inside the _hooks directory (Superuser required)
+   */
+  async deleteFolder(path, options) {
+    return this.send(`/api/hooks/files/folder?path=${encodeURIComponent(path)}`, {
+      method: "DELETE",
+      ...options
+    });
+  }
+  /**
+   * Manually triggers execution of a scheduled cron job (Superuser required)
+   */
+  async triggerCron(name, options) {
+    return this.send(`/api/hooks/cron/${encodeURIComponent(name)}/trigger`, {
+      method: "POST",
+      ...options
+    });
+  }
+  /**
+   * Cancels a running cron job (Superuser required)
+   */
+  async cancelCron(executionId, name, options) {
+    return this.send("/api/hooks/cron/cancel", {
+      method: "POST",
+      body: { executionId, name },
+      ...options
+    });
+  }
+  /**
+   * Runs a custom hook CLI command (Superuser required)
+   */
+  async runCommand(name, args, options) {
+    return this.send(`/api/hooks/commands/${encodeURIComponent(name)}/run`, {
+      method: "POST",
+      body: { args },
+      ...options
+    });
+  }
+  /**
+   * Cancels a running CLI command (Superuser required)
+   */
+  async cancelCommand(executionId, name, options) {
+    return this.send("/api/hooks/commands/cancel", {
+      method: "POST",
+      body: { executionId, name },
+      ...options
+    });
+  }
+  /**
+   * Reloads all hook files and re-registers custom routes (Superuser required)
+   */
+  async reload(options) {
+    return this.send("/api/hooks/reload", {
+      method: "POST",
+      ...options
+    });
+  }
+};
+
+// src/Client.ts
+var AlsaBase = class {
+  baseUrl;
+  authStore;
+  superusers;
+  collections;
+  logs;
+  realtime;
+  files;
+  hooks;
+  recordServices = /* @__PURE__ */ new Map();
+  cancelControllers = /* @__PURE__ */ new Map();
+  constructor(baseUrl = "/", authStore) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.authStore = authStore || (typeof window !== "undefined" ? new LocalAuthStore() : new BaseAuthStore());
+    this.superusers = new SuperuserService(this);
+    this.collections = new CollectionService(this);
+    this.logs = new LogService(this);
+    this.realtime = new RealtimeService(this);
+    this.files = new FileService(this);
+    this.hooks = new HooksService(this);
+  }
+  /**
+   * Alias for superusers service (admins)
+   */
+  get admins() {
+    return this.superusers;
+  }
+  /**
+   * Returns a RecordService instance for the specified collection
+   */
+  collection(idOrName) {
+    if (!this.recordServices.has(idOrName)) {
+      this.recordServices.set(
+        idOrName,
+        new RecordService(this, idOrName)
+      );
+    }
+    return this.recordServices.get(idOrName);
+  }
+  /**
+   * Returns the schema and column definitions for a table/collection (Requires Superuser authentication)
+   */
+  async getSchema(idOrName, options) {
+    return this.collections.getOne(idOrName, options);
+  }
+  /**
+   * Returns the schema and column definitions for a table/collection (Requires Superuser authentication)
+   * Alias for getSchema()
+   */
+  async getTableSchema(idOrName, options) {
+    return this.collections.getOne(idOrName, options);
+  }
+  /**
+   * Helper to format filter expression string with parameterized values
+   */
+  filter(expr, params = {}) {
+    if (!params || Object.keys(params).length === 0) {
+      return expr;
+    }
+    let result = expr;
+    for (const [key, val] of Object.entries(params)) {
+      let formattedVal;
+      if (val === null || val === void 0) {
+        formattedVal = "null";
+      } else if (typeof val === "number" || typeof val === "boolean") {
+        formattedVal = String(val);
+      } else if (val instanceof Date) {
+        formattedVal = `"${val.toISOString()}"`;
+      } else {
+        formattedVal = `"${String(val).replace(/"/g, '\\"')}"`;
+      }
+      const pattern = new RegExp(`{:?\\b${key}\\b}`, "g");
+      result = result.replace(pattern, formattedVal);
+    }
+    return result;
+  }
+  /**
+   * Cancels a pending request with matching requestKey
+   */
+  cancelRequest(requestKey) {
+    const controller = this.cancelControllers.get(requestKey);
+    if (controller) {
+      controller.abort();
+      this.cancelControllers.delete(requestKey);
+    }
+    return this;
+  }
+  /**
+   * Cancels all pending requests
+   */
+  cancelAllRequests() {
+    for (const controller of this.cancelControllers.values()) {
+      controller.abort();
+    }
+    this.cancelControllers.clear();
+    return this;
+  }
+  /**
+   * Builds an absolute URL with query parameters
+   */
+  buildUrl(path, query) {
+    const cleanPath = path.startsWith("/") ? path : `/${path}`;
+    let url = `${this.baseUrl}${cleanPath}`;
+    if (query && Object.keys(query).length > 0) {
+      const searchParams = new URLSearchParams();
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== null && v !== "") {
+          searchParams.append(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+        }
+      }
+      const qs = searchParams.toString();
+      if (qs) {
+        url += (url.includes("?") ? "&" : "?") + qs;
+      }
+    }
+    return url;
+  }
+  /**
+   * Dispatches an HTTP request to the AlsaBase server
+   */
+  async send(path, options = {}) {
+    const url = this.buildUrl(path, options.query || options.params);
+    let requestKey = options.requestKey;
+    if (requestKey === void 0 && options.autoCancel !== false && (options.method === "GET" || !options.method)) {
+      requestKey = `${options.method || "GET"} ${url}`;
+    }
+    let controller;
+    if (requestKey) {
+      this.cancelRequest(requestKey);
+      controller = new AbortController();
+      this.cancelControllers.set(requestKey, controller);
+    }
+    const headers = {
+      ...options.headers || {}
+    };
+    if (!headers["Authorization"] && !headers["authorization"] && this.authStore.token) {
+      headers["Authorization"] = `Bearer ${this.authStore.token}`;
+    }
+    let body = options.body;
+    if (body !== void 0 && body !== null && typeof body === "object" && typeof body.append !== "function" && !(typeof Blob !== "undefined" && body instanceof Blob) && !(typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer)) {
+      if (!headers["Content-Type"] && !headers["content-type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+      body = JSON.stringify(body);
+    }
+    const fetchOptions = {
+      ...options,
+      headers,
+      body,
+      signal: controller ? controller.signal : options.signal
+    };
+    try {
+      const response = await fetch(url, fetchOptions);
+      if (requestKey) {
+        this.cancelControllers.delete(requestKey);
+      }
+      let data = null;
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        data = await response.json().catch(() => null);
+      } else {
+        data = await response.text().catch(() => null);
+      }
+      if (!response.ok) {
+        throw new ClientResponseError({
+          url,
+          status: response.status,
+          data,
+          response
+        });
+      }
+      return data;
+    } catch (err) {
+      if (requestKey) {
+        this.cancelControllers.delete(requestKey);
+      }
+      if (err.name === "AbortError") {
+        throw new ClientResponseError({
+          url,
+          status: 0,
+          data: { message: "The request was autocancelled or aborted." },
+          isAbort: true,
+          originalError: err
+        });
+      }
+      if (err instanceof ClientResponseError) {
+        throw err;
+      }
+      throw new ClientResponseError({
+        url,
+        status: 0,
+        data: { message: err.message },
+        originalError: err
+      });
+    }
+  }
+};
+
+// src/stores/AsyncAuthStore.ts
+var AsyncAuthStore = class extends BaseAuthStore {
+  _saveHandler;
+  _clearHandler;
+  constructor(options = {}) {
+    super();
+    this._saveHandler = options.save;
+    this._clearHandler = options.clear;
+    if (options.initial) {
+      try {
+        const parsed = JSON.parse(options.initial);
+        if (parsed && typeof parsed === "object") {
+          this._token = parsed.token || "";
+          this._model = parsed.model || null;
+        }
+      } catch {
+      }
+    }
+  }
+  save(token, model) {
+    super.save(token, model);
+    if (this._saveHandler) {
+      this._saveHandler(JSON.stringify({ token: this._token, model: this._model })).catch(
+        (err) => console.error("AsyncAuthStore save failed:", err)
+      );
+    }
+  }
+  clear() {
+    super.clear();
+    if (this._clearHandler) {
+      this._clearHandler().catch(
+        (err) => console.error("AsyncAuthStore clear failed:", err)
+      );
+    }
+  }
+};
+
+// src/index.ts
+var index_default = AlsaBase;