@adonisjs/core 6.1.5-2 → 6.1.5-20

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,35 @@
+/*
+ * @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';
+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');
+        const { defineReplBindings } = await import('../src/bindings/repl.js');
+        defineReplBindings(this.app, repl);
+    }
+}

package/build/providers/vinejs_provider.d.ts

@@ -0,0 +1,5 @@
+import '../src/bindings/vinejs/main.js';
+import '../src/bindings/vinejs/types.js';
+import '../modules/http/request_validator.js';
+export default class VineJSServiceProvider {
+}

package/build/providers/vinejs_provider.js

@@ -0,0 +1,13 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import '../src/bindings/vinejs/main.js';
+import '../src/bindings/vinejs/types.js';
+import '../modules/http/request_validator.js';
+export default class VineJSServiceProvider {
+}

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');
 });

package/build/src/bindings/edge/main.d.ts

@@ -0,0 +1,7 @@
+import './types.js';
+import type { ApplicationService } from '../../types.js';
+import { type Router } from '../../../modules/http/main.js';
+/**
+ * Bridges AdonisJS with Edge
+ */
+export declare function bridgeEdgeAdonisJS(app: ApplicationService, router: Router): void;

package/build/src/bindings/edge/main.js

@@ -0,0 +1,58 @@
+/*
+ * @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 './types.js';
+import { HttpContext, BriskRoute } from '../../../modules/http/main.js';
+/**
+ * Bridges AdonisJS with Edge
+ */
+export function bridgeEdgeAdonisJS(app, 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,
+        });
+    });
+    /**
+     * 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/src/bindings/edge/types.d.ts

@@ -0,0 +1,18 @@
+import { type Edge } from 'edge.js';
+import type { Route } from '../../../modules/http/main.js';
+declare module '@adonisjs/http-server' {
+    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;
+    }
+}

package/build/src/bindings/edge/types.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 {};

package/build/src/bindings/repl.d.ts

@@ -0,0 +1,6 @@
+import type { Repl } from '../../modules/repl.js';
+import { ApplicationService } from '../types.js';
+/**
+ * Registers REPL methods
+ */
+export declare function defineReplBindings(app: ApplicationService, repl: Repl): void;

package/build/src/bindings/repl.js

@@ -0,0 +1,78 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * 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`);
+}
+/**
+ * Registers REPL methods
+ */
+export function defineReplBindings(app, repl) {
+    repl.addMethod('importDefault', (_, modulePath) => {
+        return app.importDefault(modulePath);
+    }, {
+        description: 'Returns the default export for a module',
+    });
+    repl.addMethod('make', (_, service, runtimeValues) => {
+        return app.container.make(service, runtimeValues);
+    }, {
+        description: 'Make class instance using "container.make" method',
+    });
+    repl.addMethod('loadApp', () => {
+        return resolveBindingForRepl(app, repl, 'app');
+    }, {
+        description: 'Load "app" service in the REPL context',
+    });
+    repl.addMethod('loadEncryption', () => {
+        return resolveBindingForRepl(app, repl, 'encryption');
+    }, {
+        description: 'Load "encryption" service in the REPL context',
+    });
+    repl.addMethod('loadHash', () => {
+        return resolveBindingForRepl(app, repl, 'hash');
+    }, {
+        description: 'Load "hash" service in the REPL context',
+    });
+    repl.addMethod('loadRouter', () => {
+        return resolveBindingForRepl(app, repl, 'router');
+    }, {
+        description: 'Load "router" service in the REPL context',
+    });
+    repl.addMethod('loadConfig', () => {
+        return resolveBindingForRepl(app, repl, 'config');
+    }, {
+        description: 'Load "config" service in the REPL context',
+    });
+    repl.addMethod('loadTestUtils', () => {
+        return resolveBindingForRepl(app, repl, 'testUtils');
+    }, {
+        description: 'Load "testUtils" service in the REPL context',
+    });
+    repl.addMethod('loadHelpers', async () => {
+        const { default: isModule } = await import('../helpers/is.js');
+        const { default: stringModule } = await import('../helpers/string.js');
+        const { base64, cuid, fsReadAll, slash, parseImports } = await import('../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',
+    });
+}