@adonisjs/core 6.1.5-0 → 6.1.5-10

package/build/src/ignitor/test.js

@@ -1,13 +1,38 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * The Test runner process is used to start the tests runner process
+ */
 export class TestRunnerProcess {
+    /**
+     * Ignitor reference
+     */
     #ignitor;
+    /**
+     * The callback that configures the tests runner. This callback
+     * runs at the time of starting the app.
+     */
     #configureCallback = () => { };
     constructor(ignitor) {
         this.#ignitor = ignitor;
     }
+    /**
+     * Register a callback that runs after booting the AdonisJS app
+     * and just before the provider's ready hook
+     */
     configure(callback) {
         this.#configureCallback = callback;
         return this;
     }
+    /**
+     * Runs a callback after starting the app
+     */
     async run(callback) {
         const app = this.#ignitor.createApp('test');
         await app.init();

package/build/src/internal_helpers.d.ts

@@ -1,8 +1,15 @@
 import { ApplicationService } from './types.js';
+import { RcFile } from '@adonisjs/application/types';
+/**
+ * Imports assembler optionally
+ */
 export declare function importAssembler(app: ApplicationService): Promise<typeof import('@adonisjs/assembler') | undefined>;
+/**
+ * Imports typescript optionally
+ */
 export declare function importTypeScript(app: ApplicationService): Promise<typeof import('typescript') | undefined>;
-export declare function detectAssetsBundler(app: ApplicationService): Promise<{
-    name: string;
-    devServerCommand: string;
-    buildCommand: string;
-} | undefined>;
+/**
+ * Detects the assets bundler in use. The rcFile.assetsBundler is
+ * used when exists.
+ */
+export declare function detectAssetsBundler(app: ApplicationService): Promise<RcFile['assetsBundler']>;

package/build/src/internal_helpers.js

@@ -1,32 +1,60 @@
-import fs from 'fs-extra';
+/*
+ * @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 (await fs.exists(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 (await fs.exists(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

@@ -1,10 +1,18 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="@types/node" resolution-mode="require"/>
+/// <reference types="@types/node" resolution-mode="require"/>
 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>>;
 }

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

@@ -1,19 +1,37 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="@types/node" resolution-mode="require"/>
 import Macroable from '@poppinss/macroable';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { HttpServerUtils } from './http.js';
+import { CookieClient } from '../../modules/http/main.js';
 import type { ApplicationService } from '../types.js';
-import { CookieClient } from '../../modules/http.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<import("../../modules/http/main.js").HttpContext>;
 }

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,53 +1,111 @@
+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 { Encryption } from '../modules/encryption.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 hashDriversCollection from '../modules/hash/drivers_collection.js';
 import type { Argon, Bcrypt, HashManager, Scrypt } from '../modules/hash/main.js';
 import type { ArgonConfig, BcryptConfig, ScryptConfig, ManagerDriverFactory } from '../types/hash.js';
+/**
+ * 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;
     'http:server_ready': {
         port: number;
         host: string;
     };
 }
+/**
+ * The loggers list inferred from the user application
+ * config
+ */
 export interface LoggersList {
 }
 export type InferLoggers<T extends LoggerManagerConfig<any>> = T['loggers'];
+/**
+ * A list of globally available hash drivers
+ */
 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 {
     list: Record<string, ManagerDriverFactory>;
 }> = T['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;
@@ -56,8 +114,8 @@ export interface ContainerBindings {
     emitter: EmitterService;
     encryption: EncryptionService;
     hash: HashService;
-    hashDrivers: typeof hashDriversCollection;
     server: HttpServerService;
     router: HttpRouterService;
     testUtils: TestUtils;
+    repl: Repl;
 }

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/src/vinejs/extensions/main.d.ts

@@ -0,0 +1 @@
+import './validates_files.js';

package/build/src/vinejs/extensions/main.js

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

package/build/src/vinejs/extensions/validates_files.d.ts

@@ -0,0 +1,22 @@
+import { BaseLiteralType } from '@vinejs/vine';
+import type { FieldContext, FieldOptions, Validation } from '@vinejs/vine/types';
+import type { MultipartFile, FileValidationOptions } from '@adonisjs/bodyparser/types';
+type ValidationOptions = Partial<FileValidationOptions> | ((field: FieldContext) => Partial<FileValidationOptions>);
+/**
+ * Represents a multipart file uploaded via multipart/form-data HTTP
+ * request.
+ */
+declare class VineMultipartFile extends BaseLiteralType<MultipartFile, MultipartFile> {
+    #private;
+    constructor(validationOptions?: ValidationOptions, options?: FieldOptions, validations?: Validation<any>[]);
+    clone(): this;
+}
+/**
+ * Notifying TypeScript
+ */
+declare module '@vinejs/vine' {
+    interface Vine {
+        file(options?: ValidationOptions): VineMultipartFile;
+    }
+}
+export {};

package/build/src/vinejs/extensions/validates_files.js

@@ -0,0 +1,76 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import vine, { BaseLiteralType, Vine } from '@vinejs/vine';
+/**
+ * Checks if the value is an instance of multipart file
+ * from bodyparser.
+ */
+function isBodyParserFile(file) {
+    return !!(file && typeof file === 'object' && 'isMultipartFile' in file);
+}
+/**
+ * VineJS validation rule that validates the file to be an
+ * instance of BodyParser MultipartFile class.
+ */
+const isMultipartFile = vine.createRule((file, options, field) => {
+    /**
+     * Report error when value is not a field multipart
+     * file object
+     */
+    if (!isBodyParserFile(file)) {
+        field.report('The {{ field }} must be a file', 'file', field);
+        return;
+    }
+    const validationOptions = typeof options === 'function' ? options(field) : options;
+    /**
+     * Set size when it's defined in the options and missing
+     * on the file instance
+     */
+    if (file.sizeLimit === undefined && validationOptions.size) {
+        file.sizeLimit = validationOptions.size;
+    }
+    /**
+     * Set extensions when it's defined in the options and missing
+     * on the file instance
+     */
+    if (file.allowedExtensions === undefined && validationOptions.extnames) {
+        file.allowedExtensions = validationOptions.extnames;
+    }
+    /**
+     * Validate file
+     */
+    file.validate();
+    /**
+     * Report errors
+     */
+    file.errors.forEach((error) => {
+        field.report(error.message, `file.${error.type}`, field, validationOptions);
+    });
+});
+/**
+ * Represents a multipart file uploaded via multipart/form-data HTTP
+ * request.
+ */
+class VineMultipartFile extends BaseLiteralType {
+    #validationOptions;
+    constructor(validationOptions, options, validations) {
+        super(options, validations || [isMultipartFile(validationOptions || {})]);
+        this.#validationOptions = validationOptions;
+    }
+    clone() {
+        return new VineMultipartFile(this.#validationOptions, this.cloneOptions(), this.cloneValidations());
+    }
+}
+/**
+ * The file method is used to validate a field to be a valid
+ * multipart file.
+ */
+Vine.macro('file', function (options) {
+    return new VineMultipartFile(options);
+});

package/build/stubs/index.js

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

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

@@ -0,0 +1,10 @@
+{{#var exceptionName = generators.exceptionName(entity.name)}}
+{{#var exceptionFileName = generators.exceptionFileName(entity.name)}}
+---
+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/preload_file/main.stub

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

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

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

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

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

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

@@ -1,4 +1,8 @@
 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;

package/build/toolkit/commands/index_commands.js

@@ -1,14 +1,23 @@
+/*
+ * @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';
+/**
+ * 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';
@@ -17,6 +26,5 @@ export default 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);

package/build/toolkit/main.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import IndexCommand from './commands/index_commands.js';
 import { Kernel, ListLoader, HelpCommand } from '@adonisjs/ace';
 const kernel = Kernel.create();
@@ -7,6 +15,9 @@ kernel.defineFlag('help', {
     type: 'boolean',
     description: HelpCommand.description,
 });
+/**
+ * Flag listener to display the help
+ */
 kernel.on('help', async (command, $kernel, parsed) => {
     parsed.args.unshift(command.commandName);
     const help = new HelpCommand($kernel, parsed, kernel.ui, kernel.prompt);

package/build/types/ace.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 * from '@adonisjs/ace/types';

package/build/types/app.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 * from '@adonisjs/application/types';