nolo-cli 0.1.13 → 0.1.15

package/database/dbSlice.ts

@@ -0,0 +1,149 @@
+// 文件路径: database/dbSlice.ts
+
+import {
+  asyncThunkCreator,
+  buildCreateSlice,
+  createEntityAdapter,
+  type PayloadAction,
+} from "@reduxjs/toolkit";
+import type { RootState } from "app/store";
+
+// Import actions
+import { removeAction } from "./actions/remove";
+import { readAction } from "./actions/read";
+import { readAndWaitAction } from "./actions/readAndWait";
+import { writeAction } from "./actions/write";
+import { patchAction } from "./actions/patch";
+import { upsertAction } from "./actions/upsert";
+import { uploadFileAction } from "./actions/upload";
+import { readFileContentAction } from "./actions/fileContent";
+import { shareResourceAction } from "share/action";
+
+// Use dbKey as the entity's unique identifier
+export const dbAdapter = createEntityAdapter<any>({
+  selectId: (entity: any) => entity.dbKey,
+});
+
+// Selectors
+export const {
+  selectById,
+  selectEntities,
+  selectAll,
+  selectIds,
+  selectTotal,
+} = dbAdapter.getSelectors((state: RootState) => state.db);
+
+// Initial state
+const initialState = dbAdapter.getInitialState({});
+
+// Create slice with async thunks
+const createSliceWithThunks = buildCreateSlice({
+  creators: { asyncThunk: asyncThunkCreator },
+});
+
+// Slice definition
+const dbSlice = createSliceWithThunks({
+  name: "db",
+  initialState,
+  reducers: (create) => ({
+    // Async Thunks
+    read: create.asyncThunk(readAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && Object.keys(action.payload).length > 0) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      },
+    }),
+    readAndWait: create.asyncThunk(readAndWaitAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && Object.keys(action.payload).length > 0) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      },
+    }),
+    remove: create.asyncThunk(removeAction, {
+      fulfilled: (state, action) => {
+        const { dbKey } = action.payload;
+        if (dbKey) dbAdapter.removeOne(state, dbKey);
+      },
+    }),
+    write: create.asyncThunk(writeAction, {
+      fulfilled: (state, action) => {
+        if (
+          action.payload &&
+          action.payload.dbKey &&
+          Object.keys(action.payload).length > 0
+        ) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      },
+    }),
+    patch: create.asyncThunk(patchAction, {
+      fulfilled: (state, action) => {
+        const { payload } = action;
+        if (payload && payload.dbKey && Object.keys(payload).length > 0) {
+          dbAdapter.upsertOne(state, payload);
+        }
+      },
+    }),
+    upsert: create.asyncThunk(upsertAction, {
+      fulfilled: (state, action) => {
+        if (
+          action.payload &&
+          action.payload.dbKey &&
+          Object.keys(action.payload).length > 0
+        ) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      },
+    }),
+    // 文件上传（avatar / Slate / Space 等统一走这里）
+    upload: create.asyncThunk(uploadFileAction, {
+      fulfilled: (state, action) => {
+        const payload = action.payload;
+        if (payload && payload.dbKey && Object.keys(payload).length > 0) {
+          dbAdapter.upsertOne(state, payload);
+        }
+      },
+    }),
+    // 读取文件内容（优先本地 IndexedDB，无状态副作用）
+    readFileContent: create.asyncThunk(readFileContentAction, {
+      // fulfilled 时不修改 db state；由调用方通过 unwrap() 拿返回值使用
+    }),
+    share: create.asyncThunk(shareResourceAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && action.payload.key) {
+          // We might want to store the shared object in local DB state too?
+          // writeAction already does it. This is just for return value.
+          // Actually, writeAction is dispatched inside shareResourceAction.
+          // Does writeAction update state? Yes.
+          // So here we might not need to do anything extra to state, 
+          // just define the thunk.
+        }
+      }
+    }),
+    // SSR 预取：服务端直接注入实体到 db slice，供首屏 hydrate 使用
+    upsertSSREntity: create.reducer((state, action: PayloadAction<any>) => {
+      if (action.payload && action.payload.dbKey) {
+        dbAdapter.upsertOne(state, action.payload);
+      }
+    }),
+  }),
+});
+
+// Export actions
+export const {
+  remove,
+  read,
+  readAndWait,
+  write,
+  patch,
+  upsert,
+  upload,
+  readFileContent,
+  share,
+  upsertSSREntity,
+} = dbSlice.actions;
+
+// Export the reducer
+export default dbSlice.reducer;

package/database/email.ts

@@ -0,0 +1,42 @@
+import type { DataType } from "create/types";
+
+export type EmailOwnerType = "user" | "agent";
+export type EmailMailbox = "inbox" | "sent" | "archive" | "trash" | "drafts";
+export type EmailStatus =
+  | "received"
+  | "draft"
+  | "queued"
+  | "sent"
+  | "failed";
+
+export type EmailParticipant = {
+  email: string;
+  name?: string;
+};
+
+export type EmailRecord = {
+  dbKey: string;
+  type: DataType.EMAIL;
+  ownerType: EmailOwnerType;
+  ownerId: string;
+  tenantId: string;
+  spaceId?: string | null;
+  mailbox: EmailMailbox;
+  status: EmailStatus;
+  from: EmailParticipant;
+  to: EmailParticipant[];
+  cc?: EmailParticipant[];
+  bcc?: EmailParticipant[];
+  replyTo?: EmailParticipant[];
+  subject: string;
+  text?: string;
+  html?: string;
+  messageId?: string;
+  threadId?: string;
+  inReplyTo?: string;
+  references?: string[];
+  tags?: string[];
+  meta?: Record<string, unknown>;
+  createdAt: string | number;
+  updatedAt: string | number;
+};

package/database/fileRing.ts

@@ -0,0 +1,51 @@
+// 文件路径: database/fileRing.ts
+
+/**
+ * 简单的 FNV-1a 32bit 字符串哈希
+ * - 稳定、实现简单，适合作为 hash ring 的排序依据
+ */
+const fnv1a32 = (str: string): number => {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = (hash * 0x01000193) >>> 0; // 32bit
+    }
+    return hash >>> 0;
+};
+
+/**
+ * 通用服务器选择函数：
+ *
+ * 给定一组服务器和一个“key”（可以是 tenantId / userId / orgId / fileId …），
+ * 选择 replicaCount 个服务器作为该 key 的“归属服务器”。
+ *
+ * 规则：
+ * - 对每个 server 计算 hash(server + "::" + key)
+ * - 按 hash 升序排序
+ * - 取前 replicaCount 个
+ *
+ * 说明：
+ * - 这不是严格意义上的一致性哈希环，但分布效果 + 实现复杂度比较均衡；
+ * - 之后要支持更多服务器，只需要在配置中把新 server 加入列表即可，
+ *   这里不需要改代码。
+ */
+export const chooseServersByKey = (
+    allServers: string[],
+    key: string,
+    replicaCount: number
+): string[] => {
+    if (!allServers.length || replicaCount <= 0) return [];
+
+    const uniqueServers = Array.from(new Set(allServers)).filter((s) => !!s);
+    if (uniqueServers.length === 0) return [];
+
+    const scored = uniqueServers.map((server) => ({
+        server,
+        score: fnv1a32(`${server}::${key}`),
+    }));
+
+    scored.sort((a, b) => a.score - b.score);
+
+    const limit = Math.min(replicaCount, scored.length);
+    return scored.slice(0, limit).map((item) => item.server);
+};

package/database/fileSharding.ts

@@ -0,0 +1,70 @@
+// 文件路径: database/fileSharding.ts
+
+import { chooseServersForFile } from "./fileRing";
+
+/**
+ * 当前“切片”策略参数：
+ *
+ * - REPLICA_COUNT = 3:
+ *   在 ring 中尽量挑 3 台不同的服务器存副本。
+ *
+ * - REQUIRED_SHARDS = 2:
+ *   语义上表示：只要有 2 份副本可用就能工作（当前是完整副本，所以任意一份都能用）。
+ *
+ * 将来如果要上真正的纠删码（2-of-3），可以保留这两个名字，
+ * 只是把 encode/decode 的实现替换掉即可。
+ */
+export const REPLICA_COUNT = 3;
+export const REQUIRED_SHARDS = 2;
+
+/**
+ * 基于 hash ring 选择本次写入要用的服务器列表。
+ *
+ * 要求：
+ * - 优先根据 fileId 在 allServers 上做 ring 选择 REPLICA_COUNT 个；
+ * - 无论 ring 如何选择，currentServer 必须包含在结果中（保证当前前端指向的服务器上总有一份）。
+ *
+ * 说明：
+ * - 现在每个 server 存的是完整文件，将来可以改成“每个 server 存一个 shard blob”，
+ *   但对 upload 调用方来说只是「发给这些 servers」这一点不变。
+ */
+export const planReplicaServersForFile = (
+    allServers: string[],
+    currentServer: string | null | undefined,
+    fileId: string
+): string[] => {
+    const uniqueServers = Array.from(new Set(allServers)).filter(Boolean);
+    if (!uniqueServers.length) return [];
+
+    const fromRing = chooseServersForFile(uniqueServers, fileId, REPLICA_COUNT);
+    const set = new Set(fromRing);
+
+    if (currentServer && uniqueServers.includes(currentServer)) {
+        set.add(currentServer);
+    }
+
+    return Array.from(set);
+};
+
+/**
+ * 预留：将来真正做 2-of-3 纠删码时在这里实现。
+ *
+ * encode:
+ *   接收完整 File/Blob，返回若干 shard（索引 + blob），
+ *   上层再根据 shardIndex + planReplicaServersForFile 决定各 shard 分布。
+ *
+ * decode:
+ *   接收至少 REQUIRED_SHARDS 份 shard，重建完整 Blob。
+ */
+
+// export async function encodeToShards(
+//   file: File | Blob
+// ): Promise<Array<{ shardIndex: number; blob: Blob }>> {
+//   // TODO: 将来在这里实现真正的 2-of-3 切片编码
+// }
+
+// export async function decodeFromShards(
+//   shards: Array<{ shardIndex: number; blob: Blob }>
+// ): Promise<Blob> {
+//   // TODO: 将来在这里实现解码逻辑
+// }

package/database/fileStorage.native.ts

@@ -0,0 +1,92 @@
+
+/**
+ * React Native 端的"文件存储"实现
+ * 
+ * 由于 RN 环境没有 IndexedDB，且直接将文件存入 LevelDB 性能较差（虽然可行但不是最佳实践），
+ * 这里我们采用折衷方案：
+ * 1. 假设文件已经存在于设备文件系统中（例如相册选择的临时路径，或者下载后的路径）。
+ * 2. 我们只存储 fileId -> localUri 的映射关系到 LevelDB 中。
+ * 3. 读取时返回这个映射，让上层通过 Image.source 或 RNFS 读取。
+ * 
+ * 注意：如果原始文件被系统清理（如 tmp 目录），这个引用会失效。
+ * 理想情况下应该 copy 到 DocumentDirectory，但为了避免引入 react-native-fs 依赖导致需要 rebuild，
+ * 暂时先存储路径映射。
+ */
+
+import { getDb } from "./client/db";
+
+// 在 RN 中，File 对象通常是 { uri, name, type, size } 的结构
+export interface RNFile {
+    uri: string;
+    name: string;
+    type: string;
+    size: number;
+}
+
+export interface StoredFileRecord {
+    id: string;
+    uri: string; // 替代 blob
+    size: number;
+    type: string;
+    createdAt: string;
+}
+
+const FILE_PREFIX = "local-file-ref:";
+
+export const saveFileToIndexedDb = async (
+    fileId: string,
+    file: File | Blob | RNFile
+): Promise<void> => {
+    try {
+        const db = getDb();
+        if (!db) {
+            console.warn("[fileStorage.native] Database not initialized");
+            return;
+        }
+
+        // 检查是否为 RN 文件结构
+        const uri = (file as any).uri;
+        if (!uri) {
+            console.warn("[fileStorage.native] File object missing URI, cannot store reference", file);
+            return;
+        }
+
+        const record: StoredFileRecord = {
+            id: fileId,
+            uri: uri,
+            size: (file as any).size || 0,
+            type: (file as any).type || "application/octet-stream",
+            createdAt: new Date().toISOString(),
+        };
+
+        await db.put(`${FILE_PREFIX}${fileId}`, record);
+        console.log(`[fileStorage.native] Saved file reference: ${fileId} -> ${uri}`);
+    } catch (err) {
+        console.error("[fileStorage.native] Failed to save file reference:", err);
+    }
+};
+
+export const loadFileFromIndexedDb = async (
+    fileId: string
+): Promise<StoredFileRecord | null> => {
+    try {
+        const db = getDb();
+        if (!db) return null;
+
+        const record = await db.get(`${FILE_PREFIX}${fileId}`);
+        return record as StoredFileRecord;
+    } catch (err) {
+        // LevelDB throws if key not found
+        return null;
+    }
+};
+
+export const deleteFileFromIndexedDb = async (fileId: string): Promise<void> => {
+    try {
+        const db = getDb();
+        if (!db) return;
+        await db.del(`${FILE_PREFIX}${fileId}`);
+    } catch (err) {
+        console.warn("[fileStorage.native] Failed to delete file reference:", err);
+    }
+};

package/database/fileStorage.ts

@@ -0,0 +1,232 @@
+// 文件路径: database/fileStorage.ts
+
+/**
+ * 浏览器端文件存储（IndexedDB）
+ *
+ * 设计：
+ * - 库名: "nolo-file-storage"
+ * - 表名: "files"
+ * - 主键: "id" (即 fileId / BlobId)
+ *
+ * 存储内容:
+ * {
+ *   id: string;         // fileId
+ *   blob: Blob;         // 文件数据
+ *   size: number;
+ *   type: string;       // MIME
+ *   createdAt: string;  // ISO 时间
+ * }
+ */
+
+const DB_NAME = "nolo-file-storage";
+const STORE_NAME = "files";
+const DB_VERSION = 1;
+
+export interface StoredFileRecord {
+    id: string;
+    blob: Blob;
+    size: number;
+    type: string;
+    createdAt: string;
+}
+
+let dbPromise: Promise<IDBDatabase> | null = null;
+
+const openFileDb = (): Promise<IDBDatabase> => {
+    if (dbPromise) return dbPromise;
+
+    if (typeof indexedDB === "undefined") {
+        console.warn(
+            "[fileStorage] indexedDB is not available in this environment. File caching is disabled."
+        );
+        dbPromise = Promise.reject(
+            new Error("indexedDB is not available in this environment")
+        );
+        return dbPromise;
+    }
+
+    dbPromise = new Promise((resolve, reject) => {
+        const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+        request.onerror = () => {
+            console.error("[fileStorage] Failed to open IndexedDB:", request.error);
+            reject(request.error);
+        };
+
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+                const store = db.createObjectStore(STORE_NAME, {
+                    keyPath: "id",
+                });
+                store.createIndex("createdAt", "createdAt", { unique: false });
+            }
+        };
+
+        request.onsuccess = () => {
+            const db = request.result;
+            db.onversionchange = () => {
+                db.close();
+                console.warn(
+                    "[fileStorage] IndexedDB version change detected, closing old connection."
+                );
+            };
+            resolve(db);
+        };
+    });
+
+    return dbPromise;
+};
+
+/**
+ * 将文件 (File/Blob) 存入 IndexedDB
+ * - key = fileId
+ */
+export const saveFileToIndexedDb = async (
+    fileId: string,
+    file: File | Blob
+): Promise<void> => {
+    try {
+        const db = await openFileDb();
+        const tx = db.transaction(STORE_NAME, "readwrite");
+        const store = tx.objectStore(STORE_NAME);
+
+        const blob = file instanceof Blob ? file : new Blob([file]);
+
+        const record: StoredFileRecord = {
+            id: fileId,
+            blob,
+            size: blob.size,
+            type: blob.type || "application/octet-stream",
+            createdAt: new Date().toISOString(),
+        };
+
+        const request = store.put(record);
+
+        await new Promise<void>((resolve, reject) => {
+            request.onsuccess = () => {
+                console.debug(
+                    "[fileStorage] Saved file to IndexedDB:",
+                    fileId,
+                    "size=",
+                    record.size,
+                    "type=",
+                    record.type
+                );
+                resolve();
+            };
+            request.onerror = () => {
+                console.error(
+                    "[fileStorage] Failed to save file to IndexedDB:",
+                    fileId,
+                    request.error
+                );
+                reject(request.error);
+            };
+        });
+
+        await new Promise<void>((resolve, reject) => {
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            tx.onabort = () => reject(tx.error);
+        });
+    } catch (err) {
+        console.warn(
+            "[fileStorage] saveFileToIndexedDb error (non-fatal, caching disabled for this file):",
+            err
+        );
+    }
+};
+
+/**
+ * 从 IndexedDB 中读取文件
+ * - key = fileId
+ */
+export const loadFileFromIndexedDb = async (
+    fileId: string
+): Promise<StoredFileRecord | null> => {
+    try {
+        const db = await openFileDb();
+        const tx = db.transaction(STORE_NAME, "readonly");
+        const store = tx.objectStore(STORE_NAME);
+
+        const request = store.get(fileId);
+
+        const record = await new Promise<StoredFileRecord | null>(
+            (resolve, reject) => {
+                request.onsuccess = () => {
+                    const result = request.result as StoredFileRecord | undefined;
+                    if (result) {
+                        console.debug(
+                            "[fileStorage] Loaded file from IndexedDB:",
+                            fileId,
+                            "size=",
+                            result.size,
+                            "type=",
+                            result.type
+                        );
+                    } else {
+                        console.debug(
+                            "[fileStorage] No local file found in IndexedDB for id:",
+                            fileId
+                        );
+                    }
+                    resolve(result ?? null);
+                };
+                request.onerror = () => {
+                    console.error(
+                        "[fileStorage] Failed to load file from IndexedDB:",
+                        fileId,
+                        request.error
+                    );
+                    reject(request.error);
+                };
+            }
+        );
+
+        return record ?? null;
+    } catch (err) {
+        console.warn(
+            "[fileStorage] loadFileFromIndexedDb error, treat as cache miss:",
+            err
+        );
+        return null;
+    }
+};
+
+/**
+ * 从 IndexedDB 中删除文件
+ * - key = fileId
+ */
+export const deleteFileFromIndexedDb = async (fileId: string): Promise<void> => {
+    try {
+        const db = await openFileDb();
+        const tx = db.transaction(STORE_NAME, "readwrite");
+        const store = tx.objectStore(STORE_NAME);
+
+        const request = store.delete(fileId);
+
+        await new Promise<void>((resolve, reject) => {
+            request.onsuccess = () => {
+                console.debug("[fileStorage] Deleted file from IndexedDB:", fileId);
+                resolve();
+            };
+            request.onerror = () => {
+                console.error(
+                    "[fileStorage] Failed to delete file from IndexedDB:",
+                    fileId,
+                    request.error
+                );
+                reject(request.error);
+            };
+        });
+
+        await new Promise<void>((resolve, reject) => {
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            tx.onabort = () => reject(tx.error);
+        });
+    } catch (err) {
+        console.warn("[fileStorage] deleteFileFromIndexedDb error:", err);
+    }
+};

package/database/fileUrl.ts

@@ -0,0 +1,34 @@
+import { API_ENDPOINTS } from "./config";
+
+const normalizeServerOrigin = (
+  serverOrigin: string | undefined | null
+): string => {
+  if (typeof serverOrigin !== "string") return "";
+  return serverOrigin.trim().replace(/\/+$/, "");
+};
+
+const normalizeFileId = (fileId: string | undefined | null): string => {
+  if (typeof fileId !== "string") return "";
+  return fileId.trim();
+};
+
+export const buildDatabaseFileContentUrl = (
+  serverOrigin: string | undefined | null,
+  fileId: string | undefined | null
+): string | null => {
+  const normalizedServer = normalizeServerOrigin(serverOrigin);
+  const normalizedFileId = normalizeFileId(fileId);
+
+  if (!normalizedServer || !normalizedFileId) {
+    return null;
+  }
+
+  return `${normalizedServer}${API_ENDPOINTS.DATABASE}/file/content/${normalizedFileId}`;
+};
+
+export const isLocalDatabaseFileContentUrl = (
+  url: string | null | undefined
+): boolean => {
+  if (typeof url !== "string" || !url) return false;
+  return url.includes("localhost") || url.includes("127.0.0.1");
+};