@adonisjs/core 5.9.0 → 6.0.1-0

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

package/build/services/encryption.js

@@ -1,12 +1,7 @@
-"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/Encryption');
+import app from './app.js';
+import { Encryption } from '../modules/encryption.js';
+let encryption;
+await app.booted(async () => {
+    encryption = await app.container.make(Encryption);
+});
+export { encryption as default };

package/build/services/hash.d.ts

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

package/build/services/hash.js

@@ -1,12 +1,7 @@
-"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/Hash');
+import app from './app.js';
+import { HashManager } from '../modules/hash/main.js';
+let hash;
+await app.booted(async () => {
+    hash = await app.container.make(HashManager);
+});
+export { hash as default };

package/build/services/logger.d.ts

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

package/build/services/logger.js

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

package/build/services/router.d.ts

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

package/build/services/router.js

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

package/build/services/server.d.ts

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

package/build/services/server.js

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

package/build/services/test_utils.d.ts

@@ -0,0 +1,3 @@
+import type { TestUtils } from '../src/test_utils/main.js';
+declare let testUtils: TestUtils;
+export { testUtils as default };

package/build/services/test_utils.js

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

package/build/src/debug.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+declare const _default: import("util").DebugLogger;
+export default _default;

package/build/src/debug.js

@@ -0,0 +1,2 @@
+import { debuglog } from 'node:util';
+export default debuglog('adonisjs:core');

package/build/src/helpers/is.d.ts

@@ -0,0 +1,2 @@
+import is from '@sindresorhus/is';
+export default is;

package/build/src/helpers/is.js

@@ -0,0 +1,2 @@
+import is from '@sindresorhus/is';
+export default is;

package/build/src/helpers/main.d.ts

@@ -0,0 +1,2 @@
+export { default as cuid } from 'cuid';
+export { safeEqual, compose, base64, fsImportAll, fsReadAll } from '@poppinss/utils';

package/build/src/helpers/main.js

@@ -0,0 +1,2 @@
+export { default as cuid } from 'cuid';
+export { safeEqual, compose, base64, fsImportAll, fsReadAll } from '@poppinss/utils';

package/build/src/helpers/string.d.ts

@@ -0,0 +1,17 @@
+import { EncodeOptions } from 'he';
+import string from '@poppinss/utils/string';
+declare const stringHelpers: typeof string & {
+    ordinalize: (typeof string)['ordinal'];
+    toSentence: (typeof string)['sentence'];
+    generateRandom: (typeof string)['random'];
+    prettyHrTime(time: [number, number], options?: {
+        verbose?: boolean | undefined;
+        precise?: boolean | undefined;
+    }): string;
+    isEmpty(value: string): boolean;
+    escapeHTML(value: string, options?: {
+        encodeSymbols?: boolean;
+    }): string;
+    encodeSymbols(value: string, options?: EncodeOptions): string;
+};
+export default stringHelpers;

package/build/src/helpers/string.js

@@ -0,0 +1,26 @@
+import he from 'he';
+import prettyHrTime from 'pretty-hrtime';
+import string from '@poppinss/utils/string';
+const stringHelpers = {
+    ...string,
+    toSentence: string.sentence,
+    ordinalize: string.ordinal,
+    generateRandom: string.random,
+    prettyHrTime(time, options) {
+        return prettyHrTime(time, options);
+    },
+    isEmpty(value) {
+        return value.trim().length === 0;
+    },
+    escapeHTML(value, options) {
+        value = he.escape(value);
+        if (options && options.encodeSymbols) {
+            value = this.encodeSymbols(value, { allowUnsafeSymbols: true });
+        }
+        return value;
+    },
+    encodeSymbols(value, options) {
+        return he.encode(value, options);
+    },
+};
+export default stringHelpers;

package/build/src/helpers/string_builder.d.ts

@@ -0,0 +1,23 @@
+export declare class StringBuilder {
+    #private;
+    constructor(value: string | StringBuilder);
+    dashCase(): this;
+    dotCase(): this;
+    snakeCase(): this;
+    pascalCase(): this;
+    camelCase(): this;
+    capitalCase(): this;
+    titleCase(): this;
+    sentenceCase(): this;
+    noCase(): this;
+    plural(): this;
+    singular(): this;
+    slugify(): this;
+    removeSuffix(suffix: string): this;
+    suffix(suffix: string): this;
+    removePrefix(prefix: string): this;
+    prefix(prefix: string): this;
+    removeExtension(): this;
+    ext(extension: string): this;
+    toString(): string;
+}

package/build/src/helpers/string_builder.js

@@ -0,0 +1,86 @@
+import { extname } from 'node:path';
+import string from './string.js';
+export class StringBuilder {
+    #value;
+    constructor(value) {
+        this.#value = typeof value === 'string' ? value : value.toString();
+    }
+    dashCase() {
+        this.#value = string.dashCase(this.#value);
+        return this;
+    }
+    dotCase() {
+        this.#value = string.dotCase(this.#value);
+        return this;
+    }
+    snakeCase() {
+        this.#value = string.snakeCase(this.#value);
+        return this;
+    }
+    pascalCase() {
+        this.#value = string.pascalCase(this.#value);
+        return this;
+    }
+    camelCase() {
+        this.#value = string.camelCase(this.#value);
+        return this;
+    }
+    capitalCase() {
+        this.#value = string.capitalCase(this.#value);
+        return this;
+    }
+    titleCase() {
+        this.#value = string.titleCase(this.#value);
+        return this;
+    }
+    sentenceCase() {
+        this.#value = string.sentenceCase(this.#value);
+        return this;
+    }
+    noCase() {
+        this.#value = string.noCase(this.#value);
+        return this;
+    }
+    plural() {
+        this.#value = string.pluralize(this.#value);
+        return this;
+    }
+    singular() {
+        this.#value = string.singular(this.#value);
+        return this;
+    }
+    slugify() {
+        this.#value = string.slug(this.#value);
+        return this;
+    }
+    removeSuffix(suffix) {
+        this.#value = this.#value.replace(new RegExp(`[-_]?${suffix}$`, 'i'), '');
+        return this;
+    }
+    suffix(suffix) {
+        this.removeSuffix(suffix);
+        this.#value = `${this.#value}${suffix}`;
+        return this;
+    }
+    removePrefix(prefix) {
+        this.#value = this.#value.replace(new RegExp(`^${prefix}[-_]?`, 'i'), '');
+        return this;
+    }
+    prefix(prefix) {
+        this.removePrefix(prefix);
+        this.#value = `${prefix}${this.#value}`;
+        return this;
+    }
+    removeExtension() {
+        this.#value = this.#value.replace(new RegExp(`${extname(this.#value)}$`), '');
+        return this;
+    }
+    ext(extension) {
+        this.removeExtension();
+        this.#value = `${this.#value}.${extension.replace(/^\./, '')}`;
+        return this;
+    }
+    toString() {
+        return this.#value;
+    }
+}

package/build/src/helpers/types.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" resolution-mode="require"/>
+import is from '@sindresorhus/is';
+declare const types: {
+    lookup: typeof is;
+    isNull: (value: unknown) => value is null;
+    isBoolean: (value: unknown) => value is boolean;
+    isBuffer: (value: unknown) => value is Buffer;
+    isNumber: (value: unknown) => value is number;
+    isString: (value: unknown) => value is string;
+    isArguments: any;
+    isObject: (value: unknown) => value is object;
+    isDate: (value: unknown) => value is Date;
+    isArray: <T = unknown>(value: unknown, assertion?: ((value: T) => value is T) | undefined) => value is T[];
+    isRegexp: (value: unknown) => value is RegExp;
+    isError: (value: unknown) => value is Error;
+    isFunction: (value: unknown) => value is Function;
+    isClass: (value: unknown) => value is import("@sindresorhus/is").Class<unknown, any[]>;
+    isInteger: (value: unknown) => value is number;
+    isFloat(value: number): value is number;
+    isDecimal(value: string | number, options?: {
+        decimalPlaces?: string;
+    }): boolean;
+};
+export default types;

package/build/src/helpers/types.js

@@ -0,0 +1,29 @@
+import is from '@sindresorhus/is';
+const types = {
+    lookup: is,
+    isNull: is.null_,
+    isBoolean: is.boolean,
+    isBuffer: is.buffer,
+    isNumber: is.number,
+    isString: is.string,
+    isArguments: is.arguments,
+    isObject: is.object,
+    isDate: is.date,
+    isArray: is.array,
+    isRegexp: is.regExp,
+    isError: is.error,
+    isFunction: is.function_,
+    isClass: is.class_,
+    isInteger: is.integer,
+    isFloat(value) {
+        return value !== (value | 0);
+    },
+    isDecimal(value, options) {
+        if (typeof value === 'number') {
+            value = value.toString();
+        }
+        const decimalPlaces = (options && options.decimalPlaces) || '1,';
+        return new RegExp(`^[-+]?([0-9]+)?(\\.[0-9]{${decimalPlaces}})$`).test(value);
+    },
+};
+export default types;

package/build/src/ignitor/ace.d.ts

@@ -0,0 +1,8 @@
+import { Ignitor } from './main.js';
+import type { ApplicationService } from '../types.js';
+export declare class AceProcess {
+    #private;
+    constructor(ignitor: Ignitor);
+    configure(callback: (app: ApplicationService) => Promise<void> | void): this;
+    handle(argv: string[]): Promise<void>;
+}

package/build/src/ignitor/ace.js

@@ -0,0 +1,31 @@
+export class AceProcess {
+    #ignitor;
+    #configureCallback = () => { };
+    constructor(ignitor) {
+        this.#ignitor = ignitor;
+    }
+    configure(callback) {
+        this.#configureCallback = callback;
+        return this;
+    }
+    async handle(argv) {
+        const app = this.#ignitor.createApp('console');
+        await app.init();
+        const { createAceKernel } = await import('../../modules/ace/create_kernel.js');
+        const kernel = createAceKernel(app);
+        app.container.bindValue('ace', kernel);
+        kernel.loading(async (metaData) => {
+            if (metaData.options.startApp && !app.isReady) {
+                await app.boot();
+                await app.start(() => { });
+            }
+        });
+        await this.#configureCallback(app);
+        await kernel.handle(argv);
+        process.exitCode = kernel.exitCode;
+        const mainCommand = kernel.getMainCommand();
+        if (!mainCommand || !mainCommand.staysAlive) {
+            await app.terminate();
+        }
+    }
+}