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

package/build/modules/encryption.d.ts

@@ -1 +1,18 @@
+/**
+ * Encryption module re-exports all functionality from @adonisjs/encryption.
+ * This includes the Encryption class and related utilities for encrypting and
+ * decrypting data using various algorithms and key management strategies.
+ *
+ * @example
+ * // Import the Encryption class
+ * import { Encryption } from '@adonisjs/core/encryption'
+ *
+ * const encryption = new Encryption({ secret: 'your-secret-key' })
+ * const encrypted = encryption.encrypt('sensitive data')
+ * const decrypted = encryption.decrypt(encrypted)
+ *
+ * @example
+ * // Import encryption types and utilities
+ * import type { EncryptionConfig, DriverContract } from '@adonisjs/core/encryption'
+ */
 export * from '@adonisjs/encryption';

package/build/modules/encryption.js

@@ -6,4 +6,21 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+/**
+ * Encryption module re-exports all functionality from @adonisjs/encryption.
+ * This includes the Encryption class and related utilities for encrypting and
+ * decrypting data using various algorithms and key management strategies.
+ *
+ * @example
+ * // Import the Encryption class
+ * import { Encryption } from '@adonisjs/core/encryption'
+ *
+ * const encryption = new Encryption({ secret: 'your-secret-key' })
+ * const encrypted = encryption.encrypt('sensitive data')
+ * const decrypted = encryption.decrypt(encrypted)
+ *
+ * @example
+ * // Import encryption types and utilities
+ * import type { EncryptionConfig, DriverContract } from '@adonisjs/core/encryption'
+ */
 export * from '@adonisjs/encryption';

package/build/modules/env/main.d.ts

@@ -1 +1,20 @@
+/**
+ * Environment module re-exports all functionality from @adonisjs/env.
+ * This includes the Env class, validation schemas, and utilities for managing
+ * environment variables with type safety and validation.
+ *
+ * @example
+ * // Import the Env class and validation
+ * import { Env } from '@adonisjs/core/env'
+ *
+ * const env = await Env.create(new URL('../', import.meta.url), {
+ *   NODE_ENV: Env.schema.enum(['development', 'production', 'test'] as const),
+ *   PORT: Env.schema.number(),
+ *   HOST: Env.schema.string({ format: 'host' })
+ * })
+ *
+ * @example
+ * // Import environment types and utilities
+ * import type { EnvParser, EnvEditor } from '@adonisjs/core/env'
+ */
 export * from '@adonisjs/env';

package/build/modules/env/main.js

@@ -6,4 +6,23 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+/**
+ * Environment module re-exports all functionality from @adonisjs/env.
+ * This includes the Env class, validation schemas, and utilities for managing
+ * environment variables with type safety and validation.
+ *
+ * @example
+ * // Import the Env class and validation
+ * import { Env } from '@adonisjs/core/env'
+ *
+ * const env = await Env.create(new URL('../', import.meta.url), {
+ *   NODE_ENV: Env.schema.enum(['development', 'production', 'test'] as const),
+ *   PORT: Env.schema.number(),
+ *   HOST: Env.schema.string({ format: 'host' })
+ * })
+ *
+ * @example
+ * // Import environment types and utilities
+ * import type { EnvParser, EnvEditor } from '@adonisjs/core/env'
+ */
 export * from '@adonisjs/env';

package/build/modules/hash/drivers/bcrypt.d.ts

@@ -1 +1,12 @@
+/**
+ * Bcrypt hash driver re-exports from @adonisjs/hash.
+ * Provides bcrypt password hashing functionality with configurable rounds.
+ *
+ * @example
+ * import { Bcrypt } from '@adonisjs/core/hash/drivers/bcrypt'
+ *
+ * const bcrypt = new Bcrypt({ rounds: 12 })
+ * const hashed = await bcrypt.make('password')
+ * const isValid = await bcrypt.verify(hashed, 'password')
+ */
 export * from '@adonisjs/hash/drivers/bcrypt';

package/build/modules/hash/drivers/bcrypt.js

@@ -6,4 +6,15 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+/**
+ * Bcrypt hash driver re-exports from @adonisjs/hash.
+ * Provides bcrypt password hashing functionality with configurable rounds.
+ *
+ * @example
+ * import { Bcrypt } from '@adonisjs/core/hash/drivers/bcrypt'
+ *
+ * const bcrypt = new Bcrypt({ rounds: 12 })
+ * const hashed = await bcrypt.make('password')
+ * const isValid = await bcrypt.verify(hashed, 'password')
+ */
 export * from '@adonisjs/hash/drivers/bcrypt';

package/build/modules/hash/main.d.ts

@@ -1,2 +1,20 @@
+/**
+ * Hash module provides password hashing functionality with multiple driver support.
+ * Re-exports all functionality from @adonisjs/hash along with configuration utilities.
+ *
+ * @example
+ * // Import the Hash manager and drivers
+ * import { HashManager, Hash } from '@adonisjs/core/hash'
+ *
+ * const manager = new HashManager(config)
+ * const hasher = manager.use('scrypt')
+ * const hashed = await hasher.make('password')
+ * const verified = await hasher.verify(hashed, 'password')
+ *
+ * @example
+ * // Import configuration and driver types
+ * import { defineConfig, drivers } from '@adonisjs/core/hash'
+ * import type { HashConfig, ScryptConfig } from '@adonisjs/core/types/hash'
+ */
 export * from '@adonisjs/hash';
 export { defineConfig, drivers } from './define_config.ts';

package/build/modules/hash/main.js

@@ -6,5 +6,23 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+/**
+ * Hash module provides password hashing functionality with multiple driver support.
+ * Re-exports all functionality from @adonisjs/hash along with configuration utilities.
+ *
+ * @example
+ * // Import the Hash manager and drivers
+ * import { HashManager, Hash } from '@adonisjs/core/hash'
+ *
+ * const manager = new HashManager(config)
+ * const hasher = manager.use('scrypt')
+ * const hashed = await hasher.make('password')
+ * const verified = await hasher.verify(hashed, 'password')
+ *
+ * @example
+ * // Import configuration and driver types
+ * import { defineConfig, drivers } from '@adonisjs/core/hash'
+ * import type { HashConfig, ScryptConfig } from '@adonisjs/core/types/hash'
+ */
 export * from '@adonisjs/hash';
 export { defineConfig, drivers } from "./define_config.js";

package/build/modules/http/url_builder_client.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/http-server/client/url_builder';

package/build/modules/http/url_builder_client.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export * from '@adonisjs/http-server/client/url_builder';

package/build/providers/app_provider.d.ts

@@ -174,32 +174,20 @@ export default class AppServiceProvider {
      */
     protected registerDumper(): void;
     /**
-     * Generates the types needed by the URL builder and writes
-     * them to the ".adonisjs/server/routes.d.ts" file
+     * Generates TypeScript type definitions and JSON representation of routes
      *
-     * This method scans registered routes and generates TypeScript
-     * types for type-safe URL generation in development.
+     * Creates route type definitions for better IDE support and a JSON file
+     * containing all registered routes. This is used in development mode for
+     * tooling integration and type-safety.
      *
-     * @param router - The router instance to generate types from
+     * @param router - The router instance containing registered routes
      *
      * @example
-     * await generateRoutesTypes(router)
-     * // Creates .adonisjs/server/routes.d.ts with route types
-     */
-    protected generateRoutesTypes(router: Router): Promise<void>;
-    /**
-     * Generates the routes JSON needed by the client integration
-     *
-     * Exports all registered routes as JSON for client-side
-     * applications that need route information.
-     *
-     * @param router - The router instance to export routes from
-     *
-     * @example
-     * await generateRoutesJSONFile(router)
-     * // Creates .adonisjs/client/routes.json
+     * const router = await container.make('router')
+     * await this.emitRoutes(router)
+     * // Generates .adonisjs/server/routes.d.ts and routes.json
      */
-    protected generateRoutesJSONFile(router: Router): Promise<void>;
+    protected emitRoutes(router: Router): Promise<void>;
     /**
      * Registers bindings
      *

package/build/providers/app_provider.js

@@ -225,7 +225,7 @@ export default class AppServiceProvider {
      * await middleware.handle(ctx, next)
      */
     registerBodyParserMiddleware() {
-        this.app.container.bind(BodyParserMiddleware, () => {
+        this.app.container.singleton(BodyParserMiddleware, () => {
             const config = this.app.config.get('bodyparser');
             return new BodyParserMiddleware(config, this.app.experimentalFlags);
         });
@@ -256,50 +256,47 @@ export default class AppServiceProvider {
         this.app.container.alias('dumper', Dumper);
     }
     /**
-     * Generates the types needed by the URL builder and writes
-     * them to the ".adonisjs/server/routes.d.ts" file
+     * Generates TypeScript type definitions and JSON representation of routes
      *
-     * This method scans registered routes and generates TypeScript
-     * types for type-safe URL generation in development.
+     * Creates route type definitions for better IDE support and a JSON file
+     * containing all registered routes. This is used in development mode for
+     * tooling integration and type-safety.
      *
-     * @param router - The router instance to generate types from
+     * @param router - The router instance containing registered routes
      *
      * @example
-     * await generateRoutesTypes(router)
-     * // Creates .adonisjs/server/routes.d.ts with route types
-     */
-    async generateRoutesTypes(router) {
-        const types = router.generateTypes(4);
-        const outputPath = this.app.generatedServerPath('routes.d.ts');
-        await mkdir(dirname(outputPath), { recursive: true });
-        await writeFile(outputPath, [
-            `import '@adonisjs/core/types/http'`,
-            '',
-            `declare module '@adonisjs/core/types/http' {`,
-            '  type ScannedRoutes = {',
-            types,
-            '  }',
-            'export interface RoutesList extends ScannedRoutes {}',
-            '}',
-        ].join('\n'));
-    }
-    /**
-     * Generates the routes JSON needed by the client integration
-     *
-     * Exports all registered routes as JSON for client-side
-     * applications that need route information.
-     *
-     * @param router - The router instance to export routes from
-     *
-     * @example
-     * await generateRoutesJSONFile(router)
-     * // Creates .adonisjs/client/routes.json
+     * const router = await container.make('router')
+     * await this.emitRoutes(router)
+     * // Generates .adonisjs/server/routes.d.ts and routes.json
      */
-    async generateRoutesJSONFile(router) {
-        const routes = router.toJSON();
-        const outputPath = this.app.makePath('.adonisjs/client/routes.json');
-        await mkdir(dirname(outputPath), { recursive: true });
-        await writeFile(outputPath, JSON.stringify(routes, null, 2));
+    async emitRoutes(router) {
+        try {
+            const { routes, imports, types } = router.generateTypes(2);
+            const routesTypesPath = this.app.generatedServerPath('routes.d.ts');
+            const routesJsonPath = this.app.generatedServerPath('routes.json');
+            await mkdir(dirname(routesTypesPath), { recursive: true });
+            await Promise.all([
+                writeFile(routesTypesPath, [
+                    `import '@adonisjs/core/types/http'`,
+                    ...imports,
+                    '',
+                    ...types,
+                    '',
+                    'export type ScannedRoutes = {',
+                    routes,
+                    '}',
+                    `declare module '@adonisjs/core/types/http' {`,
+                    '  export interface RoutesList extends ScannedRoutes {}',
+                    '}',
+                ].join('\n')),
+                writeFile(routesJsonPath, JSON.stringify(router.toJSON())),
+            ]);
+            this.app.notify({ isAdonisJS: true, routesFileLocation: routesJsonPath });
+        }
+        catch (error) {
+            console.error("Unable to generate routes types file due to the following error. This won't impact the dev-server");
+            console.error(error);
+        }
     }
     /**
      * Registers bindings
@@ -337,8 +334,8 @@ export default class AppServiceProvider {
      */
     async boot() {
         BaseEvent.useEmitter(await this.app.container.make('emitter'));
-        HttpContext.instanceProperty('serialize', function (...args) {
-            return serialize(...args);
+        HttpContext.instanceProperty('serialize', function (value, container) {
+            return serialize(value, container ?? this.containerResolver);
         });
     }
     /**
@@ -355,8 +352,7 @@ export default class AppServiceProvider {
         if (!this.app.inProduction) {
             const router = await this.app.container.make('router');
             if (router.commited) {
-                await this.generateRoutesJSONFile(router);
-                await this.generateRoutesTypes(router);
+                await this.emitRoutes(router);
             }
         }
     }

package/build/providers/edge_provider.js

@@ -8,7 +8,7 @@
  */
 import edge from 'edge.js';
 import { pluginEdgeDumper } from "../modules/dumper/plugins/edge.js";
-import { BriskRoute, HttpContext } from "../modules/http/main.js";
+import { BriskRoute, HttpContext, Qs } from "../modules/http/main.js";
 /**
  * The Edge service provider configures Edge to work within
  * an AdonisJS application environment
@@ -53,6 +53,7 @@ export default class EdgeServiceProvider {
      */
     async boot() {
         const app = this.app;
+        const qs = new 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) {
@@ -61,6 +62,25 @@ export default class EdgeServiceProvider {
         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;
+            }, {});
+        }
         /**
          * Mount the default disk
          */
@@ -71,6 +91,7 @@ export default class EdgeServiceProvider {
         edge.configure({ cache: app.inProduction });
         /**
          * Define Edge global helpers
+         * @deprecated
          */
         edge.global('route', function (...args) {
             return router.makeUrl(...args);
@@ -80,6 +101,46 @@ export default class EdgeServiceProvider {
         });
         edge.global('app', app);
         edge.global('config', edgeConfigResolver);
+        edge.global('routes', function () {
+            return clientRoutes();
+        });
+        edge.global('routesJSON', function () {
+            return JSON.stringify(clientRoutes());
+        });
+        /**
+         * Route helpers
+         */
+        edge.global('urlFor', function (...args) {
+            return router.urlBuilder.urlFor(...args);
+        });
+        edge.global('signedUrlFor', function (...args) {
+            return router.urlBuilder.signedUrlFor(...args);
+        });
+        /**
+         * Sharing qs parser with templates
+         */
+        edge.global('qs', qs);
+        edge.global('formAttributes', function (route, method, params, options) {
+            /**
+             * Normalize method and keep a reference to the original method
+             */
+            options = options ?? {};
+            method = method.toUpperCase();
+            const original = method;
+            /**
+             * If method if not GET and POST, then use the querystring _method
+             * to and force update the method to "POST"
+             */
+            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,
+            };
+        });
         /**
          * Creating a isolated instance of edge renderer
          */

package/build/src/assembler_hooks/index_entities.js

@@ -45,12 +45,18 @@ 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);
+    const transformers = Object.assign({
+        enabled: false,
+        source: 'app/transformers',
+        importAlias: '#transformers',
+        withSharedProps: false,
+    }, entities.transformers);
     return {
         run(_, indexGenerator) {
             if (events.enabled) {
                 indexGenerator.add('events', {
                     source: events.source,
+                    disableLazyImports: true,
                     glob: events.glob,
                     as: 'barrelFile',
                     exportName: 'events',
@@ -95,7 +101,7 @@ export function indexEntities(entities = {}) {
                             },
                             transformValue: helpers.toImportPath,
                         });
-                        outputTransformerDataObjects(transformersList, buffer);
+                        outputTransformerDataObjects(transformersList, buffer, transformers.withSharedProps);
                     },
                     importAlias: transformers.importAlias,
                     output: '.adonisjs/client/data.d.ts',

package/build/src/cli_formatters/routes_list.js

@@ -64,7 +64,9 @@ export class RoutesListFormatter {
         this.#router.commit();
     }
     /**
-     * Test if a route clears the applied filters
+     * Test if a route clears the applied filters based on middleware, name, pattern, and handler.
+     *
+     * @param route - The serialized route to test against filters
      */
     #isAllowedByFilters(route) {
         let allowRoute = true;
@@ -124,7 +126,10 @@ export class RoutesListFormatter {
         return false;
     }
     /**
-     * Serializes routes JSON to an object that can be used for pretty printing
+     * Serializes routes JSON to an object that can be used for pretty printing.
+     * Converts RouteJSON into a format suitable for display and filtering.
+     *
+     * @param route - The route JSON object to serialize
      */
     async #serializeRoute(route) {
         let methods = route.methods;
@@ -143,13 +148,17 @@ export class RoutesListFormatter {
         };
     }
     /**
-     * Formats the route method for the ansi list and table
+     * Formats the route method for the ansi list and table with dim styling.
+     *
+     * @param method - The HTTP method to format (GET, POST, etc.)
      */
     #formatRouteMethod(method) {
         return this.#colors.dim(method);
     }
     /**
-     * Formats route pattern for the ansi list and table
+     * Formats route pattern for the ansi list and table with colored parameters and route name.
+     *
+     * @param route - The serialized route containing pattern and name information
      */
     #formatRoutePattern(route) {
         const pattern = this.#router
@@ -170,7 +179,9 @@ export class RoutesListFormatter {
         return `${pattern === '/' ? pattern : `/${pattern}`}${route.name ? ` ${this.#colors.dim(`(${route.name})`)}` : ''} `;
     }
     /**
-     * Formats controller name for the ansi list and table
+     * Formats controller name for the ansi list and table with cyan coloring.
+     *
+     * @param route - The serialized route containing handler information
      */
     #formatControllerName(route) {
         return route.handler.type === 'controller'
@@ -178,7 +189,9 @@ export class RoutesListFormatter {
             : '';
     }
     /**
-     * Formats action name for the ansi list and table
+     * Formats action name for the ansi list and table with cyan coloring and arguments.
+     *
+     * @param route - The serialized route containing handler information
      */
     #formatAction(route) {
         if (route.handler.type === 'controller') {
@@ -191,7 +204,10 @@ export class RoutesListFormatter {
         return functionName;
     }
     /**
-     * Formats route middleware for the ansi list and table
+     * Formats route middleware for the ansi list and table with optional compacting.
+     *
+     * @param route - The serialized route containing middleware information
+     * @param mode - Display mode: 'normal' shows all middleware, 'compact' truncates long lists
      */
     #formatMiddleware(route, mode = 'normal') {
         if (mode === 'compact' && route.middleware.length > 3) {

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

@@ -0,0 +1,20 @@
+/**
+ * HTTP helper utilities re-exported from @adonisjs/http-server. This module
+ * provides a convenient entry point for accessing all HTTP-related utilities
+ * including route helpers, middleware utilities, and request/response helpers.
+ *
+ * @example
+ * // Import specific HTTP helpers
+ * import { middlewareInfo, routeInfo } from '@adonisjs/core/helpers'
+ *
+ * const middleware = middlewareInfo('cors', CorsMiddleware)
+ * const route = routeInfo('users.show', '/users/:id')
+ *
+ * @example
+ * // Access all HTTP helpers
+ * import * as httpHelpers from '@adonisjs/core/helpers/http'
+ *
+ * // Use any helper from the http-server package
+ * const routeData = httpHelpers.routeInfo('api.posts', '/api/posts')
+ */
+export * from '@adonisjs/http-server/helpers';

package/build/src/helpers/http.js

@@ -0,0 +1,28 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * HTTP helper utilities re-exported from @adonisjs/http-server. This module
+ * provides a convenient entry point for accessing all HTTP-related utilities
+ * including route helpers, middleware utilities, and request/response helpers.
+ *
+ * @example
+ * // Import specific HTTP helpers
+ * import { middlewareInfo, routeInfo } from '@adonisjs/core/helpers'
+ *
+ * const middleware = middlewareInfo('cors', CorsMiddleware)
+ * const route = routeInfo('users.show', '/users/:id')
+ *
+ * @example
+ * // Access all HTTP helpers
+ * import * as httpHelpers from '@adonisjs/core/helpers/http'
+ *
+ * // Use any helper from the http-server package
+ * const routeData = httpHelpers.routeInfo('api.posts', '/api/posts')
+ */
+export * from '@adonisjs/http-server/helpers';

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

@@ -37,12 +37,8 @@ export { default as base64 } from '@poppinss/utils/base64';
  * Core utilities including function composition, secret management,
  * safe equality comparison, and message building.
  */
-export { compose, Secret, safeEqual, MessageBuilder } from '@poppinss/utils';
+export { compose, Secret, safeEqual, MessageBuilder, defineStaticProperty } from '@poppinss/utils';
 /**
  * Verification token utility for creating secure tokens.
  */
 export { VerificationToken } from './verification_token.ts';
-/**
- * HTTP server helper functions for middleware and route information.
- */
-export { middlewareInfo, routeInfo } from '@adonisjs/http-server/helpers';

package/build/src/helpers/main.js

@@ -45,12 +45,8 @@ export { default as base64 } from '@poppinss/utils/base64';
  * Core utilities including function composition, secret management,
  * safe equality comparison, and message building.
  */
-export { compose, Secret, safeEqual, MessageBuilder } from '@poppinss/utils';
+export { compose, Secret, safeEqual, MessageBuilder, defineStaticProperty } from '@poppinss/utils';
 /**
  * Verification token utility for creating secure tokens.
  */
 export { VerificationToken } from "./verification_token.js";
-/**
- * HTTP server helper functions for middleware and route information.
- */
-export { middlewareInfo, routeInfo } from '@adonisjs/http-server/helpers';

package/build/src/helpers/string.js

@@ -43,9 +43,21 @@ const stringHelpers = {
     prettyHrTime(time, options) {
         return prettyHrTime(time, options);
     },
+    /**
+     * Check if a string is empty or contains only whitespace characters.
+     *
+     * @param value - The string to check for emptiness
+     */
     isEmpty(value) {
         return value.trim().length === 0;
     },
+    /**
+     * Escape HTML entities to prevent XSS attacks and display HTML safely.
+     *
+     * @param value - The string containing HTML to escape
+     * @param options - Optional configuration for escaping behavior
+     * @param options.encodeSymbols - Whether to also encode Unicode symbols as HTML entities
+     */
     escapeHTML(value, options) {
         value = he.escape(value);
         if (options && options.encodeSymbols) {
@@ -53,6 +65,12 @@ const stringHelpers = {
         }
         return value;
     },
+    /**
+     * Encode Unicode symbols and special characters as HTML entities.
+     *
+     * @param value - The string containing symbols to encode
+     * @param options - Encoding options from the 'he' library
+     */
     encodeSymbols(value, options) {
         return he.encode(value, options);
     },