@archlast/client 0.0.1

package/dist/client.js

@@ -0,0 +1,642 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/auth/index.ts
+import axios from "axios";
+function resolveBaseUrl(explicit) {
+  if (explicit && explicit.trim()) return explicit.replace(/\/+$/, "");
+  if (typeof window !== "undefined" && window.location?.origin) return window.location.origin;
+  return "";
+}
+var ArchlastAuthClient = class {
+  constructor(options = {}) {
+    __publicField(this, "baseUrl");
+    __publicField(this, "axios");
+    __publicField(this, "appId");
+    __publicField(this, "apiKey");
+    this.baseUrl = resolveBaseUrl(options.baseUrl);
+    this.appId = options.appId;
+    this.apiKey = options.apiKey;
+    this.axios = axios.create({
+      baseURL: this.baseUrl,
+      withCredentials: !options.apiKey,
+      // Only use cookies if no API key
+      headers: {
+        "content-type": "application/json",
+        ...this.appId ? { "x-archlast-app-id": this.appId } : {},
+        ...options.apiKey ? { "x-api-key": options.apiKey } : {}
+      }
+    });
+  }
+  /**
+   * Get current authentication state
+   * Uses Better-Auth's getSession endpoint
+   */
+  async getState() {
+    try {
+      const response = await this.axios.get("/api/auth/get-session");
+      const { user, session } = response.data;
+      return {
+        user,
+        session,
+        isAuthenticated: !!user
+      };
+    } catch (error) {
+      return {
+        user: null,
+        session: null,
+        isAuthenticated: false
+      };
+    }
+  }
+  /**
+   * Sign up new user
+   * Uses Better-Auth's email signUp endpoint
+   */
+  async signUp(input) {
+    const response = await this.axios.post("/api/auth/sign-up/email", {
+      email: input.email,
+      password: input.password,
+      name: input.name,
+      username: input.username
+    });
+    return {
+      user: response.data.user,
+      session: null,
+      // Session is managed via cookies
+      isAuthenticated: !!response.data.user
+    };
+  }
+  /**
+   * Sign in with email/username and password
+   * Uses Better-Auth's credential sign-in endpoint
+   */
+  async signIn(input) {
+    if (!input.email && !input.username) {
+      throw new Error("Either email or username is required");
+    }
+    const response = await this.axios.post("/api/auth/sign-in/email", {
+      email: input.email,
+      username: input.username,
+      password: input.password
+    });
+    return {
+      user: response.data.user,
+      session: null,
+      // Session is managed via cookies
+      isAuthenticated: !!response.data.user
+    };
+  }
+  /**
+   * Sign out and revoke session
+   * Uses Better-Auth's sign-out endpoint
+   */
+  async signOut() {
+    const response = await this.axios.post(
+      "/api/auth/sign-out",
+      {},
+      { withCredentials: true }
+    );
+    return response.data;
+  }
+  /**
+   * Request password reset email
+   * Uses Better-Auth's password reset flow
+   */
+  async requestPasswordReset(email, callbackURL) {
+    const response = await this.axios.post("/api/auth/forgot-password", {
+      email,
+      redirectTo: callbackURL
+    });
+    return response.data;
+  }
+  /**
+   * Reset password with token
+   * Uses Better-Auth's reset password endpoint
+   */
+  async resetPassword(token, password) {
+    const response = await this.axios.post("/api/auth/reset-password", {
+      token,
+      password
+    });
+    return response.data;
+  }
+  /**
+   * Verify email with token
+   * Uses Better-Auth's email verification endpoint
+   */
+  async verifyEmail(token) {
+    const response = await this.axios.post("/api/auth/verify-email", {
+      token
+    });
+    return response.data;
+  }
+};
+
+// src/storage/index.ts
+import axios2 from "axios";
+var StorageClient = class {
+  constructor(baseUrl, appId, options) {
+    __publicField(this, "axios");
+    this.axios = axios2.create({
+      baseURL: baseUrl,
+      withCredentials: !options?.apiKey,
+      // Only use cookies if no API key
+      headers: {
+        ...appId ? { "x-archlast-app-id": appId } : {},
+        ...options?.apiKey ? { "x-api-key": options.apiKey } : {}
+      }
+    });
+  }
+  /**
+   * Upload a file
+   */
+  async upload(file, contentType) {
+    let body = file;
+    let headers = {};
+    if (file instanceof File) {
+      const formData = new FormData();
+      formData.append("file", file);
+      body = formData;
+    } else {
+      if (contentType) {
+        headers["Content-Type"] = contentType;
+      }
+      if (file instanceof Uint8Array) {
+      }
+    }
+    const response = await this.axios.post(
+      "/_archlast/storage/upload",
+      body,
+      {
+        headers
+      }
+    );
+    const data = response.data;
+    if (!data.id) throw new Error("Upload failed: No ID returned");
+    return this.hydrate(data);
+  }
+  /**
+   * List files
+   */
+  async list(limit = 20, offset = 0) {
+    const response = await this.axios.get("/_archlast/storage/list", {
+      params: { limit, offset }
+    });
+    return {
+      items: response.data.items.map((item) => this.hydrate(item))
+    };
+  }
+  /**
+   * Get file metadata
+   */
+  async getMetadata(id) {
+    const response = await this.axios.get(`/_archlast/storage/files/${id}`);
+    return this.hydrate(response.data);
+  }
+  /**
+   * Generate a presigned download URL
+   */
+  async presign(id, expiresInSeconds = 300) {
+    const response = await this.axios.post("/_archlast/storage/presign", {
+      id,
+      expiresInSeconds
+    });
+    return response.data;
+  }
+  /**
+   * Delete file
+   */
+  async delete(id) {
+    const response = await this.axios.delete(
+      `/_archlast/storage/files/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Get public URL for a file
+   */
+  getPublicUrl(id) {
+    const base = this.axios.defaults.baseURL?.replace(/\/+$/, "") || "";
+    return `${base}/_storage/${id}`;
+  }
+  getDownloadUrl(id) {
+    const base = this.axios.defaults.baseURL?.replace(/\/+$/, "") || "";
+    return `${base}/_archlast/storage/files/${id}/download`;
+  }
+  hydrate(file) {
+    if (!file.id) throw new Error("Invalid file object: missing id");
+    return {
+      id: file.id,
+      name: file.name ?? file.fileName ?? "Untitled",
+      // Handle aliasing
+      fileName: file.fileName ?? file.name ?? null,
+      url: file.url ?? this.getPublicUrl(file.id),
+      downloadUrl: file.downloadUrl ?? this.getDownloadUrl(file.id),
+      hash: file.hash ?? "",
+      contentType: file.contentType ?? "application/octet-stream",
+      size: file.size ?? 0,
+      createdAt: file.createdAt ?? Date.now(),
+      updatedAt: file.updatedAt ?? Date.now(),
+      refCount: file.refCount ?? 1
+    };
+  }
+};
+
+// src/admin/index.ts
+import axios3 from "axios";
+var AdminAuthClient = class {
+  constructor(baseUrl, options) {
+    __publicField(this, "axios");
+    this.axios = axios3.create({
+      baseURL: baseUrl,
+      withCredentials: !options?.apiKey,
+      headers: {
+        ...options?.apiKey ? { "x-api-key": options.apiKey } : {}
+      }
+    });
+  }
+  async signIn(email, password) {
+    const response = await this.axios.post("/_archlast/admin/auth/sign-in", {
+      email,
+      password
+    });
+    return response.data;
+  }
+  async signOut() {
+    const response = await this.axios.post("/_archlast/admin/auth/sign-out");
+    return response.data;
+  }
+  async getProfile() {
+    const response = await this.axios.get("/_archlast/admin/auth/me");
+    return response.data;
+  }
+  async getSessions() {
+    const response = await this.axios.get("/_archlast/admin/auth/sessions");
+    return response.data;
+  }
+  async revokeSession(sessionId) {
+    const response = await this.axios.post("/_archlast/admin/auth/revoke-session", {
+      sessionId
+    });
+    return response.data;
+  }
+  async signOutAll() {
+    const response = await this.axios.post("/_archlast/admin/auth/sign-out-all");
+    return response.data;
+  }
+};
+var AdminClient = class {
+  // Add other admin clients here (users, tenants, etc.)
+  constructor(baseUrl, options) {
+    __publicField(this, "auth");
+    this.auth = new AdminAuthClient(baseUrl, options);
+  }
+};
+
+// src/client.ts
+var ArchlastClient = class {
+  /**
+   * @param url WebSocket URL
+   * @param httpUrl Backend HTTP URL (used for WS derivation fallback)
+   * @param appId App ID for session isolation
+   * @param authUrl Optional same-origin URL for auth requests (to avoid cross-origin cookie issues)
+   * @param options Configuration options
+   */
+  constructor(url, httpUrl, appId, authUrl, options = {}) {
+    __publicField(this, "ws", null);
+    __publicField(this, "url");
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+    __publicField(this, "subscriptions", /* @__PURE__ */ new Map());
+    __publicField(this, "pendingMutations", /* @__PURE__ */ new Map());
+    __publicField(this, "messageQueue", []);
+    __publicField(this, "isConnected", false);
+    __publicField(this, "reconnectAttempts", 0);
+    __publicField(this, "maxReconnectAttempts", 5);
+    __publicField(this, "reconnectDelay", 1e3);
+    __publicField(this, "reconnectTimeout", null);
+    __publicField(this, "isExplicitlyClosed", false);
+    __publicField(this, "sessionId", null);
+    // Event listeners
+    __publicField(this, "connectionListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "disconnectionListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "errorListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "auth");
+    __publicField(this, "storage");
+    __publicField(this, "admin");
+    __publicField(this, "baseUrl");
+    __publicField(this, "appId");
+    __publicField(this, "isAdmin");
+    __publicField(this, "apiKey");
+    __publicField(this, "betterAuthCookies");
+    __publicField(this, "heartbeatInterval", null);
+    this.url = url;
+    this.appId = appId;
+    this.isAdmin = options.isAdmin ?? false;
+    this.apiKey = options.apiKey;
+    this.betterAuthCookies = options.betterAuthCookies;
+    const derivedHttpUrl = httpUrl !== void 0 ? httpUrl : url.replace(/^ws/, "http");
+    const authBaseUrl = authUrl !== void 0 ? authUrl : derivedHttpUrl;
+    this.baseUrl = authBaseUrl;
+    this.auth = new ArchlastAuthClient({ baseUrl: authBaseUrl, appId, apiKey: options.apiKey });
+    this.storage = new StorageClient(authBaseUrl, appId, { apiKey: options.apiKey });
+    this.admin = new AdminClient(authBaseUrl, { apiKey: options.apiKey });
+    if (options.autoConnect !== false) {
+      this.connect();
+    }
+  }
+  /**
+   * Update Better-Auth cookies (call this when session changes)
+   */
+  setBetterAuthCookies(cookies) {
+    this.betterAuthCookies = cookies;
+    if (this.isConnected) {
+      this.connect();
+    }
+  }
+  /**
+   * Update Better-Auth API key (call this when API key changes)
+   */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+    if (this.isConnected) {
+      this.connect();
+    }
+  }
+  connect() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    this.isExplicitlyClosed = false;
+    if (this.ws) {
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        return;
+      }
+      try {
+        this.ws.close();
+      } catch (e) {
+      }
+      this.ws = null;
+    }
+    try {
+      this.ws = new WebSocket(this.url);
+    } catch (e) {
+      this.handleClose();
+      return;
+    }
+    this.ws.onopen = async () => {
+      console.log("Connected to Archlast Server");
+      this.isConnected = true;
+      this.reconnectAttempts = 0;
+      const headers = {};
+      if (this.appId) {
+        headers["x-archlast-app-id"] = this.appId;
+      }
+      if (this.apiKey) {
+        headers["x-api-key"] = this.apiKey;
+      }
+      const cookies = {};
+      if (this.betterAuthCookies) {
+        Object.assign(cookies, this.betterAuthCookies);
+      }
+      this.sendMessage({
+        type: "connect",
+        auth: {
+          headers: Object.keys(headers).length > 0 ? headers : void 0,
+          cookies: Object.keys(cookies).length > 0 ? cookies : void 0
+        }
+      });
+      if (this.isAdmin) {
+        this.sendMessage({
+          type: "subscribe_logs"
+        });
+        this.sendMessage({
+          type: "subscribe_admin_events"
+        });
+      } else {
+        try {
+          const state = await this.auth.getState();
+          console.log("Auth state:", state);
+          if (state.isAuthenticated) {
+            this.sendMessage({
+              type: "subscribe_logs"
+            });
+            this.sendMessage({
+              type: "subscribe_admin_events"
+            });
+          }
+        } catch (err) {
+        }
+      }
+      this.flushQueue();
+      this.resubscribeAll();
+      this.startHeartbeat();
+    };
+    this.ws.onmessage = (event) => this.handleMessage(event);
+    this.ws.onclose = () => this.handleClose();
+    this.ws.onerror = (err) => {
+      if (!this.isExplicitlyClosed) {
+        console.error("WebSocket error:", err);
+        this.ws?.close();
+      }
+    };
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      if (this.isConnected) {
+        this.sendMessage({ type: "ping" });
+      }
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  handleClose() {
+    this.isConnected = false;
+    this.sessionId = null;
+    this.disconnectionListeners.forEach((l) => l("Disconnected"));
+    if (this.isExplicitlyClosed) return;
+    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+      const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts);
+      console.log(`Disconnected. Reconnecting in ${delay}ms...`);
+      this.reconnectTimeout = setTimeout(() => {
+        this.reconnectAttempts++;
+        this.connect();
+      }, delay);
+    }
+  }
+  handleMessage(event) {
+    try {
+      const msg = JSON.parse(event.data);
+      if (msg.type === "data" || msg.type === "patch") {
+        const queryId = msg.queryId;
+        const data = msg.data || msg.patch;
+        const listeners = this.listeners.get(queryId);
+        if (listeners) {
+          listeners.forEach((l) => l(data));
+        }
+      } else if (msg.type === "mutationResponse") {
+        const pending = this.pendingMutations.get(msg.mutationId);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pendingMutations.delete(msg.mutationId);
+          if (msg.success) {
+            pending.resolve(msg.data);
+          } else {
+            pending.reject(new Error(msg.error));
+          }
+        }
+      } else if (msg.type === "connected") {
+        console.log("Session established:", msg.sessionId);
+        this.sessionId = msg.sessionId;
+        this.isConnected = true;
+        this.reconnectAttempts = 0;
+        this.connectionListeners.forEach((l) => l(msg.sessionId));
+      } else if (msg.type === "error") {
+        console.error("Server error:", msg.message);
+        this.errorListeners.forEach((l) => l(msg.message));
+        if (msg.message === "Authentication required") {
+          this.isExplicitlyClosed = true;
+          this.ws?.close();
+        }
+      }
+    } catch (e) {
+      console.error("Error handling message:", e);
+    }
+  }
+  getWs() {
+    return this.ws;
+  }
+  onConnected(cb) {
+    this.connectionListeners.add(cb);
+    return () => this.connectionListeners.delete(cb);
+  }
+  onDisconnected(cb) {
+    this.disconnectionListeners.add(cb);
+    return () => this.disconnectionListeners.delete(cb);
+  }
+  onError(cb) {
+    this.errorListeners.add(cb);
+    return () => this.errorListeners.delete(cb);
+  }
+  getStatus() {
+    return this.isConnected ? "connected" : "disconnected";
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  sendMessage(msg) {
+    const data = JSON.stringify(msg);
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(data);
+    } else {
+      this.messageQueue.push(data);
+    }
+  }
+  flushQueue() {
+    while (this.messageQueue.length > 0) {
+      const msg = this.messageQueue.shift();
+      if (msg) this.ws?.send(msg);
+    }
+  }
+  resubscribeAll() {
+    for (const [queryId, sub] of Array.from(this.subscriptions.entries())) {
+      this.sendMessage({
+        type: "query",
+        queryId,
+        name: sub.name,
+        args: sub.args
+      });
+    }
+  }
+  getQueryId(name, args) {
+    const stableArgs = JSON.stringify(args, Object.keys(args || {}).sort());
+    return `${name}:${stableArgs}`;
+  }
+  subscribe(queryName, args, onUpdate) {
+    const queryId = this.getQueryId(queryName, args);
+    if (!this.listeners.has(queryId)) {
+      this.listeners.set(queryId, /* @__PURE__ */ new Set());
+      this.subscriptions.set(queryId, { name: queryName, args });
+      this.sendMessage({
+        type: "query",
+        queryId,
+        name: queryName,
+        args
+      });
+    }
+    this.listeners.get(queryId).add(onUpdate);
+    return () => {
+      const set = this.listeners.get(queryId);
+      if (set) {
+        set.delete(onUpdate);
+        if (set.size === 0) {
+          this.listeners.delete(queryId);
+          this.subscriptions.delete(queryId);
+        }
+      }
+    };
+  }
+  async fetch(name, args) {
+    const queryId = this.getQueryId(name, args);
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      const unsubscribe = this.subscribe(name, args, (data) => {
+        if (!resolved) {
+          resolved = true;
+          unsubscribe();
+          resolve(data);
+        }
+      });
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          unsubscribe();
+          reject(new Error("Timeout waiting for data"));
+        }
+      }, 5e3);
+    });
+  }
+  async mutate(name, args) {
+    return new Promise((resolve, reject) => {
+      const mutationId = Math.random().toString(36).slice(2);
+      const timeout = setTimeout(() => {
+        this.pendingMutations.delete(mutationId);
+        reject(new Error("Mutation timeout"));
+      }, 1e4);
+      this.pendingMutations.set(mutationId, { resolve, reject, timeout });
+      this.sendMessage({
+        type: "mutation",
+        mutationId,
+        name,
+        args
+      });
+    });
+  }
+  close() {
+    this.isExplicitlyClosed = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.onopen = null;
+      this.ws.onerror = null;
+      this.ws.onmessage = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isConnected = false;
+    this.stopHeartbeat();
+  }
+};
+export {
+  ArchlastClient
+};
+//# sourceMappingURL=client.js.map