@adonisjs/core 5.5.3 → 5.6.0

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

@@ -6,6 +6,7 @@
 /// <reference path="assets-manager.d.ts" />
 /// <reference path="container.d.ts" />
 /// <reference path="test-utils.d.ts" />
+/// <reference path="tests.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

@@ -22,3 +22,4 @@
 /// <reference path="./assets-manager.ts" />
 /// <reference path="./container.ts" />
 /// <reference path="./test-utils.ts" />
+/// <reference path="./tests.ts" />

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

@@ -0,0 +1,13 @@
+import '@japa/api-client';
+declare module '@japa/api-client' {
+    interface ApiRequest {
+        /**
+         * Define encrypted cookie
+         */
+        encryptedCookie(key: string, value: any): this;
+        /**
+         * Define plain cookie
+         */
+        plainCookie(key: string, value: any): this;
+    }
+}

package/build/{src/TestUtils/Ace/index.js → adonis-typings/tests.js}

@@ -1,8 +1,11 @@
+"use strict";
 /*
  * @adonisjs/core
  *
- * (c) Harminder Virk <virk@adonisjs.com>
+ * (c) AdonisJS
  *
  * 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 });
+require("@japa/api-client");

package/build/commands/ListRoutes/Renderers/Base.d.ts

@@ -0,0 +1,31 @@
+import { BaseCommand } from '@adonisjs/core/build/standalone';
+import ListRoutes from '..';
+export declare class BaseRender {
+    protected command: ListRoutes;
+    constructor(command: ListRoutes);
+    /**
+     * The colors associated with each HTTP method
+     */
+    private methodColors;
+    /**
+     * Returns the color name for a HTTP method
+     */
+    getHttpMethodColor(method: string): keyof BaseCommand['colors'];
+    /**
+     * Find if the route contains all the methods registered by
+     * the "Route.any" method
+     */
+    hasAllMethods(methods: string[]): boolean;
+    /**
+     * Colorize the route methods
+     */
+    colorizeRouteMethods(methods: string[]): string;
+    /**
+     * Colorize the route pattern
+     */
+    colorizeRoutePattern(pattern: string): string;
+    /**
+     * Returns the rendering width.
+     */
+    getRenderingWidth(): number;
+}

package/build/commands/ListRoutes/Renderers/Base.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * 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.BaseRender = void 0;
+/**
+ * Methods registered by "Route.any" method
+ */
+const ALL_METHODS = ['HEAD', 'OPTIONS', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+class BaseRender {
+    constructor(command) {
+        this.command = command;
+        /**
+         * The colors associated with each HTTP method
+         */
+        this.methodColors = {
+            GET: 'cyan',
+            POST: 'green',
+            PUT: 'yellow',
+            PATCH: 'yellow',
+            DELETE: 'red',
+            HEAD: 'gray',
+        };
+    }
+    /**
+     * Returns the color name for a HTTP method
+     */
+    getHttpMethodColor(method) {
+        const methodColor = this.methodColors[method];
+        return methodColor ? methodColor : 'gray';
+    }
+    /**
+     * Find if the route contains all the methods registered by
+     * the "Route.any" method
+     */
+    hasAllMethods(methods) {
+        return ALL_METHODS.every((method) => methods.includes(method));
+    }
+    /**
+     * Colorize the route methods
+     */
+    colorizeRouteMethods(methods) {
+        return this.hasAllMethods(methods)
+            ? this.command.colors.cyan('ANY')
+            : methods
+                .map((method) => this.command.colors[this.getHttpMethodColor(method)](method))
+                .join(this.command.colors.gray('|'));
+    }
+    /**
+     * Colorize the route pattern
+     */
+    colorizeRoutePattern(pattern) {
+        return pattern
+            .replace(/:([^/]+)/gm, `${this.command.colors.yellow('$&')}`)
+            .replace(/\*/gm, `${this.command.colors.red('$&')}`);
+    }
+    /**
+     * Returns the rendering width.
+     */
+    getRenderingWidth() {
+        return this.command.maxWidth || process.stdout.columns || 80;
+    }
+}
+exports.BaseRender = BaseRender;

package/build/commands/ListRoutes/Renderers/PrettyRenderer.d.ts

@@ -0,0 +1,51 @@
+import { BaseRender } from './Base';
+import ListRoutes from '../index';
+/**
+ * Renders the routes as a pretty list
+ */
+export declare class RoutesPrettyRenderer extends BaseRender {
+    private routes;
+    private renderingWidth;
+    private longestMethodName;
+    constructor(command: ListRoutes);
+    /**
+     * Returns a list of serialized routes
+     */
+    private serializeRotues;
+    /**
+     * Returns the name of the longest method name
+     * across all the routes
+     */
+    private findLongestMethodName;
+    /**
+     * Render a single route by concatenating and colorizing each part of it
+     */
+    private outputRoute;
+    /**
+     * Log message
+     */
+    private log;
+    /**
+     * Crop the handler name
+     */
+    private cropHandlerName;
+    /**
+     * Returns the whitespace to be rendered between the
+     * route methods and the route pattern
+     */
+    private getWhiteSpace;
+    /**
+     * Returns the rendering width with and without the
+     * route handler
+     */
+    private getRenderingWidths;
+    /**
+     * Returns the dashes to be rendered between pattern and the
+     * route handler name.
+     */
+    private getDashes;
+    /**
+     * Renders routes to the console
+     */
+    render(): void;
+}

package/build/commands/ListRoutes/Renderers/PrettyRenderer.js

@@ -0,0 +1,135 @@
+"use strict";
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE.md
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutesPrettyRenderer = void 0;
+const Base_1 = require("./Base");
+/**
+ * Renders the routes as a pretty list
+ */
+class RoutesPrettyRenderer extends Base_1.BaseRender {
+    constructor(command) {
+        super(command);
+        this.routes = this.serializeRotues();
+        this.renderingWidth = this.getRenderingWidth();
+        this.longestMethodName = this.findLongestMethodName();
+    }
+    /**
+     * Returns a list of serialized routes
+     */
+    serializeRotues() {
+        const serializedRoutes = this.command.serializeRoutes();
+        return Object.keys(serializedRoutes)
+            .map((domain) => serializedRoutes[domain])
+            .flat();
+    }
+    /**
+     * Returns the name of the longest method name
+     * across all the routes
+     */
+    findLongestMethodName() {
+        return (Math.max(...this.routes.map((route) => {
+            return this.hasAllMethods(route.methods) ? 'ANY'.length : route.methods.join('|').length;
+        })) - 1);
+    }
+    /**
+     * Render a single route by concatenating and colorizing each part of it
+     */
+    outputRoute(route, renderingOptions) {
+        const methodsOutput = this.colorizeRouteMethods(route.methods);
+        const patternOutput = this.colorizeRoutePattern(route.pattern);
+        const nameAndHandlerOutput = this.command.colors.gray(route.handler);
+        const dashesOutput = this.command.colors.gray(renderingOptions.dashes);
+        this.log(methodsOutput + renderingOptions.spaces + patternOutput + dashesOutput + nameAndHandlerOutput);
+        /**
+         * Display middleware in verbose mode
+         */
+        if (route.middleware.length && this.command.verbose) {
+            const middleware = route.middleware
+                .map((one) => {
+                const glyph = '├──';
+                const spaces = ' '.repeat(Math.max(this.longestMethodName + 5, 0));
+                return this.command.colors.gray(`${spaces} ${glyph} ${one}`);
+            })
+                .join('\n');
+            this.log(middleware);
+        }
+    }
+    /**
+     * Log message
+     */
+    log(message) {
+        if (this.command.application.environment === 'test') {
+            this.command.logger.log(message);
+        }
+        else {
+            console.log(message);
+        }
+    }
+    /**
+     * Crop the handler name
+     */
+    cropHandlerName(handlerName, totalLength) {
+        return handlerName.substring(0, this.renderingWidth - totalLength - 1) + '…';
+    }
+    /**
+     * Returns the whitespace to be rendered between the
+     * route methods and the route pattern
+     */
+    getWhiteSpace(methods) {
+        return ' '.repeat(Math.max(this.longestMethodName + 5 - methods.length, 0));
+    }
+    /**
+     * Returns the rendering width with and without the
+     * route handler
+     */
+    getRenderingWidths(methods, spaces, pattern, nameAndHandler) {
+        const widthWithoutHandler = (methods + spaces + pattern).length + 1;
+        const totalWidth = widthWithoutHandler + nameAndHandler.length;
+        return { widthWithoutHandler, totalWidth };
+    }
+    /**
+     * Returns the dashes to be rendered between pattern and the
+     * route handler name.
+     */
+    getDashes(totalWidth) {
+        return ` ${'─'.repeat(Math.max(this.renderingWidth - totalWidth, 0))}`;
+    }
+    /**
+     * Renders routes to the console
+     */
+    render() {
+        this.routes.forEach((route) => {
+            const methods = this.hasAllMethods(route.methods) ? 'ANY' : route.methods.join('|');
+            const pattern = route.domain !== 'root' ? `${route.domain}${route.pattern}` : route.pattern;
+            let handler = route.name ? ` ${route.name} › ${route.handler}` : ` ${route.handler}`;
+            const spaces = this.getWhiteSpace(methods);
+            const widths = this.getRenderingWidths(methods, spaces, pattern, handler);
+            const dashes = this.getDashes(widths.totalWidth);
+            /**
+             * If name and handler output is too long we crop it
+             */
+            if (widths.totalWidth > this.renderingWidth) {
+                handler = this.cropHandlerName(handler, widths.widthWithoutHandler);
+            }
+            this.outputRoute({
+                pattern,
+                handler,
+                middleware: route.middleware,
+                methods: route.methods,
+                domain: route.domain,
+                name: route.name,
+            }, {
+                spaces,
+                dashes,
+            });
+        });
+    }
+}
+exports.RoutesPrettyRenderer = RoutesPrettyRenderer;

package/build/commands/ListRoutes/Renderers/TableRenderer.d.ts

@@ -0,0 +1,36 @@
+import ListRoutes from '../index';
+import { BaseRender } from './Base';
+/**
+ * Renders the routes in a table
+ */
+export declare class RoutesTableRenderer extends BaseRender {
+    private routes;
+    private domains;
+    private columns;
+    private longestPatternName;
+    constructor(command: ListRoutes);
+    /**
+     * Returns the length of the longest pattern name among
+     * all the routes
+     */
+    private getLongestPatterName;
+    /**
+     * Returns the width for methods column. We limit them at 15 max and
+     * return the left over from the column size
+     */
+    private getMethodsColumnWidth;
+    /**
+     * Returns the width for all the columns.
+     */
+    private getColumnsSize;
+    /**
+     * Distributing the left over from the methods column between
+     * the pattern column and the handler column.
+     */
+    private distributeLeftOverBetweenColumns;
+    private getTable;
+    /**
+     * Render the serialized routes to the console
+     */
+    render(): void;
+}

package/build/commands/ListRoutes/Renderers/TableRenderer.js

@@ -0,0 +1,137 @@
+"use strict";
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE.md
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutesTableRenderer = void 0;
+const Base_1 = require("./Base");
+/**
+ * Renders the routes in a table
+ */
+class RoutesTableRenderer extends Base_1.BaseRender {
+    constructor(command) {
+        super(command);
+        this.routes = this.command.serializeRoutes();
+        this.domains = Object.keys(this.routes);
+        this.columns = this.getColumnsSize();
+        this.longestPatternName = this.getLongestPatterName();
+    }
+    /**
+     * Returns the length of the longest pattern name among
+     * all the routes
+     */
+    getLongestPatterName() {
+        return (Math.max(...this.domains.map((domain) => {
+            return Math.max(...this.routes[domain].map((route) => route.pattern.length));
+        })) + 2);
+    }
+    /**
+     * Returns the width for methods column. We limit them at 15 max and
+     * return the left over from the column size
+     */
+    getMethodsColumnWidth(columnSize) {
+        return columnSize < 15
+            ? { size: columnSize, leftOver: 0 }
+            : { size: 15, leftOver: columnSize - 15 };
+    }
+    /**
+     * Returns the width for all the columns.
+     */
+    getColumnsSize() {
+        /**
+         * Dividing equal column width between all the columns
+         */
+        const columnSize = Math.round(this.getRenderingWidth() / 3) - 2;
+        /**
+         * Limiting the methods column width to 15 cells at max. 90% of the
+         * time methods fits within this width, for rest of the cases, they
+         * will truncate.
+         */
+        const { size: methodsColumnSize, leftOver } = this.getMethodsColumnWidth(columnSize);
+        /**
+         * Starting wdith for the patterns column and the handlers column.
+         */
+        const patternColumnSize = columnSize;
+        const handlerColumnSize = columnSize;
+        return {
+            methodsColumnSize,
+            patternColumnSize,
+            handlerColumnSize,
+            leftOver,
+        };
+    }
+    /**
+     * Distributing the left over from the methods column between
+     * the pattern column and the handler column.
+     */
+    distributeLeftOverBetweenColumns() {
+        /**
+         * If the pattern width is smaller than the column width itself, then
+         * we just give all the left over to the handler column.
+         */
+        if (this.longestPatternName < this.columns.patternColumnSize) {
+            this.columns.handlerColumnSize += this.columns.leftOver;
+            return;
+        }
+        const cellsNeeded = this.longestPatternName - this.columns.patternColumnSize;
+        /**
+         * If the pattern column width execeeds the left over width, then
+         * we just give the left over to the pattern column. This will
+         * also make the pattern column truncate.
+         */
+        if (cellsNeeded > this.columns.leftOver) {
+            this.columns.patternColumnSize += this.columns.leftOver;
+            return;
+        }
+        /**
+         * Finally, we give the cells needed for the pattern column and
+         * give the rest to the handler column.
+         */
+        this.columns.patternColumnSize += cellsNeeded;
+        this.columns.handlerColumnSize += this.columns.leftOver - cellsNeeded;
+        return;
+    }
+    getTable() {
+        if (this.columns.leftOver > 0) {
+            this.distributeLeftOverBetweenColumns();
+        }
+        return this.command.ui
+            .table()
+            .head(['Method', 'Route & Name', 'Handler & Middleware'])
+            .columnWidths([
+            this.columns.methodsColumnSize,
+            this.columns.patternColumnSize,
+            this.columns.handlerColumnSize,
+        ]);
+    }
+    /**
+     * Render the serialized routes to the console
+     */
+    render() {
+        const hasCustomDomains = this.domains.find((domain) => domain !== 'root');
+        const table = this.getTable();
+        this.domains.forEach((domain) => {
+            if (hasCustomDomains) {
+                table.row([{ colSpan: 3, content: this.command.colors.cyan(domain) }]);
+            }
+            const domainRoutes = this.routes[domain];
+            domainRoutes.forEach((route) => {
+                const methodsOutput = this.colorizeRouteMethods(route.methods);
+                const patternAndNameOutput = route.name
+                    ? `${this.colorizeRoutePattern(route.pattern)}\n${this.command.colors.gray(route.name)}`
+                    : this.colorizeRoutePattern(route.pattern);
+                const handlerOutput = route.middleware.length
+                    ? `${route.handler}\n${this.command.colors.gray(route.middleware.join('\n'))}`
+                    : route.handler;
+                table.row([methodsOutput, patternAndNameOutput, handlerOutput]);
+            });
+        });
+        table.render();
+    }
+}
+exports.RoutesTableRenderer = RoutesTableRenderer;

package/build/commands/ListRoutes/index.d.ts

@@ -0,0 +1,73 @@
+import { BaseCommand } from '@adonisjs/ace';
+import type { RouteNode } from '@ioc:Adonis/Core/Route';
+/**
+ * Shape of a route serialized by the ListRoute JSON serializer
+ */
+export declare type SerializedRoute = {
+    domain: string;
+    name: string;
+    pattern: string;
+    handler: string;
+    methods: string[];
+    middleware: string[];
+};
+/**
+ * A command to display a list of routes
+ */
+export default class ListRoutes extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    verbose: boolean;
+    reverse: boolean;
+    methodsFilter: string[];
+    patternsFilter: string[];
+    namesFilter: string[];
+    json: boolean;
+    table: boolean;
+    maxWidth: number;
+    /**
+     * Load application
+     */
+    static settings: {
+        loadApp: boolean;
+    };
+    /**
+     * Returns the display handler name
+     */
+    private getHandlerName;
+    /**
+     * Apply the method filter on the route
+     */
+    private hasPassedMethodFilter;
+    /**
+     * Apply the pattern filter on the route
+     */
+    private hasPassedPatternFilter;
+    /**
+     * Apply the name filter on the route
+     */
+    private hasPassedNameFilter;
+    /**
+     * Log message
+     */
+    private log;
+    /**
+     * Serialize route to JSON
+     */
+    serializeRoute(route: RouteNode & {
+        methods: string[];
+    }, domain: string): {
+        domain: string;
+        name: string;
+        pattern: string;
+        methods: string[];
+        handler: string;
+        middleware: string[];
+    };
+    /**
+     * Returns an array of routes as JSON, filtered according to the
+     * flags passed to the command
+     */
+    serializeRoutes(): Record<string, SerializedRoute[]>;
+    run(): Promise<void>;
+}

package/build/commands/ListRoutes/index.js

@@ -0,0 +1,164 @@
+"use strict";
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE.md
+ * file that was distributed with this source code.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ace_1 = require("@adonisjs/ace");
+const TableRenderer_1 = require("./Renderers/TableRenderer");
+const PrettyRenderer_1 = require("./Renderers/PrettyRenderer");
+/**
+ * A command to display a list of routes
+ */
+class ListRoutes extends ace_1.BaseCommand {
+    /**
+     * Returns the display handler name
+     */
+    getHandlerName(route) {
+        const resolvedHandler = route.meta.resolvedHandler;
+        if (resolvedHandler.type === 'function') {
+            return 'Closure';
+        }
+        const defaultControllersNamespace = this.application.namespacesMap.get('httpControllers');
+        return `${resolvedHandler.namespace.replace(new RegExp(`^${defaultControllersNamespace}\/`), '')}.${resolvedHandler.method}`;
+    }
+    /**
+     * Apply the method filter on the route
+     */
+    hasPassedMethodFilter(route) {
+        if (!this.methodsFilter || !this.methodsFilter.length) {
+            return true;
+        }
+        return !!this.methodsFilter.find((filter) => route.methods.includes(filter.toUpperCase()));
+    }
+    /**
+     * Apply the pattern filter on the route
+     */
+    hasPassedPatternFilter(route) {
+        if (!this.patternsFilter || !this.patternsFilter.length) {
+            return true;
+        }
+        return !!this.patternsFilter.find((filter) => route.pattern.includes(filter));
+    }
+    /**
+     * Apply the name filter on the route
+     */
+    hasPassedNameFilter(route) {
+        if (!this.namesFilter || !this.namesFilter.length) {
+            return true;
+        }
+        return !!this.namesFilter.find((filter) => route.name.includes(filter));
+    }
+    /**
+     * Log message
+     */
+    log(message) {
+        if (this.application.environment === 'test') {
+            this.logger.log(message);
+        }
+        else {
+            console.log(message);
+        }
+    }
+    /**
+     * Serialize route to JSON
+     */
+    serializeRoute(route, domain) {
+        return {
+            domain,
+            name: route.name || '',
+            pattern: route.pattern,
+            methods: route.methods,
+            handler: this.getHandlerName(route),
+            middleware: route.middleware.map((one) => (typeof one === 'function' ? 'Closure' : one)),
+        };
+    }
+    /**
+     * Returns an array of routes as JSON, filtered according to the
+     * flags passed to the command
+     */
+    serializeRoutes() {
+        const Router = this.application.container.use('Adonis/Core/Route');
+        Router.commit();
+        const routes = Router.toJSON();
+        return Object.keys(routes).reduce((result, domain) => {
+            const domainRoutes = routes[domain]
+                .map((route) => this.serializeRoute(route, domain))
+                .filter((route) => {
+                return (this.hasPassedMethodFilter(route) &&
+                    this.hasPassedNameFilter(route) &&
+                    this.hasPassedPatternFilter(route));
+            });
+            if (this.reverse) {
+                domainRoutes.reverse();
+            }
+            result[domain] = domainRoutes;
+            return result;
+        }, {});
+    }
+    async run() {
+        if (this.json) {
+            this.log(JSON.stringify(this.serializeRoutes(), null, 2));
+        }
+        else if (this.table) {
+            new TableRenderer_1.RoutesTableRenderer(this).render();
+        }
+        else {
+            new PrettyRenderer_1.RoutesPrettyRenderer(this).render();
+        }
+    }
+}
+ListRoutes.commandName = 'list:routes';
+ListRoutes.description = 'List application routes';
+/**
+ * Load application
+ */
+ListRoutes.settings = {
+    loadApp: true,
+};
+__decorate([
+    ace_1.flags.boolean({ name: 'verbose', description: 'Display more information' }),
+    __metadata("design:type", Boolean)
+], ListRoutes.prototype, "verbose", void 0);
+__decorate([
+    ace_1.flags.boolean({ alias: 'r', name: 'reverse', description: 'Reverse routes display' }),
+    __metadata("design:type", Boolean)
+], ListRoutes.prototype, "reverse", void 0);
+__decorate([
+    ace_1.flags.array({ alias: 'm', name: 'methods', description: 'Filter routes by method' }),
+    __metadata("design:type", Array)
+], ListRoutes.prototype, "methodsFilter", void 0);
+__decorate([
+    ace_1.flags.array({ alias: 'p', name: 'patterns', description: 'Filter routes by the route pattern' }),
+    __metadata("design:type", Array)
+], ListRoutes.prototype, "patternsFilter", void 0);
+__decorate([
+    ace_1.flags.array({ alias: 'n', name: 'names', description: 'Filter routes by route name' }),
+    __metadata("design:type", Array)
+], ListRoutes.prototype, "namesFilter", void 0);
+__decorate([
+    ace_1.flags.boolean({ description: 'Output as JSON' }),
+    __metadata("design:type", Boolean)
+], ListRoutes.prototype, "json", void 0);
+__decorate([
+    ace_1.flags.boolean({ description: 'Output as Table' }),
+    __metadata("design:type", Boolean)
+], ListRoutes.prototype, "table", void 0);
+__decorate([
+    ace_1.flags.number({ description: 'Specify maximum rendering width. Ignored for JSON Output' }),
+    __metadata("design:type", Number)
+], ListRoutes.prototype, "maxWidth", void 0);
+exports.default = ListRoutes;

package/build/commands/index.js

@@ -10,6 +10,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = [
     '@adonisjs/core/build/commands/DumpRc.js',
-    '@adonisjs/core/build/commands/ListRoutes.js',
+    '@adonisjs/core/build/commands/ListRoutes/index.js',
     '@adonisjs/core/build/commands/GenerateKey.js',
 ];

package/build/providers/AppProvider.d.ts

@@ -53,6 +53,10 @@ export default class AppProvider {
      * Define repl bindings
      */
     protected defineReplBindings(): void;
+    /**
+     * Define bindings for japa tests
+     */
+    protected defineTestsBindings(): void;
     /**
      * Registering all required bindings to the container
      */

package/build/providers/AppProvider.js

@@ -165,6 +165,15 @@ class AppProvider {
             defineReplBindings(this.app, Repl);
         });
     }
+    /**
+     * Define bindings for japa tests
+     */
+    defineTestsBindings() {
+        this.app.container.withBindings(['Japa/Preset/ApiRequest', 'Japa/Preset/ApiClient', 'Adonis/Core/CookieClient'], (ApiRequest, ApiClient, CookieClient) => {
+            const { defineTestsBindings } = require('../src/Bindings/Tests');
+            defineTestsBindings(ApiRequest, ApiClient, CookieClient);
+        });
+    }
     /**
      * Registering all required bindings to the container
      */
@@ -183,6 +192,7 @@ class AppProvider {
         this.registerStaticAssetsHook();
         this.registerHealthCheckers();
         this.defineReplBindings();
+        this.defineTestsBindings();
     }
 }
 exports.default = AppProvider;

package/build/src/Bindings/Repl.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="@adonisjs/repl" />
 import { ReplContract } from '@ioc:Adonis/Addons/Repl';
 import { ApplicationContract } from '@ioc:Adonis/Core/Application';
 /**

package/build/src/Bindings/Tests.d.ts

@@ -0,0 +1,6 @@
+import { ContainerBindings } from '@ioc:Adonis/Core/Application';
+import { CookieClientContract } from '@ioc:Adonis/Core/CookieClient';
+/**
+ * Define test bindings
+ */
+export declare function defineTestsBindings(ApiRequest: ContainerBindings['Japa/Preset/ApiRequest'], ApiClient: ContainerBindings['Japa/Preset/ApiClient'], CookieClient: CookieClientContract): void;

package/build/src/Bindings/Tests.js

@@ -0,0 +1,66 @@
+"use strict";
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * 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.defineTestsBindings = void 0;
+/**
+ * Define test bindings
+ */
+function defineTestsBindings(ApiRequest, ApiClient, CookieClient) {
+    /**
+     * Serializing for parsing response cookies
+     */
+    ApiClient.cookiesSerializer({
+        /**
+         * The methods on the Request class encrypts and signs cookies.
+         * Therefore, the prepare method returns the value as it is
+         */
+        prepare(_, value) {
+            return value;
+        },
+        /**
+         * Process the server response and convert cookie value to a
+         * plain string
+         */
+        process(key, value) {
+            return CookieClient.parse(key, value);
+        },
+    });
+    /**
+     * Define cookie
+     */
+    ApiRequest.macro('cookie', function (key, value) {
+        const signedValue = CookieClient.sign(key, value);
+        if (signedValue) {
+            this.cookiesJar[key] = { name: key, value: signedValue };
+        }
+        return this;
+    });
+    /**
+     * Define encrypted cookie
+     */
+    ApiRequest.macro('encryptedCookie', function (key, value) {
+        const encryptedValue = CookieClient.encrypt(key, value);
+        if (encryptedValue) {
+            this.cookiesJar[key] = { name: key, value: encryptedValue };
+        }
+        return this;
+    });
+    /**
+     * Define plain cookie
+     */
+    ApiRequest.macro('plainCookie', function (key, value) {
+        const encodedValue = CookieClient.encode(key, value);
+        if (encodedValue) {
+            this.cookiesJar[key] = { name: key, value: encodedValue };
+        }
+        return this;
+    });
+}
+exports.defineTestsBindings = defineTestsBindings;

package/build/templates/contracts/tests.txt

@@ -0,0 +1,16 @@
+/**
+ * Contract source: https://github.com/adonisjs/core/blob/master/templates/contracts/tests.txt
+ *
+ * Feel free to let us know via PR, if you find something broken in this contract
+ * file.
+ */
+
+import '@japa/runner'
+
+declare module '@japa/runner' {
+  interface TestContext {
+  }
+
+  interface Test<DataSet> {
+  }
+}

package/build/templates/tests/bootstrap.txt

@@ -5,11 +5,9 @@
  * file.
  */
 
-import { assert } from '@japa/assert'
-import type { Suite } from '@japa/core'
-import { specReporter } from '@japa/spec-reporter'
+import type { Config } from '@japa/runner'
 import TestUtils from '@ioc:Adonis/Core/TestUtils'
-import type { PluginFn, RunnerHooksHandler, TestContext, ReporterContract } from '@japa/runner'
+import { assert, runFailedTests, specReporter } from '@japa/preset-adonis'
 
 /*
 |--------------------------------------------------------------------------
@@ -22,7 +20,7 @@ import type { PluginFn, RunnerHooksHandler, TestContext, ReporterContract } from
 | Feel free to remove existing plugins or add more.
 |
 */
-export const plugins: PluginFn[] = [assert()]
+export const plugins: Config['plugins'] = [assert(), runFailedTests()]
 
 /*
 |--------------------------------------------------------------------------
@@ -34,7 +32,7 @@ export const plugins: PluginFn[] = [assert()]
 | of tests on the terminal.
 |
 */
-export const reporters: ReporterContract[] = [specReporter()]
+export const reporters: Config['reporters'] = [specReporter()]
 
 /*
 |--------------------------------------------------------------------------
@@ -48,8 +46,8 @@ export const reporters: ReporterContract[] = [specReporter()]
 | within the runner hooks
 |
 */
-export const runnerHooks: { setup: RunnerHooksHandler[]; teardown: RunnerHooksHandler[] } = {
-  setup: [() => TestUtils.ace().loadCommands()],
+export const runnerHooks: Required<Pick<Config, 'setup' | 'teardown'>> = {
+  setup: [() => TestUtils.ace().loadCommands(), () => TestUtils.db().migrate()],
   teardown: [],
 }
 
@@ -62,10 +60,10 @@ export const runnerHooks: { setup: RunnerHooksHandler[]; teardown: RunnerHooksHa
 | within ".adonisrc.json" file.
 |
 | You can use this method to configure suites. For example: Only start
-| the HTTP server when it is a feature suite.
+| the HTTP server when it is a functional suite.
 */
-export const configureSuite = (suite: Suite<TestContext>) => {
-  if (suite.name === 'feature') {
+export const configureSuite: Config['configureSuite'] = (suite) => {
+  if (suite.name === 'functional') {
     suite.setup(() => TestUtils.httpServer().start())
   }
 }

package/build/templates/tests.txt

@@ -0,0 +1,44 @@
+/*
+|--------------------------------------------------------------------------
+| Tests
+|--------------------------------------------------------------------------
+|
+| The contents in this file boots the AdonisJS application and configures
+| the Japa tests runner.
+|
+| For the most part you will never edit this file. The configuration
+| for the tests can be controlled via ".adonisrc.json" and
+| "tests/bootstrap.ts" files.
+|
+*/
+
+process.env.NODE_ENV = 'testing'
+
+import 'reflect-metadata'
+import sourceMapSupport from 'source-map-support'
+import { Ignitor } from '@adonisjs/core/build/standalone'
+import { configure, processCliArgs, run, RunnerHooksHandler } from '@japa/runner'
+
+sourceMapSupport.install({ handleUncaughtExceptions: false })
+
+const kernel = new Ignitor(__dirname).kernel('test')
+
+kernel
+  .boot()
+  .then(() => import('./tests/bootstrap'))
+  .then(({ runnerHooks, ...config }) => {
+    const app: RunnerHooksHandler[] = [() => kernel.start()]
+
+    configure({
+      ...kernel.application.rcFile.tests,
+      ...processCliArgs(process.argv.slice(2)),
+      ...config,
+      ...{
+        importer: (filePath) => import(filePath),
+        setup: app.concat(runnerHooks.setup),
+        teardown: runnerHooks.teardown,
+      },
+    })
+
+    run()
+  })

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@adonisjs/core",
-	"version": "5.5.3",
+	"version": "5.6.0",
 	"description": "Core of AdonisJS",
 	"exports": {
 		".": {
@@ -63,38 +63,39 @@
 	},
 	"homepage": "https://github.com/adonisjs/core#readme",
 	"devDependencies": {
-		"@adonisjs/assembler": "^5.4.1",
-		"@adonisjs/mrm-preset": "^5.0.2",
+		"@adonisjs/assembler": "^5.4.2",
+		"@adonisjs/mrm-preset": "^5.0.3",
 		"@adonisjs/repl": "^3.1.9",
 		"@adonisjs/require-ts": "^2.0.10",
 		"@adonisjs/sink": "^5.2.2",
-		"@japa/assert": "^1.2.3",
-		"@japa/run-failed-tests": "^1.0.3",
-		"@japa/runner": "^1.2.0",
-		"@japa/spec-reporter": "^1.1.7",
+		"@japa/assert": "^1.3.2",
+		"@japa/preset-adonis": "^1.0.8",
+		"@japa/run-failed-tests": "^1.0.6",
+		"@japa/runner": "^2.0.5",
+		"@japa/spec-reporter": "^1.1.11",
 		"@poppinss/dev-utils": "^2.0.2",
-		"@types/node": "^17.0.21",
-		"@types/supertest": "^2.0.11",
+		"@types/node": "^17.0.23",
+		"@types/supertest": "^2.0.12",
 		"clear-module": "^4.1.2",
 		"commitizen": "^4.2.4",
 		"copyfiles": "^2.4.1",
 		"cz-conventional-changelog": "^3.3.0",
 		"del-cli": "^4.0.1",
-		"eslint": "^8.10.0",
+		"eslint": "^8.12.0",
 		"eslint-config-prettier": "^8.5.0",
 		"eslint-plugin-adonis": "^2.1.0",
 		"eslint-plugin-prettier": "^4.0.0",
 		"etag": "^1.8.1",
 		"github-label-sync": "^2.0.2",
 		"husky": "^7.0.4",
-		"mrm": "^3.0.10",
-		"np": "^7.6.0",
-		"prettier": "^2.5.1",
+		"mrm": "^4.0.0",
+		"np": "^7.6.1",
+		"prettier": "^2.6.1",
 		"reflect-metadata": "^0.1.13",
-		"strip-ansi": "^6.0.0",
+		"strip-ansi": "^6.0.1",
 		"supertest": "^6.2.2",
 		"test-console": "^2.0.0",
-		"typescript": "^4.6.2",
+		"typescript": "^4.6.3",
 		"youch": "^3.1.1",
 		"youch-terminal": "^2.1.3"
 	},
@@ -119,20 +120,20 @@
 	"dependencies": {
 		"@adonisjs/ace": "^11.2.2",
 		"@adonisjs/application": "^5.2.0",
-		"@adonisjs/bodyparser": "^8.1.0",
-		"@adonisjs/drive": "^2.0.9",
+		"@adonisjs/bodyparser": "^8.1.1",
+		"@adonisjs/drive": "^2.0.10",
 		"@adonisjs/encryption": "^4.0.7",
 		"@adonisjs/events": "^7.1.3",
 		"@adonisjs/hash": "^7.0.10",
-		"@adonisjs/http-server": "^5.6.1",
-		"@adonisjs/validator": "^12.2.2",
+		"@adonisjs/http-server": "^5.7.3",
+		"@adonisjs/validator": "^12.2.3",
 		"@poppinss/cliui": "^3.0.1",
 		"@poppinss/manager": "^5.0.1",
 		"@poppinss/utils": "^4.0.2",
 		"fs-extra": "^10.0.1",
-		"macroable": "^6.0.1",
+		"macroable": "^7.0.0",
 		"memfs": "^3.4.1",
-		"serve-static": "^1.14.2",
+		"serve-static": "^1.15.0",
 		"stringify-attributes": "^2.0.0"
 	},
 	"np": {

package/build/commands/ListRoutes.d.ts

@@ -1,28 +0,0 @@
-import { BaseCommand } from '@adonisjs/ace';
-/**
- * A command to display a list of routes
- */
-export default class ListRoutes extends BaseCommand {
-    static commandName: string;
-    static description: string;
-    json: boolean;
-    /**
-     * Load application
-     */
-    static settings: {
-        loadApp: boolean;
-    };
-    /**
-     * Returns an array of routes as JSON
-     */
-    private outputJSON;
-    /**
-     * Output routes a table string
-     */
-    private outputTable;
-    /**
-     * Log message
-     */
-    private log;
-    run(): Promise<void>;
-}

package/build/commands/ListRoutes.js

@@ -1,116 +0,0 @@
-"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.
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ace_1 = require("@adonisjs/ace");
-/**
- * A command to display a list of routes
- */
-class ListRoutes extends ace_1.BaseCommand {
-    /**
-     * Returns an array of routes as JSON
-     */
-    outputJSON(router) {
-        const routes = router.toJSON();
-        return Object.keys(routes).reduce((result, domain) => {
-            result[domain] = routes[domain].map((route) => {
-                let handler = 'Closure';
-                const middleware = route
-                    ? route.middleware.map((one) => (typeof one === 'function' ? 'Closure' : one))
-                    : [];
-                if (route.meta.resolvedHandler.type !== 'function' && route.meta.namespace) {
-                    handler = `${route.meta.resolvedHandler['namespace']}.${route.meta.resolvedHandler['method']}`;
-                }
-                else if (route.meta.resolvedHandler.type !== 'function') {
-                    const method = route.meta.resolvedHandler['method'];
-                    const routeHandler = route.handler;
-                    handler = `${routeHandler.replace(new RegExp(`.${method}$`), '')}.${method}`;
-                }
-                return {
-                    methods: route.methods,
-                    name: route.name || '',
-                    pattern: route.pattern,
-                    handler: handler,
-                    middleware: middleware,
-                };
-            });
-            return result;
-        }, {});
-    }
-    /**
-     * Output routes a table string
-     */
-    outputTable(router) {
-        const routes = this.outputJSON(router);
-        const domains = Object.keys(routes);
-        const showDomainHeadline = domains.length > 1 || domains[0] !== 'root';
-        const table = this.ui.table().head(['Method', 'Route', 'Handler', 'Middleware', 'Name']);
-        domains.forEach((domain) => {
-            if (showDomainHeadline) {
-                table.row([{ colSpan: 5, content: `Domain ${this.colors.cyan(domain)}` }]);
-            }
-            routes[domain].forEach((route) => {
-                table.row([
-                    this.colors.dim(route.methods.join(', ')),
-                    route.pattern,
-                    typeof route.handler === 'function' ? 'Closure' : route.handler,
-                    route.middleware.join(','),
-                    route.name,
-                ]);
-            });
-        });
-        table.render();
-    }
-    /**
-     * Log message
-     */
-    log(message) {
-        if (this.application.environment === 'test') {
-            this.logger.log(message);
-        }
-        else {
-            console.log(message);
-        }
-    }
-    async run() {
-        const Router = this.application.container.use('Adonis/Core/Route');
-        /**
-         * Commit routes before we can read them
-         */
-        Router.commit();
-        if (this.json) {
-            this.log(JSON.stringify(this.outputJSON(Router), null, 2));
-        }
-        else {
-            this.outputTable(Router);
-        }
-    }
-}
-ListRoutes.commandName = 'list:routes';
-ListRoutes.description = 'List application routes';
-/**
- * Load application
- */
-ListRoutes.settings = {
-    loadApp: true,
-};
-__decorate([
-    ace_1.flags.boolean({ description: 'Output as JSON' }),
-    __metadata("design:type", Boolean)
-], ListRoutes.prototype, "json", void 0);
-exports.default = ListRoutes;