solrkit
Version:
 
582 lines • 24.7 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Immutable = require("seamless-immutable");
var fetchJsonp = require("fetch-jsonp");
var _ = require("lodash");
function escape(value) {
if (value === '*') {
return value;
}
return ((value.toString().indexOf(' ') > 0) ? ('"' + value.toString().replace(/ /g, '%20') + '"') : (value.toString()));
}
function escapeNoQuote(value) {
if (value === '*') {
return value;
}
return ((value.toString().indexOf(' ') > 0) ? (value.toString().replace(/ /g, '%20')) : (value.toString()));
}
var UrlParams;
(function (UrlParams) {
UrlParams["ID"] = "id";
UrlParams["QUERY"] = "query";
UrlParams["FQ"] = "fq";
UrlParams["START"] = "start";
UrlParams["TYPE"] = "type";
UrlParams["HL"] = "highlight";
})(UrlParams || (UrlParams = {}));
exports.UrlParams = UrlParams;
var QueryBeingBuilt = (function () {
function QueryBeingBuilt(solrUrlFragment, appUrlFragment) {
this.solrUrlFragment = solrUrlFragment;
this.appUrlFragment = appUrlFragment;
}
return QueryBeingBuilt;
}());
exports.QueryBeingBuilt = 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, props) {
function joinProp(useProps, propertyName) {
if (!useProps || !useProps[propertyName]) {
return null;
}
else {
return 'mlt.' + propertyName + '=' + useProps[propertyName].join(',');
}
}
function prop(useProps, propertyName) {
if (!useProps || !useProps[propertyName]) {
return null;
}
else {
return 'mlt.' + propertyName + '=' + useProps[propertyName];
}
}
return new SolrQueryBuilder(function () { return new QueryBeingBuilt(handler + '?q=' + col + ':' + id + '&' +
[
joinProp(props, 'fl'),
prop(props, 'mintf'),
prop(props, 'mindf'),
prop(props, 'maxdf'),
prop(props, 'minwl'),
prop(props, 'maxwl'),
prop(props, 'maxqt'),
prop(props, 'maxntp'),
prop(props, 'boost'),
joinProp(props, 'qf')
].filter(function (x) { return !!x; }).join(','), [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.qt = function (qt) {
return new SolrQueryBuilder(function () { return new QueryBeingBuilt('tv.all=true&qt=' + qt, null); }, this);
};
SolrQueryBuilder.prototype.q = function (searchFields, value) {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt('defType=edismax&q=' +
searchFields.map(function (field) { return field + ':' + escape(value); }).join('%20OR%20'), [UrlParams.QUERY, value]);
}, this);
};
SolrQueryBuilder.prototype.bq = function (query) {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt('bq=' + query, null);
}, 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.highlight = function (query) {
if (query.fields.length > 0) {
return new SolrQueryBuilder(function () {
var params = [
'method',
'fields',
'query',
'qparser',
'requireFieldMatch',
'usePhraseHighlighter',
'highlightMultiTerm',
'snippets',
'fragsize',
'encoder',
'maxAnalyzedChars'
].map(function (key) { return query[key] ? ('hl.' + key + '=' + query[key]) : ''; }).filter(function (key) { return key !== ''; });
if (query.pre) {
params.push('hl.tag.pre=' + query.pre);
}
if (query.post) {
params.push('hl.tag.post=' + query.pre);
}
return new QueryBeingBuilt('hl=true&' +
'hl.fl=' + query.fields.join(',') + (params.length > 0 ? ('&' + params.join('&')) : ''), null);
});
}
else {
return null;
}
};
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(escapeNoQuote).join(','), null);
}, this);
};
SolrQueryBuilder.prototype.schema = function () {
return new SolrQueryBuilder(function () {
return new QueryBeingBuilt('admin/luke?', null);
});
};
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;
}());
exports.SolrQueryBuilder = SolrQueryBuilder;
function mergeQuery(q1, q2) {
if (!q1) {
return q2 || { query: '*:* /* q2 */' };
}
if (!q2) {
return q1 || { query: '*:* /* q1 */' };
}
return {
query: '(' + q1.query + ') AND (' + q2.query + ')',
rows: q1.rows || q2.rows,
boost: q1.boost || q2.boost,
sort: q1.sort || q2.sort
};
}
var requestId = 0;
var SolrCore = (function () {
function SolrCore(solrConfig) {
this.currentParameters = {};
this.getCache = {};
this.mltCache = {};
this.refinements = [];
this.solrConfig = solrConfig;
this.clearEvents();
}
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.refine = function (query) {
var obj = this;
if (null == obj || 'object' !== typeof obj) {
return obj;
}
var copy = new SolrCore(this.solrConfig);
for (var attr in obj) {
if (obj.hasOwnProperty(attr) &&
attr !== 'events' &&
attr !== 'refinements') {
copy[attr] = obj[attr];
}
}
copy.clearEvents();
copy.query = mergeQuery(query, this.query);
this.refinements.push(copy);
return copy;
};
SolrCore.prototype.registerFacet = function (facetNames) {
var events = this.events.facet;
return function facetBind(cb) {
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, mltProps) {
this.prefetchMoreLikeThis(id, mltProps, true);
};
SolrCore.prototype.getNamespace = function () {
return '';
};
SolrCore.prototype.prefetchMoreLikeThis = function (id, mltProps, prefetch) {
var _this = this;
var self = this;
if (!self.mltCache[id]) {
var callback = 'cb_' + requestId++;
var qb = new SolrQueryBuilder(function () { return new QueryBeingBuilt('', null); }).moreLikeThis('mlt', self.solrConfig.primaryKey, id, mltProps).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], mltProps, 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_' + 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 (desiredQuery, cb) {
var _this = this;
var self = this;
if (self.events.query.length > 0) {
var callback = 'cb_' + (requestId++);
var query_1 = mergeQuery(desiredQuery, this.query);
var qb_1 = new SolrQueryBuilder(function () { return new QueryBeingBuilt('', null); });
qb_1 = qb_1.select().q(this.solrConfig.defaultSearchFields, query_1.query);
if (this.solrConfig.qt) {
qb_1 = qb_1.qt(this.solrConfig.qt);
}
qb_1 = qb_1.fl(this.solrConfig.fields).rows(query_1.rows || this.solrConfig.pageSize);
if (this.solrConfig.fq) {
qb_1 = qb_1.fq(this.solrConfig.fq[0], [this.solrConfig.fq[1]]);
}
if (query_1.boost) {
qb_1 = qb_1.bq(query_1.boost);
}
if (query_1.sort) {
qb_1 = qb_1.sort(query_1.sort);
}
_.map(this.events.facet, function (v, k) {
qb_1 = qb_1.requestFacet(k);
});
if (cb) {
qb_1 = cb(qb_1);
}
qb_1 = qb_1.jsonp(callback);
var url = this.solrConfig.url + this.solrConfig.core + '/' + qb_1.buildSolrUrl();
fetchJsonp(url, {
jsonpCallbackFunction: callback,
timeout: 30000
}).then(function (data) {
_this.currentParameters = qb_1.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_1.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).map(function (facetData) {
return {
value: facetData[0],
count: facetData[1],
checked: facetData[2]
};
}));
});
}
});
}
}
}).catch(function (error) {
self.events.error.map(function (event) { return event(error); });
});
});
}
this.refinements.map(function (refinement) { return refinement.doQuery(desiredQuery, cb); });
};
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) {
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 || '*',
boost: newState.boost,
sort: newState.sort
}, 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;
}());
exports.SolrCore = SolrCore;
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) {
var key = config.url;
if (!_.endsWith(key, '/')) {
key += '/';
}
key += config.core;
if (!this.cores[key]) {
this.cores[key] = new SolrCore(config);
}
return this.cores[key];
};
return DataStore;
}());
exports.DataStore = DataStore;
var AutoConfiguredDataStore = (function (_super) {
__extends(AutoConfiguredDataStore, _super);
function AutoConfiguredDataStore() {
return _super !== null && _super.apply(this, arguments) || this;
}
AutoConfiguredDataStore.prototype.getCore = function () {
return this.core;
};
AutoConfiguredDataStore.prototype.getFacets = function () {
return this.facets;
};
AutoConfiguredDataStore.prototype.getFields = function () {
return this.fields;
};
AutoConfiguredDataStore.prototype.autoconfigure = function (config, complete, useFacet) {
var _this = this;
var callback = 'cb_autoconfigure_' + config.core;
useFacet = useFacet || (function (facet) { return true; });
var qb = new SolrQueryBuilder(function () { return new QueryBeingBuilt('', null); }).schema().jsonp(callback);
var url = config.url + config.core + '/' + qb.buildSolrUrl();
fetchJsonp(url, {
jsonpCallbackFunction: callback
}).then(function (data) {
data.json().then(function (responseData) {
var fields = _.toPairs(responseData.fields).filter(function (_a) {
var fieldName = _a[0], fieldDef = _a[1];
return fieldDef.docs > 0 && fieldDef.schema.match(/I.S............../);
}).map(function (_a) {
var fieldName = _a[0], fieldDef = _a[1];
return fieldName;
});
var defaultSearchFields = _.toPairs(responseData.fields).filter(function (_a) {
var fieldName = _a[0], fieldDef = _a[1];
return fieldDef.docs > 0 && fieldDef.schema.match(/I................/);
}).map(function (_a) {
var fieldName = _a[0], fieldDef = _a[1];
return fieldName;
});
var coreConfig = _.extend({}, {
primaryKey: 'id',
fields: fields,
defaultSearchFields: defaultSearchFields,
pageSize: 50,
prefix: config.core
}, config);
_this.core = new SolrCore(coreConfig);
_this.fields = fields;
_this.facets = fields.filter(useFacet);
_this.core.registerFacet(_this.facets)(_.identity);
complete();
});
});
};
return AutoConfiguredDataStore;
}(DataStore));
exports.AutoConfiguredDataStore = AutoConfiguredDataStore;
//# sourceMappingURL=DataStore.js.map