eyereasoner 1.0.3 → 1.1.1

package/README.md

@@ -3,32 +3,92 @@ Distributing the [EYE](https://github.com/josd/eye) reasoner for browser and nod
 
 [![GitHub license](https://img.shields.io/github/license/eyereasoner/eye-js.svg)](https://github.com/eyereasoner/eye-js/blob/master/LICENSE)
 [![npm version](https://img.shields.io/npm/v/eyereasoner.svg)](https://www.npmjs.com/package/eyereasoner)
-[![build](https://img.shields.io/github/workflow/status/eyereasoner/eye-js/Node.js%20CI)](https://github.com/eyereasoner/eye-js/tree/main/)
+[![build](https://img.shields.io/github/actions/workflow/status/eyereasoner/eye-js/nodejs.yml?branch=main)](https://github.com/eyereasoner/eye-js/tree/main/)
 [![Dependabot](https://badgen.net/badge/Dependabot/enabled/green?icon=dependabot)](https://dependabot.com/)
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 
 ## Usage
-<!--
+
 The simplest way to use this package is to execute a query over a dataset and get the results
 
 ```ts
 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
--->
-
-An example usage of the module is as follows
 
 ```ts
 import { SWIPL, loadEye, queryOnce } from 'eyereasoner';

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;
     });
@@ -93,8 +94,23 @@ exports.executeBasicEyeQuery = executeBasicEyeQuery;
 function executeBasicEyeQueryQuads(swipl, data, queryString) {
     return __awaiter(this, void 0, void 0, function* () {
         const parser = new n3_1.Parser({ format: 'text/n3' });
-        const writer = new n3_1.Writer({ format: 'text/n3' });
-        return parser.parse(yield executeBasicEyeQuery(swipl, writer.quadsToString(data), writer.quadsToString(queryString)));
+        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.3",
+  "version": "1.1.1",
   "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",