@adonisjs/core 6.1.5-9 → 6.2.1

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/main.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/main.js").HttpContext>;
+    }): Promise<HttpContext>;
 }

package/build/src/types.d.ts

@@ -4,31 +4,40 @@ 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 { 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 { ManagerDriverFactory } from '../types/hash.js';
 import type { Router, Server } from '../modules/http/main.js';
-import type { HttpRequestFinishedPayload } from '../types/http.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;
+        duration: [number, number];
     };
 }
 /**
@@ -38,22 +47,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 {

package/build/stubs/make/listener/for_event.stub

@@ -3,10 +3,12 @@
 {{#var eventName = generators.eventName(event.name)}}
 {{#var eventFileName = generators.eventFileName(event.name)}}
 {{#var eventImportPath = generators.importPath('#events', event.path, eventFileName)}}
----
-to: {{ app.listenersPath(entity.path, listenerFileName) }}
----
-import {{ eventName }} from '{{ eventImportPath }}'
+{{{
+  exports({
+    to: app.listenersPath(entity.path, listenerFileName)
+  })
+}}}
+import type {{ eventName }} from '{{ eventImportPath }}'
 
 export default class {{ listenerName }} {
   async handle(event: {{ eventName }}) {}

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

@@ -1,7 +1,9 @@
 {{#var listenerName = generators.listenerName(entity.name)}}
 {{#var listenerFileName = generators.listenerFileName(entity.name)}}
----
-to: {{ app.listenersPath(entity.path, listenerFileName) }}
----
+{{{
+  exports({
+    to: app.listenersPath(entity.path, listenerFileName)
+  })
+}}}
 export default class {{ listenerName }} {
 }

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

@@ -1,10 +1,12 @@
 {{#var middlewareName = generators.middlewareName(entity.name)}}
 {{#var middlewareFileName = generators.middlewareFileName(entity.name)}}
----
-to: {{ app.middlewarePath(entity.path, middlewareFileName) }}
----
-import { HttpContext } from '@adonisjs/core/http'
-import { NextFn } from '@adonisjs/core/types/http'
+{{{
+  exports({
+    to: app.middlewarePath(entity.path, middlewareFileName)
+  })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
+import type { NextFn } from '@adonisjs/core/types/http'
 
 export default class {{ middlewareName }} {
   async handle(ctx: HttpContext, next: NextFn) {

package/build/stubs/make/{preload_file → preload}/main.stub

@@ -1,4 +1,6 @@
 {{#var preloadFileName = string(entity.name).snakeCase().removeExtension().ext('.ts').toString()}}
----
-to: {{ app.startPath(entity.path, preloadFileName) }}
----
+{{{
+  exports({
+    to: app.startPath(entity.path, preloadFileName)
+  })
+}}}

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

@@ -1,9 +1,11 @@
 {{#var providerName = generators.providerName(entity.name)}}
 {{#var providerFileName = generators.providerFileName(entity.name)}}
----
-to: {{ app.providersPath(entity.path, providerFileName) }}
----
-import { ApplicationService } from '@adonisjs/core/types'
+{{{
+  exports({
+    to: app.providersPath(entity.path, providerFileName)
+  })
+}}}
+import type { ApplicationService } from '@adonisjs/core/types'
 
 export default class {{ providerName }} {
   constructor(protected app: ApplicationService) {}

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

@@ -1,4 +1,6 @@
 {{#var serviceFileName = generators.serviceFileName(entity.name)}}
----
-to: {{ app.servicesPath(entity.path, serviceFileName) }}
----
+{{{
+  exports({
+    to: app.servicesPath(entity.path, serviceFileName)
+  })
+}}}

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

@@ -1,8 +1,10 @@
 {{#var testGroupName = generators.testGroupName(entity)}}
 {{#var testFileName = generators.testFileName(entity.name)}}
----
-to: {{ app.makePath(suite.directory, entity.path, testFileName) }}
----
+{{{
+  exports({
+    to: app.makePath(suite.directory, entity.path, testFileName)
+  })
+}}}
 import { test } from '@japa/runner'
 
 test.group('{{ testGroupName }}', () => {

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

@@ -0,0 +1,7 @@
+{{#var validatorFileName = generators.validatorFileName(entity.name)}}
+{{{
+  exports({
+    to: app.validatorsPath(entity.path, validatorFileName)
+  })
+}}}
+import vine from '@vinejs/vine'

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

@@ -0,0 +1,26 @@
+{{#var validatorName = string(generators.validatorName(entity.name)).noCase()}}
+{{#var validatorFileName = generators.validatorFileName(entity.name)}}
+{{#var createAction = generators.validatorActionName(entity.name, 'create')}}
+{{#var updateAction = generators.validatorActionName(entity.name, 'update')}}
+{{{
+  exports({
+    to: app.validatorsPath(entity.path, validatorFileName)
+  })
+}}}
+import vine from '@vinejs/vine'
+
+/**
+ * Validator to validate the payload when creating
+ * a new {{ validatorName }}.
+ */
+export const {{ createAction }} = vine.compile(
+  vine.object({})
+)
+
+/**
+ * Validator to validate the payload when updating
+ * an existing {{ validatorName }}.
+ */
+export const {{ updateAction }} = vine.compile(
+  vine.object({})
+)

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

@@ -0,0 +1,6 @@
+{{#var viewFileName = generators.viewFileName(entity.name)}}
+{{{
+  exports({
+    to: app.viewsPath(entity.path, viewFileName)
+  })
+}}}

package/build/types/bodyparser.js

@@ -1,5 +1,5 @@
 /*
- * @adonisjs/ace
+ * @adonisjs/core
  *
  * (c) AdonisJS
  *

package/build/types/helpers.d.ts

@@ -0,0 +1 @@
+export type { Opaque, ReadAllFilesOptions, NormalizeConstructor, ImportAllFilesOptions, } from '@poppinss/utils/types';

package/build/{src/vinejs/extensions/main.js → types/helpers.js}

@@ -6,4 +6,4 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import './validates_files.js';
+export {};

package/build/types/http.d.ts

@@ -1 +1,8 @@
 export * from '@adonisjs/http-server/types';
+import type { ValidationOptions } from '@vinejs/vine/types';
+/**
+ * Validation options accepted by the "request.validateUsing" method
+ */
+export type RequestValidationOptions<MetaData extends undefined | Record<string, any>> = ValidationOptions<MetaData> & {
+    data?: any;
+};