nolo-cli 0.1.31 → 0.1.33

package/database/dbSlice.ts

@@ -1,149 +0,0 @@
-// 文件路径: 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

@@ -1,42 +0,0 @@
-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

@@ -1,51 +0,0 @@
-// 文件路径: 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

@@ -1,70 +0,0 @@
-// 文件路径: 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

@@ -1,92 +0,0 @@
-
-/**
- * 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

@@ -1,232 +0,0 @@
-// 文件路径: 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

@@ -1,34 +0,0 @@
-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");
-};