@adonisjs/core 6.1.5-4 → 6.1.5-5

package/build/providers/http_provider.js

@@ -1,10 +1,25 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import { Router, Server } from '../modules/http.js';
 import BodyParserMiddleware from '../modules/bodyparser/bodyparser_middleware.js';
+/**
+ * Http Service provider binds the router and the HTTP server to
+ * the container.
+ */
 export default class HttpServiceProvider {
     app;
     constructor(app) {
         this.app = app;
     }
+    /**
+     * Registers the HTTP server with the container as a singleton
+     */
     registerServer() {
         this.app.container.singleton(Server, async (resolver) => {
             const encryption = await resolver.make('encryption');
@@ -15,6 +30,9 @@ export default class HttpServiceProvider {
         });
         this.app.container.alias('server', Server);
     }
+    /**
+     * Registers router with the container as a singleton
+     */
     registerRouter() {
         this.app.container.singleton(Router, async (resolver) => {
             const server = await resolver.make('server');
@@ -22,12 +40,19 @@ export default class HttpServiceProvider {
         });
         this.app.container.alias('router', Router);
     }
+    /**
+     * Self construct bodyparser middleware class, since it needs
+     * config that cannot be resolved by the container
+     */
     registerBodyParserMiddleware() {
         this.app.container.bind(BodyParserMiddleware, () => {
             const config = this.app.config.get('bodyparser');
             return new BodyParserMiddleware(config);
         });
     }
+    /**
+     * Registers bindings
+     */
     register() {
         this.registerServer();
         this.registerRouter();

package/build/services/ace.d.ts

@@ -1,4 +1,3 @@
 import type { Kernel } from '../modules/ace/main.js';
 declare let ace: Kernel;
 export { ace as default };
-//# sourceMappingURL=ace.d.ts.map

package/build/services/ace.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 ace;
+/**
+ * Returns a singleton instance of the ace kernel
+ * from the container.
+ *
+ * ace service is an instance of the "Kernel" class stored inside
+ * the "modules/ace/kernel.ts" file
+ */
 await app.booted(async () => {
     ace = await app.container.make('ace');
 });

package/build/services/app.d.ts

@@ -1,5 +1,12 @@
 import type { ApplicationService } from '../src/types.js';
 declare let app: ApplicationService;
+/**
+ * Set the application instance the app service should
+ * be using. Other services relies on the same app
+ * instance as well.
+ *
+ * app service is an instance of the "Application" exported from
+ * the "modules/app.ts" file.
+ */
 export declare function setApp(appService: ApplicationService): void;
 export { app as default };
-//# sourceMappingURL=app.d.ts.map

package/build/services/app.js

@@ -1,4 +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.
+ */
 let app;
+/**
+ * Set the application instance the app service should
+ * be using. Other services relies on the same app
+ * instance as well.
+ *
+ * app service is an instance of the "Application" exported from
+ * the "modules/app.ts" file.
+ */
 export function setApp(appService) {
     app = appService;
 }

package/build/services/config.d.ts

@@ -1,4 +1,3 @@
 import type { ApplicationService } from '../src/types.js';
 declare let config: ApplicationService['config'];
 export { config as default };
-//# sourceMappingURL=config.d.ts.map

package/build/services/config.js

@@ -1,5 +1,16 @@
+/*
+ * @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 config;
+/**
+ * The config service uses the config instance from the app service
+ */
 await app.booted(() => {
     config = app.config;
 });

package/build/services/emitter.d.ts

@@ -1,4 +1,3 @@
 import type { EmitterService } from '../src/types.js';
 declare let emitter: EmitterService;
 export { emitter as default };
-//# sourceMappingURL=emitter.d.ts.map

package/build/services/emitter.js

@@ -1,5 +1,17 @@
+/*
+ * @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 emitter;
+/**
+ * Returns a singleton instance of the emitter class
+ * from the container
+ */
 await app.booted(async () => {
     emitter = await app.container.make('emitter');
 });

package/build/services/encryption.d.ts

@@ -1,4 +1,3 @@
 import type { EncryptionService } from '../src/types.js';
 declare let encryption: EncryptionService;
 export { encryption as default };
-//# sourceMappingURL=encryption.d.ts.map

package/build/services/encryption.js

@@ -1,5 +1,17 @@
+/*
+ * @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 encryption;
+/**
+ * Returns a singleton instance of the encryption class
+ * from the container
+ */
 await app.booted(async () => {
     encryption = await app.container.make('encryption');
 });

package/build/services/hash.d.ts

@@ -1,4 +1,3 @@
 import type { HashService } from '../src/types.js';
 declare let hash: HashService;
 export { hash as default };
-//# sourceMappingURL=hash.d.ts.map

package/build/services/hash.js

@@ -1,5 +1,17 @@
+/*
+ * @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 hash;
+/**
+ * Returns a singleton instance of the Hash manager from the
+ * container
+ */
 await app.booted(async () => {
     hash = await app.container.make('hash');
 });

package/build/services/logger.d.ts

@@ -1,4 +1,3 @@
 import type { LoggerService } from '../src/types.js';
 declare let logger: LoggerService;
 export { logger as default };
-//# sourceMappingURL=logger.d.ts.map

package/build/services/logger.js

@@ -1,5 +1,17 @@
+/*
+ * @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 logger;
+/**
+ * Returns a singleton instance of the logger class
+ * from the container
+ */
 await app.booted(async () => {
     logger = await app.container.make('logger');
 });

package/build/services/router.d.ts

@@ -1,4 +1,3 @@
 import type { HttpRouterService } from '../src/types.js';
 declare let router: HttpRouterService;
 export { router as default };
-//# sourceMappingURL=router.d.ts.map

package/build/services/router.js

@@ -1,5 +1,17 @@
+/*
+ * @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 router;
+/**
+ * Returns a singleton instance of the router class from
+ * the container
+ */
 await app.booted(async () => {
     router = await app.container.make('router');
 });

package/build/services/server.d.ts

@@ -1,4 +1,3 @@
 import type { HttpServerService } from '../src/types.js';
 declare let server: HttpServerService;
 export { server as default };
-//# sourceMappingURL=server.d.ts.map

package/build/services/server.js

@@ -1,5 +1,17 @@
+/*
+ * @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 server;
+/**
+ * Returns a singleton instance of the HTTP server
+ * from the container
+ */
 await app.booted(async () => {
     server = await app.container.make('server');
 });

package/build/services/test_utils.d.ts

@@ -1,4 +1,3 @@
 import type { TestUtils } from '../src/test_utils/main.js';
 declare let testUtils: TestUtils;
 export { testUtils as default };
-//# sourceMappingURL=test_utils.d.ts.map

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/cli_formatters/routes_list.d.ts

@@ -1,5 +1,8 @@
 import { type Router } from '../../modules/http.js';
 import type { UIPrimitives } from '../../types/ace.js';
+/**
+ * Shape of the serialized route specific to the formatter
+ */
 type SerializedRoute = {
     name: string;
     pattern: string;
@@ -14,6 +17,12 @@ type SerializedRoute = {
         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: {
@@ -24,18 +33,31 @@ export declare class RoutesListFormatter {
         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 {};
-//# sourceMappingURL=routes_list.d.ts.map

package/build/src/cli_formatters/routes_list.js

@@ -1,11 +1,31 @@
+/*
+ * @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;
@@ -15,8 +35,15 @@ export class RoutesListFormatter {
         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 === '*') {
@@ -25,6 +52,10 @@ export class RoutesListFormatter {
                 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 === '*') {
@@ -33,22 +64,40 @@ export class RoutesListFormatter {
                 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') {
@@ -61,18 +110,30 @@ export class RoutesListFormatter {
             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) {
@@ -86,9 +147,15 @@ export class RoutesListFormatter {
             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)
@@ -107,14 +174,23 @@ export class RoutesListFormatter {
             .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];
@@ -124,6 +200,10 @@ export class RoutesListFormatter {
         }
         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)} `], {
@@ -133,19 +213,31 @@ export class RoutesListFormatter {
         }
         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, {
@@ -153,6 +245,10 @@ export class RoutesListFormatter {
                 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);
@@ -172,6 +268,10 @@ export class RoutesListFormatter {
             };
         });
     }
+    /**
+     * Formats routes as an array of objects. Routes are grouped by
+     * domain.
+     */
     async formatAsJSON() {
         const routes = this.#router.toJSON();
         const domains = Object.keys(routes);
@@ -185,6 +285,11 @@ export class RoutesListFormatter {
         }
         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);
@@ -201,6 +306,10 @@ export class RoutesListFormatter {
                     ],
                 ],
             };
+            /**
+             * 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)) {
@@ -218,6 +327,11 @@ export class RoutesListFormatter {
         }
         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);
@@ -235,6 +349,10 @@ export class RoutesListFormatter {
                     { 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)) {

package/build/src/debug.d.ts

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

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/helpers/is.d.ts

@@ -1,3 +1,2 @@
 import is from '@sindresorhus/is';
 export default is;
-//# sourceMappingURL=is.d.ts.map