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

package/build/providers/edge_provider.js

@@ -1,104 +1,97 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import edge from 'edge.js';
-import { pluginEdgeDumper } from "../modules/dumper/plugins/edge.js";
-import { BriskRoute, HttpContext } from "../modules/http/main.js";
-/**
- * The Edge service provider configures Edge to work within
- * an AdonisJS application environment
- *
- * This provider integrates EdgeJS template engine with AdonisJS by:
- * - Mounting the views directory
- * - Configuring template caching for production
- * - Adding global helpers for route generation
- * - Creating isolated renderer instances for HTTP contexts
- * - Adding render macro to BriskRoute for template rendering
- *
- * @example
- * const provider = new EdgeServiceProvider(app)
- * await provider.boot()
- */
-export default class EdgeServiceProvider {
-    app;
-    /**
-     * Edge service provider constructor
-     *
-     * Sets the usingEdgeJS flag to true to indicate EdgeJS is being used.
-     *
-     * @param app - The application service instance
-     */
-    constructor(app) {
-        this.app = app;
-        this.app.usingEdgeJS = true;
-    }
-    /**
-     * Bridge AdonisJS and Edge
-     *
-     * Configures EdgeJS integration by:
-     * - Setting up template mounting and caching
-     * - Defining global helpers (route, signedRoute, app, config)
-     * - Adding view getter to HttpContext for isolated rendering
-     * - Adding render macro to BriskRoute
-     * - Registering dumper plugin
-     *
-     * @example
-     * await provider.boot()
-     * // Now edge templates can use {{ route('home') }} helper
-     */
-    async boot() {
-        const app = this.app;
-        const router = await this.app.container.make('router');
-        const dumper = await this.app.container.make('dumper');
-        function edgeConfigResolver(key, defaultValue) {
-            return app.config.get(key, defaultValue);
-        }
-        edgeConfigResolver.has = function (key) {
-            return app.config.has(key);
-        };
-        /**
-         * Mount the default disk
-         */
-        edge.mount(app.viewsPath());
-        /**
-         * Cache templates in production
-         */
-        edge.configure({ cache: app.inProduction });
-        /**
-         * Define Edge global helpers
-         */
-        edge.global('route', function (...args) {
-            return router.makeUrl(...args);
-        });
-        edge.global('signedRoute', function (...args) {
-            return router.makeSignedUrl(...args);
-        });
-        edge.global('app', app);
-        edge.global('config', edgeConfigResolver);
-        /**
-         * Creating a isolated instance of edge renderer
-         */
-        HttpContext.getter('view', function () {
-            return edge.createRenderer().share({
-                request: this.request,
-            });
-        }, true);
-        /**
-         * Adding brisk route to render templates without an
-         * explicit handler
-         */
-        BriskRoute.macro('render', function (template, data) {
-            function rendersTemplate({ view }) {
-                return view.render(template, data);
-            }
-            Object.defineProperty(rendersTemplate, 'listArgs', { value: template, writable: false });
-            return this.setHandler(rendersTemplate);
-        });
-        edge.use(pluginEdgeDumper(dumper));
-    }
-}
+import "../chunk-MjwdjG2f.js";
+import { t as main_exports } from "../main-CFmDHDls.js";
+import { t as pluginEdgeDumper } from "../edge-LQdCc1L3.js";
+import edge from "edge.js";
+var EdgeServiceProvider = class {
+	constructor(app) {
+		this.app = app;
+		this.app.usingEdgeJS = true;
+	}
+	async boot() {
+		const app = this.app;
+		const qs = new main_exports.Qs(app.config.get("app.http.qs", {}));
+		const router = await this.app.container.make("router");
+		const dumper = await this.app.container.make("dumper");
+		function edgeConfigResolver(key, defaultValue) {
+			return app.config.get(key, defaultValue);
+		}
+		edgeConfigResolver.has = function(key) {
+			return app.config.has(key);
+		};
+		function clientRoutes() {
+			const routes = router.toJSON();
+			return Object.keys(routes).reduce((result, domain) => {
+				result[domain] = routes[domain].reduce((routesResult, route) => {
+					if (!route.name) return routesResult;
+					routesResult.push({
+						domain: route.domain,
+						methods: route.methods,
+						pattern: route.pattern,
+						tokens: route.tokens,
+						name: route.name
+					});
+					return routesResult;
+				}, []);
+				return result;
+			}, {});
+		}
+		edge.mount(app.viewsPath());
+		edge.configure({ cache: app.inProduction });
+		edge.global("route", function(...args) {
+			return router.makeUrl(...args);
+		});
+		edge.global("signedRoute", function(...args) {
+			return router.makeSignedUrl(...args);
+		});
+		edge.global("app", app);
+		edge.global("config", edgeConfigResolver);
+		edge.global("routes", function() {
+			return clientRoutes();
+		});
+		edge.global("routesJSON", function() {
+			return JSON.stringify(clientRoutes());
+		});
+		edge.global("urlFor", function(...args) {
+			return router.urlBuilder.urlFor(...args);
+		});
+		edge.global("signedUrlFor", function(...args) {
+			return router.urlBuilder.signedUrlFor(...args);
+		});
+		edge.global("qs", qs);
+		edge.global("formAttributes", function(route, method, params, options) {
+			options = options ?? {};
+			method = method.toUpperCase();
+			const original = method;
+			if (method !== "GET" && method !== "POST") {
+				method = "POST";
+				options = {
+					...options,
+					qs: {
+						_method: original,
+						...options.qs
+					}
+				};
+			}
+			const { action } = router.urlBuilder.urlFor.method(original, route, params, options).form;
+			return {
+				action,
+				method
+			};
+		});
+		main_exports.HttpContext.getter("view", function() {
+			return edge.createRenderer().share({ request: this.request });
+		}, true);
+		main_exports.BriskRoute.macro("render", function(template, data) {
+			function rendersTemplate({ view }) {
+				return view.render(template, data);
+			}
+			Object.defineProperty(rendersTemplate, "listArgs", {
+				value: template,
+				writable: false
+			});
+			return this.setHandler(rendersTemplate);
+		});
+		edge.use(pluginEdgeDumper(dumper));
+	}
+};
+export { EdgeServiceProvider as default };

package/build/providers/hash_provider.js

@@ -1,91 +1,29 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { RuntimeException } from '@poppinss/utils/exception';
-import { Hash } from "../modules/hash/main.js";
-import { configProvider } from "../src/config_provider.js";
-/**
- * Registers the passwords hasher with the container
- *
- * This provider sets up password hashing functionality by:
- * - Registering the HashManager with configuration from config/hash.ts
- * - Providing a Hash class that uses the default hasher
- * - Supporting multiple hashing drivers (bcrypt, argon2, etc.)
- *
- * @example
- * const provider = new HashServiceProvider(app)
- * provider.register()
- * const hash = await app.container.make('hash')
- */
-export default class HashServiceProvider {
-    app;
-    /**
-     * Hash service provider constructor
-     *
-     * @param app - The application service instance
-     */
-    constructor(app) {
-        this.app = app;
-    }
-    /**
-     * Registering the hash class to resolve an instance with the
-     * default hasher.
-     *
-     * Creates a singleton binding for the Hash class that resolves
-     * the default hasher from the hash manager.
-     *
-     * @example
-     * const hash = await container.make(Hash)
-     * const hashed = await hash.make('password')
-     */
-    registerHash() {
-        this.app.container.singleton(Hash, async (resolver) => {
-            const hashManager = await resolver.make('hash');
-            return hashManager.use();
-        });
-    }
-    /**
-     * Registers the hash manager with the container
-     *
-     * Creates a singleton binding for 'hash' that instantiates
-     * the HashManager with configuration from config/hash.ts file.
-     * Throws an error if the configuration is invalid.
-     *
-     * @example
-     * const hashManager = await container.make('hash')
-     * const bcryptHasher = hashManager.use('bcrypt')
-     */
-    registerHashManager() {
-        this.app.container.singleton('hash', async () => {
-            const hashConfigProvider = this.app.config.get('hash');
-            /**
-             * Resolve config from the provider
-             */
-            const config = await configProvider.resolve(this.app, hashConfigProvider);
-            if (!config) {
-                throw new RuntimeException('Invalid "config/hash.ts" file. Make sure you are using the "defineConfig" method');
-            }
-            const { HashManager } = await import('../modules/hash/main.js');
-            return new HashManager(config);
-        });
-    }
-    /**
-     * Registers bindings
-     *
-     * Called during the application bootstrap phase to register
-     * the hash manager and hash class with the IoC container.
-     *
-     * @example
-     * const provider = new HashServiceProvider(app)
-     * provider.register() // Registers hash services
-     */
-    register() {
-        this.registerHashManager();
-        this.registerHash();
-    }
-}
+import "../chunk-MjwdjG2f.js";
+import "../debug-DURPi9xn.js";
+import { t as configProvider } from "../config_provider-CY-xuo2R.js";
+import { t as main_exports } from "../main-BrJQ1VAM.js";
+import { RuntimeException } from "@poppinss/utils/exception";
+var HashServiceProvider = class {
+	constructor(app) {
+		this.app = app;
+	}
+	registerHash() {
+		this.app.container.singleton(main_exports.Hash, async (resolver) => {
+			return (await resolver.make("hash")).use();
+		});
+	}
+	registerHashManager() {
+		this.app.container.singleton("hash", async () => {
+			const hashConfigProvider = this.app.config.get("hash");
+			const config = await configProvider.resolve(this.app, hashConfigProvider);
+			if (!config) throw new RuntimeException("Invalid \"config/hash.ts\" file. Make sure you are using the \"defineConfig\" method");
+			const { HashManager } = await import("../modules/hash/main.js");
+			return new HashManager(config);
+		});
+	}
+	register() {
+		this.registerHashManager();
+		this.registerHash();
+	}
+};
+export { HashServiceProvider as default };

package/build/providers/repl_provider.js

@@ -1,154 +1,63 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { fsImportAll } from '@poppinss/utils/fs';
-import { Repl } from "../modules/repl.js";
-/**
- * Resolves a container binding and sets it on the REPL
- * context
- *
- * This helper function makes a service from the container and
- * adds it to the REPL context with a notification message.
- *
- * @param app - The application service instance
- * @param repl - The REPL instance to add the binding to
- * @param binding - The container binding key to resolve
- *
- * @example
- * await resolveBindingForRepl(app, repl, 'router')
- * // Now 'router' variable is available in REPL
- */
+import "../chunk-MjwdjG2f.js";
+import { t as repl_exports } from "../repl-CumYg2V_.js";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { fsImportAll } from "@poppinss/utils/fs";
 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`);
-}
-/**
- * REPL Service Provider configures the interactive Node.js REPL
- * for AdonisJS applications
- *
- * This provider sets up:
- * - REPL instance with history file support
- * - Helper methods for importing modules and making container bindings
- * - Quick access methods for loading common services (app, router, etc.)
- * - Utility methods for development and debugging
- *
- * @example
- * const provider = new ReplServiceProvider(app)
- * provider.register()
- * await provider.boot()
- */
-export default class ReplServiceProvider {
-    app;
-    /**
-     * REPL service provider constructor
-     *
-     * @param app - The application service instance
-     */
-    constructor(app) {
-        this.app = app;
-    }
-    /**
-     * Registers the REPL binding
-     *
-     * Creates a singleton binding for the REPL with history file
-     * support in the user's home directory.
-     *
-     * @example
-     * const provider = new ReplServiceProvider(app)
-     * provider.register()
-     * const repl = await app.container.make('repl')
-     */
-    register() {
-        this.app.container.singleton(Repl, async () => {
-            return new Repl({
-                historyFilePath: join(homedir(), '.adonisjs_v6_repl_history'),
-            });
-        });
-        this.app.container.alias('repl', Repl);
-    }
-    /**
-     * Registering REPL bindings during provider boot
-     *
-     * Adds helper methods to the REPL instance including:
-     * - importDefault: Import default export from modules
-     * - importAll: Import all files from a directory
-     * - make: Create instances using container.make
-     * - load* methods: Quick access to common services
-     * - loadHelpers: Load utility helper functions
-     *
-     * @example
-     * await provider.boot()
-     * // REPL now has helper methods available
-     */
-    async boot() {
-        this.app.container.resolving('repl', (repl) => {
-            repl.addMethod('importDefault', (_, modulePath) => {
-                return this.app.importDefault(modulePath);
-            }, {
-                description: 'Returns the default export for a module',
-            });
-            repl.addMethod('importAll', (_, dirPath) => {
-                return fsImportAll(this.app.makeURL(dirPath), {
-                    ignoreMissingRoot: false,
-                });
-            }, {
-                description: 'Import all files from a directory and assign them to a variable',
-            });
-            repl.addMethod('make', (_, service, runtimeValues) => {
-                return this.app.container.make(service, runtimeValues);
-            }, {
-                description: 'Make class instance using "container.make" method',
-            });
-            repl.addMethod('loadApp', () => {
-                return resolveBindingForRepl(this.app, repl, 'app');
-            }, {
-                description: 'Load "app" service in the REPL context',
-            });
-            repl.addMethod('loadEncryption', () => {
-                return resolveBindingForRepl(this.app, repl, 'encryption');
-            }, {
-                description: 'Load "encryption" service in the REPL context',
-            });
-            repl.addMethod('loadHash', () => {
-                return resolveBindingForRepl(this.app, repl, 'hash');
-            }, {
-                description: 'Load "hash" service in the REPL context',
-            });
-            repl.addMethod('loadRouter', () => {
-                return resolveBindingForRepl(this.app, repl, 'router');
-            }, {
-                description: 'Load "router" service in the REPL context',
-            });
-            repl.addMethod('loadConfig', () => {
-                return resolveBindingForRepl(this.app, repl, 'config');
-            }, {
-                description: 'Load "config" service in the REPL context',
-            });
-            repl.addMethod('loadTestUtils', () => {
-                return resolveBindingForRepl(this.app, repl, 'testUtils');
-            }, {
-                description: 'Load "testUtils" service in the REPL context',
-            });
-            repl.addMethod('loadHelpers', async () => {
-                const { default: isModule } = await import('../src/helpers/is.js');
-                const { default: stringModule } = await import('../src/helpers/string.js');
-                const helpers = await import('../src/helpers/main.js');
-                repl.server.context.helpers = {
-                    string: stringModule,
-                    is: isModule,
-                    ...helpers,
-                };
-                repl.notify(`Loaded "helpers" module. You can access it using the "${repl.colors.underline('helpers')}" variable`);
-            }, {
-                description: 'Load "helpers" module in the REPL context',
-            });
-        });
-    }
+	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`);
 }
+var ReplServiceProvider = class {
+	constructor(app) {
+		this.app = app;
+	}
+	register() {
+		this.app.container.singleton(repl_exports.Repl, async () => {
+			return new repl_exports.Repl({ historyFilePath: join(homedir(), ".adonisjs_v6_repl_history") });
+		});
+		this.app.container.alias("repl", repl_exports.Repl);
+	}
+	async boot() {
+		this.app.container.resolving("repl", (repl) => {
+			repl.addMethod("importDefault", (_, modulePath) => {
+				return this.app.importDefault(modulePath);
+			}, { description: "Returns the default export for a module" });
+			repl.addMethod("importAll", (_, dirPath) => {
+				return fsImportAll(this.app.makeURL(dirPath), { ignoreMissingRoot: false });
+			}, { description: "Import all files from a directory and assign them to a variable" });
+			repl.addMethod("make", (_, service, runtimeValues) => {
+				return this.app.container.make(service, runtimeValues);
+			}, { description: "Make class instance using \"container.make\" method" });
+			repl.addMethod("loadApp", () => {
+				return resolveBindingForRepl(this.app, repl, "app");
+			}, { description: "Load \"app\" service in the REPL context" });
+			repl.addMethod("loadEncryption", () => {
+				return resolveBindingForRepl(this.app, repl, "encryption");
+			}, { description: "Load \"encryption\" service in the REPL context" });
+			repl.addMethod("loadHash", () => {
+				return resolveBindingForRepl(this.app, repl, "hash");
+			}, { description: "Load \"hash\" service in the REPL context" });
+			repl.addMethod("loadRouter", () => {
+				return resolveBindingForRepl(this.app, repl, "router");
+			}, { description: "Load \"router\" service in the REPL context" });
+			repl.addMethod("loadConfig", () => {
+				return resolveBindingForRepl(this.app, repl, "config");
+			}, { description: "Load \"config\" service in the REPL context" });
+			repl.addMethod("loadTestUtils", () => {
+				return resolveBindingForRepl(this.app, repl, "testUtils");
+			}, { description: "Load \"testUtils\" service in the REPL context" });
+			repl.addMethod("loadHelpers", async () => {
+				const { default: isModule } = await import("../src/helpers/is.js");
+				const { default: stringModule } = await import("../src/helpers/string.js");
+				const helpers = await import("../src/helpers/main.js");
+				repl.server.context.helpers = {
+					string: stringModule,
+					is: isModule,
+					...helpers
+				};
+				repl.notify(`Loaded "helpers" module. You can access it using the "${repl.colors.underline("helpers")}" variable`);
+			}, { description: "Load \"helpers\" module in the REPL context" });
+		});
+	}
+};
+export { ReplServiceProvider as default };

package/build/providers/vinejs_provider.d.ts

@@ -13,7 +13,7 @@ declare module '@vinejs/vine' {
  * Extend HTTP request class
  */
 declare module '@adonisjs/core/http' {
-    interface Request extends RequestValidator {
+    interface HttpRequest extends RequestValidator {
     }
 }
 /**

package/build/providers/vinejs_provider.js

@@ -1,66 +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 { Vine } from '@vinejs/vine';
-import { Request, RequestValidator } from "../modules/http/main.js";
-import { VineMultipartFile } from "../src/vine.js";
-/**
- * The VineJS service provider integrates VineJS validation
- * library with AdonisJS application environment
- *
- * This provider sets up:
- * - File validation rule for multipart file uploads
- * - Request validation macro for easy validation in HTTP contexts
- * - Extension of VineJS with AdonisJS-specific validation features
- *
- * @example
- * const provider = new VineJSServiceProvider(app)
- * provider.boot()
- * // Now Request has validateUsing method
- */
-export default class VineJSServiceProvider {
-    app;
-    /**
-     * VineJS service provider constructor
-     *
-     * Sets the usingVineJS flag to true to indicate VineJS is being used.
-     *
-     * @param app - The application service instance
-     */
-    constructor(app) {
-        this.app = app;
-        this.app.usingVineJS = true;
-    }
-    /**
-     * Boot the VineJS service provider
-     *
-     * Extends VineJS with file validation macro and adds validateUsing
-     * method to the Request class for easy validation in HTTP contexts.
-     *
-     * @example
-     * provider.boot()
-     * // Now vine.file() and request.validateUsing() are available
-     */
-    boot() {
-        const experimentalFlags = this.app.experimentalFlags;
-        /**
-         * The file method is used to validate a field to be a valid
-         * multipart file.
-         */
-        Vine.macro('file', function (options) {
-            return new VineMultipartFile(options);
-        });
-        /**
-         * The validate method can be used to validate the request
-         * data for the current request using VineJS validators
-         */
-        Request.macro('validateUsing', function (...args) {
-            return new RequestValidator(this.ctx, experimentalFlags).validateUsing(...args);
-        });
-    }
-}
+import "../chunk-MjwdjG2f.js";
+import { n as RequestValidator, t as main_exports } from "../main-CFmDHDls.js";
+import { t as VineMultipartFile } from "../vine-Bt4ymkM0.js";
+import { Vine } from "@vinejs/vine";
+var VineJSServiceProvider = class {
+	constructor(app) {
+		this.app = app;
+		this.app.usingVineJS = true;
+	}
+	boot() {
+		const experimentalFlags = this.app.experimentalFlags;
+		Vine.macro("file", function(options) {
+			return new VineMultipartFile(options);
+		});
+		main_exports.HttpRequest.macro("validateUsing", function(...args) {
+			return new RequestValidator(this.ctx, experimentalFlags).validateUsing(...args);
+		});
+	}
+};
+export { VineJSServiceProvider as default };

package/build/services/ace.js

@@ -1,21 +1,6 @@
-/*
- * @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 { t as app } from "../app-B6oge7b3.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');
+	ace = await app.container.make("ace");
 });
 export { ace as default };