Propagate original error messages to require calls, Closes #65

Author: rubensworks

lib/construction/strategy/ConstructionStrategyCommonJs.ts

@@ -25,15 +25,15 @@ export class ConstructionStrategyCommonJs implements IConstructionStrategy<any>
   public createInstance(options: ICreationStrategyInstanceOptions<any>): any {
     // Call require()
     options.requireName = this.overrideRequireNames[options.requireName] || options.requireName;
+
+    // First try requiring current module, and fallback to a plain require
     let object: any;
-    try {
-      object = this.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
-    } catch {
-      // Always require relative from main module, because Components.js will in most cases just be dependency.
-      object = this.req(options.requireName.startsWith('.') ?
+    const currentResult = this.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
+    object = currentResult !== false ?
+      currentResult.value :
+      this.req(options.requireName.startsWith('.') ?
         Path.join(process.cwd(), options.requireName) :
         this.req.resolve(options.requireName, { paths: [ options.moduleState.mainModulePath ]}));
-    }
 
     // Determine the child of the require'd element
     let subObject;
@@ -70,18 +70,18 @@ export class ConstructionStrategyCommonJs implements IConstructionStrategy<any>
    * @param requireName The module name that should be required.
    * @returns {any} The require() result
    */
-  public requireCurrentRunningModuleIfCurrent(moduleState: IModuleState, requireName: string): void {
+  public requireCurrentRunningModuleIfCurrent(moduleState: IModuleState, requireName: string): { value: any } | false {
     const pckg = moduleState.packageJsons[moduleState.mainModulePath];
     if (pckg) {
       if (requireName === pckg.name) {
         const mainPath: string = Path.posix.join(moduleState.mainModulePath, pckg.main);
         const required = this.req(mainPath);
         if (required) {
-          return required;
+          return { value: required };
         }
       }
     }
-    throw new Error('Component is not the main module');
+    return false;
   }
 
   public createHash(options: ICreationStrategyHashOptions<any>): any {

lib/construction/strategy/ConstructionStrategyCommonJsString.ts

@@ -44,14 +44,16 @@ export class ConstructionStrategyCommonJsString implements IConstructionStrategy
   public createInstance(options: ICreationStrategyInstanceOptions<string>): string {
     // Call require()
     options.requireName = this.overrideRequireNames[options.requireName] || options.requireName;
-    let resultingRequirePath: string;
-    try {
-      this.strategyCommonJs.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
-      resultingRequirePath = `.${Path.sep}${Path.relative(options.moduleState.mainModulePath,
-        this.getCurrentRunningModuleMain(options.moduleState))}`;
-    } catch {
-      resultingRequirePath = options.requireName;
-    }
+
+    // First try requiring current module, and fallback to a plain require
+    const currentResult = this.strategyCommonJs
+      .requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
+    const resultingRequirePath = currentResult !== false ?
+      `.${Path.sep}${Path.relative(
+        options.moduleState.mainModulePath,
+        this.getCurrentRunningModuleMain(options.moduleState),
+      )}` :
+      options.requireName;
     let serialization = `require('${resultingRequirePath.replace(/\\/gu, '/')}')`;
 
     // Determine the child of the require'd element

test/integration/instantiateFile-test.ts

@@ -18,6 +18,7 @@ describe('construction with component configs as files', () => {
       importPaths: {
         'http://example.org/': `${__dirname}/../`,
       },
+      packageJsons: {},
     };
     jest.clearAllMocks();
   });

test/integration/instantiateResourceConfigComponent-test.ts

@@ -22,6 +22,7 @@ describe('construction with component configs as Resource', () => {
       mainModulePath: `${__dirname}/../../__mocks__`,
       moduleState: <any> {
         mainModulePath: `${__dirname}/../../__mocks__`,
+        packageJsons: {},
       },
       async moduleLoader() {
         // Register nothing

test/integration/instantiateResourceConfigComponentMapped-test.ts

@@ -24,6 +24,7 @@ describe('construction with mapped component configs as Resource', () => {
       mainModulePath: `${__dirname}/../../__mocks__`,
       moduleState: <any> {
         mainModulePath: `${__dirname}/../../__mocks__`,
+        packageJsons: {},
       },
       async moduleLoader() {
         // Register nothing

test/integration/instantiateResourceConfigRaw-test.ts

@@ -22,6 +22,7 @@ describe('construction with component configs as Resource', () => {
       mainModulePath: `${__dirname}/../../__mocks__`,
       moduleState: <any> {
         mainModulePath: `${__dirname}/../../__mocks__`,
+        packageJsons: {},
       },
       async moduleLoader() {
         // Register nothing

test/unit/construction/strategy/ConstructionStrategyCommonJs-test.ts

@@ -267,15 +267,15 @@ describe('ConstructionStrategyCommonJs', () => {
   describe('requireCurrentRunningModuleIfCurrent', () => {
     it('for the current module should require its main entry', () => {
       expect(constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'currentmodule'))
-        .toBe(requireMain);
+        .toEqual({ value: requireMain });
     });
 
-    it('for an unknown package should throw', () => {
-      expect(() => constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'unknownmodule'))
-        .toThrow(new Error('Component is not the main module'));
+    it('for an unknown package should return false', () => {
+      expect(constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'unknownmodule'))
+        .toBe(false);
     });
 
-    it('for a main module path pointing to unknown package should throw', () => {
+    it('for a main module path pointing to unknown package should return false', () => {
       moduleState = {
         componentModules: {},
         contexts: {},
@@ -290,11 +290,11 @@ describe('ConstructionStrategyCommonJs', () => {
           },
         },
       };
-      expect(() => constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'currentmodule'))
-        .toThrow(new Error('Component is not the main module'));
+      expect(constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'currentmodule'))
+        .toBe(false);
     });
 
-    it('for a different package should throw', () => {
+    it('for a different package should return false', () => {
       moduleState = {
         componentModules: {},
         contexts: {},
@@ -309,11 +309,11 @@ describe('ConstructionStrategyCommonJs', () => {
           },
         },
       };
-      expect(() => constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'currentmodule'))
-        .toThrow(new Error('Component is not the main module'));
+      expect(constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'currentmodule'))
+        .toBe(false);
     });
 
-    it('for an invalid main should throw', () => {
+    it('for an empty main should return false', () => {
       moduleState = {
         componentModules: {},
         contexts: {},
@@ -328,8 +328,27 @@ describe('ConstructionStrategyCommonJs', () => {
           },
         },
       };
+      expect(constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'currentmodule'))
+        .toBe(false);
+    });
+
+    it('for an invalid main should throw', () => {
+      moduleState = {
+        componentModules: {},
+        contexts: {},
+        importPaths: {},
+        mainModulePath: 'mainmodulepath',
+        nodeModuleImportPaths: [],
+        nodeModulePaths: [],
+        packageJsons: {
+          mainmodulepath: {
+            name: 'currentmodule',
+            main: 'INVALID',
+          },
+        },
+      };
       expect(() => constructionStrategy.requireCurrentRunningModuleIfCurrent(moduleState, 'currentmodule'))
-        .toThrow(new Error('Component is not the main module'));
+        .toThrow(new Error('Invalid require'));
     });
   });