nolo-cli 0.1.13 → 0.1.14

package/database/server/patch.ts

@@ -0,0 +1,282 @@
+// patch.js (或你的 patch 处理文件名)
+import { pino } from "pino";
+import { DataType } from "create/types";
+import serverDb from "./db"; // 确认路径正确
+import { handleToken } from "auth/server/token";
+import {
+  CYBOT_READONLY_MESSAGE,
+  isCybotReadOnlyMutation,
+} from "./cybotReadonly";
+import { invalidatePublicAgentsCache } from "ai/agent/server/fetchPublicAgents";
+import { resolveWriteAuthority } from "./writeAuthority";
+import {
+  findActiveLiveShareByTable,
+  patchShareMeta,
+  reconcileReplicaTable,
+  replicateSharedTableMutation,
+} from "../../share/server/tableReplication";
+
+const logger = pino({ name: "patch" });
+const getRequestOrigin = (req): string => {
+  try {
+    return new URL(req?.url ?? "").origin.replace(/\/+$/, "");
+  } catch {
+    return "";
+  }
+};
+const getForwardHeaders = (req): Record<string, string> => {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  const authHeader =
+    typeof req?.headers?.authorization === "string"
+      ? req.headers.authorization
+      : typeof req?.headers?.Authorization === "string"
+        ? req.headers.Authorization
+        : "";
+  if (authHeader) {
+    headers.Authorization = authHeader;
+  }
+  return headers;
+};
+
+// 深度合并工具函数 (保持不变)
+const deepMerge = (target, source) => {
+  const output = { ...target };
+  for (const key in source) {
+    // eslint-disable-next-line no-prototype-builtins
+    if (!source.hasOwnProperty(key)) continue;
+
+    if (source[key] === null && key in output) {
+      delete output[key];
+    } else if (
+      source[key] &&
+      typeof source[key] === "object" &&
+      !Array.isArray(source[key])
+    ) {
+      output[key] = deepMerge(output[key] || {}, source[key]);
+    } else {
+      output[key] = source[key];
+    }
+  }
+  return output;
+};
+
+export const handlePatch = async (req, res) => {
+  req.user = await handleToken(req, res);
+
+  // --- 修改：变量名改为 dbKey，但仍然从 req.params.id 获取值 ---
+  // (路由中仍然是 :id, 所以这里还是 req.params.id)
+  const dbKey = req.params.id;
+  const changes = req.body;
+  const { user } = req; // 假设 handleToken 添加了 user 对象
+
+  // --- 可选：检查 user 是否存在及权限 ---
+  if (!user || !user.userId) {
+    return res
+      .status(401)
+      .json({ message: "Unauthorized: Missing user token or userId" });
+  }
+  const actionUserId = user.userId;
+
+  // --- 基本验证 ---
+  if (!dbKey) {
+    // 这里理论上不会发生，因为路由匹配了 :id
+    return res
+      .status(400)
+      .json({ message: "Bad Request: Missing key in path parameter 'id'" });
+  }
+  if (
+    !changes ||
+    typeof changes !== "object" ||
+    Object.keys(changes).length === 0
+  ) {
+    return res
+      .status(400)
+      .json({ message: "Bad Request: Missing or invalid changes in body" });
+  }
+
+  if (isCybotReadOnlyMutation({ dbKey, dataType: changes?.type })) {
+    return res.status(403).json({
+      message: CYBOT_READONLY_MESSAGE,
+      error: "cybot_readonly",
+    });
+  }
+
+  try {
+    // --- 修改：使用 dbKey 变量与数据库交互 ---
+    const exist = await serverDb.get(dbKey);
+    if (!exist) {
+      // 使用 404 Not Found 更合适
+      return res
+        .status(404)
+        .json({ message: `Data not found for key: ${dbKey}` });
+    }
+
+    if (isCybotReadOnlyMutation({ dbKey, existingType: exist?.type })) {
+      return res.status(403).json({
+        message: CYBOT_READONLY_MESSAGE,
+        error: "cybot_readonly",
+      });
+    }
+
+    // --- 权限检查：只允许本人修改自己的数据 ---
+    const {
+      keyOwnerId,
+      recordOwnerId,
+      isAllowed,
+    } = resolveWriteAuthority({
+      dbKey,
+      actionUserId,
+      existingRecord: exist,
+    });
+
+    if (!isAllowed) {
+      logger.warn({
+        event: "patch_permission_denied",
+        actionUserId,
+        keyOwnerId,
+        recordOwnerId,
+        dbKey,
+      });
+      return res.status(403).json({
+        message: `Permission denied: user ${actionUserId} cannot patch data owned by ${keyOwnerId}`,
+      });
+    }
+
+    // 深度合并现有数据和变更 (保持不变)
+    const final = deepMerge(exist, changes);
+
+    await serverDb.put(dbKey, final);
+
+    if (
+      (final?.type === "table" || final?.type === "table_row") &&
+      typeof final?.tenantId === "string" &&
+      typeof final?.tableId === "string"
+    ) {
+      await replicateSharedTableMutation({
+        mutation: {
+          kind: "patch",
+          dbKey,
+          data: final,
+          dataType: final.type,
+          tenantId: final.tenantId,
+          tableId: final.tableId,
+        },
+        originServer: getRequestOrigin(req),
+        replicaServers: [],
+        findActiveLiveShare: findActiveLiveShareByTable,
+        putMutationToReplica: async (server, mutation) => {
+          try {
+            const response = await fetch(
+              `${server}/api/v1/db/patch/${encodeURIComponent(mutation.dbKey)}`,
+              {
+                method: "PATCH",
+                headers: getForwardHeaders(req),
+                body: JSON.stringify(mutation.data ?? {}),
+              }
+            );
+            return {
+              ok: response.ok,
+              status: response.status,
+              detail: response.ok ? "" : await response.text(),
+            };
+          } catch (error: any) {
+            return {
+              ok: false,
+              detail: error?.message ?? "Replica patch request failed",
+            };
+          }
+        },
+        reconcileReplicaTable: async ({
+          shareDbKey,
+          tableDbKey,
+          tableOwnerId,
+          replicaServers,
+        }) => {
+          const resolvedTableDbKey =
+            tableDbKey || `meta-${final.tenantId}-${final.tableId}`;
+          const resolvedTableOwnerId = tableOwnerId || final.tenantId;
+          await reconcileReplicaTable({
+            shareDbKey,
+            tableDbKey: resolvedTableDbKey,
+            tableOwnerId: resolvedTableOwnerId,
+            originServer: getRequestOrigin(req),
+            replicaServers,
+            thunkApi: null,
+            putRecordToServer: async (server, dbKey, record) => {
+              try {
+                const response = await fetch(`${server}/api/v1/db/write/`, {
+                  method: "POST",
+                  headers: getForwardHeaders(req),
+                  body: JSON.stringify({
+                    data: record,
+                    customKey: dbKey,
+                    userId: record?.userId ?? record?.tenantId ?? actionUserId,
+                  }),
+                });
+                return {
+                  ok: response.ok,
+                  status: response.status,
+                  detail: response.ok ? "" : await response.text(),
+                };
+              } catch (error: any) {
+                return {
+                  ok: false,
+                  detail: error?.message ?? "Replica reconcile request failed",
+                };
+              }
+            },
+            resetReplicaTable: async (server, tableDbKey) => {
+              try {
+                const response = await fetch(
+                  `${server}/api/v1/db/delete/${encodeURIComponent(tableDbKey)}?type=table`,
+                  {
+                    method: "DELETE",
+                    headers: getForwardHeaders(req),
+                  }
+                );
+                return {
+                  ok: response.ok,
+                  status: response.status,
+                  detail: response.ok ? "" : await response.text(),
+                };
+              } catch (error: any) {
+                return {
+                  ok: false,
+                  detail: error?.message ?? "Replica table reset failed",
+                };
+              }
+            },
+            patchShareMeta,
+          });
+        },
+        patchShareMeta,
+      });
+    }
+
+    if (dbKey.startsWith("agent-pub-") || dbKey.startsWith("cybot-pub-")) {
+      invalidatePublicAgentsCache();
+    }
+
+    // 返回成功响应 (保持修正后的逻辑：返回 final 对象)
+    return res.status(200).json({
+      data: final, // 返回合并后的完整数据，它应包含正确的 id
+      message: "Data patched successfully",
+    });
+  } catch (error) {
+    console.error(`[handlePatch Error] dbKey: ${dbKey}, Error:`, error);
+    // 根据错误类型返回更具体的错误码可能更好
+    if (error.name === "NotFoundError" || error.notFound) {
+      // 检查 LevelDB 可能的错误类型
+      return res.status(404).json({
+        message: `Data not found during patch operation for key: ${dbKey}`,
+      });
+    }
+    return res.status(500).json({
+      message: "Failed to patch data due to internal server error",
+      // 在生产环境中隐藏详细错误信息
+      // error: process.env.NODE_ENV === 'development' ? error.message : undefined,
+    });
+  }
+};

package/database/server/query.ts

@@ -0,0 +1,138 @@
+// database/server/handler.ts
+import serverDb from "./db";
+import { getUserDataPrefixes } from "../queryPrefixes";
+
+interface BaseItem {
+  id: string;
+  type: string;
+  updatedAt?: string | number;
+  created?: string | number;
+  userId: string;
+  [key: string]: any;
+}
+
+const isDeletedRecord = (value: unknown): boolean =>
+  Boolean(value && typeof value === "object" && (value as any).deletedAt);
+
+const shouldDebugQuery = process.env.APP_QUERY_DEBUG === "1";
+
+const attachQueriedKey = (key: string, value: unknown): BaseItem | null => {
+  if (!value || typeof value !== "object") return null;
+  const record = value as BaseItem;
+  if (typeof record.dbKey === "string" && record.dbKey.trim().length > 0) {
+    return record;
+  }
+  return {
+    ...record,
+    dbKey: key,
+  };
+};
+
+const normalizeQueryTypes = (value: unknown): string[] => {
+  if (Array.isArray(value)) {
+    return value
+      .filter((item): item is string => typeof item === "string")
+      .map((item) => item.trim())
+      .filter(Boolean);
+  }
+
+  if (typeof value === "string" && value.trim()) {
+    return [value.trim()];
+  }
+
+  return [];
+};
+
+const getComparableTimestamp = (item: BaseItem): number => {
+  const candidates = [item.updatedAt, item.createdAt, item.created];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return candidate;
+    }
+    if (typeof candidate === "string") {
+      const parsed = Date.parse(candidate);
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+      }
+    }
+  }
+
+  return 0;
+};
+
+async function fetchUserData(
+  types: string | string[],
+  userId: string,
+  options: { includeDeleted?: boolean } = {}
+): Promise<Record<string, BaseItem[]>> {
+  const results: Record<string, BaseItem[]> = {};
+  if (!userId || userId === "local" || userId === "undefined") return results;
+  const typeArray = Array.isArray(types) ? types : [types];
+  const includeDeleted = options.includeDeleted === true;
+  for (const type of typeArray) {
+    const prefixes = getUserDataPrefixes(type, userId);
+    for (const prefix of prefixes) {
+      for await (const [key, value] of serverDb.iterator({
+        gte: prefix,
+        lte: `${prefix}\uffff`,
+      })) {
+        const hydrated = attachQueriedKey(String(key), value);
+        if (hydrated != null && (includeDeleted || !isDeletedRecord(hydrated))) {
+          (results[type] ||= []).push(hydrated);
+        }
+      }
+    }
+  }
+  return results;
+}
+
+export const handleQuery = async (req: any, res: any) => {
+  const userId = req.params.userId;
+  if (
+    !userId ||
+    userId === "local" ||
+    userId.trim() === "" ||
+    userId === "undefined"
+  ) {
+    return res.status(400).json({ error: "UserId is invalid or missing" });
+  }
+  const { type, includeDeleted } = req.body as {
+    type?: string | string[];
+    includeDeleted?: boolean;
+  };
+  const requestedTypes = normalizeQueryTypes(type);
+  if (requestedTypes.length === 0) {
+    return res
+      .status(400)
+      .json({ error: "Query condition with valid 'type' or 'type[]' is required" });
+  }
+  const limit = Number(req.query.limit) || undefined;
+  try {
+    const groupedData = await fetchUserData(requestedTypes, userId, {
+      includeDeleted,
+    });
+    const data = requestedTypes.flatMap((requestedType) => groupedData[requestedType] || []);
+    const sortedData = [...data].sort(
+      (left, right) => getComparableTimestamp(right) - getComparableTimestamp(left)
+    );
+    const result = limit ? sortedData.slice(0, limit) : sortedData;
+    if (shouldDebugQuery) {
+      console.log("[db/query]", {
+        userId,
+        types: requestedTypes,
+        includeDeleted: includeDeleted === true,
+        limit: limit ?? null,
+        total: data.length,
+        returned: result.length,
+        sampleKeys: result.slice(0, 10).map((item) =>
+          item.dbKey ?? item.contentKey ?? item.appKey ?? item.appId ?? item.id ?? "unknown"
+        ),
+      });
+    }
+    return res.status(200).json({ data: { data: result } });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return res.status(500).json({ error: message });
+  }
+};