@adonisjs/core 6.1.5-2 → 6.1.5-20

package/build/src/helpers/string.js

@@ -1,11 +1,26 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import he from 'he';
 import prettyHrTime from 'pretty-hrtime';
 import string from '@poppinss/utils/string';
+import StringBuilder from '@poppinss/utils/string_builder';
+/**
+ * Collection of string helpers to transform a string value.
+ */
 const stringHelpers = {
     ...string,
     toSentence: string.sentence,
     ordinalize: string.ordinal,
     generateRandom: string.random,
+    create(value) {
+        return new StringBuilder(value);
+    },
     prettyHrTime(time, options) {
         return prettyHrTime(time, options);
     },

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

@@ -1,21 +1,119 @@
-/// <reference types="node" resolution-mode="require"/>
-import is from '@sindresorhus/is';
+/**
+ * @deprecated
+ * Use "is" helpers instead. The types helpers exists
+ * for backward compatibility
+ */
 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;
+    lookup: ((value: unknown) => import("@sindresorhus/is").TypeName) & {
+        all: typeof import("@sindresorhus/is").isAll;
+        any: typeof import("@sindresorhus/is").isAny;
+        array: typeof import("@sindresorhus/is").isArray;
+        arrayBuffer: typeof import("@sindresorhus/is").isArrayBuffer;
+        arrayLike: typeof import("@sindresorhus/is").isArrayLike;
+        asyncFunction: typeof import("@sindresorhus/is").isAsyncFunction;
+        asyncGenerator: typeof import("@sindresorhus/is").isAsyncGenerator;
+        asyncGeneratorFunction: typeof import("@sindresorhus/is").isAsyncGeneratorFunction;
+        asyncIterable: typeof import("@sindresorhus/is").isAsyncIterable;
+        bigint: typeof import("@sindresorhus/is").isBigint;
+        bigInt64Array: typeof import("@sindresorhus/is").isBigInt64Array;
+        bigUint64Array: typeof import("@sindresorhus/is").isBigUint64Array;
+        blob: typeof import("@sindresorhus/is").isBlob;
+        boolean: typeof import("@sindresorhus/is").isBoolean;
+        boundFunction: typeof import("@sindresorhus/is").isBoundFunction;
+        buffer: typeof import("@sindresorhus/is").isBuffer;
+        class: typeof import("@sindresorhus/is").isClass;
+        class_: typeof import("@sindresorhus/is").isClass;
+        dataView: typeof import("@sindresorhus/is").isDataView;
+        date: typeof import("@sindresorhus/is").isDate;
+        detect: (value: unknown) => import("@sindresorhus/is").TypeName;
+        directInstanceOf: typeof import("@sindresorhus/is").isDirectInstanceOf;
+        domElement: typeof import("@sindresorhus/is").isHtmlElement;
+        emptyArray: typeof import("@sindresorhus/is").isEmptyArray;
+        emptyMap: typeof import("@sindresorhus/is").isEmptyMap;
+        emptyObject: typeof import("@sindresorhus/is").isEmptyObject;
+        emptySet: typeof import("@sindresorhus/is").isEmptySet;
+        emptyString: typeof import("@sindresorhus/is").isEmptyString;
+        emptyStringOrWhitespace: typeof import("@sindresorhus/is").isEmptyStringOrWhitespace;
+        enumCase: typeof import("@sindresorhus/is").isEnumCase;
+        error: typeof import("@sindresorhus/is").isError;
+        evenInteger: typeof import("@sindresorhus/is").isEvenInteger;
+        falsy: typeof import("@sindresorhus/is").isFalsy;
+        float32Array: typeof import("@sindresorhus/is").isFloat32Array;
+        float64Array: typeof import("@sindresorhus/is").isFloat64Array;
+        formData: typeof import("@sindresorhus/is").isFormData;
+        function: typeof import("@sindresorhus/is").isFunction;
+        function_: typeof import("@sindresorhus/is").isFunction;
+        generator: typeof import("@sindresorhus/is").isGenerator;
+        generatorFunction: typeof import("@sindresorhus/is").isGeneratorFunction;
+        htmlElement: typeof import("@sindresorhus/is").isHtmlElement;
+        infinite: typeof import("@sindresorhus/is").isInfinite;
+        inRange: typeof import("@sindresorhus/is").isInRange;
+        int16Array: typeof import("@sindresorhus/is").isInt16Array;
+        int32Array: typeof import("@sindresorhus/is").isInt32Array;
+        int8Array: typeof import("@sindresorhus/is").isInt8Array;
+        integer: typeof import("@sindresorhus/is").isInteger;
+        iterable: typeof import("@sindresorhus/is").isIterable;
+        map: typeof import("@sindresorhus/is").isMap;
+        nan: typeof import("@sindresorhus/is").isNan;
+        nativePromise: typeof import("@sindresorhus/is").isNativePromise;
+        negativeNumber: typeof import("@sindresorhus/is").isNegativeNumber;
+        nodeStream: typeof import("@sindresorhus/is").isNodeStream;
+        nonEmptyArray: typeof import("@sindresorhus/is").isNonEmptyArray;
+        nonEmptyMap: typeof import("@sindresorhus/is").isNonEmptyMap;
+        nonEmptyObject: typeof import("@sindresorhus/is").isNonEmptyObject;
+        nonEmptySet: typeof import("@sindresorhus/is").isNonEmptySet;
+        nonEmptyString: typeof import("@sindresorhus/is").isNonEmptyString;
+        nonEmptyStringAndNotWhitespace: typeof import("@sindresorhus/is").isNonEmptyStringAndNotWhitespace;
+        null: typeof import("@sindresorhus/is").isNull;
+        null_: typeof import("@sindresorhus/is").isNull;
+        nullOrUndefined: typeof import("@sindresorhus/is").isNullOrUndefined;
+        number: typeof import("@sindresorhus/is").isNumber;
+        numericString: typeof import("@sindresorhus/is").isNumericString;
+        object: typeof import("@sindresorhus/is").isObject;
+        observable: typeof import("@sindresorhus/is").isObservable;
+        oddInteger: typeof import("@sindresorhus/is").isOddInteger;
+        plainObject: typeof import("@sindresorhus/is").isPlainObject;
+        positiveNumber: typeof import("@sindresorhus/is").isPositiveNumber;
+        primitive: typeof import("@sindresorhus/is").isPrimitive;
+        promise: typeof import("@sindresorhus/is").isPromise;
+        propertyKey: typeof import("@sindresorhus/is").isPropertyKey;
+        regExp: typeof import("@sindresorhus/is").isRegExp;
+        safeInteger: typeof import("@sindresorhus/is").isSafeInteger;
+        set: typeof import("@sindresorhus/is").isSet;
+        sharedArrayBuffer: typeof import("@sindresorhus/is").isSharedArrayBuffer;
+        string: typeof import("@sindresorhus/is").isString;
+        symbol: typeof import("@sindresorhus/is").isSymbol;
+        truthy: typeof import("@sindresorhus/is").isTruthy;
+        tupleLike: typeof import("@sindresorhus/is").isTupleLike;
+        typedArray: typeof import("@sindresorhus/is").isTypedArray;
+        uint16Array: typeof import("@sindresorhus/is").isUint16Array;
+        uint32Array: typeof import("@sindresorhus/is").isUint32Array;
+        uint8Array: typeof import("@sindresorhus/is").isUint8Array;
+        uint8ClampedArray: typeof import("@sindresorhus/is").isUint8ClampedArray;
+        undefined: typeof import("@sindresorhus/is").isUndefined;
+        urlInstance: typeof import("@sindresorhus/is").isUrlInstance;
+        urlSearchParams: typeof import("@sindresorhus/is").isUrlSearchParams;
+        urlString: typeof import("@sindresorhus/is").isUrlString;
+        validLength: typeof import("@sindresorhus/is").isValidLength;
+        weakMap: typeof import("@sindresorhus/is").isWeakMap;
+        weakRef: typeof import("@sindresorhus/is").isWeakRef;
+        weakSet: typeof import("@sindresorhus/is").isWeakSet;
+        whitespaceString: typeof import("@sindresorhus/is").isWhitespaceString;
+    };
+    isNull: typeof import("@sindresorhus/is").isNull;
+    isBoolean: typeof import("@sindresorhus/is").isBoolean;
+    isBuffer: typeof import("@sindresorhus/is").isBuffer;
+    isNumber: typeof import("@sindresorhus/is").isNumber;
+    isString: typeof import("@sindresorhus/is").isString;
     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;
+    isObject: typeof import("@sindresorhus/is").isObject;
+    isDate: typeof import("@sindresorhus/is").isDate;
+    isArray: typeof import("@sindresorhus/is").isArray;
+    isRegexp: typeof import("@sindresorhus/is").isRegExp;
+    isError: typeof import("@sindresorhus/is").isError;
+    isFunction: typeof import("@sindresorhus/is").isFunction;
+    isClass: typeof import("@sindresorhus/is").isClass;
+    isInteger: typeof import("@sindresorhus/is").isInteger;
     isFloat(value: number): value is number;
     isDecimal(value: string | number, options?: {
         decimalPlaces?: string;

package/build/src/helpers/types.js

@@ -1,4 +1,17 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import is from '@sindresorhus/is';
+/**
+ * @deprecated
+ * Use "is" helpers instead. The types helpers exists
+ * for backward compatibility
+ */
 const types = {
     lookup: is,
     isNull: is.null_,

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

@@ -1,8 +1,20 @@
 import { Ignitor } from './main.js';
 import type { ApplicationService } from '../types.js';
+/**
+ * The Ace process is used to start the application in the
+ * console environment.
+ */
 export declare class AceProcess {
     #private;
     constructor(ignitor: Ignitor);
+    /**
+     * Register a callback that can be used to configure the ace
+     * kernel before the handle method is called
+     */
     configure(callback: (app: ApplicationService) => Promise<void> | void): this;
+    /**
+     * Handles the command line arguments and executes
+     * the matching ace commands
+     */
     handle(argv: string[]): Promise<void>;
 }

package/build/src/ignitor/ace.js

@@ -1,31 +1,80 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * The Ace process is used to start the application in the
+ * console environment.
+ */
 export class AceProcess {
+    /**
+     * Ignitor reference
+     */
     #ignitor;
+    /**
+     * The callback that configures the ace instance before the
+     * handle method is called
+     */
     #configureCallback = () => { };
     constructor(ignitor) {
         this.#ignitor = ignitor;
     }
+    /**
+     * Register a callback that can be used to configure the ace
+     * kernel before the handle method is called
+     */
     configure(callback) {
         this.#configureCallback = callback;
         return this;
     }
+    /**
+     * Handles the command line arguments and executes
+     * the matching ace commands
+     */
     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);
+        /**
+         * Hook into kernel and start the app when the
+         * command needs the app.
+         *
+         * Since multiple commands can be executed in a single process,
+         * we add a check to only start the app only once.
+         */
         kernel.loading(async (metaData) => {
             if (metaData.options.startApp && !app.isReady) {
+                if (metaData.commandName === 'repl') {
+                    app.setEnvironment('repl');
+                }
                 await app.boot();
                 await app.start(() => { });
             }
         });
         await this.#configureCallback(app);
+        /**
+         * Handle command line args
+         */
         await kernel.handle(argv);
-        process.exitCode = kernel.exitCode;
+        /**
+         * Terminate the app when the command does not want to
+         * hold a long running process
+         */
         const mainCommand = kernel.getMainCommand();
         if (!mainCommand || !mainCommand.staysAlive) {
+            process.exitCode = kernel.exitCode;
             await app.terminate();
         }
+        else {
+            app.terminating(() => {
+                process.exitCode = mainCommand.exitCode;
+            });
+        }
     }
 }

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

@@ -1,10 +1,17 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="@types/node" resolution-mode="require"/>
+/// <reference types="@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';
+/**
+ * The HTTP server process is used to start the application in the
+ * web environment.
+ */
 export declare class HttpServerProcess {
     #private;
     constructor(ignitor: Ignitor);
+    /**
+     * Start the HTTP server by wiring up the application
+     */
     start(serverCallback?: (handler: (req: IncomingMessage, res: ServerResponse) => any) => NodeHttpsServer | NodeHttpServer): Promise<void>;
 }

package/build/src/ignitor/http.js

@@ -1,21 +1,50 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import { createServer } from 'node:http';
 import debug from '../debug.js';
+/**
+ * The HTTP server process is used to start the application in the
+ * web environment.
+ */
 export class HttpServerProcess {
+    /**
+     * Ignitor reference
+     */
     #ignitor;
     constructor(ignitor) {
         this.#ignitor = ignitor;
     }
+    /**
+     * Calling this method closes the underlying HTTP server
+     */
     #close(nodeHttpServer) {
         return new Promise((resolve) => {
             debug('closing http server process');
             nodeHttpServer.close(() => resolve());
         });
     }
+    /**
+     * Monitors the app and the server to close the HTTP server when
+     * either one of them goes down
+     */
     #monitorAppAndServer(nodeHttpServer, app, logger) {
+        /**
+         * Close the HTTP server when the application begins to
+         * terminate
+         */
         app.terminating(async () => {
             debug('terminating signal received');
             await this.#close(nodeHttpServer);
         });
+        /**
+         * Terminate the app when the HTTP server crashes
+         */
         nodeHttpServer.once('error', (error) => {
             debug('http server crashed with error "%O"', error);
             logger.fatal({ err: error }, error.message);
@@ -23,6 +52,9 @@ export class HttpServerProcess {
             app.terminate();
         });
     }
+    /**
+     * Starts the http server a given host and port
+     */
     #listen(nodeHttpServer) {
         return new Promise((resolve, reject) => {
             const host = process.env.HOST || '0.0.0.0';
@@ -37,25 +69,60 @@ export class HttpServerProcess {
             });
         });
     }
+    /**
+     * Notifies the app and the parent process that the
+     * HTTP server is ready
+     */
     #notifyServerHasStarted(app, logger, emitter, payload) {
+        /**
+         * Notify parent process
+         */
         app.notify({ isAdonisJS: true, environment: 'web', ...payload });
+        /**
+         * Visual notification
+         */
         logger.info('started HTTP server on %s:%s', payload.host, payload.port);
+        /**
+         * Notify app
+         */
         emitter.emit('http:server_ready', payload);
     }
+    /**
+     * Start the HTTP server by wiring up the application
+     */
     async start(serverCallback) {
+        /**
+         * Method to create the HTTP server
+         */
         const createHTTPServer = serverCallback || createServer;
         const app = this.#ignitor.createApp('web');
         await app.init();
         await app.boot();
         await app.start(async () => {
+            /**
+             * Resolve and boot the AdonisJS HTTP server
+             */
             const server = await app.container.make('server');
             await server.boot();
+            /**
+             * Create Node.js HTTP server instance and share it with the
+             * AdonisJS HTTP server
+             */
             const httpServer = createHTTPServer(server.handle.bind(server));
             server.setNodeServer(httpServer);
             const logger = await app.container.make('logger');
             const emitter = await app.container.make('emitter');
+            /**
+             * Start the server by listening on a port of host
+             */
             const payload = await this.#listen(httpServer);
+            /**
+             * Notify
+             */
             this.#notifyServerHasStarted(app, logger, emitter, payload);
+            /**
+             * Monitor app and the server (after the server is listening)
+             */
             this.#monitorAppAndServer(httpServer, app, logger);
         });
     }

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

@@ -1,17 +1,45 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="@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';
+/**
+ * Ignitor is used to instantiate an AdonisJS application in different
+ * known environments.
+ */
 export declare class Ignitor {
     #private;
     constructor(appRoot: URL, options: IgnitorOptions);
+    /**
+     * Get access to the application instance created
+     * by either the http server process or the ace
+     * process
+     */
     getApp(): ApplicationService | undefined;
+    /**
+     * Create an instance of AdonisJS application
+     */
     createApp(environment: AppEnvironments): ApplicationService;
+    /**
+     * Tap to access the application class instance.
+     */
     tap(callback: (app: ApplicationService) => void): this;
+    /**
+     * Get instance of the HTTPServerProcess
+     */
     httpServer(): HttpServerProcess;
+    /**
+     * Get an instance of the AceProcess class
+     */
     ace(): AceProcess;
+    /**
+     * Get an instance of the TestRunnerProcess class
+     */
     testRunner(): TestRunnerProcess;
+    /**
+     * Terminates the app by calling the "app.terminate"
+     * method
+     */
     terminate(): Promise<void>;
 }

package/build/src/ignitor/main.js

@@ -1,24 +1,64 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 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';
+/**
+ * Ignitor is used to instantiate an AdonisJS application in different
+ * known environments.
+ */
 export class Ignitor {
+    /**
+     * Ignitor options
+     */
     #options;
+    /**
+     * Application root URL
+     */
     #appRoot;
+    /**
+     * Reference to the application instance created using
+     * the "createApp" method.
+     *
+     * We store the output of the last call made to "createApp" method
+     * and assume that in one process only one entrypoint will
+     * call this method.
+     */
     #app;
+    /**
+     * Reference to the created application
+     */
     #tapCallbacks = new Set();
     constructor(appRoot, options) {
         this.#appRoot = appRoot;
         this.#options = options;
     }
+    /**
+     * Runs all the tap callbacks
+     */
     #runTapCallbacks(app) {
         this.#tapCallbacks.forEach((tapCallback) => tapCallback(app));
     }
+    /**
+     * Get access to the application instance created
+     * by either the http server process or the ace
+     * process
+     */
     getApp() {
         return this.#app;
     }
+    /**
+     * Create an instance of AdonisJS application
+     */
     createApp(environment) {
         debug('creating application instance');
         this.#app = new Application(this.#appRoot, { environment, importer: this.#options.importer });
@@ -26,19 +66,35 @@ export class Ignitor {
         this.#runTapCallbacks(this.#app);
         return this.#app;
     }
+    /**
+     * Tap to access the application class instance.
+     */
     tap(callback) {
         this.#tapCallbacks.add(callback);
         return this;
     }
+    /**
+     * Get instance of the HTTPServerProcess
+     */
     httpServer() {
         return new HttpServerProcess(this);
     }
+    /**
+     * Get an instance of the AceProcess class
+     */
     ace() {
         return new AceProcess(this);
     }
+    /**
+     * Get an instance of the TestRunnerProcess class
+     */
     testRunner() {
         return new TestRunnerProcess(this);
     }
+    /**
+     * Terminates the app by calling the "app.terminate"
+     * method
+     */
     async terminate() {
         await this.#app?.terminate();
     }

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

@@ -1,8 +1,18 @@
 import { Ignitor } from './main.js';
 import type { ApplicationService } from '../types.js';
+/**
+ * The Test runner process is used to start the tests runner process
+ */
 export declare class TestRunnerProcess {
     #private;
     constructor(ignitor: Ignitor);
+    /**
+     * Register a callback that runs after booting the AdonisJS app
+     * and just before the provider's ready hook
+     */
     configure(callback: (app: ApplicationService) => Promise<void> | void): this;
+    /**
+     * Runs a callback after starting the app
+     */
     run(callback: (app: ApplicationService) => Promise<void> | void): Promise<void>;
 }

package/build/src/ignitor/test.js

@@ -1,13 +1,38 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * The Test runner process is used to start the tests runner process
+ */
 export class TestRunnerProcess {
+    /**
+     * Ignitor reference
+     */
     #ignitor;
+    /**
+     * The callback that configures the tests runner. This callback
+     * runs at the time of starting the app.
+     */
     #configureCallback = () => { };
     constructor(ignitor) {
         this.#ignitor = ignitor;
     }
+    /**
+     * Register a callback that runs after booting the AdonisJS app
+     * and just before the provider's ready hook
+     */
     configure(callback) {
         this.#configureCallback = callback;
         return this;
     }
+    /**
+     * Runs a callback after starting the app
+     */
     async run(callback) {
         const app = this.#ignitor.createApp('test');
         await app.init();

package/build/src/internal_helpers.d.ts

@@ -1,8 +1,15 @@
 import { ApplicationService } from './types.js';
+import { RcFile } from '@adonisjs/application/types';
+/**
+ * Imports assembler optionally
+ */
 export declare function importAssembler(app: ApplicationService): Promise<typeof import('@adonisjs/assembler') | undefined>;
+/**
+ * Imports typescript optionally
+ */
 export declare function importTypeScript(app: ApplicationService): Promise<typeof import('typescript') | undefined>;
-export declare function detectAssetsBundler(app: ApplicationService): Promise<{
-    name: string;
-    devServerCommand: string;
-    buildCommand: string;
-} | undefined>;
+/**
+ * Detects the assets bundler in use. The rcFile.assetsBundler is
+ * used when exists.
+ */
+export declare function detectAssetsBundler(app: ApplicationService): Promise<RcFile['assetsBundler']>;