ldkit 2.1.1 → 2.2.0

package/esm/library/engine/query_engine.js

@@ -41,21 +41,21 @@ export class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    query(body, responseType, context) {
+    query(body, requestType, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
         return fetchFn(endpoint, {
             method: "POST",
             headers: {
                 "accept": responseType,
-                "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+                "content-type": `${requestType}; charset=UTF-8`,
             },
-            body: new URLSearchParams(body),
+            body,
         });
     }
     async queryAndResolve(type, query, context) {
         const responseType = getResponseTypes(type).join(", ");
-        const response = await this.query({ query }, responseType, context);
+        const response = await this.query(query, "application/sparql-query", responseType, context);
         if (!response.ok) {
             await response.body?.cancel();
             throw new Error(`Invalid query response status '${response.status} ${response.statusText}'`);
@@ -100,6 +100,6 @@ export class QueryEngine {
      * @returns Nothing
      */
     async queryVoid(query, context) {
-        await this.query({ update: query }, "application/sparql-results+json", context);
+        await this.query(query, "application/sparql-update", "application/sparql-results+json", context);
     }
 }

package/esm/library/engine/query_engine_proxy.js

@@ -1,4 +1,4 @@
-import { N3, quadsToGraph } from "../rdf.js";
+import { quadsToGraph } from "../rdf.js";
 export class QueryEngineProxy {
     constructor(engine, context) {
         Object.defineProperty(this, "engine", {
@@ -25,9 +25,7 @@ export class QueryEngineProxy {
     }
     async queryGraph(query) {
         const quadStream = await this.engine.queryQuads(query, this.context);
-        const quads = await (quadStream.toArray());
-        const store = new N3.Store(quads);
-        return quadsToGraph(store);
+        return quadsToGraph(quadStream);
     }
     queryVoid(query) {
         return this.engine.queryVoid(query, this.context);

package/esm/library/engine/query_resolvers.js

@@ -1,3 +1,4 @@
+import { readableFromWeb } from "../utils.js";
 import { BindingsFactory, N3, QuadFactory } from "../rdf.js";
 import { ArrayIterator, MappingIterator, TreeIterator, } from "../asynciterator.js";
 class QueryResolver {
@@ -19,7 +20,6 @@ class BindingsJsonResolver extends QueryResolver {
         }
         const bindingsFactory = new BindingsFactory();
         const bindingsIterator = new ArrayIterator(json.results.bindings);
-        // TODO: review the unknown type cast
         return new MappingIterator(bindingsIterator, (i) => bindingsFactory.fromJson(i));
     }
 }
@@ -31,15 +31,35 @@ class QuadsJsonResolver extends QueryResolver {
         }
         const quadFactory = new QuadFactory();
         const treeIterator = new TreeIterator(json);
-        // TODO: review the unknown type cast
         return new MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
     }
 }
+const createN3Stream = async (response, format) => {
+    if (response.body === null) {
+        throw new Error("Response body is null, but it should contain quads from the SPARQL query");
+    }
+    const stream = readableFromWeb(response.body);
+    const parser = new N3.StreamParser({ format });
+    return await parser.import(stream);
+};
+class QuadsNTriplesResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "N-Triples");
+    }
+}
+class QuadsNQuadsResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "N-Quads");
+    }
+}
 class QuadsTurtleResolver extends QueryResolver {
-    async resolve(response) {
-        const text = await response.text();
-        const quads = new N3.Parser({ format: "turtle" }).parse(text);
-        return new ArrayIterator(quads);
+    resolve(response) {
+        return createN3Stream(response, "Turtle");
+    }
+}
+class QuadsTrigResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "TriG");
     }
 }
 const resolvers = {
@@ -51,7 +71,10 @@ const resolvers = {
     },
     "quads": {
         "application/rdf+json": new QuadsJsonResolver(),
+        "application/n-triples": new QuadsNTriplesResolver(),
+        "application/n-quads": new QuadsNQuadsResolver(),
         "text/turtle": new QuadsTurtleResolver(),
+        "application/trig": new QuadsTrigResolver(),
     },
 };
 export const getResponseTypes = (resolverType) => Object.keys(resolvers[resolverType]);

package/esm/library/rdf.js

@@ -1,17 +1,27 @@
 export { fromRdf, toRdf } from "rdf-literal";
+import { quadToStringQuad } from "rdf-string";
 import { DataFactory, DefaultGraph } from "rdf-data-factory";
 export { DataFactory, DefaultGraph };
 export * as N3 from "n3";
-export const quadsToGraph = (quads) => {
-    const graph = new Map();
-    for (const quad of quads) {
-        const s = quad.subject.value;
-        const p = quad.predicate.value;
-        const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
-        const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
-        termArray.push(quad.object);
-    }
-    return graph;
+export const quadsToGraph = (quadStream) => {
+    return new Promise((resolve, reject) => {
+        const graph = new Map();
+        const included = {};
+        quadStream.on("data", (quad) => {
+            const hash = Object.values(quadToStringQuad(quad)).join(" ");
+            if (included[hash]) {
+                return;
+            }
+            included[hash] = true;
+            const s = quad.subject.value;
+            const p = quad.predicate.value;
+            const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
+            const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
+            termArray.push(quad.object);
+        });
+        quadStream.on("end", () => resolve(graph));
+        quadStream.on("error", reject);
+    });
 };
 export class TermFactory {
     constructor(dataFactory = new DataFactory()) {

package/esm/library/utils.js

@@ -0,0 +1 @@
+export { readableFromWeb } from "readable-from-web";

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -70,6 +70,8 @@
     "asynciterator": "^3.9.0",
     "n3": "^1.23.1",
     "rdf-data-factory": "^2.0.2",
-    "rdf-literal": "^2.0.0"
+    "rdf-literal": "^2.0.0",
+    "rdf-string": "^2.0.0",
+    "readable-from-web": "^0.0.4"
   }
 }

package/script/library/engine/query_engine.js

@@ -44,21 +44,21 @@ class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    query(body, responseType, context) {
+    query(body, requestType, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
         return fetchFn(endpoint, {
             method: "POST",
             headers: {
                 "accept": responseType,
-                "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+                "content-type": `${requestType}; charset=UTF-8`,
             },
-            body: new URLSearchParams(body),
+            body,
         });
     }
     async queryAndResolve(type, query, context) {
         const responseType = (0, query_resolvers_js_1.getResponseTypes)(type).join(", ");
-        const response = await this.query({ query }, responseType, context);
+        const response = await this.query(query, "application/sparql-query", responseType, context);
         if (!response.ok) {
             await response.body?.cancel();
             throw new Error(`Invalid query response status '${response.status} ${response.statusText}'`);
@@ -103,7 +103,7 @@ class QueryEngine {
      * @returns Nothing
      */
     async queryVoid(query, context) {
-        await this.query({ update: query }, "application/sparql-results+json", context);
+        await this.query(query, "application/sparql-update", "application/sparql-results+json", context);
     }
 }
 exports.QueryEngine = QueryEngine;

package/script/library/engine/query_engine_proxy.js

@@ -28,9 +28,7 @@ class QueryEngineProxy {
     }
     async queryGraph(query) {
         const quadStream = await this.engine.queryQuads(query, this.context);
-        const quads = await (quadStream.toArray());
-        const store = new rdf_js_1.N3.Store(quads);
-        return (0, rdf_js_1.quadsToGraph)(store);
+        return (0, rdf_js_1.quadsToGraph)(quadStream);
     }
     queryVoid(query) {
         return this.engine.queryVoid(query, this.context);

package/script/library/engine/query_resolvers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolve = exports.getResponseTypes = void 0;
+const utils_js_1 = require("../utils.js");
 const rdf_js_1 = require("../rdf.js");
 const asynciterator_js_1 = require("../asynciterator.js");
 class QueryResolver {
@@ -22,7 +23,6 @@ class BindingsJsonResolver extends QueryResolver {
         }
         const bindingsFactory = new rdf_js_1.BindingsFactory();
         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));
     }
 }
@@ -34,15 +34,35 @@ class QuadsJsonResolver extends QueryResolver {
         }
         const quadFactory = new rdf_js_1.QuadFactory();
         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));
     }
 }
+const createN3Stream = async (response, format) => {
+    if (response.body === null) {
+        throw new Error("Response body is null, but it should contain quads from the SPARQL query");
+    }
+    const stream = (0, utils_js_1.readableFromWeb)(response.body);
+    const parser = new rdf_js_1.N3.StreamParser({ format });
+    return await parser.import(stream);
+};
+class QuadsNTriplesResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "N-Triples");
+    }
+}
+class QuadsNQuadsResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "N-Quads");
+    }
+}
 class QuadsTurtleResolver extends QueryResolver {
-    async resolve(response) {
-        const text = await response.text();
-        const quads = new rdf_js_1.N3.Parser({ format: "turtle" }).parse(text);
-        return new asynciterator_js_1.ArrayIterator(quads);
+    resolve(response) {
+        return createN3Stream(response, "Turtle");
+    }
+}
+class QuadsTrigResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "TriG");
     }
 }
 const resolvers = {
@@ -54,7 +74,10 @@ const resolvers = {
     },
     "quads": {
         "application/rdf+json": new QuadsJsonResolver(),
+        "application/n-triples": new QuadsNTriplesResolver(),
+        "application/n-quads": new QuadsNQuadsResolver(),
         "text/turtle": new QuadsTurtleResolver(),
+        "application/trig": new QuadsTrigResolver(),
     },
 };
 const getResponseTypes = (resolverType) => Object.keys(resolvers[resolverType]);

package/script/library/rdf.js

@@ -27,20 +27,30 @@ exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = expor
 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_string_1 = require("rdf-string");
 const rdf_data_factory_1 = require("rdf-data-factory");
 Object.defineProperty(exports, "DataFactory", { enumerable: true, get: function () { return rdf_data_factory_1.DataFactory; } });
 Object.defineProperty(exports, "DefaultGraph", { enumerable: true, get: function () { return rdf_data_factory_1.DefaultGraph; } });
 exports.N3 = __importStar(require("n3"));
-const quadsToGraph = (quads) => {
-    const graph = new Map();
-    for (const quad of quads) {
-        const s = quad.subject.value;
-        const p = quad.predicate.value;
-        const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
-        const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
-        termArray.push(quad.object);
-    }
-    return graph;
+const quadsToGraph = (quadStream) => {
+    return new Promise((resolve, reject) => {
+        const graph = new Map();
+        const included = {};
+        quadStream.on("data", (quad) => {
+            const hash = Object.values((0, rdf_string_1.quadToStringQuad)(quad)).join(" ");
+            if (included[hash]) {
+                return;
+            }
+            included[hash] = true;
+            const s = quad.subject.value;
+            const p = quad.predicate.value;
+            const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
+            const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
+            termArray.push(quad.object);
+        });
+        quadStream.on("end", () => resolve(graph));
+        quadStream.on("error", reject);
+    });
 };
 exports.quadsToGraph = quadsToGraph;
 class TermFactory {

package/script/library/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readableFromWeb = void 0;
+var readable_from_web_1 = require("readable-from-web");
+Object.defineProperty(exports, "readableFromWeb", { enumerable: true, get: function () { return readable_from_web_1.readableFromWeb; } });

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

@@ -16,11 +16,7 @@ import { type ResolverType } from "./query_resolvers.js";
 export declare class QueryEngine implements IQueryEngine {
     protected getSparqlEndpoint(context?: QueryContext): string;
     protected getFetch(context?: QueryContext): typeof fetch;
-    protected query(body: {
-        query: string;
-    } | {
-        update: string;
-    }, responseType: string, context?: QueryContext): Promise<Response>;
+    protected query(body: string, requestType: "application/sparql-query" | "application/sparql-update", responseType: string, context?: QueryContext): Promise<Response>;
     protected queryAndResolve<T extends ResolverType>(type: T, query: string, context?: QueryContext): Promise<{
         boolean: boolean;
         bindings: RDF.ResultStream<RDF.Bindings>;

package/types/library/options.d.ts

@@ -66,5 +66,6 @@ export declare function resolveOptions(options?: Options): {
     extensionFunctions?: Record<string, (args: import("@rdfjs/types").Term[]) => Promise<import("@rdfjs/types").Term>> | undefined;
     explain?: import("@comunica/types").QueryExplainMode | undefined;
     recoverBrokenLinks?: boolean | undefined;
+    distinctConstruct?: boolean | undefined;
 };
 export declare function resolveQueryContext(options: Options): QueryContext;

package/types/library/rdf.d.ts

@@ -7,7 +7,7 @@ export * as N3 from "n3";
 export type IRI = string;
 export type Node = Map<IRI, RDF.Term[]>;
 export type Graph = Map<IRI, Node>;
-export declare const quadsToGraph: (quads: Iterable<RDF.Quad>) => Graph;
+export declare const quadsToGraph: (quadStream: RDF.ResultStream<RDF.Quad>) => Promise<Graph>;
 export declare namespace RDFJSON {
     type Term = {
         type: "uri" | "literal" | "bnode";

package/types/library/utils.d.ts

@@ -0,0 +1 @@
+export { readableFromWeb } from "readable-from-web";