Allow type-checking to be disabled via typeChecking

lib/loading/ComponentsManagerBuilder.ts

@@ -30,6 +30,7 @@ export class ComponentsManagerBuilder<Instance = any> {
   private readonly logger: Logger;
   private readonly moduleState?: IModuleState;
   private readonly skipContextValidation: boolean;
+  private readonly typeChecking: boolean;
 
   public constructor(options: IComponentsManagerBuilderOptions<Instance>) {
     this.mainModulePath = options.mainModulePath;
@@ -44,6 +45,9 @@ export class ComponentsManagerBuilder<Instance = any> {
     this.skipContextValidation = options.skipContextValidation === undefined ?
       true :
       Boolean(options.skipContextValidation);
+    this.typeChecking = options.typeChecking === undefined ?
+      true :
+      Boolean(options.typeChecking);
   }
 
   public static createLogger(logLevel: LogLevel = 'warn'): Logger {
@@ -117,7 +121,7 @@ export class ComponentsManagerBuilder<Instance = any> {
 
     // Build constructor pool
     const runTypeConfigs = {};
-    const parameterHandler = new ParameterHandler({ objectLoader });
+    const parameterHandler = new ParameterHandler({ objectLoader, typeChecking: this.typeChecking });
     const configConstructorPool: IConfigConstructorPool<Instance> = new ConfigConstructorPool({
       objectLoader,
       configPreprocessors: [
@@ -198,4 +202,9 @@ export interface IComponentsManagerBuilderOptions<Instance> {
    * Defaults to `true`.
    */
   skipContextValidation?: boolean;
+  /**
+   * If values for parameters should be type-checked.
+   * Defaults to `true`.
+   */
+  typeChecking?: boolean;
 }

lib/preprocess/ParameterHandler.ts

@@ -22,7 +22,7 @@ export class ParameterHandler {
       new ParameterPropertyHandlerDefaultScoped(this.objectLoader),
       new ParameterPropertyHandlerDefault(this.objectLoader),
       new ParameterPropertyHandlerFixed(this.objectLoader),
-      this.parameterPropertyHandlerRange = new ParameterPropertyHandlerRange(this.objectLoader),
+      this.parameterPropertyHandlerRange = new ParameterPropertyHandlerRange(this.objectLoader, options.typeChecking),
       new ParameterPropertyHandlerLazy(),
     ];
   }
@@ -70,4 +70,5 @@ export class ParameterHandler {
 
 export interface IParameterHandlerOptions {
   objectLoader: RdfObjectLoader;
+  typeChecking: boolean;
 }

lib/preprocess/parameterproperty/ParameterPropertyHandlerRange.ts

@@ -10,9 +10,11 @@ import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
  */
 export class ParameterPropertyHandlerRange implements IParameterPropertyHandler {
   private readonly objectLoader: RdfObjectLoader;
+  private readonly typeChecking: boolean;
 
-  public constructor(objectLoader: RdfObjectLoader) {
+  public constructor(objectLoader: RdfObjectLoader, typeChecking: boolean) {
     this.objectLoader = objectLoader;
+    this.typeChecking = typeChecking;
   }
 
   public canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean {
@@ -46,7 +48,7 @@ export class ParameterPropertyHandlerRange implements IParameterPropertyHandler
   ): Resource | undefined {
     const errorContext: IErrorContext = { param };
     const conflict = this.hasValueType(value, param.property.range, errorContext, genericsContext);
-    if (!conflict) {
+    if (!conflict || !this.typeChecking) {
       return value;
     }
     ParameterPropertyHandlerRange.throwIncorrectTypeError(value, param, genericsContext, conflict);

test/unit/construction/ConfigConstructorPool-test.ts

@@ -44,7 +44,7 @@ describe('ConfigConstructorPool', () => {
       moduleState,
     });
     creationSettings = {};
-    parameterHandler = new ParameterHandler({ objectLoader });
+    parameterHandler = new ParameterHandler({ objectLoader, typeChecking: true });
   });
 
   describe('with no preprocessors', () => {

test/unit/loading/ComponentsManagerBuilder-test.ts

@@ -301,4 +301,30 @@ describe('ComponentsManagerBuilder', () => {
       transports: expect.anything(),
     });
   });
+
+  it('should build with false typeChecking', async() => {
+    const componentsManagerBuilder = new ComponentsManagerBuilder({
+      mainModulePath,
+      typeChecking: false,
+    });
+    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(2);
+    expect((<any> mgr.configConstructorPool).configPreprocessors[0]).toBeInstanceOf(ConfigPreprocessorComponentMapped);
+    expect((<any> mgr.configConstructorPool).configPreprocessors[1]).toBeInstanceOf(ConfigPreprocessorComponent);
+    expect(mgr.logger).toBeTruthy();
+    expect(createLogger).toBeCalledTimes(1);
+    expect(createLogger).toHaveBeenCalledWith({
+      level: 'warn',
+      transports: expect.anything(),
+    });
+  });
 });

test/unit/preprocess/ConfigPreprocessorComponent-test.ts

@@ -38,7 +38,7 @@ describe('ConfigPreprocessorComponent', () => {
       objectLoader,
       componentResources,
       runTypeConfigs: {},
-      parameterHandler: new ParameterHandler({ objectLoader }),
+      parameterHandler: new ParameterHandler({ objectLoader, typeChecking: true }),
       logger,
     });
   });

test/unit/preprocess/ConfigPreprocessorComponentMapped-test.ts

@@ -35,7 +35,7 @@ describe('ConfigPreprocessorComponentMapped', () => {
       objectLoader,
       componentResources,
       runTypeConfigs: {},
-      parameterHandler: new ParameterHandler({ objectLoader }),
+      parameterHandler: new ParameterHandler({ objectLoader, typeChecking: true }),
       logger: <any> { warn: jest.fn() },
     });
   });

test/unit/preprocess/ParameterHandler-test.ts

@@ -18,7 +18,7 @@ describe('ParameterHandler', () => {
     });
     await objectLoader.context;
     genericsContext = new GenericsContext(objectLoader, []);
-    handler = new ParameterHandler({ objectLoader });
+    handler = new ParameterHandler({ objectLoader, typeChecking: true });
 
     configRoot = objectLoader.createCompactedResource({
       types: 'ex:Component1',

test/unit/preprocess/parameterproperty/ParameterPropertyHandlerRange-test.ts

@@ -33,7 +33,7 @@ describe('ParameterPropertyHandlerRange', () => {
     });
     await objectLoader.context;
     genericsContext = new GenericsContext(objectLoader, []);
-    handler = new ParameterPropertyHandlerRange(objectLoader);
+    handler = new ParameterPropertyHandlerRange(objectLoader, true);
   });
 
   describe('canHandle', () => {
@@ -66,6 +66,17 @@ describe('ParameterPropertyHandlerRange', () => {
         genericsContext,
       )).toThrow(/The value "aaa" for parameter ".*" is not of required range type ".*integer"/u);
     });
+
+    it('does not throw on an invalid value when type-checking is disabled', () => {
+      handler = new ParameterPropertyHandlerRange(objectLoader, false);
+      expect(() => handler.handle(
+        objectLoader.createCompactedResource('"aaa"'),
+        objectLoader.createCompactedResource({}),
+        objectLoader.createCompactedResource({ range: IRIS_XSD.integer }),
+        objectLoader.createCompactedResource({}),
+        genericsContext,
+      )).not.toThrow();
+    });
   });
 
   describe('hasValueType', () => {