@adonisjs/core 5.4.2 → 5.5.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 # The MIT License
 
-Copyright 2021 Harminder Virk, contributors
+Copyright 2022 Harminder Virk, contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -97,7 +97,7 @@
       Guides
     </a>
     <span> | </span>
-    <a href="CONTRIBUTING.md">
+    <a href=".github/CONTRIBUTING.md">
       Contributing
     </a>
   </h3>

package/build/adonis-typings/ace.d.ts

@@ -0,0 +1,5 @@
+declare module '@ioc:Adonis/Core/Ace' {
+    import { Kernel } from '@adonisjs/ace';
+    const Ace: Kernel;
+    export default Ace;
+}

package/build/adonis-typings/ace.js

@@ -0,0 +1,8 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */

package/build/adonis-typings/container.d.ts

@@ -1,4 +1,6 @@
 declare module '@ioc:Adonis/Core/Application' {
+    import Ace from '@ioc:Adonis/Core/Ace';
+    import { TestUtilsContract } from '@ioc:Adonis/Core/TestUtils';
     import { HealthCheckContract } from '@ioc:Adonis/Core/HealthCheck';
     import { AssetsManagerContract } from '@ioc:Adonis/Core/AssetsManager';
     import HttpExceptionHandler from '@ioc:Adonis/Core/HttpExceptionHandler';
@@ -6,5 +8,7 @@ declare module '@ioc:Adonis/Core/Application' {
         'Adonis/Core/HealthCheck': HealthCheckContract;
         'Adonis/Core/AssetsManager': AssetsManagerContract;
         'Adonis/Core/HttpExceptionHandler': typeof HttpExceptionHandler;
+        'Adonis/Core/Ace': typeof Ace;
+        'Adonis/Core/TestUtils': TestUtilsContract;
     }
 }

package/build/adonis-typings/index.d.ts

@@ -1,9 +1,11 @@
+/// <reference path="ace.d.ts" />
 /// <reference path="cors.d.ts" />
 /// <reference path="health-check.d.ts" />
 /// <reference path="exception-handler.d.ts" />
 /// <reference path="static.d.ts" />
 /// <reference path="assets-manager.d.ts" />
 /// <reference path="container.d.ts" />
+/// <reference path="test-utils.d.ts" />
 /// <reference types="@adonisjs/application/build/adonis-typings" />
 /// <reference types="@adonisjs/events/build/adonis-typings" />
 /// <reference types="@adonisjs/hash/build/adonis-typings" />

package/build/adonis-typings/index.js

@@ -14,9 +14,11 @@
 /// <reference path="../node_modules/@adonisjs/bodyparser/build/adonis-typings/index.d.ts" />
 /// <reference path="../node_modules/@adonisjs/validator/build/adonis-typings/index.d.ts" />
 /// <reference path="../node_modules/@adonisjs/drive/build/adonis-typings/index.d.ts" />
+/// <reference path="./ace.ts" />
 /// <reference path="./cors.ts" />
 /// <reference path="./health-check.ts" />
 /// <reference path="./exception-handler.ts" />
 /// <reference path="./static.ts" />
 /// <reference path="./assets-manager.ts" />
 /// <reference path="./container.ts" />
+/// <reference path="./test-utils.ts" />

package/build/adonis-typings/test-utils.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+declare module '@ioc:Adonis/Core/TestUtils' {
+    import type { Server as HttpsServer } from 'https';
+    import type { MacroableConstructorContract } from 'macroable';
+    import type { IncomingMessage, ServerResponse, Server } from 'http';
+    export type ServerHandler = (req: IncomingMessage, res: ServerResponse) => any;
+    export type CustomServerCallback = (handler: ServerHandler) => Server | HttpsServer;
+    export interface TestUtilsContract {
+        constructor: MacroableConstructorContract<TestUtilsContract>;
+        ace(): {
+            loadCommands(): Promise<void>;
+        };
+        httpServer(): {
+            start(serverCallback?: CustomServerCallback): Promise<() => Promise<void>>;
+        };
+    }
+    /**
+     * Test utils module is meant to be extended to add custom
+     * utilities required for testing AdonisJS applications.
+     */
+    const TestUtils: TestUtilsContract;
+    export default TestUtils;
+}

package/build/adonis-typings/test-utils.js

@@ -0,0 +1,8 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */

package/build/providers/AppProvider.d.ts

@@ -39,6 +39,16 @@ export default class AppProvider {
      * Registers base health checkers
      */
     protected registerHealthCheckers(): void;
+    /**
+     * Register ace kernel to the container. When the process is started
+     * by running an ace command, then the "Adonis/Core/Ace" binding
+     * will already be in place and hence we do not overwrite it.
+     */
+    protected registerAceKernel(): void;
+    /**
+     * Register utilities object required during testing
+     */
+    protected registerTestUtils(): void;
     /**
      * Define repl bindings
      */

package/build/providers/AppProvider.js

@@ -124,6 +124,28 @@ class AppProvider {
             require('../src/HealthCheck/Checkers/AppKey').default(healthCheck);
         });
     }
+    /**
+     * Register ace kernel to the container. When the process is started
+     * by running an ace command, then the "Adonis/Core/Ace" binding
+     * will already be in place and hence we do not overwrite it.
+     */
+    registerAceKernel() {
+        if (!this.app.container.hasBinding('Adonis/Core/Ace')) {
+            this.app.container.singleton('Adonis/Core/Ace', () => {
+                const { Kernel } = require('@adonisjs/ace');
+                return new Kernel(this.app);
+            });
+        }
+    }
+    /**
+     * Register utilities object required during testing
+     */
+    registerTestUtils() {
+        this.app.container.singleton('Adonis/Core/TestUtils', () => {
+            const { TestUtils } = require('../src/TestUtils');
+            return new TestUtils(this.app);
+        });
+    }
     /**
      * Define repl bindings
      */
@@ -150,6 +172,8 @@ class AppProvider {
         this.registerHttpExceptionHandler();
         this.registerHealthCheck();
         this.registerAssetsManager();
+        this.registerAceKernel();
+        this.registerTestUtils();
     }
     /**
      * Register hooks and health checkers on boot

package/build/src/Ignitor/Ace/App/index.d.ts

@@ -11,26 +11,13 @@ export declare class App {
      */
     private get isAssemblerCommand();
     /**
-     * Whether or not the app was wired. App is only wired, when
-     * loadApp inside the command setting is true.
-     */
-    private wired;
-    /**
-     * Reference to the application
-     */
-    private application;
-    /**
-     * Reference to the ace kernel
+     * Reference to the app kernel
      */
     private kernel;
     /**
-     * Signals listener to listen for exit signals and kill command
-     */
-    private signalsListener;
-    /**
-     * Find if TS hook has been registered or not
+     * Reference to the ace kernel
      */
-    private registeredTsHook;
+    private ace;
     /**
      * Source root always points to the compiled source
      * code.
@@ -54,26 +41,18 @@ export declare class App {
      */
     private onRun;
     /**
-     * Hooks into kernel lifecycle events to conditionally
+     * Hooks into ace lifecycle events to conditionally
      * load the app.
      */
-    private addKernelHooks;
+    private registerAceHooks;
     /**
      * Adding flags
      */
-    private addKernelFlags;
-    /**
-     * Boot the application.
-     */
-    private wire;
-    /**
-     * Returns manifest details for assembler
-     */
-    private getAssemblerManifest;
+    private registerAceFlags;
     /**
-     * Returns manifest details for app
+     * Load commands using manifest loader
      */
-    private getAppManifest;
+    loadCommands(): Promise<void>;
     /**
      * Handle application command
      */

package/build/src/Ignitor/Ace/App/index.js

@@ -9,14 +9,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.App = void 0;
-const path_1 = require("path");
-const cliui_1 = require("@poppinss/cliui");
-const application_1 = require("@adonisjs/application");
 const ace_1 = require("@adonisjs/ace");
+const cliui_1 = require("@poppinss/cliui");
 const helpers_1 = require("@poppinss/utils/build/helpers");
-const ErrorHandler_1 = require("../ErrorHandler");
+const Kernel_1 = require("../../Kernel");
 const utils_1 = require("../../../utils");
-const SignalsListener_1 = require("../../SignalsListener");
 const GenerateManifest_1 = require("../GenerateManifest");
 /**
  * A local list of assembler commands. We need this, so that when assembler
@@ -53,26 +50,13 @@ class App {
     constructor(appRoot) {
         this.appRoot = appRoot;
         /**
-         * Whether or not the app was wired. App is only wired, when
-         * loadApp inside the command setting is true.
+         * Reference to the app kernel
          */
-        this.wired = false;
-        /**
-         * Reference to the application
-         */
-        this.application = new application_1.Application(this.appRoot, 'console');
+        this.kernel = new Kernel_1.AppKernel(this.appRoot, 'console');
         /**
          * Reference to the ace kernel
          */
-        this.kernel = new ace_1.Kernel(this.application);
-        /**
-         * Signals listener to listen for exit signals and kill command
-         */
-        this.signalsListener = new SignalsListener_1.SignalsListener(this.application);
-        /**
-         * Find if TS hook has been registered or not
-         */
-        this.registeredTsHook = false;
+        this.ace = new ace_1.Kernel(this.kernel.application);
     }
     /**
      * Returns a boolean if mentioned command is an assembler
@@ -88,7 +72,7 @@ class App {
         if (!value) {
             return;
         }
-        this.kernel.printHelp(command, [GenerateManifest_1.GenerateManifest.getManifestJSON()]);
+        this.ace.printHelp(command, [GenerateManifest_1.GenerateManifest.getManifestJSON()]);
         process.exit(0);
     }
     /**
@@ -98,8 +82,8 @@ class App {
         if (!value) {
             return;
         }
-        const appVersion = this.application.version;
-        const adonisVersion = this.application.adonisVersion;
+        const appVersion = this.kernel.application.version;
+        const adonisVersion = this.kernel.application.adonisVersion;
         let assemblerVersion = 'Not Installed';
         try {
             assemblerVersion = require((0, helpers_1.resolveFrom)(this.appRoot, '@adonisjs/assembler/package.json')).version;
@@ -128,105 +112,69 @@ class App {
          * - Is a typescript project
          * - Is not an assembler command
          */
-        if (!this.registeredTsHook && this.application.rcFile.typescript && !this.isAssemblerCommand) {
-            (0, utils_1.registerTsHook)(this.application.appRoot);
-            this.registeredTsHook = true;
+        if (!this.isAssemblerCommand) {
+            this.kernel.registerTsCompilerHook();
         }
         /**
-         * Wire application if not wired and "loadApp" is true
+         * Only main command can load the application or switch
+         * the environment.
+         *
+         * If a sub-command needs application, then the main command
+         * should set "loadApp" to true as well.
          */
-        if (!this.wired && command.settings.loadApp) {
+        if (command.commandName === this.commandName) {
             /**
              * Switch environment before wiring the app
              */
             if (command.settings.environment) {
-                this.application.switchEnvironment(command.settings.environment);
+                this.kernel.application.switchEnvironment(command.settings.environment);
+            }
+            if (command.settings.loadApp) {
+                /**
+                 * Set ace instance within the container, so that the underlying
+                 * commands or the app can access it from the container
+                 */
+                this.kernel.application.container.singleton('Adonis/Core/Ace', () => this.ace);
+                await this.kernel.boot();
             }
-            await this.wire();
         }
     }
     /**
      * Invoked before command is about to run.
      */
     async onRun() {
-        if (this.wired) {
-            await this.application.start();
+        if (this.kernel.hasBooted) {
+            await this.kernel.start();
         }
     }
     /**
-     * Hooks into kernel lifecycle events to conditionally
+     * Hooks into ace lifecycle events to conditionally
      * load the app.
      */
-    addKernelHooks() {
-        this.kernel.before('find', async (command) => this.onFind(command));
-        this.kernel.before('run', async () => this.onRun());
+    registerAceHooks() {
+        this.ace.before('find', async (command) => this.onFind(command));
+        this.ace.before('run', async () => this.onRun());
     }
     /**
      * Adding flags
      */
-    addKernelFlags() {
+    registerAceFlags() {
         /**
          * Showing help including core commands
          */
-        this.kernel.flag('help', async (value, _, command) => this.printHelp(value, command), {
+        this.ace.flag('help', async (value, _, command) => this.printHelp(value, command), {
             alias: 'h',
         });
         /**
          * Showing app and AdonisJs version
          */
-        this.kernel.flag('version', async (value) => this.printVersion(value), { alias: 'v' });
-    }
-    /**
-     * Boot the application.
-     */
-    async wire() {
-        if (this.wired) {
-            return;
-        }
-        this.wired = true;
-        /**
-         * Do not change sequence
-         */
-        await this.application.setup();
-        await this.application.registerProviders();
-        await this.application.bootProviders();
-        await this.application.requirePreloads();
+        this.ace.flag('version', async (value) => this.printVersion(value), { alias: 'v' });
     }
     /**
-     * Returns manifest details for assembler
+     * Load commands using manifest loader
      */
-    getAssemblerManifest() {
-        try {
-            const manifestAbsPath = (0, helpers_1.resolveFrom)(this.application.appRoot, '@adonisjs/assembler/build/ace-manifest.json');
-            const basePath = (0, path_1.join)(manifestAbsPath, '../');
-            return [
-                {
-                    manifestAbsPath,
-                    basePath,
-                },
-            ];
-        }
-        catch (error) {
-            return [];
-        }
-    }
-    /**
-     * Returns manifest details for app
-     */
-    getAppManifest() {
-        try {
-            const manifestAbsPath = (0, helpers_1.resolveFrom)(this.application.appRoot, './ace-manifest.json');
-            const basePath = this.application.appRoot;
-            return [
-                {
-                    manifestAbsPath,
-                    basePath,
-                },
-            ];
-        }
-        catch (error) {
-            return [];
-        }
+    async loadCommands() {
+        await (0, utils_1.loadAceCommands)(this.kernel.application, this.ace);
     }
     /**
      * Handle application command
@@ -236,20 +184,15 @@ class App {
             /**
              * Manifest files to load
              */
-            this.kernel.useManifest(new ace_1.ManifestLoader(this.getAssemblerManifest().concat(this.getAppManifest())));
+            await this.loadCommands();
             /**
-             * Define kernel hooks to wire the application (if required)
+             * Define ace hooks to wire the application (if required)
              */
-            this.addKernelHooks();
+            this.registerAceHooks();
             /**
              * Define global flags
              */
-            this.addKernelFlags();
-            /**
-             * Preload manifest in advance. This way we can show the help
-             * when no args are defined
-             */
-            await this.kernel.preloadManifest();
+            this.registerAceFlags();
             /**
              * Print help when no arguments have been passed
              */
@@ -263,33 +206,27 @@ class App {
              * executed
              */
             this.commandName = argv[0];
-            /**
-             * Listen for exit events and shutdown app
-             */
-            this.signalsListener.listen(async () => {
-                if (this.wired) {
-                    await this.application.shutdown();
-                }
-            });
             /**
              * Listen for the exit signal on ace kernel
              */
-            this.kernel.onExit(async () => {
-                if (this.kernel.error) {
-                    await new ErrorHandler_1.ErrorHandler(this.application).handleError(this.kernel.error);
+            this.ace.onExit(async () => {
+                if (!this.ace.error) {
+                    process.exit(this.ace.exitCode);
                 }
-                process.exit(this.kernel.exitCode);
+                return this.kernel
+                    .handleError(this.ace.error)
+                    .finally(() => process.exit(this.ace.exitCode));
             });
             /**
              * Handle command
              */
-            await this.kernel.handle(argv);
+            await this.ace.handle(argv);
         }
         catch (error) {
             if (!error) {
                 process.exit(1);
             }
-            new ErrorHandler_1.ErrorHandler(this.application).handleError(error).finally(() => process.exit(1));
+            this.kernel.handleError(error).finally(() => process.exit(1));
         }
     }
 }

package/build/src/Ignitor/Ace/GenerateManifest/index.d.ts

@@ -3,7 +3,7 @@
  */
 export declare class GenerateManifest {
     private appRoot;
-    private application;
+    private kernel;
     /**
      * Source root always points to the compiled source
      * code.

package/build/src/Ignitor/Ace/GenerateManifest/index.js

@@ -11,9 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateManifest = void 0;
 const cliui_1 = require("@poppinss/cliui");
 const ace_1 = require("@adonisjs/ace");
-const application_1 = require("@adonisjs/application");
-const ErrorHandler_1 = require("../ErrorHandler");
-const utils_1 = require("../../../utils");
+const Kernel_1 = require("../../Kernel");
 const Exceptions_1 = require("../Exceptions");
 /**
  * Exposes the API to generate the manifest file
@@ -25,7 +23,7 @@ class GenerateManifest {
      */
     constructor(appRoot) {
         this.appRoot = appRoot;
-        this.application = new application_1.Application(this.appRoot, 'console');
+        this.kernel = new Kernel_1.AppKernel(this.appRoot, 'console');
     }
     /**
      * Returns manifest object for showing help
@@ -46,27 +44,22 @@ class GenerateManifest {
      */
     async handle() {
         try {
-            /**
-             * Register ts hook when running typescript code directly
-             */
-            if (this.application.rcFile.typescript) {
-                (0, utils_1.registerTsHook)(this.application.appRoot);
-            }
-            const commands = this.application.rcFile.commands;
+            this.kernel.registerTsCompilerHook();
+            const commands = this.kernel.application.rcFile.commands;
             /**
              * Generating manifest requires us to import the command files to read their
              * meta data defined as class static properties. However, at this stage
              * the application is not booted and hence top level IoC container
              * imports will break
              */
-            this.application.container.trap((namespace) => {
+            this.kernel.application.container.trap((namespace) => {
                 if (namespace === 'Adonis/Core/Application') {
-                    return this.application;
+                    return this.kernel.application;
                 }
                 return {
                     __esModule: new Proxy({ namespace }, {
                         get(target) {
-                            throw new Exceptions_1.AceRuntimeException(`Top level import for module "${target.namespace}" is not allowed in commands. Learn more https://preview.adonisjs.com/guides/ace/introduction`);
+                            throw new Exceptions_1.AceRuntimeException(`Top level import for module "${target.namespace}" is not allowed in commands. Learn more https://docs.adonisjs.com/guides/ace-commandline#top-level-imports-are-not-allowed`);
                         },
                     }),
                 };
@@ -75,7 +68,7 @@ class GenerateManifest {
             cliui_1.logger.action('create').succeeded('ace-manifest.json file');
         }
         catch (error) {
-            await new ErrorHandler_1.ErrorHandler(this.application).handleError(error);
+            await this.kernel.handleError(error).finally(() => process.exit(1));
         }
     }
 }

package/build/src/Ignitor/HttpServer/index.d.ts

@@ -1,55 +1,34 @@
-/// <reference types="node" />
-import { Server as HttpsServer } from 'https';
-import { Application } from '@adonisjs/application';
-import { IncomingMessage, ServerResponse, Server } from 'http';
-declare type ServerHandler = (req: IncomingMessage, res: ServerResponse) => any;
-declare type CustomServerCallback = (handler: ServerHandler) => Server | HttpsServer;
+import { CustomServerCallback } from '@ioc:Adonis/Core/TestUtils';
+import { AppKernel } from '../Kernel';
 /**
  * Exposes the API to setup the application for starting the HTTP
  * server.
+ *
+ * - Calling "kill" explicitly exists the process.
+ * - The "error" event emitted on the server instance explicitly exists the process.
+ * - SIGINT and in some case SIGTERM explicitly exists the process.
  */
 export declare class HttpServer {
     private appRoot;
     /**
-     * Reference to core http server.
+     * Reference to the HTTP server.
      */
     private server;
     /**
-     * Whether or not the application has been wired.
+     * Reference to the app kernel
      */
-    private wired;
-    /**
-     * Reference to the application.
-     */
-    application: Application;
-    /**
-     * Listens for unix signals to kill long running
-     * processes.
-     */
-    private signalsListener;
+    kernel: AppKernel;
+    application: import("@adonisjs/application").Application;
     constructor(appRoot: string);
-    /**
-     * Wires up everything, so that we are ready to kick start
-     * the HTTP server.
-     */
-    private wire;
-    /**
-     * Sets the server reference
-     */
-    private setServer;
     /**
      * Closes the underlying HTTP server
      */
     private closeHttpServer;
     /**
      * Monitors the HTTP server for close and error events, so that
-     * we can perform a graceful shutdown
+     * we can perform a graceful shutdown.
      */
     private monitorHttpServer;
-    /**
-     * Notify server is ready
-     */
-    private notifyServerReady;
     /**
      * Creates the HTTP server to handle incoming requests. The server is just
      * created but not listening on any port.
@@ -75,4 +54,3 @@ export declare class HttpServer {
      */
     kill(waitTimeout?: number): Promise<void>;
 }
-export {};