Add a way to make a inline query with different parameters

[maxiloc]

The use case is to be able to make a small query with the helper and modifying just some parameters

For example being able to an empty query just to get the facets

[bobylito]

Would the following suits your needs :

helperInstance.searchOnce( specificParameters, function( results, state ){
  // specificParameters is an object merged with the current search state, meaning that it overrides only the properties needed
  // results is of type SearchResults and state is of type 
  // Do here your specific search behavior
} );

If we want to be fancy, we could support the double callback/promise API of the client (and it would make sense)

What do you think @vvo @pixelastic @redox?

[vvo]

Would it be feasible for you to directly use the helper.client?

var params = helper.getSearchParameters(); // non existent right now I think
params.whatYouWant = value;
helper.client.search(params, function(){});

? I am not sure your need @maxiloc is something that belongs to the helper.

Dont you just want to do a search query?

[bobylito]

Well since you have already some parameters in the helper, it could be handy to use it from time to time directly from the helper, instead of having to use the raw client.

Example of implementation (with the current API, that is far from perfect for this case)

AlgoliaSearchHelper.prototype.searchOnce = function(parameters, callback){
  var newState = this.state.setQueryParameters(parameters);
  var helper = new AlgoliaSearchHelper(this.client, this.index, newState);
  this.client.search( helper._getQueries(), function(error, results) {
    var formattedResponse = new SearchResults( newState, results );
    callback(formattedResponse, newState);
  } );
};

[maxiloc]

@vvo The thing is, the goal is to use the exact same code used with the helper, but with 1 or 2 parameters different. The content object need to be the same

[vvo]

So @bobylito solution fits I guess.

As the helper is stateful, event based, adding this function seems at first a little weird. Getting the current search parameters, modifying them and doing a client.search would work.

Otherwise:

• searchOnce feels not the best name we can find, .rawSearch()? Any other idea?
• we must forward the client error to the callback

[bobylito]

OK I'm starting to dig a little further into this one. Proposition of API :

helper.rawSearch_wipNAME(
  {
    index: '', // this one is tricky, this is not a SearchParameters attribute
               // but I guess we have to be able to update it
    query: '' 
  }, function(error, results, state){
    // error is the fw of the error
    // results is a SearchResults
    // state is the state as sent to Algolia
  }
);

// Of course we would need to support the callbackless/promise style :)

helper.rawSearch_wipNAME(
  {
    index: '', // this one is tricky, this is not a SearchParameters attribute
               // but I guess we have to be able to update it
    query: '' 
  }
).then(function onFulfill(arrayOfObjects){
  // Here we have a problem though we can't pass two arguments because of the promise contract
  // So why not an array?
  //  - [0] for the results as a SearchResults
  //  - [1] for the state as sent to Algolia (SearchParameters)
}, function onError(err){});

[redox]

LGTM, my 2cts:

• the index parameter must be optional
• every query parameters set here must override the underlying ones
• I would still add a getSearchParameters() function to retrieve the actual parameters that will be sent (based on the underlying _getHitsSearchParameters) -> can be useful to build more complex search logic (like playing with filters)
• regarding the naming, I don't have a lot of ideas. I think helper.searchOnce is OK-ish :)

[bobylito]

Thanks, short answer to your points :

• all parameters are optional, they are juste there as a way to override the current state for this specific request
• indeed they do
• from our discussion IRL, there are already some methods on the helper that do that (_getQueries...).
• right now it's between rawSearch and searchOnce. I love neither of them. What about something that explicitly says that we are not modifying the state? searchWithoutStateUpdate? statelessSearch?

[vvo]

Why not reuse the current .search but allow passing a parameters + callback? It would trigger the "callback search" mode.

helper.search([indexName], {mergedQueryParameters}, cb);

helper.search([indexName], {mergedQueryParameters}).then;

?

[bobylito]

No way :)

search is a method of the helper flow. The new method forks the flow into a separate and distinct operation. Those are two approach to do the search.