@adonisjs/core 6.1.5-33 → 6.1.5-35

package/build/commands/make/preload.js

@@ -12,6 +12,7 @@ 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 { 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'];
@@ -24,13 +25,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 +33,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,31 +47,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 codemods = await this.createCodemods();
-        const output = await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+        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.js` 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`;
+        if (!this.register) {
+            return;
+        }
+        /**
+         * Creative relative path for the preload file from
+         * the "./start" directory
+         */
+        const preloadFileRelativePath = relative(this.app.startPath(), destination).replace(extname(destination), '');
         await codemods.updateRcFile((rcFile) => {
-            rcFile.addPreloadFile(preloadImportPath, environments);
+            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 '../../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,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 { extname, relative } from 'node:path';
 import { stubsRoot } from '../../stubs/main.js';
-import { args, BaseCommand } from '../../modules/ace/main.js';
+import { args, BaseCommand, flags } from '../../modules/ace/main.js';
+const ALLOWED_ENVIRONMENTS = ['web', 'console', 'test', 'repl'];
 /**
  * Make a new provider class
  */
@@ -24,22 +26,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() {
+        /**
+         * 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 output = await codemods.makeUsingStub(stubsRoot, this.stubPath, {
+        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.js` 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`;
+        const providerRelativePath = relative(this.app.providersPath(), destination).replace(extname(destination), '');
         await codemods.updateRcFile((rcFile) => {
-            rcFile.addProvider(providerImportPath);
+            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/test.js

@@ -101,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

@@ -6,9 +6,14 @@ 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>;
 }

package/build/commands/make/validator.js

@@ -13,17 +13,28 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { stubsRoot } from '../../stubs/main.js';
-import { args, BaseCommand } from '../../modules/ace/main.js';
+import { args, flags, BaseCommand } from '../../modules/ace/main.js';
 /**
  * Make a new VineJS validator
  */
 export default class MakeValidator extends BaseCommand {
     static commandName = 'make:validator';
-    static description = 'Create a new VineJS validator';
+    static description = 'Create a new file to define VineJS validators';
     /**
      * The stub to use for generating the validator
      */
     stubPath = 'make/validator/main.stub';
+    /**
+     * Preparing the command state
+     */
+    async prepare() {
+        /**
+         * Use resource stub
+         */
+        if (this.resource) {
+            this.stubPath = 'make/validator/resource.stub';
+        }
+    }
     async run() {
         const codemods = await this.createCodemods();
         await codemods.makeUsingStub(stubsRoot, this.stubPath, {
@@ -33,5 +44,10 @@ export default class MakeValidator extends BaseCommand {
     }
 }
 __decorate([
-    args.string({ description: 'Name of the validator' })
+    args.string({ description: 'Name of the validator file' })
 ], MakeValidator.prototype, "name", void 0);
+__decorate([
+    flags.boolean({
+        description: 'Create a file with pre-defined validators for create and update actions',
+    })
+], MakeValidator.prototype, "resource", void 0);

package/build/commands/serve.js

@@ -56,13 +56,13 @@ export default class Serve extends BaseCommand {
         const assetsBundler = await detectAssetsBundler(this.app);
         return assetsBundler
             ? {
-                serve: this.assets === false ? false : true,
+                enabled: this.assets === false ? false : true,
                 driver: assetsBundler.name,
                 cmd: assetsBundler.devServer.command,
                 args: (assetsBundler.devServer.args || []).concat(this.assetsArgs || []),
             }
             : {
-                serve: false,
+                enabled: false,
             };
     }
     /**
@@ -119,10 +119,13 @@ export default class Serve extends BaseCommand {
     }
 }
 __decorate([
-    flags.boolean({ description: 'Watch filesystem and restart the HTTP server on file change' })
+    flags.boolean({
+        description: 'Watch filesystem and restart the HTTP server on file change',
+        alias: 'w',
+    })
 ], Serve.prototype, "watch", void 0);
 __decorate([
-    flags.boolean({ description: 'Use polling to detect filesystem changes' })
+    flags.boolean({ description: 'Use polling to detect filesystem changes', alias: 'p' })
 ], Serve.prototype, "poll", void 0);
 __decorate([
     flags.boolean({

package/build/commands/test.js

@@ -67,13 +67,13 @@ export default class Test extends BaseCommand {
         const assetsBundler = await detectAssetsBundler(this.app);
         return assetsBundler
             ? {
-                serve: this.assets === false ? false : true,
+                enabled: this.assets === false ? false : true,
                 driver: assetsBundler.name,
                 cmd: assetsBundler.devServer.command,
                 args: (assetsBundler.devServer.args || []).concat(this.assetsArgs || []),
             }
             : {
-                serve: false,
+                enabled: false,
             };
     }
     /**

package/build/modules/ace/codemods.d.ts

@@ -1,14 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
 import type { Logger } from '@poppinss/cliui';
 import type { CodeTransformer } from '@adonisjs/assembler/code_transformer';
-import type { AddMiddlewareEntry, EnvValidationDefinition } from '@adonisjs/assembler/types';
+import type { MiddlewareNode, EnvValidationNode, BouncerPolicyNode } from '@adonisjs/assembler/types';
 import type { Application } from '../app.js';
 /**
  * Codemods to modify AdonisJS source files. The codemod APIs relies on
  * "@adonisjs/assembler" package and it must be installed as a dependency
  * inside user application.
  */
-export declare class Codemods {
+export declare class Codemods extends EventEmitter {
     #private;
+    /**
+     * Overwrite existing files when generating files
+     * from stubs
+     */
+    overwriteExisting: boolean;
+    /**
+     * Display verbose logs for package installation
+     */
+    verboseInstallOutput: boolean;
     constructor(app: Application<any>, cliLogger: Logger);
     /**
      * Define one or more environment variables
@@ -17,11 +28,17 @@ export declare class Codemods {
     /**
      * Define validations for the environment variables
      */
-    defineEnvValidations(validations: EnvValidationDefinition): Promise<void>;
+    defineEnvValidations(validations: EnvValidationNode): Promise<void>;
     /**
      * Define validations for the environment variables
      */
-    registerMiddleware(stack: 'server' | 'router' | 'named', middleware: AddMiddlewareEntry[]): Promise<void>;
+    registerMiddleware(stack: 'server' | 'router' | 'named', middleware: MiddlewareNode[]): Promise<void>;
+    /**
+     * Register bouncer policies to the list of policies
+     * collection exported from the "app/policies/main.ts"
+     * file.
+     */
+    registerPolicies(policies: BouncerPolicyNode[]): Promise<void>;
     /**
      * Update RCFile
      */
@@ -46,9 +63,32 @@ export declare class Codemods {
     } | {
         relativeFileName: string;
         contents: string;
+        /**
+         * Reference to AdonisJS application
+         */
         destination: any;
         attributes: Record<string, any>;
         status: "skipped";
         skipReason: string;
     }>;
+    /**
+     * Install packages using the correct package manager
+     * You can specify version of each package by setting it in the
+     * name like :
+     *
+     * ```
+     * this.installPackages(['@adonisjs/lucid@next', '@adonisjs/auth@3.0.0'])
+     * ```
+     */
+    installPackages(packages: {
+        name: string;
+        isDevDependency: boolean;
+    }[]): Promise<void>;
+    /**
+     * List the packages one should install before using the packages
+     */
+    listPackagesToInstall(packages: {
+        name: string;
+        isDevDependency: boolean;
+    }[]): Promise<void>;
 }

package/build/modules/ace/codemods.js

@@ -7,13 +7,14 @@
  * file that was distributed with this source code.
  */
 import { slash } from '@poppinss/utils';
+import { EventEmitter } from 'node:events';
 import { EnvEditor } from '@adonisjs/env/editor';
 /**
  * Codemods to modify AdonisJS source files. The codemod APIs relies on
  * "@adonisjs/assembler" package and it must be installed as a dependency
  * inside user application.
  */
-export class Codemods {
+export class Codemods extends EventEmitter {
     /**
      * Flag to know if assembler is installed as a
      * peer dependency or not.
@@ -31,7 +32,17 @@ export class Codemods {
      * Reference to CLI logger to write logs
      */
     #cliLogger;
+    /**
+     * Overwrite existing files when generating files
+     * from stubs
+     */
+    overwriteExisting = false;
+    /**
+     * Display verbose logs for package installation
+     */
+    verboseInstallOutput = false;
     constructor(app, cliLogger) {
+        super();
         this.#app = app;
         this.#cliLogger = cliLogger;
     }
@@ -44,6 +55,26 @@ export class Codemods {
             this.#isAssemblerInstalled = !!this.#codeTransformer;
         }
     }
+    /**
+     * Returns the installation command for different
+     * package managers
+     */
+    #getInstallationCommands(packages, packageManager, isDev) {
+        if (!packages.length) {
+            return '';
+        }
+        const colors = this.#cliLogger.getColors();
+        const devFlag = isDev ? ' -D' : '';
+        switch (packageManager) {
+            case 'yarn':
+                return `${colors.yellow(`yarn add${devFlag}`)} ${packages.join(' ')}`;
+            case 'pnpm':
+                return `${colors.yellow(`pnpm add${devFlag}`)} ${packages.join(' ')}`;
+            case 'npm':
+            default:
+                return `${colors.yellow(`npm i${devFlag}`)} ${packages.join(' ')}`;
+        }
+    }
     /**
      * Define one or more environment variables
      */
@@ -73,6 +104,7 @@ export class Codemods {
             action.succeeded();
         }
         catch (error) {
+            this.emit('error', error);
             action.failed(error.message);
         }
     }
@@ -92,6 +124,29 @@ export class Codemods {
             action.succeeded();
         }
         catch (error) {
+            this.emit('error', error);
+            action.failed(error.message);
+        }
+    }
+    /**
+     * Register bouncer policies to the list of policies
+     * collection exported from the "app/policies/main.ts"
+     * file.
+     */
+    async registerPolicies(policies) {
+        await this.#importAssembler();
+        if (!this.#codeTransformer) {
+            this.#cliLogger.warning('Cannot update "app/policies/main.ts" file. Install "@adonisjs/assembler" to modify source files');
+            return;
+        }
+        const transformer = new this.#codeTransformer.CodeTransformer(this.#app.appRoot);
+        const action = this.#cliLogger.action('update app/policies/main.ts file');
+        try {
+            await transformer.addPolicies(policies);
+            action.succeeded();
+        }
+        catch (error) {
+            this.emit('error', error);
             action.failed(error.message);
         }
     }
@@ -111,6 +166,7 @@ export class Codemods {
             action.succeeded();
         }
         catch (error) {
+            this.emit('error', error);
             action.failed(error.message);
         }
     }
@@ -120,7 +176,7 @@ export class Codemods {
     async makeUsingStub(stubsRoot, stubPath, stubState) {
         const stubs = await this.#app.stubs.create();
         const stub = await stubs.build(stubPath, { source: stubsRoot });
-        const output = await stub.generate(stubState);
+        const output = await stub.generate({ force: this.overwriteExisting, ...stubState });
         const entityFileName = slash(this.#app.relativePath(output.destination));
         const result = { ...output, relativeFileName: entityFileName };
         if (output.status === 'skipped') {
@@ -130,4 +186,68 @@ export class Codemods {
         this.#cliLogger.action(`create ${entityFileName}`).succeeded();
         return result;
     }
+    /**
+     * Install packages using the correct package manager
+     * You can specify version of each package by setting it in the
+     * name like :
+     *
+     * ```
+     * this.installPackages(['@adonisjs/lucid@next', '@adonisjs/auth@3.0.0'])
+     * ```
+     */
+    async installPackages(packages) {
+        await this.#importAssembler();
+        const appPath = this.#app.makePath();
+        const colors = this.#cliLogger.getColors();
+        const devDependencies = packages.filter((pkg) => pkg.isDevDependency).map(({ name }) => name);
+        const dependencies = packages.filter((pkg) => !pkg.isDevDependency).map(({ name }) => name);
+        if (!this.#codeTransformer) {
+            this.#cliLogger.warning('Cannot install packages. Install "@adonisjs/assembler" or manually install following packages');
+            this.#cliLogger.log(`devDependencies: ${devDependencies.join(',')}`);
+            this.#cliLogger.log(`dependencies: ${dependencies.join(',')}`);
+            return;
+        }
+        const transformer = new this.#codeTransformer.CodeTransformer(this.#app.appRoot);
+        const packageManager = await transformer.detectPackageManager(appPath);
+        let spinner = this.#cliLogger
+            .await(`installing dependencies using ${packageManager || 'npm'} `)
+            .start();
+        try {
+            await transformer.installPackage(dependencies, {
+                cwd: appPath,
+                silent: !this.verboseInstallOutput,
+            });
+            await transformer.installPackage(devDependencies, {
+                dev: true,
+                cwd: appPath,
+                silent: !this.verboseInstallOutput,
+            });
+            spinner.stop();
+            this.#cliLogger.success('Packages installed');
+            this.#cliLogger.log(devDependencies.map((dependency) => `    ${colors.dim('dev')} ${dependency} `).join('\n'));
+            this.#cliLogger.log(dependencies.map((dependency) => `    ${colors.dim('prod')} ${dependency} `).join('\n'));
+        }
+        catch (error) {
+            spinner.update('unable to install dependencies');
+            spinner.stop();
+            this.#cliLogger.fatal(error);
+            this.emit('error', error);
+        }
+    }
+    /**
+     * List the packages one should install before using the packages
+     */
+    async listPackagesToInstall(packages) {
+        const appPath = this.#app.makePath();
+        const devDependencies = packages.filter((pkg) => pkg.isDevDependency).map(({ name }) => name);
+        const dependencies = packages.filter((pkg) => !pkg.isDevDependency).map(({ name }) => name);
+        let packageManager = null;
+        if (this.#codeTransformer) {
+            const transformer = new this.#codeTransformer.CodeTransformer(this.#app.appRoot);
+            packageManager = await transformer.detectPackageManager(appPath);
+        }
+        this.#cliLogger.log('Please install following packages');
+        this.#cliLogger.log(this.#getInstallationCommands(devDependencies, packageManager || 'npm', true));
+        this.#cliLogger.log(this.#getInstallationCommands(dependencies, packageManager || 'npm', false));
+    }
 }

package/build/modules/ace/commands.js

@@ -31,7 +31,11 @@ export class BaseCommand extends AceBaseCommand {
      */
     async createCodemods() {
         const { Codemods } = await import('./codemods.js');
-        return new Codemods(this.app, this.logger);
+        const codemods = new Codemods(this.app, this.logger);
+        codemods.on('error', () => {
+            this.exitCode = 1;
+        });
+        return codemods;
     }
     /**
      * Executes the command

package/build/providers/app_provider.js

@@ -8,7 +8,8 @@
  */
 import { Config } from '../modules/config.js';
 import { Logger } from '../modules/logger.js';
-import { BaseEvent } from '../modules/events.js';
+import { Application } from '../modules/app.js';
+import { BaseEvent, Emitter } from '../modules/events.js';
 import { Encryption } from '../modules/encryption.js';
 import { Router, Server } from '../modules/http/main.js';
 import BodyParserMiddleware from '../modules/bodyparser/bodyparser_middleware.js';
@@ -43,7 +44,8 @@ export default class AppServiceProvider {
      * Registers the application to the container
      */
     registerApp() {
-        this.app.container.singleton('app', () => this.app);
+        this.app.container.singleton(Application, () => this.app);
+        this.app.container.alias('app', Application);
     }
     /**
      * Registers the logger class to resolve the default logger
@@ -75,10 +77,10 @@ export default class AppServiceProvider {
      * Registers emitter service to the container
      */
     registerEmitter() {
-        this.app.container.singleton('emitter', async () => {
-            const { Emitter } = await import('../modules/events.js');
+        this.app.container.singleton(Emitter, async () => {
             return new Emitter(this.app);
         });
+        this.app.container.alias('emitter', Emitter);
     }
     /**
      * Register the encryption service to the container