@adonisjs/core 7.0.0-next.2 → 7.0.0-next.20

package/build/src/assembler_hooks/index_entities.js

@@ -1,107 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import stringHelpers from "../helpers/string.js";
-import { outputTransformerDataObjects } from "../utils.js";
-/**
- * Configures the IndexGenerator to create barrel files for "controllers", "events",
- * and "listeners". This function is used as an assembler hook to automatically generate
- * index files that export all modules from specified directories.
- *
- * @param {IndexEntitiesConfig} entities - Configuration object for entities indexing
- *
- * @example
- * // Basic usage with default configuration
- * indexEntities({})
- *
- * @example
- * // Custom configuration for specific entities
- * indexEntities({
- *   events: {
- *     enabled: true,
- *     source: 'app/custom-events',
- *     importAlias: '#custom-events'
- *   },
- *   controllers: {
- *     enabled: false
- *   }
- * })
- *
- * @example
- * // Using custom glob patterns
- * indexEntities({
- *   listeners: {
- *     source: 'app/handlers',
- *     glob: '**\/*_handler.ts'
- *   }
- * })
- */
-export function indexEntities(entities = {}) {
-    const events = Object.assign({ enabled: true, source: 'app/events', importAlias: '#events' }, entities.events);
-    const listeners = Object.assign({ enabled: true, source: 'app/listeners', importAlias: '#listeners' }, entities.listeners);
-    const controllers = Object.assign({ enabled: true, source: 'app/controllers', importAlias: '#controllers' }, entities.controllers);
-    const transformers = Object.assign({ enabled: false, source: 'app/transformers', importAlias: '#transformers' }, entities.transformers);
-    return {
-        run(_, indexGenerator) {
-            if (events.enabled) {
-                indexGenerator.add('events', {
-                    source: events.source,
-                    disableLazyImports: true,
-                    glob: events.glob,
-                    as: 'barrelFile',
-                    exportName: 'events',
-                    importAlias: events.importAlias,
-                    output: '.adonisjs/server/events.ts',
-                });
-            }
-            if (listeners.enabled) {
-                indexGenerator.add('listeners', {
-                    source: listeners.source,
-                    glob: listeners.glob,
-                    as: 'barrelFile',
-                    exportName: 'listeners',
-                    importAlias: listeners.importAlias,
-                    output: '.adonisjs/server/listeners.ts',
-                });
-            }
-            if (controllers.enabled) {
-                indexGenerator.add('controllers', {
-                    source: controllers.source,
-                    glob: controllers.glob,
-                    as: 'barrelFile',
-                    exportName: 'controllers',
-                    importAlias: controllers.importAlias,
-                    removeSuffix: 'controller',
-                    output: '.adonisjs/server/controllers.ts',
-                });
-            }
-            if (transformers.enabled) {
-                indexGenerator.add('transformers', {
-                    source: transformers.source,
-                    glob: transformers.glob,
-                    as(vfs, buffer, __, helpers) {
-                        const transformersList = vfs.asTree({
-                            transformKey(key) {
-                                const segments = key.split('/');
-                                const baseName = segments.pop();
-                                return [
-                                    ...segments.map((segment) => stringHelpers.pascalCase(segment)),
-                                    stringHelpers.create(baseName).removeSuffix('transformer').pascalCase(),
-                                ].join('/');
-                            },
-                            transformValue: helpers.toImportPath,
-                        });
-                        outputTransformerDataObjects(transformersList, buffer);
-                    },
-                    importAlias: transformers.importAlias,
-                    output: '.adonisjs/client/data.d.ts',
-                });
-            }
-        },
-    };
-}

package/build/src/cli_formatters/routes_list.js

@@ -1,381 +0,0 @@
-/*
- * @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 { middlewareInfo, routeInfo } from '@adonisjs/http-server/helpers';
-/**
- * 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
- *
- * @example
- * const formatter = new RoutesListFormatter(router, ui, {
- *   displayHeadRoutes: false,
- *   maxPrettyPrintWidth: 120
- * }, {
- *   match: 'api',
- *   middleware: ['auth']
- * })
- *
- * const ansiOutput = await formatter.formatAsAnsiList()
- */
-export class RoutesListFormatter {
-    /**
-     * Router instance containing all registered routes
-     */
-    #router;
-    /**
-     * Colors utility for ANSI formatting
-     */
-    #colors;
-    /**
-     * Table utility for creating formatted tables
-     */
-    #table;
-    /**
-     * Options for printing routes
-     */
-    #options;
-    /**
-     * Filters to apply when finding routes
-     */
-    #filters;
-    /**
-     * Creates a new instance of the routes list formatter
-     *
-     * @param router - Router instance containing routes to format
-     * @param ui - UI primitives for colors and table formatting
-     * @param options - Display options for route formatting
-     * @param filters - Filters to apply when displaying routes
-     */
-    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.find((middleware) => middleware.name === 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.find((middleware) => middleware.name === 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;
-    }
-    /**
-     * 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');
-        }
-        const middlewareList = await Promise.all([...route.middleware.all()].map((middleware) => {
-            return middlewareInfo(middleware);
-        }));
-        return {
-            name: route.name || '',
-            pattern: route.pattern,
-            methods: methods,
-            handler: await routeInfo(route),
-            middleware: middlewareList.filter((info) => info.type !== 'global'),
-        };
-    }
-    /**
-     * 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'
-            ? ` ${this.#colors.cyan(route.handler.moduleNameOrPath)}.`
-            : '';
-    }
-    /**
-     * Formats action name for the ansi list and table
-     */
-    #formatAction(route) {
-        if (route.handler.type === 'controller') {
-            return `${this.#colors.cyan(route.handler.method)}`;
-        }
-        const functionName = ` ${this.#colors.cyan(route.handler.name)}`;
-        if (route.handler.args) {
-            return ` ${functionName}${this.#colors.dim(`(${route.handler.args})`)}`;
-        }
-        return functionName;
-    }
-    /**
-     * 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].name;
-            const secondMiddleware = route.middleware[1].name;
-            const diff = route.middleware.length - 2;
-            return this.#colors.dim(`${firstMiddleware}, ${secondMiddleware}, and ${diff} more`);
-        }
-        return this.#colors.dim(`${route.middleware
-            .map((one) => one.name)
-            .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/config_provider.js

@@ -1,71 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/**
- * Helper utilities to create and resolve config providers. Config providers
- * are used to defer configuration resolution until the application is booted,
- * allowing access to environment variables and other application services.
- *
- * @example
- * // Creating a database config provider
- * const databaseConfig = configProvider.create(async (app) => ({
- *   connection: app.env.get('DB_CONNECTION', 'sqlite'),
- *   host: app.env.get('DB_HOST', 'localhost'),
- *   port: app.env.get('DB_PORT', 5432)
- * }))
- *
- * @example
- * // Resolving a config provider
- * const config = await configProvider.resolve(app, databaseConfig)
- * if (config) {
- *   console.log(`Database connection: ${config.connection}`)
- * }
- */
-export const configProvider = {
-    /**
-     * Creates a new config provider that will resolve configuration
-     * when the application is booted.
-     *
-     * @param resolver - Function that receives the application service and returns the configuration
-     *
-     * @example
-     * const mailConfig = configProvider.create(async (app) => ({
-     *   driver: app.env.get('MAIL_DRIVER', 'smtp'),
-     *   host: app.env.get('SMTP_HOST'),
-     *   port: app.env.get('SMTP_PORT', 587)
-     * }))
-     */
-    create(resolver) {
-        return {
-            type: 'provider',
-            resolver,
-        };
-    },
-    /**
-     * Resolves a config provider if the provided value is a valid config provider,
-     * otherwise returns null.
-     *
-     * @param app - The application service instance
-     * @param provider - The potential config provider to resolve
-     *
-     * @example
-     * const resolved = await configProvider.resolve(app, someProvider)
-     * if (resolved) {
-     *   // Use the resolved configuration
-     *   console.log('Config resolved:', resolved)
-     * } else {
-     *   console.log('Not a valid config provider')
-     * }
-     */
-    async resolve(app, provider) {
-        if (provider && typeof provider === 'object' && 'type' in provider) {
-            return provider.resolver(app);
-        }
-        return null;
-    },
-};

package/build/src/debug.js

@@ -1,25 +0,0 @@
-/*
- * @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';
-/**
- * Debug utility for AdonisJS core. This uses Node.js built-in debuglog
- * utility to provide debugging information when the NODE_DEBUG environment
- * variable includes 'adonisjs:core'.
- *
- * @example
- * // Enable debugging by setting environment variable
- * // NODE_DEBUG=adonisjs:core node app.js
- *
- * @example
- * // Usage in code
- * import debug from '@adonisjs/core/debug'
- * debug('Application started')
- * debug('Processing request: %s', req.url)
- */
-export default debuglog('adonisjs:core');

package/build/src/ignitor/ace.js

@@ -1,102 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/**
- * The Ace process is used to start the application in the
- * console environment. It manages the Ace kernel lifecycle
- * and command execution.
- *
- * @example
- * const ignitor = new Ignitor()
- * const aceProcess = new AceProcess(ignitor)
- *
- * await aceProcess
- *   .configure((app) => {
- *     // Configure ace kernel
- *   })
- *   .handle(['make:controller', 'UserController'])
- */
-export class AceProcess {
-    /**
-     * Ignitor reference
-     */
-    #ignitor;
-    /**
-     * The callback that configures the ace instance before the
-     * handle method is called
-     */
-    #configureCallback = () => { };
-    /**
-     * Creates a new Ace process instance
-     *
-     * @param ignitor - The ignitor instance used to create and manage the app
-     */
-    constructor(ignitor) {
-        this.#ignitor = ignitor;
-    }
-    /**
-     * Register a callback that can be used to configure the ace
-     * kernel before the handle method is called
-     *
-     * @param callback - Configuration callback function
-     */
-    configure(callback) {
-        this.#configureCallback = callback;
-        return this;
-    }
-    /**
-     * Handles the command line arguments and executes
-     * the matching ace commands
-     *
-     * @param argv - Command line arguments array
-     */
-    async handle(argv) {
-        const app = this.#ignitor.createApp('console');
-        await app.init();
-        const { createAceKernel } = await import('../../modules/ace/create_kernel.js');
-        const commandNameIndex = argv.findIndex((value) => !value.startsWith('-'));
-        const commandName = argv[commandNameIndex];
-        const kernel = createAceKernel(app, commandName);
-        app.container.bindValue('ace', kernel);
-        /**
-         * Hook into kernel and start the app when the
-         * command needs the app.
-         *
-         * Since multiple commands can be executed in a single process,
-         * we add a check to only start the app only once.
-         */
-        kernel.loading(async (metaData) => {
-            if (metaData.options.startApp && !app.isReady) {
-                if (metaData.commandName === 'repl') {
-                    app.setEnvironment('repl');
-                }
-                await app.boot();
-                await app.start(() => { });
-            }
-        });
-        await this.#configureCallback(app);
-        /**
-         * Handle command line args
-         */
-        await kernel.handle(argv);
-        /**
-         * Terminate the app when the command does not want to
-         * hold a long running process
-         */
-        const mainCommand = kernel.getMainCommand();
-        if (!mainCommand || !mainCommand.staysAlive) {
-            process.exitCode = kernel.exitCode;
-            await app.terminate();
-        }
-        else {
-            app.terminating(() => {
-                process.exitCode = mainCommand.exitCode;
-            });
-        }
-    }
-}