@adonisjs/core 6.1.5-3 → 6.1.5-31

package/build/src/internal_helpers.js

@@ -1,32 +1,60 @@
-import fs from 'node:fs';
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { existsSync } from 'node:fs';
+/**
+ * Imports assembler optionally
+ */
 export async function importAssembler(app) {
     try {
         return await app.import('@adonisjs/assembler');
     }
     catch { }
 }
+/**
+ * Imports typescript optionally
+ */
 export async function importTypeScript(app) {
     try {
         return await app.importDefault('typescript');
     }
     catch { }
 }
+/**
+ * Generates an array of filenames with different JavaScript
+ * extensions for the given filename
+ */
+function generateJsFilenames(filename) {
+    const extensions = ['.js', '.ts', '.cjs', '.mjs', '.cts', '.mts'];
+    return extensions.map((extension) => filename + extension);
+}
+/**
+ * Detects the assets bundler in use. The rcFile.assetsBundler is
+ * used when exists.
+ */
 export async function detectAssetsBundler(app) {
     if (app.rcFile.assetsBundler) {
         return app.rcFile.assetsBundler;
     }
-    if (fs.existsSync(app.makePath('vite.config.js'))) {
+    const possibleViteConfigFiles = generateJsFilenames('vite.config');
+    if (possibleViteConfigFiles.some((config) => existsSync(app.makePath(config)))) {
         return {
             name: 'vite',
-            devServerCommand: 'vite',
-            buildCommand: 'vite build',
+            devServer: { command: 'vite' },
+            build: { command: 'vite', args: ['build'] },
         };
     }
-    if (fs.existsSync(app.makePath('webpack.config.js'))) {
+    const possibleEncoreConfigFiles = generateJsFilenames('webpack.config');
+    if (possibleEncoreConfigFiles.some((config) => existsSync(app.makePath(config)))) {
         return {
             name: 'encore',
-            devServerCommand: 'encore dev-server',
-            buildCommand: 'encore',
+            devServer: { command: 'encore', args: ['dev-server'] },
+            build: { command: 'encore', args: ['production'] },
         };
     }
 }

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

@@ -3,9 +3,16 @@
 import type { TestUtils } from './main.js';
 import type { Server as NodeHttpsServer } from 'node:https';
 import { IncomingMessage, ServerResponse, Server as NodeHttpServer } from 'node:http';
+/**
+ * Http server utils are used to start the AdonisJS HTTP server
+ * during testing
+ */
 export declare class HttpServerUtils {
     #private;
     constructor(utils: TestUtils);
+    /**
+     * Testing hook to start the HTTP server to listen for new request.
+     * The return value is a function to close the HTTP server.
+     */
     start(serverCallback?: (handler: (req: IncomingMessage, res: ServerResponse) => any) => NodeHttpsServer | NodeHttpServer): Promise<() => Promise<void>>;
 }
-//# sourceMappingURL=http.d.ts.map

package/build/src/test_utils/http.js

@@ -1,10 +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 debug from '../debug.js';
 import { createServer } from 'node:http';
+/**
+ * Http server utils are used to start the AdonisJS HTTP server
+ * during testing
+ */
 export class HttpServerUtils {
     #utils;
     constructor(utils) {
         this.#utils = utils;
     }
+    /**
+     * Starts the http server a given host and port
+     */
     #listen(nodeHttpServer) {
         return new Promise((resolve, reject) => {
             const host = process.env.HOST || '0.0.0.0';
@@ -19,6 +34,10 @@ export class HttpServerUtils {
             });
         });
     }
+    /**
+     * Testing hook to start the HTTP server to listen for new request.
+     * The return value is a function to close the HTTP server.
+     */
     async start(serverCallback) {
         const createHTTPServer = serverCallback || createServer;
         const server = await this.#utils.app.container.make('server');

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

@@ -2,19 +2,36 @@
 import Macroable from '@poppinss/macroable';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { HttpServerUtils } from './http.js';
-import { CookieClient } from '../../modules/http.js';
 import type { ApplicationService } from '../types.js';
+import { CookieClient, type HttpContext } from '../../modules/http/main.js';
+/**
+ * Test utils has a collection of helper methods to make testing
+ * experience great for AdonisJS applications
+ */
 export declare class TestUtils extends Macroable {
     #private;
     app: ApplicationService;
+    /**
+     * Check if utils have been booted
+     */
     get isBooted(): boolean;
     cookies: CookieClient;
     constructor(app: ApplicationService);
+    /**
+     * Boot test utils. It requires the app to be booted
+     * and container to have all the bindings
+     */
     boot(): Promise<void>;
+    /**
+     * Returns an instance of the HTTP server testing
+     * utils
+     */
     httpServer(): HttpServerUtils;
+    /**
+     * Create an instance of HTTP context for testing
+     */
     createHttpContext(options?: {
         req?: IncomingMessage;
         res?: ServerResponse;
-    }): Promise<import("../../modules/http.js").HttpContext>;
+    }): Promise<HttpContext>;
 }
-//# sourceMappingURL=main.d.ts.map

package/build/src/test_utils/main.js

@@ -1,11 +1,26 @@
+/*
+ * @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.js';
+import { CookieClient } from '../../modules/http/main.js';
+/**
+ * Test utils has a collection of helper methods to make testing
+ * experience great for AdonisJS applications
+ */
 export class TestUtils extends Macroable {
     app;
     #booted = false;
+    /**
+     * Check if utils have been booted
+     */
     get isBooted() {
         return this.#booted;
     }
@@ -13,15 +28,26 @@ export class TestUtils extends Macroable {
         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
+     */
     async createHttpContext(options = {}) {
         const req = options.req || new IncomingMessage(new Socket());
         const res = options.res || new ServerResponse(req);

package/build/src/types.d.ts

@@ -1,19 +1,37 @@
+import type { Repl } from '../modules/repl.js';
 import type { Importer } from '../types/app.js';
 import type { Emitter } from '../modules/events.js';
 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 { Router, Server } from '../modules/http.js';
 import type { LoggerManager } from '../modules/logger.js';
+import type { HashManager } from '../modules/hash/main.js';
 import type { Encryption } from '../modules/encryption.js';
+import type { ManagerDriverFactory } from '../types/hash.js';
+import type { Router, Server } from '../modules/http/main.js';
 import type { HttpRequestFinishedPayload } from '../types/http.js';
 import type { ContainerResolveEventData } from '../types/container.js';
 import type { LoggerConfig, LoggerManagerConfig } from '../types/logger.js';
-import type { Argon, Bcrypt, HashManager, Scrypt } from '../modules/hash/main.js';
-import type { ArgonConfig, BcryptConfig, ScryptConfig, ManagerDriverFactory } from '../types/hash.js';
+/**
+ * A config provider waits for the application to get booted
+ * and then resolves the config. It receives an instance
+ * of the application service.
+ */
+export type ConfigProvider<T> = {
+    type: 'provider';
+    resolver: (app: ApplicationService) => Promise<T>;
+};
+/**
+ * Options accepted by ignitor
+ */
 export type IgnitorOptions = {
     importer: Importer;
 };
+/**
+ * A list of known events. The interface must be extended in
+ * user land code or packages to register events and their
+ * types.
+ */
 export interface EventsList {
     'container:resolved': ContainerResolveEventData<ContainerBindings>;
     'http:request_handled': HttpRequestFinishedPayload;
@@ -22,33 +40,73 @@ export interface EventsList {
         host: string;
     };
 }
+/**
+ * The loggers list inferred from the user application
+ * config
+ */
 export interface LoggersList {
 }
 export type InferLoggers<T extends LoggerManagerConfig<any>> = T['loggers'];
-export interface HashDriversList {
-    bcrypt: (config: BcryptConfig) => Bcrypt;
-    argon2: (config: ArgonConfig) => Argon;
-    scrypt: (config: ScryptConfig) => Scrypt;
-}
+/**
+ * A list of known hashers inferred from the user config
+ */
 export interface HashersList {
 }
-export type InferHashers<T extends {
+export type InferHashers<T extends ConfigProvider<{
     list: Record<string, ManagerDriverFactory>;
-}> = T['list'];
+}>> = Awaited<ReturnType<T['resolver']>>['list'];
+/**
+ * ----------------------------------------------------------------
+ * Container services
+ * -----------------------------------------------------------------
+ *
+ * Types for the container singleton services. Defining them
+ * upfront so that we do not have to define them in
+ * multiple places.
+ */
+/**
+ * Application service is a singleton resolved from
+ * the container
+ */
 export interface ApplicationService extends Application<ContainerBindings extends Record<any, any> ? ContainerBindings : never> {
 }
+/**
+ * Logger service is a singleton logger instance registered
+ * to the container.
+ */
 export interface LoggerService extends LoggerManager<LoggersList extends Record<string, LoggerConfig> ? LoggersList : never> {
 }
+/**
+ * Emitter service is a singleton emitter instance registered
+ * to the container.
+ */
 export interface EmitterService extends Emitter<EventsList> {
 }
+/**
+ * Encryption service is a singleton Encryption class instance
+ * registered to the container.
+ */
 export interface EncryptionService extends Encryption {
 }
+/**
+ * Http server service added to the container as a singleton
+ */
 export interface HttpServerService extends Server {
 }
+/**
+ * Http server service added to the container as a singleton
+ */
 export interface HttpRouterService extends Router {
 }
+/**
+ * Hash service is a singleton instance of the HashManager
+ * registered in the container
+ */
 export interface HashService extends HashManager<HashersList extends Record<string, ManagerDriverFactory> ? HashersList : never> {
 }
+/**
+ * A list of known container bindings.
+ */
 export interface ContainerBindings {
     ace: Kernel;
     app: ApplicationService;
@@ -60,5 +118,5 @@ export interface ContainerBindings {
     server: HttpServerService;
     router: HttpRouterService;
     testUtils: TestUtils;
+    repl: Repl;
 }
-//# sourceMappingURL=types.d.ts.map

package/build/src/types.js

@@ -1 +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 {};

package/build/stubs/{index.d.ts → main.d.ts}

@@ -1,2 +1 @@
 export declare const stubsRoot: string;
-//# sourceMappingURL=index.d.ts.map

package/{factories/app.ts → build/stubs/main.js}

@@ -6,5 +6,5 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
-export * from '@adonisjs/application/factories'
+import { getDirname } from '@poppinss/utils';
+export const stubsRoot = getDirname(import.meta.url);

package/build/stubs/make/command/main.stub

@@ -1,11 +1,13 @@
 {{#var commandName = generators.commandName(entity.name)}}
 {{#var commandTerminalName = generators.commandTerminalName(entity.name)}}
 {{#var commandFileName = generators.commandFileName(entity.name)}}
----
-to: {{ app.commandsPath(entity.path, commandFileName) }}
----
+{{{
+  exports({
+    to: app.commandsPath(entity.path, commandFileName)
+  })
+}}}
 import { BaseCommand } from '@adonisjs/core/ace'
-import { CommandOptions } from '@adonisjs/core/types/ace'
+import type { CommandOptions } from '@adonisjs/core/types/ace'
 
 export default class {{ commandName }} extends BaseCommand {
   static commandName = '{{ commandTerminalName }}'

package/build/stubs/make/controller/api.stub

@@ -1,9 +1,11 @@
 {{#var controllerName = generators.controllerName(entity.name)}}
 {{#var controllerFileName = generators.controllerFileName(entity.name)}}
----
-to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
----
-import { HttpContext } from '@adonisjs/core/http'
+{{{
+  exports({
+    to: app.httpControllersPath(entity.path, controllerFileName)
+  })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
 
 export default class {{ controllerName }} {
   /**

package/build/stubs/make/controller/main.stub

@@ -1,9 +1,11 @@
 {{#var controllerName = generators.controllerName(entity.name)}}
 {{#var controllerFileName = generators.controllerFileName(entity.name)}}
----
-to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
----
-// import { HttpContext } from '@adonisjs/core/http'
+{{{
+  exports({
+    to: app.httpControllersPath(entity.path, controllerFileName)
+  })
+}}}
+// import type { HttpContext } from '@adonisjs/core/http'
 
 export default class {{ controllerName }} {
 }

package/build/stubs/make/controller/resource.stub

@@ -1,9 +1,11 @@
 {{#var controllerName = generators.controllerName(entity.name)}}
 {{#var controllerFileName = generators.controllerFileName(entity.name)}}
----
-to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
----
-import { HttpContext } from '@adonisjs/core/http'
+{{{
+  exports({
+    to: app.httpControllersPath(entity.path, controllerFileName)
+  })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
 
 export default class {{ controllerName }} {
   /**

package/build/stubs/make/event/main.stub

@@ -1,8 +1,10 @@
 {{#var eventName = generators.eventName(entity.name)}}
 {{#var eventFileName = generators.eventFileName(entity.name)}}
----
-to: {{ app.eventsPath(entity.path, eventFileName) }}
----
+{{{
+  exports({
+    to: app.eventsPath(entity.path, eventFileName)
+  })
+}}}
 import { BaseEvent } from '@adonisjs/core/events'
 
 export default class {{ eventName }} extends BaseEvent {

package/build/stubs/make/exception/main.stub

@@ -0,0 +1,12 @@
+{{#var exceptionName = generators.exceptionName(entity.name)}}
+{{#var exceptionFileName = generators.exceptionFileName(entity.name)}}
+{{{
+  exports({
+    to: app.exceptionsPath(entity.path, exceptionFileName)
+  })
+}}}
+import { Exception } from '@adonisjs/core/exceptions'
+
+export default class {{ exceptionName }} extends Exception {
+  static status = 500
+}

package/build/stubs/make/listener/for_event.stub

@@ -3,10 +3,12 @@
 {{#var eventName = generators.eventName(event.name)}}
 {{#var eventFileName = generators.eventFileName(event.name)}}
 {{#var eventImportPath = generators.importPath('#events', event.path, eventFileName)}}
----
-to: {{ app.listenersPath(entity.path, listenerFileName) }}
----
-import {{ eventName }} from '{{ eventImportPath }}'
+{{{
+  exports({
+    to: app.listenersPath(entity.path, listenerFileName)
+  })
+}}}
+import type {{ eventName }} from '{{ eventImportPath }}'
 
 export default class {{ listenerName }} {
   async handle(event: {{ eventName }}) {}

package/build/stubs/make/listener/main.stub

@@ -1,7 +1,9 @@
 {{#var listenerName = generators.listenerName(entity.name)}}
 {{#var listenerFileName = generators.listenerFileName(entity.name)}}
----
-to: {{ app.listenersPath(entity.path, listenerFileName) }}
----
+{{{
+  exports({
+    to: app.listenersPath(entity.path, listenerFileName)
+  })
+}}}
 export default class {{ listenerName }} {
 }

package/build/stubs/make/middleware/main.stub

@@ -1,10 +1,12 @@
 {{#var middlewareName = generators.middlewareName(entity.name)}}
 {{#var middlewareFileName = generators.middlewareFileName(entity.name)}}
----
-to: {{ app.middlewarePath(entity.path, middlewareFileName) }}
----
-import { HttpContext } from '@adonisjs/core/http'
-import { NextFn } from '@adonisjs/core/types/http'
+{{{
+  exports({
+    to: app.middlewarePath(entity.path, middlewareFileName)
+  })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
+import type { NextFn } from '@adonisjs/core/types/http'
 
 export default class {{ middlewareName }} {
   async handle(ctx: HttpContext, next: NextFn) {

package/build/stubs/make/preload_file/main.stub

@@ -1,4 +1,6 @@
 {{#var preloadFileName = string(entity.name).snakeCase().removeExtension().ext('.ts').toString()}}
----
-to: {{ app.startPath(entity.path, preloadFileName) }}
----
+{{{
+  exports({
+    to: app.startPath(entity.path, preloadFileName)
+  })
+}}}

package/build/stubs/make/provider/main.stub

@@ -1,9 +1,11 @@
 {{#var providerName = generators.providerName(entity.name)}}
 {{#var providerFileName = generators.providerFileName(entity.name)}}
----
-to: {{ app.providersPath(entity.path, providerFileName) }}
----
-import { ApplicationService } from '@adonisjs/core/types'
+{{{
+  exports({
+    to: app.providersPath(entity.path, providerFileName)
+  })
+}}}
+import type { ApplicationService } from '@adonisjs/core/types'
 
 export default class {{ providerName }} {
   constructor(protected app: ApplicationService) {}

package/build/stubs/make/service/main.stub

@@ -1,4 +1,6 @@
 {{#var serviceFileName = generators.serviceFileName(entity.name)}}
----
-to: {{ app.servicesPath(entity.path, serviceFileName) }}
----
+{{{
+  exports({
+    to: app.servicesPath(entity.path, serviceFileName)
+  })
+}}}

package/build/stubs/make/test/main.stub

@@ -1,8 +1,10 @@
 {{#var testGroupName = generators.testGroupName(entity)}}
 {{#var testFileName = generators.testFileName(entity.name)}}
----
-to: {{ app.makePath(suite.directory, entity.path, testFileName) }}
----
+{{{
+  exports({
+    to: app.makePath(suite.directory, entity.path, testFileName)
+  })
+}}}
 import { test } from '@japa/runner'
 
 test.group('{{ testGroupName }}', () => {

package/build/stubs/make/validator/main.stub

@@ -0,0 +1,7 @@
+{{#var validatorFileName = generators.validatorFileName(entity.name)}}
+{{{
+  exports({
+    to: app.validatorsPath(entity.path, validatorFileName)
+  })
+}}}
+import vine from '@vinejs/vine'

package/build/stubs/make/view/main.stub

@@ -0,0 +1,6 @@
+{{#var viewFileName = generators.viewFileName(entity.name)}}
+{{{
+  exports({
+    to: app.viewsPath(entity.path, viewFileName)
+  })
+}}}

package/build/toolkit/commands/index_commands.d.ts

@@ -1,8 +1,11 @@
 import { BaseCommand } from '@adonisjs/ace';
+/**
+ * Generates index of commands with a loader. Must be called against
+ * the TypeScript compiled output.
+ */
 export default class IndexCommand extends BaseCommand {
     static commandName: string;
     static description: string;
     commandsDir: string;
     run(): Promise<any>;
 }
-//# sourceMappingURL=index_commands.d.ts.map

package/build/toolkit/commands/index_commands.js

@@ -1,15 +1,24 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 import { join } from 'node:path';
 import { args, BaseCommand, IndexGenerator } from '@adonisjs/ace';
-class IndexCommand extends BaseCommand {
+/**
+ * Generates index of commands with a loader. Must be called against
+ * the TypeScript compiled output.
+ */
+export default class IndexCommand extends BaseCommand {
     static commandName = 'index';
     static description = 'Create an index of commands along with a lazy loader';
     async run() {
@@ -17,7 +26,5 @@ class IndexCommand extends BaseCommand {
     }
 }
 __decorate([
-    args.string({ description: 'Relative path from cwd to the commands directory' }),
-    __metadata("design:type", String)
+    args.string({ description: 'Relative path from cwd to the commands directory' })
 ], IndexCommand.prototype, "commandsDir", void 0);
-export default IndexCommand;

package/build/toolkit/main.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=main.d.ts.map