@lde/sparql-qlever 0.14.4 → 0.14.6

package/dist/importer.js

@@ -168,12 +168,26 @@ export class Importer {
         const metadataFile = `${this.options.indexName}.meta-data.json`;
         const localName = basename(file);
         const decompressCommand = localName.toLowerCase().endsWith('.zip')
-            ? `unzip -p '${localName}'`
-            : `(gunzip -c '${localName}' 2>/dev/null || cat '${localName}')`;
-        const indexTask = await this.options.taskRunner.run(`${decompressCommand} | qlever-index ${flags} && cat ${metadataFile}`);
+            ? `unzip -p ${shellQuote(localName)}`
+            : `(gunzip -c ${shellQuote(localName)} 2>/dev/null || cat ${shellQuote(localName)})`;
+        const indexTask = await this.options.taskRunner.run(`${decompressCommand} | qlever-index ${flags} && cat ${shellQuote(metadataFile)}`);
         return await this.options.taskRunner.wait(indexTask);
     }
 }
+/**
+ * POSIX-quote a value for safe interpolation into a shell command: wrap it in
+ * single quotes and escape any embedded single quote as `'\''`.
+ *
+ * Without this, a data filename containing an apostrophe — e.g. a dataset
+ * titled `'s-Hertogenbosch`, whose distribution URL maps to a local file like
+ * `…Erfgoed+'s-Hertogenbosch.nt` — would terminate the surrounding quotes, so
+ * `cat`/`gunzip` would read a non-existent path and feed `qlever-index` empty
+ * input. The index then "succeeds" with 0 triples, the import is treated as
+ * failed, and every distribution (and the JSON-LD fallback) fails the same way.
+ */
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
 /**
  * Native QLever index formats — `qlever-index -F <flag>` consumes these
  * directly. JSON-LD is not here: it is preprocessed to N-Quads first (see
@@ -186,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
@@ -198,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.4",
+  "version": "0.14.6",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
     "directory": "packages/sparql-qlever"
@@ -35,7 +35,7 @@
     "rdf-parse": "^5.0.0",
     "rdf-serialize": "^5.1.0",
     "tslib": "^2.3.0",
-    "yauzl": "^3.2.0"
+    "yauzl": "^3.3.2"
   },
   "devDependencies": {
     "@rdfjs/types": "^2.0.0",