@adonisjs/core 5.9.0 → 6.0.0-0

package/build/index.js

@@ -0,0 +1,21 @@
+import { errors as aceErrors } from '@adonisjs/ace';
+import { errors as envErrors } from '@adonisjs/env';
+import { errors as appErrors } from '@adonisjs/application';
+import { errors as encryptionErrors } from '@adonisjs/encryption';
+import { errors as httpServerErrors } from '@adonisjs/http-server';
+export { stubsRoot } from './stubs/index.js';
+export { inject } from './modules/container.js';
+export { Ignitor } from './src/ignitor/main.js';
+export const errors = {
+    ...encryptionErrors,
+    ...httpServerErrors,
+    ...appErrors,
+    ...aceErrors,
+    ...envErrors,
+};
+export async function prettyPrintError(error) {
+    const { default: youchTerminal } = await import('youch-terminal');
+    const { default: Youch } = await import('youch');
+    const youch = new Youch(error, {});
+    console.error(youchTerminal(await youch.toJSON(), { displayShortPath: true }));
+}

package/build/legacy/validator.d.ts

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

package/build/legacy/validator.js

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

package/build/modules/ace/commands.d.ts

@@ -0,0 +1,26 @@
+import { BaseCommand as AceBaseCommand, ListCommand as AceListCommand } from '@adonisjs/ace';
+import { Kernel } from './kernel.js';
+import type { ApplicationService } from '../../src/types.js';
+import type { CommandOptions, ParsedOutput, UIPrimitives } from '../../types/ace.js';
+export declare class BaseCommand extends AceBaseCommand {
+    app: ApplicationService;
+    kernel: Kernel;
+    static options: CommandOptions;
+    get staysAlive(): boolean | undefined;
+    get startApp(): boolean | undefined;
+    constructor(app: ApplicationService, kernel: Kernel, parsed: ParsedOutput, ui: UIPrimitives, prompt: Kernel['prompt']);
+    prepare?(..._: any[]): any;
+    interact?(..._: any[]): any;
+    completed?(..._: any[]): any;
+    exec(): Promise<any>;
+    terminate(): Promise<void>;
+}
+export declare class ListCommand extends AceListCommand implements BaseCommand {
+    app: ApplicationService;
+    kernel: Kernel;
+    static options: CommandOptions;
+    get staysAlive(): boolean | undefined;
+    get startApp(): boolean | undefined;
+    constructor(app: ApplicationService, kernel: Kernel, parsed: ParsedOutput, ui: UIPrimitives, prompt: Kernel['prompt']);
+    terminate(): Promise<void>;
+}

package/build/modules/ace/commands.js

@@ -0,0 +1,63 @@
+import { BaseCommand as AceBaseCommand, ListCommand as AceListCommand } from '@adonisjs/ace';
+export class BaseCommand extends AceBaseCommand {
+    app;
+    kernel;
+    static options = {};
+    get staysAlive() {
+        return this.constructor.options.staysAlive;
+    }
+    get startApp() {
+        return this.constructor.options.startApp;
+    }
+    constructor(app, kernel, parsed, ui, prompt) {
+        super(kernel, parsed, ui, prompt);
+        this.app = app;
+        this.kernel = kernel;
+    }
+    async exec() {
+        this.hydrate();
+        try {
+            this.prepare && (await this.app.container.call(this, 'prepare'));
+            this.interact && (await this.app.container.call(this, 'interact'));
+            this.result = await this.app.container.call(this, 'run');
+            this.exitCode = this.exitCode ?? 0;
+        }
+        catch (error) {
+            this.error = error;
+            this.exitCode = this.exitCode ?? 1;
+        }
+        let errorHandled = this.completed
+            ? await this.app.container.call(this, 'completed')
+            : false;
+        if (this.error && !errorHandled) {
+            this.logger.fatal(this.error);
+        }
+        return this.result;
+    }
+    async terminate() {
+        if (this.kernel.getMainCommand() === this) {
+            await this.app.terminate();
+        }
+    }
+}
+export class ListCommand extends AceListCommand {
+    app;
+    kernel;
+    static options = {};
+    get staysAlive() {
+        return this.constructor.options.staysAlive;
+    }
+    get startApp() {
+        return this.constructor.options.startApp;
+    }
+    constructor(app, kernel, parsed, ui, prompt) {
+        super(kernel, parsed, ui, prompt);
+        this.app = app;
+        this.kernel = kernel;
+    }
+    async terminate() {
+        if (this.kernel.getMainCommand() === this) {
+            await this.app.terminate();
+        }
+    }
+}

package/build/modules/ace/create_kernel.d.ts

@@ -0,0 +1,3 @@
+import { Kernel } from './main.js';
+import type { ApplicationService } from '../../src/types.js';
+export declare function createAceKernel(app: ApplicationService): Kernel;

package/build/modules/ace/create_kernel.js

@@ -0,0 +1,33 @@
+import { Kernel } from './main.js';
+import { FsLoader, HelpCommand } from '../../modules/ace/main.js';
+export function createAceKernel(app) {
+    const kernel = new Kernel(app);
+    kernel.addLoader(new FsLoader(app.commandsPath()));
+    app.rcFile.commands.forEach((commandModule) => {
+        kernel.addLoader(() => app.import(commandModule));
+    });
+    kernel.defineFlag('ansi', {
+        type: 'boolean',
+        showNegatedVariantInHelp: true,
+        description: 'Force enable or disable colorful output',
+    });
+    kernel.defineFlag('help', {
+        type: 'boolean',
+        description: HelpCommand.description,
+    });
+    kernel.on('ansi', (_, $kernel, parsed) => {
+        if (parsed.flags.ansi === false) {
+            $kernel.ui.switchMode('silent');
+        }
+        if (parsed.flags.ansi === true) {
+            $kernel.ui.switchMode('normal');
+        }
+    });
+    kernel.on('help', async (command, $kernel, parsed) => {
+        parsed.args.unshift(command.commandName);
+        const help = new HelpCommand($kernel, parsed, kernel.ui, kernel.prompt);
+        await help.exec();
+        return $kernel.shortcircuit();
+    });
+    return kernel;
+}

package/build/modules/ace/kernel.d.ts

@@ -0,0 +1,7 @@
+import { Kernel as AceKernel } from '@adonisjs/ace';
+import { BaseCommand } from './commands.js';
+import type { ApplicationService } from '../../src/types.js';
+export declare class Kernel extends AceKernel<typeof BaseCommand> {
+    app: ApplicationService;
+    constructor(app: ApplicationService);
+}

package/build/modules/ace/kernel.js

@@ -0,0 +1,14 @@
+import { Kernel as AceKernel } from '@adonisjs/ace';
+import { ListCommand } from './commands.js';
+export class Kernel extends AceKernel {
+    app;
+    constructor(app) {
+        super(ListCommand, {
+            create: async (command, parsedOutput, $kernel) => {
+                return app.container.make(command, [app, $kernel, parsedOutput, $kernel.ui, $kernel.prompt]);
+            },
+            run: (command) => command.exec(),
+        });
+        this.app = app;
+    }
+}

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

@@ -0,0 +1,3 @@
+export { Kernel } from './kernel.js';
+export { BaseCommand, ListCommand } from './commands.js';
+export { args, flags, errors, Parser, FsLoader, ListLoader, HelpCommand } from '@adonisjs/ace';

package/build/modules/ace/main.js

@@ -0,0 +1,3 @@
+export { Kernel } from './kernel.js';
+export { BaseCommand, ListCommand } from './commands.js';
+export { args, flags, errors, Parser, FsLoader, ListLoader, HelpCommand } from '@adonisjs/ace';

package/build/modules/app.d.ts

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

package/build/modules/app.js

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

package/build/modules/bodyparser/bodyparser_middleware.d.ts

@@ -0,0 +1,2 @@
+import { BodyParserMiddleware } from '@adonisjs/bodyparser/bodyparser_middleware';
+export default BodyParserMiddleware;

package/build/modules/bodyparser/bodyparser_middleware.js

@@ -0,0 +1,2 @@
+import { BodyParserMiddleware } from '@adonisjs/bodyparser/bodyparser_middleware';
+export default BodyParserMiddleware;

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

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

package/build/modules/bodyparser/main.js

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

package/build/modules/config.d.ts

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

package/build/modules/config.js

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

package/build/modules/container.d.ts

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

package/build/modules/container.js

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

package/build/modules/encryption.d.ts

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

package/build/modules/encryption.js

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

package/build/modules/env.d.ts

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

package/build/modules/env.js

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

package/build/modules/events.d.ts

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

package/build/modules/events.js

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

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

@@ -0,0 +1,15 @@
+import type { HashDriversList } from '../../src/types.js';
+import type { ManagerDriverFactory } from '../../types/hash.js';
+export declare function defineConfig<KnownHashers extends Record<string, {
+    [K in keyof HashDriversList]: {
+        driver: K;
+    } & Parameters<HashDriversList[K]>[0];
+}[keyof HashDriversList]>>(config: {
+    default?: keyof KnownHashers;
+    list: KnownHashers;
+}): {
+    default?: keyof KnownHashers;
+    list: {
+        [K in keyof KnownHashers]: ManagerDriverFactory;
+    };
+};

package/build/modules/hash/define_config.js

@@ -0,0 +1,19 @@
+import { InvalidArgumentsException } from '@poppinss/utils';
+import driversCollection from './drivers_collection.js';
+export function defineConfig(config) {
+    if (!config.list) {
+        throw new InvalidArgumentsException('Missing "list" property in hash config');
+    }
+    if (config.default && !config.list[config.default]) {
+        throw new InvalidArgumentsException(`Missing "list.${String(config.default)}" in hash config. It is referenced by the "default" property`);
+    }
+    const managerHashers = Object.keys(config.list).reduce((result, disk) => {
+        const hasherConfig = config.list[disk];
+        result[disk] = () => driversCollection.create(hasherConfig.driver, hasherConfig);
+        return result;
+    }, {});
+    return {
+        default: config.default,
+        list: managerHashers,
+    };
+}

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

@@ -0,0 +1,9 @@
+import { Argon, Bcrypt, Scrypt } from './main.js';
+import type { HashDriversList } from '../../src/types.js';
+declare class HashDriversCollection {
+    list: Partial<HashDriversList>;
+    extend<Name extends keyof HashDriversList>(driverName: Name, factoryCallback: HashDriversList[Name]): this;
+    create<Name extends keyof HashDriversList>(name: Name, config: Parameters<HashDriversList[Name]>[0]): Bcrypt | Argon | Scrypt;
+}
+declare const hashDriversCollection: HashDriversCollection;
+export default hashDriversCollection;

package/build/modules/hash/drivers_collection.js

@@ -0,0 +1,22 @@
+import { Argon, Bcrypt, Scrypt } from './main.js';
+import { RuntimeException } from '@poppinss/utils';
+class HashDriversCollection {
+    list = {
+        bcrypt: (config) => new Bcrypt(config),
+        argon2: (config) => new Argon(config),
+        scrypt: (config) => new Scrypt(config),
+    };
+    extend(driverName, factoryCallback) {
+        this.list[driverName] = factoryCallback;
+        return this;
+    }
+    create(name, config) {
+        const driverFactory = this.list[name];
+        if (!driverFactory) {
+            throw new RuntimeException(`Unknown hash driver "${String(name)}". Make sure the driver is registered`);
+        }
+        return driverFactory(config);
+    }
+}
+const hashDriversCollection = new HashDriversCollection();
+export default hashDriversCollection;

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

@@ -0,0 +1,2 @@
+export * from '@adonisjs/hash';
+export { defineConfig } from './define_config.js';

package/build/modules/hash/main.js

@@ -0,0 +1,2 @@
+export * from '@adonisjs/hash';
+export { defineConfig } from './define_config.js';

package/build/modules/http.d.ts

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

package/build/modules/http.js

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

package/build/modules/logger.d.ts

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

package/build/modules/logger.js

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

package/build/providers/app_provider.d.ts

@@ -0,0 +1,16 @@
+import type { ApplicationService } from '../src/types.js';
+export default class AppServiceProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    protected registerTestUtils(): void;
+    protected registerAce(): void;
+    protected registerApp(): void;
+    protected registerLogger(): void;
+    protected registerLoggerManager(): void;
+    protected registerConfig(): void;
+    protected registerEmitter(): void;
+    protected registerEncryption(): void;
+    protected configureValidator(): Promise<void>;
+    register(): void;
+    boot(): Promise<void>;
+}

package/build/providers/app_provider.js

@@ -0,0 +1,74 @@
+import { Config } from '../modules/config.js';
+import { Emitter } from '../modules/events.js';
+import { validator } from '../legacy/validator.js';
+import { Encryption } from '../modules/encryption.js';
+import { Logger, LoggerManager } from '../modules/logger.js';
+export default class AppServiceProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    registerTestUtils() {
+        this.app.container.singleton('testUtils', async () => {
+            const { TestUtils } = await import('../src/test_utils/main.js');
+            return new TestUtils(this.app);
+        });
+    }
+    registerAce() {
+        this.app.container.singleton('ace', async () => {
+            const { createAceKernel } = await import('../modules/ace/create_kernel.js');
+            return createAceKernel(this.app);
+        });
+    }
+    registerApp() {
+        this.app.container.singleton('app', () => this.app);
+    }
+    registerLogger() {
+        this.app.container.singleton(Logger, async (resolver) => {
+            const loggerManager = await resolver.make('logger');
+            return loggerManager.use();
+        });
+    }
+    registerLoggerManager() {
+        const LoggerServiceManager = LoggerManager;
+        this.app.container.singleton(LoggerServiceManager, () => {
+            const config = this.app.config.get('logger');
+            return new LoggerManager(config);
+        });
+        this.app.container.alias('logger', LoggerServiceManager);
+    }
+    registerConfig() {
+        this.app.container.singleton(Config, () => this.app.config);
+        this.app.container.alias('config', Config);
+    }
+    registerEmitter() {
+        this.app.container.singleton(Emitter, () => {
+            return new Emitter(this.app);
+        });
+        this.app.container.alias('emitter', Emitter);
+    }
+    registerEncryption() {
+        this.app.container.singleton(Encryption, () => {
+            const appKey = this.app.config.get('app.appKey');
+            return new Encryption({ secret: appKey });
+        });
+        this.app.container.alias('encryption', Encryption);
+    }
+    async configureValidator() {
+        const config = await this.app.container.make('config');
+        validator.configure(config.get('validator', {}));
+    }
+    register() {
+        this.registerApp();
+        this.registerAce();
+        this.registerLoggerManager();
+        this.registerLogger();
+        this.registerConfig();
+        this.registerEmitter();
+        this.registerEncryption();
+        this.registerTestUtils();
+    }
+    async boot() {
+        await this.configureValidator();
+    }
+}

package/build/providers/hash_provider.d.ts

@@ -0,0 +1,9 @@
+import type { ApplicationService } from '../src/types.js';
+export default class HashServiceProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    protected registerHashDrivers(): void;
+    protected registerHash(): void;
+    protected registerHashManager(): void;
+    register(): void;
+}

package/build/providers/hash_provider.js

@@ -0,0 +1,29 @@
+import { Hash, HashManager } from '../modules/hash/main.js';
+import hashDriversCollection from '../modules/hash/drivers_collection.js';
+export default class HashServiceProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    registerHashDrivers() {
+        this.app.container.singleton('hashDrivers', () => hashDriversCollection);
+    }
+    registerHash() {
+        this.app.container.singleton(Hash, async (resolver) => {
+            const hashManager = await resolver.make('hash');
+            return hashManager.use();
+        });
+    }
+    registerHashManager() {
+        this.app.container.singleton(HashManager, async () => {
+            const config = this.app.config.get('hash');
+            return new HashManager(config);
+        });
+        this.app.container.alias('hash', HashManager);
+    }
+    register() {
+        this.registerHashManager();
+        this.registerHashDrivers();
+        this.registerHash();
+    }
+}

package/build/providers/http_provider.d.ts

@@ -0,0 +1,9 @@
+import type { ApplicationService } from '../src/types.js';
+export default class HttpServiceProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    protected registerServer(): void;
+    protected registerRouter(): void;
+    protected registerBodyParserMiddleware(): void;
+    register(): void;
+}

package/build/providers/http_provider.js

@@ -0,0 +1,36 @@
+import { Router, Server } from '../modules/http.js';
+import BodyParserMiddleware from '../modules/bodyparser/bodyparser_middleware.js';
+export default class HttpServiceProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    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);
+    }
+    registerRouter() {
+        this.app.container.singleton(Router, async (resolver) => {
+            const server = await resolver.make('server');
+            return server.getRouter();
+        });
+        this.app.container.alias('router', Router);
+    }
+    registerBodyParserMiddleware() {
+        this.app.container.bind(BodyParserMiddleware, () => {
+            const config = this.app.config.get('bodyparser');
+            return new BodyParserMiddleware(config);
+        });
+    }
+    register() {
+        this.registerServer();
+        this.registerRouter();
+        this.registerBodyParserMiddleware();
+    }
+}

package/build/services/ace.d.ts

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

package/build/services/ace.js

@@ -0,0 +1,6 @@
+import app from './app.js';
+let ace;
+await app.booted(async () => {
+    ace = await app.container.make('ace');
+});
+export { ace as default };

package/build/services/app.d.ts

@@ -1,12 +1,4 @@
-/// <reference path="../adonis-typings/container.d.ts" />
-/// <reference types="@adonisjs/application/build/adonis-typings/application" />
-/// <reference types="@adonisjs/drive/build/adonis-typings/container" />
-/// <reference types="@adonisjs/http-server/build/adonis-typings/container" />
-/// <reference types="@adonisjs/events/build/adonis-typings/container" />
-/// <reference types="@adonisjs/hash/build/adonis-typings/container" />
-/// <reference types="@adonisjs/encryption/build/adonis-typings/container" />
-/// <reference types="@adonisjs/validator/build/adonis-typings/container" />
-/// <reference types="@adonisjs/repl/build/adonis-typings/container" />
-/// <reference types="@japa/preset-adonis/build/adonis-typings/container" />
-declare const _default: import("@ioc:Adonis/Core/Application").ApplicationContract;
-export default _default;
+import type { ApplicationService } from '../src/types.js';
+declare let app: ApplicationService;
+export declare function setApp(appService: ApplicationService): void;
+export { app as default };

package/build/services/app.js

@@ -1,12 +1,5 @@
-"use strict";
-/*
- * @adonisjs/core
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("./base");
-exports.default = (0, base_1.getApp)();
+let app;
+export function setApp(appService) {
+    app = appService;
+}
+export { app as default };

package/build/services/config.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="@adonisjs/config/build/adonis-typings/config" />
-declare const _default: import("@ioc:Adonis/Core/Config").ConfigContract;
-export default _default;
+import type { ApplicationService } from '../src/types.js';
+declare let config: ApplicationService['config'];
+export { config as default };

package/build/services/config.js

@@ -1,12 +1,6 @@
-"use strict";
-/*
- * @adonisjs/core
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("./base");
-exports.default = (0, base_1.getApp)().container.resolveBinding('Adonis/Core/Config');
+import app from './app.js';
+let config;
+await app.booted(() => {
+    config = app.config;
+});
+export { config as default };

package/build/services/emitter.d.ts

@@ -0,0 +1,3 @@
+import type { EmitterService } from '../src/types.js';
+declare let emitter: EmitterService;
+export { emitter as default };

package/build/services/emitter.js

@@ -0,0 +1,7 @@
+import app from './app.js';
+import { Emitter } from '../modules/events.js';
+let emitter;
+await app.booted(async () => {
+    emitter = await app.container.make(Emitter);
+});
+export { emitter as default };

package/build/services/encryption.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="@adonisjs/encryption/build/adonis-typings/encryption" />
-declare const _default: import("@ioc:Adonis/Core/Encryption").EncryptionContract;
-export default _default;
+import type { EncryptionService } from '../src/types.js';
+declare let encryption: EncryptionService;
+export { encryption as default };