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

package/build/modules/app.d.ts

@@ -1 +1,18 @@
+/**
+ * Application module re-exports all functionality from @adonisjs/application.
+ * This includes the main Application class and related types for managing
+ * the AdonisJS application lifecycle, container bindings, and service providers.
+ *
+ * @example
+ * // Import the Application class
+ * import { Application } from '@adonisjs/core/app'
+ *
+ * const app = new Application(new URL('../', import.meta.url))
+ * await app.init()
+ * await app.boot()
+ *
+ * @example
+ * // Import application types
+ * import type { ApplicationService, ContainerBindings } from '@adonisjs/core/app'
+ */
 export * from '@adonisjs/application';

package/build/modules/app.js

@@ -1,9 +1,4 @@
-/*
- * @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/application';
+import "../chunk-B88MteZI.js";
+import "../app-DNvbxVWl.js";
+export * from "@adonisjs/application";
+export {};

package/build/modules/bodyparser/bodyparser_middleware.js

@@ -1,14 +1,2 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { BodyParserMiddleware } from '@adonisjs/bodyparser/bodyparser_middleware';
-/**
- * Default export allows lazy importing middleware with
- * destructuring the named exports
- */
-export default BodyParserMiddleware;
+import { t as bodyparser_middleware_default } from "../../bodyparser_middleware-BmARtnYe.js";
+export { bodyparser_middleware_default as default };

package/build/modules/bodyparser/main.js

@@ -1,9 +1,4 @@
-/*
- * @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/bodyparser';
+import "../../chunk-B88MteZI.js";
+import "../../main-DOY5Q8Av.js";
+export * from "@adonisjs/bodyparser";
+export {};

package/build/modules/config.d.ts

@@ -1 +1,18 @@
+/**
+ * Configuration module re-exports all functionality from @adonisjs/config.
+ * This includes the Config class and related types for managing application
+ * configuration files and environment-specific settings.
+ *
+ * @example
+ * // Import the Config class
+ * import { Config } from '@adonisjs/core/config'
+ *
+ * const config = new Config()
+ * config.set('database.connection', 'mysql')
+ * const dbConnection = config.get('database.connection')
+ *
+ * @example
+ * // Import configuration types
+ * import type { ConfigProvider } from '@adonisjs/core/config'
+ */
 export * from '@adonisjs/config';

package/build/modules/config.js

@@ -1,9 +1,4 @@
-/*
- * @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/config';
+import "../chunk-B88MteZI.js";
+import "../config-Dd2H6-_e.js";
+export * from "@adonisjs/config";
+export {};

package/build/modules/container.js

@@ -1,9 +1,4 @@
-/*
- * @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/fold';
+import "../chunk-B88MteZI.js";
+import "../container-uxa8LpGI.js";
+export * from "@adonisjs/fold";
+export {};

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

@@ -28,6 +28,11 @@ import type { Application } from '../app.ts';
  */
 export declare class Dumper {
     #private;
+    /**
+     * Creates a new Dumper instance
+     *
+     * @param app - The AdonisJS application instance
+     */
     constructor(app: Application<any>);
     /**
      * Configure the HTML formatter output options

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

@@ -1,3 +1,24 @@
+/**
+ * Dumper module provides debugging and inspection utilities for AdonisJS applications.
+ * Includes the Dumper class for formatting output, error classes, and configuration helpers.
+ *
+ * @example
+ * // Use the dumper service
+ * import { Dumper } from '@adonisjs/core/dumper'
+ *
+ * const dumper = new Dumper(app)
+ * const htmlOutput = dumper.dumpToHtml(user, { title: 'User Data' })
+ * const ansiOutput = dumper.dumpToAnsi(user, { title: 'Debug User' })
+ *
+ * @example
+ * // Configure dumper output
+ * import { defineConfig } from '@adonisjs/core/dumper'
+ *
+ * export default defineConfig({
+ *   html: { showHidden: true, depth: 5 },
+ *   console: { collapse: ['Date', 'DateTime'] }
+ * })
+ */
 export * as errors from './errors.ts';
 export { Dumper } from './dumper.ts';
 export { defineConfig } from './define_config.ts';

package/build/modules/dumper/main.js

@@ -1,11 +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.
- */
-export * as errors from "./errors.js";
-export { Dumper } from "./dumper.js";
-export { defineConfig } from "./define_config.js";
+import "../../chunk-B88MteZI.js";
+import { n as errors_exports, t as Dumper } from "../../dumper-BTjb8j4y.js";
+function defineConfig(dumperConfig) {
+	return dumperConfig;
+}
+export { Dumper, defineConfig, errors_exports as errors };

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

@@ -1,62 +1,2 @@
-/*
- * @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);
-            },
-        });
-    };
-}
+import { t as pluginEdgeDumper } from "../../../edge-BVYR-Vjr.js";
+export { pluginEdgeDumper };

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

@@ -0,0 +1,128 @@
+import { type ConfigProvider } from '../../src/types.ts';
+import { type AES256CBCDriverConfig, type AES256GCMDriverConfig, type ChaCha20Poly1305DriverConfig } from '../../types/encryption.ts';
+import { type EncryptionConfig } from '../../types/encryption.ts';
+/**
+ * Resolved configuration from the config provider that will be
+ * accepted by the encryption manager.
+ *
+ * This type unwraps ConfigProvider types to their resolved values,
+ * ensuring all encryptors in the list are concrete EncryptionConfig
+ * objects rather than providers.
+ *
+ * @template KnownEncryptors - Record of encryptor names to their configurations
+ */
+type ResolvedConfig<KnownEncryptors extends Record<string, EncryptionConfig | ConfigProvider<EncryptionConfig>>> = {
+    /**
+     * The default encryptor name to use when no specific
+     * encryptor is requested
+     */
+    default?: keyof KnownEncryptors;
+    /**
+     * Map of encryptor names to their resolved configurations.
+     * ConfigProvider types are unwrapped to their underlying
+     * EncryptionConfig values.
+     */
+    list: {
+        [K in keyof KnownEncryptors]: KnownEncryptors[K] extends ConfigProvider<infer A> ? A : KnownEncryptors[K];
+    };
+};
+/**
+ * Defines the encryption configuration for the application.
+ *
+ * This function creates a configuration provider that lazily resolves
+ * encryption drivers. It validates that the default encryptor (if specified)
+ * exists in the list and resolves any ConfigProvider instances to their
+ * concrete values.
+ *
+ * @template KnownEncryptors - Record of encryptor names to their configurations
+ *
+ * @param config - The encryption configuration object
+ * @param config.default - Optional default encryptor name
+ * @param config.list - Map of encryptor names to their configurations or providers
+ *
+ * @example
+ * ```ts
+ * const encryptionConfig = defineConfig({
+ *   default: 'app',
+ *   list: {
+ *     app: drivers.aes256gcm({
+ *       id: 'app',
+ *       keys: [env.get('APP_KEY')]
+ *     }),
+ *     backup: drivers.chacha20({
+ *       id: 'backup',
+ *       keys: [env.get('BACKUP_KEY')]
+ *     })
+ *   }
+ * })
+ * ```
+ */
+export declare function defineConfig<KnownEncryptors extends Record<string, EncryptionConfig | ConfigProvider<EncryptionConfig>>>(config: {
+    default?: keyof KnownEncryptors;
+    list: KnownEncryptors;
+}): ConfigProvider<ResolvedConfig<KnownEncryptors>>;
+/**
+ * Collection of encryption driver factory functions.
+ *
+ * Each driver factory creates a ConfigProvider that lazily imports
+ * and configures the corresponding encryption driver. This allows
+ * for efficient code splitting and on-demand loading of encryption
+ * algorithms.
+ */
+export declare const drivers: {
+    /**
+     * Creates a ChaCha20-Poly1305 encryption driver configuration.
+     *
+     * ChaCha20-Poly1305 is a modern authenticated encryption algorithm
+     * that provides excellent performance on systems without AES hardware
+     * acceleration.
+     *
+     * @param config - The ChaCha20-Poly1305 driver configuration
+     *
+     * @example
+     * ```ts
+     * drivers.chacha20({
+     *   id: 'app',
+     *   keys: [env.get('APP_KEY')]
+     * })
+     * ```
+     */
+    chacha20: (config: ChaCha20Poly1305DriverConfig) => ConfigProvider<EncryptionConfig>;
+    /**
+     * Creates an AES-256-CBC encryption driver configuration.
+     *
+     * AES-256-CBC is a widely-supported block cipher mode. However,
+     * consider using AES-256-GCM for new applications as it provides
+     * authenticated encryption.
+     *
+     * @param config - The AES-256-CBC driver configuration
+     *
+     * @example
+     * ```ts
+     * drivers.aes256cbc({
+     *   id: 'legacy',
+     *   keys: [env.get('LEGACY_KEY')]
+     * })
+     * ```
+     */
+    aes256cbc: (config: AES256CBCDriverConfig) => ConfigProvider<EncryptionConfig>;
+    /**
+     * Creates an AES-256-GCM encryption driver configuration.
+     *
+     * AES-256-GCM is an authenticated encryption algorithm that provides
+     * both confidentiality and integrity. It offers excellent performance
+     * on systems with AES hardware acceleration.
+     *
+     * @param config - The AES-256-GCM driver configuration
+     *
+     * @example
+     * ```ts
+     * drivers.aes256gcm({
+     *   id: 'app',
+     *   keys: [env.get('APP_KEY')]
+     * })
+     * ```
+     */
+    aes256gcm: (config: AES256GCMDriverConfig) => ConfigProvider<EncryptionConfig>;
+};
+export {};

package/build/modules/encryption/drivers/aes_256_cbc.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AES-256-CBC encryption driver implementation.
+ *
+ * This driver provides encryption and decryption using the AES-256-CBC
+ * (Advanced Encryption Standard with 256-bit key in Cipher Block Chaining mode)
+ * algorithm. While widely supported, AES-256-CBC does not provide authenticated
+ * encryption. Consider using AES-256-GCM for new applications.
+ *
+ * @example
+ * ```ts
+ * const driver = new AES256CBC({
+ *   id: 'app',
+ *   key: 'your-256-bit-key-here'
+ * })
+ *
+ * const encrypted = driver.encrypt('sensitive data')
+ * const decrypted = driver.decrypt(encrypted)
+ * ```
+ */
+export { AES256CBC } from '@boringnode/encryption/drivers/aes_256_cbc';

package/build/modules/encryption/drivers/aes_256_cbc.js

@@ -0,0 +1,2 @@
+import { AES256CBC } from "@boringnode/encryption/drivers/aes_256_cbc";
+export { AES256CBC };

package/build/modules/encryption/drivers/aes_256_gcm.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AES-256-GCM encryption driver implementation.
+ *
+ * This driver provides authenticated encryption and decryption using the
+ * AES-256-GCM (Advanced Encryption Standard with 256-bit key in Galois/Counter Mode)
+ * algorithm. GCM mode provides both confidentiality and authenticity, making it
+ * the recommended choice for modern applications. It offers excellent performance
+ * on systems with AES hardware acceleration.
+ *
+ * @example
+ * ```ts
+ * const driver = new AES256GCM({
+ *   id: 'app',
+ *   key: 'your-256-bit-key-here'
+ * })
+ *
+ * const encrypted = driver.encrypt('sensitive data')
+ * const decrypted = driver.decrypt(encrypted)
+ * ```
+ */
+export { AES256GCM } from '@boringnode/encryption/drivers/aes_256_gcm';

package/build/modules/encryption/drivers/aes_256_gcm.js

@@ -0,0 +1,2 @@
+import { AES256GCM } from "@boringnode/encryption/drivers/aes_256_gcm";
+export { AES256GCM };

package/build/modules/encryption/drivers/chacha20_poly1305.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ChaCha20-Poly1305 encryption driver implementation.
+ *
+ * This driver provides authenticated encryption and decryption using the
+ * ChaCha20-Poly1305 algorithm. ChaCha20 is a modern stream cipher that
+ * provides excellent performance on systems without AES hardware acceleration.
+ * Combined with Poly1305 for authentication, it offers both confidentiality
+ * and authenticity.
+ *
+ * @example
+ * ```ts
+ * const driver = new ChaCha20Poly1305({
+ *   id: 'app',
+ *   key: 'your-256-bit-key-here'
+ * })
+ *
+ * const encrypted = driver.encrypt('sensitive data')
+ * const decrypted = driver.decrypt(encrypted)
+ * ```
+ */
+export { ChaCha20Poly1305 } from '@boringnode/encryption/drivers/chacha20_poly1305';

package/build/modules/encryption/drivers/chacha20_poly1305.js

@@ -0,0 +1,2 @@
+import { ChaCha20Poly1305 } from "@boringnode/encryption/drivers/chacha20_poly1305";
+export { ChaCha20Poly1305 };

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

@@ -0,0 +1,85 @@
+/**
+ * Main encryption class for encrypting and decrypting values.
+ *
+ * Provides methods to encrypt strings and objects with optional purpose
+ * binding, decrypt values, and manage encryption keys.
+ *
+ * @example
+ * ```ts
+ * const encryption = new Encryption({ key: 'secret-key' })
+ * const encrypted = encryption.encrypt('sensitive data')
+ * const decrypted = encryption.decrypt(encrypted)
+ * ```
+ */
+export { Encryption } from '@boringnode/encryption';
+/**
+ * Manager class for handling multiple encryption instances.
+ *
+ * Allows you to configure and manage multiple encryption drivers,
+ * switch between them, and use different encryption keys for
+ * different purposes.
+ *
+ * @example
+ * ```ts
+ * const manager = new EncryptionManager({
+ *   default: 'app',
+ *   list: {
+ *     app: {
+ *       driver: (key) => new AES256GCM({ key }),
+ *       keys: ['app-key']
+ *     }
+ *   }
+ * })
+ * const encryptor = manager.use('app')
+ * ```
+ */
+export { EncryptionManager } from '@boringnode/encryption';
+/**
+ * HMAC (Hash-based Message Authentication Code) class for creating
+ * and verifying message authentication codes.
+ *
+ * Provides methods to generate cryptographic hashes with a secret key
+ * and verify them to ensure data integrity and authenticity.
+ *
+ * @example
+ * ```ts
+ * const hmac = new Hmac('secret-key')
+ * const signature = hmac.generate('message')
+ * const isValid = hmac.verify('message', signature)
+ * ```
+ */
+export { Hmac } from '@boringnode/encryption';
+/**
+ * Base class for implementing custom encryption drivers.
+ *
+ * Extend this class to create custom encryption implementations
+ * that can be used with the EncryptionManager.
+ *
+ * @example
+ * ```ts
+ * class CustomDriver extends BaseDriver {
+ *   encrypt(value: string) {
+ *     // Custom encryption logic
+ *   }
+ *   decrypt(payload: string) {
+ *     // Custom decryption logic
+ *   }
+ * }
+ * ```
+ */
+export { BaseDriver } from '@boringnode/encryption';
+/**
+ * Defines the encryption configuration for the application.
+ *
+ * @see {defineConfig} in define_config.ts for detailed documentation
+ */
+export { defineConfig } from './define_config.ts';
+/**
+ * Collection of built-in encryption driver factory functions.
+ *
+ * Includes factories for ChaCha20-Poly1305, AES-256-CBC, and
+ * AES-256-GCM encryption algorithms.
+ *
+ * @see {drivers} in define_config.ts for detailed documentation
+ */
+export { drivers } from './define_config.ts';

package/build/modules/encryption/main.js

@@ -0,0 +1,5 @@
+import "../../config_provider-DWVFHOQX.js";
+import "../../exceptions-DNMesP42.js";
+import { n as drivers, t as defineConfig } from "../../define_config-CoWy5lbf.js";
+import { i as Hmac, n as Encryption, r as EncryptionManager, t as BaseDriver } from "../../main-Bfnr5tAw.js";
+export { BaseDriver, Encryption, EncryptionManager, Hmac, defineConfig, drivers };

package/build/modules/env/editor.js

@@ -1,9 +1,2 @@
-/*
- * @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/env/editor';
+export * from "@adonisjs/env/editor";
+export {};

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

@@ -1,9 +1,2 @@
-/*
- * @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/env';
+export * from "@adonisjs/env";
+export {};

package/build/modules/events.js

@@ -1,9 +1,4 @@
-/*
- * @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/events';
+import "../chunk-B88MteZI.js";
+import "../events-C4d0OPUI.js";
+export * from "@adonisjs/events";
+export {};

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

@@ -1,9 +1,2 @@
-/*
- * @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/hash/drivers/argon';
+export * from "@adonisjs/hash/drivers/argon";
+export {};

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

@@ -1,9 +1,2 @@
-/*
- * @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/hash/drivers/bcrypt';
+export * from "@adonisjs/hash/drivers/bcrypt";
+export {};

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

@@ -1,9 +1,2 @@
-/*
- * @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/hash/drivers/scrypt';
+export * from "@adonisjs/hash/drivers/scrypt";
+export {};