solr-query-maker - npm Package Compare versions

Comparing version 0.2.2 to 0.9.0

build/src/Q.d.ts

@@ -1,12 +0,14 @@
-import { And, Clause, ConstantScore, Not, Or, Primitive, Prohibited, Required, Term, TermValue, Range, Spatial, SpatialOp } from './types';
+import { And, AndTerm, Clause, ConstantScore, Not, NotTerm, Literal, Or, OrTerm, Primitive, ProhibitedTerm, RequiredTerm, NamedTerm, Term, TermValue, Range, Spatial, SpatialOp, Required, Prohibited, Glob } from './types';
 import * as spatial from './spatial';
 export { spatial };
-export declare function defaultTerm(value?: TermValue<string>): Term<string>;
-export declare function defaultTerm(value?: TermValue<Date>): Term<Date>;
-export declare function defaultTerm(value?: TermValue<number>): Term<number>;
-export declare function defaultTerm(value?: TermValue<Spatial<SpatialOp>>): Term<Spatial<SpatialOp>>;
-export declare function term(field: string, value?: TermValue<string>): Term<string>;
-export declare function term(field: string, value?: TermValue<Date>): Term<Date>;
-export declare function term(field: string, value?: TermValue<number>): Term<number>;
-export declare function term(field: string, value?: TermValue<Spatial<SpatialOp>>): Term<Spatial<SpatialOp>>;
+export declare function L<T extends Primitive>(value: T): Literal<T>;
+export declare function glob(value: string): Literal<Glob>;
+export declare function defaultTerm(value: TermValue<string>): Term<string>;
+export declare function defaultTerm(value: TermValue<Date>): Term<Date>;
+export declare function defaultTerm(value: TermValue<number>): Term<number>;
+export declare function defaultTerm(value: TermValue<Spatial<SpatialOp>>): Term<Spatial<SpatialOp>>;
+export declare function term(field: string, value: TermValue<string>): NamedTerm<string>;
+export declare function term(field: string, value: TermValue<Date>): NamedTerm<Date>;
+export declare function term(field: string, value: TermValue<number>): NamedTerm<number>;
+export declare function term(field: string, value: TermValue<Spatial<SpatialOp>>): NamedTerm<Spatial<SpatialOp>>;
 export declare function range(closedLower: boolean, closedUpper: boolean, lower?: string, upper?: string): Range<string>;
@@ -21,16 +23,21 @@ export declare function range(closedLower: boolean, closedUpper: boolean, lower?: Date, upper?: Date): Range<Date>;
 export declare function closedRange(lower?: Date, upper?: Date): Range<Date>;
-export declare function not<T extends Primitive>(rhs: Clause<T>): Not<T>;
-export declare function required<T extends Primitive>(rhs: Clause<T>): Required<T>;
-export declare function prohibited<T extends Primitive>(rhs: Clause<T>): Prohibited<T>;
-export declare function constantScore<T extends Primitive>(lhs: Clause<T>, rhs: number): ConstantScore<T>;
-export declare function and(lhs: Clause<string>, rhs: Clause<string>, ...mode: Array<Clause<string>>): And<string>;
-export declare function and(lhs: Clause<number>, rhs: Clause<number>, ...mode: Array<Clause<number>>): And<number>;
-export declare function and(lhs: Clause<Date>, rhs: Clause<Date>, ...mode: Array<Clause<Date>>): And<Date>;
-export declare function and(lhs: Clause<Primitive>, rhs: Clause<Primitive>, ...mode: Array<Clause<Primitive>>): And<Primitive>;
-export declare function and(lhs: Clause<Spatial<SpatialOp>>, rhs: Clause<Spatial<SpatialOp>>, ...mode: Array<Clause<Spatial<SpatialOp>>>): And<Spatial<SpatialOp>>;
-export declare function or(lhs: Clause<string>, rhs: Clause<string>, ...mode: Array<Clause<string>>): Or<string>;
-export declare function or(lhs: Clause<number>, rhs: Clause<number>, ...mode: Array<Clause<number>>): Or<number>;
-export declare function or(lhs: Clause<Date>, rhs: Clause<Date>, ...mode: Array<Clause<Date>>): Or<Date>;
-export declare function or(lhs: Clause<Spatial<SpatialOp>>, rhs: Clause<Spatial<SpatialOp>>, ...mode: Array<Clause<Spatial<SpatialOp>>>): Or<Spatial<SpatialOp>>;
-export declare function or(lhs: Clause<Primitive>, rhs: Clause<Primitive>, ...mode: Array<Clause<Primitive>>): Or<Primitive>;
-export declare function toString(c?: Clause<Primitive>): string;
+export declare function not<T extends Primitive>(rhs: TermValue<T>): NotTerm<T>;
+export declare function not(rhs: Clause): Not;
+export declare function required<T extends Primitive>(rhs: TermValue<T>): RequiredTerm<T>;
+export declare function required(rhs: Clause): Required;
+export declare function prohibited<T extends Primitive>(rhs: TermValue<T>): ProhibitedTerm<T>;
+export declare function prohibited(rhs: Clause): Prohibited;
+export declare function constantScore(lhs: Clause, rhs: number): ConstantScore;
+export declare function and(...more: Array<TermValue<string>>): AndTerm<string>;
+export declare function and(...more: Array<TermValue<number>>): AndTerm<number>;
+export declare function and(...more: Array<TermValue<Date>>): AndTerm<Date>;
+export declare function and(...more: Array<TermValue<Primitive>>): AndTerm<Primitive>;
+export declare function and(...more: Array<TermValue<Spatial<SpatialOp>>>): AndTerm<Spatial<SpatialOp>>;
+export declare function and<T>(...more: Clause[]): And;
+export declare function or(...more: Array<TermValue<string>>): OrTerm<string>;
+export declare function or(...more: Array<TermValue<number>>): OrTerm<number>;
+export declare function or(...more: Array<TermValue<Date>>): OrTerm<Date>;
+export declare function or(...more: Array<TermValue<Primitive>>): OrTerm<Primitive>;
+export declare function or(...more: Array<TermValue<Spatial<SpatialOp>>>): OrTerm<Spatial<SpatialOp>>;
+export declare function or(...more: Clause[]): Or;
+export declare function toString(c: Clause): string;

build/src/Q.js

@@ -9,11 +9,21 @@ "use strict";
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const util = __importStar(require("util"));
-const lodash_reduce_1 = __importDefault(require("lodash.reduce"));
 const spatial = __importStar(require("./spatial"));
 exports.spatial = spatial;
 const wkt = __importStar(require("terraformer-wkt-parser"));
+function L(value) {
+    return {
+        type: 'literal',
+        value,
+    };
+}
+exports.L = L;
+function glob(value) {
+    return L({
+        type: 'glob',
+        value,
+    });
+}
+exports.glob = glob;
 function defaultTerm(value) {
@@ -28,3 +38,3 @@ return {
     return {
-        type: 'term',
+        type: 'namedterm',
         field,
@@ -85,21 +95,14 @@ value,
 exports.constantScore = constantScore;
-function binary(op, lhs, rhs, ...more) {
-    return lodash_reduce_1.default(more, (a, b) => {
-        return {
-            type: op,
-            lhs: a,
-            rhs: b,
-        };
-    }, {
-        type: op,
-        lhs,
-        rhs,
-    });
+function and(...more) {
+    return {
+        type: 'and',
+        operands: more,
+    };
 }
-function and(lhs, rhs, ...more) {
-    return binary('and', lhs, rhs, ...more);
-}
 exports.and = and;
-function or(lhs, rhs, ...more) {
-    return binary('or', lhs, rhs, ...more);
+function or(...more) {
+    return {
+        type: 'or',
+        operands: more,
+    };
 }
@@ -111,13 +114,3 @@ exports.or = or;
 }
-function toRangeString(v) {
-    return ((v.closedLower ? '[' : '{') +
-        toString(v.lower) +
-        ' TO ' +
-        toString(v.upper) +
-        (v.closedUpper ? ']' : '}'));
-}
-function escapeString(v) {
-    return `"${v.replace(/"/g, '\\"')}"`;
-}
-function toString(c) {
+function toLiteralString(c) {
     switch (typeof c) {
@@ -127,3 +120,3 @@ case 'undefined':
         case 'string':
-            return escapeString(c);
+            return quoteString(c);
         case 'number':
@@ -138,19 +131,54 @@ return `${c}`;
         case 'spatial':
-            return toString(`${c.op}(${wkt.convert(c.value)})`);
+            return quoteString(`${c.op}(${wkt.convert(c.value)})`);
+        case 'glob':
+            return escapedGlob(c.value);
+        /* istanbul ignore next */
+        default:
+            /* istanbul ignore next */
+            return nope();
+    }
+}
+function toRangeString(v) {
+    return ((v.closedLower ? '[' : '{') +
+        toLiteralString(v.lower) +
+        ' TO ' +
+        toLiteralString(v.upper) +
+        (v.closedUpper ? ']' : '}'));
+}
+function escapedGlob(v) {
+    // don't escape * or ?
+    return v.replace(/[ +\-&|!(){}\[\]^"~:/\\]/g, '\\$&');
+}
+function quoteString(v) {
+    return `"${v.replace(/["\\]/g, '\\$&')}"`;
+}
+function binaryOp(op, operands) {
+    const elems = [];
+    for (const v of operands) {
+        elems.push(toStringImpl(v));
+    }
+    return `(${elems.join(` ${op} `)})`;
+}
+function toStringImpl(c) {
+    switch (c.type) {
         case 'range':
             return toRangeString(c);
         case 'term':
-            return (c.field ? c.field + ':' : '') + toString(c.value);
+            return toStringImpl(c.value);
+        case 'namedterm':
+            return c.field + ':' + toStringImpl(c.value);
         case 'and':
-            return `(${toString(c.lhs)} AND ${toString(c.rhs)})`;
+            return binaryOp('AND', c.operands);
         case 'constant':
-            return `(${toString(c.lhs)})^=${c.rhs}`;
+            return `(${toStringImpl(c.lhs)})^=${c.rhs}`;
         case 'not':
-            return `(NOT ${toString(c.rhs)})`;
+            return `(NOT ${toStringImpl(c.rhs)})`;
         case 'or':
-            return `(${toString(c.lhs)} OR ${toString(c.rhs)})`;
+            return binaryOp('OR', c.operands);
         case 'prohibited':
-            return `-${toString(c.rhs)}`;
+            return `-${toStringImpl(c.rhs)}`;
         case 'required':
-            return `+${toString(c.rhs)}`;
+            return `+${toStringImpl(c.rhs)}`;
+        case 'literal':
+            return toLiteralString(c.value);
         /* istanbul ignore next */
@@ -162,3 +190,6 @@ default:
 }
+function toString(c) {
+    return toStringImpl(c);
+}
 exports.toString = toString;
 //# sourceMappingURL=Q.js.map

build/src/spatial.d.ts

@@ -1,7 +0,7 @@
-import { Spatial, SpatialOp, Intersects, IsWithin, Contains, IsDisjointTo } from './types';
+import { Spatial, SpatialOp, Intersects, IsWithin, Contains, IsDisjointTo, Literal } from './types';
 import * as geojson from 'geojson';
-export declare function spatialPredicate<T extends SpatialOp>(op: T, value: geojson.Geometry): Spatial<T>;
-export declare function intersects(value: geojson.Geometry): Intersects;
-export declare function isWithin(value: geojson.Geometry): IsWithin;
-export declare function contains(value: geojson.Geometry): Contains;
-export declare function isDisjointTo(value: geojson.Geometry): IsDisjointTo;
+export declare function spatialPredicate<T extends SpatialOp>(op: T, value: geojson.Geometry): Literal<Spatial<T>>;
+export declare function intersects(value: geojson.Geometry): Literal<Intersects>;
+export declare function isWithin(value: geojson.Geometry): Literal<IsWithin>;
+export declare function contains(value: geojson.Geometry): Literal<Contains>;
+export declare function isDisjointTo(value: geojson.Geometry): Literal<IsDisjointTo>;

build/src/spatial.js

@@ -5,5 +5,8 @@ "use strict";
     return {
-        type: 'spatial',
-        op,
-        value,
+        type: 'literal',
+        value: {
+            type: 'spatial',
+            op,
+            value,
+        },
     };
@@ -10,0 +13,0 @@ }

build/src/types.d.ts

 import * as geojson from 'geojson';
 export interface Term<T extends Primitive> {
     type: 'term';
-    field?: string;
-    value?: TermValue<T>;
+    value: TermValue<T>;
 }
+export interface NamedTerm<T extends Primitive> {
+    type: 'namedterm';
+    field: string;
+    value: TermValue<T>;
+}
 export interface Range<T extends Primitive> {
@@ -14,27 +18,45 @@ type: 'range';
 }
-export interface And<T extends Primitive> {
+export interface AndBase<U> {
     type: 'and';
-    lhs: Clause<T>;
-    rhs: Clause<T>;
+    operands: U[];
 }
-export interface Or<T extends Primitive> {
+export interface And extends AndBase<Clause> {
+}
+export interface AndTerm<T extends Primitive> extends AndBase<TermValue<T>> {
+}
+export interface OrBase<U> {
     type: 'or';
-    lhs: Clause<T>;
-    rhs: Clause<T>;
+    operands: U[];
 }
-export interface Not<T extends Primitive> {
+export interface Or extends OrBase<Clause> {
+}
+export interface OrTerm<T extends Primitive> extends OrBase<TermValue<T>> {
+}
+export interface NotBase<U> {
     type: 'not';
-    rhs: Clause<T>;
+    rhs: U;
 }
-export interface Required<T extends Primitive> {
+export interface Not extends NotBase<Clause> {
+}
+export interface NotTerm<T extends Primitive> extends NotBase<TermValue<T>> {
+}
+export interface RequiredBase<U> {
     type: 'required';
-    rhs: Clause<T>;
+    rhs: U;
 }
-export interface Prohibited<T extends Primitive> {
+export interface Required extends RequiredBase<Clause> {
+}
+export interface RequiredTerm<T extends Primitive> extends RequiredBase<TermValue<T>> {
+}
+export interface ProhibitedBase<U> {
     type: 'prohibited';
-    rhs: Clause<T>;
+    rhs: U;
 }
-export interface ConstantScore<T extends Primitive> {
+export interface Prohibited extends ProhibitedBase<Clause> {
+}
+export interface ProhibitedTerm<T extends Primitive> extends ProhibitedBase<TermValue<T>> {
+}
+export interface ConstantScore {
     type: 'constant';
-    lhs: Clause<T>;
+    lhs: Clause;
     rhs: number;
@@ -48,2 +70,6 @@ }
 }
+export interface Glob {
+    type: 'glob';
+    value: string;
+}
 export declare type Intersects = Spatial<'Intersects'>;
@@ -53,6 +79,9 @@ export declare type IsWithin = Spatial<'IsWithin'>;
 export declare type IsDisjointTo = Spatial<'IsDisjointTo'>;
-export declare type Primitive = undefined | number | Date | string | Spatial<SpatialOp>;
-export declare type Clause<T extends Primitive> = Term<T> | TermValue<T> | ConstantScore<T>;
-export declare type NonPrimitiveClause<T extends Primitive> = Term<T> | NonPrimitiveTermValue<T> | ConstantScore<T>;
-export declare type TermValue<T extends Primitive> = T | NonPrimitiveTermValue<T>;
-export declare type NonPrimitiveTermValue<T extends Primitive> = Range<T> | And<T> | Or<T> | Not<T> | Required<T> | Prohibited<T>;
+export declare type Primitive = number | Date | string | Spatial<SpatialOp> | Glob;
+export interface Literal<T extends Primitive> {
+    type: 'literal';
+    value: T;
+}
+export declare type Clause = Term<Primitive> | NamedTerm<Primitive> | ConstantScore | And | Or | Not | Required | Prohibited | TermValue<Primitive>;
+export declare type TermValue<T extends Primitive> = Literal<T> | Literal<Glob> | NonPrimitiveTermValue<T>;
+export declare type NonPrimitiveTermValue<T extends Primitive> = Range<T> | AndTerm<T> | OrTerm<T> | NotTerm<T> | RequiredTerm<T> | ProhibitedTerm<T>;

package.json

 {
   "name": "solr-query-maker",
-  "version": "0.2.2",
+  "version": "0.9.0",
   "description": "A Solr Query builder and types",
@@ -68,3 +68,2 @@ "repository": {
   "dependencies": {
-    "lodash.reduce": "^4.6.0",
     "terraformer-wkt-parser": "^1.2.0"
@@ -74,3 +73,2 @@ },
     "@types/geojson": "^7946.0.7",
-    "@types/lodash.reduce": "^4.6.6",
     "@types/mocha": "^5.2.5",
@@ -77,0 +75,0 @@ "@types/nock": "^10.0.3",

README.md

@@ -14,3 +14,3 @@ # solr-query-maker - Build Solr search queries, including spatial predicates
 function makeQuery() {
-  // '((geo:"Intersects(POINT (-122.17381 37.426002))" OR "spicy") OR product:([100 TO *] AND (NOT 600)))'
+  // '((geo:"Intersects(POINT (-122.17381 37.426002))" OR "spicy") OR title:He??o OR product:([100 TO *] AND (NOT 600)))'
   return Q.toString(
@@ -25,4 +25,5 @@ Q.or(
       ),
-      Q.defaultTerm('spicy'),
-      Q.term('product', Q.and(Q.closedRange(100, undefined), Q.not(600)))
+      Q.defaultTerm(Q.L('spicy')),
+      Q.term('title', Q.glob('He??o')),
+      Q.term('product', Q.and(Q.closedRange(100, undefined), Q.not(Q.L(600))))
     )
@@ -29,0 +30,0 @@ );

No alert changes

Improved metrics

Total package byte prevSize

43782

increased by3.37%

Dependency count

1

decreased by-50%

Dev dependency count

13

decreased by-7.14%

Lines of code

397

increased by21.41%

Number of lines in readme file

63

increased by1.61%

Dependency changes

• - Removedlodash.reduce@^4.6.0

• - Removedlodash.reduce@4.6.0(transitive)