@adonisjs/core 6.1.5-3 → 6.1.5-31

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/modules/logger.d.ts

@@ -1,2 +1 @@
 export * from '@adonisjs/logger';
-//# sourceMappingURL=logger.d.ts.map

package/build/modules/logger.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/logger';

package/build/modules/repl.d.ts

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

package/{modules/container.ts → build/modules/repl.js}

@@ -6,5 +6,4 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
-export * from '@adonisjs/fold'
+export * from '@adonisjs/repl';

package/build/providers/app_provider.d.ts

@@ -1,17 +1,59 @@
 import type { ApplicationService } from '../src/types.js';
+/**
+ * The Application Service provider registers all the baseline
+ * features required to run the framework.
+ */
 export default class AppServiceProvider {
     protected app: ApplicationService;
     constructor(app: ApplicationService);
+    /**
+     * Registers test utils with the container
+     */
     protected registerTestUtils(): void;
+    /**
+     * Registers ace with the container
+     */
     protected registerAce(): void;
+    /**
+     * Registers the application to the container
+     */
     protected registerApp(): void;
+    /**
+     * Registers the logger class to resolve the default logger
+     */
     protected registerLogger(): void;
+    /**
+     * Registers the logger manager to the container
+     */
     protected registerLoggerManager(): void;
+    /**
+     * Registers the config to the container
+     */
     protected registerConfig(): void;
+    /**
+     * Registers emitter service to the container
+     */
     protected registerEmitter(): void;
+    /**
+     * Register the encryption service to the container
+     */
     protected registerEncryption(): void;
-    protected configureValidator(): Promise<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>;
 }
-//# sourceMappingURL=app_provider.d.ts.map

package/build/providers/app_provider.js

@@ -1,33 +1,62 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import { Config } from '../modules/config.js';
 import { Logger } from '../modules/logger.js';
-import { validator } from '../legacy/validator.js';
+import { BaseEvent } 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.
+ */
 export default class AppServiceProvider {
     app;
     constructor(app) {
         this.app = app;
     }
+    /**
+     * Registers test utils with the container
+     */
     registerTestUtils() {
         this.app.container.singleton('testUtils', async () => {
             const { TestUtils } = await import('../src/test_utils/main.js');
             return new TestUtils(this.app);
         });
     }
+    /**
+     * Registers ace with the container
+     */
     registerAce() {
         this.app.container.singleton('ace', async () => {
             const { createAceKernel } = await import('../modules/ace/create_kernel.js');
             return createAceKernel(this.app);
         });
     }
+    /**
+     * Registers the application to the container
+     */
     registerApp() {
         this.app.container.singleton('app', () => this.app);
     }
+    /**
+     * Registers the logger class to resolve the default logger
+     */
     registerLogger() {
         this.app.container.singleton(Logger, async (resolver) => {
             const loggerManager = await resolver.make('logger');
             return loggerManager.use();
         });
     }
+    /**
+     * Registers the logger manager to the container
+     */
     registerLoggerManager() {
         this.app.container.singleton('logger', async () => {
             const { LoggerManager } = await import('../modules/logger.js');
@@ -35,16 +64,25 @@ export default class AppServiceProvider {
             return new LoggerManager(config);
         });
     }
+    /**
+     * Registers the config to the container
+     */
     registerConfig() {
         this.app.container.singleton(Config, () => this.app.config);
         this.app.container.alias('config', Config);
     }
+    /**
+     * Registers emitter service to the container
+     */
     registerEmitter() {
         this.app.container.singleton('emitter', async () => {
             const { Emitter } = await import('../modules/events.js');
             return new Emitter(this.app);
         });
     }
+    /**
+     * Register the encryption service to the container
+     */
     registerEncryption() {
         this.app.container.singleton(Encryption, () => {
             const appKey = this.app.config.get('app.appKey');
@@ -52,10 +90,42 @@ export default class AppServiceProvider {
         });
         this.app.container.alias('encryption', Encryption);
     }
-    async configureValidator() {
-        const config = await this.app.container.make('config');
-        validator.configure(config.get('validator', {}));
+    /**
+     * 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
+     */
     register() {
         this.registerApp();
         this.registerAce();
@@ -65,8 +135,11 @@ export default class AppServiceProvider {
         this.registerEmitter();
         this.registerEncryption();
         this.registerTestUtils();
+        this.registerServer();
+        this.registerRouter();
+        this.registerBodyParserMiddleware();
     }
     async boot() {
-        await this.configureValidator();
+        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,69 @@
+/*
+ * @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;
+    }
+    /**
+     * 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

@@ -1,10 +1,21 @@
 import type { ApplicationService } from '../src/types.js';
+/**
+ * Registers the passwords hasher with the container
+ */
 export default class HashServiceProvider {
     protected app: ApplicationService;
     constructor(app: ApplicationService);
-    protected registerHashDrivers(): void;
+    /**
+     * Registering the hash class to resolve an instance with the
+     * default hasher.
+     */
     protected registerHash(): void;
+    /**
+     * Registers the hash manager with the container
+     */
     protected registerHashManager(): void;
+    /**
+     * Registers bindings
+     */
     register(): void;
 }
-//# sourceMappingURL=hash_provider.d.ts.map

package/build/providers/hash_provider.js

@@ -1,29 +1,53 @@
-import { Argon, Bcrypt, Hash, Scrypt, driversList } from '../modules/hash/main.js';
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+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
+ */
 export default class HashServiceProvider {
     app;
     constructor(app) {
         this.app = app;
     }
-    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.
+     */
     registerHash() {
         this.app.container.singleton(Hash, async (resolver) => {
             const hashManager = await resolver.make('hash');
             return hashManager.use();
         });
     }
+    /**
+     * Registers the hash manager with the container
+     */
     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);
         });
     }
+    /**
+     * Registers bindings
+     */
     register() {
-        this.registerHashDrivers();
         this.registerHashManager();
         this.registerHash();
     }

package/build/providers/repl_provider.d.ts

@@ -0,0 +1,13 @@
+import type { ApplicationService } from '../src/types.js';
+export default class ReplServiceProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    /**
+     * Registers the REPL binding
+     */
+    register(): void;
+    /**
+     * Registering REPL bindings during provider boot
+     */
+    boot(): Promise<void>;
+}

package/build/providers/repl_provider.js

@@ -0,0 +1,98 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * 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';
+/**
+ * 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) {
+        this.app = app;
+    }
+    /**
+     * Registers the REPL binding
+     */
+    register() {
+        this.app.container.singleton('repl', async () => {
+            const { Repl } = await import('../modules/repl.js');
+            return new Repl({
+                historyFilePath: join(homedir(), '.adonisjs_v6_repl_history'),
+            });
+        });
+    }
+    /**
+     * Registering REPL bindings during provider boot
+     */
+    async boot() {
+        const repl = await this.app.container.make('repl');
+        repl.addMethod('importDefault', (_, modulePath) => {
+            return this.app.importDefault(modulePath);
+        }, {
+            description: 'Returns the default export for a module',
+        });
+        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,33 @@
+import { BaseLiteralType } from '@vinejs/vine';
+import type { Validation, FieldContext, FieldOptions } from '@vinejs/vine/types';
+import type { MultipartFile, FileValidationOptions } from '@adonisjs/bodyparser/types';
+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;
+}
+export {};