@adonisjs/core 6.1.5-1 → 6.1.5-10

package/build/commands/make/preload.js

@@ -0,0 +1,95 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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';
+const ALLOWED_ENVIRONMENTS = ['web', 'console', 'test', 'repl'];
+/**
+ * Make a new preload file
+ */
+export default class MakePreload extends BaseCommand {
+    static commandName = 'make:preload';
+    static description = 'Create a new preload file inside the start directory';
+    /**
+     * 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));
+    }
+    /**
+     * Validate the environments flag passed by the user
+     */
+    #isEnvironmentsFlagValid() {
+        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;
+    }
+    /**
+     * Run command
+     */
+    async run() {
+        let environments = this.environments;
+        /**
+         * 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;
+        }
+        /**
+         * Prompt for the environments when not defined
+         */
+        if (!environments) {
+            environments = await this.#promptForEnvironments();
+        }
+        const output = await this.generate(this.stubPath, {
+            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.
+         */
+        const preloadImportPath = `./${output.relativeFileName.replace(/(\.js|\.ts)$/, '')}.js`;
+        await this.app.rcFileEditor.addPreloadFile(preloadImportPath, environments).save();
+    }
+}
+__decorate([
+    args.string({ description: 'Name of the preload file' })
+], MakePreload.prototype, "name", void 0);
+__decorate([
+    flags.array({
+        description: `Define the preload file's environment. Accepted values are "${ALLOWED_ENVIRONMENTS}"`,
+    })
+], MakePreload.prototype, "environments", void 0);

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

@@ -1,8 +1,14 @@
 import BaseCommand from './_base.js';
+/**
+ * Make a new provider class
+ */
 export default class MakeProvider extends BaseCommand {
     static commandName: string;
     static description: string;
     name: string;
+    /**
+     * The stub to use for generating the provider class
+     */
     protected stubPath: string;
     run(): Promise<void>;
 }

package/build/commands/make/provider.js

@@ -1,25 +1,41 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     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;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 import BaseCommand from './_base.js';
 import { args } from '../../modules/ace/main.js';
+/**
+ * Make a new provider class
+ */
 export default class MakeProvider extends BaseCommand {
     static commandName = 'make:provider';
     static description = 'Create a new service provider class';
+    /**
+     * The stub to use for generating the provider class
+     */
     stubPath = 'make/provider/main.stub';
     async run() {
-        await this.generate(this.stubPath, {
+        const output = await this.generate(this.stubPath, {
             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.
+         */
+        const providerImportPath = `./${output.relativeFileName.replace(/(\.js|\.ts)$/, '')}.js`;
+        await this.app.rcFileEditor.addProvider(providerImportPath).save();
     }
 }
 __decorate([
-    args.string({ description: 'Name of the provider' }),
-    __metadata("design:type", String)
+    args.string({ description: 'Name of the provider' })
 ], MakeProvider.prototype, "name", void 0);

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

@@ -0,0 +1,14 @@
+import BaseCommand from './_base.js';
+/**
+ * Make a new service class
+ */
+export default class MakeService extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    name: string;
+    /**
+     * The stub to use for generating the service class
+     */
+    protected stubPath: string;
+    run(): Promise<void>;
+}

package/build/commands/make/service.js

@@ -0,0 +1,35 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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';
+/**
+ * Make a new service class
+ */
+export default class MakeService extends BaseCommand {
+    static commandName = 'make:service';
+    static description = 'Create a new service class';
+    /**
+     * The stub to use for generating the service class
+     */
+    stubPath = 'make/service/main.stub';
+    async run() {
+        await this.generate(this.stubPath, {
+            entity: this.app.generators.createEntity(this.name),
+        });
+    }
+}
+__decorate([
+    args.string({ description: 'Name of the service' })
+], MakeService.prototype, "name", void 0);

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

@@ -1,10 +1,19 @@
 import BaseCommand from './_base.js';
+/**
+ * Make a new test file
+ */
 export default class MakeTest extends BaseCommand {
     #private;
     static commandName: string;
     static description: string;
     name: string;
     suite?: string;
+    /**
+     * The stub to use for generating the test file
+     */
     protected stubPath: string;
+    /**
+     * Executed by ace
+     */
     run(): Promise<void>;
 }

package/build/commands/make/test.js

@@ -1,26 +1,47 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     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;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 import BaseCommand from './_base.js';
 import { args, flags } from '../../modules/ace/main.js';
+/**
+ * Make a new test file
+ */
 export default class MakeTest extends BaseCommand {
     static commandName = 'make:test';
     static description = 'Create a new Japa test file';
+    /**
+     * The stub to use for generating the test file
+     */
     stubPath = 'make/test/main.stub';
+    /**
+     * Returns the suite name for creating the test file
+     */
     async #getSuite() {
         if (this.suite) {
             return this.suite;
         }
+        /**
+         * Use the first suite from the rcFile when there is only
+         * one suite
+         */
         const rcFileSuites = this.app.rcFile.tests.suites;
         if (rcFileSuites.length === 1) {
             return rcFileSuites[0].name;
         }
+        /**
+         * Prompt the user to select a suite manually
+         */
         return this.prompt.choice('Select the suite for the test file', this.app.rcFile.tests.suites.map((suite) => {
             return suite.name;
         }), {
@@ -29,6 +50,9 @@ export default class MakeTest extends BaseCommand {
             },
         });
     }
+    /**
+     * Returns the directory path for the selected suite.
+     */
     async #getSuiteDirectory(directories) {
         if (directories.length === 1) {
             return directories[0];
@@ -39,18 +63,30 @@ export default class MakeTest extends BaseCommand {
             },
         });
     }
+    /**
+     * Find suite info from the rcFile file
+     */
     #findSuite(suiteName) {
         return this.app.rcFile.tests.suites.find((suite) => {
             return suite.name === suiteName;
         });
     }
+    /**
+     * Executed by ace
+     */
     async run() {
         const suite = this.#findSuite(await this.#getSuite());
+        /**
+         * 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.exitCode = 1;
             return;
         }
+        /**
+         * Generate entity
+         */
         await this.generate(this.stubPath, {
             entity: this.app.generators.createEntity(this.name),
             suite: {
@@ -60,10 +96,8 @@ export default class MakeTest extends BaseCommand {
     }
 }
 __decorate([
-    args.string({ description: 'Name of the test file' }),
-    __metadata("design:type", String)
+    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' }),
-    __metadata("design:type", String)
+    flags.string({ description: 'The suite for which to create the test file' })
 ], MakeTest.prototype, "suite", void 0);

package/build/commands/repl.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../modules/ace/main.js';
+import { CommandOptions } from '../types/ace.js';
+/**
+ * The ReplCommand class is used to start the Repl server
+ */
+export default class ReplCommand extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    /**
+     * Starts the REPL server process
+     */
+    run(): Promise<void>;
+}

package/build/commands/repl.js

@@ -0,0 +1,30 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { BaseCommand } from '../modules/ace/main.js';
+/**
+ * The ReplCommand class is used to start the Repl server
+ */
+export default class ReplCommand extends BaseCommand {
+    static commandName = 'repl';
+    static description = 'Start a new REPL session';
+    static options = {
+        startApp: true,
+        staysAlive: true,
+    };
+    /**
+     * Starts the REPL server process
+     */
+    async run() {
+        const repl = await this.app.container.make('repl');
+        repl.start();
+        repl.server.on('exit', async () => {
+            await this.terminate();
+        });
+    }
+}

package/build/commands/serve.d.ts

@@ -1,13 +1,25 @@
+import type { DevServer } from '@adonisjs/assembler';
 import type { CommandOptions } from '../types/ace.js';
 import { BaseCommand } from '../modules/ace/main.js';
+/**
+ * Serve command is used to run the AdonisJS HTTP server during development. The
+ * command under the hood runs the "bin/server.ts" file and watches for file
+ * system changes
+ */
 export default class Serve extends BaseCommand {
     #private;
     static commandName: string;
     static description: string;
+    static help: string[];
     static options: CommandOptions;
+    devServer: DevServer;
     watch?: boolean;
     poll?: boolean;
     clear?: boolean;
     assets?: boolean;
+    assetsArgs?: string[];
+    /**
+     * Runs the HTTP server
+     */
     run(): Promise<void>;
 }

package/build/commands/serve.js

@@ -1,20 +1,45 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     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;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 import { BaseCommand, flags } from '../modules/ace/main.js';
 import { detectAssetsBundler, importAssembler, importTypeScript } from '../src/internal_helpers.js';
+/**
+ * Serve command is used to run the AdonisJS HTTP server during development. The
+ * command under the hood runs the "bin/server.ts" file and watches for file
+ * system changes
+ */
 export default class Serve extends BaseCommand {
     static commandName = 'serve';
     static description = 'Start the development HTTP server along with the file watcher to perform restarts on file change';
+    static help = [
+        'Start the development server with file watcher using the following command.',
+        '```',
+        '{{ binaryName }} serve --watch',
+        '```',
+        '',
+        'The assets bundler dev server runs automatically after detecting vite config or webpack config files',
+        'You may pass vite CLI args using the --assets-args command line flag.',
+        '```',
+        '{{ binaryName }} serve --assets-args="--debug --base=/public"',
+        '```',
+    ];
     static options = {
         staysAlive: true,
     };
+    /**
+     * Log a development dependency is missing
+     */
     #logMissingDevelopmentDependency(dependency) {
         this.logger.error([
             `Cannot find package "${dependency}"`,
@@ -24,6 +49,25 @@ export default class Serve extends BaseCommand {
             'If you are running your application in production, then use "node bin/server.js" command to start the HTTP server',
         ].join('\n'));
     }
+    /**
+     * Returns the assets bundler config
+     */
+    async #getAssetsBundlerConfig() {
+        const assetsBundler = await detectAssetsBundler(this.app);
+        return assetsBundler
+            ? {
+                serve: this.assets === false ? false : true,
+                driver: assetsBundler.name,
+                cmd: assetsBundler.devServer.command,
+                args: (assetsBundler.devServer.args || []).concat(this.assetsArgs || []),
+            }
+            : {
+                serve: false,
+            };
+    }
+    /**
+     * Runs the HTTP server
+     */
     async run() {
         const assembler = await importAssembler(this.app);
         if (!assembler) {
@@ -31,29 +75,35 @@ export default class Serve extends BaseCommand {
             this.exitCode = 1;
             return;
         }
-        const assetsBundler = await detectAssetsBundler(this.app);
-        const devServer = new assembler.DevServer(this.app.appRoot, {
+        this.devServer = new assembler.DevServer(this.app.appRoot, {
             clearScreen: this.clear === false ? false : true,
             nodeArgs: this.parsed.nodeArgs,
             scriptArgs: [],
-            assets: assetsBundler
-                ? {
-                    serve: this.assets === false ? false : true,
-                    driver: assetsBundler.name,
-                    cmd: assetsBundler.devServerCommand,
-                }
-                : {
-                    serve: false,
-                },
+            assets: await this.#getAssetsBundlerConfig(),
             metaFiles: this.app.rcFile.metaFiles,
         });
-        devServer.setLogger(this.logger);
-        devServer.onClose((exitCode) => {
+        /**
+         * Share command logger with assembler, so that CLI flags like --no-ansi has
+         * similar impact for assembler logs as well.
+         */
+        this.devServer.setLogger(this.logger);
+        /**
+         * Exit command when the dev server is closed
+         */
+        this.devServer.onClose((exitCode) => {
             this.exitCode = exitCode;
+            this.terminate();
         });
-        devServer.onError(() => {
+        /**
+         * Exit command when the dev server crashes
+         */
+        this.devServer.onError(() => {
             this.exitCode = 1;
+            this.terminate();
         });
+        /**
+         * Start the development server
+         */
         if (this.watch) {
             const ts = await importTypeScript(this.app);
             if (!ts) {
@@ -61,34 +111,35 @@ export default class Serve extends BaseCommand {
                 this.exitCode = 1;
                 return;
             }
-            await devServer.startAndWatch(ts, { poll: this.poll || false });
+            await this.devServer.startAndWatch(ts, { poll: this.poll || false });
         }
         else {
-            await devServer.start();
+            await this.devServer.start();
         }
     }
 }
 __decorate([
-    flags.boolean({ description: 'Watch filesystem and restart the HTTP server on file change' }),
-    __metadata("design:type", Boolean)
+    flags.boolean({ description: 'Watch filesystem and restart the HTTP server on file change' })
 ], Serve.prototype, "watch", void 0);
 __decorate([
-    flags.boolean({ description: 'Use polling to detect filesystem changes' }),
-    __metadata("design:type", Boolean)
+    flags.boolean({ description: 'Use polling to detect filesystem changes' })
 ], Serve.prototype, "poll", void 0);
 __decorate([
     flags.boolean({
         description: 'Clear the terminal for new logs after file change',
         showNegatedVariantInHelp: true,
         default: true,
-    }),
-    __metadata("design:type", Boolean)
+    })
 ], Serve.prototype, "clear", void 0);
 __decorate([
     flags.boolean({
         description: 'Start assets bundler dev server',
         showNegatedVariantInHelp: true,
         default: true,
-    }),
-    __metadata("design:type", Boolean)
+    })
 ], Serve.prototype, "assets", void 0);
+__decorate([
+    flags.array({
+        description: 'Define CLI arguments to pass to the assets bundler',
+    })
+], Serve.prototype, "assetsArgs", void 0);

package/build/commands/test.d.ts

@@ -0,0 +1,32 @@
+import type { TestRunner } from '@adonisjs/assembler';
+import type { CommandOptions } from '../types/ace.js';
+import { BaseCommand } from '../modules/ace/main.js';
+/**
+ * Test command is used to run tests with optional file watcher. Under the
+ * hood, we run "bin/test.js" file.
+ */
+export default class Test extends BaseCommand {
+    #private;
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    testsRunner: TestRunner;
+    suites?: string[];
+    files?: string[];
+    tags?: string[];
+    groups?: string[];
+    tests?: string[];
+    reporters?: string[];
+    watch?: boolean;
+    poll?: boolean;
+    timeout?: number;
+    retries?: number;
+    failed?: boolean;
+    clear?: boolean;
+    assets?: boolean;
+    assetsArgs?: string[];
+    /**
+     * Runs tests
+     */
+    run(): Promise<void>;
+}