@adonisjs/core 7.0.0-next.10 → 7.0.0-next.11

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;
-            });
-        }
-    }
-}

package/build/src/ignitor/http.js

@@ -1,159 +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 { createServer, } from 'node:http';
-import debug from "../debug.js";
-/**
- * The HTTP server process is used to start the application in the
- * web environment. It creates and manages the Node.js HTTP server
- * instance, handling lifecycle events and monitoring.
- *
- * @example
- * const ignitor = new Ignitor()
- * const httpProcess = new HttpServerProcess(ignitor)
- * await httpProcess.start()
- */
-export class HttpServerProcess {
-    /**
-     * Ignitor reference
-     */
-    #ignitor;
-    /**
-     * Creates a new HTTP server process instance
-     *
-     * @param ignitor - The ignitor instance used to create and manage the app
-     */
-    constructor(ignitor) {
-        this.#ignitor = ignitor;
-    }
-    /**
-     * Calling this method closes the underlying HTTP server gracefully.
-     *
-     * @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to close
-     */
-    #close(nodeHttpServer) {
-        return new Promise((resolve) => {
-            debug('closing http server process');
-            nodeHttpServer.close(() => resolve());
-        });
-    }
-    /**
-     * Monitors the app and the server to close the HTTP server when
-     * either one of them goes down. Sets up event listeners for graceful shutdown.
-     *
-     * @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to monitor
-     * @param app - The application service instance
-     * @param logger - The logger service for error reporting
-     */
-    #monitorAppAndServer(nodeHttpServer, app, logger) {
-        /**
-         * Close the HTTP server when the application begins to
-         * terminate
-         */
-        app.terminating(async () => {
-            debug('terminating signal received');
-            await this.#close(nodeHttpServer);
-        });
-        /**
-         * Terminate the app when the HTTP server crashes
-         */
-        nodeHttpServer.once('error', (error) => {
-            debug('http server crashed with error "%O"', error);
-            logger.fatal({ err: error }, error.message);
-            process.exitCode = 1;
-            app.terminate();
-        });
-    }
-    /**
-     * Starts the HTTP server on a given host and port using environment variables.
-     *
-     * @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to start listening
-     */
-    #listen(nodeHttpServer) {
-        return new Promise((resolve, reject) => {
-            const host = process.env.HOST || '0.0.0.0';
-            const port = Number(process.env.PORT || '3333');
-            nodeHttpServer.listen(port, host);
-            nodeHttpServer.once('listening', () => {
-                debug('listening to http server, host :%s, port: %s', host, port);
-                resolve({ port, host });
-            });
-            nodeHttpServer.once('error', (error) => {
-                reject(error);
-            });
-        });
-    }
-    /**
-     * Notifies the app and the parent process that the HTTP server is ready.
-     * Sends notifications through multiple channels: parent process, logger, and event emitter.
-     *
-     * @param app - The application service instance for parent process notification
-     * @param logger - The logger service for console output
-     * @param emitter - The event emitter for app-level notifications
-     * @param payload - Server startup information including host, port, and duration
-     */
-    #notifyServerHasStarted(app, logger, emitter, payload) {
-        /**
-         * Notify parent process
-         */
-        app.notify({ isAdonisJS: true, environment: 'web', ...payload });
-        /**
-         * Visual notification
-         */
-        logger.info('started HTTP server on %s:%s', payload.host, payload.port);
-        /**
-         * Notify app
-         */
-        emitter.emit('http:server_ready', payload);
-    }
-    /**
-     * Start the HTTP server by wiring up the application
-     *
-     * @param serverCallback - Optional callback to create custom HTTP server instance
-     */
-    async start(serverCallback) {
-        const startTime = process.hrtime();
-        /**
-         * Method to create the HTTP server
-         */
-        const createHTTPServer = serverCallback || createServer;
-        const app = this.#ignitor.createApp('web');
-        await app.init();
-        await app.boot();
-        await app.start(async () => {
-            /**
-             * Resolve and boot the AdonisJS HTTP server
-             */
-            const server = await app.container.make('server');
-            await server.boot();
-            /**
-             * Create Node.js HTTP server instance and share it with the
-             * AdonisJS HTTP server
-             */
-            const httpServer = createHTTPServer(server.handle.bind(server));
-            server.setNodeServer(httpServer);
-            const logger = await app.container.make('logger');
-            const emitter = await app.container.make('emitter');
-            /**
-             * Start the server by listening on a port of host
-             */
-            const payload = await this.#listen(httpServer);
-            /**
-             * Notify
-             */
-            this.#notifyServerHasStarted(app, logger, emitter, {
-                ...payload,
-                duration: process.hrtime(startTime),
-            });
-            /**
-             * Monitor app and the server (after the server is listening)
-             */
-            this.#monitorAppAndServer(httpServer, app, logger);
-        });
-    }
-}

package/build/src/ignitor/main.js

@@ -1,124 +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 debug from "../debug.js";
-import { AceProcess } from "./ace.js";
-import { TestRunnerProcess } from "./test.js";
-import { HttpServerProcess } from "./http.js";
-import { setApp } from "../../services/app.js";
-import { Application } from "../../modules/app.js";
-/**
- * Ignitor is used to instantiate an AdonisJS application in different
- * known environments. It serves as the main entry point for creating
- * and managing application processes.
- *
- * @example
- * const ignitor = new Ignitor(new URL(import.meta.url))
- *
- * // For HTTP server
- * await ignitor.httpServer().start()
- *
- * // For CLI commands
- * await ignitor.ace().handle(process.argv.slice(2))
- *
- * // For tests
- * await ignitor.testRunner().run(() => {})
- */
-export class Ignitor {
-    /**
-     * Ignitor options
-     */
-    #options;
-    /**
-     * Application root URL
-     */
-    #appRoot;
-    /**
-     * Reference to the application instance created using
-     * the "createApp" method.
-     *
-     * We store the output of the last call made to "createApp" method
-     * and assume that in one process only one entrypoint will
-     * call this method.
-     */
-    #app;
-    /**
-     * Reference to the created application
-     */
-    #tapCallbacks = new Set();
-    /**
-     * Creates a new Ignitor instance
-     *
-     * @param appRoot - The root URL of the application
-     * @param options - Configuration options for the ignitor
-     */
-    constructor(appRoot, options = {}) {
-        this.#appRoot = appRoot;
-        this.#options = options;
-    }
-    /**
-     * Runs all the tap callbacks
-     */
-    #runTapCallbacks(app) {
-        this.#tapCallbacks.forEach((tapCallback) => tapCallback(app));
-    }
-    /**
-     * Get access to the application instance created
-     * by either the http server process or the ace
-     * process
-     */
-    getApp() {
-        return this.#app;
-    }
-    /**
-     * Create an instance of AdonisJS application
-     *
-     * @param environment - The environment in which to create the app (web, console, test, repl)
-     */
-    createApp(environment) {
-        debug('creating application instance');
-        this.#app = new Application(this.#appRoot, { environment, importer: this.#options.importer });
-        setApp(this.#app);
-        this.#runTapCallbacks(this.#app);
-        return this.#app;
-    }
-    /**
-     * Tap to access the application class instance.
-     *
-     * @param callback - Callback function to execute when app is created
-     */
-    tap(callback) {
-        this.#tapCallbacks.add(callback);
-        return this;
-    }
-    /**
-     * Get instance of the HTTPServerProcess
-     */
-    httpServer() {
-        return new HttpServerProcess(this);
-    }
-    /**
-     * Get an instance of the AceProcess class
-     */
-    ace() {
-        return new AceProcess(this);
-    }
-    /**
-     * Get an instance of the TestRunnerProcess class
-     */
-    testRunner() {
-        return new TestRunnerProcess(this);
-    }
-    /**
-     * Terminates the app by calling the "app.terminate"
-     * method
-     */
-    async terminate() {
-        await this.#app?.terminate();
-    }
-}

package/build/src/ignitor/test.js

@@ -1,66 +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 Test runner process is used to start the tests runner process.
- * It provides lifecycle hooks for configuring the test environment
- * and running tests within the AdonisJS application context.
- *
- * @example
- * const ignitor = new Ignitor()
- * const testProcess = new TestRunnerProcess(ignitor)
- *
- * await testProcess
- *   .configure((app) => {
- *     // Configure test environment
- *   })
- *   .run(async (app) => {
- *     // Run your tests
- *   })
- */
-export class TestRunnerProcess {
-    /**
-     * Ignitor reference
-     */
-    #ignitor;
-    /**
-     * The callback that configures the tests runner. This callback
-     * runs at the time of starting the app.
-     */
-    #configureCallback = () => { };
-    /**
-     * Creates a new test runner process instance
-     *
-     * @param ignitor - The ignitor instance used to create and manage the app
-     */
-    constructor(ignitor) {
-        this.#ignitor = ignitor;
-    }
-    /**
-     * Register a callback that runs after booting the AdonisJS app
-     * and just before the provider's ready hook
-     *
-     * @param callback - Configuration callback function
-     */
-    configure(callback) {
-        this.#configureCallback = callback;
-        return this;
-    }
-    /**
-     * Runs a callback after starting the app
-     *
-     * @param callback - Test execution callback function
-     */
-    async run(callback) {
-        const app = this.#ignitor.createApp('test');
-        await app.init();
-        await app.boot();
-        await app.start(this.#configureCallback);
-        await callback(app);
-    }
-}

package/build/src/test_utils/http.js

@@ -1,82 +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 debug from "../debug.js";
-import { createServer, } from 'node:http';
-/**
- * Http server utils are used to start the AdonisJS HTTP server
- * during testing. It provides methods to start and stop the server
- * for integration testing.
- *
- * @example
- * const testUtils = new TestUtils(app)
- * const httpUtils = testUtils.httpServer()
- *
- * const closeServer = await httpUtils.start()
- * // Make HTTP requests to test endpoints
- * await closeServer() // Clean up
- */
-export class HttpServerUtils {
-    /**
-     * Reference to the test utils instance
-     */
-    #utils;
-    /**
-     * Creates a new HttpServerUtils instance
-     *
-     * @param utils - The test utils instance
-     */
-    constructor(utils) {
-        this.#utils = utils;
-    }
-    /**
-     * Starts the http server a given host and port
-     *
-     * @param nodeHttpServer - The Node.js HTTP server instance
-     */
-    #listen(nodeHttpServer) {
-        return new Promise((resolve, reject) => {
-            const host = process.env.HOST || '0.0.0.0';
-            const port = Number(process.env.PORT || '3333');
-            nodeHttpServer.listen(port, host);
-            nodeHttpServer.once('listening', () => {
-                debug('listening to utils http server, host :%s, port: %s', host, port);
-                resolve({ port, host });
-            });
-            nodeHttpServer.once('error', (error) => {
-                reject(error);
-            });
-        });
-    }
-    /**
-     * Testing hook to start the HTTP server to listen for new request.
-     * The return value is a function to close the HTTP server.
-     *
-     * @param serverCallback - Optional callback to create custom HTTP server instance
-     */
-    async start(serverCallback) {
-        const createHTTPServer = serverCallback || createServer;
-        const server = await this.#utils.app.container.make('server');
-        await server.boot();
-        const httpServer = createHTTPServer(server.handle.bind(server));
-        server.setNodeServer(httpServer);
-        await this.#listen(httpServer);
-        return () => {
-            return new Promise((resolve, reject) => {
-                httpServer.close((error) => {
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            });
-        };
-    }
-}

package/build/src/utils.js

@@ -1,114 +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.
- */
-/**
- * Imports the AdonisJS assembler package optionally. This function attempts
- * to import the assembler and returns undefined if it's not available,
- * making it safe to use in environments where the assembler might not be installed.
- *
- * @param app - The application service instance used for importing the assembler
- *
- * @example
- * const assembler = await importAssembler(app)
- * if (assembler) {
- *   // Use assembler functionality
- *   const generator = new assembler.IndexGenerator()
- * }
- */
-export async function importAssembler(app) {
-    try {
-        return await app.import('@adonisjs/assembler');
-    }
-    catch { }
-}
-/**
- * Imports the TypeScript compiler package optionally. This function attempts
- * to import TypeScript and returns undefined if it's not available,
- * making it safe to use in environments where TypeScript might not be installed.
- *
- * @param app - The application service instance used for importing TypeScript
- *
- * @example
- * const ts = await importTypeScript(app)
- * if (ts) {
- *   // Use TypeScript compiler API
- *   const program = ts.createProgram(['file.ts'], {})
- *   const sourceFile = program.getSourceFile('file.ts')
- * }
- */
-export async function importTypeScript(app) {
-    try {
-        return await app.importDefault('typescript');
-    }
-    catch { }
-}
-/**
- * Outputs transformer data objects by generating TypeScript type definitions
- * for all transformers in the provided file tree. This function creates
- * InferData types for each transformer and organizes them in namespaces.
- *
- * @param transformersList - A recursive file tree containing transformer file paths
- * @param buffer - The file buffer to write the generated types to
- *
- * @example
- * const transformersList = {
- *   User: '#app/transformers/user_transformer',
- *   Auth: {
- *     Login: '#app/transformers/auth/login_transformer'
- *   }
- * }
- * await outputTransformerDataObjects(transformersList, buffer)
- * // Generates:
- * // export namespace Data {
- * //   export type User = InferData<UserTransformer>
- * //   export namespace Auth {
- * //     export type Login = InferData<AuthLoginTransformer>
- * //   }
- * // }
- */
-export async function outputTransformerDataObjects(transformersList, buffer, withSharedProps) {
-    const importsBuffer = buffer.create();
-    importsBuffer.write(`import type { InferData, InferVariants } from '@adonisjs/core/types/transformers'`);
-    if (withSharedProps) {
-        importsBuffer.write(`import type { InferSharedProps } from '@adonisjs/inertia/types'`);
-    }
-    buffer.writeLine(importsBuffer);
-    buffer.write('export namespace Data {').indent();
-    /**
-     * Recursively generates namespace tree structure for transformers.
-     * Creates nested namespaces for directory structures and type exports
-     * for individual transformer files.
-     *
-     * @param input - The current level of the file tree to process
-     * @param parents - Array of parent namespace names for import naming
-     */
-    function generateNamespaceTree(input, parents) {
-        Object.keys(input).forEach((key) => {
-            const value = input[key];
-            if (typeof value === 'string') {
-                const importName = `${parents.join()}${key}Transformer`;
-                importsBuffer.write(`import type ${importName} from '${value}'`);
-                buffer.write(`export type ${key} = InferData<${importName}>`);
-                buffer.write(`export namespace ${key} {`).indent();
-                buffer.write(`export type Variants = InferVariants<${importName}>`);
-                buffer.dedent().write('}');
-            }
-            else {
-                buffer.write(`export namespace ${key} {`).indent();
-                generateNamespaceTree(value, [...parents, key]);
-                buffer.dedent().write(`}`);
-            }
-        });
-    }
-    generateNamespaceTree(transformersList, []);
-    if (withSharedProps) {
-        importsBuffer.write(`import type InertiaMiddleware from '#middleware/inertia_middleware'`);
-        buffer.write('export type SharedProps = InferSharedProps<InertiaMiddleware>');
-    }
-    buffer.dedent().write('}');
-}

package/build/stubs/main.js

@@ -1,9 +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.
- */
-export const stubsRoot = import.meta.dirname;

package/build/toolkit/commands/index_commands.js

@@ -1,30 +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.
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { join } from 'node:path';
-import { args, BaseCommand, IndexGenerator } from '@adonisjs/ace';
-/**
- * Generates index of commands with a loader. Must be called against
- * the TypeScript compiled output.
- */
-export default class IndexCommand extends BaseCommand {
-    static commandName = 'index';
-    static description = 'Create an index of commands along with a lazy loader';
-    async run() {
-        await new IndexGenerator(join(process.cwd(), this.commandsDir)).generate();
-    }
-}
-__decorate([
-    args.string({ description: 'Relative path from cwd to the commands directory' })
-], IndexCommand.prototype, "commandsDir", void 0);