361 lines
14 KiB
TypeScript
361 lines
14 KiB
TypeScript
// ---- scriptsSlice ----
|
||
//
|
||
// 拥有 scripts / directories / dataResources / scriptCount / members /
|
||
// loadedOwnerGroups / loading / refreshing / apiOnline / readOnlyRefreshVersion。
|
||
// 所有 "从后端拉数据" 的 action 集中在这里(load / loadScripts /
|
||
// loadOwnerGroup / loadDataResources / loadScriptCount / refreshReadOnlyContent /
|
||
// setApiOnline)。
|
||
//
|
||
// cross-slice 依赖:
|
||
// - load 调用 selectionSlice 的 selectedId/openTabIds (清空失效项)
|
||
// - load 调用 treeSlice 的 loadedScriptPaths/loadedChildPaths/loadedOwnerGroups
|
||
// - loadScripts 读/写 treeSlice 的 loadedScriptPaths/loadingScriptPaths
|
||
// - loadOwnerGroup 读/写 treeSlice 的 loadedScriptPaths/loadedChildPaths
|
||
// - loadDataResources 读 helpers 的 _currentUserId
|
||
|
||
import type { StateCreator } from "zustand";
|
||
|
||
import type {
|
||
ResourceItem,
|
||
ScriptItem,
|
||
WorkspaceDirectory,
|
||
WorkspaceMember,
|
||
} from "~/services/api";
|
||
|
||
import {
|
||
bumpScriptCountSeq,
|
||
getCurrentUserId,
|
||
getScriptCountSeq,
|
||
getWorkspaceId,
|
||
ownerCacheKey,
|
||
pushToast,
|
||
requireApi,
|
||
} from "./helpers";
|
||
|
||
import type {
|
||
ScriptsSliceActions,
|
||
ScriptsSliceState,
|
||
} from "./types";
|
||
import type { ScriptWorkspaceStore } from "./useScriptWorkspaceStore";
|
||
|
||
export const createScriptsSlice: StateCreator<
|
||
ScriptWorkspaceStore,
|
||
[],
|
||
[],
|
||
ScriptsSliceState & ScriptsSliceActions
|
||
> = (set, get) => {
|
||
const initial: ScriptsSliceState = {
|
||
scripts: [],
|
||
directories: [],
|
||
dataResources: [],
|
||
dataResourcesLoading: false,
|
||
scriptCount: null,
|
||
scriptCountLoading: false,
|
||
members: [],
|
||
loadedOwnerGroups: new Set<string>(),
|
||
loadingOwnerGroups: new Set<string>(),
|
||
loading: true,
|
||
refreshing: false,
|
||
apiOnline: false,
|
||
readOnlyRefreshVersion: 0,
|
||
};
|
||
|
||
return {
|
||
...initial,
|
||
|
||
setApiOnline: (online) => set({ apiOnline: online }),
|
||
|
||
refreshReadOnlyContent: () =>
|
||
set((state) => ({
|
||
readOnlyRefreshVersion: state.readOnlyRefreshVersion + 1,
|
||
})),
|
||
|
||
load: async (silent = false) => {
|
||
const api = requireApi();
|
||
if (!silent) set({ loading: true });
|
||
set({ refreshing: silent });
|
||
try {
|
||
const me = getCurrentUserId();
|
||
const workspaceId = getWorkspaceId();
|
||
// 拉取工作区成员列表 —— 顶层"我 / user1 / user2 / …"折叠分组的来源。
|
||
const memberList =
|
||
workspaceId != null
|
||
? await api
|
||
.listWorkspaceMembers(workspaceId)
|
||
.catch(() => [] as WorkspaceMember[])
|
||
: [];
|
||
// 只重新拉取"我"的已缓存脚本路径（含根）。首次挂载缓存为空 → 退化为
|
||
// 单次根级拉取。他人脚本不动（保留在 flat scripts 里，见下方合并）。
|
||
const myCachedScriptKeys = Array.from(get().loadedScriptPaths).filter(
|
||
(k) => k.startsWith(`${me}:`) || k.startsWith("me:"),
|
||
);
|
||
const rootScriptKey = ownerCacheKey(undefined, "");
|
||
const scriptFetches =
|
||
myCachedScriptKeys.length > 0
|
||
? myCachedScriptKeys.map((k) => {
|
||
const p = k.slice(k.indexOf(":") + 1);
|
||
return api.listScripts(p).catch(() => [] as ScriptItem[]);
|
||
})
|
||
: [api.listScripts("").catch(() => [] as ScriptItem[])];
|
||
// 只重新拉取"我"的已缓存目录路径（含根）。他人目录不动（保留在
|
||
// flat directories 里，按 (owner,path) 去重合并）。
|
||
const myCachedDirKeys = Array.from(get().loadedChildPaths).filter(
|
||
(k) => (me != null && k.startsWith(`${me}:`)) || k.startsWith("me:"),
|
||
);
|
||
const rootDirKey = ownerCacheKey(undefined, "");
|
||
const dirFetches =
|
||
myCachedDirKeys.length > 0
|
||
? myCachedDirKeys.map((k) => {
|
||
const p = k.slice(k.indexOf(":") + 1);
|
||
return api
|
||
.listWorkspaceDirectories(p)
|
||
.catch(() => [] as WorkspaceDirectory[]);
|
||
})
|
||
: [api
|
||
.listWorkspaceDirectories("")
|
||
.catch(() => [] as WorkspaceDirectory[])];
|
||
const [scriptLists, dirLists] = await Promise.all([
|
||
Promise.all(scriptFetches),
|
||
Promise.all(dirFetches),
|
||
]);
|
||
const myFreshScripts = scriptLists.flat();
|
||
// "我"的脚本用 fresh 集合替换；他人脚本原样保留（按 script_id 去重合并）。
|
||
const otherScripts = get().scripts.filter(
|
||
(s) => s.owner_user_id !== me,
|
||
);
|
||
const dedupedScripts = Array.from(
|
||
new Map(
|
||
[...otherScripts, ...myFreshScripts].map((s) => [s.script_id, s]),
|
||
).values(),
|
||
);
|
||
// "我"的目录用 fresh 集合替换；他人目录原样保留（按 (owner,path) 去重）。
|
||
const otherDirs = get().directories.filter(
|
||
(d) => d.owner_user_id !== me,
|
||
);
|
||
const dedupedDirs = Array.from(
|
||
new Map(
|
||
[...otherDirs, ...dirLists.flat()].map((d) => [
|
||
`${d.owner_user_id}:${d.path}`,
|
||
d,
|
||
]),
|
||
).values(),
|
||
);
|
||
const nextLoadedScripts = new Set(myCachedScriptKeys);
|
||
nextLoadedScripts.add(rootScriptKey);
|
||
const nextLoadedChildren = new Set(get().loadedChildPaths);
|
||
nextLoadedChildren.add(rootDirKey);
|
||
set({
|
||
scripts: dedupedScripts,
|
||
directories: dedupedDirs,
|
||
members: memberList,
|
||
apiOnline: true,
|
||
loadedScriptPaths: nextLoadedScripts,
|
||
loadedChildPaths: nextLoadedChildren,
|
||
});
|
||
// 刷新已展开的其他成员分组（loadOwnerGroup 总是发起请求，刷新安全）。
|
||
for (const owner of get().loadedOwnerGroups) {
|
||
if (owner !== me) void get().loadOwnerGroup(owner);
|
||
}
|
||
const validIds = new Set(dedupedScripts.map((item) => item.script_id));
|
||
const currentSelected = get().selectedId;
|
||
if (!currentSelected || !validIds.has(currentSelected)) {
|
||
set({ selectedId: null });
|
||
}
|
||
set((state) => ({
|
||
openTabIds: state.openTabIds.filter((id) => validIds.has(id)),
|
||
}));
|
||
} catch (error) {
|
||
set({ apiOnline: false });
|
||
pushToast(
|
||
"error",
|
||
error instanceof Error ? error.message : "脚本列表加载失败",
|
||
);
|
||
} finally {
|
||
set({ loading: false, refreshing: false });
|
||
}
|
||
},
|
||
|
||
loadScripts: async (parentPath, ownerUserId) => {
|
||
const api = requireApi();
|
||
const cacheKey = ownerCacheKey(ownerUserId, parentPath);
|
||
if (get().loadedScriptPaths.has(cacheKey)) return;
|
||
// Dedupe in-flight requests for the same owner×path.
|
||
if (get().loadingScriptPaths.has(cacheKey)) return;
|
||
const next = new Set(get().loadingScriptPaths);
|
||
next.add(cacheKey);
|
||
set({ loadingScriptPaths: next });
|
||
try {
|
||
const items = await api.listScripts(parentPath, ownerUserId);
|
||
set((state) => {
|
||
// append-only 合并（按 script_id 去重，fresh 覆盖 stale 同 id 值）。
|
||
// 该 owner×path 的全量刷新由 load()（我）/ loadOwnerGroup（他人）
|
||
// 负责 drop-by-owner 后重并入；这里是子目录展开，append 即可。
|
||
const byId = new Map(state.scripts.map((s) => [s.script_id, s]));
|
||
for (const item of items) byId.set(item.script_id, item);
|
||
const nextLoaded = new Set(state.loadedScriptPaths);
|
||
nextLoaded.add(cacheKey);
|
||
return {
|
||
scripts: Array.from(byId.values()),
|
||
loadedScriptPaths: nextLoaded,
|
||
loadingScriptPaths: new Set(
|
||
[...state.loadingScriptPaths].filter((p) => p !== cacheKey),
|
||
),
|
||
};
|
||
});
|
||
} catch (error) {
|
||
set((state) => ({
|
||
loadingScriptPaths: new Set(
|
||
[...state.loadingScriptPaths].filter((p) => p !== cacheKey),
|
||
),
|
||
}));
|
||
pushToast(
|
||
"error",
|
||
error instanceof Error ? error.message : "脚本列表加载失败",
|
||
);
|
||
}
|
||
},
|
||
|
||
loadOwnerGroup: async (ownerUserId) => {
|
||
const api = requireApi();
|
||
if (get().loadingOwnerGroups.has(ownerUserId)) return;
|
||
const nextLoading = new Set(get().loadingOwnerGroups);
|
||
nextLoading.add(ownerUserId);
|
||
set({ loadingOwnerGroups: nextLoading });
|
||
try {
|
||
const [scripts, resources, directories] = await Promise.all([
|
||
api.listScripts("", ownerUserId).catch(() => [] as ScriptItem[]),
|
||
api.listResources("", { ownerUserId }).catch(
|
||
() => [] as ResourceItem[],
|
||
),
|
||
api.listWorkspaceDirectories("", ownerUserId).catch(
|
||
() => [] as WorkspaceDirectory[],
|
||
),
|
||
]);
|
||
set((state) => {
|
||
// 丢弃该 owner 的旧脚本/资源/目录（按 owner 过滤后保留他人），再并入 fresh。
|
||
const keptScripts = state.scripts.filter(
|
||
(s) => s.owner_user_id !== ownerUserId,
|
||
);
|
||
const keptResources = state.dataResources.filter(
|
||
(r) => r.owner_user_id !== ownerUserId,
|
||
);
|
||
const keptDirs = state.directories.filter(
|
||
(d) => d.owner_user_id !== ownerUserId,
|
||
);
|
||
const scriptIds = new Set(keptScripts.map((s) => s.script_id));
|
||
const freshScripts = scripts.filter((s) => !scriptIds.has(s.script_id));
|
||
const resourceIds = new Set(keptResources.map((r) => r.resource_id));
|
||
const freshResources = resources.filter(
|
||
(r) => !resourceIds.has(r.resource_id),
|
||
);
|
||
const dirIds = new Set(
|
||
keptDirs.map((d) => `${d.owner_user_id}:${d.path}`),
|
||
);
|
||
const freshDirs = directories.filter(
|
||
(d) => !dirIds.has(`${d.owner_user_id}:${d.path}`),
|
||
);
|
||
const nextLoaded = new Set(state.loadedOwnerGroups);
|
||
nextLoaded.add(ownerUserId);
|
||
const nextScriptPaths = new Set(state.loadedScriptPaths);
|
||
nextScriptPaths.add(ownerCacheKey(ownerUserId, ""));
|
||
const nextChildPaths = new Set(state.loadedChildPaths);
|
||
nextChildPaths.add(ownerCacheKey(ownerUserId, ""));
|
||
return {
|
||
scripts: [...keptScripts, ...freshScripts],
|
||
dataResources: [...keptResources, ...freshResources],
|
||
directories: [...keptDirs, ...freshDirs],
|
||
loadedOwnerGroups: nextLoaded,
|
||
loadedScriptPaths: nextScriptPaths,
|
||
loadedChildPaths: nextChildPaths,
|
||
loadingOwnerGroups: new Set(
|
||
[...state.loadingOwnerGroups].filter((o) => o !== ownerUserId),
|
||
),
|
||
};
|
||
});
|
||
} catch {
|
||
set((state) => ({
|
||
loadingOwnerGroups: new Set(
|
||
[...state.loadingOwnerGroups].filter((o) => o !== ownerUserId),
|
||
),
|
||
}));
|
||
}
|
||
},
|
||
|
||
loadDataResources: async (parentPath = "", ownerUserId) => {
|
||
const api = requireApi();
|
||
const cacheKey = ownerCacheKey(ownerUserId, parentPath);
|
||
// 命中缓存：listResources 是非递归的，同一 (owner, parent_path) 拉过的
|
||
// 内容不会自己变化；省去 toggleExpanded 重复展开同一目录时的网络往返。
|
||
if (get().loadedDataResourcePaths.has(cacheKey)) return;
|
||
set({ dataResourcesLoading: true });
|
||
try {
|
||
const list = await api.listResources(parentPath, { ownerUserId });
|
||
const fresh = Array.isArray(list) ? list : [];
|
||
set((state) => {
|
||
// 按 (owner, parent_path) 局部替换：丢掉该 owner 在 parentPath 下的
|
||
// 旧条目，保留该 owner 在其它路径下的条目，再并入 fresh。
|
||
// 这样 toggleExpanded 在子目录展开时按需拉取不会把根已加载的数据
|
||
// 资源擦掉（修"根加载后子目录展开丢数据 / 子目录数据本来不显示"）。
|
||
const targetOwner = ownerUserId ?? getCurrentUserId() ?? null;
|
||
const kept = state.dataResources.filter((r) => {
|
||
if (r.owner_user_id !== targetOwner) return true;
|
||
return parentPathOf(r.jupyter_accessible_path) !== parentPath;
|
||
});
|
||
const byId = new Map(kept.map((r) => [r.resource_id, r]));
|
||
for (const item of fresh) byId.set(item.resource_id, item);
|
||
const nextLoaded = new Set(state.loadedDataResourcePaths);
|
||
nextLoaded.add(cacheKey);
|
||
return {
|
||
dataResources: Array.from(byId.values()),
|
||
loadedDataResourcePaths: nextLoaded,
|
||
};
|
||
});
|
||
} catch {
|
||
set((state) => {
|
||
const targetOwner = ownerUserId ?? getCurrentUserId() ?? null;
|
||
return {
|
||
dataResources: state.dataResources.filter((r) => {
|
||
if (r.owner_user_id !== targetOwner) return true;
|
||
return parentPathOf(r.jupyter_accessible_path) !== parentPath;
|
||
}),
|
||
};
|
||
});
|
||
} finally {
|
||
set({ dataResourcesLoading: false });
|
||
}
|
||
},
|
||
|
||
loadScriptCount: async () => {
|
||
const api = requireApi();
|
||
// Always fire — don't dedupe via the loading flag. Rapid workspace
|
||
// switches would otherwise drop the new fetch and leave the
|
||
// dashboard showing the previous workspace's count. The sequence
|
||
// counter below discards stale responses instead.
|
||
const seq = bumpScriptCountSeq();
|
||
set({ scriptCountLoading: true, scriptCount: null });
|
||
try {
|
||
const total = await api.countScripts();
|
||
if (getScriptCountSeq() !== seq) return; // a newer fetch superseded us
|
||
set({ scriptCount: total });
|
||
} catch {
|
||
if (getScriptCountSeq() !== seq) return;
|
||
// Leave previous value in place; the dashboard already tolerates
|
||
// a stale count by rendering `scriptCount ?? 0`. Don't toast —
|
||
// the dashboard's other metrics are best-effort.
|
||
} finally {
|
||
if (getScriptCountSeq() === seq) {
|
||
set({ scriptCountLoading: false });
|
||
}
|
||
}
|
||
},
|
||
};
|
||
};
|
||
|
||
// 提取 jupyter-accessible 路径的父目录；用于 `loadDataResources` 局部替换时
|
||
// 判断一条缓存资源是否落在目标 parent_path 下（list-resources 按 parent_path
|
||
// 精确匹配，非递归）。
|
||
function parentPathOf(path: string): string {
|
||
const parts = path.split("/");
|
||
parts.pop();
|
||
return parts.join("/");
|
||
} |