ldkit 0.4.2 → 0.5.0

package/esm/library/decoder.js

@@ -48,9 +48,14 @@ class Decoder {
     decode() {
         const output = [];
         for (const [iri, properties] of this.graph) {
+            console.warn("IRI", iri);
             if (properties.has(rdf.type)) {
                 const types = properties.get(rdf.type);
                 for (const type of types) {
+                    console.warn("TYPE", type.value);
+                    if (type.value === ldkit.Resource) {
+                        console.warn("FOUND", type);
+                    }
                     if (type.termType === "NamedNode" && type.value === ldkit.Resource) {
                         output.push(this.decodeNode(iri, this.schema));
                     }

package/esm/library/encoder.js

@@ -1,4 +1,4 @@
-import { DataFactory, literal, toRdf, } from "./rdf.js";
+import { DataFactory, toRdf } from "./rdf.js";
 import { rdf, xsd } from "./namespaces/mod.js";
 export const encode = (node, schema, context, variableInitCounter = 0) => {
     return Encoder.encode(node, schema, context, variableInitCounter);
@@ -87,7 +87,7 @@ class Encoder {
                     ? value[language]
                     : [value[language]];
                 languageValue.forEach((singleValue) => {
-                    this.push(nodeId, propertyId, literal(singleValue, language.length > 0 ? language : undefined));
+                    this.push(nodeId, propertyId, this.df.literal(singleValue, language.length > 0 ? language : undefined));
                 });
             });
             return;
@@ -103,7 +103,7 @@ class Encoder {
             const propertyType = property["@type"] ? property["@type"] : xsd.string;
             if (typeof val === "string" && this.context.language) {
                 if (propertyType === xsd.string || propertyType === rdf.langString) {
-                    this.push(nodeId, propertyId, literal(val, this.context.language));
+                    this.push(nodeId, propertyId, this.df.literal(val, this.context.language));
                     return;
                 }
             }

package/esm/library/engine/mod.js

@@ -0,0 +1,2 @@
+export { QueryEngine } from "./query_engine.js";
+export { QueryEngineProxy } from "./query_engine_proxy.js";

package/esm/library/engine/query_engine.js

@@ -0,0 +1,75 @@
+import { BindingsFactory, QuadFactory, } from "../rdf.js";
+export class QueryEngine {
+    getSparqlEndpoint(context) {
+        if (!context) {
+            throw new Error("No context supplied to QueryEngine. You need to create a default context or pass one to a resource.");
+        }
+        if (!Array.isArray(context.sources) || context.sources.length < 1) {
+            throw new Error("Invalid context `sources` attribute defined. You need to provide a URL to a SPARQL endpoint to query.");
+        }
+        if (context.sources.length > 1) {
+            throw new Error("This query engine supports only one data source, multiple defined in `sources` property in context.");
+        }
+        const source = context.sources[0];
+        if (typeof source === "string") {
+            return source;
+        }
+        if ("value" in source && typeof source.value === "string") {
+            if ("type" in source) {
+                if (source.type === "sparql") {
+                    return source.value;
+                }
+            }
+            else {
+                return source.value;
+            }
+        }
+        throw new Error("Invalid SPARQL source defined - please provide URL to a SPARQL endpoint to query.");
+    }
+    getFetch(context) {
+        return context && context.fetch ? context.fetch : fetch;
+    }
+    async query(query, context) {
+        const endpoint = this.getSparqlEndpoint(context);
+        const fetchFn = this.getFetch(context);
+        return await fetchFn(endpoint, {
+            method: "POST",
+            body: query,
+            headers: {
+                "content-type": "application/sparql-query",
+                "accept": "application/sparql-results+json",
+            },
+        });
+    }
+    async queryBindings(query, context) {
+        const result = await this.query(query, context);
+        const json = await result.json();
+        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));
+    }
+    async queryBoolean(query, context) {
+        const result = await this.query(query, context);
+        const json = await result.json();
+        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)) {
+            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));
+    }
+    async queryVoid(query, context) {
+        await this.query(query, context);
+    }
+}

package/esm/library/engine/query_engine_proxy.js

@@ -0,0 +1,35 @@
+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", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "engine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = resolveContext(context);
+        this.engine = resolveEngine(engine);
+    }
+    queryBoolean(query) {
+        return from(this.engine.queryBoolean(query, this.context));
+    }
+    queryBindings(query) {
+        return from(this.engine.queryBindings(query, this.context)).pipe(switchMap((stream) => of(Array.from(stream))));
+    }
+    queryGraph(query) {
+        return from(this.engine.queryQuads(query, this.context)).pipe(switchMap((stream) => of(Array.from(stream))), map((quads) => {
+            return quadsToGraph(quads);
+        }));
+    }
+    queryVoid(query) {
+        return from(this.engine.queryVoid(query, this.context));
+    }
+}

package/esm/library/global.js

@@ -0,0 +1,25 @@
+import { QueryEngine } from "./engine/mod.js";
+let defaultContext = undefined;
+let defaultEngine = undefined;
+export const setDefaultContext = (context) => {
+    defaultContext = context;
+};
+export const resolveContext = (context) => {
+    if (!context && !defaultContext) {
+        throw new Error("No context found. Please create a default context or pass one to createResource function");
+    }
+    return context || defaultContext;
+};
+export const setDefaultEngine = (engine) => {
+    defaultEngine = engine;
+};
+export const resolveEngine = (engine) => {
+    if (!engine && !defaultEngine) {
+        setDefaultEngine(new QueryEngine());
+        // TODO: consider the consequences here, maybe log a warning?
+        /*throw new Error(
+          "No engine found. Please create a default engine or pass one to createResource function",
+        );*/
+    }
+    return engine || defaultEngine;
+};

package/esm/library/namespaces/mod.js

@@ -1,4 +1,5 @@
 export { default as rdf } from "./rdf.js";
+export { default as rdfs } from "./rdfs.js";
 export { default as dcterms } from "./dcterms.js";
 export { default as ldkit } from "./ldkit.js";
 export { default as schema } from "./schema.js";

package/esm/library/namespaces/rdfs.js

@@ -0,0 +1,22 @@
+import { createNamespace } from "./namespace.js";
+export default createNamespace({
+    iri: "http://www.w3.org/2000/01/rdf-schema#",
+    prefix: "rdfs:",
+    terms: [
+        "Class",
+        "Container",
+        "ContainerMembershipProperty",
+        "Datatype",
+        "Literal",
+        "Resource",
+        "comment",
+        "domain",
+        "isDefinedBy",
+        "label",
+        "member",
+        "range",
+        "seeAlso",
+        "subClassOf",
+        "subPropertyOf",
+    ],
+});

package/esm/library/rdf.js

@@ -1,11 +1,7 @@
 export { fromRdf, toRdf } from "rdf-literal";
-import * as DataFactory from "rdf-data-factory";
+import { DataFactory } from "rdf-data-factory";
 export { DataFactory } from "rdf-data-factory";
-export const namedNode = (value) => new DataFactory.NamedNode(value);
-export const blankNode = (value) => new DataFactory.BlankNode(value);
-export const literal = (value, languageOrDatatype) => new DataFactory.Literal(value, languageOrDatatype);
-export const quad = (subject, predicate, object, graph) => new DataFactory.Quad(subject, predicate, object, graph || DataFactory.DefaultGraph.INSTANCE);
-export const variable = (value) => new DataFactory.Variable(value);
+import { BindingsFactory as ComunicaBindingsFactory } from "@comunica/bindings-factory";
 export const quadsToGraph = (quads) => {
     const graph = new Map();
     for (const quad of quads) {
@@ -17,3 +13,79 @@ export const quadsToGraph = (quads) => {
     }
     return graph;
 };
+export class TermFactory {
+    constructor(dataFactory = new DataFactory()) {
+        Object.defineProperty(this, "dataFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.dataFactory = dataFactory;
+    }
+    fromJson(jsonTerm) {
+        if (jsonTerm.type === "uri") {
+            return this.dataFactory.namedNode(jsonTerm.value);
+        }
+        if (jsonTerm.type === "bnode") {
+            return this.dataFactory.blankNode(jsonTerm.value);
+        }
+        if ("xml:lang" in jsonTerm) {
+            return this.dataFactory.literal(jsonTerm.value, jsonTerm["xml:lang"]);
+        }
+        if ("datatype" in jsonTerm) {
+            return this.dataFactory.literal(jsonTerm.value, this.dataFactory.namedNode(jsonTerm.datatype));
+        }
+        return this.dataFactory.literal(jsonTerm.value);
+    }
+}
+export class BindingsFactory extends ComunicaBindingsFactory {
+    constructor(dataFactory = new DataFactory(), termFactory = new TermFactory()) {
+        super(dataFactory);
+        Object.defineProperty(this, "localDataFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "termFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.localDataFactory = dataFactory;
+        this.termFactory = termFactory;
+    }
+    fromJson(jsonBindings) {
+        const bindingsEntries = Object.entries(jsonBindings).map(([varName, jsonTerm]) => {
+            return [
+                this.localDataFactory.variable(varName),
+                this.termFactory.fromJson(jsonTerm),
+            ];
+        });
+        return this.bindings(bindingsEntries);
+    }
+}
+export class QuadFactory {
+    constructor(dataFactory = new DataFactory(), bindingsFactory = new BindingsFactory(dataFactory)) {
+        Object.defineProperty(this, "dataFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bindingsFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.dataFactory = dataFactory;
+        this.bindingsFactory = bindingsFactory;
+    }
+    fromJson(jsonBindings) {
+        const bindings = this.bindingsFactory.fromJson(jsonBindings);
+        return this.dataFactory.quad(bindings.get("s"), bindings.get("p"), bindings.get("o"));
+    }
+}

package/esm/library/resource/query_builder.js

@@ -1,7 +1,7 @@
 import { getSchemaProperties } from "../schema/mod.js";
-import { $, CONSTRUCT, SELECT, INSERT, DELETE } from "../sparql.js";
-import { variable, namedNode, quad } from "../rdf.js";
-import { rdf, ldkit } from "../namespaces/mod.js";
+import { $, CONSTRUCT, DELETE, INSERT, SELECT } from "../sparql.js";
+import { DataFactory } from "../rdf.js";
+import { ldkit, rdf } from "../namespaces/mod.js";
 import { encode } from "../encoder.js";
 import { QueryHelper } from "./query_helper.js";
 export class QueryBuilder {
@@ -24,28 +24,35 @@ export class QueryBuilder {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "df", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "deleteQuery", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: (iris) => {
-                return DELETE `
-      ?s ?p ?o
-    `.WHERE `
-      ?s ?p ?o .
-      VALUES ?s { ${iris.map(namedNode)} }
+                return DELETE `
+      ?s ?p ?o
+    `.WHERE `
+      ?s ?p ?o .
+      VALUES ?s { ${iris.map(this.df.namedNode)} }
     `.build();
             }
         });
         this.schema = schema;
         this.schemaProperties = getSchemaProperties(this.schema);
         this.context = context;
+        this.df = new DataFactory();
     }
     getResourceSignature() {
-        return quad(variable("iri"), namedNode(rdf.type), namedNode(ldkit.Resource));
+        return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf.type), this.df.namedNode(ldkit.Resource));
     }
     getTypesSignature() {
-        return quad(variable("iri"), namedNode(rdf.type), variable("iri_type"));
+        return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf.type), this.df.variable("iri_type"));
     }
     entitiesToQuads(entities) {
         const quadArrays = entities.map((entity) => encode(entity, this.schema, this.context));
@@ -59,7 +66,7 @@ export class QueryBuilder {
             const properties = getSchemaProperties(s);
             if (varPrefix !== "iri" || !omitRootTypes) {
                 rdfType.forEach((type) => {
-                    conditions.push(quad(variable(varPrefix), namedNode(rdf.type), namedNode(type)));
+                    conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(rdf.type), this.df.namedNode(type)));
                 });
             }
             Object.keys(properties).forEach((prop, index) => {
@@ -71,7 +78,7 @@ export class QueryBuilder {
                 if (wrapOptional && isOptional) {
                     conditions.push($ `\nOPTIONAL {`);
                 }
-                conditions.push(quad(variable(varPrefix), namedNode(property["@id"]), variable(`${varPrefix}_${index}`)));
+                conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(property["@id"]), this.df.variable(`${varPrefix}_${index}`)));
                 if (typeof property["@context"] === "object") {
                     populateConditionsRecursive(property["@context"], `${varPrefix}_${index}`);
                 }
@@ -88,36 +95,36 @@ export class QueryBuilder {
         return SELECT `(count(?iri) as ?count)`.WHERE `${quads}`.build();
     }
     getQuery(where, limit = 1000) {
-        const selectSubQuery = SELECT `
-      ${variable("iri")}
-    `.WHERE `
-      ${this.getShape(false, true)}
-      ${where}
+        const selectSubQuery = SELECT `
+      ${this.df.variable("iri")}
+    `.WHERE `
+      ${this.getShape(false, true)}
+      ${where}
     `.LIMIT(limit);
-        const query = CONSTRUCT `
-      ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
-    `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
-      {
-        ${selectSubQuery}
-      }
+        const query = CONSTRUCT `
+      ${this.getResourceSignature()}
+      ${this.getTypesSignature()}
+      ${this.getShape(true, false, true)}
+    `.WHERE `
+      ${this.getTypesSignature()}
+      ${this.getShape(true, true, true)}
+      {
+        ${selectSubQuery}
+      }
     `.build();
         return query;
     }
     getByIrisQuery(iris) {
-        const query = CONSTRUCT `
-      ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
-    `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
-      VALUES ?iri {
-        ${iris.map(namedNode)}
-      }
+        const query = CONSTRUCT `
+      ${this.getResourceSignature()}
+      ${this.getTypesSignature()}
+      ${this.getShape(true, false, true)}
+    `.WHERE `
+      ${this.getTypesSignature()}
+      ${this.getShape(true, true, true)}
+      VALUES ?iri {
+        ${iris.map(this.df.namedNode)}
+      }
     `.build();
         return query;
     }

package/esm/library/resource/resource.js

@@ -1,12 +1,12 @@
-import { map, switchMap, tap, share, BehaviorSubject } from "../rxjs.js";
-import { bindingsQuery, quadsQuery, updateQuery } from "../engine.js";
-import { resolveContext } from "../context.js";
+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";
 import { QueryBuilder } from "./query_builder.js";
-export const createResource = (spec, context) => new Resource(spec, context);
+import { QueryEngineProxy } from "../engine/query_engine_proxy.js";
+export const createResource = (spec, context, engine) => new Resource(spec, context, engine);
 export class Resource {
-    constructor(schema, context) {
+    constructor(schema, context, engine) {
         Object.defineProperty(this, "schema", {
             enumerable: true,
             configurable: true,
@@ -19,6 +19,12 @@ export class Resource {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "engine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "queryBuilder", {
             enumerable: true,
             configurable: true,
@@ -33,6 +39,7 @@ export class Resource {
         });
         this.schema = expandSchema(schema);
         this.context = resolveContext(context);
+        this.engine = new QueryEngineProxy(this.context, engine);
         this.queryBuilder = new QueryBuilder(this.schema, this.context);
     }
     decode(graph) {
@@ -41,7 +48,7 @@ export class Resource {
     count() {
         const q = this.queryBuilder.countQuery();
         console.log(q);
-        return this.$trigger.pipe(switchMap(() => bindingsQuery(q, this.context)), map((bindings) => {
+        return this.$trigger.pipe(switchMap(() => this.engine.queryBindings(q)), map((bindings) => {
             console.warn("BINDINGS", bindings);
             return parseInt(bindings[0].get("count").value);
         }));
@@ -49,14 +56,16 @@ export class Resource {
     //exists(entity: Identity) {}
     query(sparqlConstructQuery) {
         console.log(sparqlConstructQuery);
-        return quadsQuery(sparqlConstructQuery, this.context).pipe(map((graph) => {
+        return this.engine.queryGraph(sparqlConstructQuery).pipe(map((graph) => {
+            console.warn("GRAPH", graph);
             return this.decode(graph);
         }));
     }
     find(where, limit) {
         const q = this.queryBuilder.getQuery(where, limit);
         console.log(q);
-        return this.$trigger.pipe(switchMap(() => quadsQuery(q, this.context)), map((graph) => {
+        return this.$trigger.pipe(switchMap(() => this.engine.queryGraph(q)), map((graph) => {
+            console.warn("GRAPH", graph);
             return this.decode(graph);
         }));
     }
@@ -66,13 +75,13 @@ export class Resource {
     findByIris(iris) {
         const q = this.queryBuilder.getByIrisQuery(iris);
         console.log(q);
-        return this.$trigger.pipe(switchMap(() => quadsQuery(q, this.context)), map((graph) => {
+        return this.$trigger.pipe(switchMap(() => this.engine.queryGraph(q)), map((graph) => {
             return this.decode(graph);
         }));
     }
     updateQuery(query) {
         console.log(query);
-        const result = updateQuery(query, this.context).pipe(tap(() => this.$trigger.next(null)), share());
+        const result = this.engine.queryVoid(query).pipe(tap(() => this.$trigger.next(null)), share());
         result.subscribe();
         return result;
     }

package/esm/library/rxjs.js

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

package/esm/mod.js

@@ -1,3 +1,3 @@
+export { setDefaultContext, setDefaultEngine } from "./library/global.js";
 export { createResource } from "./library/resource/mod.js";
 export { createNamespace } from "./library/namespaces/namespace.js";
-export { createContext, createDefaultContext, } from "./library/context.js";

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -41,7 +41,7 @@
     }
   },
   "dependencies": {
-    "@comunica/query-sparql": "2.4.3",
+    "@comunica/bindings-factory": "2.2.0",
     "@comunica/types": "2.4.0",
     "@tpluscode/rdf-string": "0.2.26",
     "@tpluscode/sparql-builder": "0.3.23",

package/script/library/decoder.js

@@ -51,9 +51,14 @@ class Decoder {
     decode() {
         const output = [];
         for (const [iri, properties] of this.graph) {
+            console.warn("IRI", iri);
             if (properties.has(mod_js_1.rdf.type)) {
                 const types = properties.get(mod_js_1.rdf.type);
                 for (const type of types) {
+                    console.warn("TYPE", type.value);
+                    if (type.value === mod_js_1.ldkit.Resource) {
+                        console.warn("FOUND", type);
+                    }
                     if (type.termType === "NamedNode" && type.value === mod_js_1.ldkit.Resource) {
                         output.push(this.decodeNode(iri, this.schema));
                     }

package/script/library/encoder.js

@@ -91,7 +91,7 @@ class Encoder {
                     ? value[language]
                     : [value[language]];
                 languageValue.forEach((singleValue) => {
-                    this.push(nodeId, propertyId, (0, rdf_js_1.literal)(singleValue, language.length > 0 ? language : undefined));
+                    this.push(nodeId, propertyId, this.df.literal(singleValue, language.length > 0 ? language : undefined));
                 });
             });
             return;
@@ -107,7 +107,7 @@ class Encoder {
             const propertyType = property["@type"] ? property["@type"] : mod_js_1.xsd.string;
             if (typeof val === "string" && this.context.language) {
                 if (propertyType === mod_js_1.xsd.string || propertyType === mod_js_1.rdf.langString) {
-                    this.push(nodeId, propertyId, (0, rdf_js_1.literal)(val, this.context.language));
+                    this.push(nodeId, propertyId, this.df.literal(val, this.context.language));
                     return;
                 }
             }

package/script/library/engine/mod.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryEngineProxy = exports.QueryEngine = void 0;
+var query_engine_js_1 = require("./query_engine.js");
+Object.defineProperty(exports, "QueryEngine", { enumerable: true, get: function () { return query_engine_js_1.QueryEngine; } });
+var query_engine_proxy_js_1 = require("./query_engine_proxy.js");
+Object.defineProperty(exports, "QueryEngineProxy", { enumerable: true, get: function () { return query_engine_proxy_js_1.QueryEngineProxy; } });