@adonisjs/core 6.1.5-33 → 6.1.5-34

package/build/commands/make/provider.js

@@ -13,7 +13,8 @@ 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, BaseCommand, flags } from '../../modules/ace/main.js';
+const ALLOWED_ENVIRONMENTS = ['web', 'console', 'test', 'repl'];
 /**
  * Make a new provider class
  */
@@ -24,7 +25,23 @@ 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;
+        }
         const codemods = await this.createCodemods();
         const output = await codemods.makeUsingStub(stubsRoot, this.stubPath, {
             flags: this.parsed.flags,
@@ -34,12 +51,23 @@ export default class MakeProvider extends BaseCommand {
          * Registering the provider with the `adonisrc.js` file. We register
          * the relative path, since we cannot be sure about aliases to exist.
          */
-        const providerImportPath = `./${output.relativeFileName.replace(/(\.js|\.ts)$/, '')}.js`;
-        await codemods.updateRcFile((rcFile) => {
-            rcFile.addProvider(providerImportPath);
-        });
+        try {
+            const providerImportPath = `./${output.relativeFileName.replace(/(\.js|\.ts)$/, '')}.js`;
+            await codemods.updateRcFile((rcFile) => {
+                rcFile.addProvider(providerImportPath, this.environments);
+            });
+        }
+        catch (_) {
+            this.logger.warning('Unable to register provider inside the adonisrc.ts file. Make sure to manually register it');
+        }
     }
 }
 __decorate([
     args.string({ description: 'Name of the provider' })
 ], MakeProvider.prototype, "name", 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 } 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,11 @@ 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>;
     /**
      * Update RCFile
      */
@@ -45,10 +56,33 @@ export declare class Codemods {
         skipReason: null;
     } | {
         relativeFileName: string;
+        /**
+         * Reference to AdonisJS application
+         */
         contents: string;
         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,7 @@ export class Codemods {
             action.succeeded();
         }
         catch (error) {
+            this.emit('error', error);
             action.failed(error.message);
         }
     }
@@ -111,6 +144,7 @@ export class Codemods {
             action.succeeded();
         }
         catch (error) {
+            this.emit('error', error);
             action.failed(error.message);
         }
     }
@@ -120,7 +154,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 +164,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

package/build/providers/repl_provider.js

@@ -8,6 +8,8 @@
  */
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { Repl } from '../modules/repl.js';
+import { fsImportAll } from '@poppinss/utils';
 /**
  * Resolves a container binding and sets it on the REPL
  * context
@@ -25,12 +27,12 @@ export default class ReplServiceProvider {
      * Registers the REPL binding
      */
     register() {
-        this.app.container.singleton('repl', async () => {
-            const { Repl } = await import('../modules/repl.js');
+        this.app.container.singleton(Repl, async () => {
             return new Repl({
                 historyFilePath: join(homedir(), '.adonisjs_v6_repl_history'),
             });
         });
+        this.app.container.alias('repl', Repl);
     }
     /**
      * Registering REPL bindings during provider boot
@@ -42,6 +44,13 @@ export default class ReplServiceProvider {
             }, {
                 description: 'Returns the default export for a module',
             });
+            repl.addMethod('importAll', (_, dirPath) => {
+                return fsImportAll(this.app.makeURL(dirPath), {
+                    ignoreMissingRoot: false,
+                });
+            }, {
+                description: 'Import all files from a directory and assign them to a variable',
+            });
             repl.addMethod('make', (_, service, runtimeValues) => {
                 return this.app.container.make(service, runtimeValues);
             }, {

package/build/src/helpers/main.d.ts

@@ -1,4 +1,4 @@
 export { default as parseImports } from 'parse-imports';
-export { createId as cuid } from '@paralleldrive/cuid2';
+export { createId as cuid, isCuid } from '@paralleldrive/cuid2';
 export { slash, base64, compose, fsReadAll, safeEqual, fsImportAll, MessageBuilder, } from '@poppinss/utils';
 export { parseBindingReference } from './parse_binding_reference.js';

package/build/src/helpers/main.js

@@ -7,6 +7,6 @@
  * file that was distributed with this source code.
  */
 export { default as parseImports } from 'parse-imports';
-export { createId as cuid } from '@paralleldrive/cuid2';
+export { createId as cuid, isCuid } from '@paralleldrive/cuid2';
 export { slash, base64, compose, fsReadAll, safeEqual, fsImportAll, MessageBuilder, } from '@poppinss/utils';
 export { parseBindingReference } from './parse_binding_reference.js';

package/build/src/types.d.ts

@@ -4,12 +4,12 @@ import type { Emitter } from '../modules/events.js';
 import type { Kernel } from '../modules/ace/main.js';
 import type { Application } from '../modules/app.js';
 import type { TestUtils } from './test_utils/main.js';
+import type { HttpServerEvents } from '../types/http.js';
 import type { LoggerManager } from '../modules/logger.js';
 import type { HashManager } from '../modules/hash/main.js';
 import type { Encryption } from '../modules/encryption.js';
 import type { ManagerDriverFactory } from '../types/hash.js';
 import type { Router, Server } from '../modules/http/main.js';
-import type { HttpRequestFinishedPayload } from '../types/http.js';
 import type { ContainerResolveEventData } from '../types/container.js';
 import type { LoggerConfig, LoggerManagerConfig } from '../types/logger.js';
 /**
@@ -32,9 +32,8 @@ export type IgnitorOptions = {
  * user land code or packages to register events and their
  * types.
  */
-export interface EventsList {
-    'container:resolved': ContainerResolveEventData<ContainerBindings>;
-    'http:request_finished': HttpRequestFinishedPayload;
+export interface EventsList extends HttpServerEvents {
+    'container_binding:resolved': ContainerResolveEventData<ContainerBindings>;
     'http:server_ready': {
         port: number;
         host: string;

package/build/stubs/make/validator/resource.stub

@@ -0,0 +1,26 @@
+{{#var validatorName = string(generators.validatorName(entity.name)).noCase()}}
+{{#var validatorFileName = generators.validatorFileName(entity.name)}}
+{{#var createAction = generators.validatorActionName(entity.name, 'create')}}
+{{#var updateAction = generators.validatorActionName(entity.name, 'update')}}
+{{{
+  exports({
+    to: app.validatorsPath(entity.path, validatorFileName)
+  })
+}}}
+import vine from '@vinejs/vine'
+
+/**
+ * Validator to validate the payload when creating
+ * a new {{ validatorName }}.
+ */
+export const {{ createAction }} = vine.compile(
+  vine.object({})
+)
+
+/**
+ * Validator to validate the payload when updating
+ * an existing {{ validatorName }}.
+ */
+export const {{ updateAction }} = vine.compile(
+  vine.object({})
+)