@oclif/core 1.24.2 → 1.25.0

package/lib/config/config.d.ts

@@ -39,6 +39,7 @@ export declare class Config implements IConfig {
     constructor(options: Options);
     static load(opts?: LoadOptions): Promise<IConfig | Config>;
     load(): Promise<void>;
+    loadPluginsAndCommands(): Promise<void>;
     loadCorePlugins(): Promise<void>;
     loadDevPlugins(): Promise<void>;
     loadUserPlugins(): Promise<void>;
@@ -105,6 +106,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

@@ -135,6 +135,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();
@@ -142,7 +146,6 @@ class Config {
             this.loadCommands(plugin);
             this.loadTopics(plugin);
         }
-        debug('config done');
     }
     async loadCorePlugins() {
         if (this.pjson.oclif.plugins) {
@@ -252,25 +255,48 @@ class Config {
     // eslint-disable-next-line default-param-last
     async runCommand(id, argv = [], cachedCommand) {
         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));
-        await this.runHook('postrun', { Command: command, result: result, argv });
+        await this.runHook('postrun', { Command: command, result, argv });
         return result;
     }
     scopedEnvVar(k) {
@@ -489,6 +515,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;
@@ -597,6 +626,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;
         });
@@ -677,10 +714,7 @@ async function toCached(c, plugin) {
             }
         }
     }
-    // v2 commands have args as an object, so we need to normalize it to an array for forwards compatibility
-    // @ts-ignore
-    const normalized = Array.isArray(c.args) ? c.args ?? [] : Object.entries(c.args ?? {}).map(([name, arg]) => ({ ...arg, name }));
-    const argsPromise = normalized.map(async (a) => ({
+    const argsPromise = (0, util_3.ensureArgArray)(c.args).map(async (a) => ({
         name: a.name,
         description: a.description,
         required: a.required,

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/help/command.js

@@ -31,7 +31,7 @@ class CommandHelp extends formatter_1.HelpFormatter {
             v.name = k;
             return v;
         }), f => [!f.char, f.char, f.name]);
-        const args = (cmd.args || []).filter(a => !a.hidden);
+        const args = (0, util_1.ensureArgArray)(cmd.args).filter(a => !a.hidden);
         const output = (0, util_1.compact)(this.sections().map(({ header, generate }) => {
             const body = generate({ cmd, flags, args }, header);
             // Generate can return a list of sections

package/lib/help/docopts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocOpts = void 0;
+const util_1 = require("../util");
 /**
  * DocOpts - See http://docopt.org/.
  *
@@ -75,7 +76,7 @@ class DocOpts {
     toString() {
         const opts = this.cmd.id === '.' || this.cmd.id === '' ? [] : ['<%= command.id %>'];
         if (this.cmd.args) {
-            const a = this.cmd.args?.map(arg => `[${arg.name.toUpperCase()}]`) || [];
+            const a = (0, util_1.ensureArgArray)(this.cmd.args).map(arg => `[${arg.name.toUpperCase()}]`) || [];
             opts.push(...a);
         }
         try {

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/util.d.ts

@@ -1,3 +1,4 @@
+import { ArgInput } from './interfaces';
 export declare function compact<T>(a: (T | undefined)[]): T[];
 export declare function uniqBy<T>(arr: T[], fn: (cur: T) => any): T[];
 type SortTypes = string | number | undefined | boolean;
@@ -7,4 +8,14 @@ export declare function isProd(): boolean;
 export declare function maxBy<T>(arr: T[], fn: (i: T) => number): T | undefined;
 export declare function sumBy<T>(arr: T[], fn: (i: T) => number): number;
 export declare function capitalize(s: string): string;
+/**
+ * Ensure that the args are in an array instead of an object. This is required to ensure
+ * forwards compatibility with the new arg format in v2.
+ *
+ * @param args The args to ensure are in an array
+ * @returns ArgInput
+ */
+export declare function ensureArgArray(args?: ArgInput | {
+    [name: string]: any;
+}): ArgInput;
 export {};

package/lib/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.uniqBy = exports.compact = void 0;
+exports.ensureArgArray = exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.uniqBy = exports.compact = void 0;
 function compact(a) {
     return a.filter((a) => Boolean(a));
 }
@@ -62,3 +62,14 @@ function capitalize(s) {
     return s ? s.charAt(0).toUpperCase() + s.slice(1).toLowerCase() : '';
 }
 exports.capitalize = capitalize;
+/**
+ * Ensure that the args are in an array instead of an object. This is required to ensure
+ * forwards compatibility with the new arg format in v2.
+ *
+ * @param args The args to ensure are in an array
+ * @returns ArgInput
+ */
+function ensureArgArray(args) {
+    return Array.isArray(args) ? args ?? [] : Object.entries(args ?? {}).map(([name, arg]) => ({ ...arg, name }));
+}
+exports.ensureArgArray = ensureArgArray;

package/package.json

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