ldkit 0.6.0 → 0.6.1

package/esm/library/asynciterator.js

@@ -1 +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,5 +1,5 @@
 import { BindingsFactory, QuadFactory, } from "../rdf.js";
-import { ArrayIterator, MappingIterator } from "../asynciterator.js";
+import { ArrayIterator, MappingIterator, TreeIterator, } from "../asynciterator.js";
 export class QueryEngine {
     getSparqlEndpoint(context) {
         if (!context) {
@@ -30,24 +30,25 @@ 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");
         }
         const bindingsFactory = new BindingsFactory();
@@ -56,25 +57,23 @@ export class QueryEngine {
         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");
         }
         const quadFactory = new QuadFactory();
-        const bindingsIterator = new ArrayIterator(json.results.bindings);
+        const treeIterator = new TreeIterator(json);
         // TODO: review the unknown type cast
-        return new MappingIterator(bindingsIterator, (i) => quadFactory.fromJson(i));
+        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/rdf.js

@@ -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/package.json

@@ -3,12 +3,15 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "0.6.0",
+  "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": {

package/script/library/asynciterator.js

@@ -1,6 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MappingIterator = exports.ArrayIterator = void 0;
-var asynciterator_1 = require("asynciterator");
-Object.defineProperty(exports, "ArrayIterator", { enumerable: true, get: function () { return asynciterator_1.ArrayIterator; } });
-Object.defineProperty(exports, "MappingIterator", { enumerable: true, get: function () { return asynciterator_1.MappingIterator; } });
+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

@@ -33,24 +33,25 @@ 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");
         }
         const bindingsFactory = new rdf_js_1.BindingsFactory();
@@ -59,26 +60,24 @@ class QueryEngine {
         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");
         }
         const quadFactory = new rdf_js_1.QuadFactory();
-        const bindingsIterator = new asynciterator_js_1.ArrayIterator(json.results.bindings);
+        const treeIterator = new asynciterator_js_1.TreeIterator(json);
         // TODO: review the unknown type cast
-        return new asynciterator_js_1.MappingIterator(bindingsIterator, (i) => quadFactory.fromJson(i));
+        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/rdf.js

@@ -76,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/types/library/asynciterator.d.ts

@@ -1 +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/rdf.d.ts

@@ -25,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;
     }
@@ -32,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 {
@@ -48,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;
 }