ldkit 0.8.0 → 1.1.0

package/esm/library/engine/query_engine.js

@@ -1,5 +1,4 @@
-import { BindingsFactory, QuadFactory, } from "../rdf.js";
-import { ArrayIterator, MappingIterator, TreeIterator, } from "../asynciterator.js";
+import { getResponseTypes, resolve, } from "./query_resolvers.js";
 export class QueryEngine {
     getSparqlEndpoint(context) {
         if (!context) {
@@ -30,10 +29,10 @@ export class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    async query(query, responseType, context) {
+    query(query, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
-        const response = await fetchFn(endpoint, {
+        return fetchFn(endpoint, {
             method: "POST",
             headers: {
                 "accept": responseType,
@@ -43,35 +42,24 @@ export class QueryEngine {
                 query,
             }),
         });
-        const json = await response.json();
-        return json;
     }
-    async queryBindings(query, context) {
-        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");
+    async queryAndResolve(type, query, context) {
+        const responseType = getResponseTypes(type).join(", ");
+        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}'`);
         }
-        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));
+        return resolve(type, response);
     }
-    async queryBoolean(query, context) {
-        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");
+    queryBindings(query, context) {
+        return this.queryAndResolve("bindings", query, context);
     }
-    async queryQuads(query, context) {
-        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 treeIterator = new TreeIterator(json);
-        // TODO: review the unknown type cast
-        return new MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
+    queryBoolean(query, context) {
+        return this.queryAndResolve("boolean", query, context);
+    }
+    queryQuads(query, context) {
+        return this.queryAndResolve("quads", query, context);
     }
     async queryVoid(query, context) {
         await this.query(query, "application/sparql-results+json", context);

package/esm/library/engine/query_resolvers.js

@@ -0,0 +1,72 @@
+import { BindingsFactory, N3, QuadFactory } from "../rdf.js";
+import { ArrayIterator, MappingIterator, TreeIterator, } from "../asynciterator.js";
+class QueryResolver {
+}
+class BooleanJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if ("boolean" in json) {
+            return Boolean(json.boolean);
+        }
+        throw new Error("Boolean SPARQL query result not found");
+    }
+}
+class BindingsJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if (!Array.isArray(json.results?.bindings)) {
+            throw new Error("Bindings SPARQL query result not found");
+        }
+        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));
+    }
+}
+class QuadsJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if (!(json?.constructor === Object)) {
+            throw new Error("Quads SPARQL query result not found");
+        }
+        const quadFactory = new QuadFactory();
+        const treeIterator = new TreeIterator(json);
+        // TODO: review the unknown type cast
+        return new MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
+    }
+}
+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);
+    }
+}
+const resolvers = {
+    "boolean": {
+        "application/sparql-results+json": new BooleanJsonResolver(),
+    },
+    "bindings": {
+        "application/sparql-results+json": new BindingsJsonResolver(),
+    },
+    "quads": {
+        "application/rdf+json": new QuadsJsonResolver(),
+        "text/turtle": new QuadsTurtleResolver(),
+    },
+};
+export const getResponseTypes = (resolverType) => Object.keys(resolvers[resolverType]);
+export const resolve = (resolverType, response) => {
+    const contentType = response.headers.get("Content-type");
+    if (!contentType) {
+        throw new Error(`Content-type header was not found in response`);
+    }
+    const separatorPosition = contentType.indexOf(";");
+    const mime = separatorPosition > 0
+        ? contentType.substring(0, separatorPosition)
+        : contentType;
+    const resolver = resolvers[resolverType][mime];
+    if (!resolver) {
+        throw new Error(`No resolver exists for response type '${mime}'`);
+    }
+    return resolver.resolve(response);
+};

package/esm/library/rdf.js

@@ -1,6 +1,7 @@
 export { fromRdf, toRdf } from "rdf-literal";
 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) {
@@ -29,8 +30,8 @@ export class TermFactory {
         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 ("lang" in jsonTerm) {
+            return this.dataFactory.literal(jsonTerm.value, jsonTerm["lang"]);
         }
         if ("datatype" in jsonTerm) {
             return this.dataFactory.literal(jsonTerm.value, this.dataFactory.namedNode(jsonTerm.datatype));

package/esm/mod.js

@@ -1,3 +1,4 @@
 export { setDefaultContext, setDefaultEngine } from "./library/global.js";
 export { createLens, createResource } from "./library/lens/mod.js";
 export { createNamespace } from "./library/namespaces/namespace.js";
+export { QueryEngine } from "./library/engine/mod.js";

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "0.8.0",
+  "version": "1.1.0",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -65,7 +65,9 @@
   },
   "dependencies": {
     "@comunica/types": "2.6.8",
+    "@types/n3": "*",
     "asynciterator": "3.8.0",
+    "n3": "1.17.2",
     "rdf-data-factory": "1.1.1",
     "rdf-js": "4.0.2",
     "rdf-literal": "1.3.1"

package/script/library/engine/query_engine.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryEngine = void 0;
-const rdf_js_1 = require("../rdf.js");
-const asynciterator_js_1 = require("../asynciterator.js");
+const query_resolvers_js_1 = require("./query_resolvers.js");
 class QueryEngine {
     getSparqlEndpoint(context) {
         if (!context) {
@@ -33,10 +32,10 @@ class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    async query(query, responseType, context) {
+    query(query, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
-        const response = await fetchFn(endpoint, {
+        return fetchFn(endpoint, {
             method: "POST",
             headers: {
                 "accept": responseType,
@@ -46,35 +45,24 @@ class QueryEngine {
                 query,
             }),
         });
-        const json = await response.json();
-        return json;
     }
-    async queryBindings(query, context) {
-        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");
+    async queryAndResolve(type, query, context) {
+        const responseType = (0, query_resolvers_js_1.getResponseTypes)(type).join(", ");
+        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}'`);
         }
-        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));
+        return (0, query_resolvers_js_1.resolve)(type, response);
     }
-    async queryBoolean(query, context) {
-        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");
+    queryBindings(query, context) {
+        return this.queryAndResolve("bindings", query, context);
     }
-    async queryQuads(query, context) {
-        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 treeIterator = new asynciterator_js_1.TreeIterator(json);
-        // TODO: review the unknown type cast
-        return new asynciterator_js_1.MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
+    queryBoolean(query, context) {
+        return this.queryAndResolve("boolean", query, context);
+    }
+    queryQuads(query, context) {
+        return this.queryAndResolve("quads", query, context);
     }
     async queryVoid(query, context) {
         await this.query(query, "application/sparql-results+json", context);

package/script/library/engine/query_resolvers.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = exports.getResponseTypes = void 0;
+const rdf_js_1 = require("../rdf.js");
+const asynciterator_js_1 = require("../asynciterator.js");
+class QueryResolver {
+}
+class BooleanJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if ("boolean" in json) {
+            return Boolean(json.boolean);
+        }
+        throw new Error("Boolean SPARQL query result not found");
+    }
+}
+class BindingsJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if (!Array.isArray(json.results?.bindings)) {
+            throw new Error("Bindings SPARQL query result not found");
+        }
+        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));
+    }
+}
+class QuadsJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if (!(json?.constructor === Object)) {
+            throw new Error("Quads SPARQL query result not found");
+        }
+        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));
+    }
+}
+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);
+    }
+}
+const resolvers = {
+    "boolean": {
+        "application/sparql-results+json": new BooleanJsonResolver(),
+    },
+    "bindings": {
+        "application/sparql-results+json": new BindingsJsonResolver(),
+    },
+    "quads": {
+        "application/rdf+json": new QuadsJsonResolver(),
+        "text/turtle": new QuadsTurtleResolver(),
+    },
+};
+const getResponseTypes = (resolverType) => Object.keys(resolvers[resolverType]);
+exports.getResponseTypes = getResponseTypes;
+const resolve = (resolverType, response) => {
+    const contentType = response.headers.get("Content-type");
+    if (!contentType) {
+        throw new Error(`Content-type header was not found in response`);
+    }
+    const separatorPosition = contentType.indexOf(";");
+    const mime = separatorPosition > 0
+        ? contentType.substring(0, separatorPosition)
+        : contentType;
+    const resolver = resolvers[resolverType][mime];
+    if (!resolver) {
+        throw new Error(`No resolver exists for response type '${mime}'`);
+    }
+    return resolver.resolve(response);
+};
+exports.resolve = resolve;

package/script/library/rdf.js

@@ -1,12 +1,36 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = exports.TermFactory = exports.quadsToGraph = exports.DefaultGraph = exports.DataFactory = exports.toRdf = exports.fromRdf = void 0;
+exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = exports.TermFactory = exports.quadsToGraph = exports.N3 = exports.DefaultGraph = exports.DataFactory = exports.toRdf = exports.fromRdf = void 0;
 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");
 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) {
@@ -36,8 +60,8 @@ class TermFactory {
         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 ("lang" in jsonTerm) {
+            return this.dataFactory.literal(jsonTerm.value, jsonTerm["lang"]);
         }
         if ("datatype" in jsonTerm) {
             return this.dataFactory.literal(jsonTerm.value, this.dataFactory.namedNode(jsonTerm.datatype));

package/script/mod.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNamespace = exports.createResource = exports.createLens = exports.setDefaultEngine = exports.setDefaultContext = void 0;
+exports.QueryEngine = exports.createNamespace = exports.createResource = exports.createLens = exports.setDefaultEngine = exports.setDefaultContext = void 0;
 var global_js_1 = require("./library/global.js");
 Object.defineProperty(exports, "setDefaultContext", { enumerable: true, get: function () { return global_js_1.setDefaultContext; } });
 Object.defineProperty(exports, "setDefaultEngine", { enumerable: true, get: function () { return global_js_1.setDefaultEngine; } });
@@ -9,3 +9,5 @@ Object.defineProperty(exports, "createLens", { enumerable: true, get: function (
 Object.defineProperty(exports, "createResource", { enumerable: true, get: function () { return mod_js_1.createResource; } });
 var namespace_js_1 = require("./library/namespaces/namespace.js");
 Object.defineProperty(exports, "createNamespace", { enumerable: true, get: function () { return namespace_js_1.createNamespace; } });
+var mod_js_2 = require("./library/engine/mod.js");
+Object.defineProperty(exports, "QueryEngine", { enumerable: true, get: function () { return mod_js_2.QueryEngine; } });

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

@@ -1,15 +1,16 @@
-import { type Context, type IQueryEngine, type RDF, RDFJSON } from "../rdf.js";
-type QueryResponseFormat = {
-    "application/sparql-results+json": RDFJSON.SparqlResultsJsonFormat;
-    "application/rdf+json": RDFJSON.RdfJsonFormat;
-};
+import { type Context, type IQueryEngine, type RDF } from "../rdf.js";
+import { type ResolverType } from "./query_resolvers.js";
 export declare class QueryEngine implements IQueryEngine {
     protected getSparqlEndpoint(context?: Context): string;
     protected getFetch(context?: Context): typeof fetch;
-    query<ResponseType extends keyof QueryResponseFormat, ResponseFormat = QueryResponseFormat[ResponseType]>(query: string, responseType: ResponseType, context?: Context): Promise<ResponseFormat>;
+    query(query: string, responseType: string, context?: Context): Promise<Response>;
+    queryAndResolve<T extends ResolverType>(type: T, query: string, context?: Context): Promise<{
+        boolean: boolean;
+        bindings: RDF.ResultStream<RDF.Bindings>;
+        quads: RDF.ResultStream<RDF.Quad>;
+    }[T]>;
     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_resolvers.d.ts

@@ -0,0 +1,10 @@
+import { type RDF } from "../rdf.js";
+type ResolveFormat = {
+    "boolean": boolean;
+    "bindings": RDF.ResultStream<RDF.Bindings>;
+    "quads": RDF.ResultStream<RDF.Quad>;
+};
+export type ResolverType = keyof ResolveFormat;
+export declare const getResponseTypes: (resolverType: ResolverType) => string[];
+export declare const resolve: <T extends keyof ResolveFormat>(resolverType: T, response: Response) => Promise<ResolveFormat[T]>;
+export {};

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

@@ -2,11 +2,12 @@ declare const _default: {
     number: "dbo:number";
     symbol: "dbo:symbol";
     tree: "dbo:tree";
-    value: "dbo:value";
-    type: "dbo:type";
     closed: "dbo:closed";
     map: "dbo:map";
     range: "dbo:range";
+    format: "dbo:format";
+    value: "dbo:value";
+    type: "dbo:type";
     prefix: "dbo:prefix";
     length: "dbo:length";
     Name: "dbo:Name";
@@ -1742,7 +1743,6 @@ declare const _default: {
     footedness: "dbo:footedness";
     forces: "dbo:forces";
     foresterDistrict: "dbo:foresterDistrict";
-    format: "dbo:format";
     formationDate: "dbo:formationDate";
     formationYear: "dbo:formationYear";
     formerBandMember: "dbo:formerBandMember";

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

@@ -1,11 +1,11 @@
 declare const _default: {
     subject: "dc:subject";
+    format: "dc:format";
     type: "dc:type";
     date: "dc:date";
     language: "dc:language";
     description: "dc:description";
     creator: "dc:creator";
-    format: "dc:format";
     publisher: "dc:publisher";
     relation: "dc:relation";
     source: "dc:source";

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

@@ -1,5 +1,6 @@
 declare const _default: {
     subject: "dcterms:subject";
+    format: "dcterms:format";
     type: "dcterms:type";
     date: "dcterms:date";
     language: "dcterms:language";
@@ -9,7 +10,6 @@ declare const _default: {
     abstract: "dcterms:abstract";
     created: "dcterms:created";
     creator: "dcterms:creator";
-    format: "dcterms:format";
     isPartOf: "dcterms:isPartOf";
     license: "dcterms:license";
     publisher: "dcterms:publisher";

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

@@ -1,8 +1,10 @@
 declare const _default: {
     object: "schema:object";
+    map: "schema:map";
+    application: "schema:application";
+    text: "schema:text";
     value: "schema:value";
     query: "schema:query";
-    map: "schema:map";
     duration: "schema:duration";
     language: "schema:language";
     Property: "schema:Property";
@@ -1560,7 +1562,6 @@ declare const _default: {
     antagonist: "schema:antagonist";
     applicableLocation: "schema:applicableLocation";
     applicantLocationRequirements: "schema:applicantLocationRequirements";
-    application: "schema:application";
     applicationCategory: "schema:applicationCategory";
     applicationContact: "schema:applicationContact";
     applicationDeadline: "schema:applicationDeadline";
@@ -2577,7 +2578,6 @@ declare const _default: {
     termDuration: "schema:termDuration";
     termsOfService: "schema:termsOfService";
     termsPerYear: "schema:termsPerYear";
-    text: "schema:text";
     textValue: "schema:textValue";
     thumbnailUrl: "schema:thumbnailUrl";
     tickerSymbol: "schema:tickerSymbol";

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

@@ -1,4 +1,5 @@
 declare const _default: {
+    example: "skos:example";
     definition: "skos:definition";
     member: "skos:member";
     note: "skos:note";
@@ -15,7 +16,6 @@ declare const _default: {
     closeMatch: "skos:closeMatch";
     editorialNote: "skos:editorialNote";
     exactMatch: "skos:exactMatch";
-    example: "skos:example";
     hasTopConcept: "skos:hasTopConcept";
     hiddenLabel: "skos:hiddenLabel";
     historyNote: "skos:historyNote";

package/types/library/rdf.d.ts

@@ -3,6 +3,7 @@ export type { RDF };
 export { fromRdf, toRdf } from "rdf-literal";
 import { DataFactory, DefaultGraph } from "rdf-data-factory";
 export { DataFactory, DefaultGraph };
+export * as N3 from "n3";
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
 export type LDkitContext = {
     graph?: string;
@@ -18,7 +19,7 @@ export declare namespace RDFJSON {
     type Term = {
         type: "uri" | "literal" | "bnode";
         value: string;
-        "xml:lang"?: string;
+        lang?: string;
         datatype?: string;
     };
     type Bindings = Record<string, Term>;

package/types/mod.d.ts

@@ -3,3 +3,4 @@ export { setDefaultContext, setDefaultEngine } from "./library/global.js";
 export { type SchemaInterface } from "./library/schema/mod.js";
 export { createLens, createResource, type Lens } from "./library/lens/mod.js";
 export { createNamespace } from "./library/namespaces/namespace.js";
+export { QueryEngine } from "./library/engine/mod.js";