Multi-paths update and Geofire

[cmellinas]

Hi,

As mentioned here, I think it should be great to easily multi update data paths and a geofire path at the same time. As the set of Geofire is pretty complex, it's hard to directly copy/paste the code to make it works.

Here the use case : (I use the same as the link above but add a path to know where a post is located). So the structure :

{
  posts: {
    post1: {
      from : user1,
      message: "Hi",
    },
    post2: {
      from : user2,
      message: "Hey",
    }
  },
  posts-location: {
    post1: {
      g : 'xxxxxxxx',
      l: {
         0 : latitude,
         1 : longitude
      }
    },
    post2: {
       g : 'xxxxxxxx',
       l: {
         0 : latitude,
         1 : longitude
      }
    }
  },
  users: {
    user1: {
      posts: {
        post1: true
      }
    },
    user2: {
      posts: {
        post2: true
      }
    }
  }
}

Now I can add a post at the same time at users and posts (with multi-path update). But I need to set the position after. In my use case, a post without a position is not valid data, it's for that the best should be to do the 3 updates at the same times (if one fails, all fail).

Deleting Geofire path is easy (using update(null)), we can multi-update for delete, but for set/update, I loop for a way to do that easily,

Cheers, Clément

[jwngr]

I think this is a great suggestion and I think we can find a way to work this into the API. It will be a little while before I have time to implement this, but I'm happy to code review PRs from the community. Otherwise, once I have some time to take a crack at this, I'll go ahead and see how we can support this kind of feature. Thanks for opening this issue!

[cmellinas]

Ah great Jacob Hope you will found a solution

Many thanks, Clément

[kz]

+1. Atomic updates are really important to ensure the integrity of the database.

[vikas-anvaya]

Do we have a solution for the problem now.

[ghost]

+1

maybe instead return _firebaseRef.update(newData); use return newData; ... then we can use ref().update function with other data

[jcheroske]

Playing fast and loose here, so disregard if this is totally whacked, but couldn't we just have a method that returns the geofire data that would be updated? Then we could just use the existing atomic update api.

[mversteeg3]

Any movement on this? I like @jcheroske's suggestion as long as there isn't any behind the scenes wizardry in the "set" method that would confound this solution

[deflexable]

checking the set function inside module at ../node_modules/geofire/dist/geofire/index.cjs.js" there wasn't really sophisticated method or external library that help update geofire hash to firebase. It's just plan method and validation.

as @ghost suggested earlier, instead of returning a promise for updating the data, you can simple return newData, then do the uploading yourself.

you can simply copy and paste below function, then you can do something like

`var map = {}; map['eventIndex/' + v] = getGeoFireHashes(eventKey, [location.lat, location.lon]);

firebase.database().ref('/').update(map);`

`function getGeoFireHashes(keyOrLocations, location) { var locations; if (typeof keyOrLocations === 'string' && keyOrLocations.length !== 0) { // If this is a set for a single location, convert it into a object locations = {}; locations[keyOrLocations] = location; } else if (typeof keyOrLocations === 'object') { if (typeof location !== 'undefined') { throw new Error('The location argument should not be used if you pass an object to set().'); } locations = keyOrLocations; } else { throw new Error('keyOrLocations must be a string or a mapping of key - location pairs.'); } var newData = {}; Object.keys(locations).forEach(function (key) { validateKey(key); var location = locations[key]; if (location === null) { // Setting location to null is valid since it will remove the key newData[key] = null; } else { validateLocation(location); var geohash = geohashForLocation(location); newData[key] = encodeGeoFireObject(location, geohash); } }); return newData; }

/**

• Encodes a location and geohash as a GeoFire object.
• @param location The location as [latitude, longitude] pair.
• @param geohash The geohash of the location.
• @returns The location encoded as GeoFire object. */ function encodeGeoFireObject(location, geohash) { validateLocation(location); validateGeohash(geohash); return { '.priority': geohash, 'g': geohash, 'l': location }; }

/**

• Generates a geohash of the specified precision/string length from the [latitude, longitude]
• pair, specified as an array.
• @param location The [latitude, longitude] pair to encode into a geohash.
• @param precision The length of the geohash to create. If no precision is specified, the
• global default is used.
• @returns The geohash of the inputted location. */ function geohashForLocation(location, precision) { if (precision === void 0) { precision = GEOHASH_PRECISION; } validateLocation(location); if (typeof precision !== 'undefined') { if (typeof precision !== 'number' || isNaN(precision)) { throw new Error('precision must be a number'); } else if (precision <= 0) { throw new Error('precision must be greater than 0'); } else if (precision > 22) { throw new Error('precision cannot be greater than 22'); } else if (Math.round(precision) !== precision) { throw new Error('precision must be an integer'); } } var latitudeRange = { min: -90, max: 90 }; var longitudeRange = { min: -180, max: 180 }; var hash = ''; var hashVal = 0; var bits = 0; var even = 1; while (hash.length < precision) { var val = even ? location[1] : location[0]; var range = even ? longitudeRange : latitudeRange; var mid = (range.min + range.max) / 2; if (val > mid) { hashVal = (hashVal << 1) + 1; range.min = mid; } else { hashVal = (hashVal << 1) + 0; range.max = mid; } even = !even; if (bits < 4) { bits++; } else { bits = 0; hash += BASE32[hashVal]; hashVal = 0; } } return hash; }

/**

• Validates the inputted geohash and throws an error if it is invalid.
• @param geohash The geohash to be validated. */ function validateGeohash(geohash) { var error; if (typeof geohash !== 'string') { error = 'geohash must be a string'; } else if (geohash.length === 0) { error = 'geohash cannot be the empty string'; } else { for (var _i = 0, geohash_1 = geohash; _i < geohash_1.length; _i++) { var letter = geohash_1[_i]; if (BASE32.indexOf(letter) === -1) { error = 'geohash cannot contain \'' + letter + '\''; } } } if (typeof error !== 'undefined') { throw new Error('Invalid GeoFire geohash \'' + geohash + '\': ' + error); } }

function validateKey(key) { var error; if (typeof key !== 'string') { error = 'key must be a string'; } else if (key.length === 0) { error = 'key cannot be the empty string'; } else if (1 + GEOHASH_PRECISION + key.length > 755) { // Firebase can only stored child paths up to 768 characters // The child path for this key is at the least: 'i/key' error = 'key is too long to be stored in Firebase'; } else if (/[[].#$\/\u0000-\u001F\u007F]/.test(key)) { // Firebase does not allow node keys to contain the following characters error = 'key cannot contain any of the following characters: . # $ ] [ /'; } if (typeof error !== 'undefined') { throw new Error('Invalid GeoFire key \'' + key + '\': ' + error); } }

function validateLocation(location) { var error; if (!Array.isArray(location)) { error = 'location must be an array'; } else if (location.length !== 2) { error = 'expected array of length 2, got length ' + location.length; } else { var latitude = location[0]; var longitude = location[1]; if (typeof latitude !== 'number' || isNaN(latitude)) { error = 'latitude must be a number'; } else if (latitude < -90 || latitude > 90) { error = 'latitude must be within the range [-90, 90]'; } else if (typeof longitude !== 'number' || isNaN(longitude)) { error = 'longitude must be a number'; } else if (longitude < -180 || longitude > 180) { error = 'longitude must be within the range [-180, 180]'; } } if (typeof error !== 'undefined') { throw new Error('Invalid GeoFire location \'' + location + '\': ' + error); } }`