@archlast/client 0.0.1

package/dist/index.js

@@ -0,0 +1,1111 @@
+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();
+  }
+};
+
+// src/react.tsx
+import { useEffect, useState, createContext, useContext, useCallback } from "react";
+import {
+  useQuery as useTanStackQuery,
+  useMutation as useTanStackMutation,
+  useQueryClient,
+  QueryClient,
+  QueryClientProvider
+} from "@tanstack/react-query";
+import axios4 from "axios";
+import { jsx } from "react/jsx-runtime";
+var ArchlastContext = createContext(null);
+var useArchlast = () => {
+  const client = useContext(ArchlastContext);
+  if (!client) throw new Error("ArchlastProvider not found");
+  return client;
+};
+function ArchlastProvider({ client, children }) {
+  const [queryClient] = useState(() => new QueryClient());
+  return /* @__PURE__ */ jsx(ArchlastContext.Provider, { value: client, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children }) });
+}
+function useQuery(queryRef, args, options) {
+  const client = useArchlast();
+  const queryClient = useQueryClient();
+  const queryKey = [queryRef._name, args];
+  useEffect(() => {
+    const unsubscribe = client.subscribe(queryRef._name, args, (data) => {
+      queryClient.setQueryData(queryKey, data);
+    });
+    return () => unsubscribe();
+  }, [client, queryRef._name, JSON.stringify(args), queryClient]);
+  const query = useTanStackQuery({
+    queryKey,
+    queryFn: async () => {
+      const result = await client.fetch(queryRef._name, args);
+      return result === void 0 ? null : result;
+    },
+    // staleTime: 0,
+    // gcTime: 1000 * 60 * 5,
+    ...options
+  });
+  return query.data;
+}
+function useMutation(mutationRef) {
+  const client = useArchlast();
+  const queryClient = useQueryClient();
+  const mutation = useTanStackMutation({
+    mutationFn: async (args) => {
+      return client.mutate(mutationRef._name, args);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries();
+    }
+  });
+  return mutation.mutateAsync;
+}
+function useUpload(options) {
+  const client = useArchlast();
+  const [isUploading, setUploading] = useState(false);
+  const [error, setError] = useState(null);
+  const [result, setResult] = useState(null);
+  const upload = useCallback(
+    async (file, contentType) => {
+      setUploading(true);
+      setError(null);
+      setResult(null);
+      try {
+        const result2 = await client.storage.upload(file, contentType);
+        setResult({ id: result2.id, url: result2.url });
+        return { id: result2.id, url: result2.url };
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setUploading(false);
+      }
+    },
+    [client]
+  );
+  const presign = useCallback(
+    async (id, expiresInSeconds = 300) => {
+      const { url: relativeUrl } = await client.storage.presign(id, expiresInSeconds);
+      const absoluteUrl = relativeUrl.startsWith("http") ? relativeUrl : `${options?.baseUrl ?? ""}${relativeUrl.startsWith("/") ? "" : "/"}${relativeUrl}`;
+      setResult((prev) => prev ? { ...prev, url: absoluteUrl } : { id, url: absoluteUrl });
+      return absoluteUrl;
+    },
+    [client, options?.baseUrl]
+  );
+  return { upload, presign, isUploading, error, result };
+}
+var DEFAULT_AUTH_STATE = {
+  isAuthenticated: false,
+  user: null,
+  session: null
+};
+function useAuth(options) {
+  const client = useArchlast();
+  const queryClient = useQueryClient();
+  const enabled = options?.enabled ?? true;
+  const pollInterval = options?.pollIntervalMs ?? 3e4;
+  const {
+    data: authState,
+    isLoading,
+    error,
+    refetch
+  } = useTanStackQuery({
+    queryKey: ["auth", "state"],
+    queryFn: async () => {
+      try {
+        return await client.auth.getState();
+      } catch (err) {
+        if (axios4.isAxiosError(err) && err.response?.status === 401) {
+          return DEFAULT_AUTH_STATE;
+        }
+        throw err;
+      }
+    },
+    retry: false,
+    // Don't retry auth checks, fail fast
+    staleTime: 0,
+    // Auth state is volatile, consider it always stale
+    refetchInterval: enabled ? pollInterval : false,
+    refetchOnWindowFocus: true,
+    // Security: re-check when user tabbs back
+    refetchOnReconnect: true,
+    enabled,
+    initialData: DEFAULT_AUTH_STATE
+    // Optimistic default
+  });
+  const invalidateAuth = useCallback(() => {
+    return queryClient.invalidateQueries({ queryKey: ["auth", "state"] });
+  }, [queryClient]);
+  const signIn = useCallback(
+    async (input) => {
+      await client.auth.signIn(input);
+      await invalidateAuth();
+    },
+    [client, invalidateAuth]
+  );
+  const signUp = useCallback(
+    async (input) => {
+      await client.auth.signUp(input);
+      await invalidateAuth();
+    },
+    [client, invalidateAuth]
+  );
+  const signOut = useCallback(async () => {
+    try {
+      await client.auth.signOut();
+    } finally {
+      queryClient.setQueryData(["auth", "state"], DEFAULT_AUTH_STATE);
+      await invalidateAuth();
+    }
+  }, [client, queryClient, invalidateAuth]);
+  const currentState = authState ?? DEFAULT_AUTH_STATE;
+  return {
+    ...currentState,
+    // Ensure booleans
+    isAuthenticated: !!currentState.isAuthenticated,
+    isLoading,
+    error,
+    refresh: async () => {
+      await refetch();
+    },
+    signIn,
+    signUp,
+    signOut
+  };
+}
+function useRequestPasswordReset() {
+  const client = useArchlast();
+  return useTanStackMutation({
+    mutationFn: async (email) => {
+      return client.auth.requestPasswordReset(email);
+    }
+  });
+}
+function useResetPassword() {
+  const client = useArchlast();
+  return useTanStackMutation({
+    mutationFn: async ({ token, password }) => {
+      return client.auth.resetPassword(token, password);
+    }
+  });
+}
+function useDownload(options) {
+  const client = useArchlast();
+  const [isDownloading, setDownloading] = useState(false);
+  const [error, setError] = useState(null);
+  const presign = useCallback(
+    async (id, expiresInSeconds = 300) => {
+      const { url: relativeUrl } = await client.storage.presign(id, expiresInSeconds);
+      const absoluteUrl = relativeUrl.startsWith("http") ? relativeUrl : `${options?.baseUrl ?? client.baseUrl ?? ""}${relativeUrl.startsWith("/") ? "" : "/"}${relativeUrl}`;
+      return absoluteUrl;
+    },
+    [client, options?.baseUrl]
+  );
+  const download = useCallback(
+    async (id, expiresInSeconds = 300) => {
+      setDownloading(true);
+      setError(null);
+      try {
+        const signedUrl = await presign(id, expiresInSeconds);
+        const response = await axios4.get(signedUrl, {
+          responseType: "blob"
+        });
+        const blob = response.data;
+        const objectUrl = URL.createObjectURL(blob);
+        return { blob, url: objectUrl };
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setDownloading(false);
+      }
+    },
+    [presign]
+  );
+  return { getUrl: presign, download, isDownloading, error };
+}
+function useStorageDelete(options) {
+  const client = useArchlast();
+  const [isDeleting, setDeleting] = useState(false);
+  const [error, setError] = useState(null);
+  const deleteFile = useCallback(
+    async (id) => {
+      setDeleting(true);
+      setError(null);
+      try {
+        const deleteUrl = `${options?.baseUrl ?? ""}/_archlast/storage/files/${encodeURIComponent(id)}`;
+        await axios4.delete(deleteUrl, {
+          withCredentials: true
+        });
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setDeleting(false);
+      }
+    },
+    [options?.baseUrl]
+  );
+  return { deleteFile, isDeleting, error };
+}
+function useClientPagination(data, initialPageSize = 10) {
+  const [page, setPage] = useState(1);
+  const [pageSize, setPageSize] = useState(initialPageSize);
+  const items = data || [];
+  const total = items.length;
+  const totalPages = Math.ceil(total / pageSize);
+  const startIndex = (page - 1) * pageSize;
+  const endIndex = startIndex + pageSize;
+  const paginatedItems = items.slice(startIndex, endIndex);
+  const hasMore = page < totalPages;
+  const hasPrevious = page > 1;
+  const nextPage = () => {
+    if (hasMore) setPage((p) => p + 1);
+  };
+  const previousPage = () => {
+    if (hasPrevious) setPage((p) => p - 1);
+  };
+  const handleSetPage = (newPage) => {
+    const validPage = Math.max(1, Math.min(newPage, totalPages || 1));
+    setPage(validPage);
+  };
+  const handleSetPageSize = (size) => {
+    setPageSize(size);
+    setPage(1);
+  };
+  useEffect(() => {
+    setPage(1);
+  }, [data?.length]);
+  return {
+    items: paginatedItems,
+    page,
+    pageSize,
+    total,
+    totalPages,
+    hasMore,
+    hasPrevious,
+    nextPage,
+    previousPage,
+    setPage: handleSetPage,
+    setPageSize: handleSetPageSize
+  };
+}
+function usePagination(queryRef, baseArgs, options) {
+  const client = useArchlast();
+  const queryClient = useQueryClient();
+  const [cursor, setCursor] = useState(null);
+  const [allItems, setAllItems] = useState([]);
+  const limit = options?.limit || 20;
+  const args = { ...baseArgs, cursor, limit };
+  const queryKey = [queryRef._name, args];
+  useEffect(() => {
+    const unsubscribe = client.subscribe(queryRef._name, args, (data2) => {
+      queryClient.setQueryData(queryKey, data2);
+    });
+    return () => unsubscribe();
+  }, [client, queryRef._name, JSON.stringify(args), queryClient]);
+  const query = useTanStackQuery({
+    queryKey,
+    queryFn: async () => {
+      const result = await client.fetch(queryRef._name, args);
+      return result === void 0 ? { items: [], continueCursor: null, isDone: true } : result;
+    },
+    // staleTime: 0,
+    // gcTime: 1000 * 60 * 5,
+    enabled: options?.enabled !== false
+  });
+  const data = query.data;
+  useEffect(() => {
+    if (data?.items) {
+      if (cursor === null) {
+        setAllItems(data.items);
+      } else {
+        setAllItems((prev) => [...prev, ...data.items]);
+      }
+    }
+  }, [data, cursor]);
+  const loadMore = () => {
+    if (data && !data.isDone && data.continueCursor) {
+      setCursor(data.continueCursor);
+    }
+  };
+  const refresh = () => {
+    setCursor(null);
+    setAllItems([]);
+    queryClient.invalidateQueries({ queryKey: [queryRef._name] });
+  };
+  return {
+    items: allItems,
+    cursor: data?.continueCursor ?? null,
+    isDone: data?.isDone ?? false,
+    page: data?.page,
+    pageSize: data?.pageSize,
+    total: data?.total,
+    hasMore: !data?.isDone && !!data?.continueCursor,
+    loadMore,
+    refresh,
+    isLoading: query.isLoading
+  };
+}
+function useStorageList(limit = 20, offset = 0) {
+  const client = useArchlast();
+  return useTanStackQuery({
+    queryKey: ["storage", "list", limit, offset],
+    queryFn: () => client.storage.list(limit, offset)
+  });
+}
+function useStorageMetadata(id) {
+  const client = useArchlast();
+  return useTanStackQuery({
+    queryKey: ["storage", "file", id],
+    queryFn: () => client.storage.getMetadata(id),
+    enabled: !!id
+  });
+}
+function useStorageUpload() {
+  const client = useArchlast();
+  const queryClient = useQueryClient();
+  return useTanStackMutation({
+    mutationFn: (file) => client.storage.upload(file),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["storage", "list"] });
+    }
+  });
+}
+function useStorageDeleteFile() {
+  const client = useArchlast();
+  const queryClient = useQueryClient();
+  return useTanStackMutation({
+    mutationFn: (id) => client.storage.delete(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["storage", "list"] });
+    }
+  });
+}
+function useStorageHelpers() {
+  const client = useArchlast();
+  return {
+    getPublicUrl: (id) => client.storage.getPublicUrl(id)
+  };
+}
+
+// src/function-reference.ts
+function makeFunctionReference(name) {
+  return {
+    _type: "query",
+    _name: name,
+    _args: void 0,
+    _return: void 0,
+    _auth: void 0
+  };
+}
+function makeRpcReference(name) {
+  return {
+    _procedureType: "query",
+    _name: name,
+    _args: void 0,
+    _return: void 0,
+    _auth: void 0
+  };
+}
+
+// src/trpc.ts
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+var BETTER_AUTH_API_KEY_PREFIX = "arch_";
+function isBetterAuthApiKey(token) {
+  return token.startsWith(BETTER_AUTH_API_KEY_PREFIX);
+}
+function createArchlastTRPCClient(options = {}) {
+  const {
+    baseUrl = "http://localhost:4000",
+    apiKey,
+    sessionToken,
+    batch = true,
+    headers: customHeaders = {}
+  } = options;
+  const headers = {
+    "Content-Type": "application/json",
+    ...customHeaders
+  };
+  if (apiKey) {
+    if (isBetterAuthApiKey(apiKey)) {
+      headers["x-api-key"] = apiKey;
+    } else {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+  }
+  if (sessionToken) {
+    headers["Cookie"] = `archlast-session=${sessionToken}`;
+  }
+  return createTRPCClient({
+    links: [
+      httpBatchLink({
+        url: `${baseUrl}/api/trpc`,
+        headers
+      })
+    ]
+  });
+}
+export {
+  ArchlastAuthClient,
+  ArchlastClient,
+  ArchlastContext,
+  ArchlastProvider,
+  StorageClient,
+  createArchlastTRPCClient,
+  makeFunctionReference,
+  makeRpcReference,
+  useArchlast,
+  useAuth,
+  useClientPagination,
+  useDownload,
+  useMutation,
+  usePagination,
+  useQuery,
+  useRequestPasswordReset,
+  useResetPassword,
+  useStorageDelete,
+  useStorageDeleteFile,
+  useStorageHelpers,
+  useStorageList,
+  useStorageMetadata,
+  useStorageUpload,
+  useUpload
+};
+//# sourceMappingURL=index.js.map