@adonisjs/core 6.1.5-1 → 6.1.5-10

package/build/services/hash.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { HashManager } from '../modules/hash/main.js';
 let hash;
+/**
+ * Returns a singleton instance of the Hash manager from the
+ * container
+ */
 await app.booted(async () => {
-    hash = await app.container.make(HashManager);
+    hash = await app.container.make('hash');
 });
 export { hash as default };

package/build/services/logger.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { LoggerManager } from '@adonisjs/logger';
 let logger;
+/**
+ * Returns a singleton instance of the logger class
+ * from the container
+ */
 await app.booted(async () => {
-    logger = (await app.container.make(LoggerManager));
+    logger = await app.container.make('logger');
 });
 export { logger as default };

package/build/services/repl.d.ts

@@ -0,0 +1,3 @@
+import type { Repl } from '../modules/repl.js';
+declare let repl: Repl;
+export { repl as default };

package/build/services/repl.js

@@ -0,0 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import app from './app.js';
+let repl;
+/**
+ * Returns a singleton instance of the Repl class from
+ * the container
+ */
+await app.booted(async () => {
+    repl = await app.container.make('repl');
+});
+export { repl as default };

package/build/services/router.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { Router } from '../modules/http.js';
 let router;
+/**
+ * Returns a singleton instance of the router class from
+ * the container
+ */
 await app.booted(async () => {
-    router = await app.container.make(Router);
+    router = await app.container.make('router');
 });
 export { router as default };

package/build/services/server.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { Server } from '../modules/http.js';
 let server;
+/**
+ * Returns a singleton instance of the HTTP server
+ * from the container
+ */
 await app.booted(async () => {
-    server = await app.container.make(Server);
+    server = await app.container.make('server');
 });
 export { server as default };

package/build/services/test_utils.js

@@ -1,5 +1,20 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
 let testUtils;
+/**
+ * Returns a singleton instance of the TestUtils class
+ * from the container.
+ *
+ * testUtils service is an instance of the "TestUtils" exported from
+ * the "src/test_utils/main.ts" file.
+ */
 await app.booted(async () => {
     testUtils = await app.container.make('testUtils');
 });

package/build/src/bindings/repl.d.ts

@@ -0,0 +1,6 @@
+import type { Repl } from '../../modules/repl.js';
+import { ApplicationService } from '../types.js';
+/**
+ * Registers REPL methods
+ */
+export declare function defineReplBindings(app: ApplicationService, repl: Repl): void;

package/build/src/bindings/repl.js

@@ -0,0 +1,78 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Resolves a container binding and sets it on the REPL
+ * context
+ */
+async function resolveBindingForRepl(app, repl, binding) {
+    repl.server.context[binding] = await app.container.make(binding);
+    repl.notify(`Loaded "${binding}" service. You can access it using the "${repl.colors.underline(binding)}" variable`);
+}
+/**
+ * Registers REPL methods
+ */
+export function defineReplBindings(app, repl) {
+    repl.addMethod('importDefault', (_, modulePath) => {
+        return app.importDefault(modulePath);
+    }, {
+        description: 'Returns the default export for a module',
+    });
+    repl.addMethod('make', (_, service, runtimeValues) => {
+        return app.container.make(service, runtimeValues);
+    }, {
+        description: 'Make class instance using "container.make" method',
+    });
+    repl.addMethod('loadApp', () => {
+        return resolveBindingForRepl(app, repl, 'app');
+    }, {
+        description: 'Load "app" service in the REPL context',
+    });
+    repl.addMethod('loadEncryption', () => {
+        return resolveBindingForRepl(app, repl, 'encryption');
+    }, {
+        description: 'Load "encryption" service in the REPL context',
+    });
+    repl.addMethod('loadHash', () => {
+        return resolveBindingForRepl(app, repl, 'hash');
+    }, {
+        description: 'Load "hash" service in the REPL context',
+    });
+    repl.addMethod('loadRouter', () => {
+        return resolveBindingForRepl(app, repl, 'router');
+    }, {
+        description: 'Load "router" service in the REPL context',
+    });
+    repl.addMethod('loadConfig', () => {
+        return resolveBindingForRepl(app, repl, 'config');
+    }, {
+        description: 'Load "config" service in the REPL context',
+    });
+    repl.addMethod('loadTestUtils', () => {
+        return resolveBindingForRepl(app, repl, 'testUtils');
+    }, {
+        description: 'Load "testUtils" service in the REPL context',
+    });
+    repl.addMethod('loadHelpers', async () => {
+        const { default: isModule } = await import('../helpers/is.js');
+        const { default: stringModule } = await import('../helpers/string.js');
+        const { base64, cuid, fsReadAll, slash, parseImports } = await import('../helpers/main.js');
+        repl.server.context.helpers = {
+            string: stringModule,
+            is: isModule,
+            base64,
+            cuid,
+            fsReadAll,
+            slash,
+            parseImports,
+        };
+        repl.notify(`Loaded "helpers" module. You can access it using the "${repl.colors.underline('helpers')}" variable`);
+    }, {
+        description: 'Load "helpers" module in the REPL context',
+    });
+}

package/build/src/cli_formatters/routes_list.d.ts

@@ -0,0 +1,63 @@
+import type { UIPrimitives } from '../../types/ace.js';
+import { type Router } from '../../modules/http/main.js';
+/**
+ * Shape of the serialized route specific to the formatter
+ */
+type SerializedRoute = {
+    name: string;
+    pattern: string;
+    methods: string[];
+    middleware: string[];
+    handler: {
+        type: 'closure';
+        name: string;
+    } | {
+        type: 'controller';
+        moduleNameOrPath: string;
+        method: string;
+    };
+};
+/**
+ * Routes list formatter is used to format the routes to JSON or an ANSI string
+ * with pretty output.
+ *
+ * The decisions of colors, padding, alignment are all handled by the lists formatter
+ */
+export declare class RoutesListFormatter {
+    #private;
+    constructor(router: Router, ui: UIPrimitives, options: {
+        displayHeadRoutes?: boolean;
+        maxPrettyPrintWidth?: number;
+    }, filters: {
+        match?: string;
+        middleware?: string[];
+        ignoreMiddleware?: string[];
+    });
+    /**
+     * Formats routes as an array of objects. Routes are grouped by
+     * domain.
+     */
+    formatAsJSON(): Promise<{
+        domain: string;
+        routes: SerializedRoute[];
+    }[]>;
+    /**
+     * Format routes to ansi list of tables. Each domain has its own table
+     * with heading and rows. Each row has colums with colors and spacing
+     * around them.
+     */
+    formatAsAnsiList(): Promise<{
+        heading: string;
+        rows: string[];
+    }[]>;
+    /**
+     * Format routes to ansi tables. Each domain has its own table
+     * with heading and rows. Each row has colums with colors and spacing
+     * around them.
+     */
+    formatAsAnsiTable(): Promise<{
+        heading: string;
+        table: ReturnType<UIPrimitives['table']>;
+    }[]>;
+}
+export {};

package/build/src/cli_formatters/routes_list.js

@@ -0,0 +1,376 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import stringWidth from 'string-width';
+import { cliHelpers } from '../../modules/ace/main.js';
+import { parseBindingReference } from '../../src/helpers/main.js';
+/**
+ * Routes list formatter is used to format the routes to JSON or an ANSI string
+ * with pretty output.
+ *
+ * The decisions of colors, padding, alignment are all handled by the lists formatter
+ */
+export class RoutesListFormatter {
+    #router;
+    #colors;
+    #table;
+    /**
+     * Options for printing routes
+     */
+    #options;
+    /**
+     * Filters to apply when finding routes
+     */
+    #filters;
+    constructor(router, ui, options, filters) {
+        this.#router = router;
+        this.#colors = ui.colors;
+        this.#table = ui.table;
+        this.#filters = filters;
+        this.#options = options;
+        this.#router.commit();
+    }
+    /**
+     * Test if a route clears the applied filters
+     */
+    #isAllowedByFilters(route) {
+        let allowRoute = true;
+        /**
+         * Check if the route is allowed by applying the middleware
+         * filter
+         */
+        if (this.#filters.middleware) {
+            allowRoute = this.#filters.middleware.every((name) => {
+                if (name === '*') {
+                    return route.middleware.length > 0;
+                }
+                return route.middleware.includes(name);
+            });
+        }
+        /**
+         * Check if the route has any or the ignored middleware. If yes, do not
+         * display the route
+         */
+        if (allowRoute && this.#filters.ignoreMiddleware) {
+            allowRoute = this.#filters.ignoreMiddleware.every((name) => {
+                if (name === '*') {
+                    return route.middleware.length === 0;
+                }
+                return !route.middleware.includes(name);
+            });
+        }
+        /**
+         * No more filters to be applied
+         */
+        if (!this.#filters.match) {
+            return allowRoute;
+        }
+        /**
+         * Check if the route name has the match keyword
+         */
+        if (route.name.includes(this.#filters.match)) {
+            return true;
+        }
+        /**
+         * Check if the route pattern has the match keyword
+         */
+        if (route.pattern.includes(this.#filters.match)) {
+            return true;
+        }
+        /**
+         * Check if the route handler has the match keyword
+         */
+        if (route.handler.type === 'controller'
+            ? route.handler.moduleNameOrPath.includes(this.#filters.match)
+            : route.handler.name.includes(this.#filters.match)) {
+            return true;
+        }
+        /**
+         * Disallow route
+         */
+        return false;
+    }
+    /**
+     * Serialize route middleware to an array of names
+     */
+    #serializeMiddleware(middleware) {
+        return [...middleware.all()].reduce((result, one) => {
+            if (typeof one === 'function') {
+                result.push(one.name || 'closure');
+                return result;
+            }
+            if ('name' in one && one.name) {
+                result.push(one.name);
+            }
+            return result;
+        }, []);
+    }
+    /**
+     * Serialize route handler reference to display object
+     */
+    async #serializeHandler(handler) {
+        /**
+         * Value is a controller reference
+         */
+        if ('reference' in handler) {
+            return {
+                type: 'controller',
+                ...(await parseBindingReference(handler.reference)),
+            };
+        }
+        /**
+         * Value is an inline closure
+         */
+        return {
+            type: 'closure',
+            name: handler.name || 'closure',
+        };
+    }
+    /**
+     * Serializes routes JSON to an object that can be used for pretty printing
+     */
+    async #serializeRoute(route) {
+        let methods = route.methods;
+        if (!this.#options.displayHeadRoutes) {
+            methods = methods.filter((method) => method !== 'HEAD');
+        }
+        return {
+            name: route.name || '',
+            pattern: route.pattern,
+            methods: methods,
+            handler: await this.#serializeHandler(route.handler),
+            middleware: this.#serializeMiddleware(route.middleware),
+        };
+    }
+    /**
+     * Formats the route method for the ansi list and table
+     */
+    #formatRouteMethod(method) {
+        return this.#colors.dim(method);
+    }
+    /**
+     * Formats route pattern for the ansi list and table
+     */
+    #formatRoutePattern(route) {
+        const pattern = this.#router
+            .parsePattern(route.pattern)
+            .map((token) => {
+            if (token.type === 1) {
+                return this.#colors.yellow(`:${token.val}`);
+            }
+            if (token.type === 3) {
+                return this.#colors.yellow(`:${token.val}?`);
+            }
+            if (token.type === 2) {
+                return this.#colors.red(token.val);
+            }
+            return token.val;
+        })
+            .join('/');
+        return `${pattern === '/' ? pattern : `/${pattern}`}${route.name ? ` ${this.#colors.dim(`(${route.name})`)}` : ''} `;
+    }
+    /**
+     * Formats controller name for the ansi list and table
+     */
+    #formatControllerName(route) {
+        return route.handler.type === 'controller' ? ` ${route.handler.moduleNameOrPath}.` : '';
+    }
+    /**
+     * Formats action name for the ansi list and table
+     */
+    #formatAction(route) {
+        return route.handler.type === 'controller'
+            ? `${this.#colors.cyan(route.handler.method)}`
+            : ` ${this.#colors.cyan(route.handler.name)}`;
+    }
+    /**
+     * Formats route middleware for the ansi list and table
+     */
+    #formatMiddleware(route, mode = 'normal') {
+        if (mode === 'compact' && route.middleware.length > 3) {
+            const firstMiddleware = route.middleware[0];
+            const secondMiddleware = route.middleware[1];
+            const diff = route.middleware.length - 2;
+            return this.#colors.dim(`${firstMiddleware}, ${secondMiddleware}, and ${diff} more`);
+        }
+        return this.#colors.dim(`${route.middleware.filter((one) => one).join(', ')}`);
+    }
+    /**
+     * Formatting the domain headling to be in green color with
+     * dots around it
+     */
+    #formatDomainHeadline(domain) {
+        if (domain !== 'root') {
+            return cliHelpers.justify([`${this.#colors.dim('..')} ${this.#colors.green(domain)} `], {
+                maxWidth: this.#options.maxPrettyPrintWidth || cliHelpers.TERMINAL_SIZE,
+                paddingChar: this.#colors.dim('.'),
+            })[0];
+        }
+        return '';
+    }
+    /**
+     * Justify the ansi list
+     */
+    #justifyListTables(tables) {
+        return tables.map((table) => {
+            /**
+             * Formatting methods
+             */
+            const methods = table.rows.map((columns) => columns[0]);
+            const largestMethodsLength = Math.max(...methods.map((method) => stringWidth(method)));
+            const formattedMethods = cliHelpers.justify(methods, {
+                maxWidth: largestMethodsLength,
+            });
+            /**
+             * Formatting patterns
+             */
+            const patterns = table.rows.map((columns) => columns[1]);
+            const largestPatternLength = Math.max(...patterns.map((pattern) => stringWidth(pattern)));
+            const formattedPatterns = cliHelpers.justify(patterns, {
+                maxWidth: largestPatternLength,
+                paddingChar: this.#colors.dim('.'),
+            });
+            /**
+             * Formatting middleware to be right aligned
+             */
+            const middleware = table.rows.map((columns) => columns[3]);
+            const largestMiddlewareLength = Math.max(...middleware.map((one) => stringWidth(one)));
+            const formattedMiddleware = cliHelpers.justify(middleware, {
+                maxWidth: largestMiddlewareLength,
+                align: 'right',
+                paddingChar: ' ',
+            });
+            /**
+             * Formatting controllers to be right aligned and take all the remaining
+             * space after printing route method, pattern and middleware.
+             */
+            const controllers = table.rows.map((columns) => columns[2]);
+            const largestControllerLength = (this.#options.maxPrettyPrintWidth || cliHelpers.TERMINAL_SIZE) -
+                (largestPatternLength + largestMethodsLength + largestMiddlewareLength);
+            const formattedControllers = cliHelpers.truncate(cliHelpers.justify(controllers, {
+                maxWidth: largestControllerLength,
+                align: 'right',
+                paddingChar: this.#colors.dim('.'),
+            }), {
+                maxWidth: largestControllerLength,
+            });
+            return {
+                heading: table.heading,
+                rows: formattedMethods.reduce((result, method, index) => {
+                    result.push(`${method}${formattedPatterns[index]}${formattedControllers[index]}${formattedMiddleware[index]}`);
+                    return result;
+                }, []),
+            };
+        });
+    }
+    /**
+     * Formats routes as an array of objects. Routes are grouped by
+     * domain.
+     */
+    async formatAsJSON() {
+        const routes = this.#router.toJSON();
+        const domains = Object.keys(routes);
+        let routesJSON = [];
+        for (let domain of domains) {
+            const domainRoutes = await Promise.all(routes[domain].map((route) => this.#serializeRoute(route)));
+            routesJSON.push({
+                domain,
+                routes: domainRoutes.filter((route) => this.#isAllowedByFilters(route)),
+            });
+        }
+        return routesJSON;
+    }
+    /**
+     * Format routes to ansi list of tables. Each domain has its own table
+     * with heading and rows. Each row has colums with colors and spacing
+     * around them.
+     */
+    async formatAsAnsiList() {
+        const routes = this.#router.toJSON();
+        const domains = Object.keys(routes);
+        const tables = [];
+        for (let domain of domains) {
+            const list = {
+                heading: this.#formatDomainHeadline(domain),
+                rows: [
+                    [
+                        this.#colors.dim('METHOD'),
+                        ` ${this.#colors.dim('ROUTE')} `,
+                        ` ${this.#colors.dim('HANDLER')}`,
+                        ` ${this.#colors.dim('MIDDLEWARE')}`,
+                    ],
+                ],
+            };
+            /**
+             * Computing table rows. Each route+method will have its
+             * own row
+             */
+            for (let route of routes[domain]) {
+                const serializedRoute = await this.#serializeRoute(route);
+                if (this.#isAllowedByFilters(serializedRoute)) {
+                    serializedRoute.methods.forEach((method) => {
+                        list.rows.push([
+                            this.#formatRouteMethod(method),
+                            ` ${this.#formatRoutePattern(serializedRoute)}`,
+                            `${this.#formatControllerName(serializedRoute)}${this.#formatAction(serializedRoute)}`,
+                            ` ${this.#formatMiddleware(serializedRoute, 'compact')}`,
+                        ]);
+                    });
+                }
+            }
+            tables.push(list);
+        }
+        return this.#justifyListTables(tables);
+    }
+    /**
+     * Format routes to ansi tables. Each domain has its own table
+     * with heading and rows. Each row has colums with colors and spacing
+     * around them.
+     */
+    async formatAsAnsiTable() {
+        const routes = this.#router.toJSON();
+        const domains = Object.keys(routes);
+        const tables = [];
+        for (let domain of domains) {
+            const list = {
+                heading: this.#formatDomainHeadline(domain),
+                table: this.#table()
+                    .fullWidth()
+                    .fluidColumnIndex(2)
+                    .head([
+                    this.#colors.dim('METHOD'),
+                    this.#colors.dim('ROUTE'),
+                    { hAlign: 'right', content: this.#colors.dim('HANDLER') },
+                    { content: this.#colors.dim('MIDDLEWARE'), hAlign: 'right' },
+                ]),
+            };
+            /**
+             * Computing table rows. Each route+method will have its
+             * own row
+             */
+            for (let route of routes[domain]) {
+                const serializedRoute = await this.#serializeRoute(route);
+                if (this.#isAllowedByFilters(serializedRoute)) {
+                    serializedRoute.methods.forEach((method) => {
+                        list.table.row([
+                            this.#formatRouteMethod(method),
+                            this.#formatRoutePattern(serializedRoute),
+                            {
+                                content: `${this.#formatControllerName(serializedRoute)}${this.#formatAction(serializedRoute)}`,
+                                hAlign: 'right',
+                            },
+                            { content: this.#formatMiddleware(serializedRoute), hAlign: 'right' },
+                        ]);
+                    });
+                }
+            }
+            tables.push(list);
+        }
+        return tables;
+    }
+}

package/build/src/debug.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="@types/node" resolution-mode="require"/>
 declare const _default: import("util").DebugLogger;
 export default _default;

package/build/src/debug.js

@@ -1,2 +1,10 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import { debuglog } from 'node:util';
 export default debuglog('adonisjs:core');

package/build/src/exceptions.d.ts

@@ -0,0 +1 @@
+export { Exception, createError, RuntimeException, InvalidArgumentsException, } from '@poppinss/utils';

package/build/src/exceptions.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 { Exception, createError, RuntimeException, InvalidArgumentsException, } from '@poppinss/utils';