tool-db 2.3.1 → 2.5.0

package/lib/tooldb.ts

@@ -0,0 +1,314 @@
+import EventEmitter from "events";
+
+import {
+  VerificationData,
+  verifyMessage,
+  randomAnimal,
+  ToolDbOptions,
+  ToolDbNetworkAdapter,
+  ToolDbStorageAdapter,
+  ToolDbUserAdapter,
+  ToolDbMessage,
+  Peer,
+} from ".";
+
+import toolDbGet from "./toolDbGet";
+import toolDbPut from "./toolDbPut";
+import toolDbSignIn from "./toolDbSignIn";
+import toolDbSignUp from "./toolDbSignUp";
+import toolDbCrdtGet from "./toolDbCrdtGet";
+import toolDbCrdtPut from "./toolDbCrdtPut";
+
+import toolDbAnonSignIn from "./toolDbAnonSignIn";
+import toolDbClientOnMessage from "./toolDbClientOnMessage";
+import toolDbVerificationWrapper from "./toolDbVerificationWrapper";
+
+import toolDbQueryKeys from "./toolDbQueryKeys";
+import toolDbKeysSignIn from "./toolDbKeysSignIn";
+import toolDbSubscribe from "./toolDbSubscribe";
+
+import handleGet from "./messageHandlers/handleGet";
+import handlePut from "./messageHandlers/handlePut";
+import handlePing from "./messageHandlers/handlePing";
+import handlePong from "./messageHandlers/handlePong";
+import handleQuery from "./messageHandlers/handleQuery";
+import handleCrdtGet from "./messageHandlers/handleCrdtGet";
+import handleCrdtPut from "./messageHandlers/handleCrdtPut";
+import handleSubscribe from "./messageHandlers/handleSubscribe";
+
+import logger from "./logger";
+
+export interface Listener<T = any> {
+  key: string;
+  timeout: number | null;
+  fn: (msg: VerificationData<T>) => void;
+}
+
+interface Verificator<T> {
+  key: string;
+  fn: (
+    msg: VerificationData<T>,
+    previousData: T | undefined
+  ) => Promise<boolean>;
+}
+
+export default class ToolDb extends EventEmitter {
+  private _network;
+  private _store: ToolDbStorageAdapter;
+  private _serverPeers: Peer[] = [];
+  private _peerAccount: ToolDbUserAdapter;
+  private _userAccount: ToolDbUserAdapter;
+
+  public logger = logger;
+
+  public clientOnMessage = toolDbClientOnMessage;
+
+  public verifyMessage = verifyMessage;
+
+  private _subscriptions: string[] = [];
+
+  get subscriptions() {
+    return this._subscriptions;
+  }
+
+  private _processedIds: Record<string, string[]> = {};
+
+  get processedIds() {
+    return this._processedIds;
+  }
+
+  private _processedOutHashes: Record<string, string[]> = {};
+
+  get processedOutHashes() {
+    return this._processedOutHashes;
+  }
+
+  public subscribeData = toolDbSubscribe;
+
+  public isConnected = false;
+
+  /**
+   * Emitted after a disconnection, when there are no more peers connected to.
+   */
+  public onDisconnect = () => {
+    //
+  };
+
+  /**
+   * Emitted the first time we are connected to a peer.
+   */
+  public onConnect = () => {
+    //
+  };
+
+  public onPeerDisconnect = (peerId: string) => {
+    //
+  };
+
+  public onPeerConnect = (peerId: string) => {
+    //
+  };
+
+  public getData = toolDbGet;
+
+  public putData = toolDbPut;
+
+  public putCrdt = toolDbCrdtPut;
+
+  public getCrdt = toolDbCrdtGet;
+
+  public queryKeys = toolDbQueryKeys;
+
+  public signIn = toolDbSignIn;
+
+  public anonSignIn = toolDbAnonSignIn;
+
+  public keysSignIn = toolDbKeysSignIn;
+
+  public signUp = toolDbSignUp;
+
+  public verify = toolDbVerificationWrapper;
+
+  // All message handlers go here
+  public handlePing = handlePing;
+  public handlePong = handlePong;
+  public handleCrdtGet = handleCrdtGet;
+  public handleCrdtPut = handleCrdtPut;
+  public handleGet = handleGet;
+  public handlePut = handlePut;
+  public handleQuery = handleQuery;
+  public handleSubscribe = handleSubscribe;
+
+  /**
+   * id listeners listen for a specific message ID just once
+   */
+  public _idListeners: Record<string, (msg: ToolDbMessage) => void> = {};
+
+  public addIdListener = (id: string, fn: (msg: ToolDbMessage) => void) => {
+    this._idListeners[id] = fn;
+  };
+
+  public removeIdListener = (id: string) => {
+    delete this._idListeners[id];
+  };
+
+  public getUserNamespacedKey(key: string) {
+    return ":" + (this.userAccount?.getAddress() || "") + "." + key;
+  }
+
+  /**
+   * Key listeners listen for a specific key, as long as the listener remains active
+   */
+  public _keyListeners: (Listener | null)[] = [];
+
+  public addKeyListener = <T>(
+    key: string,
+    fn: (msg: VerificationData<T>) => void
+  ) => {
+    this.logger(`Add key listener: ${key}`);
+
+    const newListener: Listener = {
+      key,
+      timeout: null,
+      fn,
+    };
+    this._keyListeners.push(newListener);
+
+    return this._keyListeners.length - 1;
+  };
+
+  public removeKeyListener = (id: number) => {
+    if (this._keyListeners[id]?.timeout) {
+      clearTimeout(this._keyListeners[id]?.timeout || undefined);
+    }
+
+    this._keyListeners[id] = null;
+  };
+
+  public triggerKeyListener = <T = any>(
+    key: string,
+    message: VerificationData<T>
+  ) => {
+    this._keyListeners.forEach((listener) => {
+      if (listener?.key === key) {
+        this.logger(`Trigger key listener: ${key}`);
+        if (listener.timeout) {
+          clearTimeout(listener.timeout);
+        }
+        listener.timeout = setTimeout(
+          () => listener.fn(message),
+
+          this.options.triggerDebouce
+        ) as any;
+      }
+    });
+  };
+
+  /**
+   * Custom verificators can enhance default verification on any key field
+   */
+  public _customVerificator: (Verificator<any> | null)[] = [];
+
+  public addCustomVerification = <T = any>(
+    key: string,
+    fn: (msg: VerificationData<T>, previous: T | undefined) => Promise<boolean>
+  ) => {
+    const newListener: Verificator<T> = {
+      key,
+      fn,
+    };
+
+    this._customVerificator.push(newListener);
+    return this._customVerificator.length;
+  };
+
+  public removeCustomVerification = (id: number) => {
+    this._customVerificator[id] = null;
+  };
+
+  private _options: ToolDbOptions = {
+    peers: [],
+    maxRetries: 5,
+    triggerDebouce: 100,
+    wait: 2000,
+    pow: 0,
+    server: false,
+    host: "127.0.0.1",
+    port: 8080,
+    debug: false,
+    httpServer: undefined,
+    networkAdapter: ToolDbNetworkAdapter,
+    storageAdapter: ToolDbStorageAdapter,
+    userAdapter: ToolDbUserAdapter,
+    storageName: "tooldb",
+    topic: "tool-db-default",
+  };
+
+  get options() {
+    return this._options;
+  }
+
+  get network() {
+    return this._network;
+  }
+
+  get serverPeers() {
+    return this._serverPeers;
+  }
+
+  get store() {
+    return this._store;
+  }
+
+  get userAccount() {
+    return this._userAccount;
+  }
+
+  get peerAccount() {
+    return this._peerAccount;
+  }
+
+  constructor(options: Partial<ToolDbOptions> = {}) {
+    super();
+    this._options = { ...this.options, ...options };
+
+    this._store = new this.options.storageAdapter(this);
+    this._peerAccount = new this.options.userAdapter(this);
+    this._userAccount = new this.options.userAdapter(this);
+
+    this._network = new this.options.networkAdapter(this);
+
+    const DEFAULT_KEYS = "%default-peer%";
+
+    // DO NOT USE THE DEFAULT STORE FOR KEYS
+    const tempStore = new this.options.storageAdapter(
+      this,
+      "_____peer_" + this.options.storageName
+    );
+
+    tempStore
+      .get(DEFAULT_KEYS)
+      .then((val) => {
+        this.peerAccount
+          .decryptAccount(JSON.parse(val), DEFAULT_KEYS)
+          .then((a) => {
+            this.peerAccount.setUser(a, randomAnimal());
+          })
+          .finally(() => {
+            this.emit("init", this.userAccount.getAddress());
+          });
+      })
+      .catch((_e) => {
+        this.peerAccount.encryptAccount(DEFAULT_KEYS).then((a) => {
+          tempStore
+            .put(DEFAULT_KEYS, JSON.stringify(a))
+            .catch(() => {
+              // nothing
+            })
+            .finally(() => {
+              this.emit("init", this.userAccount.getAddress());
+            });
+        });
+      });
+  }
+}

package/lib/types/message.ts

@@ -0,0 +1,133 @@
+import { Peer } from "..";
+
+export enum VerifyResult {
+  CustomVerificationFailed = "CustomVerificationFailed",
+  InvalidData = "InvalidData",
+  InvalidVerification = "InvalidVerification",
+  CantOverwrite = "CantOverwrite",
+  InvalidTimestamp = "InvalidTimestamp",
+  AddressMismatch = "AddressMismatch",
+  NoProofOfWork = "NoProofOfWork",
+  InvalidHashNonce = "InvalidHashNonce",
+  InvalidSignature = "InvalidSignature",
+  Verified = "Verified",
+}
+
+export interface VerificationData<T = any> {
+  /**
+   * Key/id
+   */
+  k: string;
+  /**
+   * Address
+   */
+  a: string;
+  /**
+   * Nonce
+   */
+  n: number;
+  /**
+   * Hash of JSON.stringify(value) + nonce
+   */
+  h: string;
+  /**
+   * Timestamp this was created
+   */
+  t: number;
+  /**
+   * Signature
+   */
+  s: string;
+  /**
+   * Value
+   */
+  v: T;
+  /**
+   * CRDT type (null for regular values)
+   */
+  c: string | null;
+}
+
+export type MessageType =
+  | "ping"
+  | "pong"
+  | "query"
+  | "queryAck"
+  | "subscribe"
+  | "get"
+  | "put"
+  | "crdtPut"
+  | "crdtGet"
+  | "crdt";
+
+export interface BaseMessage {
+  type: MessageType;
+  /**
+   * Unique random id for the message, to ack back
+   */
+  id: string;
+  /**
+   * Who was this message sent to already
+   */
+  to: string[];
+}
+
+export interface PingMessage extends BaseMessage {
+  type: "ping";
+  isServer: boolean;
+  clientId: string;
+  peer: Peer;
+}
+
+export interface PongMessage extends BaseMessage {
+  type: "pong";
+  isServer: boolean;
+  clientId: string;
+  servers: Peer[];
+}
+
+export interface QueryMessage extends BaseMessage {
+  type: "query";
+  key: string; // key we want to get
+}
+
+export interface QueryAckMessage extends BaseMessage {
+  type: "queryAck";
+  keys: string[];
+}
+
+export interface SubscribeMessage extends BaseMessage {
+  type: "subscribe";
+  key: string;
+}
+
+export interface GetMessage extends BaseMessage {
+  type: "get";
+  key: string; // key we want to get
+}
+
+export interface PutMessage<T = any> extends BaseMessage {
+  type: "put";
+  data: VerificationData<T>;
+}
+
+export interface CrdtPutMessage<T = any> extends BaseMessage {
+  type: "crdtPut";
+  data: VerificationData<T>;
+}
+
+export interface CrdtGetMessage<T = any> extends BaseMessage {
+  type: "crdtGet";
+  key: string;
+}
+
+export type ToolDbMessage =
+  | PingMessage
+  | PongMessage
+  | QueryMessage
+  | QueryAckMessage
+  | SubscribeMessage
+  | GetMessage
+  | PutMessage
+  | CrdtPutMessage
+  | CrdtGetMessage;

package/lib/types/tooldb.ts

@@ -0,0 +1,89 @@
+import { Server as HTTPServer } from "http";
+import { Server as HTTPSServer } from "https";
+
+import {
+  ToolDb,
+  ToolDbMessage,
+  ToolDbNetworkAdapter,
+  ToolDbStorageAdapter,
+  ToolDbUserAdapter,
+} from "..";
+
+export interface Peer {
+  topic: string;
+  timestamp: number;
+  host: string;
+  port: number;
+  address: string;
+  sig: string;
+}
+
+export type ToolDbMessageHandler = (
+  this: ToolDb,
+  message: ToolDbMessage,
+  remotePeerId: string
+) => void;
+
+export interface ToolDbOptions {
+  /**
+   * Show debug console logs
+   */
+  debug: boolean;
+  /**
+   * Array of peers to connect to
+   */
+  peers: { host: string; port: number }[];
+  /**
+   * Max number of tries when a connection fails
+   */
+  maxRetries: number;
+  /**
+   * How long to wait (max) for a debounced key listener recv
+   */
+  triggerDebouce: number;
+  /**
+   * How long to wait between retries
+   */
+  wait: number;
+  /**
+   * Port to listen incoming connections (server only)
+   */
+  pow: number;
+  /**
+   * Whether we are a server or not
+   */
+  server: boolean;
+  /**
+   * A server instance like Express (server only)
+   */
+  httpServer: HTTPServer | HTTPSServer | undefined;
+  /**
+   * Our hostname (server only)
+   */
+  host: string;
+  /**
+   * Port to listen incoming connections (server only, default is 8080)
+   */
+  port: number;
+  /**
+   * Our storage namespace (default is "tooldb")
+   */
+  storageName: string;
+  /**
+   * A custom network adapter class
+   */
+  networkAdapter: typeof ToolDbNetworkAdapter;
+  /**
+   * A custom storage adapter function
+   */
+  storageAdapter: typeof ToolDbStorageAdapter;
+  /**
+   * A custom user storage and validation adapter class
+   */
+  userAdapter: typeof ToolDbUserAdapter;
+  /**
+   * The namespace/topic of our app (default is "tool-db-default")
+   */
+  topic: string;
+  // [extra: string]: any;
+}

package/lib/utils/catchReturn.ts

@@ -0,0 +1,4 @@
+export default function catchReturn(arg: any) {
+  // console.error(arg);
+  return undefined;
+}

package/lib/utils/encoding/arrayBufferToHex.ts

@@ -0,0 +1,18 @@
+export default function arrayBufferToHex(buffer: ArrayBuffer) {
+  const data_view = new DataView(buffer);
+  let iii;
+  let len;
+  let hex = "";
+  let c;
+
+  for (iii = 0, len = data_view.byteLength; iii < len; iii += 1) {
+    c = data_view.getUint8(iii).toString(16);
+    if (c.length < 2) {
+      c = "0" + c;
+    }
+
+    hex += c;
+  }
+
+  return hex.toLowerCase();
+}

package/lib/utils/encoding/arrayBufferToString.ts

@@ -0,0 +1,8 @@
+export default function arrayBufferToString(arr: ArrayBuffer) {
+  const byteArray = new Uint8Array(arr);
+  let byteString = "";
+  for (let i = 0; i < byteArray.byteLength; i += 1) {
+    byteString += String.fromCodePoint(byteArray[i]);
+  }
+  return byteString;
+}

package/lib/utils/encoding/hexToArrayBuffer.ts

@@ -0,0 +1,13 @@
+export default function hexToArrayBuffer(hex: string): ArrayBuffer {
+  const pairs = hex.toUpperCase().match(/[\dA-F]{2}/gi);
+
+  if (!pairs) return new Uint8Array();
+
+  // convert the octets to integers
+  const integers = pairs.map((s) => {
+    return parseInt(s, 16);
+  });
+
+  const array = new Uint8Array(integers);
+  return array.buffer;
+}

package/lib/utils/encoding/hexToString.ts

@@ -0,0 +1,8 @@
+export default function hexToString(hexString: string) {
+  const hex = hexString.toString();
+  let str = "";
+  for (let n = 0; n < hex.length; n += 2) {
+    str += String.fromCharCode(parseInt(hex.substr(n, 2), 16));
+  }
+  return str;
+}

package/lib/utils/encoding/hexToUint8.ts

@@ -0,0 +1,5 @@
+import { hexToArrayBuffer } from "../..";
+
+export default function hexToUint8(hex: string) {
+  return new Uint8Array(hexToArrayBuffer(hex));
+}

package/lib/utils/encoding/stringToArrayBuffer.ts

@@ -0,0 +1,8 @@
+export default function stringToArrayBuffer(str: string) {
+  const buf = new ArrayBuffer(str.length);
+  const bufView = new Uint8Array(buf);
+  for (let i = 0, strLen = str.length; i < strLen; i += 1) {
+    bufView[i] = str.charCodeAt(i);
+  }
+  return buf;
+}

package/lib/utils/getPeerSignature.ts

@@ -0,0 +1,12 @@
+import { ToolDbUserAdapter, sha256 } from "..";
+
+export default function getPeerSignature(
+  account: ToolDbUserAdapter,
+  topic: string,
+  timestamp: number,
+  host: string,
+  port: number
+) {
+  const dataToSign = sha256(`${topic}-${timestamp}-${host}:${port}`);
+  return account.signData(dataToSign);
+}

package/lib/utils/getTimestamp.ts

@@ -0,0 +1,3 @@
+export default function getTimestamp() {
+  return new Date().getTime();
+}

package/lib/utils/proofOfWork.ts

@@ -0,0 +1,16 @@
+import { sha256 } from "..";
+
+export default function proofOfWork(
+  value: string,
+  difficulty: number
+): Promise<{ nonce: number; hash: string }> {
+  return new Promise((resolve) => {
+    let nonce = 0;
+    let hash = sha256(`${value}${nonce}`);
+    while (hash.substring(0, difficulty) !== Array(difficulty + 1).join("0")) {
+      nonce += 1;
+      hash = sha256(`${value}${nonce}`);
+    }
+    resolve({ nonce, hash });
+  });
+}