nolo-cli 0.8.0 → 0.9.1

package/chunk-2EISRLRC.js

@@ -0,0 +1,238 @@
+import {
+  getRuntimeServerContext,
+  scheduleDeleteReplication
+} from "./chunk-EYEEHCU4.js";
+import {
+  fetchFromClientDb
+} from "./chunk-QYXLLLGL.js";
+import {
+  buildTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+
+// packages/database/fileStorage.ts
+var DB_NAME = "nolo-file-storage";
+var STORE_NAME = "files";
+var DB_VERSION = 1;
+var dbPromise = null;
+var openFileDb = () => {
+  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;
+};
+var saveFileToIndexedDb = async (fileId, file) => {
+  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 = {
+      id: fileId,
+      blob,
+      size: blob.size,
+      type: blob.type || "application/octet-stream",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const request = store.put(record);
+    await new Promise((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((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
+    );
+  }
+};
+var loadFileFromIndexedDb = async (fileId) => {
+  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(
+      (resolve, reject) => {
+        request.onsuccess = () => {
+          const result = request.result;
+          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;
+  }
+};
+var deleteFileFromIndexedDb = async (fileId) => {
+  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((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((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      tx.onabort = () => reject(tx.error);
+    });
+  } catch (err) {
+    console.warn("[fileStorage] deleteFileFromIndexedDb error:", err);
+  }
+};
+
+// packages/database/actions/remove.ts
+var removeAction = async (payload, thunkApi) => {
+  const { db: clientDb } = thunkApi.extra;
+  const dbKey = typeof payload === "string" ? payload : payload.dbKey;
+  const preferredServerOrigin = typeof payload === "string" ? void 0 : payload.preferredServerOrigin;
+  if (!clientDb) {
+    throw new Error("Client database is undefined in removeAction");
+  }
+  const state = thunkApi.getState();
+  const { currentServer, syncServers } = getRuntimeServerContext(state);
+  console.log("[removeAction] START", {
+    dbKey,
+    preferredServerOrigin,
+    currentServer,
+    syncServers,
+    hasToken: Boolean(state?.auth?.currentToken)
+  });
+  const localData = await fetchFromClientDb(clientDb, dbKey);
+  const hadLocalData = Boolean(localData);
+  console.log("[removeAction] replication inputs", {
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    hadLocalData
+  });
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  if (localData) {
+    if (localData.id && typeof localData.id === "string") {
+      void deleteFileFromIndexedDb(localData.id).catch((err) => {
+        console.warn("[removeAction] Failed to delete associated file:", localData.id, err);
+      });
+    }
+    await clientDb.put(dbKey, buildTombstoneRecord(localData, nowIso));
+  } else {
+    await clientDb.put(dbKey, buildTombstoneRecord({ dbKey }, nowIso));
+  }
+  scheduleDeleteReplication({
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    dbKey,
+    state,
+    onResult: (result) => {
+      if (result.failed.length > 0) {
+        console.warn("[removeAction] Server delete failures after local tombstone:", result.failed);
+      }
+    },
+    onError: (err) => {
+      console.warn("[removeAction] Background server delete error:", err);
+    }
+  });
+  return { dbKey };
+};
+
+export {
+  saveFileToIndexedDb,
+  loadFileFromIndexedDb,
+  deleteFileFromIndexedDb,
+  removeAction
+};