tool-db 1.2.3 → 1.3.0

package/dist/toolDbLibP2p.js

@@ -0,0 +1,375 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTOCOL_VER = void 0;
+var lodash_1 = __importDefault(require("lodash"));
+var libp2p_1 = __importDefault(require("libp2p"));
+var libp2p_websockets_1 = __importDefault(require("libp2p-websockets"));
+var libp2p_webrtc_star_1 = __importDefault(require("libp2p-webrtc-star"));
+var libp2p_noise_1 = require("@chainsafe/libp2p-noise");
+var libp2p_mplex_1 = __importDefault(require("libp2p-mplex"));
+var it_pipe_1 = __importDefault(require("it-pipe"));
+var _1 = require(".");
+exports.PROTOCOL_VER = "/tooldb/1.2.0";
+var toolDbLibP2p = /** @class */ (function () {
+    function toolDbLibP2p(db) {
+        this._clientSockets = {};
+        this._tooldb = db;
+        this.options = db.options;
+        this.createLibP2p();
+        if (this.options.server) {
+            //
+        }
+    }
+    Object.defineProperty(toolDbLibP2p.prototype, "clientSockets", {
+        get: function () {
+            return this._clientSockets;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(toolDbLibP2p.prototype, "libp2p", {
+        get: function () {
+            return this._libp2p;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    toolDbLibP2p.prototype.createLibP2p = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var options, node;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = {
+                            addresses: {
+                                listen: [
+                                    "/dns4/wrtc-star1.par.dwebops.pub/tcp/443/wss/p2p-webrtc-star",
+                                    "/dns4/wrtc-star2.sjc.dwebops.pub/tcp/443/wss/p2p-webrtc-star",
+                                ],
+                            },
+                            modules: {
+                                transport: [libp2p_websockets_1.default, libp2p_webrtc_star_1.default],
+                                connEncryption: [libp2p_noise_1.NOISE],
+                                streamMuxer: [libp2p_mplex_1.default],
+                            },
+                        };
+                        return [4 /*yield*/, libp2p_1.default.create(options)];
+                    case 1:
+                        node = _a.sent();
+                        this._libp2p = node;
+                        window.libp2p = node;
+                        this._tooldb.options.id = node.peerId.toB58String();
+                        // Listen for new peers
+                        // node.on("peer:discovery", (peerId) => {
+                        //   console.log(`Found peer ${peerId.toB58String()}`);
+                        // });
+                        // Listen for new connections to peers
+                        node.connectionManager.on("peer:connect", function (connection) {
+                            // Send message to other peers (connected) using the protocol
+                            node.peerStore.peers.forEach(function (peer) { return __awaiter(_this, void 0, void 0, function () {
+                                var connection, pid, stream, err_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            connection = node.connectionManager.get(peer.id);
+                                            if (!connection)
+                                                return [2 /*return*/];
+                                            if (!peer.protocols.includes(exports.PROTOCOL_VER)) {
+                                                // Close connections without our protocol
+                                                connection.close();
+                                                return [2 /*return*/];
+                                            }
+                                            pid = peer.id.toB58String();
+                                            if (!!this.clientSockets[pid]) return [3 /*break*/, 5];
+                                            console.warn("Protocol found " + exports.PROTOCOL_VER);
+                                            _a.label = 1;
+                                        case 1:
+                                            _a.trys.push([1, 4, , 5]);
+                                            return [4 /*yield*/, connection.newStream([exports.PROTOCOL_VER])];
+                                        case 2:
+                                            stream = (_a.sent()).stream;
+                                            this.clientSockets[pid] = stream;
+                                            return [4 /*yield*/, this.sendToClientId(pid, {
+                                                    type: "ping",
+                                                    clientId: this.options.id,
+                                                    to: [this.options.id],
+                                                    isServer: this.options.server,
+                                                    id: (0, _1.textRandom)(10),
+                                                })];
+                                        case 3:
+                                            _a.sent();
+                                            return [3 /*break*/, 5];
+                                        case 4:
+                                            err_1 = _a.sent();
+                                            console.info("Could not handshake protocol with peer", err_1);
+                                            return [3 /*break*/, 5];
+                                        case 5: return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                        });
+                        // Listen for peers disconnecting
+                        node.connectionManager.on("peer:disconnect", function (connection) {
+                            var pid = connection.remotePeer.toB58String();
+                            delete _this.clientSockets[pid];
+                        });
+                        node.handle(exports.PROTOCOL_VER, function (args) { return _this.toolDbProtocolHandler(args); });
+                        return [4 /*yield*/, node.start()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, node];
+                }
+            });
+        });
+    };
+    toolDbLibP2p.prototype.close = function (clientId) {
+        if (this.libp2p) {
+            var conn = this.libp2p.connections.get(clientId);
+            if (conn && conn[0]) {
+                conn[0].close();
+            }
+        }
+    };
+    /**
+     * A simple handler to print incoming messages to the console
+     * @param {Object} params
+     * @param {Connection} params.connection The connection the stream belongs to
+     * @param {Stream} params.stream stream to the peer
+     */
+    toolDbLibP2p.prototype.toolDbProtocolHandler = function (_a) {
+        var connection = _a.connection, stream = _a.stream;
+        return __awaiter(this, void 0, void 0, function () {
+            var err_2;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, (0, it_pipe_1.default)(stream, function (source) { var source_1, source_1_1; return __awaiter(_this, void 0, void 0, function () {
+                                var message, msg, e_1_1;
+                                var e_1, _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _b.trys.push([0, 5, 6, 11]);
+                                            source_1 = __asyncValues(source);
+                                            _b.label = 1;
+                                        case 1: return [4 /*yield*/, source_1.next()];
+                                        case 2:
+                                            if (!(source_1_1 = _b.sent(), !source_1_1.done)) return [3 /*break*/, 4];
+                                            message = source_1_1.value;
+                                            console.info(connection.remotePeer.toB58String() + ": " + message);
+                                            try {
+                                                msg = JSON.parse("" + message);
+                                                this._tooldb.clientOnMessage(msg, connection.remotePeer.toB58String());
+                                            }
+                                            catch (e) {
+                                                console.log("Got message ERR > ", message);
+                                                console.log(e);
+                                            }
+                                            _b.label = 3;
+                                        case 3: return [3 /*break*/, 1];
+                                        case 4: return [3 /*break*/, 11];
+                                        case 5:
+                                            e_1_1 = _b.sent();
+                                            e_1 = { error: e_1_1 };
+                                            return [3 /*break*/, 11];
+                                        case 6:
+                                            _b.trys.push([6, , 9, 10]);
+                                            if (!(source_1_1 && !source_1_1.done && (_a = source_1.return))) return [3 /*break*/, 8];
+                                            return [4 /*yield*/, _a.call(source_1)];
+                                        case 7:
+                                            _b.sent();
+                                            _b.label = 8;
+                                        case 8: return [3 /*break*/, 10];
+                                        case 9:
+                                            if (e_1) throw e_1.error;
+                                            return [7 /*endfinally*/];
+                                        case 10: return [7 /*endfinally*/];
+                                        case 11: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _b.sent();
+                        // Replies are done on new streams, so let's close this stream so we don't leak it
+                        return [4 /*yield*/, (0, it_pipe_1.default)([], stream)];
+                    case 2:
+                        // Replies are done on new streams, so let's close this stream so we don't leak it
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_2 = _b.sent();
+                        console.error(err_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Writes a given `message` over the given `stream`.
+     * @param {String} message The message to send over `stream`
+     * @param {Stream} stream A stream over the muxed Connection to our peer
+     */
+    toolDbLibP2p.prototype.toolDbProtocolSend = function (message, stream) {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, (0, it_pipe_1.default)([message], stream, function (source) {
+                                var source_2, source_2_1;
+                                var e_2, _a;
+                                return __awaiter(this, void 0, void 0, function () {
+                                    var message_1, e_2_1;
+                                    return __generator(this, function (_b) {
+                                        switch (_b.label) {
+                                            case 0:
+                                                _b.trys.push([0, 5, 6, 11]);
+                                                source_2 = __asyncValues(source);
+                                                _b.label = 1;
+                                            case 1: return [4 /*yield*/, source_2.next()];
+                                            case 2:
+                                                if (!(source_2_1 = _b.sent(), !source_2_1.done)) return [3 /*break*/, 4];
+                                                message_1 = source_2_1.value;
+                                                console.info("Me: " + message_1);
+                                                _b.label = 3;
+                                            case 3: return [3 /*break*/, 1];
+                                            case 4: return [3 /*break*/, 11];
+                                            case 5:
+                                                e_2_1 = _b.sent();
+                                                e_2 = { error: e_2_1 };
+                                                return [3 /*break*/, 11];
+                                            case 6:
+                                                _b.trys.push([6, , 9, 10]);
+                                                if (!(source_2_1 && !source_2_1.done && (_a = source_2.return))) return [3 /*break*/, 8];
+                                                return [4 /*yield*/, _a.call(source_2)];
+                                            case 7:
+                                                _b.sent();
+                                                _b.label = 8;
+                                            case 8: return [3 /*break*/, 10];
+                                            case 9:
+                                                if (e_2) throw e_2.error;
+                                                return [7 /*endfinally*/];
+                                            case 10: return [7 /*endfinally*/];
+                                            case 11: return [2 /*return*/];
+                                        }
+                                    });
+                                });
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        err_3 = _a.sent();
+                        console.error(err_3);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    toolDbLibP2p.prototype.sendToAll = function (msg, crossServerOnly) {
+        var _this = this;
+        if (crossServerOnly === void 0) { crossServerOnly = false; }
+        var to = lodash_1.default.uniq(__spreadArray(__spreadArray([], msg.to, true), [this.options.id], false));
+        var filteredConns = Object.keys(this.clientSockets).filter(function (id) { return !to.includes(id); });
+        filteredConns.forEach(function (clientId) {
+            var stream = _this._clientSockets[clientId];
+            if (!crossServerOnly) {
+                console.log("Sent out to: ", clientId);
+                if (stream) {
+                    var message = JSON.stringify(__assign(__assign({}, msg), { to: to }));
+                    _this.toolDbProtocolSend(message, stream);
+                }
+            }
+        });
+    };
+    toolDbLibP2p.prototype.sendToClientId = function (clientId, msg) {
+        var stream = this._clientSockets[clientId];
+        if (stream) {
+            var to = lodash_1.default.uniq(__spreadArray(__spreadArray([], msg.to, true), [this.options.id], false));
+            var message = JSON.stringify(__assign(__assign({}, msg), { to: to }));
+            this.toolDbProtocolSend(message, stream);
+        }
+    };
+    Object.defineProperty(toolDbLibP2p.prototype, "tooldb", {
+        get: function () {
+            return this._tooldb;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return toolDbLibP2p;
+}());
+exports.default = toolDbLibP2p;
+//# sourceMappingURL=toolDbLibP2p.js.map

package/dist/toolDbLibP2p.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolDbLibP2p.js","sourceRoot":"","sources":["../src/toolDbLibP2p.ts"],"names":[],"mappings":"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"}

package/dist/toolDbNetwork.d.ts

@@ -0,0 +1,33 @@
+import WebSocket from "ws";
+import { ToolDbMessage } from ".";
+import ToolDb from "./tooldb";
+export declare type ToolDbWebSocket = WebSocket & {
+    toolDbId?: string;
+    isServer: boolean;
+    origUrl: string;
+};
+export default class toolDbNetwork {
+    private wnd;
+    private _wss;
+    private options;
+    private server;
+    private _tooldb;
+    private _connections;
+    get allPeers(): string[];
+    private _awaitingConnections;
+    private removeFromAwaiting;
+    _clientSockets: Record<string, ToolDbWebSocket>;
+    get clientSockets(): Record<string, ToolDbWebSocket>;
+    constructor(db: ToolDb);
+    /**
+     * Open a connection to a federated server
+     * @param url URL of the server (including port)
+     * @returns websocket
+     */
+    connectTo: (host: string, port: number, connectionId?: string | undefined) => ToolDbWebSocket | undefined;
+    close(clientId: string): void;
+    sendToAll(msg: ToolDbMessage, crossServerOnly?: boolean, isRelay?: boolean): void;
+    sendToClientId(clientId: string, msg: ToolDbMessage): void;
+    private reconnect;
+    get tooldb(): ToolDb;
+}