@interncom/diplomatic 0.0.35 → 0.0.37

package/dist/idbStore.d.ts

@@ -28,6 +28,7 @@ declare class IDBStore implements IClientStateStore {
     numDownloads: () => Promise<number>;
     storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
     clearOp: (sha256: Uint8Array) => Promise<void>;
+    hasOp: (sha256: Uint8Array) => Promise<boolean>;
 }
 export declare const idbStore: IDBStore;
 export {};

package/dist/index.mjs

@@ -199,6 +199,10 @@ var LocalStorageStore = class {
     const hex = btoh(sha256);
     this.ops.delete(hex);
   };
+  hasOp = async (sha256) => {
+    const hex = btoh(sha256);
+    return this.ops.has(hex);
+  };
 };
 var localStorageStore = new LocalStorageStore();
 
@@ -501,18 +505,21 @@ var IDBStore = class {
     await db.put("metaKV", str, "lastFetchedAt");
   }
   enqueueUpload = async (sha256, cipherOp) => {
-    await db.put("uploadQueue", { sha256, cipherOp });
+    const hex = btoh(sha256);
+    await db.put("uploadQueue", { sha256: hex, cipherOp });
   };
   dequeueUpload = async (sha256) => {
-    await db.delete("uploadQueue", sha256);
+    const hex = btoh(sha256);
+    await db.delete("uploadQueue", hex);
   };
   peekUpload = async (sha256) => {
-    const row = await db.get("uploadQueue", sha256);
+    const hex = btoh(sha256);
+    const row = await db.get("uploadQueue", hex);
     return row?.cipherOp;
   };
   listUploads = async () => {
-    const sha256s = await db.getAllKeys("uploadQueue");
-    return sha256s;
+    const hexes = await db.getAllKeys("uploadQueue");
+    return hexes.map(htob);
   };
   numUploads = async () => {
     const num = await db.count("uploadQueue");
@@ -520,24 +527,33 @@ var IDBStore = class {
   };
   downloadQueue = /* @__PURE__ */ new Set();
   enqueueDownload = async (sha256, recordedAt) => {
-    await db.put("downloadQueue", { sha256, recordedAt });
+    const hex = btoh(sha256);
+    await db.put("downloadQueue", { sha256: hex, recordedAt });
   };
   dequeueDownload = async (sha256) => {
-    await db.delete("downloadQueue", sha256);
+    const hex = btoh(sha256);
+    await db.delete("downloadQueue", hex);
   };
   listDownloads = async () => {
     const list = await db.getAll("downloadQueue");
-    return list;
+    return list.map((item) => ({ sha256: htob(item.sha256), recordedAt: item.recordedAt }));
   };
   numDownloads = async () => {
     const num = await db.count("downloadQueue");
     return num;
   };
   storeOp = async (sha256, cipherOp) => {
-    await db.put("ops", { sha256, cipherOp });
+    const hex = btoh(sha256);
+    await db.put("ops", { sha256: hex, cipherOp });
   };
   clearOp = async (sha256) => {
-    await db.delete("ops", sha256);
+    const hex = btoh(sha256);
+    await db.delete("ops", hex);
+  };
+  hasOp = async (sha256) => {
+    const hex = btoh(sha256);
+    const op = await db.get("ops", hex);
+    return op !== void 0;
   };
 };
 var idbStore = new IDBStore();
@@ -8983,7 +8999,7 @@ var DiplomaticClient = class {
       return [];
     }
     const lastFetchedAt = await this.store.getLastFetchedAt();
-    const begin = lastFetchedAt ?? /* @__PURE__ */ new Date(0);
+    const begin = /* @__PURE__ */ new Date(0);
     const { hostURL, hostKeyPair } = this;
     const resp = await api_default.listDeltas(hostURL, begin, hostKeyPair);
     for (const item of resp.deltas) {
@@ -9000,13 +9016,19 @@ var DiplomaticClient = class {
     const items = await this.store.listDownloads();
     items.sort((i1, i2) => i1.recordedAt.getTime() - i2.recordedAt.getTime());
     for (const item of items) {
-      const cipher = await api_default.getDelta(hostURL, item.sha256, hostKeyPair);
-      const packed = await crypto_default.decryptXSalsa20Poly1305Combined(cipher, encKey);
-      const op = decode(packed);
+      if (await this.store.hasOp(item.sha256)) {
+        console.log("already got it skipping");
+        await this.store.dequeueDownload(item.sha256);
+        this.emitUpdate();
+        continue;
+      }
       try {
+        const cipher = await api_default.getDelta(hostURL, item.sha256, hostKeyPair);
+        const packed = await crypto_default.decryptXSalsa20Poly1305Combined(cipher, encKey);
+        const op = decode(packed);
         const sha256 = await crypto_default.sha256Hash(cipher);
-        await this.store.storeOp(sha256, cipher);
         await this.stateManager.apply(op);
+        await this.store.storeOp(sha256, cipher);
         await this.store.dequeueDownload(sha256);
         this.emitUpdate();
       } catch {
@@ -9045,11 +9067,11 @@ var DiplomaticClient = class {
     const packed = encode(op);
     const cipherOp = await crypto_default.encryptXSalsa20Poly1305Combined(packed, this.encKey);
     const sha256 = await crypto_default.sha256Hash(cipherOp);
-    await this.store.storeOp(sha256, cipherOp);
     await this.store.enqueueUpload(sha256, cipherOp);
     this.emitUpdate();
     try {
       await this.stateManager.apply(op);
+      await this.store.storeOp(sha256, cipherOp);
     } catch (err) {
       await this.store.dequeueUpload(sha256);
       this.emitUpdate();

package/dist/localStorageStore.d.ts

@@ -26,6 +26,7 @@ declare class LocalStorageStore implements IClientStateStore {
     ops: Map<string, Uint8Array>;
     storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
     clearOp: (sha256: Uint8Array) => Promise<void>;
+    hasOp: (sha256: Uint8Array) => Promise<boolean>;
 }
 export declare const localStorageStore: LocalStorageStore;
 export {};

package/dist/memoryStore.d.ts

@@ -30,6 +30,7 @@ declare class MemoryStore implements IClientStateStore {
     ops: Map<string, Uint8Array>;
     storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
     clearOp: (sha256: Uint8Array) => Promise<void>;
+    hasOp: (sha256: Uint8Array) => Promise<boolean>;
 }
 export declare const memoryStore: MemoryStore;
 export {};

package/dist/types.d.ts

@@ -21,6 +21,7 @@ export interface IClientStateStore {
     numDownloads: () => Promise<number>;
     storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
     clearOp: (sha256: Uint8Array) => Promise<void>;
+    hasOp: (sha256: Uint8Array) => Promise<boolean>;
 }
 export interface IDiplomaticClientState {
     hasSeed: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interncom/diplomatic",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "type": "module",
   "description": "Secure sync layer",
   "main": "dist/index.mjs",