@adonisjs/core 5.4.1 → 5.5.1

package/build/src/Ignitor/HttpServer/index.js

@@ -9,61 +9,24 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpServer = void 0;
-const application_1 = require("@adonisjs/application");
-const http_1 = require("http");
-const ErrorHandler_1 = require("./ErrorHandler");
-const SignalsListener_1 = require("../SignalsListener");
+const Kernel_1 = require("../Kernel");
+const utils_1 = require("../../utils");
 /**
  * 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.
  */
 class HttpServer {
     constructor(appRoot) {
         this.appRoot = appRoot;
         /**
-         * Whether or not the application has been wired.
-         */
-        this.wired = false;
-        /**
-         * Reference to the application.
-         */
-        this.application = new application_1.Application(this.appRoot, 'web');
-        /**
-         * Listens for unix signals to kill long running
-         * processes.
-         */
-        this.signalsListener = new SignalsListener_1.SignalsListener(this.application);
-    }
-    /**
-     * Wires up everything, so that we are ready to kick start
-     * the HTTP server.
-     */
-    async wire() {
-        if (this.wired) {
-            return;
-        }
-        /**
-         * Setting up the application.
-         */
-        await this.application.setup();
-        /**
-         * Registering providers
-         */
-        await this.application.registerProviders();
-        /**
-         * Booting providers
-         */
-        await this.application.bootProviders();
-        /**
-         * Importing preloaded files
+         * Reference to the app kernel
          */
-        await this.application.requirePreloads();
-    }
-    /**
-     * Sets the server reference
-     */
-    setServer() {
-        this.server = this.application.container.use('Adonis/Core/Server');
+        this.kernel = new Kernel_1.AppKernel(this.appRoot, 'web');
+        this.application = this.kernel.application;
     }
     /**
      * Closes the underlying HTTP server
@@ -73,7 +36,7 @@ class HttpServer {
     }
     /**
      * Monitors the HTTP server for close and error events, so that
-     * we can perform a graceful shutdown
+     * we can perform a graceful shutdown.
      */
     monitorHttpServer() {
         this.server.instance.on('close', async () => {
@@ -82,42 +45,17 @@ class HttpServer {
             this.application.isShuttingDown = true;
         });
         this.server.instance.on('error', async (error) => {
-            if (error.code === 'EADDRINUSE') {
-                this.application.logger.error('Port in use, closing server');
-                process.exitCode = 1;
-                return;
-            }
+            this.application.logger.error(error, error.message);
             await this.kill(3000);
         });
     }
-    /**
-     * Notify server is ready
-     */
-    notifyServerReady(host, port) {
-        this.application.logger.info('started server on %s:%s', host, port);
-        if (process.send) {
-            process.send({ origin: 'adonis-http-server', ready: true, port: port, host: host });
-        }
-    }
     /**
      * Creates the HTTP server to handle incoming requests. The server is just
      * created but not listening on any port.
      */
     createServer(serverCallback) {
-        /**
-         * Optimizing the server by pre-compiling routes and middleware
-         */
-        this.application.logger.trace('optimizing http server handler');
-        this.server.optimize();
-        /**
-         * Bind exception handler to handle exceptions occured during HTTP requests.
-         */
-        if (this.application.exceptionHandlerNamespace) {
-            this.application.logger.trace('binding %s exception handler', this.application.exceptionHandlerNamespace);
-            this.server.errorHandler(this.application.exceptionHandlerNamespace);
-        }
-        const handler = this.server.handle.bind(this.server);
-        this.server.instance = serverCallback ? serverCallback(handler) : (0, http_1.createServer)(handler);
+        this.server = this.application.container.use('Adonis/Core/Server');
+        (0, utils_1.createHttpServer)(this.application, this.server, serverCallback);
     }
     /**
      * Starts the http server a given host and port
@@ -125,11 +63,12 @@ class HttpServer {
     listen() {
         return new Promise(async (resolve, reject) => {
             try {
-                await this.application.start();
+                await this.kernel.start(() => this.close());
                 const host = this.application.env.get('HOST', '0.0.0.0');
                 const port = Number(this.application.env.get('PORT', '3333'));
                 this.server.instance.listen(port, host, () => {
-                    this.notifyServerReady(host, port);
+                    this.application.logger.info('started server on %s:%s', host, port);
+                    this.kernel.ready({ port: port, host: host });
                     resolve();
                 });
             }
@@ -143,15 +82,13 @@ class HttpServer {
      */
     async start(serverCallback) {
         try {
-            await this.wire();
-            this.setServer();
+            await this.kernel.boot();
             this.createServer(serverCallback);
             this.monitorHttpServer();
             await this.listen();
-            this.signalsListener.listen(() => this.close());
         }
         catch (error) {
-            await new ErrorHandler_1.ErrorHandler(this.application).handleError(error);
+            await this.kernel.handleError(error);
         }
     }
     /**
@@ -164,8 +101,7 @@ class HttpServer {
          * we are not accepting any new request during cool off.
          */
         await this.closeHttpServer();
-        this.signalsListener.cleanup();
-        await this.application.shutdown();
+        await this.kernel.close();
     }
     /**
      * Kills the http server process by attempting to perform a graceful
@@ -184,7 +120,7 @@ class HttpServer {
             process.exit(0);
         }
         catch (error) {
-            new ErrorHandler_1.ErrorHandler(this.application).handleError(error).finally(() => process.exit(1));
+            await this.kernel.handleError(error).finally(() => process.exit(1));
         }
     }
 }

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

@@ -0,0 +1,56 @@
+import { Application } from '@adonisjs/application';
+import { AppEnvironments } from '@ioc:Adonis/Core/Application';
+import { SignalsListener } from '../SignalsListener';
+/**
+ * Kernel to manage application state
+ */
+export declare class AppKernel {
+    /**
+     * Reference to application instance
+     */
+    application: Application;
+    /**
+     * Reference to signals listener
+     */
+    signalsListener: SignalsListener;
+    /**
+     * Find if the application has been booted or not
+     */
+    hasBooted: boolean;
+    /**
+     * Avoiding duplicate registeration of ts compiler hook
+     */
+    private hasRegisteredTsHook;
+    constructor(appRoot: string, environment: AppEnvironments);
+    /**
+     * Pretty prints a given error on the terminal
+     */
+    private prettyPrintError;
+    /**
+     * Boot the application. The process for booting the app remains the
+     * same regardless of the process environment.
+     */
+    boot(): Promise<void>;
+    /**
+     * Registers the TS compiler to hook into node require and
+     * process TypeScript files
+     */
+    registerTsCompilerHook(): void;
+    /**
+     * Start the application. The callback is required to listen
+     * for close signals
+     */
+    start(shutdownCallback?: () => Promise<void>): Promise<() => Promise<void>>;
+    /**
+     * Notify that process is ready
+     */
+    ready(eventPayload: Record<string, any>): void;
+    /**
+     * Prepare application for shutdown
+     */
+    close(): Promise<void>;
+    /**
+     * Handles ignitor boot errors
+     */
+    handleError(error: any): Promise<void>;
+}

package/build/src/Ignitor/Kernel/index.js

@@ -0,0 +1,123 @@
+"use strict";
+/*
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppKernel = void 0;
+const application_1 = require("@adonisjs/application");
+const utils_1 = require("../../utils");
+const SignalsListener_1 = require("../SignalsListener");
+/**
+ * Kernel to manage application state
+ */
+class AppKernel {
+    constructor(appRoot, environment) {
+        /**
+         * Find if the application has been booted or not
+         */
+        this.hasBooted = false;
+        /**
+         * Avoiding duplicate registeration of ts compiler hook
+         */
+        this.hasRegisteredTsHook = false;
+        this.application = new application_1.Application(appRoot, environment);
+        this.signalsListener = new SignalsListener_1.SignalsListener(this.application);
+    }
+    /**
+     * Pretty prints a given error on the terminal
+     */
+    async prettyPrintError(error) {
+        try {
+            const Youch = require('youch');
+            const output = await new Youch(error, {}).toJSON();
+            console.log(require('youch-terminal')(output));
+        }
+        catch {
+            console.log(error.stack);
+        }
+    }
+    /**
+     * Boot the application. The process for booting the app remains the
+     * same regardless of the process environment.
+     */
+    async boot() {
+        if (this.hasBooted) {
+            return;
+        }
+        /**
+         * Setting up the application.
+         */
+        await this.application.setup();
+        /**
+         * Registering providers
+         */
+        await this.application.registerProviders();
+        /**
+         * Booting providers
+         */
+        await this.application.bootProviders();
+        /**
+         * Importing preloaded files
+         */
+        await this.application.requirePreloads();
+        this.hasBooted = true;
+    }
+    /**
+     * Registers the TS compiler to hook into node require and
+     * process TypeScript files
+     */
+    registerTsCompilerHook() {
+        /**
+         * Register ts hook when running typescript code directly
+         */
+        if (this.application.rcFile.typescript && !this.hasRegisteredTsHook) {
+            this.hasRegisteredTsHook = true;
+            (0, utils_1.registerTsHook)(this.application.appRoot);
+        }
+    }
+    /**
+     * Start the application. The callback is required to listen
+     * for close signals
+     */
+    async start(shutdownCallback) {
+        await this.application.start();
+        this.signalsListener.listen(shutdownCallback || (() => this.close()));
+        return () => this.close();
+    }
+    /**
+     * Notify that process is ready
+     */
+    ready(eventPayload) {
+        if (process.send) {
+            process.send('ready');
+            process.send({ isAdonisJS: true, environment: this.application.environment, ...eventPayload });
+        }
+    }
+    /**
+     * Prepare application for shutdown
+     */
+    async close() {
+        this.signalsListener.cleanup();
+        await this.application.shutdown();
+    }
+    /**
+     * Handles ignitor boot errors
+     */
+    async handleError(error) {
+        if (typeof error.handle === 'function') {
+            await error.handle(error);
+        }
+        else if (this.application.inDev) {
+            await this.prettyPrintError(error);
+        }
+        else {
+            console.error(error.stack);
+        }
+    }
+}
+exports.AppKernel = AppKernel;

package/build/src/Ignitor/SignalsListener/index.js

@@ -21,7 +21,12 @@ class SignalsListener {
          */
         this.kill = async function () {
             try {
-                await this.onCloseCallback();
+                await Promise.race([
+                    this.onCloseCallback(),
+                    new Promise((resolve) => {
+                        setTimeout(resolve, 3000);
+                    }),
+                ]);
                 process.exit(0);
             }
             catch (error) {
@@ -35,20 +40,18 @@ class SignalsListener {
      */
     listen(callback) {
         this.onCloseCallback = callback;
+        /**
+         * Close on SIGINT AND SIGTERM SIGNALS
+         */
         if (process.env.pm_id) {
-            process.once('SIGINT', this.kill);
+            process.on('SIGINT', this.kill);
         }
-        process.once('SIGTERM', this.kill);
+        process.on('SIGTERM', this.kill);
         /**
-         * Cleanup on uncaught exceptions.
+         * Notify about uncaught exceptions
          */
-        process.once('uncaughtException', (error) => {
-            if (this.application.environment === 'repl') {
-                this.application.logger.fatal(error, '"uncaughtException" detected');
-                return;
-            }
-            this.application.logger.fatal(error, '"uncaughtException" detected. Process will shutdown');
-            process.exit(1);
+        process.on('uncaughtExceptionMonitor', (error) => {
+            this.application.logger.fatal(error, '"uncaughtException" detected');
         });
     }
     /**

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

@@ -2,6 +2,7 @@ import { Application } from '@adonisjs/application';
 import { AppEnvironments } from '@ioc:Adonis/Core/Application';
 import { Ace } from './Ace';
 import { HttpServer } from './HttpServer';
+import { AppKernel } from './Kernel';
 /**
  * Ignitor is used to wireup different pieces of AdonisJs to bootstrap
  * the application.
@@ -18,6 +19,11 @@ export declare class Ignitor {
      * the HTTP server
      */
     httpServer(): HttpServer;
+    /**
+     * Returns instance of server to start
+     * the HTTP server
+     */
+    kernel(environment: AppEnvironments): AppKernel;
     /**
      * Returns instance of ace to handle console
      * commands

package/build/src/Ignitor/index.js

@@ -14,13 +14,17 @@ const url_1 = require("url");
 const application_1 = require("@adonisjs/application");
 const Ace_1 = require("./Ace");
 const HttpServer_1 = require("./HttpServer");
+const Kernel_1 = require("./Kernel");
 /**
  * Ignitor is used to wireup different pieces of AdonisJs to bootstrap
  * the application.
  */
 class Ignitor {
     constructor(appRoot) {
-        // In ESM, ignitor is constructed with `import.meta.url`. Normalize the file URL to an absolute directory path.
+        /**
+         * In ESM, ignitor is constructed with `import.meta.url`. Normalize
+         * the file URL to an absolute directory path.
+         */
         this.appRoot = appRoot.startsWith('file:') ? (0, path_1.dirname)((0, url_1.fileURLToPath)(appRoot)) : appRoot;
     }
     /**
@@ -36,6 +40,13 @@ class Ignitor {
     httpServer() {
         return new HttpServer_1.HttpServer(this.appRoot);
     }
+    /**
+     * Returns instance of server to start
+     * the HTTP server
+     */
+    kernel(environment) {
+        return new Kernel_1.AppKernel(this.appRoot, environment);
+    }
     /**
      * Returns instance of ace to handle console
      * commands

package/build/src/TestUtils/Ace/index.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/src/TestUtils/HttpServer/index.d.ts

@@ -0,0 +1,27 @@
+import { ApplicationContract } from '@ioc:Adonis/Core/Application';
+import { CustomServerCallback } from '@ioc:Adonis/Core/TestUtils';
+/**
+ * The test HTTP server to handle and serve HTTP request
+ */
+export declare class TestHttpServer {
+    application: ApplicationContract;
+    private server;
+    constructor(application: ApplicationContract);
+    /**
+     * Creates the HTTP server to handle incoming requests. The server is just
+     * created but not listening on any port.
+     */
+    private create;
+    /**
+     * Start the HTTP server to listen for incoming requests
+     */
+    private listen;
+    /**
+     * Close HTTP server from listening to any requests
+     */
+    close(): Promise<void>;
+    /**
+     * Start the test HTTP server
+     */
+    start(serverCallback?: CustomServerCallback): Promise<() => Promise<void>>;
+}

package/build/src/TestUtils/HttpServer/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestHttpServer = void 0;
+const utils_1 = require("../../utils");
+/**
+ * The test HTTP server to handle and serve HTTP request
+ */
+class TestHttpServer {
+    constructor(application) {
+        this.application = application;
+    }
+    /**
+     * Creates the HTTP server to handle incoming requests. The server is just
+     * created but not listening on any port.
+     */
+    create(serverCallback) {
+        this.server = this.application.container.use('Adonis/Core/Server');
+        (0, utils_1.createHttpServer)(this.application, this.server, serverCallback);
+    }
+    /**
+     * Start the HTTP server to listen for incoming requests
+     */
+    listen() {
+        const host = this.application.env.get('HOST', '0.0.0.0');
+        const port = Number(this.application.env.get('PORT', '3333'));
+        return new Promise((resolve) => {
+            this.server.instance.listen(port, host, () => {
+                this.application.logger.info('started server on %s:%s', host, port);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Close HTTP server from listening to any requests
+     */
+    close() {
+        return new Promise((resolve) => this.server.instance.close(() => resolve()));
+    }
+    /**
+     * Start the test HTTP server
+     */
+    async start(serverCallback) {
+        this.create(serverCallback);
+        await this.listen();
+        return () => this.close();
+    }
+}
+exports.TestHttpServer = TestHttpServer;

package/build/src/TestUtils/index.d.ts

@@ -0,0 +1,24 @@
+import { Macroable } from 'macroable';
+import { TestUtilsContract } from '@ioc:Adonis/Core/TestUtils';
+import { ApplicationContract } from '@ioc:Adonis/Core/Application';
+import { TestHttpServer } from './HttpServer';
+/**
+ * Test utils module is meant to be extended to add custom
+ * utilities required for testing AdonisJS applications.
+ */
+export declare class TestUtils extends Macroable implements Omit<TestUtilsContract, 'constructor'> {
+    application: ApplicationContract;
+    static macros: {};
+    static getters: {};
+    constructor(application: ApplicationContract);
+    /**
+     * Utilities for ace
+     */
+    ace(): {
+        loadCommands: () => Promise<void>;
+    };
+    /**
+     * Utilities for http server
+     */
+    httpServer(): TestHttpServer;
+}

package/build/src/TestUtils/index.js

@@ -0,0 +1,43 @@
+"use strict";
+/*
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestUtils = void 0;
+const macroable_1 = require("macroable");
+const utils_1 = require("../utils");
+const HttpServer_1 = require("./HttpServer");
+/**
+ * Test utils module is meant to be extended to add custom
+ * utilities required for testing AdonisJS applications.
+ */
+class TestUtils extends macroable_1.Macroable {
+    constructor(application) {
+        super();
+        this.application = application;
+    }
+    /**
+     * Utilities for ace
+     */
+    ace() {
+        return {
+            loadCommands: () => {
+                return (0, utils_1.loadAceCommands)(this.application, this.application.container.resolveBinding('Adonis/Core/Ace'));
+            },
+        };
+    }
+    /**
+     * Utilities for http server
+     */
+    httpServer() {
+        return new HttpServer_1.TestHttpServer(this.application);
+    }
+}
+exports.TestUtils = TestUtils;
+TestUtils.macros = {};
+TestUtils.getters = {};

package/build/src/utils/index.d.ts

@@ -1,10 +1,17 @@
-/// <reference types="node" />
-/**
- * Helper to know if error belongs to a missing module
- * error
- */
-export declare function isMissingModuleError(error: NodeJS.ErrnoException): boolean;
+import { Kernel } from '@adonisjs/ace';
+import { ServerContract } from '@ioc:Adonis/Core/Server';
+import { CustomServerCallback } from '@ioc:Adonis/Core/TestUtils';
+import { ApplicationContract } from '@ioc:Adonis/Core/Application';
 /**
  * Registers the ts hook to compile typescript code within the memory
  */
 export declare function registerTsHook(appRoot: string): void;
+/**
+ * Creates the AdonisJS HTTP server. The method is abstracted to be used by
+ * test utils and the HTTP server process both.
+ */
+export declare function createHttpServer(application: ApplicationContract, server: ServerContract, callback?: CustomServerCallback): void;
+/**
+ * Loads ace commands from the assembler manifest and the app manifest files
+ */
+export declare function loadAceCommands(application: ApplicationContract, ace: Kernel): Promise<void>;