@withvlibe/base-sdk 1.0.0

package/dist/react.d.mts

@@ -0,0 +1,96 @@
+import { j as BaseRecord, V as VlibeBaseDatabase, w as UseCollectionOptions, v as UseCollectionReturn, x as UseKVReturn, c as VlibeBaseAuth, y as UseAuthReturn } from './VlibeBaseAuth-ChuzgzDl.mjs';
+export { z as UsePaymentsReturn, l as VlibeUser } from './VlibeBaseAuth-ChuzgzDl.mjs';
+
+/**
+ * React hook for working with a database collection
+ *
+ * @param db - VlibeBaseDatabase instance
+ * @param collection - Collection name
+ * @param options - Query options
+ * @returns Collection data and operations
+ *
+ * @example
+ * ```tsx
+ * function TodoList() {
+ *   const { data, loading, insert, remove } = useCollection(db, 'todos', {
+ *     orderBy: 'created_at',
+ *     orderDirection: 'desc',
+ *     realtime: true,
+ *   });
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <ul>
+ *       {data.map(todo => (
+ *         <li key={todo.id}>
+ *           {todo.title}
+ *           <button onClick={() => remove(todo.id)}>Delete</button>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useCollection<T extends BaseRecord = BaseRecord>(db: VlibeBaseDatabase, collection: string, options?: UseCollectionOptions): UseCollectionReturn<T>;
+
+/**
+ * React hook for working with key-value storage
+ *
+ * @param db - VlibeBaseDatabase instance
+ * @param key - The key to read/write
+ * @returns KV data and operations
+ *
+ * @example
+ * ```tsx
+ * function Settings() {
+ *   const { data, loading, set } = useKV<{ theme: string }>(db, 'user-settings');
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <select
+ *       value={data?.theme || 'light'}
+ *       onChange={(e) => set({ ...data, theme: e.target.value })}
+ *     >
+ *       <option value="light">Light</option>
+ *       <option value="dark">Dark</option>
+ *     </select>
+ *   );
+ * }
+ * ```
+ */
+declare function useKV<T = unknown>(db: VlibeBaseDatabase, key: string): UseKVReturn<T>;
+
+/**
+ * React hook for authentication
+ *
+ * @param auth - VlibeBaseAuth instance
+ * @param initialToken - Optional initial token (from SSO callback)
+ * @returns Auth state and operations
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { user, loading, login, logout, hasFeature } = useAuth(auth);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   if (!user) {
+ *     return <button onClick={() => login()}>Login</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Welcome, {user.name}!</p>
+ *       {hasFeature('premium') && <PremiumFeature />}
+ *       <button onClick={() => logout()}>Logout</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAuth(auth: VlibeBaseAuth, initialToken?: string | null): UseAuthReturn;
+
+export { BaseRecord, UseAuthReturn, UseCollectionOptions, UseCollectionReturn, UseKVReturn, useAuth, useCollection, useKV };

package/dist/react.d.ts

@@ -0,0 +1,96 @@
+import { j as BaseRecord, V as VlibeBaseDatabase, w as UseCollectionOptions, v as UseCollectionReturn, x as UseKVReturn, c as VlibeBaseAuth, y as UseAuthReturn } from './VlibeBaseAuth-ChuzgzDl.js';
+export { z as UsePaymentsReturn, l as VlibeUser } from './VlibeBaseAuth-ChuzgzDl.js';
+
+/**
+ * React hook for working with a database collection
+ *
+ * @param db - VlibeBaseDatabase instance
+ * @param collection - Collection name
+ * @param options - Query options
+ * @returns Collection data and operations
+ *
+ * @example
+ * ```tsx
+ * function TodoList() {
+ *   const { data, loading, insert, remove } = useCollection(db, 'todos', {
+ *     orderBy: 'created_at',
+ *     orderDirection: 'desc',
+ *     realtime: true,
+ *   });
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <ul>
+ *       {data.map(todo => (
+ *         <li key={todo.id}>
+ *           {todo.title}
+ *           <button onClick={() => remove(todo.id)}>Delete</button>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useCollection<T extends BaseRecord = BaseRecord>(db: VlibeBaseDatabase, collection: string, options?: UseCollectionOptions): UseCollectionReturn<T>;
+
+/**
+ * React hook for working with key-value storage
+ *
+ * @param db - VlibeBaseDatabase instance
+ * @param key - The key to read/write
+ * @returns KV data and operations
+ *
+ * @example
+ * ```tsx
+ * function Settings() {
+ *   const { data, loading, set } = useKV<{ theme: string }>(db, 'user-settings');
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <select
+ *       value={data?.theme || 'light'}
+ *       onChange={(e) => set({ ...data, theme: e.target.value })}
+ *     >
+ *       <option value="light">Light</option>
+ *       <option value="dark">Dark</option>
+ *     </select>
+ *   );
+ * }
+ * ```
+ */
+declare function useKV<T = unknown>(db: VlibeBaseDatabase, key: string): UseKVReturn<T>;
+
+/**
+ * React hook for authentication
+ *
+ * @param auth - VlibeBaseAuth instance
+ * @param initialToken - Optional initial token (from SSO callback)
+ * @returns Auth state and operations
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { user, loading, login, logout, hasFeature } = useAuth(auth);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   if (!user) {
+ *     return <button onClick={() => login()}>Login</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Welcome, {user.name}!</p>
+ *       {hasFeature('premium') && <PremiumFeature />}
+ *       <button onClick={() => logout()}>Logout</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAuth(auth: VlibeBaseAuth, initialToken?: string | null): UseAuthReturn;
+
+export { BaseRecord, UseAuthReturn, UseCollectionOptions, UseCollectionReturn, UseKVReturn, useAuth, useCollection, useKV };

package/dist/react.js

@@ -0,0 +1,273 @@
+"use strict";
+"use client";
+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/react.ts
+var react_exports = {};
+__export(react_exports, {
+  useAuth: () => useAuth,
+  useCollection: () => useCollection,
+  useKV: () => useKV
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/hooks/useCollection.ts
+var import_react = require("react");
+function useCollection(db, collection, options = {}) {
+  const [data, setData] = (0, import_react.useState)([]);
+  const [loading, setLoading] = (0, import_react.useState)(true);
+  const [error, setError] = (0, import_react.useState)(null);
+  const { realtime = false, ...queryOptions } = options;
+  const refresh = (0, import_react.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await db.query(collection, queryOptions);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch data"));
+    } finally {
+      setLoading(false);
+    }
+  }, [db, collection, JSON.stringify(queryOptions)]);
+  const insert = (0, import_react.useCallback)(
+    async (doc) => {
+      try {
+        const result = await db.insert(collection, doc);
+        if (!realtime) {
+          setData((prev) => [result, ...prev]);
+        }
+        return result;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to insert"));
+        return null;
+      }
+    },
+    [db, collection, realtime]
+  );
+  const update = (0, import_react.useCallback)(
+    async (id, updates) => {
+      try {
+        const result = await db.update(collection, id, updates);
+        if (!realtime) {
+          setData(
+            (prev) => prev.map((item) => item.id === id ? result : item)
+          );
+        }
+        return result;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to update"));
+        return null;
+      }
+    },
+    [db, collection, realtime]
+  );
+  const remove = (0, import_react.useCallback)(
+    async (id) => {
+      try {
+        await db.delete(collection, id);
+        if (!realtime) {
+          setData((prev) => prev.filter((item) => item.id !== id));
+        }
+        return true;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to delete"));
+        return false;
+      }
+    },
+    [db, collection, realtime]
+  );
+  (0, import_react.useEffect)(() => {
+    refresh();
+  }, [refresh]);
+  (0, import_react.useEffect)(() => {
+    if (!realtime) return;
+    const subscription = db.subscribe(
+      collection,
+      (payload) => {
+        switch (payload.eventType) {
+          case "INSERT":
+            if (payload.new) {
+              setData((prev) => [payload.new, ...prev]);
+            }
+            break;
+          case "UPDATE":
+            if (payload.new) {
+              setData(
+                (prev) => prev.map(
+                  (item) => item.id === payload.new.id ? payload.new : item
+                )
+              );
+            }
+            break;
+          case "DELETE":
+            if (payload.old) {
+              setData(
+                (prev) => prev.filter((item) => item.id !== payload.old.id)
+              );
+            }
+            break;
+        }
+      }
+    );
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [db, collection, realtime]);
+  return {
+    data,
+    loading,
+    error,
+    refresh,
+    insert,
+    update,
+    remove
+  };
+}
+
+// src/hooks/useKV.ts
+var import_react2 = require("react");
+function useKV(db, key) {
+  const [data, setData] = (0, import_react2.useState)(null);
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const refresh = (0, import_react2.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await db.getKV(key);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch KV"));
+    } finally {
+      setLoading(false);
+    }
+  }, [db, key]);
+  const set = (0, import_react2.useCallback)(
+    async (value) => {
+      try {
+        await db.setKV(key, value);
+        setData(value);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to set KV"));
+        throw err;
+      }
+    },
+    [db, key]
+  );
+  (0, import_react2.useEffect)(() => {
+    refresh();
+  }, [refresh]);
+  return {
+    data,
+    loading,
+    error,
+    set,
+    refresh
+  };
+}
+
+// src/hooks/useAuth.ts
+var import_react3 = require("react");
+function useAuth(auth, initialToken) {
+  const [user, setUser] = (0, import_react3.useState)(null);
+  const [loading, setLoading] = (0, import_react3.useState)(true);
+  const [error, setError] = (0, import_react3.useState)(null);
+  (0, import_react3.useEffect)(() => {
+    const verifySession = async () => {
+      setLoading(true);
+      setError(null);
+      try {
+        let token = initialToken;
+        if (!token && typeof window !== "undefined") {
+          const params = new URLSearchParams(window.location.search);
+          token = params.get("vlibe_token");
+        }
+        if (!token && typeof window !== "undefined") {
+          token = localStorage.getItem("vlibe_base_token");
+        }
+        if (token) {
+          const verifiedUser = await auth.verifySession(token);
+          if (verifiedUser) {
+            setUser(verifiedUser);
+            if (typeof window !== "undefined") {
+              localStorage.setItem("vlibe_base_token", token);
+            }
+          } else {
+            if (typeof window !== "undefined") {
+              localStorage.removeItem("vlibe_base_token");
+            }
+          }
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Auth verification failed"));
+      } finally {
+        setLoading(false);
+      }
+    };
+    verifySession();
+  }, [auth, initialToken]);
+  const login = (0, import_react3.useCallback)(
+    (redirectPath) => {
+      const currentPath = typeof window !== "undefined" ? window.location.pathname : "/";
+      const loginUrl = auth.getLoginUrl(redirectPath || currentPath);
+      if (typeof window !== "undefined") {
+        window.location.href = loginUrl;
+      }
+    },
+    [auth]
+  );
+  const logout = (0, import_react3.useCallback)(
+    (redirectPath) => {
+      if (typeof window !== "undefined") {
+        localStorage.removeItem("vlibe_base_token");
+      }
+      setUser(null);
+      const logoutUrl = auth.getLogoutUrl(redirectPath || "/");
+      if (typeof window !== "undefined") {
+        window.location.href = logoutUrl;
+      }
+    },
+    [auth]
+  );
+  const hasFeature = (0, import_react3.useCallback)(
+    (feature) => {
+      return auth.hasFeature(user, feature);
+    },
+    [auth, user]
+  );
+  const hasSubscription = (0, import_react3.useCallback)(() => {
+    return auth.hasSubscription(user);
+  }, [auth, user]);
+  return {
+    user,
+    loading,
+    error,
+    login,
+    logout,
+    hasFeature,
+    hasSubscription
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAuth,
+  useCollection,
+  useKV
+});

package/dist/react.mjs

@@ -0,0 +1,245 @@
+"use client";
+
+// src/hooks/useCollection.ts
+import { useState, useEffect, useCallback } from "react";
+function useCollection(db, collection, options = {}) {
+  const [data, setData] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const { realtime = false, ...queryOptions } = options;
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await db.query(collection, queryOptions);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch data"));
+    } finally {
+      setLoading(false);
+    }
+  }, [db, collection, JSON.stringify(queryOptions)]);
+  const insert = useCallback(
+    async (doc) => {
+      try {
+        const result = await db.insert(collection, doc);
+        if (!realtime) {
+          setData((prev) => [result, ...prev]);
+        }
+        return result;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to insert"));
+        return null;
+      }
+    },
+    [db, collection, realtime]
+  );
+  const update = useCallback(
+    async (id, updates) => {
+      try {
+        const result = await db.update(collection, id, updates);
+        if (!realtime) {
+          setData(
+            (prev) => prev.map((item) => item.id === id ? result : item)
+          );
+        }
+        return result;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to update"));
+        return null;
+      }
+    },
+    [db, collection, realtime]
+  );
+  const remove = useCallback(
+    async (id) => {
+      try {
+        await db.delete(collection, id);
+        if (!realtime) {
+          setData((prev) => prev.filter((item) => item.id !== id));
+        }
+        return true;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to delete"));
+        return false;
+      }
+    },
+    [db, collection, realtime]
+  );
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+  useEffect(() => {
+    if (!realtime) return;
+    const subscription = db.subscribe(
+      collection,
+      (payload) => {
+        switch (payload.eventType) {
+          case "INSERT":
+            if (payload.new) {
+              setData((prev) => [payload.new, ...prev]);
+            }
+            break;
+          case "UPDATE":
+            if (payload.new) {
+              setData(
+                (prev) => prev.map(
+                  (item) => item.id === payload.new.id ? payload.new : item
+                )
+              );
+            }
+            break;
+          case "DELETE":
+            if (payload.old) {
+              setData(
+                (prev) => prev.filter((item) => item.id !== payload.old.id)
+              );
+            }
+            break;
+        }
+      }
+    );
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [db, collection, realtime]);
+  return {
+    data,
+    loading,
+    error,
+    refresh,
+    insert,
+    update,
+    remove
+  };
+}
+
+// src/hooks/useKV.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+function useKV(db, key) {
+  const [data, setData] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const refresh = useCallback2(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await db.getKV(key);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch KV"));
+    } finally {
+      setLoading(false);
+    }
+  }, [db, key]);
+  const set = useCallback2(
+    async (value) => {
+      try {
+        await db.setKV(key, value);
+        setData(value);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to set KV"));
+        throw err;
+      }
+    },
+    [db, key]
+  );
+  useEffect2(() => {
+    refresh();
+  }, [refresh]);
+  return {
+    data,
+    loading,
+    error,
+    set,
+    refresh
+  };
+}
+
+// src/hooks/useAuth.ts
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback3 } from "react";
+function useAuth(auth, initialToken) {
+  const [user, setUser] = useState3(null);
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  useEffect3(() => {
+    const verifySession = async () => {
+      setLoading(true);
+      setError(null);
+      try {
+        let token = initialToken;
+        if (!token && typeof window !== "undefined") {
+          const params = new URLSearchParams(window.location.search);
+          token = params.get("vlibe_token");
+        }
+        if (!token && typeof window !== "undefined") {
+          token = localStorage.getItem("vlibe_base_token");
+        }
+        if (token) {
+          const verifiedUser = await auth.verifySession(token);
+          if (verifiedUser) {
+            setUser(verifiedUser);
+            if (typeof window !== "undefined") {
+              localStorage.setItem("vlibe_base_token", token);
+            }
+          } else {
+            if (typeof window !== "undefined") {
+              localStorage.removeItem("vlibe_base_token");
+            }
+          }
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Auth verification failed"));
+      } finally {
+        setLoading(false);
+      }
+    };
+    verifySession();
+  }, [auth, initialToken]);
+  const login = useCallback3(
+    (redirectPath) => {
+      const currentPath = typeof window !== "undefined" ? window.location.pathname : "/";
+      const loginUrl = auth.getLoginUrl(redirectPath || currentPath);
+      if (typeof window !== "undefined") {
+        window.location.href = loginUrl;
+      }
+    },
+    [auth]
+  );
+  const logout = useCallback3(
+    (redirectPath) => {
+      if (typeof window !== "undefined") {
+        localStorage.removeItem("vlibe_base_token");
+      }
+      setUser(null);
+      const logoutUrl = auth.getLogoutUrl(redirectPath || "/");
+      if (typeof window !== "undefined") {
+        window.location.href = logoutUrl;
+      }
+    },
+    [auth]
+  );
+  const hasFeature = useCallback3(
+    (feature) => {
+      return auth.hasFeature(user, feature);
+    },
+    [auth, user]
+  );
+  const hasSubscription = useCallback3(() => {
+    return auth.hasSubscription(user);
+  }, [auth, user]);
+  return {
+    user,
+    loading,
+    error,
+    login,
+    logout,
+    hasFeature,
+    hasSubscription
+  };
+}
+export {
+  useAuth,
+  useCollection,
+  useKV
+};