@interncom/diplomatic 0.0.9 → 0.0.11

package/dist/client.d.ts

@@ -26,11 +26,12 @@ export default class DiplomaticClient {
     loadHost(): Promise<void>;
     register(hostURL: string): Promise<void>;
     get state(): DiplomaticClientState;
-    private putDelta;
-    getDeltas(): Promise<IOp[]>;
-    processDeltas(): Promise<void>;
+    processOps(): Promise<void>;
+    pullOpPaths(): Promise<never[] | undefined>;
+    fetchAndExecQueuedOps(): Promise<never[] | undefined>;
     private pushQueuedOp;
     pushQueuedOps(): Promise<void>;
+    sync(): Promise<void>;
     apply(op: IOp): Promise<void>;
     upsert<T>(type: string, body: T, version?: number): Promise<void>;
 }

package/dist/index.mjs

@@ -80,6 +80,31 @@ function useStateWatcher(mgr, opType, callback) {
   return val;
 }
 
+// src/queue.ts
+var Queue = class {
+  map;
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  async enqueue(key, value) {
+    this.map.set(key, value);
+  }
+  async peek(key) {
+    return this.map.get(key);
+  }
+  async entries() {
+    return Array.from(this.map.entries());
+  }
+  async dequeue(key) {
+    const value = this.map.get(key);
+    this.map.delete(key);
+    return value;
+  }
+  async size() {
+    return this.map.size;
+  }
+};
+
 // ../shared/lib.ts
 function btoh(bytes) {
   const hex = Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -124,29 +149,8 @@ var LocalStorageStore = class {
   async setHostID(id) {
     return localStorage.setItem(hostIDKey, id);
   }
-  uploadQueue = /* @__PURE__ */ new Map();
-  enqueueUpload = async (sha256, cipherOp) => {
-    const hex = btoh(sha256);
-    this.uploadQueue.set(hex, cipherOp);
-  };
-  dequeueUpload = async (sha256) => {
-    const hex = btoh(sha256);
-    this.uploadQueue.delete(hex);
-  };
-  peekUpload = async (sha256) => {
-    const hex = btoh(sha256);
-    return this.uploadQueue.get(hex);
-  };
-  async listUploadQueue() {
-    return Array.from(this.uploadQueue.keys());
-  }
-  downloadQueue = /* @__PURE__ */ new Set();
-  enqueueDownload = async (path) => {
-    this.downloadQueue.add(path);
-  };
-  dequeueDownload = async (path) => {
-    this.downloadQueue.delete(path);
-  };
+  pushQueue = new Queue();
+  pullQueue = new Queue();
 };
 var localStorageStore = new LocalStorageStore();
 
@@ -8440,7 +8444,6 @@ var DiplomaticClient = class {
   constructor(params) {
     this.store = params.store;
     this.applier = params.stateManager.apply;
-    console.log("constructing");
     this.init(params);
   }
   websocket;
@@ -8466,7 +8469,7 @@ var DiplomaticClient = class {
     };
     this.websocket.onmessage = (e) => {
       console.log(`RECEIVED: ${e.data}`);
-      this.processDeltas();
+      this.processOps();
     };
     this.websocket.onerror = (e) => {
       console.log(`ERROR: ${e}`);
@@ -8490,7 +8493,7 @@ var DiplomaticClient = class {
     if (this.hostURL) {
       await this.connect(this.hostURL);
     }
-    await this.processDeltas();
+    await this.sync();
     this.listener?.(this.state);
   }
   async loadSeed() {
@@ -8540,53 +8543,65 @@ var DiplomaticClient = class {
     }
     return "ready";
   }
-  async putDelta(delta) {
-    if (!this.hostURL || !this.hostKeyPair || !this.encKey) {
-      return;
-    }
-    const packed = encode(delta);
-    const cipherOp = await crypto_default.encryptXSalsa20Poly1305Combined(packed, this.encKey);
-    await api_default.putDelta(this.hostURL, cipherOp, this.hostKeyPair);
+  async processOps() {
+    await this.pullOpPaths();
+    await this.fetchAndExecQueuedOps();
   }
-  async getDeltas() {
+  async pullOpPaths() {
     if (!this.hostURL || !this.hostKeyPair || !this.encKey) {
       return [];
     }
     const begin = new Date(this.lastFetchedAt ?? 0);
-    const { hostURL, hostKeyPair, encKey } = this;
+    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.pullQueue.enqueue(path, null);
+    }
     this.lastFetchedAt = pathResp.fetchedAt;
-    const deltas = await Promise.all(paths.map(async (path) => {
+  }
+  async fetchAndExecQueuedOps() {
+    if (!this.hostURL || !this.hostKeyPair || !this.encKey) {
+      return [];
+    }
+    const { hostURL, hostKeyPair, encKey } = this;
+    const entries = await this.store.pullQueue.entries();
+    const paths = entries.map(([path]) => path);
+    paths.sort((p1, p2) => p2.localeCompare(p1));
+    for (const path of paths) {
       const cipher = await api_default.getDelta(hostURL, path, hostKeyPair);
-      const deltaPack = await crypto_default.decryptXSalsa20Poly1305Combined(cipher, encKey);
-      const delta = decode(deltaPack);
-      return delta;
-    }));
-    return deltas;
-  }
-  async processDeltas() {
-    const deltas = await this.getDeltas();
-    for (const delta of deltas) {
-      await this.applier(delta);
+      const packed = await crypto_default.decryptXSalsa20Poly1305Combined(cipher, encKey);
+      const op = decode(packed);
+      try {
+        await this.applier(op);
+        this.store.pullQueue.dequeue(path);
+      } catch {
+        const transient = true;
+        if (!transient) {
+          this.store.pullQueue.dequeue(path);
+        }
+      }
     }
   }
   async pushQueuedOp(sha256) {
     if (!this.hostURL || !this.hostKeyPair) {
       return;
     }
-    const cipherOp = await this.store.peekUpload(sha256);
+    const cipherOp = await this.store.pushQueue.peek(sha256);
     if (cipherOp) {
       await api_default.putDelta(this.hostURL, cipherOp, this.hostKeyPair);
     }
-    await this.store.dequeueUpload(sha256);
+    await this.store.pushQueue.dequeue(sha256);
   }
   async pushQueuedOps() {
-    for (const sha256 of await this.store.listUploadQueue()) {
-      const bytes = htob(sha256);
-      await this.pushQueuedOp(bytes);
+    for (const [sha256] of await this.store.pushQueue.entries()) {
+      await this.pushQueuedOp(sha256);
     }
   }
+  async sync() {
+    await this.processOps();
+    await this.pushQueuedOps();
+  }
   async apply(op) {
     if (!this.encKey) {
       throw "No encryption key";
@@ -8594,13 +8609,14 @@ 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.enqueueUpload(sha256, cipherOp);
+    const shaHex = btoh(sha256);
+    await this.store.pushQueue.enqueue(shaHex, cipherOp);
     try {
       await this.applier(op);
     } catch {
-      await this.store.dequeueUpload(sha256);
+      await this.store.pushQueue.dequeue(shaHex);
     }
-    await this.pushQueuedOp(sha256);
+    await this.pushQueuedOp(shaHex);
   }
   async upsert(type, body, version = 0) {
     const op = genUpsertOp(type, body, version);

package/dist/localStorageStore.d.ts

@@ -1,3 +1,4 @@
+import { Queue } from "./queue";
 import type { IClientStateStore } from "./types";
 declare class LocalStorageStore implements IClientStateStore {
     getSeed(): Promise<Uint8Array | undefined>;
@@ -6,14 +7,8 @@ declare class LocalStorageStore implements IClientStateStore {
     setHostURL(url: string): Promise<void>;
     getHostID(): Promise<string | undefined>;
     setHostID(id: string): Promise<void>;
-    uploadQueue: Map<string, Uint8Array>;
-    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
-    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
-    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
-    listUploadQueue(): Promise<string[]>;
-    downloadQueue: Set<string>;
-    enqueueDownload: (path: string) => Promise<void>;
-    dequeueDownload: (path: string) => Promise<void>;
+    pushQueue: Queue<string, Uint8Array>;
+    pullQueue: Queue<string, null>;
 }
 export declare const localStorageStore: LocalStorageStore;
 export {};

package/dist/queue.d.ts

@@ -0,0 +1,10 @@
+import type { IQueue } from "./types";
+export declare class Queue<K, V> implements IQueue<K, V> {
+    private map;
+    constructor();
+    enqueue(key: K, value: V): Promise<void>;
+    peek(key: K): Promise<V | undefined>;
+    entries(): Promise<Array<[K, V]>>;
+    dequeue(key: K): Promise<V | undefined>;
+    size(): Promise<number>;
+}

package/dist/types.d.ts

@@ -1,4 +1,34 @@
 import type { IOp } from "./shared/types";
+export interface IQueue<K, V> {
+    /**
+     * Adds an entry to the queue.
+     * @param key - The key of the entry.
+     * @param value - The value of the entry.
+     */
+    enqueue(key: K, value: V): Promise<void>;
+    /**
+     * Returns the value of the entry with the specified key without removing it.
+     * @param key - The key of the entry.
+     * @returns The value of the entry if found, or undefined if the key does not exist.
+     */
+    peek(key: K): Promise<V | undefined>;
+    /**
+     * Returns an array of entries in the queue, allowing sorting and iteration over all entries.
+     * @returns An array of entries in the queue.
+     */
+    entries(): Promise<Array<[K, V]>>;
+    /**
+     * Removes the entry with the specified key from the queue.
+     * @param key - The key of the entry.
+     * @returns The value of the removed entry if found, or undefined if the key does not exist.
+     */
+    dequeue(key: K): Promise<V | undefined>;
+    /**
+     * Returns the number of entries in the queue.
+     * @returns The size of the queue.
+     */
+    size(): Promise<number>;
+}
 export interface IClientStateStore {
     init?: () => Promise<void>;
     getSeed: () => Promise<Uint8Array | undefined>;
@@ -7,12 +37,8 @@ export interface IClientStateStore {
     setHostURL: (url: string) => Promise<void>;
     getHostID: () => Promise<string | undefined>;
     setHostID: (id: string) => Promise<void>;
-    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
-    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
-    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
-    listUploadQueue: () => Promise<string[]>;
-    enqueueDownload: (path: string) => Promise<void>;
-    dequeueDownload: (path: string) => Promise<void>;
+    pushQueue: IQueue<string, Uint8Array>;
+    pullQueue: IQueue<string, null>;
 }
 export type DiplomaticClientState = "loading" | "seedless" | "hostless" | "ready";
 export type Applier = (op: IOp) => Promise<void>;

package/package.json

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