@interncom/diplomatic 0.0.75 → 0.1.1

package/README.md

@@ -5,14 +5,19 @@ Secure sync layer for web apps.
 ## Usage
 
 ```tsx
-import { StateManager, useStateWatcher, localStorageStore, DiplomaticClient } from '@interncom/diplomatic'
+import {
+  DiplomaticClient,
+  localStorageStore,
+  StateManager,
+  useStateWatcher,
+} from "@interncom/diplomatic";
 
 const appState = { count: 0 };
 const stateMgr = new StateManager(async (op) => {
   if (op.type === "count" && typeof op.body === "number") {
     appState.count = op.body;
   }
-})
+});
 
 const client = new DiplomaticClient({
   seed: "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
@@ -22,8 +27,8 @@ const client = new DiplomaticClient({
 });
 
 export default function App() {
-  const count = useStateWatcher(stateMgr, "count", () => appState.count)
-  const inc = () => client.upsert("count", count + 1)
+  const count = useStateWatcher(stateMgr, "count", () => appState.count);
+  const inc = () => client.upsert("count", count + 1);
 
   return (
     <div style={{ width: "100vw", textAlign: "center" }}>
@@ -31,10 +36,11 @@ export default function App() {
       <h2>{count}</h2>
       <button onClick={inc}>+1</button>
     </div>
-  )
+  );
 }
 ```
 
 ## Development
 
-To deploy npm package, from the `web` dir, run: `npm run build && npm run tsc && npm publish --public`.
+To deploy npm package, from the `web` dir, run:
+`npm run build && npm run tsc && npm publish --public`.

package/dist/client.d.ts

@@ -1,57 +1,45 @@
-import type { EntityID, GroupID, IOp, KeyPair } from "./shared/types";
-import type { IClientStateStore, IDiplomaticClientState, IDiplomaticClientXferState } from "./types";
-import type { StateManager } from "./state";
-import TypedEventEmitter from "./typedEventEmitter";
-export interface IDiplomaticClientParams {
-    store: IClientStateStore;
-    stateManager: StateManager;
-    seed?: string | Uint8Array;
-    hostURL?: string;
-    hostID?: string;
-}
-export default class DiplomaticClient {
-    store: IClientStateStore;
-    stateManager: StateManager;
-    stateEmitter: TypedEventEmitter<IDiplomaticClientState>;
-    xferStateEmitter: TypedEventEmitter<IDiplomaticClientXferState>;
-    seed?: Uint8Array;
-    encKey?: Uint8Array;
-    hostURL?: URL;
-    hostKeyPair?: KeyPair;
-    constructor(params: IDiplomaticClientParams);
-    addEventListener(func: (state: IDiplomaticClientState) => void): () => void;
-    addXferEventListener(func: (state: IDiplomaticClientXferState) => void): () => void;
-    wipe: () => Promise<void>;
-    websocket?: WebSocket;
-    connect: (hostURL: URL) => Promise<void>;
-    init(params: IDiplomaticClientParams): Promise<void>;
-    loadSeed(): Promise<void>;
-    setSeed(seed: Uint8Array): Promise<void>;
-    loadHost(): Promise<void>;
-    register(hostURL: string): Promise<void>;
-    disconnect: () => void;
-    registerAndConnect(hostURL: string): Promise<void>;
-    requeueAllOpsForUpload(): Promise<void>;
-    emitUpdate(): Promise<void>;
-    emitXferUpdate(): Promise<void>;
-    getState(): Promise<IDiplomaticClientState>;
-    getXferState(): Promise<IDiplomaticClientXferState>;
-    processOps(): Promise<void>;
-    pullOpPaths(): Promise<never[] | undefined>;
-    fetchAndExecQueuedOps(): Promise<never[] | undefined>;
-    private pushQueuedOp;
-    pushQueuedOps(): Promise<void>;
-    sync(): Promise<void>;
-    apply(op: IOp): Promise<void>;
-    export(filename: string, extension?: string): Promise<void>;
-    import: (file: File) => Promise<void>;
-    upsert<T>({ type, body, eid, gid, pid, version }: {
-        type: string;
-        body: T;
-        eid?: EntityID;
-        gid?: GroupID;
-        pid?: EntityID;
-        version?: number;
-    }): Promise<void>;
-    delete<T>(type: string, eid: Uint8Array, version?: number): Promise<void>;
+import DiplomaticClientAPI from "./shared/client";
+import { IClock } from "./shared/clock";
+import { Status } from "./shared/consts";
+import { EncodedMessage } from "./shared/message";
+import { EntityID, HostHandle, ICrypto, IHostConnectionInfo, IInsertParams, IMessageHead, ITransport, IUpsertParams, MasterSeed } from "./shared/types";
+import { ValStat } from "./shared/valstat";
+import { IClient, IDiplomaticClientState, IDiplomaticClientXferState, IStateEmitter, IStateManager, IStore } from "./types";
+export declare class SyncClient<Handle extends HostHandle> implements IClient<Handle> {
+    private clock;
+    private state;
+    private store;
+    private transport;
+    private crypto;
+    private forceSkewHandlingByDefault;
+    connections: Map<string, DiplomaticClientAPI<Handle>>;
+    private currentSync;
+    clientState: IStateEmitter<IDiplomaticClientState>;
+    xferState: IStateEmitter<IDiplomaticClientXferState>;
+    constructor(clock: IClock, state: IStateManager, store: IStore<Handle>, transport: (host: IHostConnectionInfo<Handle>) => ITransport, crypto?: ICrypto, forceSkewHandlingByDefault?: boolean);
+    private readonly SYNC_DEBOUNCE_DELAY_MS;
+    private syncTimeout;
+    setSeed(seed: MasterSeed): Promise<void>;
+    private getClientState;
+    private getXferState;
+    private apply;
+    insertRaw(bod: EncodedMessage): Promise<ValStat<IMessageHead>>;
+    upsertRaw(eid: EntityID, bod: EncodedMessage | undefined, force?: boolean): Promise<ValStat<IMessageHead>>;
+    insert<T = unknown>(op: IInsertParams<T>): Promise<ValStat<IMessageHead>>;
+    upsert<T = unknown>(op: IUpsertParams<T>, force?: boolean): Promise<ValStat<IMessageHead>>;
+    delete(eid: EntityID): Promise<ValStat<IMessageHead>>;
+    genEID(id?: Uint8Array): Promise<ValStat<EntityID>>;
+    sync(): Promise<Status>;
+    private doSync;
+    wipe(): Promise<void>;
+    import: (file: File, options?: {
+        onProgress?: (index: number, total: number, status: Status) => void;
+    }) => Promise<Status>;
+    private scheduleSync;
+    export(filename: string): Promise<Status.Success | import("./shared/valstat").StatusNOK>;
+    link(host: IHostConnectionInfo<Handle>, connect?: boolean): Promise<void>;
+    unlink(label: string): Promise<void>;
+    private connectToHost;
+    connect(listen?: boolean, sync?: boolean): Promise<void>;
+    disconnect: () => Promise<void>;
 }

package/dist/entdb/entdb.d.ts

@@ -0,0 +1,42 @@
+import { Status } from "../shared/consts";
+import { ValStat } from "../shared/valstat";
+import { EntityID, GroupID, IMsgEntBody, IOp } from "../shared/types";
+import { StateManager } from "../state.ts";
+export interface IEntity<T = unknown> extends Omit<IMsgEntBody<T>, "body"> {
+    eid: EntityID;
+    updatedAt: Date;
+    createdAt: Date;
+    ctr: number;
+    body: T;
+}
+export interface IDateRange {
+    start: Date;
+    end: Date;
+}
+export type EntitiesQuery = {
+    type: string;
+} | {
+    type: string;
+    gid: GroupID;
+} | {
+    type: string;
+    pid: EntityID;
+} | {
+    type: string;
+    updatedBetween: IDateRange;
+};
+export interface IEntDB {
+    apply: (ops: IOp[]) => Promise<{
+        stats: Status[];
+        types: Set<string>;
+    }>;
+    clear: () => Promise<Status>;
+    getEnt<T>(eid: EntityID): Promise<ValStat<IEntity<T> | undefined>>;
+    getEntities<T>(query: EntitiesQuery): Promise<ValStat<IEntity<T>[]>>;
+    countEntities({ type }: {
+        type: string;
+    }): Promise<ValStat<number>>;
+}
+export declare function entStateManager(edb: IEntDB): StateManager;
+export declare function applyOp(curr: IEntity | undefined, op: IOp): ValStat<IEntity | undefined>;
+export declare const nullEntDB: IEntDB;

package/dist/entdb/idb.d.ts

@@ -0,0 +1,28 @@
+import { Status } from "../shared/consts";
+import { EntityID, GroupID, IOp } from "../shared/types";
+import { ValStat } from "../shared/valstat.ts";
+import { EntitiesQuery, IEntDB, IEntity } from "./entdb";
+export declare const entityTableName = "entities";
+export declare const typeIndexName = "entity_type_created_at";
+export declare const typeUpdatedAtIndexName = "entity_type_updated_at";
+export declare const typeGroupIndexName = "entity_type_group_id";
+export declare const typeParentIndexName = "entity_type_parent_id";
+export declare class EntIDB implements IEntDB {
+    db: IDBDatabase | undefined;
+    init(): Promise<void>;
+    apply: (ops: IOp[]) => Promise<{
+        stats: Status[];
+        types: Set<string>;
+    }>;
+    clear(): Promise<Status>;
+    getEnt<T>(eid: EntityID): Promise<ValStat<IEntity<T> | undefined>>;
+    getAllOfTypeUpdatedBetween<T>(opType: string, start: Date, end: Date): Promise<ValStat<IEntity<T>[]>>;
+    getGroupMembers<T>(opType: string, gid: GroupID): Promise<ValStat<IEntity<T>[]>>;
+    getAllOfType<T>(opType: string): Promise<ValStat<IEntity<T>[]>>;
+    private getAllEntities;
+    getEntities<T>(query: EntitiesQuery): Promise<ValStat<IEntity<T>[]>>;
+    countEntities({ type }: {
+        type: string;
+    }): Promise<ValStat<number>>;
+}
+export declare function openEntIDB(): Promise<EntIDB>;

package/dist/entdb/memory.d.ts

@@ -0,0 +1,30 @@
+import { IEntDB, IEntity } from "./entdb";
+import { Status } from "../shared/consts";
+import { EntityID, GroupID, IOp } from "../shared/types";
+import { ValStat } from "../shared/valstat.ts";
+interface IDateRange {
+    start: Date;
+    end: Date;
+}
+type EntitiesQuery = {
+    type: string;
+    gid?: GroupID;
+    pid?: EntityID;
+    updatedBetween?: IDateRange;
+};
+export declare class EntDBMemory implements IEntDB {
+    ents: Map<string, IEntity>;
+    constructor(initEnts?: IEntity[]);
+    apply(ops: IOp[]): Promise<{
+        stats: Status[];
+        types: Set<string>;
+    }>;
+    clear(): Promise<Status>;
+    getEnt<T>(eid: EntityID): Promise<ValStat<IEntity<T> | undefined>>;
+    private getAllEntities;
+    getEntities<T>(query: EntitiesQuery): Promise<ValStat<IEntity<T>[]>>;
+    countEntities({ type }: {
+        type: string;
+    }): Promise<ValStat<number>>;
+}
+export {};

package/dist/events.d.ts

@@ -0,0 +1,18 @@
+import { IStateEmitter } from "./types";
+type TypedListener<T> = (data: T) => void;
+export declare class TypedEventEmitter<T> {
+    private listeners;
+    addEventListener(eventType: string, listener: TypedListener<T>): () => void;
+    removeEventListener(eventType: string, listener: TypedListener<T>): void;
+    emit(eventType: string, data: T): void;
+}
+export declare class StateEmitter<T> implements IStateEmitter<T> {
+    private getter;
+    static eventName: string;
+    emitter: TypedEventEmitter<T>;
+    constructor(getter: () => Promise<T>);
+    get: () => Promise<T>;
+    emit(): Promise<void>;
+    listen(func: (state: T) => void): () => void;
+}
+export {};

package/dist/index.d.ts

@@ -1,15 +1,23 @@
-import { useClientState, useClientXferState, useSyncOnResume } from "./react/useClient";
-import { opMapApplier, StateManager } from "./state";
-import { localStorageStore } from "./localStorageStore";
-import { idbStore } from "./idbStore";
-import type { IDiplomaticClientState } from "./types";
-import DiplomaticClient from "./client";
+import { SyncClient } from "./client";
 import libsodiumCrypto from "./crypto";
-import { btoh, htob } from "./shared/lib";
-import { type IOp, type IUpsertOp, Verb } from "./shared/types";
+import { EntitiesQuery, entStateManager, IEntDB, IEntity, nullEntDB } from "./entdb/entdb";
+import { EntIDB, openEntIDB } from "./entdb/idb";
+import { EntDBMemory } from "./entdb/memory";
+import { useClient, useClientState, useClientXferState, useSyncOnResume } from "./react/useClient";
 import useStateWatcher, { useStateWatcherSuspense } from "./react/useStateWatcher";
-import InitSeedView from "./react/initSeedView";
-import ClientStatusBar from "./react/statusBar";
-import * as EntityDB from "./entityDB";
-export { btoh, ClientStatusBar, DiplomaticClient, EntityDB, htob, idbStore, InitSeedView, libsodiumCrypto, localStorageStore, opMapApplier, StateManager, useClientState, useClientXferState, useStateWatcher, useStateWatcherSuspense, useSyncOnResume, Verb, };
-export type { IDiplomaticClientState, IOp, IUpsertOp };
+import { btoh, htob } from "./shared/binary";
+import { Clock } from "./shared/clock";
+import { genSingletonEID } from "./shared/codecs/eid";
+import { Status } from "./shared/consts";
+import { HTTPTransport } from "./shared/http";
+import { EntityID, GroupID, type IOp, MasterSeed } from "./shared/types";
+import { nullStateManager, StateManager } from "./state";
+import { IDBStore, openIDBStore } from "./stores/idb/store";
+import { MemoryStore } from "./stores/memory/store";
+import type { IDiplomaticClientState, IStateManager, IStore } from "./types";
+export declare function genWebClient(stateMgr: StateManager, url: URL): Promise<{
+    client: SyncClient<URL>;
+    setSeed: (seedHex: string) => Promise<void>;
+}>;
+export { btoh, Clock, EntDBMemory, EntIDB, EntitiesQuery, EntityID, entStateManager, genSingletonEID, GroupID, htob, HTTPTransport, IDBStore, IEntDB, IEntity, IStateManager, IStore, libsodiumCrypto, MasterSeed, MemoryStore, nullEntDB, nullStateManager, openEntIDB, openIDBStore, StateManager, Status, SyncClient, useClient, useClientState, useClientXferState, useStateWatcher, useStateWatcherSuspense, useSyncOnResume, };
+export type { IDiplomaticClientState, IOp };