solrkit
Version:
  UI Components for Solr, using TypeScript + React
406 lines • 17.9 kB
JavaScript
import Immutable from 'seamless-immutable';
import * as fetchJsonp from 'fetch-jsonp';
import * as _ from 'lodash';
function escape(value) {
if (value === '*') {
return value;
}
return '"' + value.toString().replace(/ /g, '%20') + '"';
}
// Note that the stored versions of these end up namespaced and/or aliased
var UrlParams;
(function (UrlParams) {
UrlParams["ID"] = "id";
UrlParams["QUERY"] = "query";
UrlParams["FQ"] = "fq";
UrlParams["START"] = "start";
UrlParams["TYPE"] = "type";
})(UrlParams || (UrlParams = {}));
var QueryBeingBuilt = (function () {
function QueryBeingBuilt(solrUrlFragment, appUrlFragment) {
this.solrUrlFragment = solrUrlFragment;
// TODO, these need to support the following:
// aliasing multiple parameters (i.e. any of the following values could be a 'q')
// this supports renames over time
// urls in the path or the query
// this is for seo
// aliasing groups of parameters (this is like the named search example)
// numeric indexes - e.g. fq
// facets should have some special handling;
// facets can be arrays
// facets can be hierarchies (probably there are different implementations of this)
// "named" values that wrap sets of parameters - e.g named sort fields or enum queries
// need to be able to namespace the output of this to be unique to support multiple searches on a site
// this needs to work 100% bidirectional (i.e. url -> objects, objects -> url)
this.appUrlFragment = appUrlFragment;
}
return QueryBeingBuilt;
}());
var SolrQueryBuilder = (function () {
function SolrQueryBuilder(op, previous) {
this.op = op;
this.previous = previous;
}
SolrQueryBuilder.prototype.get = function (id) {
return new SolrQueryBuilder(function () { return new QueryBeingBuilt('get?id=' + id, [UrlParams.ID, id]); }, this);
};
SolrQueryBuilder.prototype.select = function () {
return new SolrQueryBuilder(function () { return new QueryBeingBuilt('select?facet=true', [UrlParams.TYPE, 'QUERY']); }, this);
};
SolrQueryBuilder.prototype.moreLikeThis = function (handler, col, id) {
return new SolrQueryBuilder(function () { return new QueryBeingBuilt(handler + '?q=' + col + ':' + id, [UrlParams.ID, id]); }, this);
};
SolrQueryBuilder.prototype.start = function (start) {
return new SolrQueryBuilder(function () { return new QueryBeingBuilt('start=' + start, [UrlParams.START, start]); }, this);
};
SolrQueryBuilder.prototype.jsonp = function (callback) {
return new SolrQueryBuilder(function () { return new QueryBeingBuilt('wt=json&json.wrf=' + callback, null); }, this);
};
SolrQueryBuilder.prototype.export = function () {
return new SolrQueryBuilder(function () { return new QueryBeingBuilt('wt=csv', null); }, this);
};
SolrQueryBuilder.prototype.q = function (searchFields, value) {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt('q=' +
searchFields.map(function (field) { return field + ':' + escape(value); }).join('%20OR%20'), [UrlParams.QUERY, value]);
}, this);
};
SolrQueryBuilder.prototype.fq = function (field, values) {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt('fq=' +
'{!tag=' + field + '_q}' +
values.map(escape).map(function (v) { return field + ':' + v; }).join('%20OR%20'), [UrlParams.FQ, [field, values]]);
}, this);
};
SolrQueryBuilder.prototype.fl = function (fields) {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt('fl=' + fields.join(','), null);
}, this);
};
SolrQueryBuilder.prototype.requestFacet = function (field) {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt("facet.field={!ex=" + field + "_q}" + field + "&" +
"facet.mincount=1&" +
("facet." + field + ".limit=50&") +
("facet." + field + ".sort=count"), null);
}, this);
};
SolrQueryBuilder.prototype.rows = function (rows) {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt('rows=' + rows, null);
}, this);
};
SolrQueryBuilder.prototype.sort = function (fields) {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt('sort=' + fields.map(escape).join(','),
// TODO: I think this should add a 'named sort' to the URL, because
// this could have a large amount of Solr specific stuff in it - i.e.
// add(field1, mul(field2, field3)) and you don't want to expose the
// internals to external search engines, or they'll index the site in
// a way that would make this hard to change
null);
}, this);
};
SolrQueryBuilder.prototype.construct = function () {
var start = ['', []];
if (this.previous) {
start = this.previous.construct();
}
if (start[0] !== '') {
start[0] = start[0] + '&';
}
var output = this.op();
return [
start[0] + output.solrUrlFragment,
start[1].concat([output.appUrlFragment])
];
};
SolrQueryBuilder.prototype.buildCurrentParameters = function () {
var initialParams = this.construct()[1];
var result = initialParams;
var searchParams = {};
result.map(function (p) {
if (p !== null) {
if (p[0] === UrlParams.FQ) {
var facet = p[1][0];
var values = p[1][1];
if (!searchParams.facets) {
searchParams.facets = {};
}
searchParams.facets[facet] = values;
}
else {
searchParams[p[0]] = p[1];
}
}
});
return searchParams;
};
SolrQueryBuilder.prototype.buildSolrUrl = function () {
return this.construct()[0];
};
return SolrQueryBuilder;
}());
var SolrCore = (function () {
function SolrCore(solrConfig) {
this.requestId = 0;
this.currentParameters = {};
this.getCache = {};
this.mltCache = {};
this.solrConfig = solrConfig;
this.clearEvents();
// this.onGet = this.memoize(this.onGet);
}
SolrCore.prototype.clearEvents = function () {
this.events = {
query: [],
error: [],
get: [],
mlt: [],
facet: {}
};
if (_.keys(this.getCache).length > 100) {
this.getCache = {};
}
if (_.keys(this.mltCache).length > 100) {
this.mltCache = {};
}
};
SolrCore.prototype.getCoreConfig = function () {
return this.solrConfig;
};
SolrCore.prototype.onQuery = function (op) {
this.events.query.push(op);
};
SolrCore.prototype.registerFacet = function (facetNames) {
var events = this.events.facet;
return function facetBind(cb) {
// this works differently than the other event types because
// you may not know in advance what all the facets should be
facetNames.map(function (facetName) {
events[facetName] =
(events[facetName] || []);
events[facetName].push(cb);
});
};
};
SolrCore.prototype.onError = function (op) {
this.events.error.push(op);
};
SolrCore.prototype.doMoreLikeThis = function (id) {
this.prefetchMoreLikeThis(id, true);
};
SolrCore.prototype.getNamespace = function () {
return '';
};
SolrCore.prototype.prefetchMoreLikeThis = function (id, prefetch) {
var _this = this;
var self = this;
if (!self.mltCache[id]) {
var callback = 'cb_' + self.requestId++;
var qb = new SolrQueryBuilder(function () { return new QueryBeingBuilt('', null); }).moreLikeThis('mlt', // TODO - configurable
self.solrConfig.primaryKey, id).fl(self.solrConfig.fields).jsonp(callback);
var url = self.solrConfig.url + self.solrConfig.core + '/' + qb.buildSolrUrl();
fetchJsonp(url, {
jsonpCallbackFunction: callback
}).then(function (data) {
data.json().then(function (responseData) {
var mlt = responseData.response.docs;
if (prefetch) {
self.events.mlt.map(function (event) {
event(Immutable(mlt));
});
mlt.map(function (doc) {
self.prefetchMoreLikeThis(doc[_this.solrConfig.primaryKey], false);
});
}
responseData.response.docs.map(function (doc) { return self.getCache[id] = responseData.doc; });
self.mltCache[id] = responseData.response.docs;
}).catch(function (error) {
self.events.error.map(function (event) { return event(error); });
});
});
}
else {
self.events.mlt.map(function (event) {
event(Immutable(_this.mltCache[id]));
});
}
};
SolrCore.prototype.onMoreLikeThis = function (op) {
this.events.mlt.push(op);
};
SolrCore.prototype.onGet = function (op) {
this.events.get.push(op);
};
SolrCore.prototype.doGet = function (id) {
var _this = this;
var self = this;
var callback = 'cb_' + this.requestId++;
var qb = new SolrQueryBuilder(function () { return new QueryBeingBuilt('', null); }).get(id).fl(this.solrConfig.fields).jsonp(callback);
var url = this.solrConfig.url + this.solrConfig.core + '/' + qb.buildSolrUrl();
if (!this.getCache[id]) {
fetchJsonp(url, {
jsonpCallbackFunction: callback
}).then(function (data) {
data.json().then(function (responseData) {
self.events.get.map(function (event) { return event(Immutable(responseData.doc)); });
_this.getCache[id] = responseData.doc;
}).catch(function (error) {
self.events.error.map(function (event) { return event(error); });
});
});
}
else {
self.events.get.map(function (event) { return event(Immutable(_this.getCache[id])); });
}
};
SolrCore.prototype.doQuery = function (query, cb) {
var _this = this;
var self = this;
var callback = 'cb_' + this.requestId++;
var qb = new SolrQueryBuilder(function () { return new QueryBeingBuilt('', null); }).select().q(this.solrConfig.defaultSearchFields, query.query).fl(this.solrConfig.fields).rows(query.rows || this.solrConfig.pageSize);
if (this.solrConfig.fq) {
qb = qb.fq(this.solrConfig.fq[0], [this.solrConfig.fq[1]]);
}
_.map(this.events.facet, function (v, k) {
qb = qb.requestFacet(k);
});
if (cb) {
qb = cb(qb);
}
qb = qb.jsonp(callback);
var url = this.solrConfig.url + this.solrConfig.core + '/' + qb.buildSolrUrl();
fetchJsonp(url, {
jsonpCallbackFunction: callback
}).then(function (data) {
_this.currentParameters = qb.buildCurrentParameters();
data.json().then(function (responseData) {
self.events.query.map(function (event) {
return event(Immutable(responseData.response.docs), Immutable({
numFound: responseData.response.numFound,
start: responseData.response.start,
pageSize: query.rows || 10
}));
});
var facetCounts = responseData.facet_counts;
if (facetCounts) {
var facetFields_1 = facetCounts.facet_fields;
if (facetFields_1) {
_.map(self.events.facet, function (events, k) {
if (facetFields_1[k]) {
var previousValues_1 = (_this.currentParameters.facets || {})[k];
var facetLabels_1 = facetFields_1[k].filter(function (v, i) { return i % 2 === 0; });
var facetLabelCount_1 = facetFields_1[k].filter(function (v, i) { return i % 2 === 1; });
var facetSelections_1 = facetLabels_1.map(function (value) { return _.includes(previousValues_1, value); });
events.map(function (event) {
event(_.zipWith(facetLabels_1, facetLabelCount_1, facetSelections_1));
});
}
});
}
}
}).catch(function (error) {
self.events.error.map(function (event) { return event(error); });
});
});
};
SolrCore.prototype.doUpdate = function (id, attr, value) {
var self = this;
var op = {
id: id,
};
op[attr] = { set: value };
var url = this.solrConfig.url + this.solrConfig.core + '/' + 'update?commit=true';
var http = new XMLHttpRequest();
var params = JSON.stringify(op);
http.open('POST', url, true);
http.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
delete this.getCache[id];
http.onreadystatechange = function () {
if (http.readyState === 4) {
// trigger UI re-render - don't care if success or failure
// because we might have succeeded but got a CORS error
self.doGet(id);
}
};
http.send(params);
};
SolrCore.prototype.doExport = function () {
var query = this.getCurrentParameters();
var qb = new SolrQueryBuilder(function () { return new QueryBeingBuilt('', null); }).select().q(this.solrConfig.defaultSearchFields, query.query || '*').fl(this.solrConfig.fields)
.rows(2147483647);
if (this.solrConfig.fq) {
qb = qb.fq(this.solrConfig.fq[0], [this.solrConfig.fq[1]]);
}
_.map(this.events.facet, function (v, k) {
qb = qb.requestFacet(k);
});
qb = qb.export();
var url = this.solrConfig.url + this.solrConfig.core + '/' + qb.buildSolrUrl();
window.open(url, '_blank');
};
SolrCore.prototype.next = function (op) {
var self = this;
var qb = op(new SolrQueryBuilder(function () { return new QueryBeingBuilt('', null); })).fl(self.solrConfig.fields);
var url = self.solrConfig.url + self.solrConfig.core + '/select?' + qb.buildSolrUrl();
fetchJsonp(url).then(function (data) {
data.json().catch(function (error) {
self.events.error.map(function (event) { return event(error); });
}).then(function (responseData) {
self.events.get.map(function (event) { return event(Immutable(responseData.response.docs)); });
});
});
};
SolrCore.prototype.stateTransition = function (newState) {
if (newState.type === 'QUERY') {
this.doQuery({
rows: this.solrConfig.pageSize,
query: newState.query || '*'
}, function (qb) {
var response = qb.start(newState.start || 0);
_.map(newState.facets, function (values, k) {
if (values.length > 0) {
response =
response.fq(k, values);
}
});
return response;
});
}
else {
throw 'INVALID STATE TRANSITION: ' + JSON.stringify(newState);
}
};
SolrCore.prototype.getCurrentParameters = function () {
return this.currentParameters;
};
return SolrCore;
}());
// TODO: I want a way to auto-generate these from Solr management APIs
// TODO: This thing should provide some reflection capability so the
// auto-registered version can be used to bind controls through
// a properties picker UI
var DataStore = (function () {
function DataStore() {
this.cores = {};
}
DataStore.prototype.clearEvents = function () {
_.map(this.cores, function (v, k) { return v.clearEvents(); });
};
DataStore.prototype.registerCore = function (config) {
// Check if this exists - Solr URL + core should be enough
var key = config.url;
if (!key.endsWith('/')) {
key += '/';
}
key += config.core;
if (!this.cores[key]) {
this.cores[key] = new SolrCore(config);
}
return this.cores[key];
};
return DataStore;
}());
export { SolrQueryBuilder, DataStore, SolrCore, };
//# sourceMappingURL=DataStore.js.map