tool-db 2.6.1 → 2.6.3

package/lib/messageHandlers/handleFunction.ts

@@ -1,59 +0,0 @@
-import { FunctionMessage, FunctionReturnMessage, ToolDb } from "..";
-
-export default function handleFunction(
-  this: ToolDb,
-  message: FunctionMessage,
-  remotePeerId: string
-) {
-  // executes the given function by message on the server if it exists
-  if (this.functions[message.function]) {
-    try {
-      this.functions[message.function](message.args)
-        .then((ret) => {
-          const messageReturn: FunctionReturnMessage = {
-            return: ret,
-            type: "functionReturn",
-            id: message.id,
-            code: "OK",
-            to: [],
-          };
-
-          this.network.sendToClientId(remotePeerId, messageReturn);
-        })
-        .catch((e) => {
-          const messageReturn: FunctionReturnMessage = {
-            return: e.toString(),
-            type: "functionReturn",
-            id: message.id,
-            code: "ERR",
-            to: [],
-          };
-
-          this.network.sendToClientId(remotePeerId, messageReturn);
-        });
-    } catch (e: any) {
-      // something went wrong, nothing to do here
-      // We might want to return the exception to the client?
-      const messageReturn: FunctionReturnMessage = {
-        return: e.toString(),
-        type: "functionReturn",
-        id: message.id,
-        code: "ERR",
-        to: [],
-      };
-
-      this.network.sendToClientId(remotePeerId, messageReturn);
-    }
-  } else {
-    // function not found
-    const messageReturn: FunctionReturnMessage = {
-      return: "Function not found",
-      type: "functionReturn",
-      id: message.id,
-      code: "NOT_FOUND",
-      to: [],
-    };
-
-    this.network.sendToClientId(remotePeerId, messageReturn);
-  }
-}

package/lib/messageHandlers/handleGet.ts

@@ -1,34 +0,0 @@
-import { ToolDb, GetMessage, PutMessage } from "..";
-
-export default function handleGet(
-  this: ToolDb,
-  message: GetMessage,
-  remotePeerId: string
-) {
-  this.store
-    .get(message.key)
-    .then((data) => {
-      try {
-        // Use the id of the get so the other client knows we are replying
-        const oldData = {
-          type: "put",
-          data: JSON.parse(data),
-          to: [],
-          id: message.id,
-        } as PutMessage;
-        this.network.sendToClientId(remotePeerId, oldData);
-      } catch (e) {
-        // socket.send(data);
-        // do nothing
-      }
-    })
-    .catch((e) => {
-      const finalMessage: GetMessage = {
-        ...message,
-        to: [...message.to, remotePeerId],
-      };
-
-      this.logger("Local key not found, relay", JSON.stringify(finalMessage));
-      this.network.sendToAll(finalMessage, false);
-    });
-}

package/lib/messageHandlers/handlePing.ts

@@ -1,40 +0,0 @@
-import { ToolDb, verifyPeer, PingMessage, PongMessage } from "..";
-
-export default function handlePing(
-  this: ToolDb,
-  message: PingMessage,
-  remotePeerId: string
-) {
-  if (!this.isConnected) {
-    this.isConnected = true;
-    this.onConnect();
-  }
-
-  verifyPeer(this, message.peer).then((verified) => {
-    // Verify integrity and topic
-    if (verified && message.peer.topic === this.options.topic) {
-      // Add this peer to our list of peers
-      const filteredPeers = this.serverPeers.filter(
-        (p) => p.address === message.peer.address
-      );
-      if (filteredPeers.length === 0 && message.isServer) {
-        // Add this peer to the list
-        this.serverPeers.push(message.peer);
-      }
-
-      this.network.sendToClientId(remotePeerId, {
-        type: "pong",
-        isServer: this.options.server,
-        clientId: this.network.getClientAddress(),
-        to: [],
-        servers: this.serverPeers,
-        id: message.id,
-      } as PongMessage);
-
-      this.onPeerConnect(this.peerAccount.getAddress() || "");
-    } else {
-      this.logger("Blocked a remote peer from joining; ", verified, message);
-      // Drop connection here!
-    }
-  });
-}

package/lib/messageHandlers/handlePong.ts

@@ -1,37 +0,0 @@
-import { ToolDb, verifyPeer, PongMessage } from "..";
-
-export default function handlePong(
-  this: ToolDb,
-  message: PongMessage,
-  remotePeerId: string
-) {
-  if (!this.isConnected) {
-    this.isConnected = true;
-    this.onConnect();
-  }
-
-  message.servers.forEach((peer) => {
-    // Check for duplicates first (synchronously) to avoid race conditions
-    const filteredPeers = this.serverPeers.filter(
-      (p) => p.address === peer.address
-    );
-    
-    if (filteredPeers.length === 0 && peer.host && peer.port) {
-      verifyPeer(this, peer).then((verified) => {
-        // Verify integrity and topic
-        if (verified && peer.topic === this.options.topic) {
-          // Double-check for duplicates after async verification
-          const recheck = this.serverPeers.filter(
-            (p) => p.address === peer.address
-          );
-          if (recheck.length === 0) {
-            // Add this peer to the list
-            this.serverPeers.push(peer);
-          }
-        }
-      });
-    }
-  });
-
-  this.onPeerConnect(this.peerAccount.getAddress() || "");
-}

package/lib/messageHandlers/handlePut.ts

@@ -1,59 +0,0 @@
-import { ToolDb, PutMessage, VerifyResult } from "..";
-
-import toolDbVerificationWrapper from "../toolDbVerificationWrapper";
-
-export default function handlePut(
-  this: ToolDb,
-  message: PutMessage,
-  remotePeerId: string
-) {
-  toolDbVerificationWrapper.call(this, message.data).then((value) => {
-    // this.logger("Verification wrapper result: ", value, message.k);
-    if (value === VerifyResult.Verified) {
-      this.emit("put", message);
-      this.emit("data", message.data);
-      this.emit("verified", message);
-      // relay to other servers !!!
-      const finalMessage: PutMessage = {
-        ...message,
-        to: [...message.to, remotePeerId],
-      };
-
-      this.network.sendToAll(finalMessage, true);
-
-      this.store
-        .get(finalMessage.data.k)
-        .then((oldData) => {
-          const parsedOldData = JSON.parse(oldData);
-          if (parsedOldData.t < finalMessage.data.t) {
-            const key = finalMessage.data.k;
-            this.triggerKeyListener(key, finalMessage.data);
-            this.store
-              .put(finalMessage.data.k, JSON.stringify(finalMessage.data))
-              .catch((e) => {
-                // do nothing
-              });
-          } else {
-            const key = finalMessage.data.k;
-            this.triggerKeyListener(key, parsedOldData);
-          }
-          // } else {
-          //   this.logger(
-          //     `${message.k} has old data, but its newer. old ${parsedOldData.t} < new ${message.t}`
-          //   );
-          // }
-        })
-        .catch((e) => {
-          const key = message.data.k;
-          this.triggerKeyListener(key, message.data);
-          this.store
-            .put(message.data.k, JSON.stringify(message.data))
-            .catch((e) => {
-              //
-            });
-        });
-    } else {
-      this.logger("unverified message: ", value, message);
-    }
-  });
-}

package/lib/messageHandlers/handleQuery.ts

@@ -1,30 +0,0 @@
-import { ToolDb, QueryAckMessage, QueryMessage } from "..";
-
-export default function handleQuery(
-  this: ToolDb,
-  message: QueryMessage,
-  remotePeerId: string
-) {
-  this.store
-    .query(message.key)
-    .then((keys) => {
-      this.network.sendToClientId(remotePeerId, {
-        type: "queryAck",
-        id: message.id,
-        to: [],
-        keys,
-      } as QueryAckMessage);
-    })
-    .catch((e) => {
-      // do nothing
-    });
-
-  if (this.options.server) {
-    const finalMessage: QueryMessage = {
-      ...message,
-      to: [...message.to, remotePeerId],
-    };
-
-    this.network.sendToAll(finalMessage, true);
-  }
-}

package/lib/messageHandlers/handleSubscribe.ts

@@ -1,46 +0,0 @@
-import { ToolDb, PutMessage, SubscribeMessage } from "..";
-
-export default function handleSubscribe(
-  this: ToolDb,
-  message: SubscribeMessage,
-  remotePeerId: string
-) {
-  const subId = remotePeerId + "-" + message.key;
-  if (!this.subscriptions.includes(subId)) {
-    this.subscriptions.push(subId);
-
-    this.addKeyListener(message.key, (msg) => {
-      if (remotePeerId) {
-        // We do not reply to the socket directly
-        // instead we use the client id, in case the socket reconnects
-        const newMsg: PutMessage = {
-          data: msg,
-          id: message.id,
-          type: "put",
-          to: [],
-        };
-        this.network.sendToClientId(remotePeerId, newMsg);
-      }
-    });
-  }
-
-  // basically the exact same as GET, below
-  this.store
-    .get(message.key)
-    .then((data) => {
-      try {
-        const oldData: PutMessage = {
-          data: JSON.parse(data),
-          id: message.id,
-          type: "put",
-          to: [],
-        };
-        this.network.sendToClientId(remotePeerId, oldData);
-      } catch (e) {
-        // do nothing
-      }
-    })
-    .catch((e) => {
-      // do nothing
-    });
-}

package/lib/server.ts

@@ -1,7 +0,0 @@
-import { ToolDb } from ".";
-
-console.log("Starting server..");
-const server = new ToolDb({
-  port: 8080,
-  server: true,
-});

package/lib/shared.ts

@@ -1,5 +0,0 @@
-const shared = {
-  toolDb: undefined,
-} as any;
-
-export default shared;

package/lib/toolDbAnonSignIn.ts

@@ -1,5 +0,0 @@
-import { ToolDb } from ".";
-
-export default async function toolDbAnonSignIn(this: ToolDb): Promise<void> {
-  await this.userAccount.anonUser();
-}

package/lib/toolDbClientOnMessage.ts

@@ -1,79 +0,0 @@
-import { ToolDb, ToolDbMessage } from ".";
-
-export default function toolDbClientOnMessage(
-  this: ToolDb,
-  message: ToolDbMessage,
-  remotePeerId: string
-) {
-  if (!this.processedIds[message.type]) {
-    this.processedIds[message.type] = [];
-  }
-  if (this.processedIds[message.type].includes(message.id)) {
-    // this.logger(
-    //   `Already processed this message > ${message.type} from ${remotePeerId}`
-    // );
-    return;
-  }
-
-  this.emit("message", message, remotePeerId);
-
-  this.processedIds[message.type].push(message.id);
-
-  this.logger(`Got message ${message.type} from ${remotePeerId}`);
-  this.logger(message);
-
-  // Check if we are listening for this ID
-  if (message.id) {
-    const msgId = message.id;
-    if (this._idListeners[msgId]) {
-      this._idListeners[msgId](message);
-      this.removeIdListener(msgId);
-    }
-  }
-
-  if (message === undefined || message.type === undefined) {
-    this.logger("Message is invalid!", message, typeof message);
-    return;
-  }
-
-  switch (message.type) {
-    case "ping":
-      this.handlePing(message, remotePeerId);
-      break;
-
-    case "pong":
-      this.handlePong(message, remotePeerId);
-      break;
-
-    case "subscribe":
-      this.handleSubscribe(message, remotePeerId);
-      break;
-
-    case "get":
-      this.handleGet(message, remotePeerId);
-      break;
-
-    case "put":
-      this.handlePut(message, remotePeerId);
-      break;
-
-    case "crdtPut":
-      this.handleCrdtPut(message, remotePeerId);
-      break;
-
-    case "crdtGet":
-      this.handleCrdtGet(message, remotePeerId);
-      break;
-
-    case "query":
-      this.handleQuery(message, remotePeerId);
-      break;
-
-    case "function":
-      this.handleFunction(message, remotePeerId);
-      break;
-
-    default:
-      break;
-  }
-}

package/lib/toolDbCrdtGet.ts

@@ -1,83 +0,0 @@
-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,
-  to?: string[]
-): 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) => resolve(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: to || [],
-      key: finalKey,
-      id: msgId,
-    });
-  });
-}

package/lib/toolDbCrdtPut.ts

@@ -1,78 +0,0 @@
-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,
-  to?: string[]
-): 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: to || [],
-              data,
-            };
-            this.network.sendToAll(finalMessage);
-            resolve(finalMessage);
-          }
-        });
-      })
-      .catch(reject);
-  });
-}

package/lib/toolDbFunction.ts

@@ -1,49 +0,0 @@
-import {
-  AllowedFunctionArguments,
-  FunctionReturn,
-  GenericObject,
-  textRandom,
-  ToolDb,
-} from ".";
-
-/**
- * Triggers a FUNCTION request to other peers. If the function executes sucessfully it will return code "OK"
- * @param function function name
- * @param args arguments for the function
- * @param timeout Max time to wait for remote.
- * @returns Promise<FunctionReturn>
- */
-export default function toolDbFunction<R, A = GenericObject>(
-  this: ToolDb,
-  fName: string,
-  args: AllowedFunctionArguments<A>,
-  timeoutMs = 10000
-): Promise<FunctionReturn<R>> {
-  return new Promise((resolve, reject) => {
-    this.logger("FUNCTION > " + fName);
-
-    const msgId = textRandom(10);
-
-    const cancelTimeout = setTimeout(() => {
-      resolve({ return: "Timed out", code: "ERR" });
-    }, timeoutMs);
-
-    this.addIdListener(msgId, (msg) => {
-      this.logger("FUNCTION RECV  > " + fName, msg);
-
-      clearTimeout(cancelTimeout);
-      if (msg.type === "functionReturn") {
-        resolve({ return: msg.return, code: msg.code });
-      }
-    });
-
-    // Do get
-    this.network.sendToAll({
-      type: "function",
-      to: [],
-      function: fName,
-      args: args,
-      id: msgId,
-    });
-  });
-}