Source: components/room-bridge-store.js

  1. /**
  2.  * Room storage format:
  3.  * {
  4.  *   id: "matrix|remote|link_key",      // customisable
  5.  *   matrix_id: "room_id",
  6.  *   remote_id: "remote_room_id",
  7.  *   matrix: { serialised matrix room info },
  8.  *   remote: { serialised remote room info },
  9.  *   data: { ... any additional info ... }
  10.  * }
  11.  *
  12.  * Each document can either represent a matrix room, a remote room, or
  13.  * a mapping. They look like this:
  14.  * MATRIX
  15.  * {
  16.  *    id: "!room:id",
  17.  *    matrix_id: "!room:id",
  18.  *    matrix: { .. custom data eg name: "A happy place" .. }
  19.  * }
  20.  *
  21.  * REMOTE (e.g. IRC)
  22.  * {
  23.  *    id: "irc.freenode.net_#channame",
  24.  *    remote_id: "irc.freenode.net_#channame",
  25.  *    remote: { .. custom data e.g. is_pm_room: true .. }
  26.  * }
  27.  *
  28.  * MAPPING
  29.  * {
  30.  *    id: "!room:id__irc.freenode.net_#channame", // link key; customisable.
  31.  *    matrix_id: "!room:id",
  32.  *    remote_id: "irc.freenode.net_#channame",
  33.  *    matrix: { .. custom data .. },
  34.  *    remote: { .. custom data .. },
  35.  *    data: { .. custom data about the mapping ..}
  36.  * }
  37.  *
  38.  * A unique, non-sparse index can be set on the 'id' key, and non-unique,
  39.  * sparse indexes can be set on matrix_id and remote_id to make mappings
  40.  * quicker to compute.
  41.  *
  42.  */
  43. "use strict";
  44. var BridgeStore = require("./bridge-store");
  45. var MatrixRoom = require("../models/rooms/matrix");
  46. var RemoteRoom = require("../models/rooms/remote");
  47. var util = require("util");
  49. /**
  50.  * Construct a store suitable for room bridging information. Data is stored
  51.  * as {@link RoomBridgeStore~Entry}s which have the following
  52.  * <i>serialized</i> format:
  53.  * <pre>
  54.  * {
  55.  *   id: "unique_id",      // customisable
  56.  *   matrix_id: "room_id",
  57.  *   remote_id: "remote_room_id",
  58.  *   matrix: { serialised matrix room info },
  59.  *   remote: { serialised remote room info },
  60.  *   data: { ... any additional info ... }
  61.  * }
  62.  * </pre>
  63.  * <p>If a unique 'id' is not given, the store will generate one by concatenating
  64.  * the <code>matrix_id</code> and the <code>remote_id</code>. The delimiter
  65.  * used is a property on this store and can be modified.</p>
  66.  * <p>The structure of Entry objects means that it is efficient to select based
  67.  * off the 'id', 'matrix_id' or 'remote_id'. Additional indexes can be added
  68.  * manually.</p>
  69.  * @constructor
  70.  * @param {Datastore} db The connected NEDB database instance
  71.  * @param {Object} opts Options for this store.
  72.  * @property {string} delimiter The delimiter between matrix and
  73.  * remote IDs. Defaults to three spaces. If the schema of your remote IDs
  74.  * allows spaces, you will need to change this.
  75.  */
  76. function RoomBridgeStore(db, opts) {
  77.     this.db = db;
  78.     this.delimiter = "   ";
  79. }
  80. util.inherits(RoomBridgeStore, BridgeStore);
  82. /**
  83.  * Insert an entry, clobbering based on the ID of the entry.
  84.  * @param {RoomBridgeStore~Entry} entry
  85.  * @return {Promise}
  86.  */
  87. RoomBridgeStore.prototype.upsertEntry = function(entry) {
  88.     return this.upsert({
  89.         id: entry.id
  90.     }, serializeEntry(entry));
  91. }
  93. /**
  94.  * Get an existing entry based on the provided entry ID.
  95.  * @param {String} id The ID of the entry to retrieve.
  96.  * @return {?RoomBridgeStore~Entry} A promise which resolves to the entry or null.
  97.  */
  98. RoomBridgeStore.prototype.getEntryById = function(id) {
  99.     return this.selectOne({
  100.         id: id
  101.     }, this.convertTo(function(doc) {
  102.         return new Entry(doc);
  103.     }));
  104. }
  106. /**
  107.  * Get a list of entries based on the matrix_id of each entry.
  108.  * @param {string} matrixId
  109.  * @return {RoomBridgeStore~Entry[]}
  110.  */
  111. RoomBridgeStore.prototype.getEntriesByMatrixId = function(matrixId) {
  112.     return this.select({
  113.         matrix_id: matrixId
  114.     }, this.convertTo(function(doc) {
  115.         return new Entry(doc);
  116.     }));
  117. };
  119. /**
  120.  * A batch version of <code>getEntriesByMatrixId</code>.
  121.  * @param {String[]} ids
  122.  * @return {Object.<string,RoomBridgeStore~Entry[]>} Resolves
  123.  * to a map of room_id => Entry[]
  124.  */
  125. RoomBridgeStore.prototype.getEntriesByMatrixIds = function(ids) {
  126.     return this.select({
  127.         matrix_id: {
  128.             $in: ids
  129.         }
  130.     }).then(function(docs) {
  131.         var entries = {};
  132.         docs.forEach(function(doc) {
  133.             if (!entries[doc.matrix_id]) {
  134.                 entries[doc.matrix_id] = [];
  135.             }
  136.             entries[doc.matrix_id].push(new Entry(doc));
  137.         });
  138.         return entries;
  139.     });
  140. };
  142. /**
  143.  * Get a list of entries based on the remote_id of each entry.
  144.  * @param {String} remoteId
  145.  * @return {RoomBridgeStore~Entry[]}
  146.  */
  147. RoomBridgeStore.prototype.getEntriesByRemoteId = function(remoteId) {
  148.     return this.select({
  149.         remote_id: remoteId
  150.     }, this.convertTo(function(doc) {
  151.         return new Entry(doc);
  152.     }));
  153. };
  155. /**
  156.  * Create a link between a matrix room and remote room. This will create an entry with:
  157.  * <ul>
  158.  * <li>The matrix_id set to the matrix room ID.</li>
  159.  * <li>The remote_id set to the remote room ID.</li>
  160.  * <li>The id set to the id value given OR a concatenation of the matrix and remote IDs
  161.  * if one is not provided.</li>
  162.  * </ul>
  163.  * @param {MatrixRoom} matrixRoom The matrix room
  164.  * @param {RemoteRoom} remoteRoom The remote room
  165.  * @param {Object=} data Information about this mapping.
  166.  * @param {string=} linkId The id value to set. If not given, a unique ID will be
  167.  * created from the matrix_id and remote_id.
  168.  * @return {Promise}
  169.  */
  170. RoomBridgeStore.prototype.linkRooms = function(matrixRoom, remoteRoom, data, linkId) {
  171.     data = data || {};
  172.     linkId = linkId || createUniqueId(
  173.         matrixRoom.getId(), remoteRoom.getId(), this.delimiter
  174.     );
  175.     var self = this;
  176.     return self.upsert({
  177.         id: linkId
  178.     }, {
  179.         id: linkId,
  180.         remote_id: remoteRoom.getId(),
  181.         matrix_id: matrixRoom.getId(),
  182.         remote: remoteRoom.serialize(),
  183.         matrix: matrixRoom.serialize(),
  184.         data: data
  185.     });
  186. };
  188. /**
  189.  * Create an entry with only a matrix room. Sets the 'id' of the entry to the
  190.  * Matrix room ID. If an entry already exists with this 'id', it will be replaced.
  191.  * This function is useful if you just want to store a room with some data and not
  192.  * worry about any mappings.
  193.  * @param {MatrixRoom} matrixRoom
  194.  * @return {Promise}
  195.  * @see RoomBridgeStore#getMatrixRoom
  196.  */
  197. RoomBridgeStore.prototype.setMatrixRoom = function(matrixRoom) {
  198.     return this.upsertEntry({
  199.         id: matrixRoom.getId(),
  200.         matrix_id: matrixRoom.getId(),
  201.         matrix: matrixRoom
  202.     });
  203. };
  205. /**
  206.  * Get an entry's Matrix room based on the provided room_id. The entry MUST have
  207.  * an 'id' of the room_id and there MUST be a Matrix room contained within the
  208.  * entry for this to return.
  209.  * @param {string} roomId
  210.  * @return {?MatrixRoom}
  211.  * @see RoomBridgeStore#setMatrixRoom
  212.  */
  213. RoomBridgeStore.prototype.getMatrixRoom = function(roomId) {
  214.     return this.getEntryById(roomId).then(function(e) {
  215.         return e ? e.matrix : null;
  216.     });
  217. };
  219. /**
  220.  * Get all entries with the given remote_id which have a Matrix room within.
  221.  * @param {string} remoteId
  222.  * @return {MatrixRoom[]}
  223.  */
  224. RoomBridgeStore.prototype.getLinkedMatrixRooms = function(remoteId) {
  225.     return this.getEntriesByRemoteId(remoteId).then(function(entries) {
  226.         return entries.filter(function(e) {
  227.             return Boolean(e.matrix);
  228.         }).map(function(e) {
  229.             return e.matrix;
  230.         });
  231.     });
  232. };
  234. /**
  235.  * Get all entries with the given matrix_id which have a Remote room within.
  236.  * @param {string} matrixId
  237.  * @return {RemoteRoom[]}
  238.  */
  239. RoomBridgeStore.prototype.getLinkedRemoteRooms = function(matrixId) {
  240.     return this.getEntriesByMatrixId(matrixId).then(function(entries) {
  241.         return entries.filter(function(e) {
  242.             return Boolean(e.remote);
  243.         }).map(function(e) {
  244.             return e.remote;
  245.         });
  246.     });
  247. };
  249. /**
  250.  * A batched version of <code>getLinkedRemoteRooms</code>.
  251.  * @param {string[]} matrixIds
  252.  * @return {Object.<string, RemoteRoom>} A mapping of room_id to RemoteRoom.
  253.  * @see RoomBridgeStore#getLinkedRemoteRooms
  254.  */
  255. RoomBridgeStore.prototype.batchGetLinkedRemoteRooms = function(matrixIds) {
  256.     return this.getEntriesByMatrixIds(matrixIds).then(function(entryMap) {
  257.         Object.keys(entryMap).forEach(function(k) {
  258.             entryMap[k] = entryMap[k].filter(function(e) {
  259.                 return Boolean(e.remote);
  260.             }).map(function(e) {
  261.                 return e.remote;
  262.             });
  263.         })
  264.         return entryMap;
  265.     });
  266. };
  269. /**
  270.  * Get a list of entries based on a RemoteRoom data value.
  271.  * @param {Object} data The data values to retrieve based from.
  272.  * @return {RoomBridgeStore~Entry[]} A list of entries
  273.  * @example
  274.  * remoteRoom.set("some_key", "some_val");
  275.  * // store remoteRoom and then:
  276.  * store.getEntriesByRemoteRoomData({
  277.  *     some_key: "some_val"
  278.  * });
  279.  */
  280. RoomBridgeStore.prototype.getEntriesByRemoteRoomData = function(data) {
  281.     Object.keys(data).forEach(function(k) {
  282.         var query = data[k];
  283.         delete data[k];
  284.         data["remote." + k] = query;
  285.     });
  286.     return this.select(data, this.convertTo(function(doc) {
  287.         return new Entry(doc);
  288.     }));
  289. };
  291. /**
  292.  * Get a list of entries based on a MatrixRoom data value.
  293.  * @param {Object} data The data values to retrieve based from.
  294.  * @return {RoomBridgeStore~Entry[]} A list of entries
  295.  * @example
  296.  * matrixRoom.set("some_key", "some_val");
  297.  * // store matrixRoom and then:
  298.  * store.getEntriesByMatrixRoomData({
  299.  *     some_key: "some_val"
  300.  * });
  301.  */
  302. RoomBridgeStore.prototype.getEntriesByMatrixRoomData = function(data) {
  303.     Object.keys(data).forEach(function(k) {
  304.         var query = data[k];
  305.         delete data[k];
  306.         data["matrix.extras." + k] = query;
  307.     });
  308.     return this.select(data, this.convertTo(function(doc) {
  309.         return new Entry(doc);
  310.     }));
  311. };
  313. /**
  314.  * Get a list of entries based on the link's data value.
  315.  * @param {Object} data The data values to retrieve based from.
  316.  * @return {RoomBridgeStore~Entry[]} A list of entries
  317.  * @example
  318.  * store.linkRooms(matrixRoom, remoteRoom, { some_key: "some_val" });
  319.  * store.getEntriesByLinkData({
  320.  *     some_key: "some_val"
  321.  * });
  322.  */
  323. RoomBridgeStore.prototype.getEntriesByLinkData = function(data) {
  324.     Object.keys(data).forEach(function(k) {
  325.         var query = data[k];
  326.         delete data[k];
  327.         data["data." + k] = query;
  328.     });
  329.     return this.select(data, this.convertTo(function(doc) {
  330.         return new Entry(doc);
  331.     }));
  332. };
  334. /**
  335.  * Remove entries based on remote room data.
  336.  * @param {Object} data The data to match.
  337.  * @return {Promise}
  338.  * @example
  339.  * remoteRoom.set("a_key", "a_val");
  340.  * // store remoteRoom and then:
  341.  * store.removeEntriesByRemoteRoomData({
  342.  *     a_key: "a_val"
  343.  * });
  344.  */
  345. RoomBridgeStore.prototype.removeEntriesByRemoteRoomData = function(data) {
  346.     Object.keys(data).forEach(function(k) {
  347.         var query = data[k];
  348.         delete data[k];
  349.         data["remote." + k] = query;
  350.     });
  351.     return this.delete(data);
  352. };
  354. /**
  355.  * Remove entries with this remote room id.
  356.  * @param {Object} remoteId The remote id.
  357.  * @return {Promise}
  358.  * @example
  359.  * new RemoteRoom("foobar");
  360.  * // store the RemoteRoom and then:
  361.  * store.removeEntriesByRemoteRoomId("foobar");
  362.  */
  363. RoomBridgeStore.prototype.removeEntriesByRemoteRoomId = function(remoteId) {
  364.     return this.delete({
  365.       remote_id: remoteId
  366.     });
  367. };
  369. /**
  370.  * Remove entries based on matrix room data.
  371.  * @param {Object} data The data to match.
  372.  * @return {Promise}
  373.  * @example
  374.  * matrixRoom.set("a_key", "a_val");
  375.  * // store matrixRoom and then:
  376.  * store.removeEntriesByMatrixRoomData({
  377.  *     a_key: "a_val"
  378.  * });
  379.  */
  380. RoomBridgeStore.prototype.removeEntriesByMatrixRoomData = function(data) {
  381.     Object.keys(data).forEach(function(k) {
  382.         var query = data[k];
  383.         delete data[k];
  384.         data["matrix.extras." + k] = query;
  385.     });
  386.     return this.delete(data);
  387. };
  389. /**
  390.  * Remove entries with this matrix room id.
  391.  * @param {Object} matrixId The matrix id.
  392.  * @return {Promise}
  393.  * @example
  394.  * new MatrixRoom("!foobar:matrix.org");
  395.  * // store the MatrixRoom and then:
  396.  * store.removeEntriesByMatrixRoomId("!foobar:matrix.org");
  397.  */
  398. RoomBridgeStore.prototype.removeEntriesByMatrixRoomId = function(matrixId) {
  399.     return this.delete({
  400.       matrix_id: matrixId
  401.     });
  402. };
  404. /**
  405.  * Remove entries based on the link's data value.
  406.  * @param {Object} data The data to match.
  407.  * @return {Promise}
  408.  * @example
  409.  * store.linkRooms(matrixRoom, remoteRoom, { a_key: "a_val" });
  410.  * store.removeEntriesByLinkData({
  411.  *     a_key: "a_val"
  412.  * });
  413.  */
  414. RoomBridgeStore.prototype.removeEntriesByLinkData = function(data) {
  415.     Object.keys(data).forEach(function(k) {
  416.         var query = data[k];
  417.         delete data[k];
  418.         data["data." + k] = query;
  419.     });
  420.     return this.delete(data);
  421. };
  423. /**
  424.  * Remove an existing entry based on the provided entry ID.
  425.  * @param {String} id The ID of the entry to remove.
  426.  * @return {Promise}
  427.  * @example
  428.  * store.removeEntryById("anid");
  429.  */
  430. RoomBridgeStore.prototype.removeEntryById = function(id) {
  431.     return this.delete({ id });
  432. }
  435. function createUniqueId(matrixRoomId, remoteRoomId, delimiter) {
  436.     return (matrixRoomId || "") + delimiter + (remoteRoomId || "");
  437. }
  440. /**
  441.  * Construct a new RoomBridgeStore Entry.
  442.  * @constructor
  443.  * @typedef RoomBridgeStore~Entry
  444.  * @property {string} id The unique ID for this entry.
  445.  * @property {?MatrixRoom} matrix The matrix room, if applicable.
  446.  * @property {?RemoteRoom} remote The remote room, if applicable.
  447.  * @property {?Object} data Information about this mapping, which may be an empty.
  448.  */
  449. function Entry(doc) {
  450.     doc = doc || {};
  451.     this.id = doc.id;
  452.     this.matrix = doc.matrix_id ? new MatrixRoom(doc.matrix_id, doc.matrix) : undefined;
  453.     this.remote = doc.remote_id ? new RemoteRoom(doc.remote_id, doc.remote) : undefined;
  454.     this.data = doc.data;
  455. }
  457. // not a member function so callers can provide a POJO
  458. function serializeEntry(entry) {
  459.     return {
  460.         id: entry.id,
  461.         remote_id: entry.remote ? entry.remote.getId() : undefined,
  462.         matrix_id: entry.matrix ? entry.matrix.getId() : undefined,
  463.         remote: entry.remote ? entry.remote.serialize() : undefined,
  464.         matrix: entry.matrix ? entry.matrix.serialize() : undefined,
  465.         data: entry.data
  466.     }
  467. }
  469. module.exports = RoomBridgeStore;