@oclif/core 2.0.2-beta.8 → 2.0.3

package/lib/config/config.d.ts

@@ -40,6 +40,7 @@ export declare class Config implements IConfig {
     constructor(options: Options);
     static load(opts?: LoadOptions): Promise<Config>;
     load(): Promise<void>;
+    loadPluginsAndCommands(): Promise<void>;
     loadCorePlugins(): Promise<void>;
     loadDevPlugins(): Promise<void>;
     loadUserPlugins(): Promise<void>;
@@ -106,6 +107,7 @@ export declare class Config implements IConfig {
         detail: string;
     }, scope?: string): void;
     protected get isProd(): boolean;
+    private isJitPluginCommand;
     private getCmdLookupId;
     private getTopicLookupId;
     private loadCommands;

package/lib/config/config.js

@@ -134,6 +134,10 @@ class Config {
                 ...s3.templates && s3.templates.vanilla,
             },
         };
+        await this.loadPluginsAndCommands();
+        debug('config done');
+    }
+    async loadPluginsAndCommands() {
         await this.loadUserPlugins();
         await this.loadDevPlugins();
         await this.loadCorePlugins();
@@ -141,7 +145,6 @@ class Config {
             this.loadCommands(plugin);
             this.loadTopics(plugin);
         }
-        debug('config done');
     }
     async loadCorePlugins() {
         if (this.pjson.oclif.plugins) {
@@ -250,21 +253,44 @@ class Config {
     }
     async runCommand(id, argv = [], cachedCommand = null) {
         debug('runCommand %s %o', id, argv);
-        const c = cachedCommand ?? this.findCommand(id);
+        let c = cachedCommand ?? this.findCommand(id);
         if (!c) {
             const matches = this.flexibleTaxonomy ? this.findMatches(id, argv) : [];
             const hookResult = this.flexibleTaxonomy && matches.length > 0 ?
                 await this.runHook('command_incomplete', { id, argv, matches }) :
                 await this.runHook('command_not_found', { id, argv });
-            if (hookResult.successes[0]) {
-                const cmdResult = hookResult.successes[0].result;
-                return cmdResult;
-            }
-            if (hookResult.failures[0]) {
+            if (hookResult.successes[0])
+                return hookResult.successes[0].result;
+            if (hookResult.failures[0])
                 throw hookResult.failures[0].error;
-            }
             throw new errors_1.CLIError(`command ${id} not found`);
         }
+        if (this.isJitPluginCommand(c)) {
+            const pluginName = c.pluginName;
+            const pluginVersion = this.pjson.oclif.jitPlugins[pluginName];
+            const jitResult = await this.runHook('jit_plugin_not_installed', {
+                id,
+                argv,
+                command: c,
+                pluginName,
+                pluginVersion,
+            });
+            if (jitResult.failures[0])
+                throw jitResult.failures[0].error;
+            if (jitResult.successes[0]) {
+                await this.loadPluginsAndCommands();
+                c = this.findCommand(id) ?? c;
+            }
+            else {
+                // this means that no jit_plugin_not_installed hook exists, so we should run the default behavior
+                const result = await this.runHook('command_not_found', { id, argv });
+                if (result.successes[0])
+                    return result.successes[0].result;
+                if (result.failures[0])
+                    throw result.failures[0].error;
+                throw new errors_1.CLIError(`command ${id} not found`);
+            }
+        }
         const command = await c.load();
         await this.runHook('prerun', { Command: command, argv });
         const result = (await command.run(argv, this));
@@ -487,6 +513,9 @@ class Config {
     get isProd() {
         return (0, util_3.isProd)();
     }
+    isJitPluginCommand(c) {
+        return Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') && !this.plugins.find(p => p.name === c?.pluginName);
+    }
     getCmdLookupId(id) {
         if (this._commands.has(id))
             return id;
@@ -595,6 +624,14 @@ class Config {
             if (a.pluginType === 'core' && b.pluginType !== 'core') {
                 return -1;
             }
+            // if a is a jit plugin and b is not sort b first
+            if (a.pluginType === 'jit' && b.pluginType !== 'jit') {
+                return 1;
+            }
+            // if b is a jit plugin and a is not sort a first
+            if (b.pluginType === 'jit' && a.pluginType !== 'jit') {
+                return -1;
+            }
             // neither plugin is core, so do not change the order
             return 0;
         });

package/lib/config/plugin.js

@@ -127,7 +127,12 @@ class Plugin {
         this.manifest = await this._manifest(Boolean(this.options.ignoreManifest), Boolean(this.options.errorOnManifestCreate));
         this.commands = Object
             .entries(this.manifest.commands)
-            .map(([id, c]) => ({ ...c, pluginAlias: this.alias, pluginType: this.type, load: async () => this.findCommand(id, { must: true }) }))
+            .map(([id, c]) => ({
+            ...c,
+            pluginAlias: this.alias,
+            pluginType: c.pluginType === 'jit' ? 'jit' : this.type,
+            load: async () => this.findCommand(id, { must: true }),
+        }))
             .sort((a, b) => a.id.localeCompare(b.id));
     }
     get topics() {

package/lib/interfaces/hooks.d.ts

@@ -58,6 +58,16 @@ export interface Hooks {
         };
         return: unknown;
     };
+    'jit_plugin_not_installed': {
+        options: {
+            id: string;
+            argv: string[];
+            command: Command.Loadable;
+            pluginName: string;
+            pluginVersion: string;
+        };
+        return: unknown;
+    };
     'plugins:preinstall': {
         options: {
             plugin: {
@@ -84,6 +94,7 @@ export declare namespace Hook {
     type Update = Hook<'update'>;
     type CommandNotFound = Hook<'command_not_found'>;
     type CommandIncomplete = Hook<'command_incomplete'>;
+    type JitPluginNotInstalled = Hook<'jit_plugin_not_installed'>;
     interface Context {
         config: Config;
         exit(code?: number): void;

package/lib/interfaces/pjson.d.ts

@@ -27,6 +27,7 @@ export declare namespace PJSON {
             default?: string;
             plugins?: string[];
             devPlugins?: string[];
+            jitPlugins?: Record<string, string>;
             helpClass?: string;
             helpOptions?: HelpOptions;
             aliases?: {
@@ -83,6 +84,7 @@ export declare namespace PJSON {
             scope?: string;
             dirname?: string;
             flexibleTaxonomy?: boolean;
+            jitPlugins?: Record<string, string>;
         };
     }
     interface User extends PJSON {

package/lib/interfaces/plugin.d.ts

@@ -13,6 +13,7 @@ export interface PluginOptions {
 }
 export interface Options extends PluginOptions {
     devPlugins?: boolean;
+    jitPlugins?: boolean;
     userPlugins?: boolean;
     channel?: string;
     version?: string;

package/lib/parser/errors.d.ts

@@ -1,6 +1,6 @@
 import { CLIError } from '../errors';
 import { OptionFlag, Flag } from '../interfaces';
-import { Arg, ArgInput, CLIParseErrorOptions } from '../interfaces/parser';
+import { Arg, ArgInput, BooleanFlag, CLIParseErrorOptions } from '../interfaces/parser';
 export { CLIError } from '../errors';
 export type Validation = {
     name: string;
@@ -47,6 +47,9 @@ export declare class NonExistentFlagsError extends CLIParseError {
 export declare class FlagInvalidOptionError extends CLIParseError {
     constructor(flag: OptionFlag<any>, input: string);
 }
+export declare class FailedFlagParseError extends CLIParseError {
+    constructor(flag: BooleanFlag<any> | OptionFlag<any>, errMsg: string);
+}
 export declare class ArgInvalidOptionError extends CLIParseError {
     constructor(arg: Arg<any>, input: string);
 }

package/lib/parser/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredFlagError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
+exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FailedFlagParseError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredFlagError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
 const errors_1 = require("../errors");
 const help_1 = require("./help");
 const list_1 = require("../cli-ux/list");
@@ -74,6 +74,13 @@ class FlagInvalidOptionError extends CLIParseError {
     }
 }
 exports.FlagInvalidOptionError = FlagInvalidOptionError;
+class FailedFlagParseError extends CLIParseError {
+    constructor(flag, errMsg) {
+        const message = `Parsing --${flag.name} \n\t${errMsg}`;
+        super({ parse: {}, message });
+    }
+}
+exports.FailedFlagParseError = FailedFlagParseError;
 class ArgInvalidOptionError extends CLIParseError {
     constructor(arg, input) {
         const message = `Expected ${input} to be one of: ${arg.options.join(', ')}`;

package/lib/parser/parse.d.ts

@@ -11,6 +11,7 @@ export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T[
     constructor(input: T);
     parse(): Promise<ParserOutput<TFlags, BFlags, TArgs>>;
     private _flags;
+    private _parseFlag;
     private _validateOptions;
     private _args;
     private _debugOutput;

package/lib/parser/parse.js

@@ -182,13 +182,13 @@ class Parser {
                 else {
                     flags[token.flag] = true;
                 }
-                flags[token.flag] = await flag.parse(flags[token.flag], this.context, flag);
+                flags[token.flag] = await this._parseFlag(flags[token.flag], flag);
             }
             else {
                 const input = token.input;
                 this._validateOptions(flag, input);
                 if (flag.delimiter && flag.multiple) {
-                    const values = await Promise.all(input.split(flag.delimiter).map(async (v) => flag.parse ? flag.parse(v.trim(), this.context, flag) : v.trim()));
+                    const values = await Promise.all(input.split(flag.delimiter).map(async (v) => this._parseFlag(v.trim(), flag)));
                     flags[token.flag] = flags[token.flag] || [];
                     flags[token.flag].push(...values);
                 }
@@ -229,6 +229,17 @@ class Parser {
         }
         return flags;
     }
+    async _parseFlag(input, flag) {
+        try {
+            if (flag.type === 'boolean') {
+                return await flag.parse(input, this.context, flag);
+            }
+            return flag.parse ? await flag.parse(input, this.context, flag) : input;
+        }
+        catch (error) {
+            throw new errors_1.FailedFlagParseError(flag, error.message);
+        }
+    }
     _validateOptions(flag, input) {
         if (flag.options && !flag.options.includes(input))
             throw new errors_1.FlagInvalidOptionError(flag, input);

package/lib/util.js

@@ -94,11 +94,11 @@ const fileExists = async (input) => {
 };
 exports.fileExists = fileExists;
 function isTruthy(input) {
-    return ['true', 'TRUE', '1', 'yes', 'YES', 'y', 'Y'].includes(input);
+    return ['true', '1', 'yes', 'y'].includes(input.toLowerCase());
 }
 exports.isTruthy = isTruthy;
 function isNotFalsy(input) {
-    return !['false', 'FALSE', '0', 'no', 'NO', 'n', 'N'].includes(input);
+    return !['false', '0', 'no', 'n'].includes(input.toLowerCase());
 }
 exports.isNotFalsy = isNotFalsy;
 function requireJson(...pathParts) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "2.0.2-beta.8",
+  "version": "2.0.3",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {