@xnetjs/react 0.0.2 → 0.1.0

package/dist/chunk-KSHTDZ2V.js

@@ -0,0 +1,893 @@
+import {
+  useNodeStore
+} from "./chunk-IHTMVTTE.js";
+
+// src/hooks/useDatabaseDoc.ts
+import {
+  getColumns,
+  getColumn,
+  createColumn as createColumnOp,
+  updateColumn as updateColumnOp,
+  deleteColumn as deleteColumnOp,
+  reorderColumn as reorderColumnOp,
+  duplicateColumn as duplicateColumnOp,
+  getViews,
+  getView,
+  createView as createViewOp,
+  updateView as updateViewOp,
+  deleteView as deleteViewOp,
+  duplicateView as duplicateViewOp,
+  initializeDatabaseDoc,
+  isDatabaseDocInitialized,
+  getDatabaseDocumentModel
+} from "@xnetjs/data";
+import { useState, useEffect, useCallback, useRef } from "react";
+import * as Y from "yjs";
+function useDatabaseDoc(databaseId) {
+  const { store, isReady } = useNodeStore();
+  const [doc, setDoc] = useState(null);
+  const [columns, setColumns] = useState([]);
+  const [views, setViews] = useState([]);
+  const [storageMode, setStorageMode] = useState("empty");
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const storeRef = useRef(store);
+  storeRef.current = store;
+  const docRef = useRef(null);
+  docRef.current = doc;
+  const storageModeRef = useRef("empty");
+  storageModeRef.current = storageMode;
+  const refreshStateFromDoc = useCallback((currentDoc) => {
+    setStorageMode(getDatabaseDocumentModel(currentDoc));
+    setColumns(getColumns(currentDoc));
+    setViews(getViews(currentDoc));
+  }, []);
+  useEffect(() => {
+    if (!store || !isReady || !databaseId) {
+      setDoc(null);
+      setColumns([]);
+      setViews([]);
+      setStorageMode("empty");
+      setLoading(false);
+      return;
+    }
+    let mounted = true;
+    const loadDoc = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const ydoc = new Y.Doc({ guid: databaseId, gc: false });
+        const storedContent = await store.getDocumentContent(databaseId);
+        if (storedContent && storedContent.length > 0) {
+          Y.applyUpdate(ydoc, storedContent);
+        }
+        if (!mounted) {
+          ydoc.destroy();
+          return;
+        }
+        if (!isDatabaseDocInitialized(ydoc)) {
+          initializeDatabaseDoc(ydoc);
+        }
+        docRef.current = ydoc;
+        setDoc(ydoc);
+        refreshStateFromDoc(ydoc);
+      } catch (err) {
+        if (!mounted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (mounted) setLoading(false);
+      }
+    };
+    loadDoc();
+    return () => {
+      mounted = false;
+      if (docRef.current && store) {
+        const content = Y.encodeStateAsUpdate(docRef.current);
+        store.setDocumentContent(databaseId, content).catch(() => {
+        });
+        docRef.current.destroy();
+        docRef.current = null;
+      }
+    };
+  }, [store, isReady, databaseId, refreshStateFromDoc]);
+  useEffect(() => {
+    if (!doc) return;
+    const handleUpdate = () => {
+      refreshStateFromDoc(doc);
+    };
+    doc.on("update", handleUpdate);
+    handleUpdate();
+    return () => {
+      doc.off("update", handleUpdate);
+    };
+  }, [doc, refreshStateFromDoc]);
+  useEffect(() => {
+    if (!doc || !store) return;
+    let saveTimeout = null;
+    const handleUpdate = () => {
+      if (saveTimeout) {
+        clearTimeout(saveTimeout);
+      }
+      saveTimeout = setTimeout(() => {
+        if (docRef.current && store) {
+          const content = Y.encodeStateAsUpdate(docRef.current);
+          store.setDocumentContent(databaseId, content).catch(() => {
+          });
+        }
+      }, 500);
+    };
+    doc.on("update", handleUpdate);
+    return () => {
+      doc.off("update", handleUpdate);
+      if (saveTimeout) {
+        clearTimeout(saveTimeout);
+      }
+    };
+  }, [doc, store, databaseId]);
+  const handleCreateColumn = useCallback(
+    (definition) => {
+      if (!docRef.current) return null;
+      return createColumnOp(docRef.current, definition);
+    },
+    []
+  );
+  const handleUpdateColumn = useCallback(
+    (columnId, updates) => {
+      if (!docRef.current) return;
+      updateColumnOp(docRef.current, columnId, updates);
+    },
+    []
+  );
+  const handleDeleteColumn = useCallback((columnId) => {
+    if (!docRef.current) return;
+    deleteColumnOp(docRef.current, columnId);
+  }, []);
+  const handleReorderColumn = useCallback((columnId, newIndex) => {
+    if (!docRef.current) return;
+    reorderColumnOp(docRef.current, columnId, newIndex);
+  }, []);
+  const handleDuplicateColumn = useCallback((columnId, newName) => {
+    if (!docRef.current) return null;
+    return duplicateColumnOp(docRef.current, columnId, newName);
+  }, []);
+  const handleGetColumn = useCallback((columnId) => {
+    if (!docRef.current) return null;
+    return getColumn(docRef.current, columnId);
+  }, []);
+  const handleCreateView = useCallback((config) => {
+    if (!docRef.current) return null;
+    return createViewOp(docRef.current, config);
+  }, []);
+  const handleUpdateView = useCallback(
+    (viewId, updates) => {
+      if (!docRef.current) return;
+      updateViewOp(docRef.current, viewId, updates);
+    },
+    []
+  );
+  const handleDeleteView = useCallback((viewId) => {
+    if (!docRef.current) return;
+    deleteViewOp(docRef.current, viewId);
+  }, []);
+  const handleDuplicateView = useCallback((viewId, newName) => {
+    if (!docRef.current) return null;
+    return duplicateViewOp(docRef.current, viewId, newName);
+  }, []);
+  const handleGetView = useCallback((viewId) => {
+    if (!docRef.current) return null;
+    return getView(docRef.current, viewId);
+  }, []);
+  return {
+    columns,
+    views,
+    doc,
+    storageMode,
+    loading,
+    error,
+    // Column operations
+    createColumn: handleCreateColumn,
+    updateColumn: handleUpdateColumn,
+    deleteColumn: handleDeleteColumn,
+    reorderColumn: handleReorderColumn,
+    duplicateColumn: handleDuplicateColumn,
+    getColumn: handleGetColumn,
+    // View operations
+    createView: handleCreateView,
+    updateView: handleUpdateView,
+    deleteView: handleDeleteView,
+    duplicateView: handleDuplicateView,
+    getView: handleGetView
+  };
+}
+
+// src/hooks/useDatabase.ts
+import {
+  queryRows,
+  createRow as createRowOp,
+  updateCells,
+  deleteRow as deleteRowOp,
+  moveRow,
+  fromCellProperties,
+  filterRows,
+  sortRows
+} from "@xnetjs/data";
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useMemo, useRef as useRef2 } from "react";
+function useDatabase(databaseId, options = {}) {
+  const { store, isReady } = useNodeStore();
+  const {
+    columns,
+    views,
+    doc,
+    storageMode,
+    loading: databaseDocLoading
+  } = useDatabaseDoc(databaseId);
+  const [rows, setRows] = useState2([]);
+  const [total, setTotal] = useState2(0);
+  const [cursor, setCursor] = useState2();
+  const [offset, setOffset] = useState2(0);
+  const [hasMore, setHasMore] = useState2(false);
+  const [loading, setLoading] = useState2(true);
+  const [loadingMore, setLoadingMore] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [activeViewId, setActiveViewId] = useState2(options.view);
+  const { pageSize = 50, filters, sorts, search } = options;
+  const storeRef = useRef2(store);
+  storeRef.current = store;
+  const docRef = useRef2(doc);
+  docRef.current = doc;
+  const storageModeRef = useRef2(storageMode);
+  storageModeRef.current = storageMode;
+  const rowsRef = useRef2([]);
+  rowsRef.current = rows;
+  const resolvedActiveViewId = options.view ?? activeViewId;
+  const activeView = useMemo(() => {
+    if (resolvedActiveViewId) {
+      return views.find((v) => v.id === resolvedActiveViewId) ?? null;
+    }
+    return views[0] ?? null;
+  }, [views, resolvedActiveViewId]);
+  const effectiveFilters = useMemo(
+    () => filters ?? activeView?.filters ?? null,
+    [filters, activeView]
+  );
+  const effectiveSorts = useMemo(() => sorts ?? activeView?.sorts ?? [], [sorts, activeView]);
+  const materializedView = useMemo(
+    () => resolveDatabaseMaterializedView(databaseId, activeView, options.materializedView),
+    [activeView, databaseId, options.materializedView]
+  );
+  useEffect2(() => {
+    setActiveViewId(options.view);
+  }, [options.view]);
+  const fetchRows = useCallback2(
+    async (reset = true) => {
+      if (!store || !isReady) return;
+      try {
+        if (reset) {
+          setLoading(true);
+          setCursor(void 0);
+          setOffset(0);
+        } else {
+          setLoadingMore(true);
+        }
+        const queryOffset = reset ? 0 : offset;
+        const canonicalResult = await queryRows(store, databaseId, {
+          limit: pageSize * 10,
+          offset: queryOffset,
+          materializedView
+        });
+        let parsedRows = canonicalResult.rows.map((node) => nodeToRow(node, columns));
+        if (effectiveFilters && effectiveFilters.conditions.length > 0) {
+          parsedRows = filterRows(parsedRows, columns, effectiveFilters);
+        }
+        if (effectiveSorts.length > 0) {
+          parsedRows = sortRows(parsedRows, columns, effectiveSorts);
+        }
+        parsedRows = parsedRows.slice(0, pageSize);
+        if (reset) {
+          setRows(parsedRows);
+        } else {
+          setRows((prev) => [...prev, ...parsedRows]);
+        }
+        setTotal(parsedRows.length);
+        setCursor(void 0);
+        setOffset(queryOffset + canonicalResult.rows.length);
+        setHasMore(canonicalResult.hasMore);
+        setError(null);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+        setLoadingMore(false);
+      }
+    },
+    [
+      store,
+      isReady,
+      databaseId,
+      pageSize,
+      cursor,
+      offset,
+      columns,
+      effectiveFilters,
+      effectiveSorts,
+      materializedView
+    ]
+  );
+  useEffect2(() => {
+    if (databaseDocLoading) {
+      return;
+    }
+    if (columns.length > 0) {
+      void fetchRows(true);
+      return;
+    }
+    setRows([]);
+    setTotal(0);
+    setCursor(void 0);
+    setOffset(0);
+    setHasMore(false);
+    setError(null);
+    setLoading(false);
+    setLoadingMore(false);
+  }, [databaseId, columns.length, databaseDocLoading, doc, storageMode]);
+  useEffect2(() => {
+    if (!databaseDocLoading && columns.length > 0) {
+      void fetchRows(true);
+    }
+  }, [
+    databaseDocLoading,
+    effectiveFilters,
+    effectiveSorts,
+    search,
+    doc,
+    storageMode,
+    materializedView
+  ]);
+  useEffect2(() => {
+    if (!store) return;
+    const unsubscribe = store.subscribe((event) => {
+      const node = event.node;
+      if (node?.schemaId === "xnet://xnet.fyi/DatabaseRow") {
+        const dbId = node.properties.database;
+        if (dbId === databaseId) {
+          fetchRows(true);
+        }
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [store, databaseId, fetchRows, doc]);
+  const loadMore = useCallback2(async () => {
+    if (!hasMore || loadingMore) return;
+    await fetchRows(false);
+  }, [hasMore, loadingMore, fetchRows]);
+  const handleCreateRow = useCallback2(
+    async (values) => {
+      if (!storeRef.current) throw new Error("Store not ready");
+      const lastRow = rows[rows.length - 1];
+      const rowId = await createRowOp(storeRef.current, {
+        databaseId,
+        cells: values ?? {},
+        after: lastRow?.sortKey
+      });
+      return rowId;
+    },
+    [databaseId, rows]
+  );
+  const handleUpdateRow = useCallback2(
+    async (rowId, values) => {
+      if (!storeRef.current) throw new Error("Store not ready");
+      await updateCells(storeRef.current, rowId, values);
+    },
+    []
+  );
+  const handleDeleteRow = useCallback2(async (rowId) => {
+    if (!storeRef.current) throw new Error("Store not ready");
+    await deleteRowOp(storeRef.current, rowId);
+  }, []);
+  const handleReorderRow = useCallback2(
+    async (rowId, before, after) => {
+      if (!storeRef.current) throw new Error("Store not ready");
+      const resolveBoundary = (value) => {
+        if (!value) return void 0;
+        const matchingRow = rowsRef.current.find((row) => row.id === value || row.sortKey === value);
+        return matchingRow?.sortKey ?? value;
+      };
+      await moveRow(storeRef.current, rowId, {
+        before: resolveBoundary(before),
+        after: resolveBoundary(after)
+      });
+    },
+    []
+  );
+  const handleDeleteRows = useCallback2(async (rowIds) => {
+    if (!storeRef.current) throw new Error("Store not ready");
+    await Promise.all(rowIds.map((id) => deleteRowOp(storeRef.current, id)));
+  }, []);
+  return {
+    columns,
+    views,
+    rows,
+    total,
+    hasMore,
+    loadMore,
+    activeView,
+    setActiveView: setActiveViewId,
+    createRow: handleCreateRow,
+    updateRow: handleUpdateRow,
+    deleteRow: handleDeleteRow,
+    reorderRow: handleReorderRow,
+    deleteRows: handleDeleteRows,
+    loading,
+    loadingMore,
+    error,
+    refetch: () => fetchRows(true)
+  };
+}
+function resolveDatabaseMaterializedView(databaseId, activeView, option) {
+  if (!option) {
+    return void 0;
+  }
+  if (option === true) {
+    return activeView ? { viewId: `database:${databaseId}:view:${activeView.id}` } : void 0;
+  }
+  return option;
+}
+function nodeToRow(node, _columns) {
+  const cells = fromCellProperties(node.properties);
+  return {
+    id: node.id,
+    sortKey: node.properties.sortKey,
+    cells,
+    createdAt: node.createdAt,
+    createdBy: node.createdBy
+  };
+}
+
+// src/hooks/useDatabaseRow.ts
+import { getRow, updateCells as updateCells2, deleteRow as deleteRowOp2 } from "@xnetjs/data";
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback3, useRef as useRef3 } from "react";
+import * as Y2 from "yjs";
+function useDatabaseRow(rowId) {
+  const { store, isReady } = useNodeStore();
+  const [row, setRow] = useState3(null);
+  const [doc, setDoc] = useState3(null);
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  const optimisticRef = useRef3({});
+  const storeRef = useRef3(store);
+  storeRef.current = store;
+  useEffect3(() => {
+    if (!store || !isReady || !rowId) {
+      setRow(null);
+      setDoc(null);
+      setLoading(false);
+      return;
+    }
+    let mounted = true;
+    const load = async () => {
+      try {
+        setLoading(true);
+        const node = await getRow(store, rowId);
+        if (!mounted) return;
+        if (node) {
+          setRow({
+            id: node.id,
+            databaseId: node.properties.database,
+            sortKey: node.properties.sortKey,
+            cells: node.cells,
+            createdAt: node.createdAt,
+            createdBy: node.createdBy
+          });
+          const storedContent = await store.getDocumentContent(rowId);
+          if (storedContent && storedContent.length > 0) {
+            const ydoc = new Y2.Doc({ guid: rowId, gc: false });
+            Y2.applyUpdate(ydoc, storedContent);
+            setDoc(ydoc);
+          }
+        } else {
+          setRow(null);
+          setDoc(null);
+        }
+        setError(null);
+      } catch (err) {
+        if (!mounted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (mounted) setLoading(false);
+      }
+    };
+    load();
+    const unsubscribe = store.subscribeToNode(rowId, () => {
+      load();
+    });
+    return () => {
+      mounted = false;
+      unsubscribe();
+    };
+  }, [store, isReady, rowId]);
+  const handleUpdate = useCallback3(
+    async (values) => {
+      if (!storeRef.current) throw new Error("Store not ready");
+      optimisticRef.current = { ...optimisticRef.current, ...values };
+      setRow(
+        (prev) => prev ? {
+          ...prev,
+          cells: { ...prev.cells, ...values }
+        } : null
+      );
+      try {
+        await updateCells2(storeRef.current, rowId, values);
+        for (const key of Object.keys(values)) {
+          delete optimisticRef.current[key];
+        }
+      } catch (err) {
+        setRow((prev) => {
+          if (!prev) return null;
+          const reverted = { ...prev.cells };
+          for (const key of Object.keys(values)) {
+            delete reverted[key];
+          }
+          return { ...prev, cells: reverted };
+        });
+        throw err;
+      }
+    },
+    [rowId]
+  );
+  const handleDelete = useCallback3(async () => {
+    if (!storeRef.current) throw new Error("Store not ready");
+    await deleteRowOp2(storeRef.current, rowId);
+  }, [rowId]);
+  return {
+    row,
+    doc,
+    update: handleUpdate,
+    delete: handleDelete,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useCell.ts
+import { updateCell, cellKey } from "@xnetjs/data";
+import { useState as useState4, useEffect as useEffect4, useCallback as useCallback4, useRef as useRef4 } from "react";
+function useCell(rowId, columnId, options = {}) {
+  const { store, isReady } = useNodeStore();
+  const { debounce: debounceMs = 300 } = options;
+  const [value, setValue] = useState4(null);
+  const [saving, setSaving] = useState4(false);
+  const [error, setError] = useState4(null);
+  const debounceRef = useRef4();
+  const storeRef = useRef4(store);
+  storeRef.current = store;
+  useEffect4(() => {
+    if (!store || !isReady || !rowId) return;
+    store.get(rowId).then((node) => {
+      if (node) {
+        const key = cellKey(columnId);
+        setValue(node.properties[key] ?? null);
+      }
+    });
+  }, [store, isReady, rowId, columnId]);
+  useEffect4(() => {
+    if (!store || !rowId) return;
+    const unsubscribe = store.subscribeToNode(rowId, (event) => {
+      if (event.node) {
+        const key = cellKey(columnId);
+        setValue(event.node.properties[key] ?? null);
+      }
+    });
+    return unsubscribe;
+  }, [store, rowId, columnId]);
+  const handleSetValue = useCallback4(
+    (newValue) => {
+      setValue(newValue);
+      setError(null);
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+      debounceRef.current = setTimeout(async () => {
+        if (!storeRef.current) return;
+        try {
+          setSaving(true);
+          await updateCell(storeRef.current, rowId, columnId, newValue);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        } finally {
+          setSaving(false);
+        }
+      }, debounceMs);
+    },
+    [rowId, columnId, debounceMs]
+  );
+  const clear = useCallback4(() => {
+    handleSetValue(null);
+  }, [handleSetValue]);
+  useEffect4(() => {
+    return () => {
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+    };
+  }, []);
+  return {
+    value,
+    setValue: handleSetValue,
+    clear,
+    saving,
+    error
+  };
+}
+
+// src/hooks/useRelatedRows.ts
+import { fromCellProperties as fromCellProperties2 } from "@xnetjs/data";
+import { useState as useState5, useEffect as useEffect5, useMemo as useMemo2 } from "react";
+function useRelatedRows(rowIds) {
+  const { store, isReady } = useNodeStore();
+  const [rows, setRows] = useState5([]);
+  const [loading, setLoading] = useState5(true);
+  const [error, setError] = useState5(null);
+  const idsKey = useMemo2(() => rowIds.join(","), [rowIds]);
+  useEffect5(() => {
+    if (!store || !isReady) return;
+    if (rowIds.length === 0) {
+      setRows([]);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const fetchRows = async () => {
+      try {
+        setLoading(true);
+        const results = await Promise.all(
+          rowIds.map(async (id) => {
+            try {
+              return await store.get(id);
+            } catch {
+              return null;
+            }
+          })
+        );
+        if (!cancelled) {
+          const loadedRows = results.filter((node) => node !== null).map((node) => nodeToRow2(node));
+          setRows(loadedRows);
+          setError(null);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    };
+    fetchRows();
+    return () => {
+      cancelled = true;
+    };
+  }, [store, isReady, idsKey, rowIds]);
+  return { rows, loading, error };
+}
+function nodeToRow2(node) {
+  const cells = fromCellProperties2(node.properties);
+  return {
+    id: node.id,
+    sortKey: node.properties.sortKey ?? "",
+    cells,
+    createdAt: node.createdAt,
+    createdBy: node.createdBy
+  };
+}
+
+// src/hooks/useReverseRelations.ts
+import { fromCellProperties as fromCellProperties3, getColumns as getColumns2, isDatabaseDocInitialized as isDatabaseDocInitialized2 } from "@xnetjs/data";
+import { useState as useState6, useEffect as useEffect6 } from "react";
+import * as Y3 from "yjs";
+function useReverseRelations(rowId, databaseId) {
+  const { store, isReady } = useNodeStore();
+  const [relations, setRelations] = useState6([]);
+  const [loading, setLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const [refetchKey, setRefetchKey] = useState6(0);
+  useEffect6(() => {
+    if (!store || !isReady || !rowId || !databaseId) {
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const findReverseRelations = async () => {
+      try {
+        setLoading(true);
+        const allDatabases = await store.list({
+          schemaId: "xnet://xnet.fyi/Database"
+        });
+        const reverseRelations = [];
+        for (const db of allDatabases) {
+          if (cancelled) break;
+          try {
+            const docContent = await store.getDocumentContent(db.id);
+            if (!docContent || docContent.length === 0) continue;
+            const doc = new Y3.Doc({ guid: db.id });
+            Y3.applyUpdate(doc, docContent);
+            if (!isDatabaseDocInitialized2(doc)) {
+              doc.destroy();
+              continue;
+            }
+            const columns = getColumns2(doc);
+            const relationColumns = columns.filter(
+              (col) => col.type === "relation" && col.config?.targetDatabase === databaseId
+            );
+            doc.destroy();
+            if (relationColumns.length === 0) continue;
+            for (const col of relationColumns) {
+              if (cancelled) break;
+              const allRows = await store.list({
+                schemaId: "xnet://xnet.fyi/DatabaseRow"
+              });
+              const rows = allRows.filter((row) => row.properties.database === db.id);
+              for (const node of rows) {
+                const cellKey2 = `cell_${col.id}`;
+                const cellValue = node.properties[cellKey2];
+                if (Array.isArray(cellValue) && cellValue.includes(rowId)) {
+                  reverseRelations.push({
+                    row: nodeToRow3(node),
+                    column: col,
+                    sourceDatabaseId: db.id,
+                    sourceDatabaseTitle: db.properties.title ?? "Untitled"
+                  });
+                }
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+        if (!cancelled) {
+          setRelations(reverseRelations);
+          setError(null);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    };
+    findReverseRelations();
+    return () => {
+      cancelled = true;
+    };
+  }, [store, isReady, rowId, databaseId, refetchKey]);
+  const refetch = () => setRefetchKey((k) => k + 1);
+  return { relations, loading, error, refetch };
+}
+function nodeToRow3(node) {
+  const cells = fromCellProperties3(node.properties);
+  return {
+    id: node.id,
+    sortKey: node.properties.sortKey ?? "",
+    cells,
+    createdAt: node.createdAt,
+    createdBy: node.createdBy
+  };
+}
+
+// src/hooks/useDatabaseSchema.ts
+import { extractSchemaFromDoc } from "@xnetjs/data";
+import { useState as useState7, useEffect as useEffect7, useMemo as useMemo3, useRef as useRef5 } from "react";
+import * as Y4 from "yjs";
+function useDatabaseSchema(databaseId) {
+  const { store, isReady } = useNodeStore();
+  const [schema, setSchema] = useState7(null);
+  const [metadata, setMetadata] = useState7(null);
+  const [schemaIRI, setSchemaIRI] = useState7(null);
+  const [loading, setLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  const [refreshKey, setRefreshKey] = useState7(0);
+  const docRef = useRef5(null);
+  useEffect7(() => {
+    if (!store || !isReady || !databaseId) {
+      setSchema(null);
+      setMetadata(null);
+      setSchemaIRI(null);
+      setLoading(false);
+      return;
+    }
+    let mounted = true;
+    const loadSchema = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const ydoc = new Y4.Doc({ guid: databaseId, gc: false });
+        const storedContent = await store.getDocumentContent(databaseId);
+        if (storedContent && storedContent.length > 0) {
+          Y4.applyUpdate(ydoc, storedContent);
+        }
+        if (!mounted) {
+          ydoc.destroy();
+          return;
+        }
+        docRef.current = ydoc;
+        const extractedSchema = extractSchemaFromDoc(databaseId, ydoc);
+        if (!extractedSchema) {
+          setSchema(null);
+          setMetadata(null);
+          setSchemaIRI(null);
+          return;
+        }
+        const dataMap = ydoc.getMap("data");
+        const meta = dataMap.get("schema");
+        if (!mounted) return;
+        setSchema(extractedSchema);
+        setMetadata(meta ?? null);
+        setSchemaIRI(extractedSchema["@id"]);
+      } catch (err) {
+        if (!mounted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (mounted) setLoading(false);
+      }
+    };
+    void loadSchema();
+    return () => {
+      mounted = false;
+      if (docRef.current) {
+        docRef.current.destroy();
+        docRef.current = null;
+      }
+    };
+  }, [store, isReady, databaseId, refreshKey]);
+  useEffect7(() => {
+    const doc = docRef.current;
+    if (!doc || !databaseId) return;
+    const dataMap = doc.getMap("data");
+    const handleSchemaChange = () => {
+      const meta = dataMap.get("schema");
+      if (!meta) return;
+      const extractedSchema = extractSchemaFromDoc(databaseId, doc);
+      if (extractedSchema) {
+        setSchema(extractedSchema);
+        setMetadata(meta);
+        setSchemaIRI(extractedSchema["@id"]);
+      }
+    };
+    dataMap.observe(handleSchemaChange);
+    return () => {
+      dataMap.unobserve(handleSchemaChange);
+    };
+  }, [databaseId, schema]);
+  const refresh = useMemo3(
+    () => () => {
+      setRefreshKey((k) => k + 1);
+    },
+    []
+  );
+  return useMemo3(
+    () => ({
+      schema,
+      metadata,
+      schemaIRI,
+      loading,
+      error,
+      refresh
+    }),
+    [schema, metadata, schemaIRI, loading, error, refresh]
+  );
+}
+
+export {
+  useDatabaseDoc,
+  useDatabase,
+  useDatabaseRow,
+  useCell,
+  useRelatedRows,
+  useReverseRelations,
+  useDatabaseSchema
+};