@adonisjs/core 6.1.5-2 → 6.1.5-21

package/build/providers/hash_provider.d.ts

@@ -1,9 +1,29 @@
-import type { ApplicationService } from '../src/types.js';
+import type { ApplicationService, HashDriversList } from '../src/types.js';
+/**
+ * Registers the passwords hasher with the container
+ */
 export default class HashServiceProvider {
     protected app: ApplicationService;
     constructor(app: ApplicationService);
-    protected registerHashDrivers(): void;
+    /**
+     * Lazily registers a hash driver with the driversList collection
+     */
+    protected registerHashDrivers(driversInUse: Set<keyof HashDriversList>): Promise<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;
+    /**
+     * Register drivers based upon hash config
+     */
+    boot(): void;
 }

package/build/providers/hash_provider.js

@@ -1,29 +1,71 @@
-import { Hash, HashManager } from '../modules/hash/main.js';
-import hashDriversCollection from '../modules/hash/drivers_collection.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 { Hash, driversList } from '../modules/hash/main.js';
+/**
+ * Registers the passwords hasher with the container
+ */
 export default class HashServiceProvider {
     app;
     constructor(app) {
         this.app = app;
     }
-    registerHashDrivers() {
-        this.app.container.singleton('hashDrivers', () => hashDriversCollection);
+    /**
+     * Lazily registers a hash driver with the driversList collection
+     */
+    async registerHashDrivers(driversInUse) {
+        if (driversInUse.has('bcrypt')) {
+            const { Bcrypt } = await import('../modules/hash/drivers/bcrypt.js');
+            driversList.extend('bcrypt', (config) => new Bcrypt(config));
+        }
+        if (driversInUse.has('scrypt')) {
+            const { Scrypt } = await import('../modules/hash/drivers/scrypt.js');
+            driversList.extend('scrypt', (config) => new Scrypt(config));
+        }
+        if (driversInUse.has('argon2')) {
+            const { Argon } = await import('../modules/hash/drivers/argon.js');
+            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(HashManager, async () => {
+        this.app.container.singleton('hash', async () => {
             const config = this.app.config.get('hash');
+            const { HashManager } = await import('../modules/hash/main.js');
             return new HashManager(config);
         });
-        this.app.container.alias('hash', HashManager);
     }
+    /**
+     * Registers bindings
+     */
     register() {
         this.registerHashManager();
-        this.registerHashDrivers();
         this.registerHash();
     }
+    /**
+     * Register drivers based upon hash config
+     */
+    boot() {
+        this.app.container.resolving('hash', async () => {
+            const config = this.app.config.get('hash');
+            await this.registerHashDrivers(config.driversInUse);
+        });
+    }
 }

package/build/providers/http_provider.d.ts

@@ -1,9 +1,26 @@
 import type { ApplicationService } from '../src/types.js';
+/**
+ * Http Service provider binds the router and the HTTP server to
+ * the container.
+ */
 export default class HttpServiceProvider {
     protected app: ApplicationService;
     constructor(app: ApplicationService);
+    /**
+     * 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;
 }

package/build/providers/http_provider.js

@@ -1,10 +1,25 @@
-import { Router, Server } from '../modules/http.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 { Router, Server } from '../modules/http/main.js';
 import BodyParserMiddleware from '../modules/bodyparser/bodyparser_middleware.js';
+/**
+ * Http Service provider binds the router and the HTTP server to
+ * the container.
+ */
 export default class HttpServiceProvider {
     app;
     constructor(app) {
         this.app = app;
     }
+    /**
+     * Registers the HTTP server with the container as a singleton
+     */
     registerServer() {
         this.app.container.singleton(Server, async (resolver) => {
             const encryption = await resolver.make('encryption');
@@ -15,6 +30,9 @@ export default class HttpServiceProvider {
         });
         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');
@@ -22,12 +40,19 @@ export default class HttpServiceProvider {
         });
         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.registerServer();
         this.registerRouter();

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 {};

package/build/providers/vinejs_provider.js

@@ -0,0 +1,84 @@
+/*
+ * @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';
+import { Request, RequestValidator } from '../modules/http/main.js';
+/**
+ * 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);
+});
+/**
+ * The validate method can be used to validate the request
+ * data for the current request using VineJS validators
+ */
+Request.macro('validateUsing', function (...args) {
+    return new RequestValidator(this.ctx).validateUsing(...args);
+});

package/build/services/ace.js

@@ -1,5 +1,20 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
 let ace;
+/**
+ * Returns a singleton instance of the ace kernel
+ * from the container.
+ *
+ * ace service is an instance of the "Kernel" class stored inside
+ * the "modules/ace/kernel.ts" file
+ */
 await app.booted(async () => {
     ace = await app.container.make('ace');
 });

package/build/services/app.d.ts

@@ -1,4 +1,12 @@
 import type { ApplicationService } from '../src/types.js';
 declare let app: ApplicationService;
+/**
+ * Set the application instance the app service should
+ * be using. Other services relies on the same app
+ * instance as well.
+ *
+ * app service is an instance of the "Application" exported from
+ * the "modules/app.ts" file.
+ */
 export declare function setApp(appService: ApplicationService): void;
 export { app as default };

package/build/services/app.js

@@ -1,4 +1,20 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 let app;
+/**
+ * Set the application instance the app service should
+ * be using. Other services relies on the same app
+ * instance as well.
+ *
+ * app service is an instance of the "Application" exported from
+ * the "modules/app.ts" file.
+ */
 export function setApp(appService) {
     app = appService;
 }

package/build/services/config.js

@@ -1,5 +1,16 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
 let config;
+/**
+ * The config service uses the config instance from the app service
+ */
 await app.booted(() => {
     config = app.config;
 });

package/build/services/emitter.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { Emitter } from '../modules/events.js';
 let emitter;
+/**
+ * Returns a singleton instance of the emitter class
+ * from the container
+ */
 await app.booted(async () => {
-    emitter = await app.container.make(Emitter);
+    emitter = await app.container.make('emitter');
 });
 export { emitter as default };

package/build/services/encryption.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { Encryption } from '../modules/encryption.js';
 let encryption;
+/**
+ * Returns a singleton instance of the encryption class
+ * from the container
+ */
 await app.booted(async () => {
-    encryption = await app.container.make(Encryption);
+    encryption = await app.container.make('encryption');
 });
 export { encryption as default };

package/build/services/hash.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { HashManager } from '../modules/hash/main.js';
 let hash;
+/**
+ * Returns a singleton instance of the Hash manager from the
+ * container
+ */
 await app.booted(async () => {
-    hash = await app.container.make(HashManager);
+    hash = await app.container.make('hash');
 });
 export { hash as default };

package/build/services/logger.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { LoggerManager } from '@adonisjs/logger';
 let logger;
+/**
+ * Returns a singleton instance of the logger class
+ * from the container
+ */
 await app.booted(async () => {
-    logger = (await app.container.make(LoggerManager));
+    logger = await app.container.make('logger');
 });
 export { logger as default };

package/build/services/repl.d.ts

@@ -0,0 +1,3 @@
+import type { Repl } from '../modules/repl.js';
+declare let repl: Repl;
+export { repl as default };

package/build/services/repl.js

@@ -0,0 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import app from './app.js';
+let repl;
+/**
+ * Returns a singleton instance of the Repl class from
+ * the container
+ */
+await app.booted(async () => {
+    repl = await app.container.make('repl');
+});
+export { repl as default };

package/build/services/router.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { Router } from '../modules/http.js';
 let router;
+/**
+ * Returns a singleton instance of the router class from
+ * the container
+ */
 await app.booted(async () => {
-    router = await app.container.make(Router);
+    router = await app.container.make('router');
 });
 export { router as default };

package/build/services/server.js

@@ -1,7 +1,18 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
-import { Server } from '../modules/http.js';
 let server;
+/**
+ * Returns a singleton instance of the HTTP server
+ * from the container
+ */
 await app.booted(async () => {
-    server = await app.container.make(Server);
+    server = await app.container.make('server');
 });
 export { server as default };

package/build/services/test_utils.js

@@ -1,5 +1,20 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import app from './app.js';
 let testUtils;
+/**
+ * Returns a singleton instance of the TestUtils class
+ * from the container.
+ *
+ * testUtils service is an instance of the "TestUtils" exported from
+ * the "src/test_utils/main.ts" file.
+ */
 await app.booted(async () => {
     testUtils = await app.container.make('testUtils');
 });