@adminide-stack/yantra-mobile 12.0.141-alpha.1 → 12.0.142-alpha.0

package/lib/features/notion/database/useNotionDatabase.js

@@ -0,0 +1,617 @@
+import {useState,useRef,useCallback,useEffect,useMemo}from'react';import {useApolloClient,useQuery,useMutation}from'@apollo/client/index.js';import {NATIVE_NOTION_BLOCK,NATIVE_NOTION_DATABASE_VIEWS,NATIVE_NOTION_UPDATE_BLOCK,NATIVE_NOTION_CREATE_BLOCK,NATIVE_NOTION_DELETE_BLOCK,NATIVE_NOTION_RESTORE_BLOCK,NATIVE_NOTION_CREATE_DATABASE_VIEW,NATIVE_NOTION_UPDATE_DATABASE_VIEW,NATIVE_NOTION_DELETE_DATABASE_VIEW,NATIVE_NOTION_QUERY_DATABASE}from'../notionDocuments.js';import {serverErrorText}from'../notionPageActions.js';import {extraColumnFields,parseViewSorts}from'./databaseView.js';import {parseViewFilter,serializeViewFilter}from'./databaseFilter.js';import {uniqueIdProperties,maxUniqueId}from'./uniqueId.js';import {DEFAULT_VIEW_ID,parseViewSettings,viewLayout}from'./databaseViews.js';var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const PAGE_SIZE = 200;
+const ROWS_CREATION_ORDER = [{
+  timestamp: "createdTime",
+  direction: "ascending"
+}];
+const FILTER_SAVE_DELAY = 600;
+function columnsFromSchema(schema) {
+  if (!schema) return [];
+  return Object.entries(schema).map(([name, def]) => __spreadValues({
+    name,
+    type: (def == null ? void 0 : def.type) || "text",
+    options: (def == null ? void 0 : def.options) || [],
+    width: (def == null ? void 0 : def.type) === "title" ? 220 : void 0,
+    expression: typeof (def == null ? void 0 : def.expression) === "string" ? def.expression : void 0,
+    databaseId: typeof (def == null ? void 0 : def.databaseId) === "string" ? def.databaseId : void 0
+  }, extraColumnFields(def)));
+}
+function rowFromBlock(b) {
+  var _a, _b, _c, _d;
+  return {
+    id: b.id,
+    type: b.type,
+    properties: b.properties || {},
+    createdTime: (_a = b.createdTime) != null ? _a : void 0,
+    lastEditedTime: (_b = b.lastEditedTime) != null ? _b : void 0,
+    createdBy: (_c = b.createdBy) != null ? _c : void 0,
+    lastEditedBy: (_d = b.lastEditedBy) != null ? _d : void 0
+  };
+}
+function viewFromRaw(v) {
+  var _a, _b;
+  return {
+    id: v.id,
+    name: v.name || "Default",
+    type: viewLayout(v.type),
+    sorts: parseViewSorts(v.sorts),
+    conditions: parseViewFilter(v.filter),
+    groupBy: (_a = v.groupBy) != null ? _a : null,
+    properties: (_b = v.properties) != null ? _b : void 0,
+    settings: parseViewSettings(v.settings)
+  };
+}
+const IMPLICIT_TABLE_VIEW = {
+  id: DEFAULT_VIEW_ID,
+  name: "Table",
+  type: "table",
+  sorts: [],
+  conditions: [],
+  groupBy: null,
+  properties: void 0,
+  settings: {}
+};
+function databaseTitle(properties) {
+  const t = properties == null ? void 0 : properties.title;
+  if (typeof t === "string") return t;
+  if (Array.isArray(t)) return t.map((rt) => {
+    var _a, _b, _c;
+    return (_c = (_b = rt == null ? void 0 : rt.plainText) != null ? _b : (_a = rt == null ? void 0 : rt.text) == null ? void 0 : _a.content) != null ? _c : "";
+  }).join("");
+  return "";
+}
+function viewInputOf(change) {
+  const out = {};
+  if (change.name !== void 0) out.name = change.name;
+  if (change.type !== void 0) out.type = change.type;
+  if (change.sorts !== void 0) out.sorts = change.sorts;
+  if (change.conditions !== void 0) out.filter = serializeViewFilter(change.conditions);
+  if (change.groupBy !== void 0) out.groupBy = change.groupBy;
+  if (change.properties !== void 0) out.properties = change.properties;
+  if (change.settings !== void 0) out.settings = change.settings;
+  return out;
+}
+function useNotionDatabase(blockId) {
+  var _a, _b, _c, _d, _e;
+  const client = useApolloClient();
+  const block = useQuery(NATIVE_NOTION_BLOCK, {
+    variables: {
+      input: {
+        blockId
+      }
+    },
+    skip: !blockId,
+    fetchPolicy: "cache-and-network"
+  });
+  const viewsQuery = useQuery(NATIVE_NOTION_DATABASE_VIEWS, {
+    variables: {
+      databaseId: blockId
+    },
+    skip: !blockId,
+    fetchPolicy: "cache-and-network"
+  });
+  const [updateBlock] = useMutation(NATIVE_NOTION_UPDATE_BLOCK);
+  const [createBlock] = useMutation(NATIVE_NOTION_CREATE_BLOCK);
+  const [deleteBlock] = useMutation(NATIVE_NOTION_DELETE_BLOCK);
+  const [restoreBlock] = useMutation(NATIVE_NOTION_RESTORE_BLOCK);
+  const [createView] = useMutation(NATIVE_NOTION_CREATE_DATABASE_VIEW);
+  const [updateView] = useMutation(NATIVE_NOTION_UPDATE_DATABASE_VIEW);
+  const [deleteView] = useMutation(NATIVE_NOTION_DELETE_DATABASE_VIEW);
+  const [rows, setRows] = useState([]);
+  const [cursor, setCursor] = useState(null);
+  const [hasMore, setHasMore] = useState(false);
+  const [totalCount, setTotalCount] = useState(null);
+  const [rowsLoading, setRowsLoading] = useState(true);
+  const [rowsError, setRowsError] = useState(null);
+  const loadSeq = useRef(0);
+  const rowsCountRef = useRef(0);
+  rowsCountRef.current = rows.length;
+  const fetchPage = useCallback(async (startCursor) => {
+    var _a2, _b2, _c2;
+    const res = await client.query({
+      query: NATIVE_NOTION_QUERY_DATABASE,
+      variables: {
+        input: __spreadValues({
+          databaseId: blockId,
+          pageSize: PAGE_SIZE,
+          sorts: ROWS_CREATION_ORDER
+        }, startCursor ? {
+          startCursor
+        } : {})
+      },
+      fetchPolicy: "network-only"
+    });
+    const page = (_a2 = res.data) == null ? void 0 : _a2.queryDatabase;
+    return {
+      rows: ((_b2 = page == null ? void 0 : page.results) != null ? _b2 : []).filter((b) => !!(b == null ? void 0 : b.id)).map(rowFromBlock),
+      cursor: (_c2 = page == null ? void 0 : page.nextCursor) != null ? _c2 : null,
+      hasMore: Boolean(page == null ? void 0 : page.hasMore),
+      total: typeof (page == null ? void 0 : page.totalCount) === "number" ? page.totalCount : null
+    };
+  }, [blockId, client]);
+  const reloadRows = useCallback(async () => {
+    if (!blockId) return;
+    const seq = ++loadSeq.current;
+    setRowsError(null);
+    try {
+      const want = Math.max(rowsCountRef.current, 1);
+      let page = await fetchPage(null);
+      let all = page.rows;
+      while (page.hasMore && page.cursor && all.length < want) {
+        page = await fetchPage(page.cursor);
+        all = all.concat(page.rows);
+      }
+      if (seq !== loadSeq.current) return;
+      setRows(all);
+      setCursor(page.cursor);
+      setHasMore(page.hasMore);
+      setTotalCount(page.total);
+    } catch (err) {
+      if (seq === loadSeq.current) setRowsError(serverErrorText(err));
+    } finally {
+      if (seq === loadSeq.current) setRowsLoading(false);
+    }
+  }, [blockId, fetchPage]);
+  useEffect(() => {
+    setRowsLoading(true);
+    rowsCountRef.current = 0;
+    reloadRows();
+  }, [reloadRows]);
+  const [loadingMore, setLoadingMore] = useState(false);
+  const loadMore = useCallback(async () => {
+    if (!hasMore || !cursor || loadingMore) return;
+    setLoadingMore(true);
+    try {
+      const page = await fetchPage(cursor);
+      setRows((prev) => {
+        const seen = new Set(prev.map((r) => r.id));
+        return prev.concat(page.rows.filter((r) => !seen.has(r.id)));
+      });
+      setCursor(page.cursor);
+      setHasMore(page.hasMore);
+    } catch (err) {
+      setRowsError(serverErrorText(err));
+    } finally {
+      setLoadingMore(false);
+    }
+  }, [cursor, fetchPage, hasMore, loadingMore]);
+  const loadAll = useCallback(async () => {
+    let all = rows;
+    let next = cursor;
+    let more = hasMore;
+    for (let i = 0; more && next && i < 100; i += 1) {
+      const page = await fetchPage(next);
+      const seen = new Set(all.map((r) => r.id));
+      all = all.concat(page.rows.filter((r) => !seen.has(r.id)));
+      next = page.cursor;
+      more = page.hasMore;
+    }
+    setRows(all);
+    setCursor(next);
+    setHasMore(more);
+    return all;
+  }, [cursor, fetchPage, hasMore, rows]);
+  const dbBlock = (_b = (_a = block.data) == null ? void 0 : _a.getBlock) != null ? _b : null;
+  const [schemaOverride, setSchemaOverride] = useState(null);
+  const serverSchema = useMemo(() => {
+    var _a2, _b2;
+    return (_b2 = (_a2 = dbBlock == null ? void 0 : dbBlock.properties) == null ? void 0 : _a2.schema) != null ? _b2 : {};
+  }, [dbBlock]);
+  const schema = schemaOverride != null ? schemaOverride : serverSchema;
+  const columns = useMemo(() => columnsFromSchema(schema), [schema]);
+  const title = databaseTitle(dbBlock == null ? void 0 : dbBlock.properties);
+  const icon = (_d = (_c = dbBlock == null ? void 0 : dbBlock.properties) == null ? void 0 : _c.icon) != null ? _d : null;
+  const saveSchema = useCallback(async (next) => {
+    setSchemaOverride(next);
+    try {
+      await updateBlock({
+        variables: {
+          input: {
+            id: blockId,
+            properties: {
+              schema: next
+            }
+          }
+        },
+        errorPolicy: "none"
+      });
+      return null;
+    } catch (err) {
+      setSchemaOverride(null);
+      return serverErrorText(err);
+    }
+  }, [blockId, updateBlock]);
+  useEffect(() => {
+    if (schemaOverride && JSON.stringify(serverSchema) === JSON.stringify(schemaOverride)) {
+      setSchemaOverride(null);
+    }
+  }, [schemaOverride, serverSchema]);
+  const renameDatabase = useCallback(async (next) => {
+    try {
+      await updateBlock({
+        variables: {
+          input: {
+            id: blockId,
+            properties: {
+              title: [{
+                text: {
+                  content: next
+                },
+                plainText: next
+              }]
+            }
+          }
+        },
+        errorPolicy: "none"
+      });
+      return null;
+    } catch (err) {
+      return serverErrorText(err);
+    }
+  }, [blockId, updateBlock]);
+  const updateCell = useCallback(async (rowId, property, value) => {
+    let previous;
+    setRows((prev) => prev.map((r) => {
+      if (r.id !== rowId) return r;
+      previous = r.properties[property];
+      return __spreadProps(__spreadValues({}, r), {
+        properties: __spreadProps(__spreadValues({}, r.properties), {
+          [property]: value
+        })
+      });
+    }));
+    try {
+      await updateBlock({
+        variables: {
+          input: {
+            id: rowId,
+            properties: {
+              [property]: value
+            }
+          }
+        },
+        errorPolicy: "none"
+      });
+      return null;
+    } catch (err) {
+      setRows((prev) => prev.map((r) => r.id === rowId ? __spreadProps(__spreadValues({}, r), {
+        properties: __spreadProps(__spreadValues({}, r.properties), {
+          [property]: previous
+        })
+      }) : r));
+      return serverErrorText(err);
+    }
+  }, [updateBlock]);
+  const patchRow = useCallback(async (rowId, patch) => {
+    let previous = null;
+    setRows((prev) => prev.map((r) => {
+      if (r.id !== rowId) return r;
+      previous = r.properties;
+      return __spreadProps(__spreadValues({}, r), {
+        properties: __spreadValues(__spreadValues({}, r.properties), patch)
+      });
+    }));
+    try {
+      await updateBlock({
+        variables: {
+          input: {
+            id: rowId,
+            properties: patch
+          }
+        },
+        errorPolicy: "none"
+      });
+      return null;
+    } catch (err) {
+      const before = previous;
+      if (before) setRows((prev) => prev.map((r) => r.id === rowId ? __spreadProps(__spreadValues({}, r), {
+        properties: before
+      }) : r));
+      return serverErrorText(err);
+    }
+  }, [updateBlock]);
+  const patchRowsLocally = useCallback((fn) => {
+    setRows((prev) => prev.map(fn));
+  }, []);
+  const lastUniqueRef = useRef({});
+  const takeUniqueIds = useCallback(async () => {
+    var _a2;
+    const props = uniqueIdProperties(schema);
+    if (!props.length) return {};
+    const all = hasMore ? await loadAll() : rows;
+    const out = {};
+    for (const prop of props) {
+      const next = Math.max(maxUniqueId(all, prop), (_a2 = lastUniqueRef.current[prop]) != null ? _a2 : 0) + 1;
+      out[prop] = next;
+      lastUniqueRef.current[prop] = next;
+    }
+    return out;
+  }, [hasMore, loadAll, rows, schema]);
+  const addRow = useCallback(async (initial = {}) => {
+    var _a2;
+    try {
+      const ids = await takeUniqueIds();
+      const res = await createBlock({
+        variables: {
+          input: {
+            type: "database_row",
+            parent: {
+              type: "database",
+              id: blockId
+            },
+            properties: __spreadValues(__spreadValues({
+              title: [{
+                text: {
+                  content: ""
+                },
+                plainText: ""
+              }]
+            }, initial), ids)
+          }
+        },
+        errorPolicy: "none"
+      });
+      const created = (_a2 = res.data) == null ? void 0 : _a2.createBlock;
+      if (created == null ? void 0 : created.id) {
+        setRows((prev) => prev.concat(rowFromBlock(created)));
+        setTotalCount((n) => n == null ? n : n + 1);
+      }
+      return {
+        id: created == null ? void 0 : created.id
+      };
+    } catch (err) {
+      return {
+        error: serverErrorText(err)
+      };
+    }
+  }, [blockId, createBlock, takeUniqueIds]);
+  const deleteRows = useCallback(async (ids) => {
+    const removed = rows.filter((r) => ids.includes(r.id));
+    setRows((prev) => prev.filter((r) => !ids.includes(r.id)));
+    const results = await Promise.allSettled(ids.map((id) => deleteBlock({
+      variables: {
+        blockId: id
+      },
+      errorPolicy: "none"
+    })));
+    const failed = ids.filter((_, i) => results[i].status === "rejected");
+    if (failed.length) {
+      setRows((prev) => prev.concat(removed.filter((r) => failed.includes(r.id))));
+    }
+    const deleted = ids.filter((id) => !failed.includes(id));
+    setTotalCount((n) => n == null ? n : Math.max(0, n - deleted.length));
+    const rejection = results.find((r) => r.status === "rejected");
+    return {
+      deleted,
+      error: rejection ? serverErrorText(rejection.reason) : null
+    };
+  }, [deleteBlock, rows]);
+  const restoreRows = useCallback(async (ids) => {
+    await Promise.allSettled(ids.map((id) => restoreBlock({
+      variables: {
+        blockId: id
+      }
+    })));
+    await reloadRows();
+  }, [reloadRows, restoreBlock]);
+  const serverViews = useMemo(() => {
+    var _a2, _b2;
+    return ((_b2 = (_a2 = viewsQuery.data) == null ? void 0 : _a2.getDatabaseViews) != null ? _b2 : []).filter((v) => !!(v == null ? void 0 : v.id)).map(viewFromRaw);
+  }, [viewsQuery.data]);
+  const [overrides, setOverrides] = useState({});
+  const views = useMemo(() => {
+    const base = serverViews.length ? serverViews : [IMPLICIT_TABLE_VIEW];
+    return base.map((v) => {
+      var _a2;
+      const o = overrides[v.id];
+      return o ? __spreadProps(__spreadValues(__spreadValues({}, v), o), {
+        settings: (_a2 = o.settings) != null ? _a2 : v.settings
+      }) : v;
+    });
+  }, [overrides, serverViews]);
+  const [activeViewId, setActiveViewId] = useState(null);
+  const activeView = (_e = views.find((v) => v.id === activeViewId)) != null ? _e : views[0];
+  const filterTimers = useRef({});
+  useEffect(() => () => {
+    Object.values(filterTimers.current).forEach(clearTimeout);
+  }, []);
+  const persistView = useCallback(async (viewId, change) => {
+    try {
+      await updateView({
+        variables: {
+          input: __spreadValues({
+            databaseId: blockId,
+            viewId
+          }, viewInputOf(change))
+        },
+        errorPolicy: "none"
+      });
+      return null;
+    } catch (err) {
+      return serverErrorText(err);
+    }
+  }, [blockId, updateView]);
+  const changeView = useCallback((viewId, change) => {
+    setOverrides((prev) => __spreadProps(__spreadValues({}, prev), {
+      [viewId]: __spreadValues(__spreadValues({}, prev[viewId]), change)
+    }));
+    if (viewId === DEFAULT_VIEW_ID) return Promise.resolve(null);
+    if (change.conditions && Object.keys(change).length === 1) {
+      clearTimeout(filterTimers.current[viewId]);
+      return new Promise((resolve) => {
+        filterTimers.current[viewId] = setTimeout(() => persistView(viewId, change).then(resolve), FILTER_SAVE_DELAY);
+      });
+    }
+    return persistView(viewId, change);
+  }, [persistView]);
+  const addView = useCallback(async (draft) => {
+    var _a2, _b2;
+    try {
+      if (!serverViews.length) {
+        const implicit = views[0];
+        await createView({
+          variables: {
+            input: __spreadValues({
+              databaseId: blockId,
+              name: implicit.name,
+              type: "table"
+            }, viewInputOf({
+              sorts: implicit.sorts,
+              conditions: implicit.conditions,
+              properties: implicit.properties,
+              settings: implicit.settings
+            }))
+          },
+          errorPolicy: "none"
+        });
+      }
+      const res = await createView({
+        variables: {
+          input: __spreadValues({
+            databaseId: blockId,
+            name: draft.name,
+            type: draft.type
+          }, draft.groupBy ? {
+            groupBy: draft.groupBy
+          } : {})
+        },
+        errorPolicy: "none"
+      });
+      await viewsQuery.refetch();
+      const id = (_b2 = (_a2 = res.data) == null ? void 0 : _a2.createDatabaseView) == null ? void 0 : _b2.id;
+      if (id) setActiveViewId(id);
+      return null;
+    } catch (err) {
+      return serverErrorText(err);
+    }
+  }, [blockId, createView, serverViews.length, views, viewsQuery]);
+  const duplicateView = useCallback(async (view, name) => {
+    var _a2, _b2;
+    try {
+      const res = await createView({
+        variables: {
+          input: __spreadValues({
+            databaseId: blockId,
+            name,
+            type: view.type
+          }, viewInputOf({
+            sorts: view.sorts,
+            conditions: view.conditions,
+            groupBy: view.groupBy,
+            properties: view.properties,
+            settings: view.settings
+          }))
+        },
+        errorPolicy: "none"
+      });
+      await viewsQuery.refetch();
+      const id = (_b2 = (_a2 = res.data) == null ? void 0 : _a2.createDatabaseView) == null ? void 0 : _b2.id;
+      if (id) setActiveViewId(id);
+      return null;
+    } catch (err) {
+      return serverErrorText(err);
+    }
+  }, [blockId, createView, viewsQuery]);
+  const removeView = useCallback(async (viewId) => {
+    if (viewId === DEFAULT_VIEW_ID) return null;
+    try {
+      await deleteView({
+        variables: {
+          databaseId: blockId,
+          viewId
+        },
+        errorPolicy: "none"
+      });
+      if (activeViewId === viewId) setActiveViewId(null);
+      await viewsQuery.refetch();
+      return null;
+    } catch (err) {
+      return serverErrorText(err);
+    }
+  }, [activeViewId, blockId, deleteView, viewsQuery]);
+  const refresh = useCallback(async () => {
+    await Promise.allSettled([block.refetch(), viewsQuery.refetch(), reloadRows()]);
+  }, [block, reloadRows, viewsQuery]);
+  return {
+    block: dbBlock,
+    title,
+    icon,
+    schema,
+    columns,
+    rows,
+    totalCount,
+    hasMore,
+    loadMore,
+    loadAll,
+    loadingMore,
+    loading: block.loading && !dbBlock || rowsLoading,
+    error: block.error ? serverErrorText(block.error) : rowsError,
+    views,
+    hasSavedViews: serverViews.length > 0,
+    activeView,
+    setActiveViewId,
+    changeView,
+    addView,
+    duplicateView,
+    removeView,
+    saveSchema,
+    renameDatabase,
+    updateCell,
+    patchRow,
+    patchRowsLocally,
+    addRow,
+    deleteRows,
+    restoreRows,
+    reloadRows,
+    refresh
+  };
+}
+const NEW_DATABASE_PROPERTIES = {
+  title: [{
+    type: "text",
+    text: {
+      content: "Untitled database"
+    },
+    plainText: "Untitled database",
+    annotations: {}
+  }],
+  schema: {
+    title: {
+      type: "title"
+    },
+    Status: {
+      type: "select",
+      options: [{
+        name: "To Do",
+        color: "gray"
+      }, {
+        name: "In Progress",
+        color: "blue"
+      }, {
+        name: "Done",
+        color: "green"
+      }]
+    },
+    Date: {
+      type: "date"
+    }
+  }
+};export{IMPLICIT_TABLE_VIEW,NEW_DATABASE_PROPERTIES,columnsFromSchema,databaseTitle,rowFromBlock,useNotionDatabase,viewFromRaw};//# sourceMappingURL=useNotionDatabase.js.map