@adonisjs/core 6.1.5-9 → 6.2.0

package/build/commands/make/controller.js

@@ -12,8 +12,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args, flags } from '../../modules/ace/main.js';
+import string from '@poppinss/utils/string';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, flags, BaseCommand } from '../../modules/ace/main.js';
 /**
  * The make controller command to create an HTTP controller
  */
@@ -28,27 +29,46 @@ export default class MakeController extends BaseCommand {
      * Preparing the command state
      */
     async prepare() {
+        /**
+         * Use actions stub
+         */
+        if (this.actions) {
+            this.stubPath = 'make/controller/actions.stub';
+        }
         /**
          * Use resource stub
          */
         if (this.resource) {
-            this.stubPath = 'make/controller/resource.stub';
+            if (this.actions) {
+                this.logger.warning('Cannot use --resource flag with actions. Ignoring --resource');
+            }
+            else {
+                this.stubPath = 'make/controller/resource.stub';
+            }
         }
         /**
          * Use api stub
          */
         if (this.api) {
-            this.stubPath = 'make/controller/api.stub';
+            if (this.actions) {
+                this.logger.warning('Cannot use --api flag with actions. Ignoring --api');
+            }
+            else {
+                this.stubPath = 'make/controller/api.stub';
+            }
         }
         /**
          * Log warning when both flags are used together
          */
-        if (this.resource && this.api) {
+        if (this.resource && this.api && !this.actions) {
             this.logger.warning('--api and --resource flags cannot be used together. Ignoring --resource');
         }
     }
     async run() {
-        await this.generate(this.stubPath, {
+        const codemods = await this.createCodemods();
+        await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
+            actions: this.actions?.map((action) => string.camelCase(action)),
             entity: this.app.generators.createEntity(this.name),
         });
     }
@@ -56,21 +76,24 @@ export default class MakeController extends BaseCommand {
 __decorate([
     args.string({ description: 'The name of the controller' })
 ], MakeController.prototype, "name", void 0);
+__decorate([
+    args.spread({ description: 'Create controller with custom method names', required: false })
+], MakeController.prototype, "actions", void 0);
 __decorate([
     flags.boolean({
-        description: 'Convert controller class and file name to its singular form',
-        alias: 'r',
+        description: 'Generate controller in singular form',
+        alias: 's',
     })
 ], MakeController.prototype, "singular", void 0);
 __decorate([
     flags.boolean({
-        description: 'Generate controller with resource actions',
+        description: 'Generate controller with methods to perform CRUD actions on a resource',
         alias: 'r',
     })
 ], MakeController.prototype, "resource", void 0);
 __decorate([
     flags.boolean({
-        description: 'Generate controller with api resource actions',
+        description: 'Generate resourceful controller with the "edit" and the "create" methods',
         alias: 'a',
     })
 ], MakeController.prototype, "api", void 0);

package/build/commands/make/event.d.ts

@@ -1,4 +1,4 @@
-import BaseCommand from './_base.js';
+import { BaseCommand } from '../../modules/ace/main.js';
 /**
  * The make event command to create a class based event
  */

package/build/commands/make/event.js

@@ -12,8 +12,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args } from '../../modules/ace/main.js';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, BaseCommand } from '../../modules/ace/main.js';
 /**
  * The make event command to create a class based event
  */
@@ -25,7 +25,9 @@ export default class MakeEvent extends BaseCommand {
      */
     stubPath = 'make/event/main.stub';
     async run() {
-        await this.generate(this.stubPath, {
+        const codemods = await this.createCodemods();
+        await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
             entity: this.app.generators.createEntity(this.name),
         });
     }

package/build/commands/make/exception.d.ts

@@ -1,4 +1,4 @@
-import BaseCommand from './_base.js';
+import { BaseCommand } from '../../modules/ace/main.js';
 /**
  * Make a new exception class
  */

package/build/commands/make/exception.js

@@ -12,20 +12,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args } from '../../modules/ace/main.js';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, BaseCommand } from '../../modules/ace/main.js';
 /**
  * Make a new exception class
  */
 export default class MakeException extends BaseCommand {
     static commandName = 'make:exception';
-    static description = 'Create a new ace exception class';
+    static description = 'Create a new custom exception class';
     /**
      * The stub to use for generating the command class
      */
     stubPath = 'make/exception/main.stub';
     async run() {
-        await this.generate(this.stubPath, {
+        const codemods = await this.createCodemods();
+        await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
             entity: this.app.generators.createEntity(this.name),
         });
     }

package/build/commands/make/listener.d.ts

@@ -1,4 +1,4 @@
-import BaseCommand from './_base.js';
+import { BaseCommand } from '../../modules/ace/main.js';
 /**
  * The make listener command to create a class based event
  * listener

package/build/commands/make/listener.js

@@ -12,8 +12,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args, flags } from '../../modules/ace/main.js';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, flags, BaseCommand } from '../../modules/ace/main.js';
 /**
  * The make listener command to create a class based event
  * listener
@@ -31,6 +31,7 @@ export default class MakeListener extends BaseCommand {
         }
     }
     async run() {
+        const codemods = await this.createCodemods();
         if (this.event) {
             const { exitCode } = await this.kernel.exec('make:event', [this.event]);
             /**
@@ -38,20 +39,22 @@ export default class MakeListener extends BaseCommand {
              */
             if (exitCode === 0) {
                 const eventEntity = this.app.generators.createEntity(this.event);
-                await this.generate(this.stubPath, {
-                    entity: this.app.generators.createEntity(this.name),
+                await codemods.makeUsingStub(stubsRoot, this.stubPath, {
                     event: eventEntity,
+                    flags: this.parsed.flags,
+                    entity: this.app.generators.createEntity(this.name),
                 });
             }
             return;
         }
-        await this.generate(this.stubPath, {
+        await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
             entity: this.app.generators.createEntity(this.name),
         });
     }
 }
 __decorate([
-    args.string({ description: 'Name of the listener' })
+    args.string({ description: 'Name of the event listener' })
 ], MakeListener.prototype, "name", void 0);
 __decorate([
     flags.string({

package/build/commands/make/middleware.d.ts

@@ -1,4 +1,4 @@
-import BaseCommand from './_base.js';
+import { BaseCommand } from '../../modules/ace/main.js';
 /**
  * The make middleware command to create a new middleware
  * class.
@@ -7,6 +7,7 @@ export default class MakeMiddleware extends BaseCommand {
     static commandName: string;
     static description: string;
     name: string;
+    stack?: 'server' | 'named' | 'router';
     /**
      * The stub to use for generating the middleware
      */

package/build/commands/make/middleware.js

@@ -12,25 +12,71 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args } from '../../modules/ace/main.js';
+import { slash } from '@poppinss/utils';
+import string from '@poppinss/utils/string';
+import { basename, extname, relative } from 'node:path';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, BaseCommand, flags } from '../../modules/ace/main.js';
 /**
  * The make middleware command to create a new middleware
  * class.
  */
 export default class MakeMiddleware extends BaseCommand {
     static commandName = 'make:middleware';
-    static description = 'Create a new middleware class';
+    static description = 'Create a new middleware class for HTTP requests';
     /**
      * The stub to use for generating the middleware
      */
     stubPath = 'make/middleware/main.stub';
     async run() {
-        await this.generate(this.stubPath, {
+        const stackChoices = ['server', 'router', 'named'];
+        /**
+         * Prompt to select the stack under which to register
+         * the middleware
+         */
+        if (!this.stack) {
+            this.stack = await this.prompt.choice('Under which stack you want to register the middleware?', stackChoices);
+        }
+        /**
+         * Error out when mentioned stack is invalid
+         */
+        if (!stackChoices.includes(this.stack)) {
+            this.exitCode = 1;
+            this.logger.error(`Invalid middleware stack "${this.stack}". Select from "${stackChoices.join(', ')}"`);
+            return;
+        }
+        /**
+         * Create middleware
+         */
+        const codemods = await this.createCodemods();
+        const { destination } = await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
             entity: this.app.generators.createEntity(this.name),
         });
+        /**
+         * Creative relative path for the middleware file from
+         * the "./app/middleware" directory
+         */
+        const middlewareRelativePath = slash(relative(this.app.middlewarePath(), destination).replace(extname(destination), ''));
+        /**
+         * Take the middleware relative path, remove `_middleware` prefix from it
+         * and convert everything to camelcase
+         */
+        const name = string.camelCase(basename(middlewareRelativePath).replace(/_middleware$/, ''));
+        /**
+         * Register middleware
+         */
+        await codemods.registerMiddleware(this.stack, [
+            {
+                name: name,
+                path: `#middleware/${middlewareRelativePath}`,
+            },
+        ]);
     }
 }
 __decorate([
     args.string({ description: 'Name of the middleware' })
 ], MakeMiddleware.prototype, "name", void 0);
+__decorate([
+    flags.string({ description: 'The stack in which to register the middleware', alias: 's' })
+], MakeMiddleware.prototype, "stack", void 0);

package/build/commands/make/preload.d.ts

@@ -1,5 +1,5 @@
-import BaseCommand from './_base.js';
-declare const ALLOWED_ENVIRONMENTS: ("repl" | "web" | "console" | "test")[];
+import { BaseCommand } from '../../modules/ace/main.js';
+declare const ALLOWED_ENVIRONMENTS: ("web" | "console" | "test" | "repl")[];
 type AllowedAppEnvironments = typeof ALLOWED_ENVIRONMENTS;
 /**
  * Make a new preload file
@@ -9,7 +9,8 @@ export default class MakePreload extends BaseCommand {
     static commandName: string;
     static description: string;
     name: string;
-    environments: AllowedAppEnvironments;
+    register?: boolean;
+    environments?: AllowedAppEnvironments;
     /**
      * The stub to use for generating the preload file
      */

package/build/commands/make/preload.js

@@ -12,8 +12,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args, flags } from '../../modules/ace/main.js';
+import { slash } from '@poppinss/utils';
+import { extname, relative } from 'node:path';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, flags, BaseCommand } from '../../modules/ace/main.js';
 const ALLOWED_ENVIRONMENTS = ['web', 'console', 'test', 'repl'];
 /**
  * Make a new preload file
@@ -24,13 +26,7 @@ export default class MakePreload extends BaseCommand {
     /**
      * The stub to use for generating the preload file
      */
-    stubPath = 'make/preload_file/main.stub';
-    /**
-     * Check if the mentioned environments are valid
-     */
-    #isValidEnvironment(environment) {
-        return !environment.find((one) => !ALLOWED_ENVIRONMENTS.includes(one));
-    }
+    stubPath = 'make/preload/main.stub';
     /**
      * Validate the environments flag passed by the user
      */
@@ -38,29 +34,12 @@ export default class MakePreload extends BaseCommand {
         if (!this.environments || !this.environments.length) {
             return true;
         }
-        return this.#isValidEnvironment(this.environments);
-    }
-    /**
-     * Prompt for the environments
-     */
-    async #promptForEnvironments() {
-        const selectedEnvironments = await this.prompt.multiple('Select the environment(s) in which you want to load this file', [
-            { name: 'all', message: 'Load file in all environments' },
-            { name: 'console', message: 'Environment for ace commands' },
-            { name: 'repl', message: 'Environment for the REPL session' },
-            { name: 'web', message: 'Environment for HTTP requests' },
-            { name: 'test', message: 'Environment for the test process' },
-        ]);
-        if (selectedEnvironments.includes('all')) {
-            return ['web', 'console', 'test', 'repl'];
-        }
-        return selectedEnvironments;
+        return this.environments.every((one) => ALLOWED_ENVIRONMENTS.includes(one));
     }
     /**
      * Run command
      */
     async run() {
-        let environments = this.environments;
         /**
          * Ensure the environments are valid when provided via flag
          */
@@ -69,27 +48,47 @@ export default class MakePreload extends BaseCommand {
             return;
         }
         /**
-         * Prompt for the environments when not defined
+         * Display prompt to know if we should register the preload
+         * file inside the ".adonisrc.ts" file.
          */
-        if (!environments) {
-            environments = await this.#promptForEnvironments();
+        if (this.register === undefined) {
+            this.register = await this.prompt.confirm('Do you want to register the preload file in .adonisrc.ts file?');
         }
-        const output = await this.generate(this.stubPath, {
+        const codemods = await this.createCodemods();
+        const { destination } = await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
             entity: this.app.generators.createEntity(this.name),
         });
         /**
-         * Registering the preload file with the `.adonisrc.json` file. We register
-         * the relative path, since we cannot be sure about aliases to exist.
+         * Do not register when prompt has been denied or "--no-register"
+         * flag was used
          */
-        const preloadImportPath = `./${output.relativeFileName.replace(/(\.js|\.ts)$/, '')}.js`;
-        await this.app.rcFileEditor.addPreloadFile(preloadImportPath, environments).save();
+        if (!this.register) {
+            return;
+        }
+        /**
+         * Creative relative path for the preload file from
+         * the "./start" directory
+         */
+        const preloadFileRelativePath = slash(relative(this.app.startPath(), destination).replace(extname(destination), ''));
+        await codemods.updateRcFile((rcFile) => {
+            rcFile.addPreloadFile(`#start/${preloadFileRelativePath}`, this.environments);
+        });
     }
 }
 __decorate([
     args.string({ description: 'Name of the preload file' })
 ], MakePreload.prototype, "name", void 0);
+__decorate([
+    flags.boolean({
+        description: 'Auto register the preload file inside the .adonisrc.ts file',
+        showNegatedVariantInHelp: true,
+        alias: 'r',
+    })
+], MakePreload.prototype, "register", void 0);
 __decorate([
     flags.array({
         description: `Define the preload file's environment. Accepted values are "${ALLOWED_ENVIRONMENTS}"`,
+        alias: 'e',
     })
 ], MakePreload.prototype, "environments", void 0);

package/build/commands/make/provider.d.ts

@@ -1,14 +1,20 @@
-import BaseCommand from './_base.js';
+import { BaseCommand } from '../../modules/ace/main.js';
+declare const ALLOWED_ENVIRONMENTS: ("web" | "console" | "test" | "repl")[];
+type AllowedAppEnvironments = typeof ALLOWED_ENVIRONMENTS;
 /**
  * Make a new provider class
  */
 export default class MakeProvider extends BaseCommand {
+    #private;
     static commandName: string;
     static description: string;
     name: string;
+    register?: boolean;
+    environments?: AllowedAppEnvironments;
     /**
      * The stub to use for generating the provider class
      */
     protected stubPath: string;
     run(): Promise<void>;
 }
+export {};

package/build/commands/make/provider.js

@@ -12,8 +12,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args } from '../../modules/ace/main.js';
+import { slash } from '@poppinss/utils';
+import { extname, relative } from 'node:path';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, BaseCommand, flags } from '../../modules/ace/main.js';
+const ALLOWED_ENVIRONMENTS = ['web', 'console', 'test', 'repl'];
 /**
  * Make a new provider class
  */
@@ -24,18 +27,65 @@ export default class MakeProvider extends BaseCommand {
      * The stub to use for generating the provider class
      */
     stubPath = 'make/provider/main.stub';
+    /**
+     * Validate the environments flag passed by the user
+     */
+    #isEnvironmentsFlagValid() {
+        if (!this.environments || !this.environments.length) {
+            return true;
+        }
+        return this.environments.every((one) => ALLOWED_ENVIRONMENTS.includes(one));
+    }
     async run() {
-        const output = await this.generate(this.stubPath, {
+        /**
+         * Ensure the environments are valid when provided via flag
+         */
+        if (!this.#isEnvironmentsFlagValid()) {
+            this.logger.error(`Invalid environment(s) "${this.environments}". Only "${ALLOWED_ENVIRONMENTS}" are allowed`);
+            return;
+        }
+        /**
+         * Display prompt to know if we should register the provider
+         * file inside the ".adonisrc.ts" file.
+         */
+        if (this.register === undefined) {
+            this.register = await this.prompt.confirm('Do you want to register the provider in .adonisrc.ts file?');
+        }
+        const codemods = await this.createCodemods();
+        const { destination } = await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
             entity: this.app.generators.createEntity(this.name),
         });
         /**
-         * Registering the provider with the `.adonisrc.json` file. We register
-         * the relative path, since we cannot be sure about aliases to exist.
+         * Do not register when prompt has been denied or "--no-register"
+         * flag was used
+         */
+        if (!this.register) {
+            return;
+        }
+        /**
+         * Creative relative path for the provider file from
+         * the "./start" directory
          */
-        const providerImportPath = `./${output.relativeFileName.replace(/(\.js|\.ts)$/, '')}.js`;
-        await this.app.rcFileEditor.addProvider(providerImportPath).save();
+        const providerRelativePath = slash(relative(this.app.providersPath(), destination).replace(extname(destination), ''));
+        await codemods.updateRcFile((rcFile) => {
+            rcFile.addProvider(`#providers/${providerRelativePath}`, this.environments);
+        });
     }
 }
 __decorate([
     args.string({ description: 'Name of the provider' })
 ], MakeProvider.prototype, "name", void 0);
+__decorate([
+    flags.boolean({
+        description: 'Auto register the provider inside the .adonisrc.ts file',
+        showNegatedVariantInHelp: true,
+        alias: 'r',
+    })
+], MakeProvider.prototype, "register", void 0);
+__decorate([
+    flags.array({
+        description: `Define the provider environment. Accepted values are "${ALLOWED_ENVIRONMENTS}"`,
+        alias: 'e',
+    })
+], MakeProvider.prototype, "environments", void 0);

package/build/commands/make/service.d.ts

@@ -1,4 +1,4 @@
-import BaseCommand from './_base.js';
+import { BaseCommand } from '../../modules/ace/main.js';
 /**
  * Make a new service class
  */

package/build/commands/make/service.js

@@ -12,8 +12,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args } from '../../modules/ace/main.js';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, BaseCommand } from '../../modules/ace/main.js';
 /**
  * Make a new service class
  */
@@ -25,7 +25,9 @@ export default class MakeService extends BaseCommand {
      */
     stubPath = 'make/service/main.stub';
     async run() {
-        await this.generate(this.stubPath, {
+        const codemods = await this.createCodemods();
+        await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
             entity: this.app.generators.createEntity(this.name),
         });
     }

package/build/commands/make/test.d.ts

@@ -1,4 +1,4 @@
-import BaseCommand from './_base.js';
+import { BaseCommand } from '../../modules/ace/main.js';
 /**
  * Make a new test file
  */

package/build/commands/make/test.js

@@ -12,8 +12,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import BaseCommand from './_base.js';
-import { args, flags } from '../../modules/ace/main.js';
+import { stubsRoot } from '../../stubs/main.js';
+import { args, flags, BaseCommand } from '../../modules/ace/main.js';
 /**
  * Make a new test file
  */
@@ -80,14 +80,16 @@ export default class MakeTest extends BaseCommand {
          * Show error when mentioned/selected suite does not exist
          */
         if (!suite) {
-            this.logger.error(`The "${this.suite}" suite is not configured inside the .adonisrc.json file`);
+            this.logger.error(`The "${this.suite}" suite is not configured inside the "adonisrc.js" file`);
             this.exitCode = 1;
             return;
         }
         /**
          * Generate entity
          */
-        await this.generate(this.stubPath, {
+        const codemods = await this.createCodemods();
+        await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+            flags: this.parsed.flags,
             entity: this.app.generators.createEntity(this.name),
             suite: {
                 directory: await this.#getSuiteDirectory(suite.directories),
@@ -99,5 +101,5 @@ __decorate([
     args.string({ description: 'Name of the test file' })
 ], MakeTest.prototype, "name", void 0);
 __decorate([
-    flags.string({ description: 'The suite for which to create the test file' })
+    flags.string({ description: 'The suite for which to create the test file', alias: 's' })
 ], MakeTest.prototype, "suite", void 0);

package/build/commands/make/validator.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../modules/ace/main.js';
+/**
+ * Make a new VineJS validator
+ */
+export default class MakeValidator extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    name: string;
+    resource: boolean;
+    /**
+     * The stub to use for generating the validator
+     */
+    protected stubPath: string;
+    /**
+     * Preparing the command state
+     */
+    prepare(): Promise<void>;
+    run(): Promise<void>;
+}