@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/plugins/replication-webrtc/signaling-server.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PEER_ID_LENGTH = void 0;
+exports.startSignalingServerSimplePeer = startSignalingServerSimplePeer;
+var _index = require("../utils/index.js");
+var _connectionHandlerSimplePeer = require("./connection-handler-simple-peer.js");
+var PEER_ID_LENGTH = exports.PEER_ID_LENGTH = 12;
+/**
+ * Starts a WebRTC signaling server
+ * that can be used in tests.
+*/
+async function startSignalingServerSimplePeer(serverOptions) {
+  var {
+    WebSocketServer
+  } = await import('ws');
+  var wss = new WebSocketServer(serverOptions);
+  var peerById = new Map();
+  var peersByRoom = new Map();
+  var serverClosed = false;
+  wss.on('close', () => {
+    serverClosed = true;
+    peerById.clear();
+    peersByRoom.clear();
+  });
+
+  /**
+   * Clients can disconnect without telling that to the
+   * server. Therefore we have to automatically disconnect clients that
+   * have not sent a ping message in the last 2 minutes.
+   */
+  (async () => {
+    var _loop = async function () {
+      await (0, _index.promiseWait)(1000 * 5);
+      var minTime = Date.now() - _connectionHandlerSimplePeer.SIMPLE_PEER_PING_INTERVAL;
+      Array.from(peerById.values()).forEach(peer => {
+        if (peer.lastPing < minTime) {
+          disconnectSocket(peer.id, 'no ping for 2 minutes');
+        }
+      });
+    };
+    while (!serverClosed) {
+      await _loop();
+    }
+  })();
+  function disconnectSocket(peerId, reason) {
+    console.log('# disconnect peer ' + peerId + ' reason: ' + reason);
+    var peer = peerById.get(peerId);
+    if (peer) {
+      peer.socket.close && peer.socket.close(undefined, reason);
+      peer.rooms.forEach(roomId => {
+        var room = peersByRoom.get(roomId);
+        room?.delete(peerId);
+        if (room && room.size === 0) {
+          peersByRoom.delete(roomId);
+        }
+      });
+    }
+    peerById.delete(peerId);
+  }
+  wss.on('connection', function (ws) {
+    /**
+     * PeerID is created by the server to prevent malicious
+     * actors from falsy claiming other peoples ids.
+     */
+    var peerId = (0, _index.randomToken)(PEER_ID_LENGTH);
+    var peer = {
+      id: peerId,
+      socket: ws,
+      rooms: new Set(),
+      lastPing: Date.now()
+    };
+    peerById.set(peerId, peer);
+    sendMessage(ws, {
+      type: 'init',
+      yourPeerId: peerId
+    });
+    ws.on('error', err => {
+      console.error('SERVER ERROR:');
+      console.dir(err);
+      disconnectSocket(peerId, 'socket errored');
+    });
+    ws.on('close', () => {
+      disconnectSocket(peerId, 'socket disconnected');
+    });
+    ws.on('message', msgEvent => {
+      peer.lastPing = Date.now();
+      var message = JSON.parse(msgEvent.toString());
+      var type = message.type;
+      switch (type) {
+        case 'join':
+          var roomId = message.room;
+          if (!validateIdString(roomId) || !validateIdString(peerId)) {
+            disconnectSocket(peerId, 'invalid ids');
+            return;
+          }
+          if (peer.rooms.has(peerId)) {
+            return;
+          }
+          peer.rooms.add(roomId);
+          var room = (0, _index.getFromMapOrCreate)(peersByRoom, message.room, () => new Set());
+          room.add(peerId);
+
+          // tell everyone about new room state
+          room.forEach(otherPeerId => {
+            var otherPeer = peerById.get(otherPeerId);
+            if (otherPeer) {
+              sendMessage(otherPeer.socket, {
+                type: 'joined',
+                otherPeerIds: Array.from(room)
+              });
+            }
+          });
+          break;
+        case 'signal':
+          if (message.senderPeerId !== peerId) {
+            disconnectSocket(peerId, 'spoofed sender');
+            return;
+          }
+          var receiver = peerById.get(message.receiverPeerId);
+          if (receiver) {
+            sendMessage(receiver.socket, message);
+          }
+          break;
+        case 'ping':
+          break;
+        default:
+          disconnectSocket(peerId, 'unknown message type ' + type);
+      }
+    });
+  });
+  return {
+    port: serverOptions.port,
+    server: wss,
+    localUrl: 'ws://localhost:' + serverOptions.port
+  };
+}
+function sendMessage(ws, message) {
+  var msgString = JSON.stringify(message);
+  ws.send(msgString);
+}
+function validateIdString(roomId) {
+  if (typeof roomId === 'string' && roomId.length > 5 && roomId.length < 100) {
+    return true;
+  } else {
+    return false;
+  }
+}
+//# sourceMappingURL=signaling-server.js.map

package/dist/cjs/plugins/replication-webrtc/signaling-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signaling-server.js","names":["_index","require","_connectionHandlerSimplePeer","PEER_ID_LENGTH","exports","startSignalingServerSimplePeer","serverOptions","WebSocketServer","wss","peerById","Map","peersByRoom","serverClosed","on","clear","_loop","promiseWait","minTime","Date","now","SIMPLE_PEER_PING_INTERVAL","Array","from","values","forEach","peer","lastPing","disconnectSocket","id","peerId","reason","console","log","get","socket","close","undefined","rooms","roomId","room","delete","size","ws","randomToken","Set","set","sendMessage","type","yourPeerId","err","error","dir","msgEvent","message","JSON","parse","toString","validateIdString","has","add","getFromMapOrCreate","otherPeerId","otherPeer","otherPeerIds","senderPeerId","receiver","receiverPeerId","port","server","localUrl","msgString","stringify","send","length"],"sources":["../../../../src/plugins/replication-webrtc/signaling-server.ts"],"sourcesContent":["import {\r\n    getFromMapOrCreate,\r\n    promiseWait,\r\n    randomToken\r\n} from '../utils/index.ts';\r\nimport {\r\n    SIMPLE_PEER_PING_INTERVAL,\r\n    type PeerMessage\r\n} from './connection-handler-simple-peer.ts';\r\nimport type {\r\n    WebSocket,\r\n    ServerOptions\r\n} from 'ws';\r\n\r\nexport const PEER_ID_LENGTH = 12;\r\nexport type ServerPeer = {\r\n    id: string;\r\n    socket: WebSocket;\r\n    rooms: Set<string>;\r\n    lastPing: number;\r\n};\r\n\r\n\r\n/**\r\n * Starts a WebRTC signaling server\r\n * that can be used in tests.\r\n*/\r\nexport async function startSignalingServerSimplePeer(\r\n    serverOptions: ServerOptions\r\n) {\r\n    const { WebSocketServer } = await import('ws');\r\n    const wss = new WebSocketServer(serverOptions);\r\n\r\n    const peerById = new Map<string, ServerPeer>();\r\n    const peersByRoom = new Map<string, Set<string>>();\r\n\r\n    let serverClosed = false;\r\n    wss.on('close', () => {\r\n        serverClosed = true\r\n        peerById.clear();\r\n        peersByRoom.clear();\r\n    });\r\n\r\n    /**\r\n     * Clients can disconnect without telling that to the\r\n     * server. Therefore we have to automatically disconnect clients that\r\n     * have not sent a ping message in the last 2 minutes.\r\n     */\r\n    (async () => {\r\n        while (!serverClosed) {\r\n            await promiseWait(1000 * 5);\r\n            const minTime = Date.now() - SIMPLE_PEER_PING_INTERVAL;\r\n            Array.from(peerById.values()).forEach(peer => {\r\n                if (peer.lastPing < minTime) {\r\n                    disconnectSocket(peer.id, 'no ping for 2 minutes');\r\n                }\r\n            });\r\n        }\r\n    })();\r\n\r\n    function disconnectSocket(peerId: string, reason: string) {\r\n        console.log('# disconnect peer ' + peerId + ' reason: ' + reason);\r\n        const peer = peerById.get(peerId);\r\n        if (peer) {\r\n            peer.socket.close && peer.socket.close(undefined, reason);\r\n            peer.rooms.forEach(roomId => {\r\n                const room = peersByRoom.get(roomId);\r\n                room?.delete(peerId);\r\n                if (room && room.size === 0) {\r\n                    peersByRoom.delete(roomId);\r\n                }\r\n            });\r\n        }\r\n        peerById.delete(peerId);\r\n    }\r\n\r\n    wss.on('connection', function (ws: WebSocket) {\r\n        /**\r\n         * PeerID is created by the server to prevent malicious\r\n         * actors from falsy claiming other peoples ids.\r\n         */\r\n        const peerId = randomToken(PEER_ID_LENGTH);\r\n        const peer: ServerPeer = {\r\n            id: peerId,\r\n            socket: ws,\r\n            rooms: new Set(),\r\n            lastPing: Date.now()\r\n        };\r\n        peerById.set(peerId, peer);\r\n\r\n        sendMessage(ws, { type: 'init', yourPeerId: peerId });\r\n\r\n\r\n        ws.on('error', (err: Error) => {\r\n            console.error('SERVER ERROR:');\r\n            console.dir(err);\r\n            disconnectSocket(peerId, 'socket errored');\r\n        });\r\n        ws.on('close', () => {\r\n            disconnectSocket(peerId, 'socket disconnected');\r\n        });\r\n\r\n        ws.on('message', (msgEvent: any) => {\r\n            peer.lastPing = Date.now();\r\n            const message = JSON.parse(msgEvent.toString());\r\n            const type = message.type;\r\n            switch (type) {\r\n                case 'join':\r\n                    const roomId = message.room;\r\n                    if (\r\n                        !validateIdString(roomId) ||\r\n                        !validateIdString(peerId)\r\n                    ) {\r\n                        disconnectSocket(peerId, 'invalid ids');\r\n                        return;\r\n                    }\r\n\r\n                    if (peer.rooms.has(peerId)) {\r\n                        return;\r\n                    }\r\n                    peer.rooms.add(roomId);\r\n\r\n\r\n                    const room = getFromMapOrCreate(\r\n                        peersByRoom,\r\n                        message.room,\r\n                        () => new Set()\r\n                    );\r\n\r\n                    room.add(peerId);\r\n\r\n                    // tell everyone about new room state\r\n                    room.forEach(otherPeerId => {\r\n                        const otherPeer = peerById.get(otherPeerId);\r\n                        if (otherPeer) {\r\n                            sendMessage(\r\n                                otherPeer.socket,\r\n                                {\r\n                                    type: 'joined',\r\n                                    otherPeerIds: Array.from(room)\r\n                                }\r\n                            );\r\n                        }\r\n                    });\r\n                    break;\r\n                case 'signal':\r\n                    if (\r\n                        message.senderPeerId !== peerId\r\n                    ) {\r\n                        disconnectSocket(peerId, 'spoofed sender');\r\n                        return;\r\n                    }\r\n                    const receiver = peerById.get(message.receiverPeerId);\r\n                    if (receiver) {\r\n                        sendMessage(\r\n                            receiver.socket,\r\n                            message\r\n                        );\r\n                    }\r\n                    break;\r\n                case 'ping':\r\n                    break;\r\n                default:\r\n                    disconnectSocket(peerId, 'unknown message type ' + type);\r\n            }\r\n\r\n        });\r\n    });\r\n\r\n    return {\r\n        port: serverOptions.port,\r\n        server: wss,\r\n        localUrl: 'ws://localhost:' + serverOptions.port\r\n    };\r\n}\r\n\r\n\r\nfunction sendMessage(ws: WebSocket, message: PeerMessage) {\r\n    const msgString = JSON.stringify(message);\r\n    ws.send(msgString);\r\n}\r\n\r\nfunction validateIdString(roomId: string): boolean {\r\n    if (\r\n        typeof roomId === 'string' &&\r\n        roomId.length > 5 &&\r\n        roomId.length < 100\r\n    ) {\r\n        return true;\r\n    } else {\r\n        return false;\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/replication-webrtc/webrtc-helper.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMasterInWebRTCReplication = isMasterInWebRTCReplication;
+exports.sendMessageAndAwaitAnswer = sendMessageAndAwaitAnswer;
+var _rxjs = require("rxjs");
+/**
+ * To deterministically define which peer is master and
+ * which peer is fork, we compare the storage tokens.
+ * But we have to hash them before, to ensure that
+ * a storageToken like 'aaaaaa' is not always the master
+ * for all peers.
+ */
+async function isMasterInWebRTCReplication(hashFunction, ownStorageToken, otherStorageToken) {
+  var isMaster = (await hashFunction([ownStorageToken, otherStorageToken].join('|'))) > (await hashFunction([otherStorageToken, ownStorageToken].join('|')));
+  return isMaster;
+}
+
+/**
+ * Send a message to the peer and await the answer.
+ * @throws with an EmptyErrorImpl if the peer connection
+ * was closed before an answer was received.
+ */
+function sendMessageAndAwaitAnswer(handler, peer, message) {
+  var requestId = message.id;
+  var answerPromise = (0, _rxjs.firstValueFrom)(handler.response$.pipe((0, _rxjs.filter)(d => d.peer === peer), (0, _rxjs.filter)(d => d.response.id === requestId), (0, _rxjs.map)(d => d.response)));
+  handler.send(peer, message);
+  return answerPromise;
+}
+//# sourceMappingURL=webrtc-helper.js.map

package/dist/cjs/plugins/replication-webrtc/webrtc-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc-helper.js","names":["_rxjs","require","isMasterInWebRTCReplication","hashFunction","ownStorageToken","otherStorageToken","isMaster","join","sendMessageAndAwaitAnswer","handler","peer","message","requestId","id","answerPromise","firstValueFrom","response$","pipe","filter","d","response","map","send"],"sources":["../../../../src/plugins/replication-webrtc/webrtc-helper.ts"],"sourcesContent":["import type {\r\n    HashFunction\r\n} from '../../types/index.d.ts';\r\nimport type {\r\n    WebRTCConnectionHandler,\r\n    WebRTCMessage,\r\n    WebRTCResponse,\r\n    PeerWithResponse\r\n} from './webrtc-types.ts';\r\nimport { filter, firstValueFrom, map } from 'rxjs';\r\n\r\n\r\n\r\n/**\r\n * To deterministically define which peer is master and\r\n * which peer is fork, we compare the storage tokens.\r\n * But we have to hash them before, to ensure that\r\n * a storageToken like 'aaaaaa' is not always the master\r\n * for all peers.\r\n */\r\nexport async function isMasterInWebRTCReplication(\r\n    hashFunction: HashFunction,\r\n    ownStorageToken: string,\r\n    otherStorageToken: string\r\n): Promise<boolean> {\r\n    const isMaster =\r\n        await hashFunction([ownStorageToken, otherStorageToken].join('|'))\r\n        >\r\n        await hashFunction([otherStorageToken, ownStorageToken].join('|'));\r\n    return isMaster;\r\n}\r\n\r\n/**\r\n * Send a message to the peer and await the answer.\r\n * @throws with an EmptyErrorImpl if the peer connection\r\n * was closed before an answer was received.\r\n */\r\nexport function sendMessageAndAwaitAnswer<PeerType>(\r\n    handler: WebRTCConnectionHandler<PeerType>,\r\n    peer: PeerType,\r\n    message: WebRTCMessage\r\n): Promise<WebRTCResponse> {\r\n\r\n\r\n    const requestId = message.id;\r\n    const answerPromise = firstValueFrom(\r\n        handler.response$.pipe(\r\n            filter((d: PeerWithResponse<PeerType>) => d.peer === peer),\r\n            filter((d: PeerWithResponse<PeerType>) => d.response.id === requestId),\r\n            map((d: PeerWithResponse<PeerType>) => d.response)\r\n        )\r\n    );\r\n    handler.send(peer, message);\r\n    return answerPromise;\r\n}\r\n"],"mappings":";;;;;;;AASA,IAAAA,KAAA,GAAAC,OAAA;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAeC,2BAA2BA,CAC7CC,YAA0B,EAC1BC,eAAuB,EACvBC,iBAAyB,EACT;EAChB,IAAMC,QAAQ,GACV,OAAMH,YAAY,CAAC,CAACC,eAAe,EAAEC,iBAAiB,CAAC,CAACE,IAAI,CAAC,GAAG,CAAC,CAAC,KAElE,MAAMJ,YAAY,CAAC,CAACE,iBAAiB,EAAED,eAAe,CAAC,CAACG,IAAI,CAAC,GAAG,CAAC,CAAC;EACtE,OAAOD,QAAQ;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASE,yBAAyBA,CACrCC,OAA0C,EAC1CC,IAAc,EACdC,OAAsB,EACC;EAGvB,IAAMC,SAAS,GAAGD,OAAO,CAACE,EAAE;EAC5B,IAAMC,aAAa,GAAG,IAAAC,oBAAc,EAChCN,OAAO,CAACO,SAAS,CAACC,IAAI,CAClB,IAAAC,YAAM,EAAEC,CAA6B,IAAKA,CAAC,CAACT,IAAI,KAAKA,IAAI,CAAC,EAC1D,IAAAQ,YAAM,EAAEC,CAA6B,IAAKA,CAAC,CAACC,QAAQ,CAACP,EAAE,KAAKD,SAAS,CAAC,EACtE,IAAAS,SAAG,EAAEF,CAA6B,IAAKA,CAAC,CAACC,QAAQ,CACrD,CACJ,CAAC;EACDX,OAAO,CAACa,IAAI,CAACZ,IAAI,EAAEC,OAAO,CAAC;EAC3B,OAAOG,aAAa;AACxB","ignoreList":[]}

package/dist/cjs/plugins/replication-webrtc/webrtc-types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=webrtc-types.js.map

package/dist/cjs/plugins/replication-webrtc/webrtc-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc-types.js","names":[],"sources":["../../../../src/plugins/replication-webrtc/webrtc-types.ts"],"sourcesContent":["import { Observable, Subscription } from 'rxjs';\r\nimport type {\r\n    MaybePromise,\r\n    ReplicationOptions,\r\n    ReplicationPullOptions,\r\n    ReplicationPushOptions,\r\n    RxError,\r\n    RxReplicationHandler,\r\n    RxStorageDefaultCheckpoint,\r\n    RxTypeError,\r\n    StringKeys\r\n} from '../../types/index.d.ts';\r\nimport { RxReplicationState } from '../replication/index.ts';\r\nimport { WebsocketMessageResponseType, WebsocketMessageType } from '../replication-websocket/index.ts';\r\n\r\nexport type WebRTCReplicationCheckpoint = RxStorageDefaultCheckpoint;\r\n\r\n\r\nexport type WebRTCMessage = Omit<WebsocketMessageType, 'method' | 'collection'> & {\r\n    method: StringKeys<RxReplicationHandler<any, any>> | 'token';\r\n};\r\nexport type WebRTCResponse = Omit<WebsocketMessageResponseType, 'collection'>;\r\nexport type PeerWithMessage<PeerType> = {\r\n    peer: PeerType;\r\n    message: WebRTCMessage;\r\n};\r\nexport type PeerWithResponse<PeerType> = {\r\n    peer: PeerType;\r\n    response: WebRTCResponse;\r\n};\r\n\r\nexport type WebRTCConnectionHandler<PeerType> = {\r\n    connect$: Observable<PeerType>;\r\n    disconnect$: Observable<PeerType>;\r\n    message$: Observable<PeerWithMessage<PeerType>>;\r\n    response$: Observable<PeerWithResponse<PeerType>>;\r\n    error$: Observable<RxError | RxTypeError>;\r\n    send(peer: PeerType, message: WebRTCMessage | WebRTCResponse): Promise<void>;\r\n    close(): Promise<void>;\r\n};\r\n\r\nexport type WebRTCConnectionHandlerCreator<PeerType> = (\r\n    opts: SyncOptionsWebRTC<any, PeerType>\r\n) => Promise<WebRTCConnectionHandler<PeerType>>;\r\n\r\nexport type WebRTCSyncPushOptions<RxDocType> = Omit<\r\n    ReplicationPushOptions<RxDocType>,\r\n    'handler'\r\n> & {};\r\n\r\nexport type WebRTCSyncPullOptions<RxDocType> = Omit<\r\n    ReplicationPullOptions<RxDocType, WebRTCReplicationCheckpoint>,\r\n    'handler' | 'stream$'\r\n> & {};\r\n\r\nexport type SyncOptionsWebRTC<RxDocType, PeerType> = Omit<\r\n    ReplicationOptions<RxDocType, WebRTCReplicationCheckpoint>,\r\n    'pull' |\r\n    'push' |\r\n    'replicationIdentifier' |\r\n    'deletedField' |\r\n    'live' |\r\n    'autostart' |\r\n    'waitForLeadership'\r\n> & {\r\n    /**\r\n     * It will only replicate with other instances\r\n     * that use the same topic.\r\n     */\r\n    topic: string;\r\n    connectionHandlerCreator: WebRTCConnectionHandlerCreator<PeerType>;\r\n    /**\r\n     * Run on new peers so that bad peers can be blocked.\r\n     * If returns true, the peer is valid and it will replicate.\r\n     * If returns false, it will drop the peer.\r\n     */\r\n    isPeerValid?: (peer: PeerType) => MaybePromise<boolean>;\r\n    pull?: WebRTCSyncPullOptions<RxDocType>;\r\n    push?: WebRTCSyncPushOptions<RxDocType>;\r\n};\r\n\r\nexport type RxWebRTCReplicationState<RxDocType> = RxReplicationState<RxDocType, WebRTCReplicationCheckpoint>;\r\n\r\n\r\nexport type WebRTCPeerState<RxDocType, PeerType> = {\r\n    peer: PeerType;\r\n    // only exists when the peer was picked as master and the own client was picked as fork.\r\n    replicationState?: RxWebRTCReplicationState<RxDocType>;\r\n    // clean this up when removing the peer\r\n    subs: Subscription[];\r\n};\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/plugins/replication-websocket/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _websocketClient = require("./websocket-client.js");
+Object.keys(_websocketClient).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _websocketClient[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _websocketClient[key];
+    }
+  });
+});
+var _websocketServer = require("./websocket-server.js");
+Object.keys(_websocketServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _websocketServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _websocketServer[key];
+    }
+  });
+});
+var _websocketTypes = require("./websocket-types.js");
+Object.keys(_websocketTypes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _websocketTypes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _websocketTypes[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/plugins/replication-websocket/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_websocketClient","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_websocketServer","_websocketTypes"],"sources":["../../../../src/plugins/replication-websocket/index.ts"],"sourcesContent":["export * from './websocket-client.ts';\r\nexport * from './websocket-server.ts';\r\nexport * from './websocket-types.ts';\r\n"],"mappings":";;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,gBAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,gBAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,gBAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,gBAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,gBAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,gBAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,gBAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,eAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,eAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,eAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,eAAA,CAAAN,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/dist/cjs/plugins/replication-websocket/websocket-client.js

@@ -0,0 +1,133 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWebSocketClient = createWebSocketClient;
+exports.replicateWithWebsocketServer = replicateWithWebsocketServer;
+var _index = require("../replication/index.js");
+var _reconnectingWebsocket = _interopRequireDefault(require("reconnecting-websocket"));
+var _ws = require("ws");
+var _index2 = require("../../plugins/utils/index.js");
+var _rxjs = require("rxjs");
+var _rxError = require("../../rx-error.js");
+async function createWebSocketClient(options) {
+  var wsClient = new _reconnectingWebsocket.default(options.url, [], {
+    WebSocket: _ws.WebSocket
+  });
+  var connected$ = new _rxjs.BehaviorSubject(false);
+  var message$ = new _rxjs.Subject();
+  var error$ = new _rxjs.Subject();
+  wsClient.onerror = err => {
+    console.log('--- WAS CLIENT GOT ERROR:');
+    console.log(err.error.message);
+    var emitError = (0, _rxError.newRxError)('RC_STREAM', {
+      errors: (0, _index2.toArray)(err).map(er => (0, _index2.errorToPlainJson)(er)),
+      direction: 'pull'
+    });
+    error$.next(emitError);
+  };
+  await new Promise(res => {
+    wsClient.onopen = () => {
+      if (options.headers) {
+        var authMessage = {
+          collection: options.collection.name,
+          id: (0, _index2.randomToken)(10),
+          params: [options.headers],
+          method: 'auth'
+        };
+        wsClient.send(JSON.stringify(authMessage));
+      }
+      connected$.next(true);
+      res();
+    };
+  });
+  wsClient.onclose = () => {
+    connected$.next(false);
+  };
+  wsClient.onmessage = messageObj => {
+    var message = JSON.parse(messageObj.data);
+    message$.next(message);
+  };
+  return {
+    url: options.url,
+    socket: wsClient,
+    connected$,
+    message$,
+    error$
+  };
+}
+async function replicateWithWebsocketServer(options) {
+  var websocketClient = await createWebSocketClient(options);
+  var wsClient = websocketClient.socket;
+  var messages$ = websocketClient.message$;
+  var requestCounter = 0;
+  var requestFlag = (0, _index2.randomToken)(10);
+  function getRequestId() {
+    var count = requestCounter++;
+    return options.collection.database.token + '|' + requestFlag + '|' + count;
+  }
+  var replicationState = (0, _index.replicateRxCollection)({
+    collection: options.collection,
+    replicationIdentifier: options.replicationIdentifier,
+    live: options.live,
+    pull: {
+      batchSize: options.batchSize,
+      stream$: messages$.pipe((0, _rxjs.filter)(msg => msg.id === 'stream' && msg.collection === options.collection.name), (0, _rxjs.map)(msg => msg.result)),
+      async handler(lastPulledCheckpoint, batchSize) {
+        var requestId = getRequestId();
+        var request = {
+          id: requestId,
+          collection: options.collection.name,
+          method: 'masterChangesSince',
+          params: [lastPulledCheckpoint, batchSize]
+        };
+        wsClient.send(JSON.stringify(request));
+        var result = await (0, _rxjs.firstValueFrom)(messages$.pipe((0, _rxjs.filter)(msg => msg.id === requestId), (0, _rxjs.map)(msg => msg.result)));
+        return result;
+      }
+    },
+    push: {
+      batchSize: options.batchSize,
+      handler(docs) {
+        var requestId = getRequestId();
+        var request = {
+          id: requestId,
+          collection: options.collection.name,
+          method: 'masterWrite',
+          params: [docs]
+        };
+        wsClient.send(JSON.stringify(request));
+        return (0, _rxjs.firstValueFrom)(messages$.pipe((0, _rxjs.filter)(msg => msg.id === requestId), (0, _rxjs.map)(msg => msg.result)));
+      }
+    }
+  });
+  websocketClient.error$.subscribe(err => replicationState.subjects.error.next(err));
+  websocketClient.connected$.subscribe(isConnected => {
+    if (isConnected) {
+      /**
+       * When the client goes offline and online again,
+       * we have to send a 'RESYNC' signal because the client
+       * might have missed out events while being offline.
+       */
+      replicationState.reSync();
+
+      /**
+       * Because reconnecting creates a new websocket-instance,
+       * we have to start the changestream from the remote again
+       * each time.
+       */
+      var streamRequest = {
+        id: 'stream',
+        collection: options.collection.name,
+        method: 'masterChangeStream$',
+        params: []
+      };
+      wsClient.send(JSON.stringify(streamRequest));
+    }
+  });
+  options.collection.onClose.push(() => websocketClient.socket.close());
+  return replicationState;
+}
+//# sourceMappingURL=websocket-client.js.map

package/dist/cjs/plugins/replication-websocket/websocket-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-client.js","names":["_index","require","_reconnectingWebsocket","_interopRequireDefault","_ws","_index2","_rxjs","_rxError","createWebSocketClient","options","wsClient","ReconnectingWebSocket","url","WebSocket","connected$","BehaviorSubject","message$","Subject","error$","onerror","err","console","log","error","message","emitError","newRxError","errors","toArray","map","er","errorToPlainJson","direction","next","Promise","res","onopen","headers","authMessage","collection","name","id","randomToken","params","method","send","JSON","stringify","onclose","onmessage","messageObj","parse","data","socket","replicateWithWebsocketServer","websocketClient","messages$","requestCounter","requestFlag","getRequestId","count","database","token","replicationState","replicateRxCollection","replicationIdentifier","live","pull","batchSize","stream$","pipe","filter","msg","result","handler","lastPulledCheckpoint","requestId","request","firstValueFrom","push","docs","subscribe","subjects","isConnected","reSync","streamRequest","onClose","close"],"sources":["../../../../src/plugins/replication-websocket/websocket-client.ts"],"sourcesContent":["import {\r\n    replicateRxCollection,\r\n    RxReplicationState\r\n} from '../replication/index.ts';\r\nimport {\r\n    WebsocketClientOptions,\r\n    WebsocketMessageResponseType,\r\n    WebsocketMessageType\r\n} from './websocket-types.ts';\r\n\r\nimport ReconnectingWebSocket from 'reconnecting-websocket';\r\n\r\nimport { WebSocket } from 'ws';\r\nimport {\r\n    errorToPlainJson,\r\n    randomToken,\r\n    toArray\r\n} from '../../plugins/utils/index.ts';\r\nimport {\r\n    filter,\r\n    map,\r\n    Subject,\r\n    firstValueFrom,\r\n    BehaviorSubject\r\n} from 'rxjs';\r\nimport type {\r\n    RxError,\r\n    RxReplicationWriteToMasterRow\r\n} from '../../types/index.d.ts';\r\nimport { newRxError } from '../../rx-error.ts';\r\n\r\nexport type WebsocketClient = {\r\n    url: string;\r\n    socket: any;\r\n    connected$: BehaviorSubject<boolean>;\r\n    message$: Subject<any>;\r\n    error$: Subject<RxError>;\r\n};\r\n\r\n\r\nexport async function createWebSocketClient<RxDocType>(options: WebsocketClientOptions<RxDocType>): Promise<WebsocketClient> {\r\n    const wsClient = new ReconnectingWebSocket(\r\n        options.url,\r\n        [],\r\n        { WebSocket }\r\n    );\r\n    const connected$ = new BehaviorSubject<boolean>(false);\r\n    const message$ = new Subject<any>();\r\n    const error$ = new Subject<any>();\r\n    wsClient.onerror = (err: any) => {\r\n\r\n        console.log('--- WAS CLIENT GOT ERROR:');\r\n        console.log(err.error.message);\r\n\r\n        const emitError = newRxError('RC_STREAM', {\r\n            errors: toArray(err).map((er: any) => errorToPlainJson(er)),\r\n            direction: 'pull'\r\n        });\r\n        error$.next(emitError);\r\n    };\r\n    await new Promise<void>(res => {\r\n        wsClient.onopen = () => {\r\n\r\n            if (options.headers) {\r\n                const authMessage: WebsocketMessageType = {\r\n                    collection: options.collection.name,\r\n                    id: randomToken(10),\r\n                    params: [options.headers],\r\n                    method: 'auth'\r\n                };\r\n                wsClient.send(JSON.stringify(authMessage));\r\n            }\r\n\r\n            connected$.next(true);\r\n            res();\r\n        };\r\n    });\r\n    wsClient.onclose = () => {\r\n        connected$.next(false);\r\n    };\r\n\r\n    wsClient.onmessage = (messageObj: any) => {\r\n        const message = JSON.parse(messageObj.data);\r\n        message$.next(message);\r\n    };\r\n\r\n    return {\r\n        url: options.url,\r\n        socket: wsClient,\r\n        connected$,\r\n        message$,\r\n        error$\r\n    };\r\n\r\n}\r\n\r\nexport async function replicateWithWebsocketServer<RxDocType, CheckpointType>(\r\n    options: WebsocketClientOptions<RxDocType>\r\n): Promise<RxReplicationState<RxDocType, CheckpointType>> {\r\n    const websocketClient = await createWebSocketClient(options);\r\n    const wsClient = websocketClient.socket;\r\n    const messages$ = websocketClient.message$;\r\n\r\n    let requestCounter = 0;\r\n    const requestFlag = randomToken(10);\r\n    function getRequestId() {\r\n        const count = requestCounter++;\r\n        return options.collection.database.token + '|' + requestFlag + '|' + count;\r\n    }\r\n    const replicationState = replicateRxCollection<RxDocType, CheckpointType>({\r\n        collection: options.collection,\r\n        replicationIdentifier: options.replicationIdentifier,\r\n        live: options.live,\r\n        pull: {\r\n            batchSize: options.batchSize,\r\n            stream$: messages$.pipe(\r\n                filter((msg: WebsocketMessageResponseType) => msg.id === 'stream' && msg.collection === options.collection.name),\r\n                map((msg: WebsocketMessageResponseType) => msg.result)\r\n            ),\r\n            async handler(lastPulledCheckpoint: CheckpointType | undefined, batchSize: number) {\r\n                const requestId = getRequestId();\r\n                const request: WebsocketMessageType = {\r\n                    id: requestId,\r\n                    collection: options.collection.name,\r\n                    method: 'masterChangesSince',\r\n                    params: [lastPulledCheckpoint, batchSize]\r\n                };\r\n                wsClient.send(JSON.stringify(request));\r\n                const result = await firstValueFrom(\r\n                    messages$.pipe(\r\n                        filter((msg: WebsocketMessageResponseType) => msg.id === requestId),\r\n                        map((msg: WebsocketMessageResponseType) => msg.result)\r\n                    )\r\n                );\r\n                return result;\r\n            }\r\n        },\r\n        push: {\r\n            batchSize: options.batchSize,\r\n            handler(docs: RxReplicationWriteToMasterRow<RxDocType>[]) {\r\n                const requestId = getRequestId();\r\n                const request: WebsocketMessageType = {\r\n                    id: requestId,\r\n                    collection: options.collection.name,\r\n                    method: 'masterWrite',\r\n                    params: [docs]\r\n                };\r\n                wsClient.send(JSON.stringify(request));\r\n                return firstValueFrom(\r\n                    messages$.pipe(\r\n                        filter((msg: WebsocketMessageResponseType) => msg.id === requestId),\r\n                        map((msg: WebsocketMessageResponseType) => msg.result)\r\n                    )\r\n                );\r\n            }\r\n        }\r\n    });\r\n\r\n    websocketClient.error$.subscribe((err: RxError) => replicationState.subjects.error.next(err));\r\n\r\n    websocketClient.connected$.subscribe((isConnected: boolean) => {\r\n        if (isConnected) {\r\n            /**\r\n             * When the client goes offline and online again,\r\n             * we have to send a 'RESYNC' signal because the client\r\n             * might have missed out events while being offline.\r\n             */\r\n            replicationState.reSync();\r\n\r\n            /**\r\n             * Because reconnecting creates a new websocket-instance,\r\n             * we have to start the changestream from the remote again\r\n             * each time.\r\n             */\r\n            const streamRequest: WebsocketMessageType = {\r\n                id: 'stream',\r\n                collection: options.collection.name,\r\n                method: 'masterChangeStream$',\r\n                params: []\r\n            };\r\n            wsClient.send(JSON.stringify(streamRequest));\r\n        }\r\n    });\r\n\r\n    options.collection.onClose.push(() => websocketClient.socket.close());\r\n    return replicationState;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/replication-websocket/websocket-server.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReplicationHandlerByCollection = getReplicationHandlerByCollection;
+exports.startSocketServer = startSocketServer;
+exports.startWebsocketServer = startWebsocketServer;
+var _ws = require("ws");
+var _index = require("../../replication-protocol/index.js");
+var _index2 = require("../../plugins/utils/index.js");
+var _rxjs = require("rxjs");
+function startSocketServer(options) {
+  var wss = new _ws.WebSocketServer(options);
+  var closed = false;
+  function closeServer() {
+    if (closed) {
+      return _index2.PROMISE_RESOLVE_VOID;
+    }
+    closed = true;
+    onConnection$.complete();
+    return new Promise((res, rej) => {
+      /**
+       * We have to close all client connections,
+       * otherwise wss.close() will never call the callback.
+       * @link https://github.com/websockets/ws/issues/1288#issuecomment-360594458
+       */
+      for (var ws of wss.clients) {
+        ws.close();
+      }
+      wss.close(err => {
+        if (err) {
+          rej(err);
+        } else {
+          res();
+        }
+      });
+    });
+  }
+  var onConnection$ = new _rxjs.Subject();
+  wss.on('connection', ws => onConnection$.next(ws));
+  return {
+    server: wss,
+    close: closeServer,
+    onConnection$: onConnection$.asObservable()
+  };
+}
+var REPLICATION_HANDLER_BY_COLLECTION = new Map();
+function getReplicationHandlerByCollection(database, collectionName) {
+  if (!database.collections[collectionName]) {
+    throw new Error('collection ' + collectionName + ' does not exist');
+  }
+  var collection = database.collections[collectionName];
+  var handler = (0, _index2.getFromMapOrCreate)(REPLICATION_HANDLER_BY_COLLECTION, collection, () => {
+    return (0, _index.rxStorageInstanceToReplicationHandler)(collection.storageInstance, collection.conflictHandler, database.token);
+  });
+  return handler;
+}
+function startWebsocketServer(options) {
+  var {
+    database,
+    ...wsOptions
+  } = options;
+  var serverState = startSocketServer(wsOptions);
+
+  // auto close when the database gets closed
+  database.onClose.push(() => serverState.close());
+  serverState.onConnection$.subscribe(ws => {
+    var onCloseHandlers = [];
+    ws.onclose = () => {
+      onCloseHandlers.map(fn => fn());
+    };
+    ws.on('message', async messageString => {
+      var message = JSON.parse(messageString);
+      var handler = getReplicationHandlerByCollection(database, message.collection);
+      if (message.method === 'auth') {
+        return;
+      }
+      var method = handler[message.method];
+
+      /**
+       * If it is not a function,
+       * it means that the client requested the masterChangeStream$
+       */
+      if (typeof method !== 'function') {
+        var changeStreamSub = handler.masterChangeStream$.subscribe(ev => {
+          var streamResponse = {
+            id: 'stream',
+            collection: message.collection,
+            result: ev
+          };
+          ws.send(JSON.stringify(streamResponse));
+        });
+        onCloseHandlers.push(() => changeStreamSub.unsubscribe());
+        return;
+      }
+      var result = await method(...message.params);
+      var response = {
+        id: message.id,
+        collection: message.collection,
+        result
+      };
+      ws.send(JSON.stringify(response));
+    });
+  });
+  return serverState;
+}
+//# sourceMappingURL=websocket-server.js.map

package/dist/cjs/plugins/replication-websocket/websocket-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-server.js","names":["_ws","require","_index","_index2","_rxjs","startSocketServer","options","wss","WebSocketServer","closed","closeServer","PROMISE_RESOLVE_VOID","onConnection$","complete","Promise","res","rej","ws","clients","close","err","Subject","on","next","server","asObservable","REPLICATION_HANDLER_BY_COLLECTION","Map","getReplicationHandlerByCollection","database","collectionName","collections","Error","collection","handler","getFromMapOrCreate","rxStorageInstanceToReplicationHandler","storageInstance","conflictHandler","token","startWebsocketServer","wsOptions","serverState","onClose","push","subscribe","onCloseHandlers","onclose","map","fn","messageString","message","JSON","parse","method","changeStreamSub","masterChangeStream$","ev","streamResponse","id","result","send","stringify","unsubscribe","params","response"],"sources":["../../../../src/plugins/replication-websocket/websocket-server.ts"],"sourcesContent":["import type {\r\n    RxCollection,\r\n    RxDatabase,\r\n    RxReplicationHandler\r\n} from '../../types/index.d.ts';\r\n\r\nimport {\r\n    type WebSocket,\r\n    WebSocketServer,\r\n    type ServerOptions,\r\n} from 'ws';\r\n\r\nimport type {\r\n    WebsocketMessageResponseType,\r\n    WebsocketMessageType,\r\n    WebsocketServerOptions,\r\n    WebsocketServerState\r\n} from './websocket-types.ts';\r\nimport { rxStorageInstanceToReplicationHandler } from '../../replication-protocol/index.ts';\r\nimport {\r\n    PROMISE_RESOLVE_VOID, getFromMapOrCreate\r\n} from '../../plugins/utils/index.ts';\r\nimport { Subject } from 'rxjs';\r\n\r\nexport function startSocketServer(options: ServerOptions): WebsocketServerState {\r\n    const wss = new WebSocketServer(options);\r\n    let closed = false;\r\n    function closeServer() {\r\n        if (closed) {\r\n            return PROMISE_RESOLVE_VOID;\r\n        }\r\n        closed = true;\r\n        onConnection$.complete();\r\n        return new Promise<void>((res, rej) => {\r\n            /**\r\n             * We have to close all client connections,\r\n             * otherwise wss.close() will never call the callback.\r\n             * @link https://github.com/websockets/ws/issues/1288#issuecomment-360594458\r\n             */\r\n            for (const ws of wss.clients) {\r\n                ws.close();\r\n            }\r\n            wss.close((err: any) => {\r\n                if (err) {\r\n                    rej(err);\r\n                } else {\r\n                    res();\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    const onConnection$ = new Subject<WebSocket>();\r\n    wss.on('connection', (ws: any) => onConnection$.next(ws));\r\n\r\n    return {\r\n        server: wss,\r\n        close: closeServer,\r\n        onConnection$: onConnection$.asObservable()\r\n    };\r\n}\r\n\r\nconst REPLICATION_HANDLER_BY_COLLECTION: WeakMap<RxCollection, RxReplicationHandler<any, any>> = new Map();\r\nexport function getReplicationHandlerByCollection<RxDocType>(\r\n    database: RxDatabase<any>,\r\n    collectionName: string\r\n): RxReplicationHandler<RxDocType, any> {\r\n    if (!database.collections[collectionName]) {\r\n        throw new Error('collection ' + collectionName + ' does not exist');\r\n    }\r\n\r\n    const collection = database.collections[collectionName];\r\n    const handler = getFromMapOrCreate<RxCollection, RxReplicationHandler<RxDocType, any>>(\r\n        REPLICATION_HANDLER_BY_COLLECTION,\r\n        collection,\r\n        () => {\r\n            return rxStorageInstanceToReplicationHandler(\r\n                collection.storageInstance,\r\n                collection.conflictHandler,\r\n                database.token\r\n            );\r\n        }\r\n    );\r\n    return handler;\r\n}\r\n\r\nexport function startWebsocketServer(options: WebsocketServerOptions): WebsocketServerState {\r\n    const { database, ...wsOptions } = options;\r\n    const serverState = startSocketServer(wsOptions as any);\r\n\r\n    // auto close when the database gets closed\r\n    database.onClose.push(() => serverState.close());\r\n\r\n    serverState.onConnection$.subscribe((ws: WebSocket) => {\r\n        const onCloseHandlers: Function[] = [];\r\n        ws.onclose = () => {\r\n            onCloseHandlers.map(fn => fn());\r\n        };\r\n        ws.on('message', async (messageString: string) => {\r\n            const message: WebsocketMessageType = JSON.parse(messageString);\r\n            const handler = getReplicationHandlerByCollection(database, message.collection);\r\n            if (message.method === 'auth') {\r\n                return;\r\n            }\r\n            const method = handler[message.method];\r\n\r\n            /**\r\n             * If it is not a function,\r\n             * it means that the client requested the masterChangeStream$\r\n             */\r\n            if (typeof method !== 'function') {\r\n                const changeStreamSub = handler.masterChangeStream$.subscribe((ev: any) => {\r\n                    const streamResponse: WebsocketMessageResponseType = {\r\n                        id: 'stream',\r\n                        collection: message.collection,\r\n                        result: ev\r\n                    };\r\n                    ws.send(JSON.stringify(streamResponse));\r\n                });\r\n                onCloseHandlers.push(() => changeStreamSub.unsubscribe());\r\n                return;\r\n            }\r\n            const result = await (method as any)(...message.params);\r\n            const response: WebsocketMessageResponseType = {\r\n                id: message.id,\r\n                collection: message.collection,\r\n                result\r\n            };\r\n            ws.send(JSON.stringify(response));\r\n        });\r\n    });\r\n\r\n\r\n    return serverState;\r\n}\r\n"],"mappings":";;;;;;;;AAMA,IAAAA,GAAA,GAAAC,OAAA;AAYA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAGA,IAAAG,KAAA,GAAAH,OAAA;AAEO,SAASI,iBAAiBA,CAACC,OAAsB,EAAwB;EAC5E,IAAMC,GAAG,GAAG,IAAIC,mBAAe,CAACF,OAAO,CAAC;EACxC,IAAIG,MAAM,GAAG,KAAK;EAClB,SAASC,WAAWA,CAAA,EAAG;IACnB,IAAID,MAAM,EAAE;MACR,OAAOE,4BAAoB;IAC/B;IACAF,MAAM,GAAG,IAAI;IACbG,aAAa,CAACC,QAAQ,CAAC,CAAC;IACxB,OAAO,IAAIC,OAAO,CAAO,CAACC,GAAG,EAAEC,GAAG,KAAK;MACnC;AACZ;AACA;AACA;AACA;MACY,KAAK,IAAMC,EAAE,IAAIV,GAAG,CAACW,OAAO,EAAE;QAC1BD,EAAE,CAACE,KAAK,CAAC,CAAC;MACd;MACAZ,GAAG,CAACY,KAAK,CAAEC,GAAQ,IAAK;QACpB,IAAIA,GAAG,EAAE;UACLJ,GAAG,CAACI,GAAG,CAAC;QACZ,CAAC,MAAM;UACHL,GAAG,CAAC,CAAC;QACT;MACJ,CAAC,CAAC;IACN,CAAC,CAAC;EACN;EAEA,IAAMH,aAAa,GAAG,IAAIS,aAAO,CAAY,CAAC;EAC9Cd,GAAG,CAACe,EAAE,CAAC,YAAY,EAAGL,EAAO,IAAKL,aAAa,CAACW,IAAI,CAACN,EAAE,CAAC,CAAC;EAEzD,OAAO;IACHO,MAAM,EAAEjB,GAAG;IACXY,KAAK,EAAET,WAAW;IAClBE,aAAa,EAAEA,aAAa,CAACa,YAAY,CAAC;EAC9C,CAAC;AACL;AAEA,IAAMC,iCAAwF,GAAG,IAAIC,GAAG,CAAC,CAAC;AACnG,SAASC,iCAAiCA,CAC7CC,QAAyB,EACzBC,cAAsB,EACc;EACpC,IAAI,CAACD,QAAQ,CAACE,WAAW,CAACD,cAAc,CAAC,EAAE;IACvC,MAAM,IAAIE,KAAK,CAAC,aAAa,GAAGF,cAAc,GAAG,iBAAiB,CAAC;EACvE;EAEA,IAAMG,UAAU,GAAGJ,QAAQ,CAACE,WAAW,CAACD,cAAc,CAAC;EACvD,IAAMI,OAAO,GAAG,IAAAC,0BAAkB,EAC9BT,iCAAiC,EACjCO,UAAU,EACV,MAAM;IACF,OAAO,IAAAG,4CAAqC,EACxCH,UAAU,CAACI,eAAe,EAC1BJ,UAAU,CAACK,eAAe,EAC1BT,QAAQ,CAACU,KACb,CAAC;EACL,CACJ,CAAC;EACD,OAAOL,OAAO;AAClB;AAEO,SAASM,oBAAoBA,CAAClC,OAA+B,EAAwB;EACxF,IAAM;IAAEuB,QAAQ;IAAE,GAAGY;EAAU,CAAC,GAAGnC,OAAO;EAC1C,IAAMoC,WAAW,GAAGrC,iBAAiB,CAACoC,SAAgB,CAAC;;EAEvD;EACAZ,QAAQ,CAACc,OAAO,CAACC,IAAI,CAAC,MAAMF,WAAW,CAACvB,KAAK,CAAC,CAAC,CAAC;EAEhDuB,WAAW,CAAC9B,aAAa,CAACiC,SAAS,CAAE5B,EAAa,IAAK;IACnD,IAAM6B,eAA2B,GAAG,EAAE;IACtC7B,EAAE,CAAC8B,OAAO,GAAG,MAAM;MACfD,eAAe,CAACE,GAAG,CAACC,EAAE,IAAIA,EAAE,CAAC,CAAC,CAAC;IACnC,CAAC;IACDhC,EAAE,CAACK,EAAE,CAAC,SAAS,EAAE,MAAO4B,aAAqB,IAAK;MAC9C,IAAMC,OAA6B,GAAGC,IAAI,CAACC,KAAK,CAACH,aAAa,CAAC;MAC/D,IAAMhB,OAAO,GAAGN,iCAAiC,CAACC,QAAQ,EAAEsB,OAAO,CAAClB,UAAU,CAAC;MAC/E,IAAIkB,OAAO,CAACG,MAAM,KAAK,MAAM,EAAE;QAC3B;MACJ;MACA,IAAMA,MAAM,GAAGpB,OAAO,CAACiB,OAAO,CAACG,MAAM,CAAC;;MAEtC;AACZ;AACA;AACA;MACY,IAAI,OAAOA,MAAM,KAAK,UAAU,EAAE;QAC9B,IAAMC,eAAe,GAAGrB,OAAO,CAACsB,mBAAmB,CAACX,SAAS,CAAEY,EAAO,IAAK;UACvE,IAAMC,cAA4C,GAAG;YACjDC,EAAE,EAAE,QAAQ;YACZ1B,UAAU,EAAEkB,OAAO,CAAClB,UAAU;YAC9B2B,MAAM,EAAEH;UACZ,CAAC;UACDxC,EAAE,CAAC4C,IAAI,CAACT,IAAI,CAACU,SAAS,CAACJ,cAAc,CAAC,CAAC;QAC3C,CAAC,CAAC;QACFZ,eAAe,CAACF,IAAI,CAAC,MAAMW,eAAe,CAACQ,WAAW,CAAC,CAAC,CAAC;QACzD;MACJ;MACA,IAAMH,MAAM,GAAG,MAAON,MAAM,CAAS,GAAGH,OAAO,CAACa,MAAM,CAAC;MACvD,IAAMC,QAAsC,GAAG;QAC3CN,EAAE,EAAER,OAAO,CAACQ,EAAE;QACd1B,UAAU,EAAEkB,OAAO,CAAClB,UAAU;QAC9B2B;MACJ,CAAC;MACD3C,EAAE,CAAC4C,IAAI,CAACT,IAAI,CAACU,SAAS,CAACG,QAAQ,CAAC,CAAC;IACrC,CAAC,CAAC;EACN,CAAC,CAAC;EAGF,OAAOvB,WAAW;AACtB","ignoreList":[]}

package/dist/cjs/plugins/replication-websocket/websocket-types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=websocket-types.js.map

package/dist/cjs/plugins/replication-websocket/websocket-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-types.js","names":[],"sources":["../../../../src/plugins/replication-websocket/websocket-types.ts"],"sourcesContent":["import type {\r\n    Observable,\r\n} from 'rxjs';\r\nimport type {\r\n    ServerOptions,\r\n    ClientOptions,\r\n    WebSocketServer,\r\n    WebSocket\r\n} from 'ws';\r\nimport type {\r\n    RxCollection,\r\n    RxDatabase,\r\n    RxReplicationHandler,\r\n    StringKeys\r\n} from '../../types/index.d.ts';\r\n\r\nexport type WebsocketServerOptions = {\r\n    database: RxDatabase<any, any, any>;\r\n} & ServerOptions;\r\n\r\nexport type WebsocketServerState = {\r\n    server: WebSocketServer;\r\n    close: () => Promise<void>;\r\n    onConnection$: Observable<WebSocket>;\r\n};\r\n\r\nexport type WebsocketClientOptions<RxDocType> = {\r\n    replicationIdentifier: string;\r\n    collection: RxCollection<RxDocType>;\r\n    url: string;\r\n    batchSize?: number;\r\n    live?: boolean;\r\n    headers?: { [k: string]: string; };\r\n} & ClientOptions;\r\n\r\nexport type WebsocketMessageType = {\r\n    id: string;\r\n    collection: string;\r\n    method: StringKeys<RxReplicationHandler<any, any>> | 'auth';\r\n    params: any[];\r\n};\r\n\r\nexport type WebsocketMessageResponseType = {\r\n    id: string;\r\n    collection: string;\r\n    result: any;\r\n};\r\n"],"mappings":"","ignoreList":[]}