@adonisjs/core 5.9.0 → 6.0.0-0

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();
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Server as NodeHttpsServer } from 'node:https';
+import { IncomingMessage, ServerResponse, Server as NodeHttpServer } from 'node:http';
+import { Ignitor } from './main.js';
+export declare class HttpServerProcess {
+    #private;
+    constructor(ignitor: Ignitor);
+    start(serverCallback?: (handler: (req: IncomingMessage, res: ServerResponse) => any) => NodeHttpsServer | NodeHttpServer): Promise<void>;
+}

package/build/src/ignitor/http.js

@@ -0,0 +1,62 @@
+import { createServer } from 'node:http';
+import debug from '../debug.js';
+export class HttpServerProcess {
+    #ignitor;
+    constructor(ignitor) {
+        this.#ignitor = ignitor;
+    }
+    #close(nodeHttpServer) {
+        return new Promise((resolve) => {
+            debug('closing http server process');
+            nodeHttpServer.close(() => resolve());
+        });
+    }
+    #monitorAppAndServer(nodeHttpServer, app, logger) {
+        app.terminating(async () => {
+            debug('terminating signal received');
+            await this.#close(nodeHttpServer);
+        });
+        nodeHttpServer.once('error', (error) => {
+            debug('http server crashed with error "%O"', error);
+            logger.fatal({ err: error }, error.message);
+            process.exitCode = 1;
+            app.terminate();
+        });
+    }
+    #listen(nodeHttpServer) {
+        return new Promise((resolve, reject) => {
+            const host = process.env.HOST || '0.0.0.0';
+            const port = Number(process.env.PORT || '3333');
+            nodeHttpServer.listen(port, host);
+            nodeHttpServer.once('listening', () => {
+                debug('listening to http server, host :%s, port: %s', host, port);
+                resolve({ port, host });
+            });
+            nodeHttpServer.once('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    #notifyServerHasStarted(app, logger, emitter, payload) {
+        app.notify({ isAdonisJS: true, environment: 'web', ...payload });
+        logger.info('started HTTP server on %s:%s', payload.host, payload.port);
+        emitter.emit('http:server_ready', payload);
+    }
+    async start(serverCallback) {
+        const createHTTPServer = serverCallback || createServer;
+        const app = this.#ignitor.createApp('web');
+        await app.init();
+        await app.boot();
+        await app.start(async () => {
+            const server = await app.container.make('server');
+            await server.boot();
+            const httpServer = createHTTPServer(server.handle.bind(server));
+            server.setNodeServer(httpServer);
+            const logger = await app.container.make('logger');
+            const emitter = await app.container.make('emitter');
+            const payload = await this.#listen(httpServer);
+            this.#notifyServerHasStarted(app, logger, emitter, payload);
+            this.#monitorAppAndServer(httpServer, app, logger);
+        });
+    }
+}

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

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AceProcess } from './ace.js';
+import { TestRunnerProcess } from './test.js';
+import { HttpServerProcess } from './http.js';
+import type { AppEnvironments } from '../../types/app.js';
+import type { ApplicationService, IgnitorOptions } from '../types.js';
+export declare class Ignitor {
+    #private;
+    constructor(appRoot: URL, options: IgnitorOptions);
+    getApp(): ApplicationService | undefined;
+    createApp(environment: AppEnvironments): ApplicationService;
+    tap(callback: (app: ApplicationService) => void): this;
+    httpServer(): HttpServerProcess;
+    ace(): AceProcess;
+    testRunner(): TestRunnerProcess;
+    terminate(): Promise<void>;
+}

package/build/src/ignitor/main.js

@@ -0,0 +1,45 @@
+import debug from '../debug.js';
+import { AceProcess } from './ace.js';
+import { TestRunnerProcess } from './test.js';
+import { HttpServerProcess } from './http.js';
+import { setApp } from '../../services/app.js';
+import { Application } from '../../modules/app.js';
+export class Ignitor {
+    #options;
+    #appRoot;
+    #app;
+    #tapCallbacks = new Set();
+    constructor(appRoot, options) {
+        this.#appRoot = appRoot;
+        this.#options = options;
+    }
+    #runTapCallbacks(app) {
+        this.#tapCallbacks.forEach((tapCallback) => tapCallback(app));
+    }
+    getApp() {
+        return this.#app;
+    }
+    createApp(environment) {
+        debug('creating application instance');
+        this.#app = new Application(this.#appRoot, { environment, importer: this.#options.importer });
+        setApp(this.#app);
+        this.#runTapCallbacks(this.#app);
+        return this.#app;
+    }
+    tap(callback) {
+        this.#tapCallbacks.add(callback);
+        return this;
+    }
+    httpServer() {
+        return new HttpServerProcess(this);
+    }
+    ace() {
+        return new AceProcess(this);
+    }
+    testRunner() {
+        return new TestRunnerProcess(this);
+    }
+    async terminate() {
+        await this.#app?.terminate();
+    }
+}

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

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

package/build/src/ignitor/test.js

@@ -0,0 +1,18 @@
+export class TestRunnerProcess {
+    #ignitor;
+    #configureCallback = () => { };
+    constructor(ignitor) {
+        this.#ignitor = ignitor;
+    }
+    configure(callback) {
+        this.#configureCallback = callback;
+        return this;
+    }
+    async run(callback) {
+        const app = this.#ignitor.createApp('test');
+        await app.init();
+        await app.boot();
+        await app.start(this.#configureCallback);
+        await callback(app);
+    }
+}

package/build/src/test_utils/http.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { TestUtils } from './main.js';
+import type { Server as NodeHttpsServer } from 'node:https';
+import { IncomingMessage, ServerResponse, Server as NodeHttpServer } from 'node:http';
+export declare class HttpServerUtils {
+    #private;
+    constructor(utils: TestUtils);
+    start(serverCallback?: (handler: (req: IncomingMessage, res: ServerResponse) => any) => NodeHttpsServer | NodeHttpServer): Promise<() => Promise<void>>;
+}

package/build/src/test_utils/http.js

@@ -0,0 +1,42 @@
+import debug from '../debug.js';
+import { createServer } from 'node:http';
+export class HttpServerUtils {
+    #utils;
+    constructor(utils) {
+        this.#utils = utils;
+    }
+    #listen(nodeHttpServer) {
+        return new Promise((resolve, reject) => {
+            const host = process.env.HOST || '0.0.0.0';
+            const port = Number(process.env.PORT || '3333');
+            nodeHttpServer.listen(port, host);
+            nodeHttpServer.once('listening', () => {
+                debug('listening to utils http server, host :%s, port: %s', host, port);
+                resolve({ port, host });
+            });
+            nodeHttpServer.once('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    async start(serverCallback) {
+        const createHTTPServer = serverCallback || createServer;
+        const server = await this.#utils.app.container.make('server');
+        await server.boot();
+        const httpServer = createHTTPServer(server.handle.bind(server));
+        server.setNodeServer(httpServer);
+        await this.#listen(httpServer);
+        return () => {
+            return new Promise((resolve, reject) => {
+                httpServer.close((error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        };
+    }
+}

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

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+import Macroable from '@poppinss/macroable';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { HttpServerUtils } from './http.js';
+import type { ApplicationService } from '../types.js';
+import { CookieClient } from '../../modules/http.js';
+export declare class TestUtils extends Macroable {
+    #private;
+    app: ApplicationService;
+    get isBooted(): boolean;
+    cookies: CookieClient;
+    constructor(app: ApplicationService);
+    boot(): Promise<void>;
+    httpServer(): HttpServerUtils;
+    createHttpContext(options?: {
+        req?: IncomingMessage;
+        res?: ServerResponse;
+    }): Promise<import("../../modules/http.js").HttpContext>;
+}

package/build/src/test_utils/main.js

@@ -0,0 +1,33 @@
+import { Socket } from 'node:net';
+import Macroable from '@poppinss/macroable';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { HttpServerUtils } from './http.js';
+import { CookieClient } from '../../modules/http.js';
+export class TestUtils extends Macroable {
+    app;
+    #booted = false;
+    get isBooted() {
+        return this.#booted;
+    }
+    constructor(app) {
+        super();
+        this.app = app;
+    }
+    async boot() {
+        if (!this.isBooted) {
+            this.#booted = true;
+            this.cookies = new CookieClient(await this.app.container.make('encryption'));
+        }
+    }
+    httpServer() {
+        return new HttpServerUtils(this);
+    }
+    async createHttpContext(options = {}) {
+        const req = options.req || new IncomingMessage(new Socket());
+        const res = options.res || new ServerResponse(req);
+        const server = await this.app.container.make('server');
+        const request = server.createRequest(req, res);
+        const response = server.createResponse(req, res);
+        return server.createHttpContext(request, response, this.app.container.createResolver());
+    }
+}