@interncom/diplomatic 0.0.28 → 0.0.33

package/dist/client.d.ts

@@ -16,7 +16,6 @@ export default class DiplomaticClient {
     encKey?: Uint8Array;
     hostURL?: URL;
     hostKeyPair?: KeyPair;
-    lastFetchedAt?: string;
     constructor(params: IDiplomaticClientParams);
     wipe: () => Promise<void>;
     websocket?: WebSocket;
@@ -37,5 +36,6 @@ export default class DiplomaticClient {
     pushQueuedOps(): Promise<void>;
     sync(): Promise<void>;
     apply(op: IOp): Promise<void>;
-    upsert<T>(type: string, body: T, version?: number): Promise<void>;
+    upsert<T>(type: string, body: T, eid?: Uint8Array, version?: number): Promise<void>;
+    delete<T>(type: string, eid: Uint8Array, version?: number): Promise<void>;
 }

package/dist/entityDB.d.ts

@@ -0,0 +1,23 @@
+import { type DBSchema } from 'idb';
+import { Applier } from './types';
+import { StateManager } from './state';
+export declare const entityTableName = "entities";
+export declare const typeIndexName = "entity_type";
+interface IEntityDB extends DBSchema {
+    entities: {
+        key: Uint8Array;
+        value: {
+            eid: Uint8Array;
+            type: string;
+            updatedAt: Date;
+            body: unknown;
+        };
+        indexes: {
+            "entity_type": "string";
+        };
+    };
+}
+export declare const db: import("idb").IDBPDatabase<IEntityDB>;
+export declare const applier: Applier;
+export declare const stateManager: StateManager;
+export {};

package/dist/idbStore.d.ts

@@ -3,6 +3,7 @@ declare class IDBStore implements IClientStateStore {
     seed?: Uint8Array;
     hostURL?: string;
     hostID?: string;
+    lastFetchedAt?: Date;
     wipe(): Promise<void>;
     getSeed(): Promise<Uint8Array | undefined>;
     setSeed(seed: Uint8Array): Promise<void>;
@@ -10,6 +11,8 @@ declare class IDBStore implements IClientStateStore {
     setHostURL(url: string): Promise<void>;
     getHostID(): Promise<string | undefined>;
     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>;

package/dist/index.d.ts

@@ -6,9 +6,10 @@ import type { IDiplomaticClientState } from "./types";
 import DiplomaticClient from "./client";
 import libsodiumCrypto from "./crypto";
 import { btoh, htob } from "./shared/lib";
-import { type IOp, Verb } from "./shared/types";
+import { type IOp, type IUpsertOp, Verb } from "./shared/types";
 import useStateWatcher from "./react/useStateWatcher";
 import InitSeedView from "./react/initSeedView";
 import ClientStatusBar from "./react/statusBar";
-export { useClientState, useSyncOnResume, StateManager, useStateWatcher, opMapApplier, localStorageStore, idbStore, DiplomaticClient, libsodiumCrypto, btoh, htob, Verb, InitSeedView, ClientStatusBar, };
-export type { IOp, IDiplomaticClientState, };
+import * as EntityDB from "./entityDB";
+export { useClientState, useSyncOnResume, StateManager, useStateWatcher, opMapApplier, localStorageStore, idbStore, DiplomaticClient, libsodiumCrypto, btoh, htob, Verb, InitSeedView, ClientStatusBar, EntityDB, };
+export type { IOp, IUpsertOp, IDiplomaticClientState, };

package/dist/index.mjs

@@ -69,8 +69,8 @@ var StateManager = class {
   emitter = new EventEmitter();
   applier;
   clear;
-  constructor(applier, clear) {
-    this.applier = applier;
+  constructor(applier2, clear) {
+    this.applier = applier2;
     this.clear = clear;
   }
   apply = async (op) => {
@@ -86,9 +86,9 @@ var StateManager = class {
 };
 function opMapApplier(appliers) {
   return async (op) => {
-    const applier = appliers[op.type];
-    if (applier?.check(op)) {
-      await applier.apply(op);
+    const applier2 = appliers[op.type];
+    if (applier2?.check(op)) {
+      await applier2.apply(op);
     }
   };
 }
@@ -113,6 +113,7 @@ function htob(hex) {
 var seedKey = "seedHex";
 var hostURLKey = "hostURL";
 var hostIDKey = "hostID";
+var lastFetchedAtKey = "lastFetchedAt";
 var LocalStorageStore = class {
   async wipe() {
     localStorage.clear();
@@ -140,6 +141,17 @@ var LocalStorageStore = class {
   async setHostID(id) {
     return localStorage.setItem(hostIDKey, id);
   }
+  async getLastFetchedAt() {
+    const res = localStorage.getItem(lastFetchedAtKey);
+    if (!res) {
+      return;
+    }
+    return new Date(res);
+  }
+  async setLastFetchedAt(ts) {
+    const str = ts.toISOString();
+    localStorage.setItem(lastFetchedAtKey, str);
+  }
   uploadQueue = /* @__PURE__ */ new Map();
   enqueueUpload = async (sha256, cipherOp) => {
     this.uploadQueue.set(sha256, cipherOp);
@@ -312,11 +324,11 @@ function openDB(name, version, { blocked, upgrade, blocking, terminated } = {})
       event
     ));
   }
-  openPromise.then((db2) => {
+  openPromise.then((db3) => {
     if (terminated)
-      db2.addEventListener("close", () => terminated());
+      db3.addEventListener("close", () => terminated());
     if (blocking) {
-      db2.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+      db3.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
     }
   }).catch(() => {
   });
@@ -409,12 +421,12 @@ replaceTraps((oldTraps) => ({
 
 // src/idbStore.ts
 var db = await openDB("client-store-db", 2, {
-  upgrade(db2) {
-    db2.createObjectStore("metaKV");
-    db2.createObjectStore("uploadQueue", {
+  upgrade(db3) {
+    db3.createObjectStore("metaKV");
+    db3.createObjectStore("uploadQueue", {
       keyPath: "sha256"
     });
-    db2.createObjectStore("downloadQueue", {
+    db3.createObjectStore("downloadQueue", {
       keyPath: "path"
     });
   }
@@ -423,6 +435,7 @@ var IDBStore = class {
   seed;
   hostURL;
   hostID;
+  lastFetchedAt;
   async wipe() {
     await db.clear("metaKV");
     await db.clear("uploadQueue");
@@ -455,6 +468,17 @@ var IDBStore = class {
   async setHostID(id) {
     await db.put("metaKV", id, "hostID");
   }
+  async getLastFetchedAt() {
+    const res = await db.get("metaKV", "lastFetchedAt");
+    if (!res) {
+      return;
+    }
+    return new Date(res);
+  }
+  async setLastFetchedAt(ts) {
+    const str = ts.toISOString();
+    await db.put("metaKV", str, "lastFetchedAt");
+  }
   uploadQueue = /* @__PURE__ */ new Map();
   enqueueUpload = async (sha256, cipherOp) => {
     await db.put("uploadQueue", { sha256, cipherOp });
@@ -8578,6 +8602,9 @@ var LibsodiumCrypto = class {
   constructor(sodium) {
     this.sodium = sodium;
   }
+  async gen128BitRandomID() {
+    return this.sodium.randombytes_buf(16);
+  }
   async gen256BitSecureRandomSeed() {
     return this.sodium.crypto_secretbox_keygen();
   }
@@ -8759,8 +8786,9 @@ var Verb = /* @__PURE__ */ ((Verb2) => {
 })(Verb || {});
 
 // ../shared/ops.ts
-function genUpsertOp(type, body, version = 0) {
+function genUpsertOp(eid, type, body, version = 0) {
   return {
+    eid,
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     type,
     verb: 1 /* UPSERT */,
@@ -8768,6 +8796,15 @@ function genUpsertOp(type, body, version = 0) {
     body
   };
 }
+function genDeleteOp(eid, type, version = 0) {
+  return {
+    eid,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    type,
+    verb: 0 /* DELETE */,
+    ver: version
+  };
+}
 
 // src/client.ts
 var DiplomaticClient = class {
@@ -8778,7 +8815,6 @@ var DiplomaticClient = class {
   encKey;
   hostURL;
   hostKeyPair;
-  lastFetchedAt;
   constructor(params) {
     this.store = params.store;
     this.stateManager = params.stateManager;
@@ -8789,7 +8825,6 @@ var DiplomaticClient = class {
     this.encKey = void 0;
     this.hostURL = void 0;
     this.hostKeyPair = void 0;
-    this.lastFetchedAt = void 0;
     this.websocket?.close();
     this.websocket = void 0;
     await this.stateManager.clear();
@@ -8920,7 +8955,8 @@ var DiplomaticClient = class {
     if (!this.hostURL || !this.hostKeyPair || !this.encKey) {
       return [];
     }
-    const begin = new Date(this.lastFetchedAt ?? 0);
+    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;
@@ -8928,7 +8964,7 @@ var DiplomaticClient = class {
       await this.store.enqueueDownload(path);
       this.emitUpdate();
     }
-    this.lastFetchedAt = pathResp.fetchedAt;
+    await this.store.setLastFetchedAt(new Date(pathResp.fetchedAt));
   }
   async fetchAndExecQueuedOps() {
     if (!this.hostURL || !this.hostKeyPair || !this.encKey) {
@@ -8936,7 +8972,7 @@ var DiplomaticClient = class {
     }
     const { hostURL, hostKeyPair, encKey } = this;
     const paths = await this.store.listDownloads();
-    paths.sort((p1, p2) => p2.localeCompare(p1));
+    paths.sort((p1, p2) => p1.localeCompare(p2));
     for (const path of paths) {
       const cipher = await api_default.getDelta(hostURL, path, hostKeyPair);
       const packed = await crypto_default.decryptXSalsa20Poly1305Combined(cipher, encKey);
@@ -8986,7 +9022,7 @@ var DiplomaticClient = class {
     this.emitUpdate();
     try {
       await this.stateManager.apply(op);
-    } catch {
+    } catch (err) {
       await this.store.dequeueUpload(shaHex);
       this.emitUpdate();
     }
@@ -8996,8 +9032,13 @@ var DiplomaticClient = class {
       console.info("failed to push");
     }
   }
-  async upsert(type, body, version = 0) {
-    const op = genUpsertOp(type, body, version);
+  async upsert(type, body, eid, version = 0) {
+    const id = eid ?? await crypto_default.gen128BitRandomID();
+    const op = genUpsertOp(id, type, body, version);
+    return this.apply(op);
+  }
+  async delete(type, eid, version = 0) {
+    const op = genDeleteOp(eid, type, version);
     return this.apply(op);
   }
 };
@@ -9005,12 +9046,13 @@ var DiplomaticClient = class {
 // src/react/useStateWatcher.ts
 import { useState as useState2, useEffect as useEffect2 } from "react";
 function useStateWatcher(mgr, opType, callback) {
-  const [val, setVal] = useState2(callback());
+  const [val, setVal] = useState2();
   useEffect2(() => {
-    function update() {
-      const newVal = callback();
+    async function update() {
+      const newVal = await callback();
       setVal(newVal);
     }
+    update();
     mgr.on(opType, update);
     return () => {
       mgr.off(opType, update);
@@ -9089,9 +9131,44 @@ function ClientStatusBar({ state }) {
     }
   );
 }
+
+// src/entityDB.ts
+var entityDB_exports = {};
+__export(entityDB_exports, {
+  applier: () => applier,
+  db: () => db2,
+  entityTableName: () => entityTableName,
+  stateManager: () => stateManager,
+  typeIndexName: () => typeIndexName
+});
+var entityTableName = "entities";
+var typeIndexName = "entity_type";
+var db2 = await openDB("db", 4, {
+  upgrade(db3) {
+    const store = db3.createObjectStore("entities", { keyPath: "eid", autoIncrement: false });
+    store.createIndex("entity_type", "type");
+  }
+});
+var applier = async (op) => {
+  switch (op.verb) {
+    case 1 /* UPSERT */: {
+      const curr = await db2.get("entities", op.eid);
+      if (new Date(op.ts) > (curr?.updatedAt ?? "")) {
+        await db2.put("entities", { eid: op.eid, type: op.type, updatedAt: new Date(op.ts), body: op.body });
+      }
+      break;
+    }
+    case 0 /* DELETE */: {
+      await db2.delete("entities", op.eid);
+      break;
+    }
+  }
+};
+var stateManager = new StateManager(applier, () => db2.clear("entities"));
 export {
   ClientStatusBar,
   DiplomaticClient,
+  entityDB_exports as EntityDB,
   InitSeedView,
   StateManager,
   Verb,

package/dist/localStorageStore.d.ts

@@ -7,6 +7,8 @@ declare class LocalStorageStore implements IClientStateStore {
     setHostURL(url: string): Promise<void>;
     getHostID(): Promise<string | undefined>;
     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>;

package/dist/memoryStore.d.ts

@@ -3,6 +3,7 @@ declare class MemoryStore implements IClientStateStore {
     seed?: Uint8Array;
     hostURL?: string;
     hostID?: string;
+    lastFetchedAt?: Date;
     wipe(): Promise<void>;
     getSeed(): Promise<Uint8Array | undefined>;
     setSeed(seed: Uint8Array): Promise<void>;
@@ -10,6 +11,8 @@ declare class MemoryStore implements IClientStateStore {
     setHostURL(url: string): Promise<void>;
     getHostID(): Promise<string | undefined>;
     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>;

package/dist/react/useStateWatcher.d.ts

@@ -1,2 +1,2 @@
 import type { StateManager } from "../state";
-export default function useStateWatcher<T>(mgr: StateManager, opType: string, callback: () => T): T;
+export default function useStateWatcher<T>(mgr: StateManager, opType: string, callback: () => Promise<T>): T | undefined;

package/dist/shared/crypto/libsodium.d.ts

@@ -3,6 +3,7 @@ type Libsodium = any;
 export declare class LibsodiumCrypto implements ICrypto {
     sodium: Libsodium;
     constructor(sodium: Libsodium);
+    gen128BitRandomID(): Promise<Uint8Array>;
     gen256BitSecureRandomSeed(): Promise<Uint8Array>;
     deriveXSalsa20Poly1305Key(seed: Uint8Array): Promise<Uint8Array>;
     encryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;

package/dist/shared/ops.d.ts

@@ -1,3 +1,4 @@
-import { type IOp } from './types.ts';
-export declare function genUpsertOp<T>(type: string, body: T, version?: number): IOp;
+import { IDeleteOp, type IOp, IUpsertOp } from './types.ts';
+export declare function genUpsertOp<T>(eid: Uint8Array, type: string, body: T, version?: number): IUpsertOp;
+export declare function genDeleteOp<T>(eid: Uint8Array, type: string, version?: number): IDeleteOp;
 export declare function isOp(op: any): op is IOp;

package/dist/shared/types.d.ts

@@ -3,13 +3,20 @@ export declare enum Verb {
     UPSERT = 1
 }
 type Timestamp = string;
-export interface IOp {
+export interface IBaseOp {
+    eid: Uint8Array;
     ts: Timestamp;
     type: string;
-    verb: Verb;
     ver: number;
+}
+export interface IUpsertOp extends IBaseOp {
+    verb: Verb.UPSERT;
     body: unknown;
 }
+export interface IDeleteOp extends IBaseOp {
+    verb: Verb.DELETE;
+}
+export type IOp = IUpsertOp | IDeleteOp;
 export type CipherOp = Uint8Array;
 export interface ISyncRequest {
     ops: CipherOp[];
@@ -43,6 +50,7 @@ export interface IHostCrypto {
     sha256Hash: (data: Uint8Array) => Promise<Uint8Array>;
 }
 export interface ICrypto extends IHostCrypto {
+    gen128BitRandomID: () => Promise<Uint8Array>;
     gen256BitSecureRandomSeed: () => Promise<Uint8Array>;
     deriveXSalsa20Poly1305Key: (seed: Uint8Array, derivationIndex: number) => Promise<Uint8Array>;
     encryptXSalsa20Poly1305Combined: (plaintext: Uint8Array, key: Uint8Array) => Promise<Uint8Array>;

package/dist/types.d.ts

@@ -7,6 +7,8 @@ export interface IClientStateStore {
     setHostURL: (url: string) => Promise<void>;
     getHostID: () => Promise<string | undefined>;
     setHostID: (id: string) => Promise<void>;
+    setLastFetchedAt: (ts: Date) => Promise<void>;
+    getLastFetchedAt: () => Promise<Date | undefined>;
     wipe: () => Promise<void>;
     enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
     dequeueUpload: (sha256: string) => Promise<void>;

package/package.json

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