@adonisjs/core 6.1.5-4 → 6.1.5-6

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.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/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

@@ -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/exceptions.d.ts

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

package/{factories/app.ts → build/src/exceptions.js}

@@ -6,5 +6,4 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
-export * from '@adonisjs/application/factories'
+export { Exception, createError, RuntimeException, InvalidArgumentsException, } from '@poppinss/utils';

package/build/src/helpers/is.d.ts

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

package/build/src/helpers/is.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 is from '@sindresorhus/is';
 export default is;

package/build/src/helpers/main.d.ts

@@ -2,4 +2,3 @@ export { default as parseImports } from 'parse-imports';
 export { createId as cuid } from '@paralleldrive/cuid2';
 export { safeEqual, compose, base64, fsImportAll, fsReadAll, slash } from '@poppinss/utils';
 export { parseBindingReference } from './parse_binding_reference.js';
-//# sourceMappingURL=main.d.ts.map

package/build/src/helpers/main.js

@@ -1,3 +1,11 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 export { default as parseImports } from 'parse-imports';
 export { createId as cuid } from '@paralleldrive/cuid2';
 export { safeEqual, compose, base64, fsImportAll, fsReadAll, slash } from '@poppinss/utils';

package/build/src/helpers/parse_binding_reference.d.ts

@@ -1,6 +1,45 @@
 import { LazyImport, Constructor } from '../../types/http.js';
+/**
+ * The "parseBindingReference" method can be used to parse a binding references
+ * similar to route controller binding value or event listener binding value.
+ *
+ * See the following examples to understand how this function works.
+ *
+ * ### Magic strings
+ * ```ts
+ * parseBindingReference('#controllers/home_controller')
+ * // returns { moduleNameOrPath: '#controllers/home_controller', method: 'handle' }
+
+ * parseBindingReference('#controllers/home_controller.index')
+ * // returns { moduleNameOrPath: '#controllers/home_controller', method: 'index' }
+
+ * parseBindingReference('#controllers/home.controller.index')
+ * // returns { moduleNameOrPath: '#controllers/home.controller', method: 'index' }
+ * ```
+ *
+ * ### Class reference
+ * ```ts
+ * class HomeController {}
+ *
+ * parseBindingReference([HomeController])
+ * // returns { moduleNameOrPath: 'HomeController', method: 'handle' }
+
+ * parseBindingReference([HomeController, 'index'])
+ * // returns { moduleNameOrPath: 'HomeController', method: 'index' }
+ * ```
+ *
+ * ### Lazy import reference
+ * ```ts
+ * const HomeController = () => import('#controllers/home_controller')
+ *
+ * parseBindingReference([HomeController])
+ * // returns { moduleNameOrPath: '#controllers/home_controller', method: 'handle' }
+
+ * parseBindingReference([HomeController, 'index'])
+ * // returns { moduleNameOrPath: 'controllers/home_controller', method: 'index' }
+ * ```
+ */
 export declare function parseBindingReference(binding: string | [LazyImport<Constructor<any>> | Constructor<any>, any?]): Promise<{
     moduleNameOrPath: string;
     method: string;
 }>;
-//# sourceMappingURL=parse_binding_reference.d.ts.map