Emit warning on potentially invalid IRIs

Author: rubensworks

lib/CompileUtil.ts

@@ -33,6 +33,7 @@ export async function compileConfig(
     importPaths: state.importPaths,
     ignoreImports: false,
     absolutizeRelativePaths: true,
+    logger: loader.logger,
   });
 
   // Serialize the config

lib/Loader.ts

@@ -24,7 +24,7 @@ export class Loader {
   private readonly absolutizeRelativePaths: boolean;
   private readonly mainModulePath?: string;
   private readonly dumpErrorState: boolean;
-  private readonly logger?: Logger;
+  public readonly logger?: Logger;
   public readonly objectLoader: RdfObjectLoader;
 
   public componentResources: Record<string, Resource> = {};
@@ -241,6 +241,7 @@ export class Loader {
         importPaths: state.importPaths,
         ignoreImports: false,
         absolutizeRelativePaths: this.absolutizeRelativePaths,
+        logger: this.logger,
       }));
     } catch (error: unknown) {
       throw this.generateErrorLog(error);
@@ -522,6 +523,7 @@ export class Loader {
         importPaths: state.importPaths,
         ignoreImports: false,
         absolutizeRelativePaths: this.absolutizeRelativePaths,
+        logger: this.logger,
       }));
     } catch (error: unknown) {
       throw this.generateErrorLog(error);
@@ -553,6 +555,7 @@ export class Loader {
         importPaths: state.importPaths,
         ignoreImports: false,
         absolutizeRelativePaths: this.absolutizeRelativePaths,
+        logger: this.logger,
       }), settings);
     } catch (error: unknown) {
       throw this.generateErrorLog(error);

lib/Util.ts

@@ -266,3 +266,11 @@ export function addFilePathToError(error: Error, filePath: string, fromPath?: st
 export function uriToVariableName(uri: string): string {
   return uri.replace(/[#./:@\\^-]/gu, '_');
 }
+
+/**
+ * Check if the given IRI is valid.
+ * @param iri A potential IRI.
+ */
+export function isValidIri(iri: string): boolean {
+  return Boolean(/:((\/\/)|(.*:))/u.exec(iri));
+}

lib/rdf/RdfParser.ts

@@ -3,6 +3,7 @@ import type { Readable } from 'stream';
 import type * as RDF from 'rdf-js';
 import type { ParseOptions } from 'rdf-parse';
 import rdfParser from 'rdf-parse';
+import type { Logger } from 'winston';
 import Util = require('../Util');
 import { PrefetchedDocumentLoader } from './PrefetchedDocumentLoader';
 import { RdfStreamIncluder } from './RdfStreamIncluder';
@@ -65,4 +66,8 @@ export type RdfParserOptions = ParseOptions & {
    * If relative paths 'file://' should be made absolute 'file:///'.
    */
   absolutizeRelativePaths?: boolean;
+  /**
+   * An optional logger.
+   */
+  logger?: Logger;
 };

lib/rdf/RdfStreamIncluder.ts

@@ -3,8 +3,9 @@ import type { Readable } from 'stream';
 import { PassThrough } from 'stream';
 import { DataFactory } from 'rdf-data-factory';
 import type * as RDF from 'rdf-js';
-import { mapTerms } from 'rdf-terms';
+import { getNamedNodes, getTerms, mapTerms } from 'rdf-terms';
 import Util = require('../Util');
+import { isValidIri } from '../Util';
 import { RdfParser } from './RdfParser';
 import type { RdfParserOptions } from './RdfParser';
 
@@ -27,6 +28,7 @@ export class RdfStreamIncluder extends PassThrough {
 
   public push(quad: RDF.Quad | null, encoding?: string): boolean {
     if (quad) {
+      // Check for import link
       if (!this.parserOptions.ignoreImports && quad.predicate.value === `${Util.PREFIXES.owl}imports`) {
         this.runningImporters++;
         let relativeFilePath = quad.object.value;
@@ -51,9 +53,21 @@ export class RdfStreamIncluder extends PassThrough {
           }).catch((error: any) => this
             .emit('error', Util.addFilePathToError(error, relativeFilePath, this.parserOptions.baseIRI)));
       }
+
+      // Absolutize relative file paths
       if (this.parserOptions.absolutizeRelativePaths) {
         quad = mapTerms(quad, term => this._absolutize(term));
       }
+
+      // Validate IRIs
+      if (this.parserOptions.logger) {
+        for (const term of getNamedNodes(getTerms(quad))) {
+          if (!isValidIri(term.value)) {
+            this.parserOptions.logger.warn(`Detected potentially invalid IRI: '${term.value}'`);
+          }
+        }
+      }
+
       return super.push(quad);
     }
     if (!--this.runningImporters) {

test/Util-test.ts

@@ -8,7 +8,7 @@ describe('Util', () => {
     objectLoader = new Loader().objectLoader;
   });
 
-  describe('#captureType', () => {
+  describe('captureType', () => {
     it('should capture strings', () => {
       expect((<any> Util.captureType(objectLoader.createCompactedResource('"aaa"'), objectLoader.createCompactedResource({ range: `${Util.PREFIXES.xsd}string` }), objectLoader)).term.valueRaw)
         .toBeUndefined();
@@ -89,4 +89,31 @@ describe('Util', () => {
         .toEqual(256.36);
     });
   });
+
+  describe('isValidIri', () => {
+    it('should be false on an empty string', () => {
+      expect(Util.isValidIri('')).toBeFalsy();
+    });
+
+    it('should be false without colon', () => {
+      expect(Util.isValidIri('abc')).toBeFalsy();
+    });
+
+    it('should be false with one colon without //', () => {
+      expect(Util.isValidIri('a:a')).toBeFalsy();
+    });
+
+    it('should be false with one colon with further //', () => {
+      expect(Util.isValidIri('a:a//a')).toBeFalsy();
+    });
+
+    it('should be true with one colon followed by immediate //', () => {
+      expect(Util.isValidIri('a://a')).toBeTruthy();
+    });
+
+    it('should be true with more than one colon', () => {
+      expect(Util.isValidIri('a:a:a')).toBeTruthy();
+      expect(Util.isValidIri('a:a:a:a')).toBeTruthy();
+    });
+  });
 });