@adonisjs/core 6.13.0 → 6.14.0

package/build/commands/generate_key.js

@@ -33,7 +33,7 @@ export default class GenerateKey extends BaseCommand {
         const secureKey = string.random(32);
         if (writeToFile) {
             const editor = await EnvEditor.create(this.app.appRoot);
-            editor.add('APP_KEY', secureKey);
+            editor.add('APP_KEY', secureKey, true);
             await editor.save();
             this.logger.action('add APP_KEY to .env').succeeded();
         }

package/build/index.js

@@ -30,6 +30,10 @@ export const errors = {
  * Youch terminal
  */
 export async function prettyPrintError(error) {
+    if (error && typeof error === 'object' && error.code === 'E_DUMP_DIE_EXCEPTION') {
+        console.error(error);
+        return;
+    }
     // @ts-expect-error
     const { default: youchTerminal } = await import('youch-terminal');
     const { default: Youch } = await import('youch');

package/build/modules/dumper/define_config.d.ts

@@ -0,0 +1,13 @@
+import { ConsoleDumpConfig } from '@poppinss/dumper/console/types';
+import { HTMLDumpConfig } from '@poppinss/dumper/html/types';
+/**
+ * Define config for the dumper service exported by
+ * the "@adonisjs/core/services/dumper" module
+ */
+export declare function defineConfig(dumperConfig: Partial<{
+    html: HTMLDumpConfig;
+    console: ConsoleDumpConfig;
+}>): Partial<{
+    html: HTMLDumpConfig;
+    console: ConsoleDumpConfig;
+}>;

package/build/modules/dumper/define_config.js

@@ -0,0 +1,15 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Define config for the dumper service exported by
+ * the "@adonisjs/core/services/dumper" module
+ */
+export function defineConfig(dumperConfig) {
+    return dumperConfig;
+}

package/build/modules/dumper/dumper.d.ts

@@ -0,0 +1,75 @@
+import type { HTMLDumpConfig } from '@poppinss/dumper/html/types';
+import type { ConsoleDumpConfig } from '@poppinss/dumper/console/types';
+import type { Application } from '../app.js';
+/**
+ * Dumper exposes the API to dump or die/dump values in your
+ * AdonisJS application. An singleton instance of the Dumper
+ * is shared as a service and may use it follows.
+ *
+ * ```ts
+ * const dumper = container.make('dumper')
+ *
+ * dumper.configureHtmlOutput({
+ *   // parser + html formatter config
+ * })
+ *
+ * dumper.configureAnsiOutput({
+ *   // parser + console formatter config
+ * })
+ *
+ * const html = dumper.dumpToHtml(value)
+ * const ansi = dumper.dumpToAnsi(value)
+ *
+ * // Returns style and script tags that must be
+ * // injeted to the head of the HTML document
+ *
+ * const head = dumper.getHeadElements()
+ * ```
+ */
+export declare class Dumper {
+    #private;
+    constructor(app: Application<any>);
+    /**
+     * Configure the HTML formatter output
+     */
+    configureHtmlOutput(config: HTMLDumpConfig): this;
+    /**
+     * Configure the ANSI formatter output
+     */
+    configureAnsiOutput(config: ConsoleDumpConfig): this;
+    /**
+     * Returns the style and the script elements for the
+     * HTML document
+     */
+    getHeadElements(cspNonce?: string): string;
+    /**
+     * Dump value to HTML ouput
+     */
+    dumpToHtml(value: unknown, options?: {
+        cspNonce?: string;
+        title?: string;
+        source?: {
+            location: string;
+            line: number;
+        };
+    }): string;
+    /**
+     * Dump value to ANSI output
+     */
+    dumpToAnsi(value: unknown, options?: {
+        title?: string;
+        source?: {
+            location: string;
+            line: number;
+        };
+    }): string;
+    /**
+     * Dump values and die. The formatter will be picked
+     * based upon where your app is running.
+     *
+     * - During an HTTP request, the HTML output will be
+     *   sent to the server.
+     * - Otherwise the value will be logged in the console
+     */
+    dd(value: unknown, traceSourceIndex?: number): void;
+}

package/build/modules/dumper/dumper.js

@@ -0,0 +1,186 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import useColors from '@poppinss/colors';
+import { dump as consoleDump } from '@poppinss/dumper/console';
+import { createScript, createStyleSheet, dump } from '@poppinss/dumper/html';
+import { E_DUMP_DIE_EXCEPTION } from './errors.js';
+const colors = useColors.ansi();
+const DUMP_TITLE_STYLES = `
+.adonisjs-dump-header {
+  font-family: JetBrains Mono, monaspace argon, Menlo, Monaco, Consolas, monospace;
+  background: #ff1639;
+  border-radius: 4px;
+  color: #fff;
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+  padding: 0.4rem 1.2rem;
+  font-size: 1em;
+  display: flex;
+  justify-content: space-between;
+}
+.adonisjs-dump-header .adonisjs-dump-header-title {
+  font-weight: bold;
+  text-transform: uppercase;
+}
+.adonisjs-dump-header .adonisjs-dump-header-source {
+  font-weight: bold;
+  color: inherit;
+  text-decoration: underline;
+}
+.dumper-dump pre {
+  border-radius: 4px;
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}`;
+const IDE = process.env.ADONIS_IDE ?? process.env.EDITOR ?? '';
+/**
+ * Dumper exposes the API to dump or die/dump values in your
+ * AdonisJS application. An singleton instance of the Dumper
+ * is shared as a service and may use it follows.
+ *
+ * ```ts
+ * const dumper = container.make('dumper')
+ *
+ * dumper.configureHtmlOutput({
+ *   // parser + html formatter config
+ * })
+ *
+ * dumper.configureAnsiOutput({
+ *   // parser + console formatter config
+ * })
+ *
+ * const html = dumper.dumpToHtml(value)
+ * const ansi = dumper.dumpToAnsi(value)
+ *
+ * // Returns style and script tags that must be
+ * // injeted to the head of the HTML document
+ *
+ * const head = dumper.getHeadElements()
+ * ```
+ */
+export class Dumper {
+    #app;
+    /**
+     * Configuration for the HTML formatter
+     */
+    #htmlConfig = {};
+    /**
+     * Configuration for the Console formatter
+     */
+    #consoleConfig = {
+        collapse: ['DateTime', 'Date'],
+    };
+    /**
+     * A collections of known editors to create URLs to open
+     * them
+     */
+    #editors = {
+        textmate: 'txmt://open?url=file://%f&line=%l',
+        macvim: 'mvim://open?url=file://%f&line=%l',
+        emacs: 'emacs://open?url=file://%f&line=%l',
+        sublime: 'subl://open?url=file://%f&line=%l',
+        phpstorm: 'phpstorm://open?file=%f&line=%l',
+        atom: 'atom://core/open/file?filename=%f&line=%l',
+        vscode: 'vscode://file/%f:%l',
+    };
+    constructor(app) {
+        this.#app = app;
+    }
+    /**
+     * Returns the link to open the file using dd inside one
+     * of the known code editors
+     */
+    #getEditorLink(source) {
+        const editorURL = this.#editors[IDE] || IDE;
+        if (!editorURL || !source) {
+            return;
+        }
+        return {
+            href: editorURL.replace('%f', source.location).replace('%l', String(source.line)),
+            text: `${this.#app.relativePath(source.location)}:${source.line}`,
+        };
+    }
+    /**
+     * Configure the HTML formatter output
+     */
+    configureHtmlOutput(config) {
+        this.#htmlConfig = config;
+        return this;
+    }
+    /**
+     * Configure the ANSI formatter output
+     */
+    configureAnsiOutput(config) {
+        this.#consoleConfig = config;
+        return this;
+    }
+    /**
+     * Returns the style and the script elements for the
+     * HTML document
+     */
+    getHeadElements(cspNonce) {
+        return (`<style id="dumper-styles">` +
+            createStyleSheet() +
+            DUMP_TITLE_STYLES +
+            '</style>' +
+            `<script id="dumper-script"${cspNonce ? ` nonce="${cspNonce}"` : ''}>` +
+            createScript() +
+            '</script>');
+    }
+    /**
+     * Dump value to HTML ouput
+     */
+    dumpToHtml(value, options = {}) {
+        const link = this.#getEditorLink(options.source) ?? null;
+        const title = options.title || 'DUMP';
+        return ('<div class="adonisjs-dump-header">' +
+            `<span class="adonisjs-dump-header-title">${title}</span>` +
+            (link ? `<a href="${link.href}" class="adonisjs-dump-header-source">${link.text}</a>` : '') +
+            '</div>' +
+            dump(value, { cspNonce: options.cspNonce, ...this.#htmlConfig }));
+    }
+    /**
+     * Dump value to ANSI output
+     */
+    dumpToAnsi(value, options = {}) {
+        const columns = process.stdout.columns;
+        /**
+         * Link to the source file
+         */
+        const link = `${this.#getEditorLink(options.source)?.text ?? ''} `;
+        /**
+         * Dump title
+         */
+        const title = ` ${options.title || 'DUMP'}`;
+        /**
+         * Whitespace between the title and the link to align them
+         * on each side of x axis
+         */
+        const whiteSpaceLength = columns ? columns - link.length - title.length - 4 : 2;
+        const whiteSpace = new Array(whiteSpaceLength <= 0 ? 2 : whiteSpaceLength).join(' ');
+        /**
+         * Styled heading with background color and bold text
+         */
+        const heading = colors.bgRed().bold(`${title}${whiteSpace}${link}`);
+        return `${heading}\n${consoleDump(value, this.#consoleConfig)}`;
+    }
+    /**
+     * Dump values and die. The formatter will be picked
+     * based upon where your app is running.
+     *
+     * - During an HTTP request, the HTML output will be
+     *   sent to the server.
+     * - Otherwise the value will be logged in the console
+     */
+    dd(value, traceSourceIndex = 1) {
+        const error = new E_DUMP_DIE_EXCEPTION(value, this);
+        error.setTraceSourceIndex(traceSourceIndex);
+        throw error;
+    }
+}

package/build/modules/dumper/errors.d.ts

@@ -0,0 +1,43 @@
+import { inspect } from 'node:util';
+import type { Kernel } from '@adonisjs/core/ace';
+import { Exception } from '@poppinss/utils/exception';
+import type { HttpContext } from '@adonisjs/core/http';
+import type { Dumper } from './dumper.js';
+/**
+ * DumpDie exception is raised by the "dd" function. It will
+ * result in dumping the value in response to an HTTP
+ * request or printing the value to the console
+ */
+declare class DumpDieException extends Exception {
+    #private;
+    static status: number;
+    static code: string;
+    fileName: string;
+    lineNumber: number;
+    value: unknown;
+    constructor(value: unknown, dumper: Dumper);
+    /**
+     * Set the index for the trace source. This is helpful when
+     * you build nested helpers on top of Die/Dump
+     */
+    setTraceSourceIndex(index: number): this;
+    /**
+     * Preventing itself from getting reported by the
+     * AdonisJS exception reporter
+     */
+    report(): void;
+    /**
+     * Handler called by the AdonisJS HTTP exception handler
+     */
+    handle(error: DumpDieException, ctx: HttpContext): Promise<void>;
+    /**
+     * Handler called by the AdonisJS Ace kernel
+     */
+    render(error: DumpDieException, kernel: Kernel): Promise<void>;
+    /**
+     * Custom output for the Node.js util inspect
+     */
+    [inspect.custom](): string;
+}
+export declare const E_DUMP_DIE_EXCEPTION: typeof DumpDieException;
+export {};

package/build/modules/dumper/errors.js

@@ -0,0 +1,98 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { inspect } from 'node:util';
+import { parse } from 'error-stack-parser-es';
+import { Exception } from '@poppinss/utils/exception';
+/**
+ * DumpDie exception is raised by the "dd" function. It will
+ * result in dumping the value in response to an HTTP
+ * request or printing the value to the console
+ */
+class DumpDieException extends Exception {
+    static status = 500;
+    static code = 'E_DUMP_DIE_EXCEPTION';
+    #dumper;
+    #traceSourceIndex = 1;
+    value;
+    constructor(value, dumper) {
+        super('Dump and Die exception');
+        this.#dumper = dumper;
+        this.value = value;
+    }
+    /**
+     * Returns the source file and line number location for the error
+     */
+    #getErrorSource() {
+        if (this.fileName && this.lineNumber) {
+            return {
+                location: this.fileName,
+                line: this.lineNumber,
+            };
+        }
+        const source = parse(this)[this.#traceSourceIndex];
+        if (!source.fileName || !source.lineNumber) {
+            return;
+        }
+        return {
+            location: source.fileName,
+            line: source.lineNumber,
+        };
+    }
+    /**
+     * Set the index for the trace source. This is helpful when
+     * you build nested helpers on top of Die/Dump
+     */
+    setTraceSourceIndex(index) {
+        this.#traceSourceIndex = index;
+        return this;
+    }
+    /**
+     * Preventing itself from getting reported by the
+     * AdonisJS exception reporter
+     */
+    report() { }
+    /**
+     * Handler called by the AdonisJS HTTP exception handler
+     */
+    async handle(error, ctx) {
+        const source = this.#getErrorSource();
+        /**
+         * Comes from the shield package
+         */
+        const cspNonce = 'nonce' in ctx.response ? ctx.response.nonce : undefined;
+        ctx.response
+            .status(500)
+            .send('<!DOCTYPE html>' +
+            '<html>' +
+            '<head>' +
+            '<meta charset="utf-8">' +
+            '<meta name="viewport" content="width=device-width">' +
+            `${this.#dumper.getHeadElements(cspNonce)}` +
+            '</head>' +
+            '<body>' +
+            `${this.#dumper.dumpToHtml(error.value, { cspNonce, source, title: 'DUMP DIE' })}` +
+            '</body>' +
+            '</html>');
+    }
+    /**
+     * Handler called by the AdonisJS Ace kernel
+     */
+    async render(error, kernel) {
+        const source = this.#getErrorSource();
+        kernel.ui.logger.log(this.#dumper.dumpToAnsi(error.value, { source, title: 'DUMP DIE' }));
+    }
+    /**
+     * Custom output for the Node.js util inspect
+     */
+    [inspect.custom]() {
+        const source = this.#getErrorSource();
+        return this.#dumper.dumpToAnsi(this.value, { source, title: 'DUMP DIE' });
+    }
+}
+export const E_DUMP_DIE_EXCEPTION = DumpDieException;

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

@@ -0,0 +1,3 @@
+export * as errors from './errors.js';
+export { Dumper } from './dumper.js';
+export { defineConfig } from './define_config.js';

package/build/modules/dumper/main.js

@@ -0,0 +1,11 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export * as errors from './errors.js';
+export { Dumper } from './dumper.js';
+export { defineConfig } from './define_config.js';

package/build/modules/dumper/plugins/edge.d.ts

@@ -0,0 +1,7 @@
+import { type Edge } from 'edge.js';
+import { type Dumper } from '../dumper.js';
+/**
+ * Returns an edge plugin that integrates with a given
+ * dumper instance
+ */
+export declare function pluginEdgeDumper(dumper: Dumper): (edge: Edge) => void;

package/build/modules/dumper/plugins/edge.js

@@ -0,0 +1,62 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { Template } from 'edge.js';
+/**
+ * Returns an edge plugin that integrates with a given
+ * dumper instance
+ */
+export function pluginEdgeDumper(dumper) {
+    Template.macro('dumper', dumper);
+    return (edge) => {
+        edge.registerTag({
+            tagName: 'dump',
+            block: false,
+            seekable: true,
+            noNewLine: true,
+            compile(parser, buffer, token) {
+                const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+                buffer.writeExpression(`template.stacks.pushOnceTo('dumper', 'dumper_globals', template.dumper.getHeadElements(state.cspNonce))`, token.filename, token.loc.start.line);
+                buffer.outputExpression(`template.dumper.dumpToHtml(${parser.utils.stringify(parsed)}, { cspNonce: state.cspNonce, source: { location: $filename, line: $lineNumber } })`, token.filename, token.loc.start.line, true);
+            },
+        });
+        edge.registerTag({
+            tagName: 'dd',
+            block: false,
+            seekable: true,
+            noNewLine: true,
+            compile(parser, buffer, token) {
+                const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+                /**
+                 * Dump/Die statement to catch error and convert it into
+                 * an Edge error
+                 */
+                const ddStatement = [
+                    'try {',
+                    `  template.dumper.dd(${parser.utils.stringify(parsed)})`,
+                    '} catch (error) {',
+                    `  if (error.code === 'E_DUMP_DIE_EXCEPTION') {`,
+                    '    const edgeError = template.createError(error.message, $filename, $lineNumber)',
+                    '    error.fileName = $filename',
+                    '    error.lineNumber = $lineNumber',
+                    '    edgeError.handle = function (_, ctx) {',
+                    '      return error.handle(error, ctx)',
+                    '    }',
+                    '    edgeError.report = function () {',
+                    '      return error.report(error)',
+                    '    }',
+                    '    throw edgeError',
+                    '  }',
+                    '  throw error',
+                    '}',
+                ].join('\n');
+                buffer.writeStatement(ddStatement, token.filename, token.loc.start.line);
+            },
+        });
+    };
+}

package/build/providers/app_provider.d.ts

@@ -51,6 +51,11 @@ export default class AppServiceProvider {
      * config that cannot be resolved by the container
      */
     protected registerBodyParserMiddleware(): void;
+    /**
+     * Registeres singleton instance of the "Dumper" module configured
+     * via the "config/app.ts" file.
+     */
+    protected registerDumper(): void;
     /**
      * Registers bindings
      */

package/build/providers/app_provider.js

@@ -9,9 +9,10 @@
 import { Config } from '../modules/config.js';
 import { Logger } from '../modules/logger.js';
 import { Application } from '../modules/app.js';
-import { BaseEvent, Emitter } from '../modules/events.js';
+import { Dumper } from '../modules/dumper/dumper.js';
 import { Encryption } from '../modules/encryption.js';
 import { Router, Server } from '../modules/http/main.js';
+import { BaseEvent, Emitter } from '../modules/events.js';
 import BodyParserMiddleware from '../modules/bodyparser/bodyparser_middleware.js';
 /**
  * The Application Service provider registers all the baseline
@@ -125,12 +126,31 @@ export default class AppServiceProvider {
             return new BodyParserMiddleware(config);
         });
     }
+    /**
+     * Registeres singleton instance of the "Dumper" module configured
+     * via the "config/app.ts" file.
+     */
+    registerDumper() {
+        this.app.container.singleton(Dumper, async () => {
+            const config = this.app.config.get('app.dumper', {});
+            const dumper = new Dumper(this.app);
+            if (config.html) {
+                dumper.configureHtmlOutput(config.html);
+            }
+            if (config.console) {
+                dumper.configureAnsiOutput(config.console);
+            }
+            return dumper;
+        });
+        this.app.container.alias('dumper', Dumper);
+    }
     /**
      * Registers bindings
      */
     register() {
         this.registerApp();
         this.registerAce();
+        this.registerDumper();
         this.registerLoggerManager();
         this.registerLogger();
         this.registerConfig();

package/build/providers/edge_provider.js

@@ -7,6 +7,7 @@
  * 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
@@ -24,6 +25,7 @@ export default class EdgeServiceProvider {
     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);
         }
@@ -66,5 +68,6 @@ export default class EdgeServiceProvider {
                 return view.render(template, data);
             });
         });
+        edge.use(pluginEdgeDumper(dumper));
     }
 }

package/build/services/dumper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Dump a value and die. The dumped value will be displayed
+ * using the HTML printer during an HTTP request or within
+ * the console otherwise.
+ */
+export declare const dd: (value: unknown) => void;

package/build/services/dumper.js

@@ -0,0 +1,25 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import app from './app.js';
+let dumper;
+/**
+ * dumper service is an instance of the "Dumper" class stored inside
+ * the "modules/dumper/dumper.ts" file
+ */
+await app.booted(async () => {
+    dumper = await app.container.make('dumper');
+});
+/**
+ * Dump a value and die. The dumped value will be displayed
+ * using the HTML printer during an HTTP request or within
+ * the console otherwise.
+ */
+export const dd = (value) => {
+    dumper.dd(value, 2);
+};

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

@@ -1,4 +1,4 @@
-export { default as parseImports } from 'parse-imports';
+export { parseImports } from 'parse-imports';
 export { createId as cuid, isCuid } from '@paralleldrive/cuid2';
 export { slash, base64, compose, Secret, joinToURL, fsReadAll, safeEqual, getDirname, getFilename, fsImportAll, MessageBuilder, } from '@poppinss/utils';
 export { parseBindingReference } from './parse_binding_reference.js';

package/build/src/helpers/main.js

@@ -6,7 +6,7 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-export { default as parseImports } from 'parse-imports';
+export { parseImports } from 'parse-imports';
 export { createId as cuid, isCuid } from '@paralleldrive/cuid2';
 export { slash, base64, compose, Secret, joinToURL, fsReadAll, safeEqual, getDirname, getFilename, fsImportAll, MessageBuilder, } from '@poppinss/utils';
 export { parseBindingReference } from './parse_binding_reference.js';

package/build/src/helpers/parse_binding_reference.js

@@ -6,7 +6,7 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import parseImports from 'parse-imports';
+import { parseImports } from 'parse-imports';
 /**
  * The "parseBindingReference" method can be used to parse a binding references
  * similar to route controller binding value or event listener binding value.

package/build/src/types.d.ts

@@ -5,6 +5,7 @@ import type { Kernel } from '../modules/ace/main.js';
 import type { Application } from '../modules/app.js';
 import type { TestUtils } from './test_utils/main.js';
 import type { HttpServerEvents } from '../types/http.js';
+import type { Dumper } from '../modules/dumper/dumper.js';
 import type { LoggerManager } from '../modules/logger.js';
 import type { HashManager } from '../modules/hash/main.js';
 import type { Encryption } from '../modules/encryption.js';
@@ -109,6 +110,7 @@ export interface HashService extends HashManager<HashersList extends Record<stri
  */
 export interface ContainerBindings {
     ace: Kernel;
+    dumper: Dumper;
     app: ApplicationService;
     logger: LoggerService;
     config: ApplicationService['config'];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/core",
   "description": "Core of AdonisJS",
-  "version": "6.13.0",
+  "version": "6.14.0",
   "engines": {
     "node": ">=20.6.0"
   },
@@ -49,6 +49,8 @@
     "./container": "./build/modules/container.js",
     "./encryption": "./build/modules/encryption.js",
     "./env": "./build/modules/env/main.js",
+    "./dumper": "./build/modules/dumper/main.js",
+    "./dumper/plugin_edge": "./build/modules/dumper/plugins/edge.js",
     "./env/editor": "./build/modules/env/editor.js",
     "./events": "./build/modules/events.js",
     "./http": "./build/modules/http/main.js",
@@ -82,18 +84,19 @@
   },
   "devDependencies": {
     "@adonisjs/assembler": "^7.8.2",
-    "@adonisjs/eslint-config": "^2.0.0-beta.6",
+    "@adonisjs/eslint-config": "^2.0.0-beta.7",
     "@adonisjs/prettier-config": "^1.4.0",
     "@adonisjs/tsconfig": "^1.4.0",
-    "@commitlint/cli": "^19.4.1",
-    "@commitlint/config-conventional": "^19.4.1",
+    "@commitlint/cli": "^19.5.0",
+    "@commitlint/config-conventional": "^19.5.0",
     "@japa/assert": "^3.0.0",
     "@japa/expect-type": "^2.0.2",
     "@japa/file-system": "^2.3.0",
     "@japa/runner": "^3.1.4",
-    "@release-it/conventional-changelog": "^8.0.1",
-    "@swc/core": "^1.7.23",
-    "@types/node": "^22.5.4",
+    "@japa/snapshot": "^2.0.5",
+    "@release-it/conventional-changelog": "^8.0.2",
+    "@swc/core": "^1.7.26",
+    "@types/node": "^22.5.5",
     "@types/pretty-hrtime": "^1.0.3",
     "@types/sinon": "^17.0.3",
     "@types/supertest": "^6.0.2",
@@ -105,19 +108,19 @@
     "copyfiles": "^2.4.1",
     "cross-env": "^7.0.3",
     "del-cli": "^5.1.0",
-    "edge.js": "^6.0.2",
-    "eslint": "^9.9.1",
-    "execa": "^9.3.1",
+    "edge.js": "^6.2.0",
+    "eslint": "^9.11.0",
+    "execa": "^9.4.0",
     "get-port": "^7.1.0",
     "github-label-sync": "^2.3.1",
-    "husky": "^9.1.5",
+    "husky": "^9.1.6",
     "prettier": "^3.3.3",
     "release-it": "^17.6.0",
-    "sinon": "^18.0.0",
+    "sinon": "^19.0.2",
     "supertest": "^7.0.0",
     "test-console": "^2.0.0",
     "ts-node-maintained": "^10.9.4",
-    "typescript": "^5.5.4"
+    "typescript": "^5.6.2"
   },
   "dependencies": {
     "@adonisjs/ace": "^13.2.0",
@@ -128,19 +131,22 @@
     "@adonisjs/env": "^6.1.0",
     "@adonisjs/events": "^9.0.2",
     "@adonisjs/fold": "^10.1.2",
-    "@adonisjs/hash": "^9.0.4",
+    "@adonisjs/hash": "^9.0.5",
     "@adonisjs/health": "^2.0.0",
     "@adonisjs/http-server": "^7.2.3",
     "@adonisjs/logger": "^6.0.3",
     "@adonisjs/repl": "^4.0.1",
     "@antfu/install-pkg": "^0.4.1",
     "@paralleldrive/cuid2": "^2.2.2",
-    "@poppinss/macroable": "^1.0.2",
-    "@poppinss/utils": "^6.7.3",
-    "@sindresorhus/is": "^7.0.0",
+    "@poppinss/colors": "^4.1.3",
+    "@poppinss/dumper": "^0.4.1",
+    "@poppinss/macroable": "^1.0.3",
+    "@poppinss/utils": "^6.8.3",
+    "@sindresorhus/is": "^7.0.1",
     "@types/he": "^1.2.3",
+    "error-stack-parser-es": "^0.1.5",
     "he": "^1.2.0",
-    "parse-imports": "^1.2.0",
+    "parse-imports": "^2.2.1",
     "pretty-hrtime": "^1.0.3",
     "string-width": "^7.2.0",
     "youch": "^3.3.3",
@@ -151,7 +157,7 @@
     "@vinejs/vine": "^2.1.0",
     "argon2": "^0.31.2 || ^0.41.0",
     "bcrypt": "^5.1.1",
-    "edge.js": "^6.0.1"
+    "edge.js": "^6.2.0"
   },
   "peerDependenciesMeta": {
     "argon2": {