tool-db 2.3.1 → 2.5.0

package/lib/toolDbCrdtGet.ts

@@ -0,0 +1,82 @@
+import { textRandom, BaseCrdt, ToolDb, CrdtPutMessage } from ".";
+
+/**
+ * Triggers a GET request to other peers. If the data is available locally it will return that instead.
+ * @param key key of the data
+ * @param userNamespaced If this key bolongs to a user or its public. Making it private will enforce validation for our address and signatures.
+ * @param timeout Max time to wait for remote.
+ * @returns Promise<Data>
+ */
+export default function toolDbCrdtGet<T = any>(
+  this: ToolDb,
+  key: string,
+  crdt: BaseCrdt<T, any, any>,
+  userNamespaced = false,
+  timeoutMs = 1000
+): Promise<CrdtPutMessage<T> | null> {
+  return new Promise((resolve, reject) => {
+    if (userNamespaced && this.userAccount.getAddress() === undefined) {
+      reject(new Error("You are not authorized yet!"));
+      return;
+    }
+    const finalKey = userNamespaced
+      ? `:${this.userAccount.getAddress()}.${key}`
+      : key;
+    this.logger("CRDT GET", finalKey);
+
+    const msgId = textRandom(10);
+
+    const cancelTimeout = setTimeout(() => {
+      this.store
+        .get(finalKey)
+        .then((data) => {
+          try {
+            const message = JSON.parse(data);
+            crdt.mergeChanges(message.v);
+
+            this.emit("data", message);
+            resolve(message);
+          } catch (e) {
+            resolve(null);
+          }
+        })
+        .catch((e) => reject(null));
+    }, timeoutMs);
+
+    this.addIdListener(msgId, (msg) => {
+      this.logger("GET RECV", finalKey);
+
+      clearTimeout(cancelTimeout);
+      if (msg.type === "crdtPut") {
+        crdt.mergeChanges(msg.data.v);
+        resolve(msg);
+      }
+    });
+
+    this.store
+      .get(finalKey)
+      .then((data) => {
+        try {
+          const msg = JSON.parse(data);
+          clearTimeout(cancelTimeout);
+          this.removeIdListener(msgId);
+          crdt.mergeChanges(msg.v);
+          this.emit("data", msg);
+          resolve(msg);
+        } catch (e) {
+          // do nothing
+        }
+      })
+      .catch(() => {
+        // do nothing
+      });
+
+    // Do get
+    this.network.sendToAll({
+      type: "crdtGet",
+      to: [],
+      key: finalKey,
+      id: msgId,
+    });
+  });
+}

package/lib/toolDbCrdtPut.ts

@@ -0,0 +1,77 @@
+import {
+  ToolDb,
+  CrdtPutMessage,
+  textRandom,
+  VerificationData,
+  proofOfWork,
+  BaseCrdt,
+} from ".";
+
+/**
+ * Triggers a PUT request to other peers.
+ * @param key key where we want to put the data at.
+ * @param value Data we want to any (any type)
+ * @param userNamespaced If this key bolongs to a user or its public. Making it private will enforce validation for our address and signatures.
+ * @returns Promise<Data | null>
+ */
+export default function toolDbCrdtPut<T = any>(
+  this: ToolDb,
+  key: string,
+  crdt: BaseCrdt<T, any, any>,
+  userNamespaced = false
+): Promise<CrdtPutMessage | null> {
+  return new Promise((resolve, reject) => {
+    if (key.includes(".")) {
+      // Dots are used as a delimitator character between bublic keys and the key of the user's data
+      reject(new Error(`Key cannot include dots!; ${key}`));
+      return;
+    }
+
+    if (!this.userAccount.getAddress()) {
+      reject(new Error("You need to log in before you can PUT."));
+      return;
+    }
+
+    const timestamp = new Date().getTime();
+
+    const crdtChanges = crdt.getChanges();
+
+    const encodedData = JSON.stringify(crdtChanges);
+
+    const dataString = `${encodedData}${this.userAccount.getAddress()}${timestamp}`;
+
+    // WORK
+    proofOfWork(dataString, this.options.pow)
+      .then(({ hash, nonce }) => {
+        this.userAccount.signData(hash).then((signature) => {
+          if (signature && this.userAccount.getAddress()) {
+            // Compose the message
+            const data: VerificationData<any> = {
+              k: userNamespaced
+                ? `:${this.userAccount.getAddress()}.${key}`
+                : key,
+              a: this.userAccount.getAddress() || "",
+              n: nonce,
+              t: timestamp,
+              h: hash,
+              s: signature,
+              v: crdtChanges,
+              c: crdt.type,
+            };
+
+            this.logger("PUT CRDT", key, data);
+
+            const finalMessage: CrdtPutMessage<any> = {
+              type: "crdtPut",
+              id: textRandom(10),
+              to: [],
+              data,
+            };
+            this.network.sendToAll(finalMessage);
+            resolve(finalMessage);
+          }
+        });
+      })
+      .catch(reject);
+  });
+}

package/lib/toolDbGet.ts

@@ -0,0 +1,80 @@
+import { ToolDb, textRandom } from ".";
+
+/**
+ * Triggers a GET request to other peers. If the data is available locally it will return that instead.
+ * @param key key of the data
+ * @param userNamespaced If this key bolongs to a user or its public. Making it private will enforce validation for our address and signatures.
+ * @param timeout Max time to wait for remote.
+ * @returns Promise<Data>
+ */
+export default function toolDbGet<T = any>(
+  this: ToolDb,
+  key: string,
+  userNamespaced = false,
+  timeoutMs = 1000
+): Promise<T | null> {
+  return new Promise((resolve, reject) => {
+    if (userNamespaced && this.userAccount.getAddress() === undefined) {
+      reject(new Error("You are not authorized yet!"));
+      return;
+    }
+    const finalKey = userNamespaced
+      ? `:${this.userAccount.getAddress()}.${key}`
+      : key;
+    this.logger("GET", finalKey);
+
+    const msgId = textRandom(10);
+
+    const cancelTimeout = setTimeout(() => {
+      this.store
+        .get(finalKey)
+        .then((data) => {
+          try {
+            const message = JSON.parse(data);
+            this.emit("data", message);
+            resolve(message.v);
+          } catch (e) {
+            resolve(null);
+          }
+        })
+        .catch((e) => {
+          resolve(null);
+        });
+    }, timeoutMs);
+
+    this.addIdListener(msgId, (msg) => {
+      this.logger("GET RECV", finalKey);
+
+      clearTimeout(cancelTimeout);
+      if (msg.type === "put") {
+        resolve(msg.data.v);
+      }
+    });
+
+    this.store
+      .get(finalKey)
+      .then((data) => {
+        try {
+          const parsed = JSON.parse(data);
+          const val = parsed.v;
+          clearTimeout(cancelTimeout);
+          this.removeIdListener(msgId);
+          this.emit("data", parsed);
+          resolve(val);
+        } catch (e) {
+          // do nothing
+        }
+      })
+      .catch((e) => {
+        // do nothing
+      });
+
+    // Do get
+    this.network.sendToAll({
+      type: "get",
+      to: [],
+      key: finalKey,
+      id: msgId,
+    });
+  });
+}

package/lib/toolDbKeysSignIn.ts

@@ -0,0 +1,16 @@
+import { ToolDb, randomAnimal } from ".";
+
+export default function toolDbKeysSignIn(
+  this: ToolDb,
+  privateKey: string,
+  username?: string
+): Promise<unknown> {
+  if (!this.userAccount) return Promise.resolve(undefined);
+
+  return this.userAccount
+    .getAccountFromPrivate(privateKey)
+    .then((newAccount) => {
+      this.userAccount.setUser(newAccount, username || randomAnimal());
+      return newAccount;
+    });
+}

package/lib/toolDbPut.ts

@@ -0,0 +1,83 @@
+import {
+  ToolDb,
+  PutMessage,
+  textRandom,
+  VerificationData,
+  proofOfWork,
+} from ".";
+
+/**
+ * Triggers a PUT request to other peers.
+ * @param key key where we want to put the data at.
+ * @param value Data we want to any (any type)
+ * @param userNamespaced If this key bolongs to a user or its public. Making it private will enforce validation for our address and signatures.
+ * @returns Promise<Data | null>
+ */
+export default function toolDbPut<T = any>(
+  this: ToolDb,
+  key: string,
+  value: T,
+  userNamespaced = false
+): Promise<PutMessage<T> | null> {
+  return new Promise((resolve, reject) => {
+    if (key.includes(".")) {
+      // Dots are used as a delimitator character between bublic keys and the key of the user's data
+      reject(new Error(`Key cannot include dots!; ${key}`));
+      return;
+    }
+
+    if (!this.userAccount || !this.userAccount.getAddress()) {
+      reject(new Error("You need to log in before you can PUT."));
+      return;
+    }
+
+    const timestamp = new Date().getTime();
+    const dataString = `${JSON.stringify(
+      value
+    )}${this.userAccount.getAddress()}${timestamp}`;
+
+    // WORK
+    proofOfWork(dataString, this.options.pow)
+      .then(({ hash, nonce }) => {
+        this.userAccount.signData(hash).then((signature) => {
+          if (signature && this.userAccount.getAddress()) {
+            const finalKey = userNamespaced
+              ? `:${this.userAccount.getAddress()}.${key}`
+              : key;
+
+            // Compose the message
+            const data: VerificationData = {
+              k: finalKey,
+              a: this.userAccount.getAddress() || "",
+              n: nonce,
+              t: timestamp,
+              h: hash,
+              s: signature,
+              v: value,
+              c: null,
+            };
+
+            this.logger("PUT", key, data);
+
+            const finalMessage: PutMessage = {
+              type: "put",
+              id: textRandom(10),
+              to: [],
+              data,
+            };
+
+            this.network.sendToAll(finalMessage);
+            this.store
+              .put(finalKey, JSON.stringify(data))
+              .catch((e) => {
+                // do nothing
+              })
+              .finally(() => {
+                resolve(finalMessage);
+              });
+          }
+        });
+      })
+      .catch(reject);
+  });
+}

package/lib/toolDbQueryKeys.ts

@@ -0,0 +1,64 @@
+import { ToolDb, textRandom, uniq } from ".";
+
+/**
+ * Triggers a QUERY request to other peers.
+ * @param key start of the key
+ * @param userNamespaced If this key bolongs to a user or its public.
+ * @returns Promise<Data>
+ */
+export default function toolDbQueryKeys(
+  this: ToolDb,
+  key: string,
+  userNamespaced = false,
+  timeoutMs = 1000
+): Promise<string[] | null> {
+  const user = this.userAccount;
+
+  return new Promise((resolve, reject) => {
+    if (userNamespaced && user.getAddress() === undefined) {
+      reject(new Error("You are not authorized yet!"));
+      return;
+    }
+    const finalKey = userNamespaced ? `:${user.getAddress()}.${key}` : key;
+    this.logger("QUERY", finalKey);
+
+    const msgId = textRandom(10);
+    let foundKeys: string[] = [];
+    let timeout: NodeJS.Timeout | undefined;
+
+    this.store
+      .query(finalKey)
+      .then((localKeys) => {
+        foundKeys = [...foundKeys, ...localKeys];
+        timeout = setTimeout(finishListening, timeoutMs);
+      })
+      .catch((e) => {
+        // do nothing
+      });
+
+    const finishListening = () => {
+      resolve(uniq(foundKeys));
+    };
+
+    this.addIdListener(msgId, (msg) => {
+      this.logger("QUERY RECV", finalKey);
+
+      if (msg.type === "queryAck") {
+        foundKeys = [...foundKeys, ...msg.keys];
+
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        timeout = setTimeout(finishListening, timeoutMs);
+      }
+    });
+
+    // Do get
+    this.network.sendToAll({
+      type: "query",
+      to: [],
+      key: finalKey,
+      id: msgId,
+    });
+  });
+}

package/lib/toolDbSignIn.ts

@@ -0,0 +1,31 @@
+import { ToolDb, sha256, randomAnimal } from ".";
+
+export default function toolDbSignIn(
+  this: ToolDb,
+  user: string,
+  password: string
+): Promise<unknown | undefined> {
+  return new Promise((resolve, reject) => {
+    this.getData<unknown>(`==${user}`, false, 5000).then((_user) => {
+      if (!_user) {
+        reject("Could not find user");
+        return;
+      }
+
+      try {
+        this.userAccount
+          .decryptAccount(_user, sha256(password))
+          .then((newAccount) => {
+            this.userAccount.setUser(
+              newAccount,
+              user || `Anonymous ${randomAnimal()}`
+            );
+
+            resolve(_user);
+          });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}

package/lib/toolDbSignUp.ts

@@ -0,0 +1,71 @@
+import {
+  ToolDb,
+  PutMessage,
+  textRandom,
+  VerificationData,
+  proofOfWork,
+  sha256,
+} from ".";
+
+export default async function toolDbSignUp(
+  this: ToolDb,
+  user: string,
+  password: string
+): Promise<PutMessage<any>> {
+  const userRoot = `==${user}`;
+  return new Promise((resolve, reject) => {
+    this.getData(userRoot, false, 3000)
+      .then((data) => {
+        if (data === null) {
+          const account = new this.options.userAdapter(this);
+          account.encryptAccount(sha256(password)).then((userData) => {
+            const timestamp = new Date().getTime();
+            const userDataString = `${JSON.stringify(
+              userData
+            )}${account.getAddress()}${timestamp}`;
+
+            proofOfWork(userDataString, 0)
+              .then(({ hash, nonce }) => {
+                account.signData(hash).then((signature) => {
+                  const signupMessage: VerificationData = {
+                    k: userRoot,
+                    a: account.getAddress() || "",
+                    n: nonce,
+                    t: timestamp,
+                    h: hash,
+                    s: signature,
+                    v: userData,
+                    c: null,
+                  };
+
+                  this.logger("SIGNUP PUT", userRoot, signupMessage);
+
+                  const finalMsg = {
+                    type: "put",
+                    id: textRandom(10),
+                    to: [],
+                    data: signupMessage,
+                  } as PutMessage;
+
+                  this.network.sendToAll(finalMsg);
+                  this.store
+                    .put(userRoot, JSON.stringify(signupMessage))
+                    .catch((e) => {
+                      // do nothing
+                    })
+                    .finally(() => {
+                      resolve(finalMsg);
+                    });
+                });
+              })
+              .catch(reject);
+          });
+        } else {
+          reject(new Error("User already exists!"));
+        }
+      })
+      .catch(() => {
+        reject(new Error("Could not fetch user"));
+      });
+  });
+}

package/lib/toolDbSubscribe.ts

@@ -0,0 +1,53 @@
+import { ToolDb, textRandom } from ".";
+
+/**
+ * Subscribe to all PUT updates for this key.
+ * @param key key of the data
+ * @param userNamespaced If this key bolongs to a user or its public. Making it
+ * private will enforce validation for our address and signatures.
+ * @returns Promise<Data>
+ */
+export default function toolDbSubscribe(
+  this: ToolDb,
+  key: string,
+  userNamespaced = false
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (userNamespaced && this.userAccount.getAddress() === undefined) {
+      reject(new Error("You are not authorized yet!"));
+      return;
+    }
+
+    const finalKey = userNamespaced
+      ? `:${this.userAccount.getAddress()}.${key}`
+      : key;
+
+    this.logger("SUBSCRIBE", finalKey);
+
+    const msgId = textRandom(10);
+
+    this.network.sendToAll({
+      type: "subscribe",
+      key: finalKey,
+      to: [],
+      id: msgId,
+    });
+
+    this.store
+      .get(finalKey)
+      .then((data) => {
+        try {
+          const message = JSON.parse(data);
+          this.triggerKeyListener(finalKey, message);
+        } catch (e) {
+          // do nothing
+        }
+      })
+      .catch((e) => {
+        // do nothing
+      })
+      .finally(() => {
+        resolve();
+      });
+  });
+}

package/lib/toolDbVerificationWrapper.ts

@@ -0,0 +1,55 @@
+import { ToolDb, VerificationData, VerifyResult } from ".";
+
+export default function toolDbVerificationWrapper(
+  this: ToolDb,
+  data: VerificationData<any>
+) {
+  // This wrapper function adds our custom verification functions to all messages.
+  return new Promise((resolve) => {
+    this.verifyMessage(data, this.options.pow).then(async (verified) => {
+      if (verified) {
+        let skipCustom = true;
+        this._customVerificator.forEach((listener) => {
+          if (listener && data.k && data.k.startsWith(listener.key)) {
+            skipCustom = false;
+
+            let previousData: any = undefined;
+            // Get the previously stored value of this key
+            this.store
+              .get(data.k)
+              .then((prev) => {
+                try {
+                  previousData = JSON.parse(prev);
+                } catch (e) {
+                  // do nothing
+                }
+              })
+              .catch((e) => {
+                // do nothing
+              })
+              .finally(() => {
+                listener
+                  .fn(data, previousData)
+                  .then((verified: boolean) => {
+                    if (verified) {
+                      resolve(VerifyResult.Verified);
+                    } else {
+                      resolve(VerifyResult.CustomVerificationFailed);
+                    }
+                  })
+                  .catch((e) => {
+                    resolve(VerifyResult.CustomVerificationFailed);
+                  });
+              });
+          }
+        });
+
+        if (skipCustom) {
+          resolve(verified);
+        }
+      } else {
+        resolve(VerifyResult.InvalidVerification);
+      }
+    });
+  });
+}