nolo-cli 0.1.31 → 0.1.32

package/database/hooks/useUserData.ts

@@ -1,495 +0,0 @@
-// 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;
-  remoteSummary?: boolean;
-}
-
-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,
-  summary,
-}: {
-  serverOrigin: string;
-  queryUserId: string;
-  types: DataType[];
-  limit: number;
-  summary?: boolean;
-}) => {
-  try {
-    const batchResponse = await noloQueryRequest({
-      server: serverOrigin,
-      queryUserId,
-      options: {
-        limit,
-        condition: { type: types, includeDeleted: true, ...(summary ? { summary: 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, ...(summary ? { summary: 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 remoteSummary = options.remoteSummary === true;
-
-  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,
-            summary: remoteSummary,
-          })
-        )
-      );
-      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 && !remoteSummary) {
-        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,
-    remoteSummary,
-    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

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

package/database/queryPrefixes.ts

@@ -1,14 +0,0 @@
-// 用户内容查询不能简单假设所有 key 都是 `${type}-${userId}-...`。
-// 例如 table 的真实 meta key 是 `meta-${userId}-${tableId}`，所以 query 层必须维护 type -> key prefix 的映射。
-const TYPE_PREFIX_ALIASES: Record<string, string[]> = {
-  table: ["meta"],
-};
-
-export function getUserDataPrefixes(type: string, userId: string): string[] {
-  const normalizedType = String(type || "").trim();
-  const normalizedUserId = String(userId || "").trim();
-  if (!normalizedType || !normalizedUserId) return [];
-
-  const aliases = TYPE_PREFIX_ALIASES[normalizedType] ?? [normalizedType];
-  return aliases.map((prefix) => `${prefix}-${normalizedUserId}`);
-}