Improve esm support.

lib/command.js

@@ -64,10 +64,8 @@ module.exports = cls => class EnvironmentCommand extends cls {
     const generator = await this.create(namespace.namespace, {help: true});
     EnvironmentCommand.addGeneratorOptions(namespaceCommand, generator);
 
-    namespaceCommand.action(async function () {
-      debug('Running generator with arguments %o, options %o', this.args, this.opts());
-      return env.run([namespace.namespace, ...this.args], {...this.opts()});
-    });
     namespaceCommand._parseCommand([], args);
+    debug('Running generator with arguments %o, options %o', namespaceCommand.args, namespaceCommand.opts());
+    return env.run([namespace.namespace, ...namespaceCommand.args], {...namespaceCommand.opts()});
   }
 };

lib/environment.js

@@ -673,16 +673,28 @@ class Environment extends Base {
     if (!Generator) {
       return Generator;
     }
+    let meta = Generator;
+    if (Array.isArray(Generator)) {
+      meta = Generator[1];
+      Generator = Generator[0];
+    }
     if (typeof Generator.default === 'function') {
-      Generator.default.resolved = Generator.resolved;
-      Generator.default.namespace = Generator.namespace;
+      Generator.default.resolved = meta.resolved;
+      Generator.default.namespace = meta.namespace;
       return Generator.default;
     }
     if (typeof Generator.createGenerator === 'function') {
-      const Gen = Generator.createGenerator(this);
-      Gen.resolved = Generator.resolved;
-      Gen.namespace = Generator.namespace;
-      return Gen;
+      const maybeGenerator = Generator.createGenerator(this);
+      if (maybeGenerator.then) {
+        return maybeGenerator.then(Gen => {
+          Gen.resolved = meta.resolved;
+          Gen.namespace = meta.namespace;
+          return Gen;
+        });
+      }
+      maybeGenerator.resolved = meta.resolved;
+      maybeGenerator.namespace = meta.namespace;
+      return maybeGenerator;
     }
     if (typeof Generator !== 'function') {
       throw new TypeError('The generator doesn\'t provides a constructor.');
@@ -999,8 +1011,9 @@ class Environment extends Base {
    *
    * @param {Object}       generator
    */
-  runGenerator(generator) {
+  async runGenerator(generator) {
     try {
+      generator = await generator;
       generator = this.queueGenerator(generator);
     } catch (error) {
       return Promise.reject(error);

lib/store.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const debug = require('debug')('yeoman:environment:store');
-const path = require('path');
-const {pathToFileURL} = require('url');
+
+const {requireOrImport} = require('./util/esm');
 
 /**
  * The Generator store
@@ -46,22 +46,7 @@ class Store {
 
     Object.defineProperty(this._generators, namespace, {
       get() {
-        if (path.extname(resolvedPath) === '.cjs') {
-          return require(resolvedPath);
-        }
-        if (path.extname(resolvedPath) === '.mjs') {
-          // eslint-disable-next-line node/no-unsupported-features/es-syntax
-          return import(pathToFileURL(resolvedPath));
-        }
-        try {
-          return require(resolvedPath);
-        } catch (error) {
-          if (error.code !== 'ERR_REQUIRE_ESM') {
-            throw error;
-          }
-          // eslint-disable-next-line node/no-unsupported-features/es-syntax
-          return import(pathToFileURL(resolvedPath));
-        }
+        return requireOrImport(resolvedPath);
       },
       enumerable: true,
       configurable: true
@@ -90,17 +75,13 @@ class Store {
       return;
     }
 
-    // Assign even to Promises for sync compatibility
-    Object.assign(maybeGenerator, this._meta[namespace]);
-
     if (maybeGenerator.then) {
       return maybeGenerator.then(esmGenerator => {
-        const Generator = esmGenerator.default;
-        Object.assign(Generator, this._meta[namespace]);
-        return Generator;
+        return [esmGenerator, {...this._meta[namespace]}];
       });
     }
 
+    Object.assign(maybeGenerator, this._meta[namespace]);
     return maybeGenerator;
   }
 

lib/util/esm.js

@@ -0,0 +1,23 @@
+const path = require('path');
+const {pathToFileURL} = require('url');
+
+module.exports = {
+  requireOrImport(fileToImport) {
+    if (path.extname(fileToImport) === '.cjs') {
+      return require(fileToImport);
+    }
+    if (path.extname(fileToImport) === '.mjs') {
+      // eslint-disable-next-line node/no-unsupported-features/es-syntax
+      return import(pathToFileURL(fileToImport));
+    }
+    try {
+      return require(fileToImport);
+    } catch (error) {
+      if (error.code !== 'ERR_REQUIRE_ESM') {
+        throw error;
+      }
+      // eslint-disable-next-line node/no-unsupported-features/es-syntax
+      return import(pathToFileURL(fileToImport));
+    }
+  }
+};

lib/util/repository.js

@@ -7,6 +7,7 @@ const debug = require('debug')('yeoman:environment:repository');
 const Arborist = require('@npmcli/arborist');
 
 const logger = require('./log');
+const {requireOrImport} = require('./esm');
 
 const REPOSITORY_FOLDER = '.yo-repository';
 
@@ -223,7 +224,7 @@ class YeomanRepository {
     }
     const absolutePath = this.resolvePackagePath(packageName, modulePath);
     debug('Loading module at %s', absolutePath);
-    return require(absolutePath);
+    return requireOrImport(absolutePath);
   }
 }
 

test/environment.js

@@ -20,8 +20,15 @@ const GROUPED_QUEUE_VERSION = require('grouped-queue/package.json').version;
 const sinonTest = sinonTestFactory(sinon);
 
 describe('Environment', () => {
+  let mockedDefault;
+  let MockedGenerator;
+
   beforeEach(function () {
     this.env = new Environment({skipInstall: true, sharedOptions: {sharedConstructorData: {}}});
+
+    MockedGenerator = class MockedGenerator extends Generator {};
+    mockedDefault = sinon.stub();
+    MockedGenerator.prototype.mockedDefault = mockedDefault;
   });
 
   afterEach(function () {
@@ -514,6 +521,34 @@ describe('Environment', () => {
         });
       });
     });
+    describe('with createGenerator', () => {
+      beforeEach(async function () {
+        this.env.registerStub(MockedGenerator, 'mocked-generator');
+        this.env
+          .register(path.join(__dirname, './fixtures/generator-esm/generators/create/index.js'), 'esm:create');
+      });
+
+      it('runs a registered generator', function () {
+        return this.env.run(['esm:create']).then(() => {
+          assert.ok(mockedDefault.calledOnce);
+        });
+      });
+    });
+    describe('with inherited createGenerator', () => {
+      beforeEach(async function () {
+        this.env.registerStub(MockedGenerator, 'mocked-generator');
+        this.env
+          .register(path.join(__dirname, './fixtures/generator-esm/generators/create/index.js'), 'esm:create');
+        this.env
+          .register(path.join(__dirname, './fixtures/generator-esm/generators/create-inherited/index.js'), 'esm:create-inherited');
+      });
+
+      it('runs a registered generator', function () {
+        return this.env.run(['esm:create-inherited']).then(() => {
+          assert.ok(mockedDefault.calledOnce);
+        });
+      });
+    });
   });
 
   describe('#registerModulePath()', () => {

test/fixtures/generator-esm/generators/create-inherited/index.js

@@ -0,0 +1,8 @@
+export async function createGenerator(env) {
+  const ParentGenerator = await env.requireGenerator('esm:create');
+  return class NewGenerator extends ParentGenerator {
+    default() {
+      super.mockedDefault();
+    }
+  };
+}

test/fixtures/generator-esm/generators/create/index.js

@@ -0,0 +1,8 @@
+export async function createGenerator(env) {
+  const ParentGenerator = await env.requireGenerator('mocked-generator');
+  return class NewGenerator extends ParentGenerator {
+    default() {
+      super.mockedDefault();
+    }
+  };
+}