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

package/build/src/helpers/string.js

@@ -1,60 +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 prettyHrTime from 'pretty-hrtime';
-import string from '@poppinss/utils/string';
-import he from 'he';
-import StringBuilder from '@poppinss/utils/string_builder';
-/**
- * Collection of string helpers to transform a string value. This object extends
- * the base string utilities from @poppinss/utils with additional AdonisJS-specific
- * string manipulation methods.
- *
- * @example
- * // Basic string transformations
- * stringHelpers.camelCase('hello_world') // 'helloWorld'
- * stringHelpers.snakeCase('HelloWorld')   // 'hello_world'
- * stringHelpers.pascalCase('hello world') // 'HelloWorld'
- *
- * @example
- * // HTML escaping and encoding
- * stringHelpers.escapeHTML('<script>alert("xss")</script>')
- * stringHelpers.encodeSymbols('© 2023 AdonisJS')
- */
-const stringHelpers = {
-    ...string,
-    toSentence: string.sentence,
-    ordinalize: string.ordinal,
-    generateRandom: string.random,
-    create(value) {
-        return new StringBuilder(value);
-    },
-    /**
-     * Formats Node.js hrtime output into a human-readable string.
-     *
-     * @param time - Tuple of [seconds, nanoseconds] from process.hrtime()
-     * @param options - Formatting options for output style and precision
-     */
-    prettyHrTime(time, options) {
-        return prettyHrTime(time, options);
-    },
-    isEmpty(value) {
-        return value.trim().length === 0;
-    },
-    escapeHTML(value, options) {
-        value = he.escape(value);
-        if (options && options.encodeSymbols) {
-            value = this.encodeSymbols(value, { allowUnsafeSymbols: true });
-        }
-        return value;
-    },
-    encodeSymbols(value, options) {
-        return he.encode(value, options);
-    },
-};
-export default stringHelpers;
+import { t as string_default } from "../../string-Cx6q_win.js";
+export { string_default as default };

package/build/src/helpers/types.js

@@ -1,136 +1,27 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import is from '@sindresorhus/is';
-/**
- * @deprecated
- * Use "is" helpers instead. The types helpers exist for backward compatibility.
- *
- * @example
- * // Instead of using types helpers (deprecated)
- * types.isString('hello')
- * types.isNumber(42)
- *
- * @example
- * // Use the new "is" helpers
- * import { is } from '@adonisjs/core/helpers'
- * is.string('hello')
- * is.number(42)
- */
-const types = {
-    /**
-     * Direct reference to the is utility for type checking lookups.
-     * @deprecated Use the is helpers directly instead
-     */
-    lookup: is,
-    /**
-     * Check if value is null.
-     * @deprecated Use is.null instead
-     */
-    isNull: is.null,
-    /**
-     * Check if value is a boolean.
-     * @deprecated Use is.boolean instead
-     */
-    isBoolean: is.boolean,
-    /**
-     * Check if value is a Buffer.
-     * @deprecated Use is.buffer instead
-     */
-    isBuffer: is.buffer,
-    /**
-     * Check if value is a number.
-     * @deprecated Use is.number instead
-     */
-    isNumber: is.number,
-    /**
-     * Check if value is a string.
-     * @deprecated Use is.string instead
-     */
-    isString: is.string,
-    /**
-     * Check if value is an arguments object.
-     * @deprecated Use is.arguments instead
-     */
-    isArguments: is.arguments,
-    /**
-     * Check if value is an object.
-     * @deprecated Use is.object instead
-     */
-    isObject: is.object,
-    /**
-     * Check if value is a Date.
-     * @deprecated Use is.date instead
-     */
-    isDate: is.date,
-    /**
-     * Check if value is an array.
-     * @deprecated Use is.array instead
-     */
-    isArray: is.array,
-    /**
-     * Check if value is a regular expression.
-     * @deprecated Use is.regExp instead
-     */
-    isRegexp: is.regExp,
-    /**
-     * Check if value is an error object.
-     * @deprecated Use is.error instead
-     */
-    isError: is.error,
-    /**
-     * Check if value is a function.
-     * @deprecated Use is.function instead
-     */
-    isFunction: is.function,
-    /**
-     * Check if value is a class.
-     * @deprecated Use is.class instead
-     */
-    isClass: is.class,
-    /**
-     * Check if value is an integer.
-     * @deprecated Use is.integer instead
-     */
-    isInteger: is.integer,
-    /**
-     * Check if a number is a float (has decimal places).
-     *
-     * @param value - The number to check
-     * @deprecated Use is.decimal or custom logic instead
-     *
-     * @example
-     * types.isFloat(3.14) // true
-     * types.isFloat(42)   // false
-     */
-    isFloat(value) {
-        return value !== (value | 0);
-    },
-    /**
-     * Check if a value represents a decimal number with specific decimal places.
-     *
-     * @param value - The value to check (string or number)
-     * @param options - Options for decimal validation
-     * @param options.decimalPlaces - Regex pattern for allowed decimal places (default: '1,')
-     * @deprecated Use a validation library like Vine or custom logic instead
-     *
-     * @example
-     * types.isDecimal('3.14')     // true
-     * types.isDecimal('42.0')     // true
-     * types.isDecimal('42')       // false
-     * types.isDecimal('3.141', { decimalPlaces: '1,3' }) // true
-     */
-    isDecimal(value, options) {
-        if (typeof value === 'number') {
-            value = value.toString();
-        }
-        const decimalPlaces = (options && options.decimalPlaces) || '1,';
-        return new RegExp(`^[-+]?([0-9]+)?(\\.[0-9]{${decimalPlaces}})$`).test(value);
-    },
+import is from "@sindresorhus/is";
+var types_default = {
+	lookup: is,
+	isNull: is.null,
+	isBoolean: is.boolean,
+	isBuffer: is.buffer,
+	isNumber: is.number,
+	isString: is.string,
+	isArguments: is.arguments,
+	isObject: is.object,
+	isDate: is.date,
+	isArray: is.array,
+	isRegexp: is.regExp,
+	isError: is.error,
+	isFunction: is.function,
+	isClass: is.class,
+	isInteger: is.integer,
+	isFloat(value) {
+		return value !== (value | 0);
+	},
+	isDecimal(value, options) {
+		if (typeof value === "number") value = value.toString();
+		const decimalPlaces = options && options.decimalPlaces || "1,";
+		return (/* @__PURE__ */ new RegExp(`^[-+]?([0-9]+)?(\\.[0-9]{${decimalPlaces}})$`)).test(value);
+	}
 };
-export default types;
+export { types_default as default };

package/build/src/helpers/verification_token.js

@@ -1,120 +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 { createHash } from 'node:crypto';
-import string from '@poppinss/utils/string';
-import { safeEqual, Secret } from '@poppinss/utils';
-import base64 from '@poppinss/utils/base64';
-/**
- * Verification token class can be used to create tokens publicly
- * shareable tokens while storing the token hash within the database.
- *
- * This class is used by the Auth and the Persona packages to manage
- * tokens for authentication and authorization purposes.
- *
- * @example
- * class UserToken extends VerificationToken {
- *   constructor(user: User, secret: Secret<string>) {
- *     super()
- *     this.tokenableId = user.id
- *     this.computeValue(secret)
- *   }
- * }
- */
-export class VerificationToken {
-    /**
-     * Decodes a publicly shared token and return the series
-     * and the token value from it.
-     *
-     * Returns null when unable to decode the token because of
-     * invalid format or encoding.
-     *
-     * @param value - The token string to decode
-     */
-    static decode(value) {
-        /**
-         * Ensure value is a string and starts with the prefix.
-         */
-        if (typeof value !== 'string') {
-            return null;
-        }
-        /**
-         * Remove prefix from the rest of the token.
-         */
-        if (!value) {
-            return null;
-        }
-        const [identifier, ...tokenValue] = value.split('.');
-        if (!identifier || tokenValue.length === 0) {
-            return null;
-        }
-        const decodedIdentifier = base64.urlDecode(identifier);
-        const decodedSecret = base64.urlDecode(tokenValue.join('.'));
-        if (!decodedIdentifier || !decodedSecret) {
-            return null;
-        }
-        return {
-            identifier: decodedIdentifier,
-            secret: new Secret(decodedSecret),
-        };
-    }
-    /**
-     * Creates a transient token that can be shared with the persistence
-     * layer.
-     *
-     * @param userId - The user ID for whom the token is being created
-     * @param size - The size of the random token seed
-     * @param expiresIn - Token expiration time (string like '2h' or number in seconds)
-     */
-    static createTransientToken(userId, size, expiresIn) {
-        const expiresAt = new Date();
-        expiresAt.setSeconds(expiresAt.getSeconds() + string.seconds.parse(expiresIn));
-        return {
-            userId,
-            expiresAt,
-            ...this.seed(size),
-        };
-    }
-    /**
-     * Creates a secret opaque token and its hash.
-     *
-     * @param size - The length of the random token to generate
-     */
-    static seed(size) {
-        const seed = string.random(size);
-        const secret = new Secret(seed);
-        const hash = createHash('sha256').update(secret.release()).digest('hex');
-        return { secret, hash };
-    }
-    /**
-     * Compute the value property using the given secret. You can
-     * get secret via the static "createTransientToken" method.
-     *
-     * @param secret - The secret value to compute the public token value from
-     */
-    computeValue(secret) {
-        this.value = new Secret(`${base64.urlEncode(String(this.identifier))}.${base64.urlEncode(secret.release())}`);
-    }
-    /**
-     * Check if the token has been expired. Verifies
-     * the "expiresAt" timestamp with the current
-     * date.
-     */
-    isExpired() {
-        return this.expiresAt < new Date();
-    }
-    /**
-     * Verifies the value of a token against the pre-defined hash
-     *
-     * @param secret - The secret to verify against the stored hash
-     */
-    verify(secret) {
-        const newHash = createHash('sha256').update(secret.release()).digest('hex');
-        return safeEqual(this.hash, newHash);
-    }
-}
+import { t as VerificationToken } from "../../verification_token-DrdoU4RH.js";
+export { VerificationToken };

package/build/src/test_utils/main.js

@@ -1,77 +1,8 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { Socket } from 'node:net';
-import Macroable from '@poppinss/macroable';
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { HttpServerUtils } from "./http.js";
-import { CookieClient } from "../../modules/http/main.js";
-/**
- * Test utils has a collection of helper methods to make testing
- * experience great for AdonisJS applications. It provides utilities
- * for HTTP testing, context creation, and cookie handling.
- *
- * @example
- * const testUtils = new TestUtils(app)
- * await testUtils.boot()
- *
- * const ctx = await testUtils.createHttpContext()
- * const httpUtils = testUtils.httpServer()
- */
-export class TestUtils extends Macroable {
-    app;
-    /**
-     * Flag to track if test utils have been booted
-     */
-    #booted = false;
-    /**
-     * Check if utils have been booted
-     */
-    get isBooted() {
-        return this.#booted;
-    }
-    /**
-     * Creates a new TestUtils instance
-     *
-     * @param app - The application service instance
-     */
-    constructor(app) {
-        super();
-        this.app = app;
-    }
-    /**
-     * Boot test utils. It requires the app to be booted
-     * and container to have all the bindings
-     */
-    async boot() {
-        if (!this.isBooted) {
-            this.#booted = true;
-            this.cookies = new CookieClient(await this.app.container.make('encryption'));
-        }
-    }
-    /**
-     * Returns an instance of the HTTP server testing
-     * utils
-     */
-    httpServer() {
-        return new HttpServerUtils(this);
-    }
-    /**
-     * Create an instance of HTTP context for testing
-     *
-     * @param options - Options for creating HTTP context with custom req/res objects
-     */
-    async createHttpContext(options = {}) {
-        const req = options.req || new IncomingMessage(new Socket());
-        const res = options.res || new ServerResponse(req);
-        const server = await this.app.container.make('server');
-        const request = server.createRequest(req, res);
-        const response = server.createResponse(req, res);
-        return server.createHttpContext(request, response, this.app.container.createResolver());
-    }
-}
+import "../../chunk-B88MteZI.js";
+import "../../config_provider-DWVFHOQX.js";
+import "../../main-nojlltNo.js";
+import "../../exceptions-DNMesP42.js";
+import "../../define_config-CoWy5lbf.js";
+import "../../main-Bfnr5tAw.js";
+import { t as TestUtils } from "../../main-BU8NWUEG.js";
+export { TestUtils };

package/build/src/types.d.ts

@@ -8,9 +8,10 @@ import type { HttpServerEvents, LookupList, RoutesList, SignedURLOptions, UrlFor
 import type { Dumper } from '../modules/dumper/dumper.ts';
 import type { LoggerManager } from '../modules/logger.ts';
 import type { HashManager } from '../modules/hash/main.ts';
-import type { Encryption } from '../modules/encryption.ts';
 import type { ManagerDriverFactory } from '../types/hash.ts';
 import type { Router, Server } from '../modules/http/main.ts';
+import { type EncryptionConfig } from '../types/encryption.ts';
+import type { EncryptionManager } from '../modules/encryption/main.ts';
 import type { ContainerResolveEventData } from '../types/container.ts';
 import type { LoggerConfig, LoggerManagerConfig } from '../types/logger.ts';
 /**
@@ -119,6 +120,30 @@ export interface HashersList {
 export type InferHashers<T extends ConfigProvider<{
     list: Record<string, ManagerDriverFactory>;
 }>> = Awaited<ReturnType<T['resolver']>>['list'];
+/**
+ * A list of known encryptors inferred from the user config.
+ * This interface should be extended in user code to register
+ * custom encryptors.
+ *
+ * @example
+ * // Extending EncryptorsList in user code
+ * declare module '@adonisjs/core' {
+ *   interface EncryptorsList {
+ *     default: EncryptionConfig
+ *     secondary: EncryptionConfig
+ *   }
+ * }
+ */
+export interface EncryptorsList {
+}
+/**
+ * Utility type to infer encryptors configurations from a config provider.
+ *
+ * @template T - The config provider type that resolves to an object with a 'list' property
+ */
+export type InferEncryptors<T extends ConfigProvider<{
+    list: Record<string, EncryptionConfig>;
+}>> = Awaited<ReturnType<T['resolver']>>['list'];
 /**
  * ----------------------------------------------------------------
  * Container services
@@ -132,77 +157,32 @@ export type InferHashers<T extends ConfigProvider<{
  * Application service is a singleton resolved from
  * the container. It provides access to the core application
  * instance with all registered bindings.
- *
- * @example
- * // Accessing application service in a controller
- * export default class HomeController {
- *   async index({ app }: { app: ApplicationService }) {
- *     const version = app.version
- *     const env = app.env.get('NODE_ENV')
- *   }
- * }
  */
 export interface ApplicationService extends Application<ContainerBindings extends Record<any, any> ? ContainerBindings : never> {
 }
 /**
  * Logger service is a singleton logger instance registered
  * to the container. It provides access to configured loggers.
- *
- * @example
- * // Using logger service in a controller
- * export default class UserController {
- *   async store({ logger }: { logger: LoggerService }) {
- *     logger.info('Creating new user')
- *     logger.use('file').error('Failed to create user')
- *   }
- * }
  */
 export interface LoggerService extends LoggerManager<LoggersList extends Record<string, LoggerConfig> ? LoggersList : never> {
 }
 /**
  * Emitter service is a singleton emitter instance registered
  * to the container. It provides type-safe event emission and listening.
- *
- * @example
- * // Using emitter service to emit events
- * export default class UserController {
- *   async store({ emitter }: { emitter: EmitterService }) {
- *     const user = await User.create(data)
- *     emitter.emit('user:created', { user })
- *   }
- * }
  */
 export interface EmitterService extends Emitter<EventsList> {
 }
 /**
- * Encryption service is a singleton Encryption class instance
- * registered to the container. It provides encryption and decryption
- * functionality using the application's secret key.
- *
- * @example
- * // Using encryption service
- * export default class PaymentController {
- *   async process({ encryption }: { encryption: EncryptionService }) {
- *     const encrypted = encryption.encrypt('sensitive-data')
- *     const decrypted = encryption.decrypt(encrypted)
- *   }
- * }
+ * Encryption service is a singleton instance of the EncryptionManager
+ * registered in the container. It provides encryption and decryption
+ * functionality with support for multiple encryptors.
  */
-export interface EncryptionService extends Encryption {
+export interface EncryptionService extends EncryptionManager<EncryptorsList extends Record<string, EncryptionConfig> ? EncryptorsList : never> {
 }
 /**
  * Http server service added to the container as a singleton.
  * It provides access to the HTTP server instance for handling
  * requests and responses.
- *
- * @example
- * // Accessing server service in middleware
- * export default class CustomMiddleware {
- *   async handle({ server }: { server: HttpServerService }, next: NextFn) {
- *     console.log('Server listening on:', server.getPort())
- *     return next()
- *   }
- * }
  */
 export interface HttpServerService extends Server {
 }
@@ -210,14 +190,6 @@ export interface HttpServerService extends Server {
  * Http router service added to the container as a singleton.
  * It provides access to the application's router for defining
  * and managing routes.
- *
- * @example
- * // Using router service to define routes programmatically
- * export default class RouteProvider {
- *   boot({ router }: { router: HttpRouterService }) {
- *     router.get('/api/health', () => ({ status: 'ok' }))
- *   }
- * }
  */
 export interface HttpRouterService extends Router {
 }
@@ -225,49 +197,20 @@ export interface HttpRouterService extends Router {
  * Url builder service offers a type-safe API for creating URLs
  * for pre-registered routes. It ensures type safety when building
  * URLs with parameters.
- *
- * @example
- * // Using URL builder service
- * export default class PostController {
- *   async show({ urlBuilder }: { urlBuilder: UrlBuilderService }) {
- *     const postUrl = urlBuilder.make('posts.show', { id: 1 })
- *     const userUrl = urlBuilder.make('users.profile', { username: 'john' })
- *   }
- * }
  */
-export interface UrlBuilderService extends UrlFor<RoutesList extends LookupList ? RoutesList : never, URLOptions> {
+export interface UrlBuilderUrlFor extends UrlFor<RoutesList extends LookupList ? RoutesList : never, URLOptions> {
 }
 /**
  * Url builder service offers a type-safe API for creating signed URLs
  * for pre-registered routes. Signed URLs include a signature that prevents
  * tampering and can have expiration times.
- *
- * @example
- * // Using signed URL builder service
- * export default class FileController {
- *   async getDownloadUrl({ signedUrlBuilder }: { signedUrlBuilder: SignedUrlBuilderService }) {
- *     const signedUrl = signedUrlBuilder.make('files.download',
- *       { id: 1 },
- *       { expiresIn: '1h' }
- *     )
- *   }
- * }
  */
-export interface SignedUrlBuilderService extends UrlFor<RoutesList extends LookupList ? RoutesList : never, SignedURLOptions> {
+export interface UrlBuilderSignedUrlFor extends UrlFor<RoutesList extends LookupList ? RoutesList : never, SignedURLOptions> {
 }
 /**
  * Hash service is a singleton instance of the HashManager
  * registered in the container. It provides password hashing
  * and verification functionality.
- *
- * @example
- * // Using hash service for password management
- * export default class AuthController {
- *   async register({ hash }: { hash: HashService }) {
- *     const hashedPassword = await hash.make('user-password')
- *     const isValid = await hash.verify(hashedPassword, 'user-password')
- *   }
- * }
  */
 export interface HashService extends HashManager<HashersList extends Record<string, ManagerDriverFactory> ? HashersList : never> {
 }
@@ -275,16 +218,6 @@ export interface HashService extends HashManager<HashersList extends Record<stri
  * A list of known container bindings. This interface defines
  * all the services that are registered in the IoC container
  * and available for dependency injection.
- *
- * @example
- * // Accessing container bindings in a service
- * export default class UserService {
- *   constructor(
- *     private logger: LoggerService,
- *     private hash: HashService,
- *     private emitter: EmitterService
- *   ) {}
- * }
  */
 export interface ContainerBindings {
     /** Ace command-line kernel */
@@ -349,6 +282,8 @@ export type IndexEntitiesConfig = {
         importAlias?: string;
         /** Glob patterns for matching controller files */
         glob?: string[];
+        /** Path segments to skip from generated keys. Defaults to ['controllers'] */
+        skipSegments?: string[];
     };
     /** Configuration for listeners indexing */
     listeners?: {
@@ -360,6 +295,8 @@ export type IndexEntitiesConfig = {
         importAlias?: string;
         /** Glob patterns for matching listener files */
         glob?: string[];
+        /** Path segments to skip from generated keys. Defaults to ['listeners'] */
+        skipSegments?: string[];
     };
     /** Configuration for events indexing */
     events?: {
@@ -371,11 +308,28 @@ export type IndexEntitiesConfig = {
         importAlias?: string;
         /** Glob patterns for matching event files */
         glob?: string[];
+        /** Path segments to skip from generated keys. Defaults to ['events'] */
+        skipSegments?: string[];
     };
+    /** Configuration for transformers indexing */
     transformers?: {
+        /** Whether to enable transformers indexing */
         enabled?: boolean;
+        /** Whether to include shared props in transformers */
+        withSharedProps?: boolean;
+        /** Source directory for transformers */
         source?: string;
+        /** Import alias for transformers */
         importAlias?: string;
+        /** Glob patterns for matching transformer files */
         glob?: string[];
+        /** Path segments to skip from generated keys. Defaults to ['transformers'] */
+        skipSegments?: string[];
+    };
+    /** Configuration for manifest generation */
+    manifest?: {
+        /** Whether to enable manifest generation */
+        enabled?: boolean;
+        exclude?: string[];
     };
 };