@adonisjs/core 6.1.5-8 → 6.2.0

package/build/providers/vinejs_provider.js

@@ -0,0 +1,97 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import vine, { BaseLiteralType, Vine } from '@vinejs/vine';
+import { Request, RequestValidator } from '../modules/http/main.js';
+/**
+ * Checks if the value is an instance of multipart file
+ * from bodyparser.
+ */
+function isBodyParserFile(file) {
+    return !!(file && typeof file === 'object' && 'isMultipartFile' in file);
+}
+/**
+ * VineJS validation rule that validates the file to be an
+ * instance of BodyParser MultipartFile class.
+ */
+const isMultipartFile = vine.createRule((file, options, field) => {
+    /**
+     * Report error when value is not a field multipart
+     * file object
+     */
+    if (!isBodyParserFile(file)) {
+        field.report('The {{ field }} must be a file', 'file', field);
+        return;
+    }
+    const validationOptions = typeof options === 'function' ? options(field) : options;
+    /**
+     * Set size when it's defined in the options and missing
+     * on the file instance
+     */
+    if (file.sizeLimit === undefined && validationOptions.size) {
+        file.sizeLimit = validationOptions.size;
+    }
+    /**
+     * Set extensions when it's defined in the options and missing
+     * on the file instance
+     */
+    if (file.allowedExtensions === undefined && validationOptions.extnames) {
+        file.allowedExtensions = validationOptions.extnames;
+    }
+    /**
+     * Validate file
+     */
+    file.validate();
+    /**
+     * Report errors
+     */
+    file.errors.forEach((error) => {
+        field.report(error.message, `file.${error.type}`, field, validationOptions);
+    });
+});
+/**
+ * Represents a multipart file uploaded via multipart/form-data HTTP
+ * request.
+ */
+class VineMultipartFile extends BaseLiteralType {
+    #validationOptions;
+    constructor(validationOptions, options, validations) {
+        super(options, validations || [isMultipartFile(validationOptions || {})]);
+        this.#validationOptions = validationOptions;
+    }
+    clone() {
+        return new VineMultipartFile(this.#validationOptions, this.cloneOptions(), this.cloneValidations());
+    }
+}
+/**
+ * The Edge service provider configures Edge to work within
+ * an AdonisJS application environment
+ */
+export default class VineJSServiceProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+        this.app.usingVineJS = true;
+    }
+    boot() {
+        /**
+         * The file method is used to validate a field to be a valid
+         * multipart file.
+         */
+        Vine.macro('file', function (options) {
+            return new VineMultipartFile(options);
+        });
+        /**
+         * The validate method can be used to validate the request
+         * data for the current request using VineJS validators
+         */
+        Request.macro('validateUsing', function (...args) {
+            return new RequestValidator(this.ctx).validateUsing(...args);
+        });
+    }
+}

package/build/src/cli_formatters/routes_list.d.ts

@@ -1,5 +1,5 @@
-import { type Router } from '../../modules/http.js';
 import type { UIPrimitives } from '../../types/ace.js';
+import { type Router } from '../../modules/http/main.js';
 /**
  * Shape of the serialized route specific to the formatter
  */

package/build/src/config_provider.d.ts

@@ -0,0 +1,9 @@
+import { ApplicationService, ConfigProvider } from './types.js';
+/**
+ * Helper to create config provider and resolve config from
+ * them
+ */
+export declare const configProvider: {
+    create<T>(resolver: (app: ApplicationService) => Promise<T>): ConfigProvider<T>;
+    resolve<T_1>(app: ApplicationService, provider: unknown): Promise<T_1 | null>;
+};

package/build/src/config_provider.js

@@ -0,0 +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.
+ */
+/**
+ * Helper to create config provider and resolve config from
+ * them
+ */
+export const configProvider = {
+    create(resolver) {
+        return {
+            type: 'provider',
+            resolver,
+        };
+    },
+    async resolve(app, provider) {
+        if (provider && typeof provider === 'object' && 'type' in provider) {
+            return provider.resolver(app);
+        }
+        return null;
+    },
+};

package/build/src/debug.d.ts

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

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

@@ -0,0 +1 @@
+export { assertExists, assertNotNull, assertIsDefined, assertUnreachable, } from '@poppinss/utils/assert';

package/build/src/helpers/assert.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export { assertExists, assertNotNull, assertIsDefined, assertUnreachable, } from '@poppinss/utils/assert';

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

@@ -1,4 +1,4 @@
 export { default as parseImports } from 'parse-imports';
-export { createId as cuid } from '@paralleldrive/cuid2';
-export { safeEqual, compose, base64, fsImportAll, fsReadAll, slash } from '@poppinss/utils';
+export { createId as cuid, isCuid } from '@paralleldrive/cuid2';
+export { slash, base64, compose, Secret, joinToURL, fsReadAll, safeEqual, getDirname, getFilename, fsImportAll, MessageBuilder, } from '@poppinss/utils';
 export { parseBindingReference } from './parse_binding_reference.js';

package/build/src/helpers/main.js

@@ -7,6 +7,6 @@
  * file that was distributed with this source code.
  */
 export { default as parseImports } from 'parse-imports';
-export { createId as cuid } from '@paralleldrive/cuid2';
-export { safeEqual, compose, base64, fsImportAll, fsReadAll, slash } from '@poppinss/utils';
+export { createId as cuid, isCuid } from '@paralleldrive/cuid2';
+export { slash, base64, compose, Secret, joinToURL, fsReadAll, safeEqual, getDirname, getFilename, fsImportAll, MessageBuilder, } from '@poppinss/utils';
 export { parseBindingReference } from './parse_binding_reference.js';

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

@@ -1,26 +1,119 @@
-/// <reference types="@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;
-    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

@@ -14,7 +14,7 @@ import is from '@sindresorhus/is';
  */
 const types = {
     lookup: is,
-    isNull: is.null_,
+    isNull: is.null,
     isBoolean: is.boolean,
     isBuffer: is.buffer,
     isNumber: is.number,
@@ -25,8 +25,8 @@ const types = {
     isArray: is.array,
     isRegexp: is.regExp,
     isError: is.error,
-    isFunction: is.function_,
-    isClass: is.class_,
+    isFunction: is.function,
+    isClass: is.class,
     isInteger: is.integer,
     isFloat(value) {
         return value !== (value | 0);

package/build/src/ignitor/ace.js

@@ -39,7 +39,9 @@ export class AceProcess {
         const app = this.#ignitor.createApp('console');
         await app.init();
         const { createAceKernel } = await import('../../modules/ace/create_kernel.js');
-        const kernel = createAceKernel(app);
+        const commandNameIndex = argv.findIndex((value) => !value.startsWith('-'));
+        const commandName = argv[commandNameIndex];
+        const kernel = createAceKernel(app, commandName);
         app.container.bindValue('ace', kernel);
         /**
          * Hook into kernel and start the app when the

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

@@ -1,5 +1,5 @@
-/// <reference types="@types/node" resolution-mode="require"/>
-/// <reference types="@types/node" resolution-mode="require"/>
+/// <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';

package/build/src/ignitor/http.js

@@ -91,6 +91,7 @@ export class HttpServerProcess {
      * Start the HTTP server by wiring up the application
      */
     async start(serverCallback) {
+        const startTime = process.hrtime();
         /**
          * Method to create the HTTP server
          */
@@ -119,7 +120,10 @@ export class HttpServerProcess {
             /**
              * Notify
              */
-            this.#notifyServerHasStarted(app, logger, emitter, payload);
+            this.#notifyServerHasStarted(app, logger, emitter, {
+                ...payload,
+                duration: process.hrtime(startTime),
+            });
             /**
              * Monitor app and the server (after the server is listening)
              */

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

@@ -1,4 +1,4 @@
-/// <reference types="@types/node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { AceProcess } from './ace.js';
 import { TestRunnerProcess } from './test.js';
 import { HttpServerProcess } from './http.js';
@@ -10,7 +10,7 @@ import type { ApplicationService, IgnitorOptions } from '../types.js';
  */
 export declare class Ignitor {
     #private;
-    constructor(appRoot: URL, options: IgnitorOptions);
+    constructor(appRoot: URL, options?: IgnitorOptions);
     /**
      * Get access to the application instance created
      * by either the http server process or the ace

package/build/src/ignitor/main.js

@@ -38,7 +38,7 @@ export class Ignitor {
      * Reference to the created application
      */
     #tapCallbacks = new Set();
-    constructor(appRoot, options) {
+    constructor(appRoot, options = {}) {
         this.#appRoot = appRoot;
         this.#options = options;
     }

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

@@ -1,5 +1,5 @@
-/// <reference types="@types/node" resolution-mode="require"/>
-/// <reference types="@types/node" resolution-mode="require"/>
+/// <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';

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

@@ -1,9 +1,9 @@
-/// <reference types="@types/node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import Macroable from '@poppinss/macroable';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { HttpServerUtils } from './http.js';
-import { CookieClient } from '../../modules/http.js';
 import type { ApplicationService } from '../types.js';
+import { CookieClient, type HttpContext } from '../../modules/http/main.js';
 /**
  * Test utils has a collection of helper methods to make testing
  * experience great for AdonisJS applications
@@ -33,5 +33,5 @@ export declare class TestUtils extends Macroable {
     createHttpContext(options?: {
         req?: IncomingMessage;
         res?: ServerResponse;
-    }): Promise<import("../../modules/http.js").HttpContext>;
+    }): Promise<HttpContext>;
 }

package/build/src/test_utils/main.js

@@ -10,7 +10,7 @@ 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';
+import { CookieClient } from '../../modules/http/main.js';
 /**
  * Test utils has a collection of helper methods to make testing
  * experience great for AdonisJS applications

package/build/src/types.d.ts

@@ -4,28 +4,36 @@ import type { Emitter } from '../modules/events.js';
 import type { Kernel } from '../modules/ace/main.js';
 import type { Application } from '../modules/app.js';
 import type { TestUtils } from './test_utils/main.js';
-import type { Router, Server } from '../modules/http.js';
+import type { HttpServerEvents } from '../types/http.js';
 import type { LoggerManager } from '../modules/logger.js';
+import type { HashManager } from '../modules/hash/main.js';
 import type { Encryption } from '../modules/encryption.js';
-import type { HttpRequestFinishedPayload } from '../types/http.js';
+import type { ManagerDriverFactory } from '../types/hash.js';
+import type { Router, Server } from '../modules/http/main.js';
 import type { ContainerResolveEventData } from '../types/container.js';
 import type { LoggerConfig, LoggerManagerConfig } from '../types/logger.js';
-import type { Argon, Bcrypt, HashManager, Scrypt } from '../modules/hash/main.js';
-import type { ArgonConfig, BcryptConfig, ScryptConfig, ManagerDriverFactory } from '../types/hash.js';
+/**
+ * A config provider waits for the application to get booted
+ * and then resolves the config. It receives an instance
+ * of the application service.
+ */
+export type ConfigProvider<T> = {
+    type: 'provider';
+    resolver: (app: ApplicationService) => Promise<T>;
+};
 /**
  * Options accepted by ignitor
  */
 export type IgnitorOptions = {
-    importer: Importer;
+    importer?: Importer;
 };
 /**
  * A list of known events. The interface must be extended in
  * user land code or packages to register events and their
  * types.
  */
-export interface EventsList {
-    'container:resolved': ContainerResolveEventData<ContainerBindings>;
-    'http:request_handled': HttpRequestFinishedPayload;
+export interface EventsList extends HttpServerEvents {
+    'container_binding:resolved': ContainerResolveEventData<ContainerBindings>;
     'http:server_ready': {
         port: number;
         host: string;
@@ -38,22 +46,14 @@ export interface EventsList {
 export interface LoggersList {
 }
 export type InferLoggers<T extends LoggerManagerConfig<any>> = T['loggers'];
-/**
- * A list of globally available hash drivers
- */
-export interface HashDriversList {
-    bcrypt: (config: BcryptConfig) => Bcrypt;
-    argon2: (config: ArgonConfig) => Argon;
-    scrypt: (config: ScryptConfig) => Scrypt;
-}
 /**
  * A list of known hashers inferred from the user config
  */
 export interface HashersList {
 }
-export type InferHashers<T extends {
+export type InferHashers<T extends ConfigProvider<{
     list: Record<string, ManagerDriverFactory>;
-}> = T['list'];
+}>> = Awaited<ReturnType<T['resolver']>>['list'];
 /**
  * ----------------------------------------------------------------
  * Container services

package/build/stubs/make/command/main.stub

@@ -1,11 +1,13 @@
 {{#var commandName = generators.commandName(entity.name)}}
 {{#var commandTerminalName = generators.commandTerminalName(entity.name)}}
 {{#var commandFileName = generators.commandFileName(entity.name)}}
----
-to: {{ app.commandsPath(entity.path, commandFileName) }}
----
+{{{
+  exports({
+    to: app.commandsPath(entity.path, commandFileName)
+  })
+}}}
 import { BaseCommand } from '@adonisjs/core/ace'
-import { CommandOptions } from '@adonisjs/core/types/ace'
+import type { CommandOptions } from '@adonisjs/core/types/ace'
 
 export default class {{ commandName }} extends BaseCommand {
   static commandName = '{{ commandTerminalName }}'

package/build/stubs/make/controller/actions.stub

@@ -0,0 +1,14 @@
+{{#var controllerName = generators.controllerName(entity.name)}}
+{{#var controllerFileName = generators.controllerFileName(entity.name)}}
+{{{
+  exports({
+    to: app.httpControllersPath(entity.path, controllerFileName)
+  })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
+
+export default class {{ controllerName }} {
+  {{#each actions as action}}
+  async {{action}}({}: HttpContext) {}
+  {{/each}}
+}

package/build/stubs/make/controller/api.stub

@@ -1,9 +1,11 @@
 {{#var controllerName = generators.controllerName(entity.name)}}
 {{#var controllerFileName = generators.controllerFileName(entity.name)}}
----
-to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
----
-import { HttpContext } from '@adonisjs/core/http'
+{{{
+  exports({
+    to: app.httpControllersPath(entity.path, controllerFileName)
+  })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
 
 export default class {{ controllerName }} {
   /**

package/build/stubs/make/controller/main.stub

@@ -1,9 +1,11 @@
 {{#var controllerName = generators.controllerName(entity.name)}}
 {{#var controllerFileName = generators.controllerFileName(entity.name)}}
----
-to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
----
-// import { HttpContext } from '@adonisjs/core/http'
+{{{
+  exports({
+    to: app.httpControllersPath(entity.path, controllerFileName)
+  })
+}}}
+// import type { HttpContext } from '@adonisjs/core/http'
 
 export default class {{ controllerName }} {
 }

package/build/stubs/make/controller/resource.stub

@@ -1,9 +1,11 @@
 {{#var controllerName = generators.controllerName(entity.name)}}
 {{#var controllerFileName = generators.controllerFileName(entity.name)}}
----
-to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
----
-import { HttpContext } from '@adonisjs/core/http'
+{{{
+  exports({
+    to: app.httpControllersPath(entity.path, controllerFileName)
+  })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
 
 export default class {{ controllerName }} {
   /**

package/build/stubs/make/event/main.stub

@@ -1,8 +1,10 @@
 {{#var eventName = generators.eventName(entity.name)}}
 {{#var eventFileName = generators.eventFileName(entity.name)}}
----
-to: {{ app.eventsPath(entity.path, eventFileName) }}
----
+{{{
+  exports({
+    to: app.eventsPath(entity.path, eventFileName)
+  })
+}}}
 import { BaseEvent } from '@adonisjs/core/events'
 
 export default class {{ eventName }} extends BaseEvent {

package/build/stubs/make/exception/main.stub

@@ -1,8 +1,10 @@
 {{#var exceptionName = generators.exceptionName(entity.name)}}
 {{#var exceptionFileName = generators.exceptionFileName(entity.name)}}
----
-to: {{ app.exceptionsPath(entity.path, exceptionFileName) }}
----
+{{{
+  exports({
+    to: app.exceptionsPath(entity.path, exceptionFileName)
+  })
+}}}
 import { Exception } from '@adonisjs/core/exceptions'
 
 export default class {{ exceptionName }} extends Exception {