eyereasoner 1.0.2 → 1.1.0

package/README.md

@@ -15,27 +15,106 @@ The simplest way to use this package is to execute a query over a dataset and ge
 import { basicQuery } from 'eyereasoner';
 
 async function main() {
-  const resultQuads = await basicQuery(dataQuads, queryQuads);
+  const {
+    // The result of the query (as an array of quads)
+    result,
+    // The proof of the results (as an array of quads)
+    proof
+  } = await basicQuery(dataQuads, queryQuads);
 }
 
 main();
 ```
 
-Here the inputs and outputs are both arrays of RDF/JS Quads
+Here the inputs and outputs are both arrays of RDF/JS Quads; for instance
+
+```ts
+const queryQuads = [
+  DF.quad(
+    DF.namedNode('http://example.org/socrates#Socrates'),
+    DF.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
+    DF.variable('WHAT'),
+    DF.blankNode('b1')
+  ),
+  DF.quad(
+    DF.namedNode('http://example.org/socrates#Socrates'),
+    DF.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
+    DF.variable('WHAT'),
+    DF.blankNode('b2')
+  ),
+  DF.quad(
+    DF.blankNode('b1'),
+    DF.namedNode('http://www.w3.org/2000/10/swap/log#implies'),
+    DF.blankNode('b2')
+  )
+]
+
+const dataQuads = [
+  DF.quad(
+    DF.namedNode('http://example.org/socrates#Socrates'),
+    DF.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
+    DF.namedNode('http://example.org/socrates#Human'),
+  ),
+  DF.quad(
+    DF.namedNode('http://example.org/socrates#Human'),
+    DF.namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf'),
+    DF.namedNode('http://example.org/socrates#Mortal'),
+  ),
+  DF.quad(
+    DF.variable('A'),
+    DF.namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf'),
+    DF.variable('B'),
+    DF.blankNode('b1')
+  ),
+  DF.quad(
+    DF.variable('S'),
+    DF.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
+    DF.variable('A'),
+    DF.blankNode('b1')
+  ),
+  DF.quad(
+    DF.variable('S'),
+    DF.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
+    DF.variable('B'),
+    DF.blankNode('b2')
+  ),
+  DF.quad(
+    DF.blankNode('b1'),
+    DF.namedNode('http://www.w3.org/2000/10/swap/log#implies'),
+    DF.blankNode('b2')
+  ),
+]
+```
 
 ## Advanced usage
 
 To have more granular control one can also use this module as follows
 
 ```ts
-import { SWIPL, loadEye } from 'eyereasoner';
+import { SWIPL, loadEye, queryOnce } from 'eyereasoner';
+
+const query = `
+@prefix : <http://example.org/socrates#>.
+
+{:Socrates a ?WHAT} => {:Socrates a ?WHAT}.
+`
+
+const data = `
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix : <http://example.org/socrates#>.
+
+:Socrates a :Human.
+:Human rdfs:subClassOf :Mortal.
+
+{?A rdfs:subClassOf ?B. ?S a ?A} => {?S a ?B}.
+`
 
 async function main() {
   // Instantiate a new SWIPL module and log any results it produces to the console
   const Module = await SWIPL({ print: (str: string) => { console.log(str) }, arguments: ['-q'] });
 
   // Load EYE into the SWIPL Module and run consule("eye.pl").
-  loadEye(MODULE)
+  loadEye(Module)
 
   // Load the the strings data and query as files data.n3 and query.n3 into the module
   Module.FS.writeFile('data.n3', data);
@@ -44,6 +123,9 @@ async function main() {
   // Execute main(['--quiet', './data.n3', '--query', './query.n3']).
   queryOnce(Module, 'main', ['--quiet', './data.n3', '--query', './query.n3']);
 }
+
+main();
+
 ```
 
 ## License

package/dist/index.d.ts

@@ -7,4 +7,7 @@ export { default as SWIPL } from './swipl-bundled.temp';
  * @param query The query as RDF/JS quads
  * @returns The result of the query as RDF/JS quads
  */
-export declare function basicQuery(data: Quad[], query: Quad[]): Promise<Quad[]>;
+export declare function basicQuery(data: Quad[], query: Quad[]): Promise<{
+    result: Quad[];
+    proof: Quad[];
+}>;

package/dist/n3Writer.temp.d.ts

@@ -0,0 +1,12 @@
+import { Quad, Term } from '@rdfjs/types';
+import { Store } from 'n3';
+export declare class N3Writer {
+    private _writer;
+    _encodePredicate(term: Term): string;
+    _encodeSubject(entity: Term, store: Store): string;
+    _encodeObject(entity: Term, store: Store): string;
+    quadToString(t: Quad, store: Store): string;
+    quadsStoreToString(store: Store, graph?: Term): string;
+    quadsToString(quads: Quad[]): string;
+}
+export declare function write(quads: Quad[]): string;

package/dist/n3Writer.temp.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.write = exports.N3Writer = void 0;
+const n3_1 = require("n3");
+function isQuoted(term, store) {
+    return term.termType === 'BlankNode' && store.getQuads(null, null, null, term).length > 0;
+}
+class N3Writer {
+    constructor() {
+        this._writer = new n3_1.Writer();
+    }
+    _encodePredicate(term) {
+        if (term.termType === 'NamedNode') {
+            switch (term.value) {
+                case 'http://www.w3.org/2000/10/swap/log#implies':
+                    return '=>';
+                case 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type':
+                    return 'a';
+            }
+        }
+        return this._writer._encodeIriOrBlank(term);
+    }
+    _encodeSubject(entity, store) {
+        if (isQuoted(entity, store)) {
+            return `{${this.quadsStoreToString(store, entity)}}`;
+        }
+        return this._writer._encodeSubject(entity);
+    }
+    _encodeObject(entity, store) {
+        if (isQuoted(entity, store)) {
+            return `{${this.quadsStoreToString(store, entity)}}`;
+        }
+        return this._writer._encodeObject(entity);
+    }
+    // ### `quadToString` serializes a quad as a string
+    quadToString(t, store) {
+        return `${this._encodeSubject(t.subject, store)} ${this._encodePredicate(t.predicate)} ${this._encodeObject(t.object, store)}`;
+    }
+    // ### `quadsToString` serializes an array of quads as a string
+    quadsStoreToString(store, graph = n3_1.DataFactory.defaultGraph()) {
+        return store.getQuads(null, null, null, graph)
+            .map(t => this.quadToString(t, store))
+            .join(' . ') + ' . ';
+    }
+    quadsToString(quads) {
+        return this.quadsStoreToString(new n3_1.Store(quads));
+    }
+}
+exports.N3Writer = N3Writer;
+function write(quads) {
+    return (new N3Writer).quadsToString(quads);
+}
+exports.write = write;

package/dist/transformers.d.ts

@@ -45,4 +45,7 @@ export declare function executeBasicEyeQuery(swipl: typeof SWIPL, data: string,
  * @param queryString The query (in N3 format)
  * @returns The result of the query
  */
-export declare function executeBasicEyeQueryQuads(swipl: typeof SWIPL, data: Quad[], queryString: Quad[]): Promise<Quad[]>;
+export declare function executeBasicEyeQueryQuads(swipl: typeof SWIPL, data: Quad[], queryString: Quad[]): Promise<{
+    result: Quad[];
+    proof: Quad[];
+}>;

package/dist/transformers.js

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeBasicEyeQueryQuads = exports.executeBasicEyeQuery = exports.loadAndRunQuery = exports.runQuery = exports.loadEye = exports.queryOnce = exports.query = void 0;
 const n3_1 = require("n3");
+const n3Writer_temp_1 = require("./n3Writer.temp");
 const eye_pl_1 = __importDefault(require("./eye.pl"));
 /**
  * Executes a query
@@ -53,9 +54,9 @@ exports.loadEye = loadEye;
  * @returns The same SWIPL module
  */
 function runQuery(Module, data, queryString) {
-    Module.FS.writeFile('data.n3', data);
-    Module.FS.writeFile('query.n3', queryString);
-    queryOnce(Module, 'main', ['--quiet', './data.n3', '--query', './query.n3']);
+    Module.FS.writeFile('data.nq', data);
+    Module.FS.writeFile('query.nq', queryString);
+    queryOnce(Module, 'main', ['--quiet', './data.nq', '--query', './query.nq']);
     return Module;
 }
 exports.runQuery = runQuery;
@@ -78,7 +79,7 @@ exports.loadAndRunQuery = loadAndRunQuery;
 function executeBasicEyeQuery(swipl, data, queryString) {
     return __awaiter(this, void 0, void 0, function* () {
         let res = '';
-        const Module = yield swipl({ print: (str) => { res += str; }, arguments: ['-q'] });
+        const Module = yield swipl({ print: (str) => { res += `${str}\n`; }, arguments: ['-q'] });
         loadAndRunQuery(Module, data, queryString);
         return res;
     });
@@ -92,9 +93,24 @@ exports.executeBasicEyeQuery = executeBasicEyeQuery;
  */
 function executeBasicEyeQueryQuads(swipl, data, queryString) {
     return __awaiter(this, void 0, void 0, function* () {
-        const parser = new n3_1.Parser();
-        const writer = new n3_1.Writer();
-        return parser.parse(yield executeBasicEyeQuery(swipl, writer.quadsToString(data), writer.quadsToString(queryString)));
+        const parser = new n3_1.Parser({ format: 'text/n3' });
+        const queryResult = yield executeBasicEyeQuery(swipl, (0, n3Writer_temp_1.write)(data), (0, n3Writer_temp_1.write)(queryString));
+        const proof = parser.parse(queryResult);
+        const store = new n3_1.Store(proof);
+        const proofNode = store.getSubjects('http://www.w3.org/1999/02/22-rdf-syntax-ns#type', 'http://www.w3.org/2000/10/swap/reason#Proof', n3_1.DataFactory.defaultGraph());
+        if (proofNode.length !== 1) {
+            throw new Error(`Expected exactly one proof: received ${proofNode.length}`);
+        }
+        const results = store.getObjects(proofNode[0], 'http://www.w3.org/2000/10/swap/reason#gives', n3_1.DataFactory.defaultGraph());
+        if (results.length !== 1) {
+            throw new Error(`Expected exactly one triple giving inference results from proof: received ${results.length}`);
+        }
+        const result = store.getQuads(null, null, null, results[0])
+            .map((res) => n3_1.DataFactory.quad(res.subject, res.predicate, res.object));
+        return {
+            proof,
+            result,
+        };
     });
 }
 exports.executeBasicEyeQueryQuads = executeBasicEyeQueryQuads;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyereasoner",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Distributing the [EYE](https://github.com/josd/eye) reasoner for browser and node using WebAssembly.",
   "main": "dist/index.js",
   "types": "dist/index.d.js",
@@ -60,6 +60,7 @@
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-plugin-import": "^2.26.0",
     "jest": "^29.3.1",
+    "jest-rdf": "^1.7.1",
     "pre-commit": "^1.2.2",
     "rollup": "^3.8.1",
     "rollup-plugin-string": "^3.0.0",