@interncom/diplomatic 0.0.34 → 0.0.36

package/dist/idbStore.d.ts

@@ -13,17 +13,21 @@ declare class IDBStore implements IClientStateStore {
     setHostID(id: string): Promise<void>;
     getLastFetchedAt(): Promise<Date | undefined>;
     setLastFetchedAt(ts: Date): Promise<void>;
-    uploadQueue: Map<string, Uint8Array>;
-    enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
-    dequeueUpload: (sha256: string) => Promise<void>;
-    peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
-    listUploads: () => Promise<string[]>;
+    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
+    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
+    listUploads: () => Promise<Uint8Array[]>;
     numUploads: () => Promise<number>;
     downloadQueue: Set<string>;
-    enqueueDownload: (path: string) => Promise<void>;
-    dequeueDownload: (path: string) => Promise<void>;
-    listDownloads: () => Promise<string[]>;
+    enqueueDownload: (sha256: Uint8Array, recordedAt: Date) => Promise<void>;
+    dequeueDownload: (sha256: Uint8Array) => Promise<void>;
+    listDownloads: () => Promise<{
+        sha256: Uint8Array;
+        recordedAt: Date;
+    }[]>;
     numDownloads: () => Promise<number>;
+    storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    clearOp: (sha256: Uint8Array) => Promise<void>;
 }
 export declare const idbStore: IDBStore;
 export {};

package/dist/index.mjs

@@ -154,33 +154,51 @@ var LocalStorageStore = class {
   }
   uploadQueue = /* @__PURE__ */ new Map();
   enqueueUpload = async (sha256, cipherOp) => {
-    this.uploadQueue.set(sha256, cipherOp);
+    const hex = btoh(sha256);
+    this.uploadQueue.set(hex, cipherOp);
   };
   dequeueUpload = async (sha256) => {
-    this.uploadQueue.delete(sha256);
+    const hex = btoh(sha256);
+    this.uploadQueue.delete(hex);
   };
   peekUpload = async (sha256) => {
-    return this.uploadQueue.get(sha256);
+    const hex = btoh(sha256);
+    return this.uploadQueue.get(hex);
   };
   listUploads = async () => {
-    return Array.from(this.uploadQueue.keys());
+    const hexes = Array.from(this.uploadQueue.keys());
+    return hexes.map(htob);
   };
   numUploads = async () => {
     return this.uploadQueue.size;
   };
-  downloadQueue = /* @__PURE__ */ new Set();
-  enqueueDownload = async (path) => {
-    this.downloadQueue.add(path);
+  downloadQueue = /* @__PURE__ */ new Map();
+  enqueueDownload = async (sha256, recordedAt) => {
+    const hex = btoh(sha256);
+    this.downloadQueue.set(hex, recordedAt);
   };
-  dequeueDownload = async (path) => {
-    this.downloadQueue.delete(path);
+  dequeueDownload = async (sha256) => {
+    const hex = btoh(sha256);
+    this.downloadQueue.delete(hex);
   };
   listDownloads = async () => {
-    return Array.from(this.downloadQueue.keys());
+    const list = Array.from(this.downloadQueue.entries());
+    return list.map(([hex, recordedAt]) => {
+      return { sha256: htob(hex), recordedAt };
+    });
   };
   numDownloads = async () => {
     return this.downloadQueue.size;
   };
+  ops = /* @__PURE__ */ new Map();
+  storeOp = async (sha256, cipherOp) => {
+    const hex = btoh(sha256);
+    this.ops.set(hex, cipherOp);
+  };
+  clearOp = async (sha256) => {
+    const hex = btoh(sha256);
+    this.ops.delete(hex);
+  };
 };
 var localStorageStore = new LocalStorageStore();
 
@@ -420,14 +438,17 @@ replaceTraps((oldTraps) => ({
 }));
 
 // src/idbStore.ts
-var db = await openDB("client-store-db", 2, {
+var db = await openDB("client-store-db", 5, {
   upgrade(db3) {
     db3.createObjectStore("metaKV");
+    db3.createObjectStore("ops", {
+      keyPath: "sha256"
+    });
     db3.createObjectStore("uploadQueue", {
       keyPath: "sha256"
     });
     db3.createObjectStore("downloadQueue", {
-      keyPath: "path"
+      keyPath: "sha256"
     });
   }
 });
@@ -479,40 +500,52 @@ var IDBStore = class {
     const str = ts.toISOString();
     await db.put("metaKV", str, "lastFetchedAt");
   }
-  uploadQueue = /* @__PURE__ */ new Map();
   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");
     return num;
   };
   downloadQueue = /* @__PURE__ */ new Set();
-  enqueueDownload = async (path) => {
-    await db.put("downloadQueue", { path });
+  enqueueDownload = async (sha256, recordedAt) => {
+    const hex = btoh(sha256);
+    await db.put("downloadQueue", { sha256: hex, recordedAt });
   };
-  dequeueDownload = async (path) => {
-    await db.delete("downloadQueue", path);
+  dequeueDownload = async (sha256) => {
+    const hex = btoh(sha256);
+    await db.delete("downloadQueue", hex);
   };
   listDownloads = async () => {
-    const paths = await db.getAllKeys("downloadQueue");
-    return paths;
+    const list = await db.getAll("downloadQueue");
+    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) => {
+    const hex = btoh(sha256);
+    await db.put("ops", { sha256: hex, cipherOp });
+  };
+  clearOp = async (sha256) => {
+    const hex = btoh(sha256);
+    await db.delete("ops", hex);
+  };
 };
 var idbStore = new IDBStore();
 
@@ -8721,8 +8754,9 @@ var DiplomaticClientAPI = class {
     const opPath = await response.text();
     return opPath;
   }
-  async getDelta(hostURL, opPath, keyPair) {
+  async getDelta(hostURL, sha256, keyPair) {
     const url = new URL(hostURL);
+    const opPath = btoh(sha256);
     url.pathname = `/ops/${opPath}`;
     const sig = await this.crypto.signEd25519(opPath, keyPair.privateKey);
     const sigHex = btoh(sig);
@@ -8744,7 +8778,7 @@ var DiplomaticClientAPI = class {
     }
     return resp.cipher;
   }
-  async getDeltaPaths(hostURL, begin, keyPair) {
+  async listDeltas(hostURL, begin, keyPair) {
     const t = begin.toISOString();
     const path = `/ops?begin=${t}`;
     const url = new URL(hostURL);
@@ -8958,33 +8992,34 @@ var DiplomaticClient = class {
     const lastFetchedAt = await this.store.getLastFetchedAt();
     const begin = lastFetchedAt ?? /* @__PURE__ */ new Date(0);
     const { hostURL, hostKeyPair } = this;
-    const pathResp = await api_default.getDeltaPaths(hostURL, begin, hostKeyPair);
-    const paths = pathResp.paths;
-    for (const path of paths) {
-      await this.store.enqueueDownload(path);
+    const resp = await api_default.listDeltas(hostURL, begin, hostKeyPair);
+    for (const item of resp.deltas) {
+      await this.store.enqueueDownload(item.sha256, item.recordedAt);
       this.emitUpdate();
     }
-    await this.store.setLastFetchedAt(new Date(pathResp.fetchedAt));
+    await this.store.setLastFetchedAt(new Date(resp.fetchedAt));
   }
   async fetchAndExecQueuedOps() {
     if (!this.hostURL || !this.hostKeyPair || !this.encKey) {
       return [];
     }
     const { hostURL, hostKeyPair, encKey } = this;
-    const paths = await this.store.listDownloads();
-    paths.sort((p1, p2) => p1.localeCompare(p2));
-    for (const path of paths) {
-      const cipher = await api_default.getDelta(hostURL, path, hostKeyPair);
+    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);
       try {
+        const sha256 = await crypto_default.sha256Hash(cipher);
+        await this.store.storeOp(sha256, cipher);
         await this.stateManager.apply(op);
-        await this.store.dequeueDownload(path);
+        await this.store.dequeueDownload(sha256);
         this.emitUpdate();
       } catch {
         const transient = true;
         if (!transient) {
-          await this.store.dequeueDownload(path);
+          await this.store.dequeueDownload(item.sha256);
           this.emitUpdate();
         }
       }
@@ -9017,17 +9052,17 @@ var DiplomaticClient = class {
     const packed = encode(op);
     const cipherOp = await crypto_default.encryptXSalsa20Poly1305Combined(packed, this.encKey);
     const sha256 = await crypto_default.sha256Hash(cipherOp);
-    const shaHex = btoh(sha256);
-    await this.store.enqueueUpload(shaHex, cipherOp);
+    await this.store.storeOp(sha256, cipherOp);
+    await this.store.enqueueUpload(sha256, cipherOp);
     this.emitUpdate();
     try {
       await this.stateManager.apply(op);
     } catch (err) {
-      await this.store.dequeueUpload(shaHex);
+      await this.store.dequeueUpload(sha256);
       this.emitUpdate();
     }
     try {
-      await this.pushQueuedOp(shaHex);
+      await this.pushQueuedOp(sha256);
     } catch (err) {
       console.info("failed to push");
     }

package/dist/localStorageStore.d.ts

@@ -10,16 +10,22 @@ declare class LocalStorageStore implements IClientStateStore {
     getLastFetchedAt(): Promise<Date | undefined>;
     setLastFetchedAt(ts: Date): Promise<void>;
     uploadQueue: Map<string, Uint8Array>;
-    enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
-    dequeueUpload: (sha256: string) => Promise<void>;
-    peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
-    listUploads: () => Promise<string[]>;
+    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
+    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
+    listUploads: () => Promise<Uint8Array[]>;
     numUploads: () => Promise<number>;
-    downloadQueue: Set<string>;
-    enqueueDownload: (path: string) => Promise<void>;
-    dequeueDownload: (path: string) => Promise<void>;
-    listDownloads: () => Promise<string[]>;
+    downloadQueue: Map<string, Date>;
+    enqueueDownload: (sha256: Uint8Array, recordedAt: Date) => Promise<void>;
+    dequeueDownload: (sha256: Uint8Array) => Promise<void>;
+    listDownloads: () => Promise<{
+        sha256: Uint8Array;
+        recordedAt: Date;
+    }[]>;
     numDownloads: () => Promise<number>;
+    ops: Map<string, Uint8Array>;
+    storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    clearOp: (sha256: Uint8Array) => Promise<void>;
 }
 export declare const localStorageStore: LocalStorageStore;
 export {};

package/dist/memoryStore.d.ts

@@ -14,16 +14,22 @@ declare class MemoryStore implements IClientStateStore {
     getLastFetchedAt(): Promise<Date | undefined>;
     setLastFetchedAt(ts: Date): Promise<void>;
     uploadQueue: Map<string, Uint8Array>;
-    enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
-    dequeueUpload: (sha256: string) => Promise<void>;
-    peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
-    listUploads: () => Promise<string[]>;
+    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
+    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
+    listUploads: () => Promise<Uint8Array[]>;
     numUploads: () => Promise<number>;
-    downloadQueue: Set<string>;
-    enqueueDownload: (path: string) => Promise<void>;
-    dequeueDownload: (path: string) => Promise<void>;
-    listDownloads: () => Promise<string[]>;
+    downloadQueue: Map<string, Date>;
+    enqueueDownload: (sha256: Uint8Array, recordedAt: Date) => Promise<void>;
+    dequeueDownload: (sha256: Uint8Array) => Promise<void>;
+    listDownloads: () => Promise<{
+        sha256: Uint8Array;
+        recordedAt: Date;
+    }[]>;
     numDownloads: () => Promise<number>;
+    ops: Map<string, Uint8Array>;
+    storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    clearOp: (sha256: Uint8Array) => Promise<void>;
 }
 export declare const memoryStore: MemoryStore;
 export {};

package/dist/shared/client.d.ts

@@ -1,4 +1,4 @@
-import type { ICrypto, IGetDeltaPathsResponse, IMsgpackCodec, KeyPair } from "./types.ts";
+import type { ICrypto, IListDeltasResponse, IMsgpackCodec, KeyPair } from "./types.ts";
 export default class DiplomaticClientAPI {
     codec: IMsgpackCodec;
     crypto: ICrypto;
@@ -6,6 +6,6 @@ export default class DiplomaticClientAPI {
     getHostID(hostURL: URL): Promise<string>;
     register(hostURL: URL, pubKey: Uint8Array, token: string): Promise<void>;
     putDelta(hostURL: URL, cipherOp: Uint8Array, keyPair: KeyPair): Promise<string>;
-    getDelta(hostURL: URL, opPath: string, keyPair: KeyPair): Promise<Uint8Array>;
-    getDeltaPaths(hostURL: URL, begin: Date, keyPair: KeyPair): Promise<IGetDeltaPathsResponse>;
+    getDelta(hostURL: URL, sha256: Uint8Array, keyPair: KeyPair): Promise<Uint8Array>;
+    listDeltas(hostURL: URL, begin: Date, keyPair: KeyPair): Promise<IListDeltasResponse>;
 }

package/dist/shared/types.d.ts

@@ -29,16 +29,20 @@ export interface IRegistrationRequest {
 export interface IOperationRequest {
     cipher: Uint8Array;
 }
-export interface IGetDeltaPathsResponse {
-    paths: string[];
+export interface IDeltaListItem {
+    sha256: Uint8Array;
+    recordedAt: Date;
+}
+export interface IListDeltasResponse {
+    deltas: IDeltaListItem[];
     fetchedAt: string;
 }
 export interface IStorage {
     addUser: (pubKeyHex: string) => Promise<void>;
     hasUser: (pubKeyHex: string) => Promise<boolean>;
-    setOp: (pubKeyHex: string, path: string, op: Uint8Array) => Promise<void>;
-    getOp: (pubKeyHex: string, path: string) => Promise<Uint8Array | undefined>;
-    listOps: (pubKeyHex: string, begin: string, end: string) => Promise<string[]>;
+    setOp: (pubKeyHex: string, recordedAt: Date, op: Uint8Array) => Promise<void>;
+    getOp: (pubKeyHex: string, sha256Hex: string) => Promise<Uint8Array | undefined>;
+    listOps: (pubKeyHex: string, begin: string, end: string) => Promise<IDeltaListItem[]>;
 }
 export interface KeyPair {
     keyType: "public" | "private" | "secret";

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { IOp } from "./shared/types";
+import type { IDeltaListItem, IOp } from "./shared/types";
 export interface IClientStateStore {
     init?: () => Promise<void>;
     getSeed: () => Promise<Uint8Array | undefined>;
@@ -10,15 +10,17 @@ export interface IClientStateStore {
     setLastFetchedAt: (ts: Date) => Promise<void>;
     getLastFetchedAt: () => Promise<Date | undefined>;
     wipe: () => Promise<void>;
-    enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
-    dequeueUpload: (sha256: string) => Promise<void>;
-    peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
-    listUploads: () => Promise<string[]>;
+    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
+    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
+    listUploads: () => Promise<Uint8Array[]>;
     numUploads: () => Promise<number>;
-    enqueueDownload: (path: string) => Promise<void>;
-    dequeueDownload: (path: string) => Promise<void>;
-    listDownloads: () => Promise<string[]>;
+    enqueueDownload: (sha256: Uint8Array, recordedAt: Date) => Promise<void>;
+    dequeueDownload: (sha256: Uint8Array) => Promise<void>;
+    listDownloads: () => Promise<IDeltaListItem[]>;
     numDownloads: () => Promise<number>;
+    storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    clearOp: (sha256: Uint8Array) => Promise<void>;
 }
 export interface IDiplomaticClientState {
     hasSeed: boolean;

package/package.json

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