Disable remote context lookups by default

The old behaviour can be restored by setting `remoteContextLookups` to
true in the `ComponentsManagerBuilder`.

Closes #119

Author: rubensworks

lib/loading/ComponentRegistry.ts

@@ -19,13 +19,15 @@ export class ComponentRegistry {
   private readonly logger: Logger;
   private readonly componentResources: Record<string, Resource>;
   private readonly skipContextValidation: boolean;
+  private readonly remoteContextLookups: boolean;
 
   public constructor(options: IComponentLoaderRegistryOptions) {
     this.moduleState = options.moduleState;
     this.objectLoader = options.objectLoader;
     this.logger = options.logger;
     this.componentResources = options.componentResources;
     this.skipContextValidation = options.skipContextValidation;
+    this.remoteContextLookups = options.remoteContextLookups;
   }
 
   /**
@@ -51,6 +53,7 @@ export class ComponentRegistry {
       importPaths: this.moduleState.importPaths,
       logger: this.logger,
       skipContextValidation: this.skipContextValidation,
+      remoteContextLookups: this.remoteContextLookups,
     }));
   }
 
@@ -119,4 +122,5 @@ export interface IComponentLoaderRegistryOptions {
   logger: Logger;
   componentResources: Record<string, Resource>;
   skipContextValidation: boolean;
+  remoteContextLookups: boolean;
 }

lib/loading/ComponentsManagerBuilder.ts

@@ -31,6 +31,7 @@ export class ComponentsManagerBuilder<Instance = any> {
   private readonly moduleState?: IModuleState;
   private readonly skipContextValidation: boolean;
   private readonly typeChecking: boolean;
+  private readonly remoteContextLookups: boolean;
 
   public constructor(options: IComponentsManagerBuilderOptions<Instance>) {
     this.mainModulePath = options.mainModulePath;
@@ -48,6 +49,9 @@ export class ComponentsManagerBuilder<Instance = any> {
     this.typeChecking = options.typeChecking === undefined ?
       true :
       Boolean(options.typeChecking);
+    this.remoteContextLookups = options.remoteContextLookups === undefined ?
+      false :
+      Boolean(options.typeChecking);
   }
 
   public static createLogger(logLevel: LogLevel = 'warn'): Logger {
@@ -100,6 +104,7 @@ export class ComponentsManagerBuilder<Instance = any> {
       logger: this.logger,
       componentResources,
       skipContextValidation: this.skipContextValidation,
+      remoteContextLookups: this.remoteContextLookups,
     });
     await this.componentLoader(componentRegistry);
     const componentFinalizer = new ComponentRegistryFinalizer({
@@ -116,6 +121,7 @@ export class ComponentsManagerBuilder<Instance = any> {
       objectLoader,
       logger: this.logger,
       skipContextValidation: this.skipContextValidation,
+      remoteContextLookups: this.remoteContextLookups,
     });
     await this.configLoader(configRegistry);
     this.logger.info(`Loaded configs`);
@@ -213,4 +219,11 @@ export interface IComponentsManagerBuilderOptions<Instance> {
    * Defaults to `true`.
    */
   typeChecking?: boolean;
+  /**
+   * If remote context lookups are allowed.
+   * If not allowed, an error is thrown if a remote lookup occurs.
+   * If allowed, only a warning is emitted.
+   * Defaults to `false`.
+   */
+  remoteContextLookups?: boolean;
 }

lib/loading/ConfigRegistry.ts

@@ -14,12 +14,14 @@ export class ConfigRegistry {
   private readonly objectLoader: RdfObjectLoader;
   private readonly logger: Logger;
   private readonly skipContextValidation: boolean;
+  private readonly remoteContextLookups: boolean;
 
   public constructor(options: IConfigLoaderRegistryOptions) {
     this.moduleState = options.moduleState;
     this.objectLoader = options.objectLoader;
     this.logger = options.logger;
     this.skipContextValidation = options.skipContextValidation;
+    this.remoteContextLookups = options.remoteContextLookups;
   }
 
   /**
@@ -35,6 +37,7 @@ export class ConfigRegistry {
       ignoreImports: false,
       logger: this.logger,
       skipContextValidation: this.skipContextValidation,
+      remoteContextLookups: this.remoteContextLookups,
     }));
   }
 
@@ -81,4 +84,5 @@ export interface IConfigLoaderRegistryOptions {
   objectLoader: RdfObjectLoader;
   logger: Logger;
   skipContextValidation: boolean;
+  remoteContextLookups: boolean;
 }

lib/rdf/PrefetchedDocumentLoader.ts

@@ -25,12 +25,14 @@ export class PrefetchedDocumentLoader extends FetchDocumentLoader {
   private readonly contexts: Record<string, any>;
   private readonly path?: string;
   private readonly logger?: Logger;
+  private readonly remoteContextLookups?: boolean;
 
   public constructor(options: IPrefetchedDocumentLoaderOptions) {
     super();
     this.contexts = { ...options.contexts, ...PrefetchedDocumentLoader.DEFAULT_CONTEXTS };
     this.logger = options.logger;
     this.path = options.path;
+    this.remoteContextLookups = options.remoteContextLookups;
   }
 
   public async load(url: string): Promise<IJsonLdContext> {
@@ -47,8 +49,12 @@ export class PrefetchedDocumentLoader extends FetchDocumentLoader {
     }
 
     // Warn before doing a remote context lookup
+    const errorMessage = `Detected remote context lookup for '${url}'${this.path ? ` in ${this.path}` : ''}. This may indicate a missing or invalid dependency, incorrect version number, or an invalid context URL.`;
+    if (!this.remoteContextLookups) {
+      throw new Error(errorMessage);
+    }
     if (this.logger) {
-      this.logger.warn(`Detected remote context lookup for '${url}'${this.path ? ` in ${this.path}` : ''}. This may indicate a missing or invalid dependency, incorrect version number, or an invalid context URL.`);
+      this.logger.warn(errorMessage);
     }
     return super.load(url);
   }
@@ -58,4 +64,5 @@ export interface IPrefetchedDocumentLoaderOptions {
   contexts: Record<string, any>;
   logger?: Logger;
   path?: string;
+  remoteContextLookups?: boolean;
 }

lib/rdf/RdfParser.ts

@@ -50,6 +50,7 @@ export class RdfParser {
         contexts: options.contexts || {},
         logger: options.logger,
         path: options.path,
+        remoteContextLookups: options.remoteContextLookups,
       }),
       // Enable strict parsing of JSON-LD to error on potential user config errors
       strictValues: true,
@@ -124,4 +125,10 @@ export type RdfParserOptions = ParseOptions & {
    * If JSON-LD context validation should be skipped.
    */
   skipContextValidation?: boolean;
+  /**
+   * If remote context lookups are allowed.
+   * If not allowed, an error is thrown if a remote lookup occurs.
+   * If allowed, only a warning is emitted.
+   */
+  remoteContextLookups?: boolean;
 };

test/unit/loading/ComponentRegistry-test.ts

@@ -31,6 +31,7 @@ describe('ComponentRegistry', () => {
       logger,
       componentResources,
       skipContextValidation: false,
+      remoteContextLookups: false,
     });
   });
 

test/unit/loading/ComponentRegistryFinalizer-test.ts

@@ -33,6 +33,7 @@ describe('ComponentRegistryFinalizer', () => {
       logger,
       componentResources,
       skipContextValidation: false,
+      remoteContextLookups: false,
     });
     finalizer = new ComponentRegistryFinalizer({
       objectLoader,

test/unit/loading/ComponentsManager-test.ts

@@ -56,6 +56,7 @@ describe('ComponentsManager', () => {
       objectLoader,
       logger,
       skipContextValidation: false,
+      remoteContextLookups: false,
     });
     dumpErrorState = false;
     configConstructorPool = <any> {

test/unit/loading/ComponentsManagerBuilder-test.ts

@@ -342,4 +342,31 @@ describe('ComponentsManagerBuilder', () => {
       transports: expect.anything(),
     });
   });
+
+  it('should build with true remoteContextLookups', async() => {
+    const componentsManagerBuilder = new ComponentsManagerBuilder({
+      mainModulePath,
+      remoteContextLookups: true,
+    });
+    const mgr = await componentsManagerBuilder.build();
+
+    expect(mgr).toBeTruthy();
+    expect(mgr.moduleState).toBe(dummyModuleState);
+    expect(mgr.objectLoader).toBeInstanceOf(RdfObjectLoader);
+    expect(Object.keys(mgr.componentResources).length).toBe(2);
+    expect(mgr.configRegistry).toBeInstanceOf(ConfigRegistry);
+    expect(mgr.dumpErrorState).toBe(true);
+    expect(mgr.configConstructorPool).toBeInstanceOf(ConfigConstructorPool);
+    expect((<any> mgr.configConstructorPool).constructionStrategy).toBeInstanceOf(ConstructionStrategyCommonJs);
+    expect((<any> mgr.configConstructorPool).configPreprocessors.length).toBe(3);
+    expect((<any> mgr.configConstructorPool).configPreprocessors[0]).toBeInstanceOf(ConfigPreprocessorOverride);
+    expect((<any> mgr.configConstructorPool).configPreprocessors[1]).toBeInstanceOf(ConfigPreprocessorComponentMapped);
+    expect((<any> mgr.configConstructorPool).configPreprocessors[2]).toBeInstanceOf(ConfigPreprocessorComponent);
+    expect(mgr.logger).toBeTruthy();
+    expect(createLogger).toBeCalledTimes(1);
+    expect(createLogger).toHaveBeenCalledWith({
+      level: 'warn',
+      transports: expect.anything(),
+    });
+  });
 });

test/unit/loading/ConfigRegistry-test.ts

@@ -27,6 +27,7 @@ describe('ConfigRegistry', () => {
       objectLoader,
       logger,
       skipContextValidation: false,
+      remoteContextLookups: false,
     });
   });
 

test/unit/rdf/PrefetchedDocumentLoader-test.ts

@@ -77,31 +77,70 @@ describe('PrefetchedDocumentLoader', () => {
     });
 
     it('for a non-prefetched context', async() => {
+      await expect(loader.load('http://remote.org/context')).rejects
+        .toThrow(`Detected remote context lookup for 'http://remote.org/context' in PATH. This may indicate a missing or invalid dependency, incorrect version number, or an invalid context URL.`);
+    });
+
+    it('for a non-prefetched context with a logger', async() => {
+      const logger: any = {
+        warn: jest.fn(),
+      };
+      loader = new PrefetchedDocumentLoader({
+        contexts: {},
+        logger,
+        path: 'PATH',
+      });
+      await expect(loader.load('http://remote.org/context')).rejects
+        .toThrow(`Detected remote context lookup for 'http://remote.org/context' in PATH. This may indicate a missing or invalid dependency, incorrect version number, or an invalid context URL.`);
+    });
+
+    it('for a non-prefetched context with a logger without path', async() => {
+      const logger: any = {
+        warn: jest.fn(),
+      };
+      loader = new PrefetchedDocumentLoader({
+        contexts: {},
+        logger,
+      });
+      await expect(loader.load('http://remote.org/context')).rejects
+        .toThrow(`Detected remote context lookup for 'http://remote.org/context'. This may indicate a missing or invalid dependency, incorrect version number, or an invalid context URL.`);
+    });
+
+    it('for a non-prefetched context with remoteContextLookups: true', async() => {
+      loader = new PrefetchedDocumentLoader({
+        contexts: {
+          'http://example.org/context': { a: 'b' },
+        },
+        path: 'PATH',
+        remoteContextLookups: true,
+      });
       expect(await loader.load('http://remote.org/context'))
         .toEqual({ x: 'y' });
     });
 
-    it('for a non-prefetched context with a logger', async() => {
+    it('for a non-prefetched context with a logger with remoteContextLookups: true', async() => {
       const logger: any = {
         warn: jest.fn(),
       };
       loader = new PrefetchedDocumentLoader({
         contexts: {},
         logger,
         path: 'PATH',
+        remoteContextLookups: true,
       });
       expect(await loader.load('http://remote.org/context'))
         .toEqual({ x: 'y' });
       expect(logger.warn).toHaveBeenCalledWith(`Detected remote context lookup for 'http://remote.org/context' in PATH. This may indicate a missing or invalid dependency, incorrect version number, or an invalid context URL.`);
     });
 
-    it('for a non-prefetched context with a logger without path', async() => {
+    it('for a non-prefetched context with a logger without path with remoteContextLookups: true', async() => {
       const logger: any = {
         warn: jest.fn(),
       };
       loader = new PrefetchedDocumentLoader({
         contexts: {},
         logger,
+        remoteContextLookups: true,
       });
       expect(await loader.load('http://remote.org/context'))
         .toEqual({ x: 'y' });