@adonisjs/core 6.1.5-9 → 6.2.1

package/build/modules/ace/codemods.js

@@ -0,0 +1,259 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * 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 extends EventEmitter {
+    /**
+     * Flag to know if assembler is installed as a
+     * peer dependency or not.
+     */
+    #isAssemblerInstalled;
+    /**
+     * Reference to lazily imported assembler code transformer
+     */
+    #codeTransformer;
+    /**
+     * Reference to AdonisJS application
+     */
+    #app;
+    /**
+     * 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;
+    }
+    /**
+     * Lazily imports assembler
+     */
+    async #importAssembler() {
+        if (this.#isAssemblerInstalled === undefined) {
+            this.#codeTransformer = await import('@adonisjs/assembler/code_transformer');
+            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
+     */
+    async defineEnvVariables(environmentVariables) {
+        const editor = new EnvEditor(this.#app.appRoot);
+        await editor.load();
+        Object.keys(environmentVariables).forEach((key) => {
+            const value = environmentVariables[key];
+            editor.add(key, value);
+        });
+        await editor.save();
+        this.#cliLogger.action('update .env file').succeeded();
+    }
+    /**
+     * Define validations for the environment variables
+     */
+    async defineEnvValidations(validations) {
+        await this.#importAssembler();
+        if (!this.#codeTransformer) {
+            this.#cliLogger.warning('Cannot update "start/env.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 start/env.ts file');
+        try {
+            await transformer.defineEnvValidations(validations);
+            action.succeeded();
+        }
+        catch (error) {
+            this.emit('error', error);
+            action.failed(error.message);
+        }
+    }
+    /**
+     * Define validations for the environment variables
+     */
+    async registerMiddleware(stack, middleware) {
+        await this.#importAssembler();
+        if (!this.#codeTransformer) {
+            this.#cliLogger.warning('Cannot update "start/kernel.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 start/kernel.ts file');
+        try {
+            await transformer.addMiddlewareToStack(stack, middleware);
+            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);
+        }
+    }
+    /**
+     * Update RCFile
+     */
+    async updateRcFile(...params) {
+        await this.#importAssembler();
+        if (!this.#codeTransformer) {
+            this.#cliLogger.warning('Cannot update "adonisrc.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 adonisrc.ts file');
+        try {
+            await transformer.updateRcFile(...params);
+            action.succeeded();
+        }
+        catch (error) {
+            this.emit('error', error);
+            action.failed(error.message);
+        }
+    }
+    /**
+     * Generats the stub
+     */
+    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({ force: this.overwriteExisting, ...stubState });
+        const entityFileName = slash(this.#app.relativePath(output.destination));
+        const result = { ...output, relativeFileName: entityFileName };
+        if (output.status === 'skipped') {
+            this.#cliLogger.action(`create ${entityFileName}`).skipped(output.skipReason);
+            return result;
+        }
+        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);
+        const spinner = this.#cliLogger.await(`installing dependencies using ${packageManager || 'npm'} `);
+        const silentLogs = !this.verboseInstallOutput;
+        if (silentLogs) {
+            spinner.start();
+        }
+        try {
+            await transformer.installPackage(dependencies, {
+                cwd: appPath,
+                silent: silentLogs,
+            });
+            await transformer.installPackage(devDependencies, {
+                dev: true,
+                cwd: appPath,
+                silent: silentLogs,
+            });
+            if (silentLogs) {
+                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) {
+            if (silentLogs) {
+                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.d.ts

@@ -2,36 +2,6 @@ import { BaseCommand as AceBaseCommand, ListCommand as AceListCommand } from '@a
 import { Kernel } from './kernel.js';
 import type { ApplicationService } from '../../src/types.js';
 import type { CommandOptions, ParsedOutput, UIPrimitives } from '../../types/ace.js';
-/**
- * Wrapper around the stub generation logic.
- * Allow commands to easily generate files from given stubs
- */
-declare class StubGenerator {
-    #private;
-    constructor(command: BaseCommand, flags: Record<string, any>);
-    generate(stubsRoot: string, stubPath: string, stubState: Record<string, any>): Promise<{
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "created";
-        skipReason: null;
-    } | {
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "force_created";
-        skipReason: null;
-    } | {
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "skipped";
-        skipReason: string;
-    }>;
-}
 /**
  * The base command to create custom ace commands. The AdonisJS base commands
  * receives the application instance
@@ -39,11 +9,14 @@ declare class StubGenerator {
 export declare class BaseCommand extends AceBaseCommand {
     app: ApplicationService;
     kernel: Kernel;
-    stubGenerator: StubGenerator;
     static options: CommandOptions;
     get staysAlive(): boolean | undefined;
     get startApp(): boolean | undefined;
     constructor(app: ApplicationService, kernel: Kernel, parsed: ParsedOutput, ui: UIPrimitives, prompt: Kernel['prompt']);
+    /**
+     * Creates the codemods module to modify source files
+     */
+    createCodemods(): Promise<import("./codemods.js").Codemods>;
     /**
      * The prepare template method is used to prepare the
      * state for the command. This is the first method
@@ -65,31 +38,6 @@ export declare class BaseCommand extends AceBaseCommand {
      * reporting to the kernel layer.
      */
     completed?(..._: any[]): any;
-    /**
-     * Make a new file using the given stub
-     */
-    makeUsingStub(stubPath: string, stubState: Record<string, any>, stubsRoot: string): Promise<{
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "created";
-        skipReason: null;
-    } | {
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "force_created";
-        skipReason: null;
-    } | {
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "skipped";
-        skipReason: string;
-    }>;
     /**
      * Executes the command
      */
@@ -108,36 +56,14 @@ export declare class BaseCommand extends AceBaseCommand {
 export declare class ListCommand extends AceListCommand implements BaseCommand {
     app: ApplicationService;
     kernel: Kernel;
-    stubGenerator: StubGenerator;
     static options: CommandOptions;
     get staysAlive(): boolean | undefined;
     get startApp(): boolean | undefined;
     constructor(app: ApplicationService, kernel: Kernel, parsed: ParsedOutput, ui: UIPrimitives, prompt: Kernel['prompt']);
     /**
-     * Make a new file using the given stub
+     * Creates the codemods module to modify source files
      */
-    makeUsingStub(stubPath: string, stubState: Record<string, any>, stubsRoot: string): Promise<{
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "created";
-        skipReason: null;
-    } | {
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "force_created";
-        skipReason: null;
-    } | {
-        relativeFileName: string;
-        contents: any;
-        destination: any;
-        attributes: any;
-        status: "skipped";
-        skipReason: string;
-    }>;
+    createCodemods(): Promise<import("./codemods.js").Codemods>;
     /**
      * Terminate the app. A command should prefer calling this method
      * over the "app.terminate", because this method only triggers
@@ -146,4 +72,3 @@ export declare class ListCommand extends AceListCommand implements BaseCommand {
      */
     terminate(): Promise<void>;
 }
-export {};

package/build/modules/ace/commands.js

@@ -6,32 +6,7 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { slash } from '@poppinss/utils';
 import { BaseCommand as AceBaseCommand, ListCommand as AceListCommand } from '@adonisjs/ace';
-/**
- * Wrapper around the stub generation logic.
- * Allow commands to easily generate files from given stubs
- */
-class StubGenerator {
-    #command;
-    #flags;
-    constructor(command, flags) {
-        this.#command = command;
-        this.#flags = flags;
-    }
-    async generate(stubsRoot, stubPath, stubState) {
-        const stub = await this.#command.app.stubs.build(stubPath, { source: stubsRoot });
-        const output = await stub.generate(Object.assign({ flags: this.#flags }, stubState));
-        const entityFileName = slash(this.#command.app.relativePath(output.destination));
-        const result = { ...output, relativeFileName: entityFileName };
-        if (output.status === 'skipped') {
-            this.#command.logger.action(`create ${entityFileName}`).skipped(output.skipReason);
-            return result;
-        }
-        this.#command.logger.action(`create ${entityFileName}`).succeeded();
-        return result;
-    }
-}
 /**
  * The base command to create custom ace commands. The AdonisJS base commands
  * receives the application instance
@@ -39,7 +14,6 @@ class StubGenerator {
 export class BaseCommand extends AceBaseCommand {
     app;
     kernel;
-    stubGenerator = new StubGenerator(this, this.parsed?.flags || {});
     static options = {};
     get staysAlive() {
         return this.constructor.options.staysAlive;
@@ -53,10 +27,15 @@ export class BaseCommand extends AceBaseCommand {
         this.kernel = kernel;
     }
     /**
-     * Make a new file using the given stub
+     * Creates the codemods module to modify source files
      */
-    async makeUsingStub(stubPath, stubState, stubsRoot) {
-        return this.stubGenerator.generate(stubsRoot, stubPath, stubState);
+    async createCodemods() {
+        const { Codemods } = await import('./codemods.js');
+        const codemods = new Codemods(this.app, this.logger);
+        codemods.on('error', () => {
+            this.exitCode = 1;
+        });
+        return codemods;
     }
     /**
      * Executes the command
@@ -110,7 +89,6 @@ export class BaseCommand extends AceBaseCommand {
 export class ListCommand extends AceListCommand {
     app;
     kernel;
-    stubGenerator = new StubGenerator(this, this.parsed?.flags || {});
     static options = {};
     get staysAlive() {
         return this.constructor.options.staysAlive;
@@ -124,10 +102,11 @@ export class ListCommand extends AceListCommand {
         this.kernel = kernel;
     }
     /**
-     * Make a new file using the given stub
+     * Creates the codemods module to modify source files
      */
-    async makeUsingStub(stubPath, stubState, stubsRoot) {
-        return this.stubGenerator.generate(stubsRoot, stubPath, stubState);
+    async createCodemods() {
+        const { Codemods } = await import('./codemods.js');
+        return new Codemods(this.app, this.logger);
     }
     /**
      * Terminate the app. A command should prefer calling this method

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

@@ -9,4 +9,4 @@ import type { ApplicationService } from '../../src/types.js';
  * - In other environments, ace can be pulled from the container to
  * run commands
  */
-export declare function createAceKernel(app: ApplicationService): Kernel;
+export declare function createAceKernel(app: ApplicationService, commandName?: string): Kernel;

package/build/modules/ace/create_kernel.js

@@ -17,16 +17,32 @@ import { FsLoader, HelpCommand } from '../../modules/ace/main.js';
  * - In other environments, ace can be pulled from the container to
  * run commands
  */
-export function createAceKernel(app) {
+export function createAceKernel(app, commandName) {
     const kernel = new Kernel(app);
-    kernel.addLoader(new FsLoader(app.commandsPath()));
     kernel.info.set('binary', 'node ace');
     /**
      * Lazy import commands mentioned in the "commands" array
      * of rcFile
      */
     app.rcFile.commands.forEach((commandModule) => {
-        kernel.addLoader(() => app.import(commandModule));
+        kernel.addLoader(() => typeof commandModule === 'function' ? commandModule() : app.import(commandModule));
+    });
+    /**
+     * When we know the command we are running ahead of time, then we
+     * defer loading the application commands if the command has
+     * already been registered by other loaders.
+     */
+    const fsLoader = new FsLoader(app.commandsPath());
+    kernel.addLoader({
+        async getMetaData() {
+            if (!commandName || !kernel.getCommand(commandName)) {
+                return fsLoader.getMetaData();
+            }
+            return [];
+        },
+        getCommand(command) {
+            return fsLoader.getCommand(command);
+        },
     });
     /**
      * Custom global flags

package/build/modules/env/editor.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/env/editor';

package/build/modules/env/editor.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export * from '@adonisjs/env/editor';

package/build/modules/hash/define_config.d.ts

@@ -1,18 +1,35 @@
-import type { HashDriversList } from '../../src/types.js';
-import type { ManagerDriverFactory } from '../../types/hash.js';
+import type { Argon } from './drivers/argon.js';
+import type { Scrypt } from './drivers/scrypt.js';
+import type { Bcrypt } from './drivers/bcrypt.js';
+import type { ConfigProvider } from '../../src/types.js';
+import type { ArgonConfig, BcryptConfig, ScryptConfig, ManagerDriverFactory } from '../../types/hash.js';
 /**
- * Define config for the hash service.
+ * Resolved config from the config provider will be
+ * the config accepted by the hash manager
  */
-export declare function defineConfig<KnownHashers extends Record<string, {
-    [K in keyof HashDriversList]: {
-        driver: K;
-    } & Parameters<HashDriversList[K]>[0];
-}[keyof HashDriversList]>>(config: {
-    default?: keyof KnownHashers;
-    list: KnownHashers;
-}): {
+type ResolvedConfig<KnownHashers extends Record<string, ManagerDriverFactory | ConfigProvider<ManagerDriverFactory>>> = {
     default?: keyof KnownHashers;
     list: {
-        [K in keyof KnownHashers]: ManagerDriverFactory;
+        [K in keyof KnownHashers]: KnownHashers[K] extends ConfigProvider<infer A> ? A : KnownHashers[K];
     };
 };
+/**
+ * Define config for the hash service.
+ */
+export declare function defineConfig<KnownHashers extends Record<string, ManagerDriverFactory | ConfigProvider<ManagerDriverFactory>>>(config: {
+    default?: keyof KnownHashers;
+    list: KnownHashers;
+}): ConfigProvider<ResolvedConfig<KnownHashers>>;
+/**
+ * Helpers to configure drivers inside the config file. The
+ * drivers will be imported and constructed lazily.
+ *
+ * - Import happens when you first use the hash module
+ * - Construction of drivers happens when you first use a driver
+ */
+export declare const drivers: {
+    argon2: (config: ArgonConfig) => ConfigProvider<() => Argon>;
+    bcrypt: (config: BcryptConfig) => ConfigProvider<() => Bcrypt>;
+    scrypt: (config: ScryptConfig) => ConfigProvider<() => Scrypt>;
+};
+export {};

package/build/modules/hash/define_config.js

@@ -7,7 +7,8 @@
  * file that was distributed with this source code.
  */
 import { InvalidArgumentsException } from '@poppinss/utils';
-import driversCollection from './drivers_collection.js';
+import debug from '../../src/debug.js';
+import { configProvider } from '../../src/config_provider.js';
 /**
  * Define config for the hash service.
  */
@@ -25,15 +26,55 @@ export function defineConfig(config) {
         throw new InvalidArgumentsException(`Missing "list.${String(config.default)}" in hash config. It is referenced by the "default" property`);
     }
     /**
-     * Converting list config to a collection that hash manager can use
+     * Config provider to lazily import drivers as they are used inside
+     * the user application
      */
-    const managerHashers = Object.keys(config.list).reduce((result, disk) => {
-        const hasherConfig = config.list[disk];
-        result[disk] = () => driversCollection.create(hasherConfig.driver, hasherConfig);
-        return result;
-    }, {});
-    return {
-        default: config.default,
-        list: managerHashers,
-    };
+    return configProvider.create(async (app) => {
+        debug('resolving hash config');
+        const hashersList = Object.keys(config.list);
+        const hashers = {};
+        for (let hasherName of hashersList) {
+            const hasher = config.list[hasherName];
+            if (typeof hasher === 'function') {
+                hashers[hasherName] = hasher;
+            }
+            else {
+                hashers[hasherName] = await hasher.resolver(app);
+            }
+        }
+        return {
+            default: config.default,
+            list: hashers,
+        };
+    });
 }
+/**
+ * Helpers to configure drivers inside the config file. The
+ * drivers will be imported and constructed lazily.
+ *
+ * - Import happens when you first use the hash module
+ * - Construction of drivers happens when you first use a driver
+ */
+export const drivers = {
+    argon2: (config) => {
+        return configProvider.create(async () => {
+            const { Argon } = await import('./drivers/argon.js');
+            debug('configuring argon driver');
+            return () => new Argon(config);
+        });
+    },
+    bcrypt: (config) => {
+        return configProvider.create(async () => {
+            const { Bcrypt } = await import('./drivers/bcrypt.js');
+            debug('configuring bcrypt driver');
+            return () => new Bcrypt(config);
+        });
+    },
+    scrypt: (config) => {
+        return configProvider.create(async () => {
+            const { Scrypt } = await import('./drivers/scrypt.js');
+            debug('configuring scrypt driver');
+            return () => new Scrypt(config);
+        });
+    },
+};

package/build/modules/hash/drivers/argon.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/hash/drivers/argon';

package/build/modules/hash/drivers/argon.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export * from '@adonisjs/hash/drivers/argon';

package/build/modules/hash/drivers/bcrypt.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/hash/drivers/bcrypt';

package/build/modules/hash/drivers/bcrypt.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export * from '@adonisjs/hash/drivers/bcrypt';

package/build/modules/hash/drivers/scrypt.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/hash/drivers/scrypt';