ldkit 0.5.1 → 0.6.1

package/README.md

@@ -1,5 +1,7 @@
 # LDkit
 
-RDF framework for browser, Deno and Node
+Linked Data query toolkit for TypeScript developers.
+
+RDF and SPARQL abstraction for browser, Deno and Node.
 
 [ldkit.io](https://ldkit.io).

package/esm/library/asynciterator.js

@@ -0,0 +1,95 @@
+import { AsyncIterator } from "asynciterator";
+export { ArrayIterator, MappingIterator, } from "asynciterator";
+export class TreeIterator extends AsyncIterator {
+    constructor(tree) {
+        super();
+        Object.defineProperty(this, "_tree", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_pointer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._tree = tree;
+        this._pointer = this._buildPointerFromSource(tree);
+        this.readable = true;
+    }
+    read() {
+        if (this.closed) {
+            return null;
+        }
+        this._findNextCommonSegment();
+        this._findNextLeaf();
+        const p = this._pointer;
+        if (p.type === "leaf") {
+            p.index++;
+            if (p.index < p.items.length) {
+                return [...p.path, p.items[p.index]];
+            }
+            if (!p.parent) {
+                this.close();
+            }
+        }
+        if (p.type === "node") {
+            this.close();
+        }
+        return null;
+    }
+    _buildPointerFromSource(tree, path = []) {
+        if (tree.constructor === Object && !Array.isArray(tree)) {
+            return {
+                tree,
+                parent: this._pointer,
+                type: "node",
+                items: Object.keys(tree),
+                path,
+                index: -1,
+            };
+        }
+        if (Array.isArray(tree)) {
+            return {
+                parent: this._pointer,
+                type: "leaf",
+                items: tree,
+                path,
+                index: -1,
+            };
+        }
+        else {
+            throw new Error("Invalid tree specified, expecting arrays in plain objects.");
+        }
+    }
+    _findNextCommonSegment() {
+        while (this._pointer.parent !== null) {
+            const p = this._pointer;
+            if (p.type === "leaf" && p.index < p.items.length - 1) {
+                // Points to a leaf that is not yet exhausted
+                break;
+            }
+            if (p.index >= p.items.length - 1 && this._pointer.parent) {
+                this._pointer = this._pointer.parent;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    _findNextLeaf() {
+        while (this._pointer.type !== "leaf") {
+            const p = this._pointer;
+            p.index++;
+            if (p.index >= p.items.length) {
+                // no other keys present, the tree is exhausted;
+                break;
+            }
+            const key = p.items[p.index];
+            const source = this._pointer.tree[key];
+            this._pointer = this._buildPointerFromSource(source, [...p.path, key]);
+        }
+    }
+}

package/esm/library/engine/query_engine.js

@@ -1,4 +1,5 @@
 import { BindingsFactory, QuadFactory, } from "../rdf.js";
+import { ArrayIterator, MappingIterator, TreeIterator, } from "../asynciterator.js";
 export class QueryEngine {
     getSparqlEndpoint(context) {
         if (!context) {
@@ -29,49 +30,50 @@ export class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    async query(query, context) {
+    async query(query, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
-        return await fetchFn(endpoint, {
+        const response = await fetchFn(endpoint, {
             method: "POST",
             headers: {
-                "accept": "application/sparql-results+json",
+                "accept": responseType,
                 "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
             },
             body: new URLSearchParams({
                 query,
             }),
         });
+        const json = await response.json();
+        return json;
     }
     async queryBindings(query, context) {
-        const result = await this.query(query, context);
-        const json = await result.json();
-        if (!Array.isArray(json?.results?.bindings)) {
+        const json = await this.query(query, "application/sparql-results+json", context);
+        if (!Array.isArray(json.results?.bindings)) {
             throw new Error("Bindings SPARQL query result not found");
         }
-        // Force richer type from RDF spec
         const bindingsFactory = new BindingsFactory();
-        return Array.from(json.results.bindings, (i) => bindingsFactory.fromJson(i));
+        const bindingsIterator = new ArrayIterator(json.results.bindings);
+        // TODO: review the unknown type cast
+        return new MappingIterator(bindingsIterator, (i) => bindingsFactory.fromJson(i));
     }
     async queryBoolean(query, context) {
-        const result = await this.query(query, context);
-        const json = await result.json();
+        const json = await this.query(query, "application/sparql-results+json", context);
         if ("boolean" in json) {
             return Boolean(json.boolean);
         }
         throw new Error("Boolean SPARQL query result not found");
     }
     async queryQuads(query, context) {
-        const result = await this.query(query, context);
-        const json = await result.json();
-        if (!Array.isArray(json?.results?.bindings)) {
+        const json = await this.query(query, "application/rdf+json", context);
+        if (!(json?.constructor === Object)) {
             throw new Error("Quads SPARQL query result not found");
         }
-        // Force richer type from RDF spec
         const quadFactory = new QuadFactory();
-        return Array.from(json.results.bindings, (i) => quadFactory.fromJson(i));
+        const treeIterator = new TreeIterator(json);
+        // TODO: review the unknown type cast
+        return new MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
     }
     async queryVoid(query, context) {
-        await this.query(query, context);
+        await this.query(query, "application/sparql-results+json", context);
     }
 }

package/esm/library/engine/query_engine_proxy.js

@@ -1,6 +1,5 @@
 import { quadsToGraph } from "../rdf.js";
 import { resolveContext, resolveEngine } from "../global.js";
-import { from, map, of, switchMap } from "../rxjs.js";
 export class QueryEngineProxy {
     constructor(context, engine) {
         Object.defineProperty(this, "context", {
@@ -19,17 +18,18 @@ export class QueryEngineProxy {
         this.engine = resolveEngine(engine);
     }
     queryBoolean(query) {
-        return from(this.engine.queryBoolean(query, this.context));
+        return this.engine.queryBoolean(query, this.context);
     }
-    queryBindings(query) {
-        return from(this.engine.queryBindings(query, this.context)).pipe(switchMap((stream) => of(Array.from(stream))));
+    async queryBindings(query) {
+        const bindingsStream = await this.engine.queryBindings(query, this.context);
+        return bindingsStream.toArray();
     }
-    queryGraph(query) {
-        return from(this.engine.queryQuads(query, this.context)).pipe(switchMap((stream) => of(Array.from(stream))), map((quads) => {
-            return quadsToGraph(quads);
-        }));
+    async queryGraph(query) {
+        const quadStream = await this.engine.queryQuads(query, this.context);
+        const quads = await (quadStream.toArray());
+        return quadsToGraph(quads);
     }
     queryVoid(query) {
-        return from(this.engine.queryVoid(query, this.context));
+        return this.engine.queryVoid(query, this.context);
     }
 }

package/esm/library/rdf.js

@@ -1,6 +1,6 @@
 export { fromRdf, toRdf } from "rdf-literal";
 import { DataFactory } from "rdf-data-factory";
-export { DataFactory } from "rdf-data-factory";
+export { DataFactory };
 import { BindingsFactory as ComunicaBindingsFactory } from "@comunica/bindings-factory";
 export const quadsToGraph = (quads) => {
     const graph = new Map();
@@ -68,24 +68,24 @@ export class BindingsFactory extends ComunicaBindingsFactory {
     }
 }
 export class QuadFactory {
-    constructor(dataFactory = new DataFactory(), bindingsFactory = new BindingsFactory(dataFactory)) {
+    constructor(dataFactory = new DataFactory(), termFactory = new TermFactory()) {
         Object.defineProperty(this, "dataFactory", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "bindingsFactory", {
+        Object.defineProperty(this, "termFactory", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
         this.dataFactory = dataFactory;
-        this.bindingsFactory = bindingsFactory;
+        this.termFactory = termFactory;
     }
-    fromJson(jsonBindings) {
-        const bindings = this.bindingsFactory.fromJson(jsonBindings);
-        return this.dataFactory.quad(bindings.get("s"), bindings.get("p"), bindings.get("o"));
+    fromJson(jsonRdf) {
+        const [s, p, o] = jsonRdf;
+        return this.dataFactory.quad(this.dataFactory.namedNode(s), this.dataFactory.namedNode(p), this.termFactory.fromJson(o));
     }
 }

package/esm/library/resource/resource.js

@@ -1,4 +1,3 @@
-import { BehaviorSubject, map, share, switchMap, tap } from "../rxjs.js";
 import { resolveContext } from "../global.js";
 import { expandSchema, } from "../schema/mod.js";
 import { decode } from "../decoder.js";
@@ -31,12 +30,6 @@ export class Resource {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "$trigger", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new BehaviorSubject(null)
-        });
         this.schema = expandSchema(schema);
         this.context = resolveContext(context);
         this.engine = new QueryEngineProxy(this.context, engine);
@@ -45,45 +38,36 @@ export class Resource {
     decode(graph) {
         return decode(graph, this.schema, this.context);
     }
-    count() {
+    async count() {
         const q = this.queryBuilder.countQuery();
         console.log(q);
-        return this.$trigger.pipe(switchMap(() => this.engine.queryBindings(q)), map((bindings) => {
-            console.warn("BINDINGS", bindings);
-            return parseInt(bindings[0].get("count").value);
-        }));
+        const bindings = await this.engine.queryBindings(q);
+        return parseInt(bindings[0].get("count").value);
     }
     //exists(entity: Identity) {}
-    query(sparqlConstructQuery) {
-        console.log(sparqlConstructQuery);
-        return this.engine.queryGraph(sparqlConstructQuery).pipe(map((graph) => {
-            console.warn("GRAPH", graph);
-            return this.decode(graph);
-        }));
+    async query(sparqlConstructQuery) {
+        const graph = await this.engine.queryGraph(sparqlConstructQuery);
+        return this.decode(graph);
     }
-    find(where, limit) {
+    async find(where, limit) {
         const q = this.queryBuilder.getQuery(where, limit);
         console.log(q);
-        return this.$trigger.pipe(switchMap(() => this.engine.queryGraph(q)), map((graph) => {
-            console.warn("GRAPH", graph);
-            return this.decode(graph);
-        }));
+        const graph = await this.engine.queryGraph(q);
+        return this.decode(graph);
     }
-    findByIri(iri) {
-        return this.findByIris([iri]).pipe(map((result) => (result.length > 0 ? result[0] : undefined)));
+    async findByIri(iri) {
+        const results = await this.findByIris([iri]);
+        return results.length > 0 ? results[0] : undefined;
     }
-    findByIris(iris) {
+    async findByIris(iris) {
         const q = this.queryBuilder.getByIrisQuery(iris);
         console.log(q);
-        return this.$trigger.pipe(switchMap(() => this.engine.queryGraph(q)), map((graph) => {
-            return this.decode(graph);
-        }));
+        const graph = await this.engine.queryGraph(q);
+        return this.decode(graph);
     }
     updateQuery(query) {
         console.log(query);
-        const result = this.engine.queryVoid(query).pipe(tap(() => this.$trigger.next(null)), share());
-        result.subscribe();
-        return result;
+        return this.engine.queryVoid(query);
     }
     insert(...entities) {
         const q = this.queryBuilder.insertQuery(entities);

package/package.json

@@ -3,12 +3,15 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
   "keywords": [
-    "linked data, rdf, sparql"
+    "linked data",
+    "rdf",
+    "sparql",
+    "deno"
   ],
   "license": "MIT",
   "repository": {
@@ -45,9 +48,9 @@
     "@comunica/types": "2.4.0",
     "@tpluscode/rdf-string": "0.2.26",
     "@tpluscode/sparql-builder": "0.3.23",
+    "asynciterator": "3.7.0",
     "rdf-data-factory": "1.1.1",
     "rdf-js": "4.0.2",
-    "rdf-literal": "1.3.0",
-    "rxjs": "7.5.6"
+    "rdf-literal": "1.3.0"
   }
 }

package/script/library/asynciterator.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeIterator = exports.MappingIterator = exports.ArrayIterator = void 0;
+const asynciterator_1 = require("asynciterator");
+var asynciterator_2 = require("asynciterator");
+Object.defineProperty(exports, "ArrayIterator", { enumerable: true, get: function () { return asynciterator_2.ArrayIterator; } });
+Object.defineProperty(exports, "MappingIterator", { enumerable: true, get: function () { return asynciterator_2.MappingIterator; } });
+class TreeIterator extends asynciterator_1.AsyncIterator {
+    constructor(tree) {
+        super();
+        Object.defineProperty(this, "_tree", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_pointer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._tree = tree;
+        this._pointer = this._buildPointerFromSource(tree);
+        this.readable = true;
+    }
+    read() {
+        if (this.closed) {
+            return null;
+        }
+        this._findNextCommonSegment();
+        this._findNextLeaf();
+        const p = this._pointer;
+        if (p.type === "leaf") {
+            p.index++;
+            if (p.index < p.items.length) {
+                return [...p.path, p.items[p.index]];
+            }
+            if (!p.parent) {
+                this.close();
+            }
+        }
+        if (p.type === "node") {
+            this.close();
+        }
+        return null;
+    }
+    _buildPointerFromSource(tree, path = []) {
+        if (tree.constructor === Object && !Array.isArray(tree)) {
+            return {
+                tree,
+                parent: this._pointer,
+                type: "node",
+                items: Object.keys(tree),
+                path,
+                index: -1,
+            };
+        }
+        if (Array.isArray(tree)) {
+            return {
+                parent: this._pointer,
+                type: "leaf",
+                items: tree,
+                path,
+                index: -1,
+            };
+        }
+        else {
+            throw new Error("Invalid tree specified, expecting arrays in plain objects.");
+        }
+    }
+    _findNextCommonSegment() {
+        while (this._pointer.parent !== null) {
+            const p = this._pointer;
+            if (p.type === "leaf" && p.index < p.items.length - 1) {
+                // Points to a leaf that is not yet exhausted
+                break;
+            }
+            if (p.index >= p.items.length - 1 && this._pointer.parent) {
+                this._pointer = this._pointer.parent;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    _findNextLeaf() {
+        while (this._pointer.type !== "leaf") {
+            const p = this._pointer;
+            p.index++;
+            if (p.index >= p.items.length) {
+                // no other keys present, the tree is exhausted;
+                break;
+            }
+            const key = p.items[p.index];
+            const source = this._pointer.tree[key];
+            this._pointer = this._buildPointerFromSource(source, [...p.path, key]);
+        }
+    }
+}
+exports.TreeIterator = TreeIterator;

package/script/library/engine/query_engine.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryEngine = void 0;
 const rdf_js_1 = require("../rdf.js");
+const asynciterator_js_1 = require("../asynciterator.js");
 class QueryEngine {
     getSparqlEndpoint(context) {
         if (!context) {
@@ -32,50 +33,51 @@ class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    async query(query, context) {
+    async query(query, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
-        return await fetchFn(endpoint, {
+        const response = await fetchFn(endpoint, {
             method: "POST",
             headers: {
-                "accept": "application/sparql-results+json",
+                "accept": responseType,
                 "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
             },
             body: new URLSearchParams({
                 query,
             }),
         });
+        const json = await response.json();
+        return json;
     }
     async queryBindings(query, context) {
-        const result = await this.query(query, context);
-        const json = await result.json();
-        if (!Array.isArray(json?.results?.bindings)) {
+        const json = await this.query(query, "application/sparql-results+json", context);
+        if (!Array.isArray(json.results?.bindings)) {
             throw new Error("Bindings SPARQL query result not found");
         }
-        // Force richer type from RDF spec
         const bindingsFactory = new rdf_js_1.BindingsFactory();
-        return Array.from(json.results.bindings, (i) => bindingsFactory.fromJson(i));
+        const bindingsIterator = new asynciterator_js_1.ArrayIterator(json.results.bindings);
+        // TODO: review the unknown type cast
+        return new asynciterator_js_1.MappingIterator(bindingsIterator, (i) => bindingsFactory.fromJson(i));
     }
     async queryBoolean(query, context) {
-        const result = await this.query(query, context);
-        const json = await result.json();
+        const json = await this.query(query, "application/sparql-results+json", context);
         if ("boolean" in json) {
             return Boolean(json.boolean);
         }
         throw new Error("Boolean SPARQL query result not found");
     }
     async queryQuads(query, context) {
-        const result = await this.query(query, context);
-        const json = await result.json();
-        if (!Array.isArray(json?.results?.bindings)) {
+        const json = await this.query(query, "application/rdf+json", context);
+        if (!(json?.constructor === Object)) {
             throw new Error("Quads SPARQL query result not found");
         }
-        // Force richer type from RDF spec
         const quadFactory = new rdf_js_1.QuadFactory();
-        return Array.from(json.results.bindings, (i) => quadFactory.fromJson(i));
+        const treeIterator = new asynciterator_js_1.TreeIterator(json);
+        // TODO: review the unknown type cast
+        return new asynciterator_js_1.MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
     }
     async queryVoid(query, context) {
-        await this.query(query, context);
+        await this.query(query, "application/sparql-results+json", context);
     }
 }
 exports.QueryEngine = QueryEngine;

package/script/library/engine/query_engine_proxy.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryEngineProxy = void 0;
 const rdf_js_1 = require("../rdf.js");
 const global_js_1 = require("../global.js");
-const rxjs_js_1 = require("../rxjs.js");
 class QueryEngineProxy {
     constructor(context, engine) {
         Object.defineProperty(this, "context", {
@@ -22,18 +21,19 @@ class QueryEngineProxy {
         this.engine = (0, global_js_1.resolveEngine)(engine);
     }
     queryBoolean(query) {
-        return (0, rxjs_js_1.from)(this.engine.queryBoolean(query, this.context));
+        return this.engine.queryBoolean(query, this.context);
     }
-    queryBindings(query) {
-        return (0, rxjs_js_1.from)(this.engine.queryBindings(query, this.context)).pipe((0, rxjs_js_1.switchMap)((stream) => (0, rxjs_js_1.of)(Array.from(stream))));
+    async queryBindings(query) {
+        const bindingsStream = await this.engine.queryBindings(query, this.context);
+        return bindingsStream.toArray();
     }
-    queryGraph(query) {
-        return (0, rxjs_js_1.from)(this.engine.queryQuads(query, this.context)).pipe((0, rxjs_js_1.switchMap)((stream) => (0, rxjs_js_1.of)(Array.from(stream))), (0, rxjs_js_1.map)((quads) => {
-            return (0, rdf_js_1.quadsToGraph)(quads);
-        }));
+    async queryGraph(query) {
+        const quadStream = await this.engine.queryQuads(query, this.context);
+        const quads = await (quadStream.toArray());
+        return (0, rdf_js_1.quadsToGraph)(quads);
     }
     queryVoid(query) {
-        return (0, rxjs_js_1.from)(this.engine.queryVoid(query, this.context));
+        return this.engine.queryVoid(query, this.context);
     }
 }
 exports.QueryEngineProxy = QueryEngineProxy;

package/script/library/rdf.js

@@ -5,8 +5,7 @@ var rdf_literal_1 = require("rdf-literal");
 Object.defineProperty(exports, "fromRdf", { enumerable: true, get: function () { return rdf_literal_1.fromRdf; } });
 Object.defineProperty(exports, "toRdf", { enumerable: true, get: function () { return rdf_literal_1.toRdf; } });
 const rdf_data_factory_1 = require("rdf-data-factory");
-var rdf_data_factory_2 = require("rdf-data-factory");
-Object.defineProperty(exports, "DataFactory", { enumerable: true, get: function () { return rdf_data_factory_2.DataFactory; } });
+Object.defineProperty(exports, "DataFactory", { enumerable: true, get: function () { return rdf_data_factory_1.DataFactory; } });
 const bindings_factory_1 = require("@comunica/bindings-factory");
 const quadsToGraph = (quads) => {
     const graph = new Map();
@@ -77,25 +76,25 @@ class BindingsFactory extends bindings_factory_1.BindingsFactory {
 }
 exports.BindingsFactory = BindingsFactory;
 class QuadFactory {
-    constructor(dataFactory = new rdf_data_factory_1.DataFactory(), bindingsFactory = new BindingsFactory(dataFactory)) {
+    constructor(dataFactory = new rdf_data_factory_1.DataFactory(), termFactory = new TermFactory()) {
         Object.defineProperty(this, "dataFactory", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "bindingsFactory", {
+        Object.defineProperty(this, "termFactory", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
         this.dataFactory = dataFactory;
-        this.bindingsFactory = bindingsFactory;
+        this.termFactory = termFactory;
     }
-    fromJson(jsonBindings) {
-        const bindings = this.bindingsFactory.fromJson(jsonBindings);
-        return this.dataFactory.quad(bindings.get("s"), bindings.get("p"), bindings.get("o"));
+    fromJson(jsonRdf) {
+        const [s, p, o] = jsonRdf;
+        return this.dataFactory.quad(this.dataFactory.namedNode(s), this.dataFactory.namedNode(p), this.termFactory.fromJson(o));
     }
 }
 exports.QuadFactory = QuadFactory;

package/script/library/resource/resource.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Resource = exports.createResource = void 0;
-const rxjs_js_1 = require("../rxjs.js");
 const global_js_1 = require("../global.js");
 const mod_js_1 = require("../schema/mod.js");
 const decoder_js_1 = require("../decoder.js");
@@ -35,12 +34,6 @@ class Resource {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "$trigger", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new rxjs_js_1.BehaviorSubject(null)
-        });
         this.schema = (0, mod_js_1.expandSchema)(schema);
         this.context = (0, global_js_1.resolveContext)(context);
         this.engine = new query_engine_proxy_js_1.QueryEngineProxy(this.context, engine);
@@ -49,45 +42,36 @@ class Resource {
     decode(graph) {
         return (0, decoder_js_1.decode)(graph, this.schema, this.context);
     }
-    count() {
+    async count() {
         const q = this.queryBuilder.countQuery();
         console.log(q);
-        return this.$trigger.pipe((0, rxjs_js_1.switchMap)(() => this.engine.queryBindings(q)), (0, rxjs_js_1.map)((bindings) => {
-            console.warn("BINDINGS", bindings);
-            return parseInt(bindings[0].get("count").value);
-        }));
+        const bindings = await this.engine.queryBindings(q);
+        return parseInt(bindings[0].get("count").value);
     }
     //exists(entity: Identity) {}
-    query(sparqlConstructQuery) {
-        console.log(sparqlConstructQuery);
-        return this.engine.queryGraph(sparqlConstructQuery).pipe((0, rxjs_js_1.map)((graph) => {
-            console.warn("GRAPH", graph);
-            return this.decode(graph);
-        }));
+    async query(sparqlConstructQuery) {
+        const graph = await this.engine.queryGraph(sparqlConstructQuery);
+        return this.decode(graph);
     }
-    find(where, limit) {
+    async find(where, limit) {
         const q = this.queryBuilder.getQuery(where, limit);
         console.log(q);
-        return this.$trigger.pipe((0, rxjs_js_1.switchMap)(() => this.engine.queryGraph(q)), (0, rxjs_js_1.map)((graph) => {
-            console.warn("GRAPH", graph);
-            return this.decode(graph);
-        }));
+        const graph = await this.engine.queryGraph(q);
+        return this.decode(graph);
     }
-    findByIri(iri) {
-        return this.findByIris([iri]).pipe((0, rxjs_js_1.map)((result) => (result.length > 0 ? result[0] : undefined)));
+    async findByIri(iri) {
+        const results = await this.findByIris([iri]);
+        return results.length > 0 ? results[0] : undefined;
     }
-    findByIris(iris) {
+    async findByIris(iris) {
         const q = this.queryBuilder.getByIrisQuery(iris);
         console.log(q);
-        return this.$trigger.pipe((0, rxjs_js_1.switchMap)(() => this.engine.queryGraph(q)), (0, rxjs_js_1.map)((graph) => {
-            return this.decode(graph);
-        }));
+        const graph = await this.engine.queryGraph(q);
+        return this.decode(graph);
     }
     updateQuery(query) {
         console.log(query);
-        const result = this.engine.queryVoid(query).pipe((0, rxjs_js_1.tap)(() => this.$trigger.next(null)), (0, rxjs_js_1.share)());
-        result.subscribe();
-        return result;
+        return this.engine.queryVoid(query);
     }
     insert(...entities) {
         const q = this.queryBuilder.insertQuery(entities);

package/types/library/asynciterator.d.ts

@@ -0,0 +1,29 @@
+import { AsyncIterator } from "asynciterator";
+export { ArrayIterator, type AsyncIterator, MappingIterator, } from "asynciterator";
+declare type TreeNode<T> = {
+    [property: string]: T[] | TreeNode<T>;
+};
+export declare type Tree<T> = T[] | TreeNode<T>;
+declare type Subtree<T> = {
+    type: "node";
+    tree: TreeNode<T>;
+    parent?: Subtree<T>;
+    items: string[];
+    path: string[];
+    index: number;
+} | {
+    type: "leaf";
+    parent?: Subtree<T>;
+    items: T[];
+    path: string[];
+    index: number;
+};
+export declare class TreeIterator<T> extends AsyncIterator<[...string[], T]> {
+    private _tree;
+    private _pointer;
+    constructor(tree: Tree<T>);
+    read(): [...string[], T] | null;
+    protected _buildPointerFromSource(tree: Tree<T>, path?: string[]): Subtree<T>;
+    protected _findNextCommonSegment(): void;
+    protected _findNextLeaf(): void;
+}

package/types/library/engine/query_engine.d.ts

@@ -1,10 +1,15 @@
-import { type Context, type IQueryEngine, type RDF } from "../rdf.js";
+import { type Context, type IQueryEngine, type RDF, RDFJSON } from "../rdf.js";
+declare type QueryResponseFormat = {
+    "application/sparql-results+json": RDFJSON.SparqlResultsJsonFormat;
+    "application/rdf+json": RDFJSON.RdfJsonFormat;
+};
 export declare class QueryEngine implements IQueryEngine {
     protected getSparqlEndpoint(context?: Context): string;
     protected getFetch(context?: Context): typeof fetch;
-    query(query: string, context?: Context): Promise<Response>;
+    query<ResponseType extends keyof QueryResponseFormat, ResponseFormat = QueryResponseFormat[ResponseType]>(query: string, responseType: ResponseType, context?: Context): Promise<ResponseFormat>;
     queryBindings(query: string, context?: Context): Promise<RDF.ResultStream<RDF.Bindings>>;
     queryBoolean(query: string, context?: Context): Promise<boolean>;
     queryQuads(query: string, context?: Context): Promise<RDF.ResultStream<RDF.Quad>>;
     queryVoid(query: string, context?: Context): Promise<void>;
 }
+export {};

package/types/library/engine/query_engine_proxy.d.ts

@@ -3,8 +3,8 @@ export declare class QueryEngineProxy {
     private readonly context;
     private readonly engine;
     constructor(context?: Context, engine?: IQueryEngine);
-    queryBoolean(query: string): import("rxjs/internal/Observable").Observable<boolean>;
-    queryBindings(query: string): import("rxjs/internal/Observable").Observable<RDF.Bindings[]>;
-    queryGraph(query: string): import("rxjs/internal/Observable").Observable<import("../rdf.js").Graph>;
-    queryVoid(query: string): import("rxjs/internal/Observable").Observable<void>;
+    queryBoolean(query: string): Promise<boolean>;
+    queryBindings(query: string): Promise<RDF.Bindings[]>;
+    queryGraph(query: string): Promise<import("../rdf.js").Graph>;
+    queryVoid(query: string): Promise<void>;
 }

package/types/library/namespaces/rdfs.d.ts

@@ -1,5 +1,6 @@
 declare const _default: {
     Literal: "rdfs:Literal";
+    range: "rdfs:range";
     Class: "rdfs:Class";
     Container: "rdfs:Container";
     ContainerMembershipProperty: "rdfs:ContainerMembershipProperty";
@@ -10,7 +11,6 @@ declare const _default: {
     isDefinedBy: "rdfs:isDefinedBy";
     label: "rdfs:label";
     member: "rdfs:member";
-    range: "rdfs:range";
     seeAlso: "rdfs:seeAlso";
     subClassOf: "rdfs:subClassOf";
     subPropertyOf: "rdfs:subPropertyOf";

package/types/library/namespaces/schema.d.ts

@@ -2,7 +2,6 @@ declare const _default: {
     object: "schema:object";
     value: "schema:value";
     query: "schema:query";
-    error: "schema:error";
     map: "schema:map";
     Property: "schema:Property";
     language: "schema:language";
@@ -1769,6 +1768,7 @@ declare const _default: {
     episodeNumber: "schema:episodeNumber";
     episodes: "schema:episodes";
     equal: "schema:equal";
+    error: "schema:error";
     estimatedCost: "schema:estimatedCost";
     estimatedFlightDuration: "schema:estimatedFlightDuration";
     estimatedSalary: "schema:estimatedSalary";

package/types/library/rdf.d.ts

@@ -3,7 +3,8 @@ export type { Bindings, BlankNode, Literal, NamedNode, Quad, Term, Variable };
 import type * as RDF from "rdf-js";
 export type { RDF };
 export { fromRdf, toRdf } from "rdf-literal";
-export { DataFactory } from "rdf-data-factory";
+import { DataFactory } from "rdf-data-factory";
+export { DataFactory };
 import { BindingsFactory as ComunicaBindingsFactory } from "@comunica/bindings-factory";
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
 export declare type LDkitContext = {
@@ -24,6 +25,16 @@ export declare namespace RDFJSON {
         datatype?: string;
     };
     type Bindings = Record<string, Term>;
+    type SparqlResultsJsonFormat = {
+        head: {
+            vars?: string[];
+        };
+        results?: {
+            bindings: Bindings[];
+        };
+        boolean?: boolean;
+    };
+    type RdfJsonFormat = Record<Iri, Record<Iri, Term[]>>;
     interface TermFactory {
         fromJson(jsonTerm: Term): RDF.Term;
     }
@@ -31,7 +42,7 @@ export declare namespace RDFJSON {
         fromJson(jsonBindings: Bindings): RDF.Bindings;
     }
     interface QuadFactory {
-        fromJson(jsonBindings: Bindings): RDF.Quad;
+        fromJson(jsonRdf: [Iri, Iri, Term]): RDF.Quad;
     }
 }
 export declare class TermFactory implements RDFJSON.TermFactory {
@@ -47,7 +58,7 @@ export declare class BindingsFactory extends ComunicaBindingsFactory implements
 }
 export declare class QuadFactory implements RDFJSON.QuadFactory {
     protected readonly dataFactory: RDF.DataFactory;
-    protected readonly bindingsFactory: RDFJSON.BindingsFactory;
-    constructor(dataFactory?: RDF.DataFactory, bindingsFactory?: RDFJSON.BindingsFactory);
-    fromJson(jsonBindings: RDFJSON.Bindings): Quad;
+    protected readonly termFactory: RDFJSON.TermFactory;
+    constructor(dataFactory?: RDF.DataFactory, termFactory?: RDFJSON.TermFactory);
+    fromJson(jsonRdf: [Iri, Iri, RDFJSON.Term]): Quad;
 }

package/types/library/resource/resource.d.ts

@@ -7,18 +7,17 @@ export declare class Resource<S extends SchemaPrototype, I = SchemaInterface<S>>
     private readonly context;
     private readonly engine;
     private readonly queryBuilder;
-    private readonly $trigger;
     constructor(schema: S, context?: Context, engine?: IQueryEngine);
     private decode;
-    count(): import("rxjs/internal/Observable").Observable<number>;
-    query(sparqlConstructQuery: string): import("rxjs/internal/Observable").Observable<I[]>;
-    find(where?: string | RDF.Quad[], limit?: number): import("rxjs/internal/Observable").Observable<I[]>;
-    findByIri(iri: Iri): import("rxjs/internal/Observable").Observable<I | undefined>;
-    findByIris(iris: Iri[]): import("rxjs/internal/Observable").Observable<I[]>;
+    count(): Promise<number>;
+    query(sparqlConstructQuery: string): Promise<I[]>;
+    find(where?: string | RDF.Quad[], limit?: number): Promise<I[]>;
+    findByIri(iri: Iri): Promise<I | undefined>;
+    findByIris(iris: Iri[]): Promise<I[]>;
     private updateQuery;
-    insert(...entities: Entity<I>[]): import("rxjs/internal/Observable").Observable<void>;
-    insertData(...quads: RDF.Quad[]): import("rxjs/internal/Observable").Observable<void>;
-    update(...entities: Entity<I>[]): import("rxjs/internal/Observable").Observable<void>;
-    delete(...identities: SchemaInterfaceIdentity[] | Iri[]): import("rxjs/internal/Observable").Observable<void>;
-    deleteData(...quads: RDF.Quad[]): import("rxjs/internal/Observable").Observable<void>;
+    insert(...entities: Entity<I>[]): Promise<void>;
+    insertData(...quads: RDF.Quad[]): Promise<void>;
+    update(...entities: Entity<I>[]): Promise<void>;
+    delete(...identities: SchemaInterfaceIdentity[] | Iri[]): Promise<void>;
+    deleteData(...quads: RDF.Quad[]): Promise<void>;
 }

package/esm/library/rxjs.js

@@ -1,2 +0,0 @@
-export { BehaviorSubject, firstValueFrom, from, lastValueFrom, of, } from "rxjs";
-export { map, share, switchMap, tap, } from "rxjs/operators";

package/script/library/rxjs.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tap = exports.switchMap = exports.share = exports.map = exports.of = exports.lastValueFrom = exports.from = exports.firstValueFrom = exports.BehaviorSubject = void 0;
-var rxjs_1 = require("rxjs");
-Object.defineProperty(exports, "BehaviorSubject", { enumerable: true, get: function () { return rxjs_1.BehaviorSubject; } });
-Object.defineProperty(exports, "firstValueFrom", { enumerable: true, get: function () { return rxjs_1.firstValueFrom; } });
-Object.defineProperty(exports, "from", { enumerable: true, get: function () { return rxjs_1.from; } });
-Object.defineProperty(exports, "lastValueFrom", { enumerable: true, get: function () { return rxjs_1.lastValueFrom; } });
-Object.defineProperty(exports, "of", { enumerable: true, get: function () { return rxjs_1.of; } });
-var operators_1 = require("rxjs/operators");
-Object.defineProperty(exports, "map", { enumerable: true, get: function () { return operators_1.map; } });
-Object.defineProperty(exports, "share", { enumerable: true, get: function () { return operators_1.share; } });
-Object.defineProperty(exports, "switchMap", { enumerable: true, get: function () { return operators_1.switchMap; } });
-Object.defineProperty(exports, "tap", { enumerable: true, get: function () { return operators_1.tap; } });

package/types/library/rxjs.d.ts

@@ -1,2 +0,0 @@
-export { BehaviorSubject, firstValueFrom, from, lastValueFrom, type Observable, of, } from "rxjs";
-export { map, share, switchMap, tap, } from "rxjs/operators";