nolo-cli 0.1.13 → 0.1.14

package/database/queryPrefixes.ts

@@ -0,0 +1,14 @@
+// 用户内容查询不能简单假设所有 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}`);
+}

package/database/requests.ts

@@ -0,0 +1,443 @@
+// database/requests.ts
+import { API_ENDPOINTS } from "./config";
+
+
+export const TIMEOUT = 5000;
+
+type RequestFailureLogLevel = "error" | "warn" | "info" | "silent";
+
+const logRequestFailure = (
+  level: RequestFailureLogLevel,
+  message: string
+) => {
+  if (level === "silent") return;
+  if (level === "warn") {
+    console.warn(message);
+    return;
+  }
+  if (level === "info") {
+    console.info(message);
+    return;
+  }
+  console.error(message);
+};
+
+/**
+ * 通用的Nolo服务器请求函数
+ * @param server 服务器地址
+ * @param config 请求配置 (url, method, body)
+ * @param state Redux state (用于获取token)
+ * @param signal AbortSignal 用于取消请求
+ * @returns Fetch Response Promise
+ */
+export const noloRequest = async (
+  server: string,
+  config: {
+    url: string;
+    method?: string;
+    body?: string | FormData;
+    headers?: HeadersInit;
+    keepalive?: boolean;
+  },
+  state: any,
+  signal?: AbortSignal
+): Promise<Response> => {
+  const headers: HeadersInit = config.headers || {
+    "Content-Type": "application/json",
+  };
+  // 从 state 中安全地获取 token
+  const token = state?.auth?.currentToken;
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+
+  return fetch(server + config.url, {
+    method: config.method || "GET",
+    headers,
+    body: config.body,
+    signal, // 传递 AbortSignal
+    ...(config.keepalive ? { keepalive: true } : {}),
+  });
+};
+
+/**
+ * 向单个服务器发送 PATCH 请求 (用于更新部分数据)
+ * @param server 服务器地址
+ * @param dbKey 数据键
+ * @param updates 要更新的数据对象
+ * @param state Redux state
+ * @param signal AbortSignal
+ * @returns Promise<boolean> 请求是否成功 (response.ok)
+ */
+export const noloPatchRequest = async (
+  server: string,
+  dbKey: string,
+  updates: any,
+  state: any,
+  signal?: AbortSignal,
+  options?: { failureLogLevel?: RequestFailureLogLevel }
+): Promise<boolean> => {
+  const failureLogLevel = options?.failureLogLevel ?? "error";
+  try {
+    const response = await noloRequest(
+      server,
+      {
+        url: `${API_ENDPOINTS.DATABASE}/patch/${dbKey}`,
+        method: "PATCH",
+        body: JSON.stringify(updates),
+      },
+      state,
+      signal
+    );
+    if (!response.ok) {
+      logRequestFailure(
+        failureLogLevel,
+        `PATCH request failed for ${dbKey} on ${server}: HTTP ${response.status}`
+      );
+    }
+    return response.ok;
+  } catch (error: any) {
+    if (error.name !== "AbortError") {
+      logRequestFailure(
+        failureLogLevel,
+        `PATCH request failed for ${dbKey} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    // 对于 AbortError 或其他网络错误，返回 false
+    return false;
+  }
+};
+
+/**
+ * 向单个服务器发送 POST 请求 (用于写入完整数据)
+ * @param server 服务器地址
+ * @param writeConfig 写入配置 { data, customKey, userId }
+ * @param state Redux state
+ * @param signal AbortSignal
+ * @returns Promise<boolean> 请求是否成功 (response.ok)
+ */
+export const noloWriteRequest = async (
+  server: string,
+  writeConfig: { data: any; customKey: string; userId?: string; indexKeys?: string[] },
+  state: any,
+  signal?: AbortSignal,
+  options?: { failureLogLevel?: RequestFailureLogLevel }
+): Promise<boolean> => {
+  const { data, customKey, userId, indexKeys } = writeConfig;
+  const failureLogLevel = options?.failureLogLevel ?? "error";
+  try {
+    const response = await noloRequest(
+      server,
+      {
+        url: `${API_ENDPOINTS.DATABASE}/write/`,
+        method: "POST",
+        body: JSON.stringify({ data, customKey, userId, indexKeys }),
+      },
+      state,
+      signal
+    );
+    if (!response.ok) {
+      logRequestFailure(
+        failureLogLevel,
+        `Write request failed for ${customKey} on ${server}: HTTP ${response.status}`
+      );
+    }
+    return response.ok;
+  } catch (error: any) {
+    if (error.name !== "AbortError") {
+      logRequestFailure(
+        failureLogLevel,
+        `Write request failed for ${customKey} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    // 对于 AbortError 或其他网络错误，返回 false
+    return false;
+  }
+};
+
+/**
+ * 向单个服务器发送 POST 请求 (用于文件上传)
+ * @param server 服务器地址
+ * @param uploadConfig 上传配置 { file, metadata, customKey, userId }
+ * @param state Redux state
+ * @param signal AbortSignal
+ * @returns Promise<boolean> 请求是否成功 (response.ok)
+ */
+export const noloUploadRequest = async (
+  server: string,
+  uploadConfig: {
+    file: File;
+    metadata: any;
+    customKey: string;
+    userId?: string;
+  },
+  state: any,
+  signal?: AbortSignal
+): Promise<boolean> => {
+  const { file, metadata, customKey, userId } = uploadConfig;
+  try {
+    const isReactNative =
+      typeof navigator !== "undefined" && (navigator as any).product === "ReactNative";
+    const isRNFile = (f: any) => f && typeof f.uri === 'string' && typeof f.name === 'string' && typeof f.type === 'string';
+    const normalizeBlobUtilPath = (uri: string): string =>
+      uri.startsWith("file://") ? uri.slice("file://".length) : uri;
+
+    if (isReactNative && isRNFile(file)) {
+      const ReactNativeBlobUtil = (await import("react-native-blob-util")).default;
+      const wrappedPath = ReactNativeBlobUtil.wrap(normalizeBlobUtilPath((file as any).uri));
+      const token = state?.auth?.currentToken;
+      const headers: Record<string, string> = {
+        "Content-Type": "multipart/form-data",
+      };
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+
+      const response = await ReactNativeBlobUtil.fetch(
+        "POST",
+        server + `${API_ENDPOINTS.DATABASE}/upload`,
+        headers,
+        [
+          {
+            name: "file",
+            filename: (file as any).name,
+            type: (file as any).type,
+            data: wrappedPath,
+          },
+          { name: "metadata", data: JSON.stringify(metadata) },
+          { name: "customKey", data: customKey },
+          ...(userId ? [{ name: "userId", data: userId }] : []),
+        ]
+      );
+      const status = response.info().status;
+      const ok = status >= 200 && status < 300;
+
+      if (!ok) {
+        console.error(
+          `Upload request failed for ${customKey} on ${server}: HTTP ${status}`
+        );
+      }
+
+      return ok;
+    }
+
+    // 创建 FormData 对象，用于 multipart/form-data 请求
+    const formData = new FormData();
+
+    if (isRNFile(file)) {
+      // @ts-ignore - RN 的 FormData append 允许传对象，但 TS 定义可能不匹配
+      formData.append("file", {
+        uri: (file as any).uri,
+        type: (file as any).type,
+        name: (file as any).name,
+      });
+    } else {
+      // Web 环境：直接 append File 对象
+      formData.append("file", file);
+    }
+
+    formData.append("metadata", JSON.stringify(metadata)); // 添加文件元数据
+    formData.append("customKey", customKey); // 添加自定义键
+    if (userId) {
+      formData.append("userId", userId); // 添加用户ID（如果有）
+    }
+
+    const response = await noloRequest(
+      server,
+      {
+        url: `${API_ENDPOINTS.DATABASE}/upload`,
+        method: "POST",
+        body: formData as any, // Cast to any to avoid TS mismatch with Bun/DOM FormData
+        headers: {}, // 不设置 Content-Type，让浏览器自动处理 multipart/form-data
+      },
+      state,
+      signal
+    );
+    if (!response.ok) {
+      console.error(
+        `Upload request failed for ${customKey} on ${server}: HTTP ${response.status}`
+      );
+    }
+    return response.ok;
+  } catch (error: any) {
+    if (error.name !== "AbortError") {
+      console.error(
+        `Upload request failed for ${customKey} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    // 对于 AbortError 或其他网络错误，返回 false
+    return false;
+  }
+};
+
+/**
+ * 向单个服务器发送 GET 请求 (用于读取文件内容或元数据)
+ * @param server 服务器地址
+ * @param fileId 文件ID或自定义键
+ * @param options 可选参数 { type: 'metadata' | 'content' }
+ * @param state Redux state
+ * @param signal AbortSignal
+ * @returns Promise<{ success: boolean, data?: any }> 请求是否成功以及返回的数据
+ */
+export const noloReadFileRequest = async (
+  server: string,
+  fileId: string,
+  options: {
+    type?: "metadata" | "content"; // metadata: 只获取元数据, content: 获取文件内容
+  } = { type: "metadata" },
+  state: any,
+  signal?: AbortSignal
+): Promise<{ success: boolean; data?: any }> => {
+  const { type = "metadata" } = options;
+
+  try {
+    // 根据类型构建 URL
+    const url =
+      type === "content"
+        ? `${API_ENDPOINTS.DATABASE}/file/content/${fileId}`
+        : `${API_ENDPOINTS.DATABASE}/file/metadata/${fileId}`;
+
+    const response = await noloRequest(
+      server,
+      {
+        url,
+        method: "GET",
+      },
+      state,
+      signal
+    );
+
+    if (!response.ok) {
+      console.error(
+        `Read file request failed for ${fileId} on ${server}: HTTP ${response.status}`
+      );
+      return { success: false };
+    }
+
+    // 根据类型处理响应数据
+    let data;
+    if (type === "content") {
+      // 文件内容可能较大，建议以流式或 Blob 形式处理
+      data = await response.blob(); // 以 Blob 形式返回文件内容
+    } else {
+      data = await response.json(); // 元数据以 JSON 形式返回
+    }
+
+    return { success: true, data };
+  } catch (error: any) {
+    if (error.name !== "AbortError") {
+      console.error(
+        `Read file request failed for ${fileId} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    return { success: false };
+  }
+};
+
+/**
+ * 通用的服务器同步函数，带有超时和错误处理
+ * @param servers 服务器地址列表
+ * @param requestFn 实际执行请求的函数 (应返回 Promise<boolean>)
+ * @param errorMessage 失败时的错误消息前缀
+ * @param requestArgs 传递给 requestFn 的额外参数 (除了 server 和 signal)
+ */
+export const syncWithServers = <TArgs extends any[]>(
+  servers: string[],
+  requestFn: (
+    server: string,
+    ...args: [...TArgs, AbortSignal?]
+  ) => Promise<boolean>,
+  errorMessage: string,
+  ...requestArgs: TArgs
+): void => {
+  servers.forEach((server) => {
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(() => {
+      // console.warn(`Request to ${server} timed out after ${TIMEOUT}ms`); // 可选：超时警告
+      abortController.abort(); // 超时时中止请求
+    }, TIMEOUT);
+
+    // 执行请求函数
+    requestFn(server, ...requestArgs, abortController.signal)
+      .then((success) => {
+        clearTimeout(timeoutId); // 清除超时定时器
+        if (!success) {
+          // 只在请求明确失败时提示（非超时）
+          // 注意：noloPatchRequest/noloWriteRequest 内部已打印详细错误
+          // 此处 toast 可考虑移除或改为更通用的后台同步失败提示
+          // toast.error(`${errorMessage} ${server}`);
+          console.warn(`${errorMessage} ${server}`); // 使用 console.warn 代替 toast
+        }
+      })
+      .catch((error) => {
+        clearTimeout(timeoutId); // 清除超时定时器
+        // AbortError 通常由超时引起，已在 requestFn 中处理或此处忽略
+        if (error.name !== "AbortError") {
+          console.error(
+            `Unexpected error during sync with ${server}: ${error.message || "Unknown error"}`
+          );
+          // toast.error(`Sync failed with ${server}`); // 可选的通用失败提示
+        }
+      });
+  });
+};
+
+/**
+ * 向单个服务器发送 DELETE 请求
+ * @param server 服务器地址
+ * @param dbKey 数据键
+ * @param options 可选参数 { type: 'messages' | 'single' }
+ * @param state Redux state
+ * @param signal AbortSignal
+ * @returns Promise<boolean> 请求是否成功
+ */
+export const noloDeleteRequest = async (
+  server: string,
+  dbKey: string,
+  options: {
+    // 原来: type?: "messages" | "single";
+    // 现在增加 "table"，给删整张表用
+    type?: "messages" | "single" | "table";
+  },
+  state: any,
+  signal?: AbortSignal
+): Promise<boolean> => {
+  const { type = "single" } = options; // 默认为 'single'
+
+  try {
+    // 根据类型构建 URL
+    const url =
+      type === "messages"
+        ? `${API_ENDPOINTS.DATABASE}/delete/${dbKey}?type=messages`
+        : type === "table"
+          ? `${API_ENDPOINTS.DATABASE}/delete/${dbKey}?type=table`
+          : `${API_ENDPOINTS.DATABASE}/delete/${dbKey}`;
+
+    const response = await noloRequest(
+      server,
+      {
+        url,
+        method: "DELETE",
+        keepalive: true,
+      },
+      state,
+      signal
+    );
+
+    if (!response.ok) {
+      console.error(
+        `DELETE request failed for ${dbKey} on ${server}: HTTP ${response.status}`
+      );
+      return false;
+    }
+
+    return true; // 请求成功
+  } catch (error: any) {
+    if (error.name !== "AbortError") {
+      console.error(
+        `DELETE request failed for ${dbKey} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    return false;
+  }
+};

package/database/runtimeServerContext.ts

@@ -0,0 +1,35 @@
+import type { RootState } from "app/store";
+import { selectRuntimeSnapshot } from "app/stateViews/runtime";
+import { getAllServers } from "database/actions/common";
+
+export type RuntimeServerContext = {
+  currentToken?: string;
+  currentUserId?: string;
+  currentServer?: string;
+  syncServers: string[];
+  remoteServers: string[];
+};
+
+export const getRuntimeServerContext = (
+  state: RootState,
+  preferredServerOrigin?: string | null
+): RuntimeServerContext => {
+  const {
+    currentToken,
+    currentUserId,
+    currentServer,
+    syncServers = [],
+  } = selectRuntimeSnapshot(state);
+
+  return {
+    currentToken,
+    currentUserId,
+    currentServer,
+    syncServers,
+    remoteServers: getAllServers(
+      currentServer,
+      syncServers,
+      preferredServerOrigin
+    ),
+  };
+};

package/database/server/MemoryDB.ts

@@ -0,0 +1,76 @@
+export interface BatchOp {
+    type: "put" | "del";
+    key: string;
+    value?: any;
+}
+
+export class MemoryDB {
+    private data = new Map<string, any>();
+
+    async get(key: string): Promise<any> {
+        if (this.data.has(key)) {
+            return this.data.get(key);
+        }
+        throw new Error("NotFound");
+    }
+
+    async put(key: string, value: any): Promise<void> {
+        this.data.set(key, value);
+    }
+
+    async del(key: string): Promise<void> {
+        this.data.delete(key);
+    }
+
+    private async applyBatch(ops: BatchOp[]): Promise<void> {
+        for (const op of ops) {
+            if (op.type === "put") {
+                this.data.set(op.key, op.value);
+            } else {
+                this.data.delete(op.key);
+            }
+        }
+    }
+
+    batch(ops?: BatchOp[]) {
+        if (Array.isArray(ops)) {
+            return this.applyBatch(ops);
+        }
+
+        const bufferedOps: BatchOp[] = [];
+        return {
+            put: (key: string, value: any) => {
+                bufferedOps.push({ type: "put", key, value });
+            },
+            del: (key: string) => {
+                bufferedOps.push({ type: "del", key });
+            },
+            write: async () => {
+                await this.applyBatch(bufferedOps);
+            },
+        };
+    }
+
+    async *iterator(options: { gte?: string; lte?: string; lt?: string; reverse?: boolean } = {}) {
+        let keys = Array.from(this.data.keys()).sort();
+        if (options.reverse) {
+            keys.reverse();
+        }
+
+        for (const key of keys) {
+            if (options.gte && key < options.gte) continue;
+            if (options.lte && key > options.lte) continue;
+            if (options.lt && key >= options.lt) continue;
+            yield [key, this.data.get(key)];
+        }
+    }
+
+    // Helper for tests
+    dump() {
+        return Object.fromEntries(this.data);
+    }
+
+    clear() {
+        this.data.clear();
+    }
+}

package/database/server/actorAccess.ts

@@ -0,0 +1,76 @@
+import type { ActorContext } from "auth/actor";
+import {
+  authorizeRecordAccess,
+  type AccessAction,
+  type AccessResult,
+} from "./resourceAccess";
+import {
+  loadAgentDelegation,
+  validateAgentDelegation,
+} from "./agentDelegation";
+
+type ActorAccessInput = {
+  action: AccessAction;
+  actor?: ActorContext | null;
+  dbKey: string;
+  record?: any;
+};
+
+export async function authorizeActorRecordAccess({
+  action,
+  actor,
+  dbKey,
+  record,
+}: ActorAccessInput): Promise<AccessResult> {
+  if (!actor) {
+    return { allowed: false, reason: "missing_actor" };
+  }
+
+  if (actor.type === "user") {
+    return authorizeRecordAccess({
+      action,
+      actionUserId: actor.userId,
+      dbKey,
+      record,
+    });
+  }
+
+  if (!actor.principalUserId) {
+    return { allowed: false, reason: "missing_principal_user" };
+  }
+
+  const principalAccess = await authorizeRecordAccess({
+    action,
+    actionUserId: actor.principalUserId,
+    dbKey,
+    record,
+  });
+  if (!principalAccess.allowed) {
+    return {
+      ...principalAccess,
+      allowed: false,
+      reason: "principal_access_denied",
+    };
+  }
+
+  const delegation = await loadAgentDelegation(
+    actor.principalUserId,
+    actor.agentId
+  );
+  const delegationAccess = validateAgentDelegation({
+    delegation,
+    action,
+    dbKey,
+    record,
+    spaceId: principalAccess.spaceId,
+  });
+  if (!delegationAccess.allowed) {
+    return {
+      ...principalAccess,
+      allowed: false,
+      reason: delegationAccess.reason,
+    };
+  }
+
+  return principalAccess;
+}