@oclif/core 3.0.0-beta.1 → 3.0.0-beta.2

package/lib/config/config.d.ts

@@ -39,8 +39,10 @@ export declare class Config implements IConfig {
     private _commands;
     private _topics;
     private _commandIDs;
+    private static _rootPlugin;
     constructor(options: Options);
     static load(opts?: LoadOptions): Promise<Config>;
+    static get rootPlugin(): Plugin.Plugin | undefined;
     load(): Promise<void>;
     loadPluginsAndCommands(): Promise<void>;
     loadCorePlugins(): Promise<void>;
@@ -104,6 +106,7 @@ export declare class Config implements IConfig {
     get versionDetails(): VersionDetails;
     s3Key(type: keyof PJSON.S3.Templates, ext?: '.tar.gz' | '.tar.xz' | IConfig.s3Key.Options, options?: IConfig.s3Key.Options): string;
     s3Url(key: string): string;
+    getPluginsList(): IPlugin[];
     protected dir(category: 'cache' | 'data' | 'config'): string;
     protected windowsHome(): string | undefined;
     protected windowsHomedriveHome(): string | undefined;

package/lib/config/config.js

@@ -83,11 +83,15 @@ class Config {
         await config.load();
         return config;
     }
+    static get rootPlugin() {
+        return Config._rootPlugin;
+    }
     // eslint-disable-next-line complexity
     async load() {
         settings_1.settings.performanceEnabled = (settings_1.settings.performanceEnabled === undefined ? this.options.enablePerf : settings_1.settings.performanceEnabled) ?? false;
         const plugin = new Plugin.Plugin({ root: this.options.root });
         await plugin.load();
+        Config._rootPlugin = plugin;
         this.plugins.push(plugin);
         this.root = plugin.root;
         this.pjson = plugin.pjson;
@@ -460,6 +464,9 @@ class Config {
         url.pathname = path.join(url.pathname, key);
         return url.toString();
     }
+    getPluginsList() {
+        return this.plugins;
+    }
     dir(category) {
         const base = process.env[`XDG_${category.toUpperCase()}_HOME`] ||
             (this.windows && process.env.LOCALAPPDATA) ||

package/lib/config/plugin.d.ts

@@ -11,6 +11,7 @@ export declare class Plugin implements IPlugin {
     version: string;
     pjson: PJSON.Plugin;
     type: string;
+    moduleType: 'module' | 'commonjs';
     root: string;
     alias: string;
     tag?: string;

package/lib/config/plugin.js

@@ -115,6 +115,7 @@ class Plugin {
         this.root = root;
         this._debug('reading %s plugin %s', this.type, root);
         this.pjson = await (0, util_3.loadJSON)(path.join(root, 'package.json'));
+        this.moduleType = this.pjson.type === 'module' ? 'module' : 'commonjs';
         this.name = this.pjson.name;
         this.alias = this.options.name ?? this.pjson.name;
         const pjsonPath = path.join(root, 'package.json');
@@ -149,7 +150,7 @@ class Plugin {
     get commandsDir() {
         if (this._commandsDir)
             return this._commandsDir;
-        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this.type);
+        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
         return this._commandsDir;
     }
     get commandIDs() {

package/lib/config/ts-node.d.ts

@@ -1,7 +1,8 @@
+import { Plugin } from '../interfaces';
 /**
  * Convert a path from the compiled ./lib files to the ./src typescript source
  * this is for developing typescript plugins/CLIs
  * if there is a tsconfig and the original sources exist, it attempts to require ts-node
  */
-export declare function tsPath(root: string, orig: string, type?: string): string;
-export declare function tsPath(root: string, orig: string | undefined, type?: string): string | undefined;
+export declare function tsPath(root: string, orig: string, plugin: Plugin): string;
+export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin): string | undefined;

package/lib/config/ts-node.js

@@ -6,11 +6,15 @@ const path = require("path");
 const settings_1 = require("../settings");
 const util_1 = require("../util");
 const util_2 = require("./util");
+const config_1 = require("./config");
+const errors_1 = require("../errors");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)('ts-node');
-const TYPE_ROOTS = [`${__dirname}/../node_modules/@types`];
-const ROOT_DIRS = [];
+const TS_CONFIGS = {};
+const REGISTERED = new Set();
 function loadTSConfig(root) {
+    if (TS_CONFIGS[root])
+        return TS_CONFIGS[root];
     const tsconfigPath = path.join(root, 'tsconfig.json');
     let typescript;
     try {
@@ -18,7 +22,7 @@ function loadTSConfig(root) {
     }
     catch {
         try {
-            typescript = require(root + '/node_modules/typescript');
+            typescript = require(path.join(root, 'node_modules', 'typescript'));
         }
         catch { }
     }
@@ -28,6 +32,7 @@ function loadTSConfig(root) {
             throw new Error(`Could not read and parse tsconfig.json at ${tsconfigPath}, or it ` +
                 'did not contain a "compilerOptions" section.');
         }
+        TS_CONFIGS[root] = tsconfig;
         return tsconfig;
     }
 }
@@ -35,54 +40,96 @@ function registerTSNode(root) {
     const tsconfig = loadTSConfig(root);
     if (!tsconfig)
         return;
+    if (REGISTERED.has(root))
+        return tsconfig;
     debug('registering ts-node at', root);
     const tsNodePath = require.resolve('ts-node', { paths: [root, __dirname] });
+    debug('ts-node path:', tsNodePath);
     const tsNode = require(tsNodePath);
-    TYPE_ROOTS.push(`${root}/node_modules/@types`);
+    const typeRoots = [
+        path.join(root, 'node_modules', '@types'),
+    ];
+    const rootDirs = [];
     if (tsconfig.compilerOptions.rootDirs) {
-        ROOT_DIRS.push(...tsconfig.compilerOptions.rootDirs.map(r => path.join(root, r)));
+        for (const r of tsconfig.compilerOptions.rootDirs) {
+            rootDirs.push(path.join(root, r));
+        }
+    }
+    else if (tsconfig.compilerOptions.rootDir) {
+        rootDirs.push(path.join(root, tsconfig.compilerOptions.rootDir));
     }
     else {
-        ROOT_DIRS.push(`${root}/src`);
+        rootDirs.push(path.join(root, 'src'));
     }
-    const cwd = process.cwd();
-    try {
-        process.chdir(root);
-        tsNode.register({
-            skipProject: true,
-            transpileOnly: true,
-            compilerOptions: {
-                esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
-                target: tsconfig.compilerOptions.target || 'es2017',
-                experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators || false,
-                emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata || false,
-                module: 'commonjs',
-                sourceMap: true,
-                rootDirs: ROOT_DIRS,
-                typeRoots: TYPE_ROOTS,
-                jsx: 'react',
-            },
-        });
-        return tsconfig;
+    const conf = {
+        compilerOptions: {
+            esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
+            target: tsconfig.compilerOptions.target ?? 'es2019',
+            experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators ?? false,
+            emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata ?? false,
+            module: tsconfig.compilerOptions.module ?? 'commonjs',
+            sourceMap: tsconfig.compilerOptions.sourceMap ?? true,
+            rootDirs,
+            typeRoots,
+        },
+        skipProject: true,
+        transpileOnly: true,
+        esm: tsconfig['ts-node']?.esm ?? true,
+        scope: true,
+        scopeDir: root,
+        cwd: root,
+        experimentalSpecifierResolution: tsconfig['ts-node']?.experimentalSpecifierResolution ?? 'explicit',
+    };
+    if (tsconfig.compilerOptions.moduleResolution) {
+        // @ts-expect-error TSNode.RegisterOptions.compilerOptions is typed as a plain object
+        conf.compilerOptions.moduleResolution = tsconfig.compilerOptions.moduleResolution;
     }
-    finally {
-        process.chdir(cwd);
+    if (tsconfig.compilerOptions.jsx) {
+        // @ts-expect-error TSNode.RegisterOptions.compilerOptions is typed as a plain object
+        conf.compilerOptions.jsx = tsconfig.compilerOptions.jsx;
     }
+    tsNode.register(conf);
+    REGISTERED.add(root);
+    return tsconfig;
 }
-function tsPath(root, orig, type) {
+// eslint-disable-next-line complexity
+function tsPath(root, orig, plugin) {
     if (!orig)
         return orig;
     orig = orig.startsWith(root) ? orig : path.join(root, orig);
-    const skipTSNode = 
-    // the CLI specifically turned it off
-    (settings_1.settings.tsnodeEnabled === false) ||
-        // the CLI didn't specify ts-node and it is production
-        (settings_1.settings.tsnodeEnabled === undefined && (0, util_1.isProd)());
-    // We always want to load the tsconfig for linked plugins.
-    if (skipTSNode && type !== 'link')
+    // NOTE: The order of these checks matter!
+    if (settings_1.settings.tsnodeEnabled === false) {
+        debug(`Skipping ts-node registration for ${root} because tsNodeEnabled is explicitly set to false`);
+        return orig;
+    }
+    // Skip ts-node registration if plugin is an ESM plugin executing from a CJS plugin
+    if (plugin?.moduleType === 'module' && config_1.Config.rootPlugin?.moduleType === 'commonjs') {
+        debug(`Skipping ts-node registration for ${root} because it's an ESM module but the root plugin is CommonJS`);
+        if (plugin.type === 'link')
+            (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-compiled from a CommonJS root plugin. Existing compiled source will be used instead.`);
         return orig;
+    }
+    // If plugin is an ESM plugin being executed from an ESM root plugin, check to see if ts-node/esm loader has been set
+    // either in the NODE_OPTIONS env var or from the exec args. If the ts-node/esm loader has NOT been loaded then we want
+    // to skip ts-node registration so that it falls back on the compiled source.
+    if (plugin?.moduleType === 'module') {
+        const tsNodeEsmLoaderInExecArgv = process.execArgv.includes('--loader') && process.execArgv.includes('ts-node/esm');
+        const tsNodeEsmLoaderInNodeOptions = process.env.NODE_OPTIONS?.includes('--loader=ts-node/esm') ?? false;
+        if (!tsNodeEsmLoaderInExecArgv && !tsNodeEsmLoaderInNodeOptions) {
+            debug(`Skipping ts-node registration for ${root} because it's an ESM module but the ts-node/esm loader hasn't been run`);
+            debug('try setting NODE_OPTIONS="--loader ts-node/esm" in your environment.');
+            if (plugin.type === 'link') {
+                (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-compiled without setting NODE_OPTIONS="--loader=ts-node/esm" in the environment. Existing compiled source will be used instead.`);
+            }
+            return orig;
+        }
+    }
+    if (settings_1.settings.tsnodeEnabled === undefined && (0, util_1.isProd)() && plugin?.type !== 'link') {
+        debug(`Skipping ts-node registration for ${root} because NODE_ENV is NOT "test" or "development"`);
+        return orig;
+    }
     try {
-        const tsconfig = type === 'link' ? registerTSNode(root) : loadTSConfig(root);
+        const tsconfig = registerTSNode(root);
         if (!tsconfig)
             return orig;
         const { rootDir, rootDirs, outDir } = tsconfig.compilerOptions;

package/lib/errors/errors/cli.d.ts

@@ -8,6 +8,7 @@ export declare function addOclifExitCode(error: Record<string, any>, options?: {
 export declare class CLIError extends Error implements OclifError {
     oclif: OclifError['oclif'];
     code?: string;
+    suggestions?: string[];
     constructor(error: string | Error, options?: {
         exit?: number | false;
     } & PrettyPrintableError);

package/lib/errors/errors/cli.js

@@ -24,6 +24,7 @@ class CLIError extends Error {
         this.oclif = {};
         addOclifExitCode(this, options);
         this.code = options.code;
+        this.suggestions = options.suggestions;
     }
     get stack() {
         return cs(super.stack, { pretty: true });

package/lib/errors/index.d.ts

@@ -14,3 +14,4 @@ export declare function error(input: string | Error, options?: {
     exit?: number;
 } & PrettyPrintableError): never;
 export declare function warn(input: string | Error): void;
+export declare function memoizedWarn(input: string | Error): void;

package/lib/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warn = exports.error = exports.exit = exports.config = exports.Logger = exports.CLIError = exports.ModuleLoadError = exports.ExitError = exports.handle = void 0;
+exports.memoizedWarn = exports.warn = exports.error = exports.exit = exports.config = exports.Logger = exports.CLIError = exports.ModuleLoadError = exports.ExitError = exports.handle = void 0;
 var handle_1 = require("./handle");
 Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
 var exit_1 = require("./errors/exit");
@@ -60,3 +60,10 @@ function warn(input) {
         config_2.config.errorLogger.log(err?.stack ?? '');
 }
 exports.warn = warn;
+const WARNINGS = new Set();
+function memoizedWarn(input) {
+    if (!WARNINGS.has(input))
+        warn(input);
+    WARNINGS.add(input);
+}
+exports.memoizedWarn = memoizedWarn;

package/lib/interfaces/config.d.ts

@@ -135,6 +135,7 @@ export interface Config {
     s3Url(key: string): string;
     s3Key(type: 'versioned' | 'unversioned', ext: '.tar.gz' | '.tar.xz', options?: Config.s3Key.Options): string;
     s3Key(type: keyof PJSON.S3.Templates, options?: Config.s3Key.Options): string;
+    getPluginsList(): Plugin[];
 }
 export declare namespace Config {
     namespace s3Key {

package/lib/interfaces/pjson.d.ts

@@ -12,6 +12,7 @@ export interface PJSON {
         bin?: string;
         dirname?: string;
         hooks?: Record<string, string | string[]>;
+        plugins?: string[];
     };
 }
 export declare namespace PJSON {

package/lib/interfaces/plugin.d.ts

@@ -49,6 +49,10 @@ export interface Plugin {
      * examples: core, link, user, dev
      */
     type: string;
+    /**
+     * Plugin is written in ESM or CommonJS
+     */
+    moduleType: 'module' | 'commonjs';
     /**
      * base path of plugin
      */

package/lib/interfaces/ts-config.d.ts

@@ -7,5 +7,14 @@ export interface TSConfig {
         esModuleInterop?: boolean;
         experimentalDecorators?: boolean;
         emitDecoratorMetadata?: boolean;
+        module?: string;
+        moduleResolution?: string;
+        sourceMap?: boolean;
+        jsx?: boolean;
+    };
+    'ts-node'?: {
+        esm?: boolean;
+        experimentalSpecifierResolution?: 'node' | 'explicit';
+        scope?: boolean;
     };
 }

package/lib/main.d.ts

@@ -11,46 +11,41 @@ export declare function run(argv?: string[], options?: Interfaces.LoadOptions):
  *
  * @example For ESM dev.js
  * ```
- * #!/usr/bin/env ts-node
- * // eslint-disable-next-line node/shebang
+ * #!/usr/bin/env node
  * (async () => {
  *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', development: true, dir: import.meta.url})
+ *   await oclif.execute({development: true, dir: import.meta.url})
  * })()
  * ```
  *
  * @example For ESM run.js
  * ```
  * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
  * (async () => {
  *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', dir: import.meta.url})
+ *   await oclif.execute({dir: import.meta.url})
  * })()
  * ```
  *
  * @example For CJS dev.js
  * ```
  * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
  * (async () => {
  *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', development: true, dir: __dirname})
+ *   await oclif.execute({development: true, dir: __dirname})
  * })()
  * ```
  *
  * @example For CJS run.js
  * ```
  * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
  * (async () => {
  *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', dir: import.meta.url})
+ *   await oclif.execute({dir: __dirname})
  * })()
  * ```
  */
 export declare function execute(options: {
-    type: 'cjs' | 'esm';
     dir: string;
     args?: string[];
     loadOptions?: Interfaces.LoadOptions;

package/lib/main.js

@@ -8,9 +8,9 @@ const config_1 = require("./config");
 const help_1 = require("./help");
 const settings_1 = require("./settings");
 const _1 = require(".");
-const path_1 = require("path");
 const stream_1 = require("./cli-ux/stream");
 const performance_1 = require("./performance");
+const debug = require('debug')('oclif:main');
 const log = (message = '', ...args) => {
     message = typeof message === 'string' ? message : (0, util_1.inspect)(message);
     stream_1.stdout.write((0, util_1.format)(message, ...args) + '\n');
@@ -45,6 +45,9 @@ async function run(argv, options) {
         await performance_1.Performance.collect();
         performance_1.Performance.debug();
     };
+    debug(`process.execPath: ${process.execPath}`);
+    debug(`process.execArgv: ${process.execArgv}`);
+    debug('process.argv: %O', process.argv);
     argv = argv ?? process.argv.slice(2);
     // Handle the case when a file URL string or URL is passed in such as 'import.meta.url'; covert to file path.
     if (options && ((typeof options === 'string' && options.startsWith('file://')) || options instanceof url_2.URL)) {
@@ -93,9 +96,6 @@ async function run(argv, options) {
     }
 }
 exports.run = run;
-function getTsConfigPath(dir, type) {
-    return type === 'cjs' ? (0, path_1.join)(dir, '..', 'tsconfig.json') : (0, path_1.join)((0, path_1.dirname)((0, url_1.fileURLToPath)(dir)), '..', 'tsconfig.json');
-}
 /**
  * Load and run oclif CLI
  *
@@ -104,41 +104,37 @@ function getTsConfigPath(dir, type) {
  *
  * @example For ESM dev.js
  * ```
- * #!/usr/bin/env ts-node
- * // eslint-disable-next-line node/shebang
+ * #!/usr/bin/env node
  * (async () => {
  *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', development: true, dir: import.meta.url})
+ *   await oclif.execute({development: true, dir: import.meta.url})
  * })()
  * ```
  *
  * @example For ESM run.js
  * ```
  * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
  * (async () => {
  *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', dir: import.meta.url})
+ *   await oclif.execute({dir: import.meta.url})
  * })()
  * ```
  *
  * @example For CJS dev.js
  * ```
  * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
  * (async () => {
  *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', development: true, dir: __dirname})
+ *   await oclif.execute({development: true, dir: __dirname})
  * })()
  * ```
  *
  * @example For CJS run.js
  * ```
  * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
  * (async () => {
  *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', dir: import.meta.url})
+ *   await oclif.execute({dir: __dirname})
  * })()
  * ```
  */
@@ -146,9 +142,6 @@ async function execute(options) {
     if (options.development) {
         // In dev mode -> use ts-node and dev plugins
         process.env.NODE_ENV = 'development';
-        require('ts-node').register({
-            project: getTsConfigPath(options.dir, options.type),
-        });
         settings_1.settings.debug = true;
     }
     await run(options.args ?? process.argv.slice(2), options.loadOptions ?? options.dir)

package/lib/module-loader.js

@@ -4,13 +4,16 @@ const path = require("path");
 const url = require("url");
 const fs = require("fs-extra");
 const errors_1 = require("./errors");
-const Config = require("./config");
+const config_1 = require("./config");
 const getPackageType = require('get-package-type');
 /**
  * Defines file extension resolution when source files do not have an extension.
  */
 // eslint-disable-next-line camelcase
 const s_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs'];
+const isPlugin = (config) => {
+    return config.type !== undefined;
+};
 /**
  * Provides a static class with several utility methods to work with Oclif config / plugin to load ESM or CJS Node
  * modules and source files.
@@ -120,15 +123,12 @@ class ModuleLoader {
     static resolvePath(config, modulePath) {
         let isESM;
         let filePath;
-        const isPlugin = (config) => {
-            return config.type !== undefined;
-        };
         try {
             filePath = require.resolve(modulePath);
             isESM = ModuleLoader.isPathModule(filePath);
         }
         catch {
-            filePath = isPlugin(config) ? Config.tsPath(config.root, modulePath, config.type) : Config.tsPath(config.root, modulePath);
+            filePath = (isPlugin(config) ? (0, config_1.tsPath)(config.root, modulePath, config) : (0, config_1.tsPath)(config.root, modulePath)) ?? modulePath;
             let fileExists = false;
             let isDirectory = false;
             if (fs.existsSync(filePath)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.2",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
@@ -66,13 +66,14 @@
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "commitlint": "^12.1.4",
+    "cross-env": "^7.0.3",
     "eslint": "^7.32.0",
     "eslint-config-oclif": "^4.0.0",
     "eslint-config-oclif-typescript": "^1.0.3",
     "fancy-test": "^2.0.16",
     "globby": "^11.1.0",
     "husky": "6",
-    "mocha": "^8.4.0",
+    "mocha": "^10.2.0",
     "nock": "^13.3.0",
     "proxyquire": "^2.1.3",
     "shelljs": "^0.8.5",
@@ -110,14 +111,15 @@
   "scripts": {
     "build": "shx rm -rf lib && tsc",
     "commitlint": "commitlint",
+    "compile": "tsc",
     "lint": "eslint . --ext .ts --config .eslintrc",
     "posttest": "yarn lint",
-    "compile": "tsc",
     "prepack": "yarn run build",
-    "test": "mocha --forbid-only \"test/**/*.test.ts\"",
-    "test:e2e": "mocha --forbid-only \"test/**/*.e2e.ts\" --timeout 1200000",
     "pretest": "yarn build --noEmit && tsc -p test --noEmit --skipLibCheck",
-    "test:perf": "ts-node test/perf/parser.perf.ts"
+    "test:e2e": "mocha --forbid-only \"test/**/*.e2e.ts\" --parallel --timeout 1200000",
+    "test:esm-cjs": "cross-env DEBUG=e2e:* ts-node test/integration/esm-cjs.ts",
+    "test:perf": "ts-node test/perf/parser.perf.ts",
+    "test": "mocha --forbid-only \"test/**/*.test.ts\""
   },
   "types": "lib/index.d.ts"
 }