Members

cons : Object: The constrain object for KB. has many convenience methods. Call via KB.cons.
addNode ⇒ Promise: Adds node(s) to neo4j with a required JSON prop satisfying the KB constraints, and an optional Label string or array.
getNode ⇒ Promise: Get node(s) from neo4j with JSON prop, and optional Label.
addEdge ⇒ Promise: Adds edge(s) to neo4j with propLabel of nodes A -> B with the edge E. The propLabel for A and B is an array of a optional non-empty JSON prop (doesn't have to satisfy KB constraints), and an optional Label string or array. The prop for E must satisfy the KB constraints, and the Label for E is required.
getEdge ⇒ Promise: Get edge(s) from neo4j with propLabel of nodes A -> B with the edge E. The propLabel for A, B and E is an array of a optional non-empty JSON prop (doesn't have to satisfy KB constraints), and a (optional for A,B; required for E) Label string or array.
get ⇒ Promise: Get graph and do whatever u want with the search results: filter, RETURN, DELETE, DETACH DELETE. Graph: node(s) and edge(s) from neo4j with propLabel of nodes A -> B with the edge E. The propLabel for A, B and E is an array of a optional non-empty JSON prop (doesn't have to satisfy KB constraints), and a (optional for A,B; required for E) Label string or array. This is a flexible method used for querying node(s), or optionally edge(s) and node(s). It also takes an optional WHERE filter sentence string, and a required RETURN sentence string.The resultant query string is of the form: For nodes: MATCH (a:LabelA {propA}) For nodes and edges: MATCH (a:LabelA {propA})-[e:LabelE ({propE}|*Dist)]-(b:LabelB {propB})
add ⇒ Promise: Get graph and do whatever u want with the search results: filter, RETURN, DELETE, DETACH DELETE. Graph: node(s) and edge(s) from neo4j with propLabel of nodes A -> B with the edge E. The propLabel for A, B and E is an array of a optional non-empty JSON prop (doesn't have to satisfy KB constraints), and a (optional for A,B; required for E) Label string or array. This is a flexible method used for querying node(s), or optionally edge(s) and node(s). It also takes an optional WHERE filter sentence string, and a required RETURN sentence string.The resultant query string is of the form: For nodes: MATCH (a:LabelA {propA}) For nodes and edges: MATCH (a:LabelA {propA})-[e:LabelE ({propE}|*Dist)]-(b:LabelB {propB})
query ⇒ Promise: Queries Neo4j with arrays of pairs of query and optional params. Is the right-composition of genStatArr and postQuery. This is is query() method with full power, i.e. no query-string cleaning. Use responsibly. The high level add/get methods call this internall with query-string cleaning to prevent SQL injection. The query cleaning algorithm is (proven( based on the CFG parse tree and logic. Refer to isLegalSentence(). A sentence is a clause starting with the following query operation specifier: WHERE,SET,REMOVE,RETURN,DELETE,DETACH DELETE,SHORTESTPATH,ALLSHORTESTPATHS The sentence also consists of variables and operators . The permissible operators by this algorithm are AND,OR,XOR,NOT,=,<>,<,>,<=,>=,IS NULL,IS NOT NULL,+,+=,=~,EXISTS,nodes,labels,keys,",",=,ORDER BY,LIMIT,COUNT,sum,avg,percentileDisc,percentileCont,stdev,stdevp,max,min,collect,DISTINCT,nodes,labels,keys

Functions

literalize(propDistLabel, [name]) ⇒ string: Generalization of literalizeProp. Parses a propDistLabel array of prop-label or dist-label into a 'literal map' string as required by neo4j error (unable to user parameter map in MATCH). On can pass the name of the identifier too. Beware: in the query-param pair, the param prop JSON must use the key 'prop_'. E.g. query param pair:
log(arg) ⇒ string: A conveience method. JSON-stringify the argument, logs it, and return the string.
beautify(neoRes, fn, [keepHead]) ⇒ string: Transform and beautify the entire neoRes by internally calling transform(neoRes) -> array of tables -> beautifyMat on each table -> join('\n\n\n'). If neoRes has only one qRes, then returns the single transformed table.
transBeautify(transNeoRes, fn) ⇒ string: Beautify for post-transformation: beautify the transformed neoRes by internally calling array of tables -> beautifyMat on each table -> join('\n\n\n'). Note that neoRes must be transformed beforehand. This is for when transformation happens separately. If neoRes has only one qRes, then returns the single transformed table.
beautifyMat(mat) ⇒ string: Beautify a matrix by JSON.stringify -> join('\n\n') -> join('\n\n---\n\n') to separate rows, and wrap with '```'
transform(neoRes, fn, [keepHead]) ⇒ Array: Format the entire neoRes into an array of qRes tables. Can be called multiply for sequential transformation. If neoRes has only one qRes, then returns the single transformed table.
parseKV(obj) ⇒ Array: Parse a JSON object into array to ['k: v', 'k: v'], where v is attemptedly stringified.
cleanUser(userObj) ⇒ JSON: Cleanup the user object by picking out name, real_name, id, email_address.
parseUser(userObj) ⇒ string: A beautify transformer method to parse user, picking out name, real_name, id, email_address; uses parseKV internally.
parseObj(obj, keyArr) ⇒ Array: A beautify transformer method to parse object, picking out keys from keyArr; uses parseKV internally.
leftJoin(propArr, match, [boolOp]) ⇒ string: Helper to generate wOp for matching multiple properties to the same value.
sorter(iteratees) ⇒ function: Generate a function to sort the rows of a matrix passed to it using _.sortBy and iteratees.
picker(iteratees) ⇒ function: For use with transform. Generate a picker function using _.pick with a supplied iteratees.
pickerBy(iteratees) ⇒ function: For use with transform. Generate a picker function using _.pickBy with a supplied iteratees.
flattenIndex(mat) ⇒ string: Flatten and index a matrix of objects into formatted string. 'name' key will always appear first next to index.

cons : `Object`

The constrain object for KB. has many convenience methods. Call via KB.cons.

Kind: global variable

cons : Object
- .now() ⇒ string
- .legalize(prop, [res], [hash_by]) ⇒ JSON
- .illegalize(prop) ⇒ JSON
- .isLegalSentence(str) ⇒ Boolean

cons.now() ⇒ `string`

Generates the current timestamp in ISO 8601 format, e.g. 2016-01-22T14:42:27.579Z

Kind: static method of cons
Returns: string - ISO 8601 timestamp string, e.g. '2016-01-22T14:42:27.579Z'

cons.legalize(prop, [res], [hash_by]) ⇒ `JSON`

Legalize a prop obj by inserting the missing mandatory fields with default values. Automatically flattens the JSON with key delimiter '__' since neo4J doesn't take a deep JSON. Also updates the hash as demanded by 'hash_by', and you can supply the 'hash_by' key as an argument. Mutates the object. Used mainly for testing. Use with care.

Kind: static method of cons
Returns: JSON - mutated prop that is now legal wrt the constraints.

Param	Type	Description
prop	`JSON`	The properties object for KB node.
[res]	`JSON`	For the robot to extract user id.
[hash_by]	`string`	Specify and set the hash_by key and update it internally.

Example

var prop = {name: 'A', hash_by: 'name'}
cons.legalize(prop)
// => { name: 'A',
// hash_by: 'name',
// hash: 'A',
// updated_by: 'bot',
// updated_when: 1452802513112 }

// supplying the 'hash_by' key
var prop0 = {name: 'A'}
cons.legalize(prop0, 'name')
// => { name: 'A',
// hash_by: 'name',
// hash: 'A',
// updated_by: 'bot',
// updated_when: 1452802513112 }

var prop1 = {name: 'A', hash_by: 'name', meh: { a:1 }}
cons.legalize(prop1)
// => { name: 'A',
// meh__a: 1,
// hash_by: 'name',
// hash: 'A',
// updated_by: 'bot',
// updated_when: 1452802513112 }

// quick constructor of a legal prop
cons.legalize('A')
// { name: 'A',
//   hash_by: 'name',
//   hash: 'A',
//   updated_by: 'bot',
//   updated_when: '2016-02-01T20:34:02.582Z' }

cons.legalize('A', 'updated_when')
// { name: 'A',
//   hash_by: 'updated_when',
//   hash: '2016-02-01T20:34:02.603Z',
//   updated_by: 'bot',
//   updated_when: '2016-02-01T20:34:02.603Z' }

cons.illegalize(prop) ⇒ `JSON`

The opposite of legalize: Return a new prop with its mandatoryFields removed. Does not mutate object. Used to yield cleaner prop.

Kind: static method of cons
Returns: JSON - Prop without the mandatory fields.

Param	Type	Description
prop	`JSON`	The prop to illegalize.

Example

var prop = {name: 'A'}
cons.legalize(prop)
// => prop = { name: 'A',
  hash_by: 'hash',
  hash: 'test',
  updated_by: 'bot',
  updated_when: '2016-02-01T22:02:34.822Z' }
  
cons.illegalize(prop)
// => { name: 'A' }

cons.isLegalSentence(str) ⇒ `Boolean`

Check if the string is a RETURN operation string and is legal, to prevent SQL injection. Algo (str):

replace "(" and ")" globally
split by globally, trim spaces, into variables
check if each variable is legally atomic (shan't be split further): either contains no space "\s+" and no quotes "", '" at all, or is a proper quoted string with quotes on the boundaries but not the inside.

A sentence is a clause starting with the following query operation specifier: WHERE,SET,REMOVE,RETURN,DELETE,DETACH DELETE,SHORTESTPATH,ALLSHORTESTPATHS The sentence also consists of variables and operators . The permissible operators by this algorithm are AND,OR,XOR,NOT,=,<>,<,>,<=,>=,IS NULL,IS NOT NULL,+,+=,=~,EXISTS,nodes,labels,keys,",",=,ORDER BY,LIMIT,COUNT,sum,avg,percentileDisc,percentileCont,stdev,stdevp,max,min,collect,DISTINCT,nodes,labels,keys

Proof: Some terminologies: A sentence is a string that can properly evaluate to its output. It consists of operators and variables. Operators (single argument on either side here) operate on a single variable on either side (left and right) to yield another variable. We can take the CFG parse tree of the whole string, split by the ops. We do not care about operator precedence in checking the legality of the string. Also note that parentheses "(", ")" exists only to assert operator precedence to give an unambiguous parse tree, thus removing them entirely is simply making the tree flat, i.e. all operations run from left to right. Furthermore, note that from the terminologies we can see that in a sentence, there can only be adjacent occurence of operators, but not of variables. This can also be seen from the parse tree, where the sentence is split by operators, and variables are the leaves. Leaves are always atomic. This justifies our algorithm.

Kind: static method of cons

Param	Type	Description
str	`string`	A sentence of Ops and Variables.

addNode ⇒ `Promise`

Adds node(s) to neo4j with a required JSON prop satisfying the KB constraints, and an optional Label string or array.