tool-db 2.6.2 → 2.6.6

package/lib/messageHandlers/handleCrdtPut.ts

@@ -1,133 +0,0 @@
-import {
-  ToolDb,
-  VerifyResult,
-  CrdtPutMessage,
-  VerificationData,
-  MapCrdt,
-  MapChanges,
-  CRDT_COUNTER,
-  CRDT_LIST,
-  CRDT_MAP,
-  ListCrdt,
-  ListChanges,
-  CounterCrdt,
-  CounterChanges,
-} from "..";
-
-import toolDbVerificationWrapper from "../toolDbVerificationWrapper";
-
-export default function handleCrdtPut(
-  this: ToolDb,
-  message: CrdtPutMessage,
-  remotePeerId: string
-) {
-  toolDbVerificationWrapper.call(this, message.data).then((value) => {
-    // this.logger("Verification wrapper result: ", value, message.k);
-    if (value === VerifyResult.Verified) {
-      const finalMessage: CrdtPutMessage = {
-        ...message,
-        to: [...message.to, remotePeerId],
-      };
-
-      this.emit("crdtput", finalMessage);
-      this.emit("data", finalMessage.data);
-      this.emit("verified", finalMessage);
-      // relay to other servers !!!
-      this.network.sendToAll(finalMessage, true);
-
-      this.store
-        .get(finalMessage.data.k)
-        .then((oldData) => {
-          if (oldData) {
-            try {
-              const parsedOldData: VerificationData<any> = JSON.parse(oldData);
-
-              let newMessage = finalMessage;
-
-              // Merge old document with new data incoming and save it
-              // Add handles for all kinds of CRDT we add
-              let oldDoc:
-                | MapCrdt<any>
-                | ListCrdt<any>
-                | CounterCrdt<any>
-                | undefined;
-
-              if (parsedOldData.c === CRDT_MAP) {
-                oldDoc = new MapCrdt(
-                  this.userAccount.getAddress() || "",
-                  parsedOldData.v
-                );
-              }
-
-              if (parsedOldData.c === CRDT_LIST) {
-                oldDoc = new ListCrdt(
-                  this.userAccount.getAddress() || "",
-                  parsedOldData.v
-                );
-              }
-
-              if (parsedOldData.c === CRDT_COUNTER) {
-                oldDoc = new CounterCrdt(
-                  this.userAccount.getAddress() || "",
-                  parsedOldData.v
-                );
-              }
-
-              let changesMerged:
-                | MapChanges<any>[]
-                | ListChanges<any>[]
-                | CounterChanges[] = [];
-
-              if (oldDoc) {
-                oldDoc.mergeChanges(finalMessage.data.v);
-                changesMerged = oldDoc.getChanges();
-              }
-              newMessage = {
-                ...finalMessage,
-              };
-              newMessage.data.v = changesMerged;
-
-              if (parsedOldData.t < finalMessage.data.t) {
-                const key = newMessage.data.k;
-                this.triggerKeyListener(key, newMessage.data);
-                this.store
-                  .put(newMessage.data.k, JSON.stringify(newMessage.data))
-                  .catch((e) => {
-                    // do nothing
-                  });
-              } else {
-                const key = message.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) {
-              this.logger("Couldnt parse crdt data", oldData, e);
-            }
-          } else {
-            const key = finalMessage.data.k;
-            this.triggerKeyListener(key, finalMessage.data);
-            this.store
-              .put(finalMessage.data.k, JSON.stringify(finalMessage.data))
-              .catch((e) => {
-                this.logger("Couldnt insert crdt data", e);
-              });
-          }
-        })
-        .catch((e) => {
-          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 {
-      this.logger("unverified message: ", value, message);
-    }
-  });
-}

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,
-    });
-  });
-}