nolo-cli 0.1.13 → 0.1.14

package/database/hooks/useUserData.ts

@@ -0,0 +1,489 @@
+// database/hooks/useUserData.ts
+import { useEffect, useState, useCallback, useRef, useMemo } from "react";
+import {
+  selectRuntimeRemoteServers,
+  selectRuntimeSnapshot,
+} from "app/stateViews/runtime";
+import { toast } from "app/utils/toast";
+
+import { DataType } from "create/types";
+import { useAppDispatch, useAppSelector } from "app/store";
+import {
+  getUserDataItemTimestamp,
+  mergeAndDedupUserData,
+} from "../userDataMerge";
+import { isTombstoneRecord } from "../tombstones";
+import { getUserDataLoadDecision } from "../userDataLoadDecision";
+
+import { fetchUserDataThunk } from "../actions/fetchUserData";
+import { cacheMergedUserDataThunk } from "../actions/cacheMergedUserData";
+import { noloQueryRequest } from "../client/queryRequest";
+
+interface BaseItem {
+  id: string;
+  type: DataType;
+  updatedAt?: string | number;
+  created?: string | number;
+  userId: string;
+  [key: string]: any;
+}
+
+interface FetchState {
+  loading: boolean;
+  error: Error | null;
+  data: BaseItem[];
+}
+
+interface UseUserDataReturn extends FetchState {
+  reload: () => Promise<void>;
+  clearCache: () => void;
+}
+
+interface UseUserDataOptions {
+  allowPartialData?: boolean;
+  partialDataStrategy?: PartialDataStrategy;
+}
+
+export type PartialDataStrategy = "always" | "never" | "hydrated-cache";
+
+const shouldDebugUserData =
+  typeof window !== "undefined" &&
+  !!window.location &&
+  typeof window.location.hostname === "string" &&
+  /^(localhost|127\.0\.0\.1)$/.test(window.location.hostname);
+
+const summarizeItemsByType = (items: BaseItem[]): Record<string, number> => {
+  return items.reduce<Record<string, number>>((acc, item) => {
+    const key =
+      (typeof item.type === "string" && item.type.trim()) ||
+      (typeof item.appKey === "string" && item.appKey.startsWith("app-") ? DataType.APP : "unknown");
+    acc[key] = (acc[key] ?? 0) + 1;
+    return acc;
+  }, {});
+};
+
+const summarizeAppKeys = (items: BaseItem[]): string[] => {
+  return items
+    .filter((item) => {
+      const candidates = [item.dbKey, item.contentKey, item.appKey];
+      return candidates.some(
+        (candidate) => typeof candidate === "string" && candidate.startsWith("app-")
+      );
+    })
+    .slice(0, 12)
+    .map(
+      (item) =>
+        item.dbKey ??
+        item.contentKey ??
+        item.appKey ??
+        item.appId ??
+        item.id
+    )
+    .filter((candidate): candidate is string => typeof candidate === "string");
+};
+
+const debugUserData = (
+  phase: string,
+  payload: Record<string, unknown>
+) => {
+  if (!shouldDebugUserData) return;
+  console.debug(`[useUserData] ${phase}`, payload);
+};
+
+export const buildUserDataHydrationKey = ({
+  userId,
+  typesKey,
+  serverKey,
+}: {
+  userId: string;
+  typesKey: string;
+  serverKey: string;
+}): string => `nolo-user-data-hydrated:${userId}:${typesKey}:${serverKey}`;
+
+const readHydratedUserDataCacheFlag = (hydrationKey: string): boolean => {
+  if (typeof window === "undefined" || !hydrationKey) return false;
+  try {
+    return window.localStorage.getItem(hydrationKey) === "1";
+  } catch {
+    return false;
+  }
+};
+
+const markHydratedUserDataCacheFlag = (hydrationKey: string) => {
+  if (typeof window === "undefined" || !hydrationKey) return;
+  try {
+    window.localStorage.setItem(hydrationKey, "1");
+  } catch {
+    // Best-effort local UI optimization only.
+  }
+};
+
+export const shouldUsePartialLocalData = ({
+  strategy,
+  hasHydratedCache,
+  localItemCount,
+}: {
+  strategy: PartialDataStrategy;
+  hasHydratedCache: boolean;
+  localItemCount: number;
+}): boolean => {
+  if (strategy === "never") return false;
+  if (strategy === "hydrated-cache") {
+    return hasHydratedCache && localItemCount > 0;
+  }
+  return true;
+};
+
+const withServerOrigin = (items: BaseItem[], serverOrigin: string) =>
+  items.map((item) => ({
+    ...item,
+    serverOrigin,
+  }));
+
+const extractRemoteItems = async (
+  response: Response,
+  serverOrigin: string
+): Promise<BaseItem[]> => {
+  const data = await response.json();
+  const items = Array.isArray(data?.data?.data) ? data.data.data : [];
+  return withServerOrigin(items as BaseItem[], serverOrigin);
+};
+
+export const getItemTimestamp = (dataItem: BaseItem): number =>
+  getUserDataItemTimestamp(dataItem);
+
+export const mergeAndDedupData = (
+  localData: BaseItem[],
+  remoteResults: any[],
+  options: { includeDeleted?: boolean } = {}
+): BaseItem[] =>
+  mergeAndDedupUserData(localData, remoteResults, options) as BaseItem[];
+
+const loadRemoteUserData = async ({
+  serverOrigin,
+  queryUserId,
+  types,
+  limit,
+}: {
+  serverOrigin: string;
+  queryUserId: string;
+  types: DataType[];
+  limit: number;
+}) => {
+  try {
+    const batchResponse = await noloQueryRequest({
+      server: serverOrigin,
+      queryUserId,
+      options: {
+        limit,
+        condition: { type: types, includeDeleted: true },
+      },
+    });
+
+    if (batchResponse.ok) {
+      return { data: { data: await extractRemoteItems(batchResponse, serverOrigin) } };
+    }
+
+    // 多服务器环境里远端可能还是旧版本，只接受单个 type。
+    // 这里回退到 legacy per-type 查询，保证正确性优先于省请求。
+    if (![400, 404].includes(batchResponse.status)) {
+      return { data: { data: [] } };
+    }
+
+    const legacyResponses = await Promise.all(
+      types.map(async (type) => {
+        try {
+          const response = await noloQueryRequest({
+            server: serverOrigin,
+            queryUserId,
+            options: {
+              limit,
+              condition: { type, includeDeleted: true },
+            },
+          });
+          if (!response.ok) return [];
+          return extractRemoteItems(response, serverOrigin);
+        } catch {
+          return [];
+        }
+      })
+    );
+
+    return { data: { data: legacyResponses.flat() } };
+  } catch {
+    return { data: { data: [] } };
+  }
+};
+
+export function useUserData(
+  types: DataType | DataType[],
+  userId: string,
+  limit: number,
+  options: UseUserDataOptions = {}
+): UseUserDataReturn {
+  const dispatch = useAppDispatch();
+  const { currentUserId, currentToken } = useAppSelector(selectRuntimeSnapshot);
+  const partialDataStrategy = useMemo<PartialDataStrategy>(() => {
+    if (options.partialDataStrategy) return options.partialDataStrategy;
+    return options.allowPartialData ?? true ? "always" : "never";
+  }, [options.allowPartialData, options.partialDataStrategy]);
+
+  const [{ loading, error, data }, setState] = useState<FetchState>({
+    loading: true,
+    error: null,
+    data: [],
+  });
+
+  const typeArray = useMemo(
+    () => (Array.isArray(types) ? types : [types]),
+    [types]
+  );
+  const typesKey = useMemo(() => typeArray.join(","), [typeArray]);
+
+  const loadingRef = useRef(false);
+  const pendingRefreshRef = useRef(false);
+  const previousParamsRef = useRef<{
+    typesKey: string;
+    userId: string;
+    serverKey: string;
+  }>({
+    typesKey: "",
+    userId: "",
+    serverKey: "",
+  });
+
+  const effectiveUserId = useMemo(() => {
+    if (userId === "local" && currentToken && currentUserId) {
+      return currentUserId;
+    }
+    return userId;
+  }, [userId, currentToken, currentUserId]);
+  const allServers = useAppSelector(selectRuntimeRemoteServers);
+  const serverKey = useMemo(() => allServers.join(","), [allServers]);
+  const hydrationKey = useMemo(() => {
+    if (!effectiveUserId || effectiveUserId === "undefined") return "";
+    return buildUserDataHydrationKey({
+      userId: effectiveUserId,
+      typesKey,
+      serverKey,
+    });
+  }, [effectiveUserId, serverKey, typesKey]);
+
+  const clearCache = useCallback(() => {
+    previousParamsRef.current = { typesKey: "", userId: "", serverKey: "" };
+  }, []);
+
+  const loadData = useCallback(async (options?: { forceRefresh?: boolean }) => {
+    if (!effectiveUserId || effectiveUserId === "undefined") {
+      previousParamsRef.current = { typesKey: "", userId: "", serverKey: "" };
+      setState({
+        loading: false,
+        error: null,
+        data: [],
+      });
+      return;
+    }
+
+    const currentParams = {
+      typesKey,
+      userId: effectiveUserId,
+      serverKey,
+    };
+    const hydratedCacheReady = readHydratedUserDataCacheFlag(hydrationKey);
+    const sameParams =
+      JSON.stringify(previousParamsRef.current) ===
+      JSON.stringify(currentParams);
+    const decision = getUserDataLoadDecision({
+      loading: loadingRef.current,
+      sameParams,
+      forceRefresh: options?.forceRefresh,
+    });
+
+    if (decision === "queue") {
+      pendingRefreshRef.current = true;
+      return;
+    }
+
+    if (decision === "skip") {
+      return;
+    }
+
+    loadingRef.current = true;
+    previousParamsRef.current = currentParams;
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+
+    try {
+      const localResults = await dispatch(
+        fetchUserDataThunk({
+          types: typeArray,
+          userId: effectiveUserId,
+          includeDeleted: true,
+        })
+      ).unwrap();
+      const localData: BaseItem[] = (Object.values(localResults).flat() as any[]).map(
+        (item) => item as BaseItem
+      );
+      debugUserData("local-loaded", {
+        userId: effectiveUserId,
+        types: typeArray,
+        localCount: localData.length,
+        localByType: summarizeItemsByType(localData),
+        localAppKeys: summarizeAppKeys(localData),
+      });
+
+      if (userId === "local" && !currentToken) {
+        const sortedLocalData = [...localData]
+          .filter((item) => !isTombstoneRecord(item))
+          .sort((a, b) => {
+            return getItemTimestamp(b) - getItemTimestamp(a);
+          });
+        const limitedLocalData = sortedLocalData.slice(0, limit);
+
+        setState({
+          loading: false,
+          error: null,
+          data: limitedLocalData,
+        });
+        loadingRef.current = false;
+        return;
+      }
+
+      const sortedInitialLocalData = [...localData]
+        .filter((item) => !isTombstoneRecord(item))
+        .sort((a, b) => {
+          return getItemTimestamp(b) - getItemTimestamp(a);
+        });
+      const limitedInitialLocalData = sortedInitialLocalData.slice(0, limit);
+
+      if (
+        shouldUsePartialLocalData({
+          strategy: partialDataStrategy,
+          hasHydratedCache: hydratedCacheReady,
+          localItemCount: limitedInitialLocalData.length,
+        })
+      ) {
+        setState((prev) => ({
+          ...prev,
+          data: limitedInitialLocalData,
+          loading: true,
+        }));
+      } else {
+        // 对于冷缓存或明确禁用 partial data 的场景，继续等完整 merge 后再替换，
+        // 避免首次进入时空列表/错位列表带来的明显闪烁。
+        setState((prev) => ({
+          ...prev,
+          loading: true,
+        }));
+      }
+
+      const remoteResults = await Promise.all(
+        allServers.map((serverOrigin) =>
+          loadRemoteUserData({
+            serverOrigin,
+            queryUserId: effectiveUserId,
+            types: typeArray,
+            limit,
+          })
+        )
+      );
+      debugUserData("remote-loaded", {
+        userId: effectiveUserId,
+        servers: allServers,
+        remoteCounts: remoteResults.map((result, index) => ({
+          index,
+          count: Array.isArray(result?.data?.data) ? result.data.data.length : 0,
+          byType: summarizeItemsByType(Array.isArray(result?.data?.data) ? result.data.data : []),
+          appKeys: summarizeAppKeys(Array.isArray(result?.data?.data) ? result.data.data : []),
+        })),
+      });
+
+      const mergedDataWithDeleted = mergeAndDedupData(localData, remoteResults, {
+        includeDeleted: true,
+      });
+      const mergedData = mergedDataWithDeleted.filter((item) => !isTombstoneRecord(item));
+      const sortedData = [...mergedData].sort((a, b) => {
+        return getItemTimestamp(b) - getItemTimestamp(a);
+      });
+      const limitedData = sortedData.slice(0, limit);
+      debugUserData("merged", {
+        userId: effectiveUserId,
+        mergedCount: mergedData.length,
+        mergedByType: summarizeItemsByType(mergedData),
+        mergedAppKeys: summarizeAppKeys(mergedData),
+        limitedCount: limitedData.length,
+        limitedByType: summarizeItemsByType(limitedData),
+        limitedAppKeys: summarizeAppKeys(limitedData),
+      });
+
+      if (mergedDataWithDeleted.length > 0) {
+        try {
+          await dispatch(cacheMergedUserDataThunk({ records: mergedDataWithDeleted })).unwrap();
+        } catch (cacheError) {
+          console.warn("[useUserData] Failed to persist merged user data cache", cacheError);
+        }
+      }
+
+      if (partialDataStrategy === "hydrated-cache" && hydrationKey) {
+        markHydratedUserDataCacheFlag(hydrationKey);
+      }
+
+      setState({
+        loading: false,
+        error: null,
+        data: limitedData,
+      });
+    } catch (err) {
+      const error =
+        err instanceof Error
+          ? err
+          : new Error(String(err) || "Unknown error occurred");
+      toast.error("加载数据失败，请检查网络或稍后重试");
+
+      setState((prev) => ({
+        ...prev,
+        loading: false,
+        error,
+      }));
+    } finally {
+      loadingRef.current = false;
+      if (pendingRefreshRef.current) {
+        pendingRefreshRef.current = false;
+        void loadData({ forceRefresh: true });
+      }
+    }
+  }, [
+    typesKey,
+    effectiveUserId,
+    serverKey,
+    hydrationKey,
+    limit,
+    dispatch,
+    currentToken,
+    userId,
+    typeArray,
+    partialDataStrategy,
+    allServers,
+  ]);
+
+  useEffect(() => {
+    loadData();
+  }, [loadData]);
+
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+
+    const refresh = () => {
+      clearCache();
+      void loadData({ forceRefresh: true });
+    };
+
+    window.addEventListener("nolo-user-data-updated", refresh);
+    return () => {
+      window.removeEventListener("nolo-user-data-updated", refresh);
+    };
+  }, [clearCache, loadData]);
+
+  return { loading, error, data, reload: loadData, clearCache };
+}

package/database/index.ts

@@ -0,0 +1 @@
+console.log('Hello via Bun!');