@lde/sparql-qlever 0.14.5 → 0.14.7

package/dist/importer.js

@@ -200,8 +200,8 @@ const nativeFormats = new Map([
 ]);
 /**
  * Accepted distribution media types, in preference order: the first match is
- * tried first. Native formats win over JSON-LD because they skip the Node-side
- * preprocessor.
+ * tried first. Native formats win over JSON-LD and RDF/XML because they skip
+ * the Node-side preprocessor.
  *
  * `application/zip` is intentionally absent — the inner RDF format must be
  * declared via `mediaType` with `application/zip` appearing only as the
@@ -212,6 +212,7 @@ const acceptedMediaTypes = [
     'application/n-triples',
     'text/turtle',
     'application/ld+json',
+    'application/rdf+xml',
 ];
 const defaultQleverIndexOptions = {
     'ascii-prefixes-only': true,

package/dist/preprocess.d.ts

@@ -9,8 +9,8 @@ export interface PreprocessResult {
  * Whether a distribution needs Node-side preprocessing before `qlever-index`
  * can read it.
  *
- * Only JSON-LD distributions return `true`: `qlever-index` cannot parse
- * JSON-LD, so we stream it through a JSON-LD parser into N-Quads first.
+ * JSON-LD and RDF/XML distributions return `true`: `qlever-index` cannot parse
+ * either, so we stream them through `rdf-parse` into N-Quads first.
  *
  * Native RDF formats (`nt`, `nq`, `ttl`) — including when wrapped in
  * `application/gzip` or `application/zip` — go straight through the shell
@@ -20,12 +20,13 @@ export interface PreprocessResult {
  */
 export declare function needsPreprocessing(distribution: Distribution): boolean;
 /**
- * Convert a JSON-LD distribution to N-Quads alongside the source file.
+ * Convert a JSON-LD or RDF/XML distribution to N-Quads alongside the source
+ * file.
  *
  * Streams the source through `rdf-parse` → `rdf-serialize` so memory use
  * stays bounded regardless of input size. Handles gzip transparently
  * (declared `compressFormat` or `.gz` filename) and zip containers (folds
- * each JSON-LD entry into the output stream in order).
+ * each matching entry into the output stream in order).
  *
  * Cached: if the output is newer than the input, it is reused as-is.
  */

package/dist/preprocess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preprocess.d.ts","sourceRoot":"","sources":["../src/preprocess.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAmB5C,MAAM,WAAW,gBAAgB;IAC/B,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IACb,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAEtE;AAED;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,gBAAgB,CAAC,CAsB3B"}
+{"version":3,"file":"preprocess.d.ts","sourceRoot":"","sources":["../src/preprocess.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAmC5C,MAAM,WAAW,gBAAgB;IAC/B,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IACb,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAKtE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,gBAAgB,CAAC,CA2B3B"}

package/dist/preprocess.js

@@ -8,16 +8,25 @@ import { finished } from 'node:stream/promises';
 import { promisify } from 'node:util';
 import yauzl from 'yauzl';
 const JSONLD_MIME = 'application/ld+json';
+const RDFXML_MIME = 'application/rdf+xml';
 const ZIP_MIME = 'application/zip';
 const GZIP_MIME = 'application/gzip';
 const GZIP_MIME_LEGACY = 'application/x-gzip';
-const JSONLD_ZIP_EXTENSIONS = ['.jsonld', '.json'];
+/**
+ * RDF media types that `qlever-index` cannot read natively, so they are streamed
+ * through `rdf-parse` → N-Quads first. The map key is the `rdf-parse`
+ * `contentType`; the value carries the metadata needed to handle zip containers.
+ */
+const preprocessFormats = new Map([
+    [JSONLD_MIME, { label: 'JSON-LD', zipExtensions: ['.jsonld', '.json'] }],
+    [RDFXML_MIME, { label: 'RDF/XML', zipExtensions: ['.rdf', '.xml', '.owl'] }],
+]);
 /**
  * Whether a distribution needs Node-side preprocessing before `qlever-index`
  * can read it.
  *
- * Only JSON-LD distributions return `true`: `qlever-index` cannot parse
- * JSON-LD, so we stream it through a JSON-LD parser into N-Quads first.
+ * JSON-LD and RDF/XML distributions return `true`: `qlever-index` cannot parse
+ * either, so we stream them through `rdf-parse` into N-Quads first.
  *
  * Native RDF formats (`nt`, `nq`, `ttl`) — including when wrapped in
  * `application/gzip` or `application/zip` — go straight through the shell
@@ -26,20 +35,26 @@ const JSONLD_ZIP_EXTENSIONS = ['.jsonld', '.json'];
  * format must be declared.
  */
 export function needsPreprocessing(distribution) {
-    return distribution.mimeType === JSONLD_MIME;
+    return (distribution.mimeType !== undefined &&
+        preprocessFormats.has(distribution.mimeType));
 }
 /**
- * Convert a JSON-LD distribution to N-Quads alongside the source file.
+ * Convert a JSON-LD or RDF/XML distribution to N-Quads alongside the source
+ * file.
  *
  * Streams the source through `rdf-parse` → `rdf-serialize` so memory use
  * stays bounded regardless of input size. Handles gzip transparently
  * (declared `compressFormat` or `.gz` filename) and zip containers (folds
- * each JSON-LD entry into the output stream in order).
+ * each matching entry into the output stream in order).
  *
  * Cached: if the output is newer than the input, it is reused as-is.
  */
 export async function preprocess(localFile, distribution) {
-    if (!needsPreprocessing(distribution)) {
+    const contentType = distribution.mimeType;
+    const format = contentType === undefined
+        ? undefined
+        : preprocessFormats.get(contentType);
+    if (contentType === undefined || format === undefined) {
         throw new Error(`preprocess called for distribution that does not need preprocessing: mediaType=${distribution.mimeType}`);
     }
     const outputFile = `${localFile}.preprocessed.nq`;
@@ -49,10 +64,10 @@ export async function preprocess(localFile, distribution) {
     await rm(outputFile, { force: true });
     const warnings = [];
     if (distribution.compressMimeType === ZIP_MIME) {
-        await streamJsonldZip(localFile, outputFile, warnings);
+        await streamRdfZip(localFile, outputFile, contentType, format, warnings);
     }
     else {
-        await streamJsonldFile(localFile, outputFile, distribution);
+        await streamRdfFile(localFile, outputFile, contentType, distribution);
     }
     return { path: outputFile, format: 'nq', warnings };
 }
@@ -69,12 +84,12 @@ async function outputIsUpToDate(inputFile, outputFile) {
     }
 }
 /**
- * Pipe one JSON-LD source through parse → N-Quads serialize into an already
+ * Pipe one RDF source through parse → N-Quads serialize into an already
  * open writable, without closing it. Back-pressure is handled by Node's
  * built-in `.pipe()`; the caller manages `output`'s lifecycle.
  */
-async function pipeJsonldToWritable(input, output) {
-    const quads = rdfParser.parse(input, { contentType: JSONLD_MIME });
+async function pipeRdfToWritable(input, output, contentType) {
+    const quads = rdfParser.parse(input, { contentType });
     const bytes = rdfSerializer.serialize(quads, {
         contentType: 'application/n-quads',
     });
@@ -88,7 +103,7 @@ async function closeWritable(output) {
         output.end();
     });
 }
-async function streamJsonldFile(localFile, outputFile, distribution) {
+async function streamRdfFile(localFile, outputFile, contentType, distribution) {
     const isGzipped = distribution.compressMimeType === GZIP_MIME ||
         distribution.compressMimeType === GZIP_MIME_LEGACY ||
         localFile.toLowerCase().endsWith('.gz');
@@ -96,14 +111,14 @@ async function streamJsonldFile(localFile, outputFile, distribution) {
     const input = isGzipped ? source.pipe(createGunzip()) : source;
     const output = createWriteStream(outputFile);
     try {
-        await pipeJsonldToWritable(input, output);
+        await pipeRdfToWritable(input, output, contentType);
     }
     finally {
         await closeWritable(output);
     }
 }
 const openZip = promisify(yauzl.open);
-async function streamJsonldZip(zipFile, outputFile, warnings) {
+async function streamRdfZip(zipFile, outputFile, contentType, format, warnings) {
     const zip = await openZip(zipFile, { lazyEntries: true });
     const output = createWriteStream(outputFile);
     let entriesProcessed = 0;
@@ -119,13 +134,13 @@ async function streamJsonldZip(zipFile, outputFile, warnings) {
                             return;
                         }
                         const extension = extname(entry.fileName).toLowerCase();
-                        if (!JSONLD_ZIP_EXTENSIONS.includes(extension)) {
-                            warnings.push(`Skipping zip entry ${entry.fileName}: extension ${extension || '(none)'} is not JSON-LD`);
+                        if (!format.zipExtensions.includes(extension)) {
+                            warnings.push(`Skipping zip entry ${entry.fileName}: extension ${extension || '(none)'} is not ${format.label}`);
                             zip.readEntry();
                             return;
                         }
                         const stream = await openZipEntry(zip, entry);
-                        await pipeJsonldToWritable(stream, output);
+                        await pipeRdfToWritable(stream, output, contentType);
                         entriesProcessed++;
                         zip.readEntry();
                     }
@@ -142,7 +157,7 @@ async function streamJsonldZip(zipFile, outputFile, warnings) {
         await closeWritable(output);
     }
     if (entriesProcessed === 0) {
-        throw new Error(`Zip ${zipFile} contains no JSON-LD entries`);
+        throw new Error(`Zip ${zipFile} contains no ${format.label} entries`);
     }
 }
 function openZipEntry(zip, entry) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/sparql-qlever",
-  "version": "0.14.5",
+  "version": "0.14.7",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
     "directory": "packages/sparql-qlever"
@@ -24,9 +24,9 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/dataset": "0.7.4",
-    "@lde/distribution-downloader": "0.6.2",
-    "@lde/sparql-importer": "0.6.2",
+    "@lde/dataset": "0.7.5",
+    "@lde/distribution-downloader": "0.6.3",
+    "@lde/sparql-importer": "0.6.3",
     "@lde/sparql-server": "0.4.11",
     "@lde/task-runner": "0.2.11",
     "@lde/task-runner-docker": "0.2.13",
@@ -35,7 +35,7 @@
     "rdf-parse": "^5.0.0",
     "rdf-serialize": "^5.1.0",
     "tslib": "^2.3.0",
-    "yauzl": "^3.3.1"
+    "yauzl": "^3.3.2"
   },
   "devDependencies": {
     "@rdfjs/types": "^2.0.0",