ldkit 2.0.0 → 2.1.1

package/README.md

@@ -110,6 +110,16 @@ Persons.delete("http://dbpedia.org/resource/Alan_Turing");
 
 More complex examples can be found in [documentation](https://ldkit.io/docs).
 
+## Specification Compliance
+
+LDkit complies with the following specifications:
+
+- [RDF/JS: Data model specification](https://rdf.js.org/data-model-spec/)
+- [RDF/JS: Query specification](https://rdf.js.org/query-spec/)
+- [SPARQL 1.1 Query Language](https://www.w3.org/TR/sparql11-query/)
+- [SPARQL 1.1 Update](https://www.w3.org/TR/2013/REC-sparql11-update-20130321/)
+- [SPARQL 1.1 Protocol](https://www.w3.org/TR/2013/REC-sparql11-protocol-20130321/)
+
 ## License
 
 [MIT License](./LICENSE.md)

package/esm/library/engine/query_engine.js

@@ -41,7 +41,7 @@ export class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    query(query, responseType, context) {
+    query(body, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
         return fetchFn(endpoint, {
@@ -50,14 +50,12 @@ export class QueryEngine {
                 "accept": responseType,
                 "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
             },
-            body: new URLSearchParams({
-                query,
-            }),
+            body: new URLSearchParams(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 }, responseType, context);
         if (!response.ok) {
             await response.body?.cancel();
             throw new Error(`Invalid query response status '${response.status} ${response.statusText}'`);
@@ -102,6 +100,6 @@ export class QueryEngine {
      * @returns Nothing
      */
     async queryVoid(query, context) {
-        await this.query(query, "application/sparql-results+json", context);
+        await this.query({ update: query }, "application/sparql-results+json", context);
     }
 }

package/esm/library/lens/lens.js

@@ -125,8 +125,8 @@ export class Lens {
      *
      * @returns total number of entities corresponding to the data schema
      */
-    async count() {
-        const q = this.queryBuilder.countQuery();
+    async count(max) {
+        const q = this.queryBuilder.countQuery(max);
         this.log(q);
         const bindings = await this.engine.queryBindings(q);
         return parseInt(bindings[0].get("count").value);

package/esm/library/lens/query_builder.js

@@ -110,9 +110,12 @@ export class QueryBuilder {
         populateConditionsRecursive(this.schema, mainVar, searchSchema);
         return conditions;
     }
-    countQuery() {
+    countQuery(max) {
         const quads = this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes);
-        return SELECT `(count(?iri) as ?count)`.WHERE `${quads}`.build();
+        const innerQuery = max === undefined
+            ? quads
+            : SELECT `?iri`.WHERE `${quads}`.LIMIT(max);
+        return SELECT `(count(?iri) as ?count)`.WHERE `${innerQuery}`.build();
     }
     getQuery(where, limit, offset) {
         const selectSubQuery = SELECT.DISTINCT `

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -64,12 +64,12 @@
     }
   },
   "dependencies": {
-    "@comunica/types": "2.6.8",
-    "@rdfjs/types": "*",
-    "@types/n3": "*",
-    "asynciterator": "3.8.0",
-    "n3": "1.17.2",
-    "rdf-data-factory": "1.1.1",
-    "rdf-literal": "1.3.1"
+    "@comunica/types": "^4.1.0",
+    "@rdfjs/types": "^2.0.0",
+    "@types/n3": "^1.21.1",
+    "asynciterator": "^3.9.0",
+    "n3": "^1.23.1",
+    "rdf-data-factory": "^2.0.2",
+    "rdf-literal": "^2.0.0"
   }
 }

package/script/library/engine/query_engine.js

@@ -44,7 +44,7 @@ class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    query(query, responseType, context) {
+    query(body, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
         return fetchFn(endpoint, {
@@ -53,14 +53,12 @@ class QueryEngine {
                 "accept": responseType,
                 "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
             },
-            body: new URLSearchParams({
-                query,
-            }),
+            body: new URLSearchParams(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 }, responseType, context);
         if (!response.ok) {
             await response.body?.cancel();
             throw new Error(`Invalid query response status '${response.status} ${response.statusText}'`);
@@ -105,7 +103,7 @@ class QueryEngine {
      * @returns Nothing
      */
     async queryVoid(query, context) {
-        await this.query(query, "application/sparql-results+json", context);
+        await this.query({ update: query }, "application/sparql-results+json", context);
     }
 }
 exports.QueryEngine = QueryEngine;

package/script/library/lens/lens.js

@@ -129,8 +129,8 @@ class Lens {
      *
      * @returns total number of entities corresponding to the data schema
      */
-    async count() {
-        const q = this.queryBuilder.countQuery();
+    async count(max) {
+        const q = this.queryBuilder.countQuery(max);
         this.log(q);
         const bindings = await this.engine.queryBindings(q);
         return parseInt(bindings[0].get("count").value);

package/script/library/lens/query_builder.js

@@ -113,9 +113,12 @@ class QueryBuilder {
         populateConditionsRecursive(this.schema, mainVar, searchSchema);
         return conditions;
     }
-    countQuery() {
+    countQuery(max) {
         const quads = this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes);
-        return (0, mod_js_2.SELECT) `(count(?iri) as ?count)`.WHERE `${quads}`.build();
+        const innerQuery = max === undefined
+            ? quads
+            : (0, mod_js_2.SELECT) `?iri`.WHERE `${quads}`.LIMIT(max);
+        return (0, mod_js_2.SELECT) `(count(?iri) as ?count)`.WHERE `${innerQuery}`.build();
     }
     getQuery(where, limit, offset) {
         const selectSubQuery = mod_js_2.SELECT.DISTINCT `

package/types/library/encoder.d.ts

@@ -3,5 +3,5 @@ import { DataFactory, type RDF } from "./rdf.js";
 import type { ExpandedSchema } from "./schema/mod.js";
 type DecodedNode = Record<string, unknown>;
 export declare const encode: (node: DecodedNode, schema: ExpandedSchema, options: Options, includeType?: boolean, variableInitCounter?: number) => RDF.Quad[];
-export declare const encodeValue: (value: unknown, datatype: string, df: DataFactory) => any;
+export declare const encodeValue: (value: unknown, datatype: string, df: DataFactory) => RDF.Literal | import("rdf-data-factory").NamedNode<string>;
 export {};

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

@@ -16,7 +16,11 @@ 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(query: string, responseType: string, context?: QueryContext): Promise<Response>;
+    protected query(body: {
+        query: string;
+    } | {
+        update: string;
+    }, 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/engine/types.d.ts

@@ -1,4 +1,4 @@
-import type { IDataSource, IQueryContextCommon } from "@comunica/types";
+import type { IQueryContextCommon, QuerySourceUnidentified } from "@comunica/types";
 import { RDF } from "../rdf.js";
 /**
  * A set of context entries that can be passed to a query engine,
@@ -16,7 +16,7 @@ import { RDF } from "../rdf.js";
  * await engine.queryBoolean("ASK { ?s ?p ?o }", context);
  * ```
  */
-export type QueryContext = RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
+export type QueryContext = RDF.QueryStringContext & RDF.QuerySourceContext<QuerySourceUnidentified> & IQueryContextCommon;
 /**
  * Interface of a query engine compatible with LDkit
  */

package/types/library/lens/lens.d.ts

@@ -92,7 +92,7 @@ export declare class Lens<T extends Schema> {
      *
      * @returns total number of entities corresponding to the data schema
      */
-    count(): Promise<number>;
+    count(max?: number): Promise<number>;
     /**
      * Find entities with a custom SPARQL query.
      *

package/types/library/lens/query_builder.d.ts

@@ -10,7 +10,7 @@ export declare class QueryBuilder {
     private getResourceSignature;
     private entitiesToQuads;
     private getShape;
-    countQuery(): string;
+    countQuery(max?: number): string;
     getQuery(where: string | RDF.Quad[] | undefined, limit: number, offset: number): string;
     getSearchQuery(where: SearchSchema, limit: number, offset: number): string;
     getByIrisQuery(iris: IRI[], where?: SearchSchema): string;

package/types/library/options.d.ts

@@ -45,8 +45,7 @@ export declare function resolveOptions(options?: Options): {
     queryFormat?: import("@rdfjs/types").QueryFormat | undefined;
     baseIRI?: string | undefined;
     queryTimestamp?: Date | undefined;
-    sources?: [import("@comunica/types").IDataSource, ...import("@comunica/types").IDataSource[]] | undefined;
-    source?: string | import("@rdfjs/types").Source<import("@rdfjs/types").Quad> | import("@comunica/types").IDataSourceExpanded | undefined;
+    sources?: [import("@comunica/types").QuerySourceUnidentified, ...import("@comunica/types").QuerySourceUnidentified[]] | undefined;
     destination?: import("@comunica/types").IDataDestination | undefined;
     initialBindings?: import("@rdfjs/types").Bindings | undefined;
     log?: import("@comunica/types").Logger | undefined;
@@ -58,8 +57,8 @@ export declare function resolveOptions(options?: Options): {
     httpTimeout?: number | undefined;
     httpBodyTimeout?: boolean | undefined;
     httpRetryCount?: number | undefined;
-    httpRetryDelay?: number | undefined;
-    httpRetryOnServerError?: boolean | undefined;
+    httpRetryDelayFallback?: number | undefined;
+    httpRetryDelayLimit?: number | undefined;
     fetch?: typeof fetch | undefined;
     readOnly?: boolean | undefined;
     extensionFunctionCreator?: ((functionNamedNode: import("@rdfjs/types").NamedNode<string>) => ((args: import("@rdfjs/types").Term[]) => Promise<import("@rdfjs/types").Term>) | undefined) | undefined;
@@ -67,6 +66,5 @@ 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;
-    localizeBlankNodes?: boolean | undefined;
 };
 export declare function resolveQueryContext(options: Options): QueryContext;