@adonisjs/core 6.1.5-8 → 6.2.0

package/build/modules/hash/drivers/scrypt.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.
+ */
+export * from '@adonisjs/hash/drivers/scrypt';

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

@@ -1,3 +1,2 @@
 export * from '@adonisjs/hash';
-export { defineConfig } from './define_config.js';
-export { default as driversList } from './drivers_collection.js';
+export { defineConfig, drivers } from './define_config.js';

package/build/modules/hash/main.js

@@ -7,5 +7,4 @@
  * file that was distributed with this source code.
  */
 export * from '@adonisjs/hash';
-export { defineConfig } from './define_config.js';
-export { default as driversList } from './drivers_collection.js';
+export { defineConfig, drivers } from './define_config.js';

package/build/modules/hash/phc_formatter.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/hash/phc_formatter';

package/build/modules/hash/phc_formatter.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.
+ */
+export * from '@adonisjs/hash/phc_formatter';

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

@@ -0,0 +1,7 @@
+/**
+ * Bodyparser import is needed to merge types of Request
+ * class augmented by the bodyparser package
+ */
+import '@adonisjs/bodyparser';
+export * from '@adonisjs/http-server';
+export { RequestValidator } from './request_validator.js';

package/build/modules/http/main.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.
+ */
+/**
+ * Bodyparser import is needed to merge types of Request
+ * class augmented by the bodyparser package
+ */
+import '@adonisjs/bodyparser';
+export * from '@adonisjs/http-server';
+export { RequestValidator } from './request_validator.js';

package/build/modules/http/request_validator.d.ts

@@ -0,0 +1,34 @@
+import type { VineValidator } from '@vinejs/vine';
+import type { Infer, SchemaTypes, ErrorReporterContract, MessagesProviderContact } from '@vinejs/vine/types';
+import type { HttpContext } from './main.js';
+import type { RequestValidationOptions } from '../../types/http.js';
+/**
+ * Request validator is used validate HTTP request data using
+ * VineJS validators. You may validate the request body,
+ * files, cookies, and headers.
+ */
+export declare class RequestValidator {
+    #private;
+    constructor(ctx: HttpContext);
+    /**
+     * The error reporter method returns the error reporter
+     * to use for reporting errors.
+     *
+     * You can use this function to pick a different error reporter
+     * for each HTTP request
+     */
+    static errorReporter?: (_: HttpContext) => ErrorReporterContract;
+    /**
+     * The messages provider method returns the messages provider to use
+     * finding custom error messages
+     *
+     * You can use this function to pick a different messages provider for
+     * each HTTP request
+     */
+    static messagesProvider?: (_: HttpContext) => MessagesProviderContact;
+    /**
+     * The validate method can be used to validate the request
+     * data for the current request using VineJS validators
+     */
+    validateUsing<Schema extends SchemaTypes, MetaData extends undefined | Record<string, any>>(validator: VineValidator<Schema, MetaData>, ...[options]: [undefined] extends MetaData ? [options?: RequestValidationOptions<MetaData> | undefined] : [options: RequestValidationOptions<MetaData>]): Promise<Infer<Schema>>;
+}

package/build/modules/http/request_validator.js

@@ -0,0 +1,66 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Request validator is used validate HTTP request data using
+ * VineJS validators. You may validate the request body,
+ * files, cookies, and headers.
+ */
+export class RequestValidator {
+    #ctx;
+    constructor(ctx) {
+        this.#ctx = ctx;
+    }
+    /**
+     * The error reporter method returns the error reporter
+     * to use for reporting errors.
+     *
+     * You can use this function to pick a different error reporter
+     * for each HTTP request
+     */
+    static errorReporter;
+    /**
+     * The messages provider method returns the messages provider to use
+     * finding custom error messages
+     *
+     * You can use this function to pick a different messages provider for
+     * each HTTP request
+     */
+    static messagesProvider;
+    /**
+     * The validate method can be used to validate the request
+     * data for the current request using VineJS validators
+     */
+    validateUsing(validator, ...[options]) {
+        const validatorOptions = options || {};
+        /**
+         * Assign request specific error reporter
+         */
+        if (RequestValidator.errorReporter && !validatorOptions.errorReporter) {
+            const errorReporter = RequestValidator.errorReporter(this.#ctx);
+            validatorOptions.errorReporter = () => errorReporter;
+        }
+        /**
+         * Assign request specific messages provider
+         */
+        if (RequestValidator.messagesProvider && !validatorOptions.messagesProvider) {
+            validatorOptions.messagesProvider = RequestValidator.messagesProvider(this.#ctx);
+        }
+        /**
+         * Data to validate
+         */
+        const data = validatorOptions.data || {
+            ...this.#ctx.request.all(),
+            ...this.#ctx.request.allFiles(),
+            params: this.#ctx.request.params(),
+            headers: this.#ctx.request.headers(),
+            cookies: this.#ctx.request.cookiesList(),
+        };
+        return validator.validate(data, validatorOptions);
+    }
+}

package/build/providers/app_provider.d.ts

@@ -38,8 +38,22 @@ export default class AppServiceProvider {
      * Register the encryption service to the container
      */
     protected registerEncryption(): void;
+    /**
+     * Registers the HTTP server with the container as a singleton
+     */
+    protected registerServer(): void;
+    /**
+     * Registers router with the container as a singleton
+     */
+    protected registerRouter(): void;
+    /**
+     * Self construct bodyparser middleware class, since it needs
+     * config that cannot be resolved by the container
+     */
+    protected registerBodyParserMiddleware(): void;
     /**
      * Registers bindings
      */
     register(): void;
+    boot(): Promise<void>;
 }

package/build/providers/app_provider.js

@@ -8,7 +8,11 @@
  */
 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 { Encryption } from '../modules/encryption.js';
+import { Router, Server } from '../modules/http/main.js';
+import BodyParserMiddleware from '../modules/bodyparser/bodyparser_middleware.js';
 /**
  * The Application Service provider registers all the baseline
  * features required to run the framework.
@@ -40,7 +44,8 @@ export default class AppServiceProvider {
      * Registers the application to the container
      */
     registerApp() {
-        this.app.container.singleton('app', () => this.app);
+        this.app.container.singleton(Application, () => this.app);
+        this.app.container.alias('app', Application);
     }
     /**
      * Registers the logger class to resolve the default logger
@@ -72,10 +77,10 @@ export default class AppServiceProvider {
      * Registers emitter service to the container
      */
     registerEmitter() {
-        this.app.container.singleton('emitter', async () => {
-            const { Emitter } = await import('../modules/events.js');
+        this.app.container.singleton(Emitter, async () => {
             return new Emitter(this.app);
         });
+        this.app.container.alias('emitter', Emitter);
     }
     /**
      * Register the encryption service to the container
@@ -87,6 +92,39 @@ export default class AppServiceProvider {
         });
         this.app.container.alias('encryption', Encryption);
     }
+    /**
+     * Registers the HTTP server with the container as a singleton
+     */
+    registerServer() {
+        this.app.container.singleton(Server, async (resolver) => {
+            const encryption = await resolver.make('encryption');
+            const emitter = await resolver.make('emitter');
+            const logger = await resolver.make('logger');
+            const config = this.app.config.get('app.http');
+            return new Server(this.app, encryption, emitter, logger, config);
+        });
+        this.app.container.alias('server', Server);
+    }
+    /**
+     * Registers router with the container as a singleton
+     */
+    registerRouter() {
+        this.app.container.singleton(Router, async (resolver) => {
+            const server = await resolver.make('server');
+            return server.getRouter();
+        });
+        this.app.container.alias('router', Router);
+    }
+    /**
+     * Self construct bodyparser middleware class, since it needs
+     * config that cannot be resolved by the container
+     */
+    registerBodyParserMiddleware() {
+        this.app.container.bind(BodyParserMiddleware, () => {
+            const config = this.app.config.get('bodyparser');
+            return new BodyParserMiddleware(config);
+        });
+    }
     /**
      * Registers bindings
      */
@@ -99,5 +137,11 @@ export default class AppServiceProvider {
         this.registerEmitter();
         this.registerEncryption();
         this.registerTestUtils();
+        this.registerServer();
+        this.registerRouter();
+        this.registerBodyParserMiddleware();
+    }
+    async boot() {
+        BaseEvent.useEmitter(await this.app.container.make('emitter'));
     }
 }

package/build/providers/edge_provider.d.ts

@@ -0,0 +1,31 @@
+import { type Edge } from 'edge.js';
+import type { ApplicationService } from '../src/types.js';
+import { type Route } from '../modules/http/main.js';
+declare module '@adonisjs/core/http' {
+    interface HttpContext {
+        /**
+         * Reference to the edge renderer to render templates
+         * during an HTTP request
+         */
+        view: ReturnType<Edge['createRenderer']>;
+    }
+    interface BriskRoute {
+        /**
+         * Render an edge template without defining an
+         * explicit route handler
+         */
+        render(template: string, data?: Record<string, any>): Route;
+    }
+}
+/**
+ * The Edge service provider configures Edge to work within
+ * an AdonisJS application environment
+ */
+export default class EdgeServiceProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    /**
+     * Bridge AdonisJS and Edge
+     */
+    boot(): Promise<void>;
+}

package/build/providers/edge_provider.js

@@ -0,0 +1,70 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import edge from 'edge.js';
+import { BriskRoute, HttpContext } from '../modules/http/main.js';
+/**
+ * The Edge service provider configures Edge to work within
+ * an AdonisJS application environment
+ */
+export default class EdgeServiceProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+        this.app.usingEdgeJS = true;
+    }
+    /**
+     * Bridge AdonisJS and Edge
+     */
+    async boot() {
+        const app = this.app;
+        const router = await this.app.container.make('router');
+        function edgeConfigResolver(key, defaultValue) {
+            return app.config.get(key, defaultValue);
+        }
+        edgeConfigResolver.has = function (key) {
+            return app.config.has(key);
+        };
+        /**
+         * Mount the default disk
+         */
+        edge.mount(app.viewsPath());
+        /**
+         * Cache templates in production
+         */
+        edge.configure({ cache: app.inProduction });
+        /**
+         * Define Edge global helpers
+         */
+        edge.global('route', function (...args) {
+            return router.makeUrl(...args);
+        });
+        edge.global('signedRoute', function (...args) {
+            return router.makeSignedUrl(...args);
+        });
+        edge.global('app', app);
+        edge.global('config', edgeConfigResolver);
+        /**
+         * Creating a isolated instance of edge renderer
+         */
+        HttpContext.getter('view', function () {
+            return edge.createRenderer().share({
+                request: this.request,
+            });
+        }, true);
+        /**
+         * Adding brisk route to render templates without an
+         * explicit handler
+         */
+        BriskRoute.macro('render', function (template, data) {
+            return this.setHandler(({ view }) => {
+                return view.render(template, data);
+            });
+        });
+    }
+}

package/build/providers/hash_provider.d.ts

@@ -5,10 +5,6 @@ import type { ApplicationService } from '../src/types.js';
 export default class HashServiceProvider {
     protected app: ApplicationService;
     constructor(app: ApplicationService);
-    /**
-     * Registering bundled drivers with the driversList collection
-     */
-    protected registerHashDrivers(): void;
     /**
      * Registering the hash class to resolve an instance with the
      * default hasher.

package/build/providers/hash_provider.js

@@ -6,7 +6,9 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { Argon, Bcrypt, Hash, Scrypt, driversList } from '../modules/hash/main.js';
+import { RuntimeException } from '@poppinss/utils';
+import { Hash } from '../modules/hash/main.js';
+import { configProvider } from '../src/config_provider.js';
 /**
  * Registers the passwords hasher with the container
  */
@@ -15,14 +17,6 @@ export default class HashServiceProvider {
     constructor(app) {
         this.app = app;
     }
-    /**
-     * Registering bundled drivers with the driversList collection
-     */
-    registerHashDrivers() {
-        driversList.extend('bcrypt', (config) => new Bcrypt(config));
-        driversList.extend('scrypt', (config) => new Scrypt(config));
-        driversList.extend('argon2', (config) => new Argon(config));
-    }
     /**
      * Registering the hash class to resolve an instance with the
      * default hasher.
@@ -38,8 +32,15 @@ export default class HashServiceProvider {
      */
     registerHashManager() {
         this.app.container.singleton('hash', async () => {
+            const hashConfigProvider = this.app.config.get('hash');
+            /**
+             * Resolve config from the provider
+             */
+            const config = await configProvider.resolve(this.app, hashConfigProvider);
+            if (!config) {
+                throw new RuntimeException('Invalid "config/hash.ts" file. Make sure you are using the "defineConfig" method');
+            }
             const { HashManager } = await import('../modules/hash/main.js');
-            const config = this.app.config.get('hash');
             return new HashManager(config);
         });
     }
@@ -47,7 +48,6 @@ export default class HashServiceProvider {
      * Registers bindings
      */
     register() {
-        this.registerHashDrivers();
         this.registerHashManager();
         this.registerHash();
     }

package/build/providers/repl_provider.js

@@ -6,6 +6,18 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { Repl } from '../modules/repl.js';
+import { fsImportAll } from '@poppinss/utils';
+/**
+ * Resolves a container binding and sets it on the REPL
+ * context
+ */
+async function resolveBindingForRepl(app, repl, binding) {
+    repl.server.context[binding] = await app.container.make(binding);
+    repl.notify(`Loaded "${binding}" service. You can access it using the "${repl.colors.underline(binding)}" variable`);
+}
 export default class ReplServiceProvider {
     app;
     constructor(app) {
@@ -15,19 +27,82 @@ export default class ReplServiceProvider {
      * Registers the REPL binding
      */
     register() {
-        this.app.container.singleton('repl', async () => {
-            const { Repl } = await import('../modules/repl.js');
-            return new Repl();
+        this.app.container.singleton(Repl, async () => {
+            return new Repl({
+                historyFilePath: join(homedir(), '.adonisjs_v6_repl_history'),
+            });
         });
+        this.app.container.alias('repl', Repl);
     }
     /**
      * Registering REPL bindings during provider boot
      */
     async boot() {
-        if (this.app.getEnvironment() === 'repl') {
-            const repl = await this.app.container.make('repl');
-            const { defineReplBindings } = await import('../src/bindings/repl.js');
-            defineReplBindings(this.app, repl);
-        }
+        this.app.container.resolving('repl', (repl) => {
+            repl.addMethod('importDefault', (_, modulePath) => {
+                return this.app.importDefault(modulePath);
+            }, {
+                description: 'Returns the default export for a module',
+            });
+            repl.addMethod('importAll', (_, dirPath) => {
+                return fsImportAll(this.app.makeURL(dirPath), {
+                    ignoreMissingRoot: false,
+                });
+            }, {
+                description: 'Import all files from a directory and assign them to a variable',
+            });
+            repl.addMethod('make', (_, service, runtimeValues) => {
+                return this.app.container.make(service, runtimeValues);
+            }, {
+                description: 'Make class instance using "container.make" method',
+            });
+            repl.addMethod('loadApp', () => {
+                return resolveBindingForRepl(this.app, repl, 'app');
+            }, {
+                description: 'Load "app" service in the REPL context',
+            });
+            repl.addMethod('loadEncryption', () => {
+                return resolveBindingForRepl(this.app, repl, 'encryption');
+            }, {
+                description: 'Load "encryption" service in the REPL context',
+            });
+            repl.addMethod('loadHash', () => {
+                return resolveBindingForRepl(this.app, repl, 'hash');
+            }, {
+                description: 'Load "hash" service in the REPL context',
+            });
+            repl.addMethod('loadRouter', () => {
+                return resolveBindingForRepl(this.app, repl, 'router');
+            }, {
+                description: 'Load "router" service in the REPL context',
+            });
+            repl.addMethod('loadConfig', () => {
+                return resolveBindingForRepl(this.app, repl, 'config');
+            }, {
+                description: 'Load "config" service in the REPL context',
+            });
+            repl.addMethod('loadTestUtils', () => {
+                return resolveBindingForRepl(this.app, repl, 'testUtils');
+            }, {
+                description: 'Load "testUtils" service in the REPL context',
+            });
+            repl.addMethod('loadHelpers', async () => {
+                const { default: isModule } = await import('../src/helpers/is.js');
+                const { default: stringModule } = await import('../src/helpers/string.js');
+                const { base64, cuid, fsReadAll, slash, parseImports } = await import('../src/helpers/main.js');
+                repl.server.context.helpers = {
+                    string: stringModule,
+                    is: isModule,
+                    base64,
+                    cuid,
+                    fsReadAll,
+                    slash,
+                    parseImports,
+                };
+                repl.notify(`Loaded "helpers" module. You can access it using the "${repl.colors.underline('helpers')}" variable`);
+            }, {
+                description: 'Load "helpers" module in the REPL context',
+            });
+        });
     }
 }

package/build/providers/vinejs_provider.d.ts

@@ -0,0 +1,43 @@
+import { BaseLiteralType } from '@vinejs/vine';
+import type { Validation, FieldContext, FieldOptions } from '@vinejs/vine/types';
+import type { MultipartFile, FileValidationOptions } from '@adonisjs/bodyparser/types';
+import type { ApplicationService } from '../src/types.js';
+import { RequestValidator } from '../modules/http/main.js';
+/**
+ * Validation options accepted by the "file" rule
+ */
+export type FileRuleValidationOptions = Partial<FileValidationOptions> | ((field: FieldContext) => Partial<FileValidationOptions>);
+/**
+ * Extend VineJS
+ */
+declare module '@vinejs/vine' {
+    interface Vine {
+        file(options?: FileRuleValidationOptions): VineMultipartFile;
+    }
+}
+/**
+ * Extend HTTP request class
+ */
+declare module '@adonisjs/core/http' {
+    interface Request extends RequestValidator {
+    }
+}
+/**
+ * Represents a multipart file uploaded via multipart/form-data HTTP
+ * request.
+ */
+declare class VineMultipartFile extends BaseLiteralType<MultipartFile, MultipartFile> {
+    #private;
+    constructor(validationOptions?: FileRuleValidationOptions, options?: FieldOptions, validations?: Validation<any>[]);
+    clone(): this;
+}
+/**
+ * The Edge service provider configures Edge to work within
+ * an AdonisJS application environment
+ */
+export default class VineJSServiceProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    boot(): void;
+}
+export {};