@adonisjs/inertia 3.1.1 → 4.0.0-next.1

package/build/src/inertia_middleware.js

@@ -1,6 +1,113 @@
 import {
-  InertiaMiddleware
-} from "../chunk-W7TVEB4V.js";
+  InertiaManager
+} from "../chunk-74S2VAL7.js";
+import {
+  InertiaHeaders
+} from "../chunk-DISC5OYC.js";
+import {
+  debug_default
+} from "../chunk-4EZ2J6OA.js";
+import "../chunk-MLKGABMK.js";
+
+// src/inertia_middleware.ts
+var MUTATION_METHODS = ["PUT", "PATCH", "DELETE"];
+var BaseInertiaMiddleware = class {
+  /**
+   * Extract validation errors from the session and format them for Inertia
+   *
+   * Retrieves validation errors from the session flash messages and formats
+   * them according to Inertia's error bag conventions. Supports both simple
+   * error objects and error bags for multi-form scenarios.
+   *
+   * @param ctx - The HTTP context containing session data
+   * @returns Formatted validation errors, either as a simple object or error bags
+   *
+   * @example
+   * ```js
+   * const errors = middleware.getValidationErrors(ctx)
+   * // Returns: { email: 'Email is required', password: 'Password too short' }
+   * // Or with error bags: { login: { email: 'Email is required' } }
+   * ```
+   */
+  getValidationErrors(ctx) {
+    if (!ctx.session) {
+      return {};
+    }
+    const inputErrors = ctx.session.flashMessages.get("inputErrorsBag");
+    const errors = Object.entries(inputErrors).reduce(
+      (result, [field, messages]) => {
+        result[field] = Array.isArray(messages) ? messages[0] : messages;
+        return result;
+      },
+      {}
+    );
+    const errorBag = ctx.request.header(InertiaHeaders.ErrorBag);
+    if (errorBag) {
+      return { [errorBag]: errors };
+    }
+    return errors;
+  }
+  /**
+   * Initialize the Inertia instance for the current request
+   *
+   * This method creates an Inertia instance and attaches it to the
+   * HTTP context, making it available throughout the request lifecycle.
+   *
+   * @param ctx - The HTTP context object
+   *
+   * @example
+   * ```ts
+   * await middleware.init(ctx)
+   * ```
+   */
+  async init(ctx) {
+    debug_default("initiating inertia");
+    const inertiaContainer = await ctx.containerResolver.make(InertiaManager);
+    ctx.inertia = inertiaContainer.createForRequest(ctx);
+    if (this.share) {
+      ctx.inertia.share(await this.share(ctx));
+    }
+  }
+  /**
+   * Clean up and finalize the Inertia response
+   *
+   * This method handles the final processing of Inertia requests including:
+   * - Setting appropriate response headers
+   * - Handling redirects for mutation methods (PUT/PATCH/DELETE)
+   * - Managing asset versioning conflicts
+   *
+   * @param ctx - The HTTP context object
+   *
+   * @example
+   * ```ts
+   * await middleware.dispose(ctx)
+   * ```
+   */
+  dispose(ctx) {
+    const requestInfo = ctx.inertia.requestInfo();
+    if (!requestInfo.isInertiaRequest) {
+      return;
+    }
+    debug_default("disposing as inertia request");
+    ctx.response.header("Vary", InertiaHeaders.Inertia);
+    const method = ctx.request.method();
+    if (ctx.response.getStatus() === 302 && MUTATION_METHODS.includes(method)) {
+      debug_default("upgrading response status from 302 to 303");
+      ctx.response.status(303);
+    }
+    const version = ctx.inertia.getVersion();
+    const clientVersion = requestInfo.version ?? "";
+    if (method === "GET" && clientVersion !== version) {
+      debug_default("version mis-match. Reloading page");
+      if (ctx.session) {
+        ctx.session.reflash();
+      }
+      ctx.response.removeHeader(InertiaHeaders.Inertia);
+      ctx.response.header(InertiaHeaders.Location, ctx.request.url(true));
+      ctx.response.status(409);
+    }
+  }
+};
 export {
-  InertiaMiddleware as default
+  BaseInertiaMiddleware as default
 };

package/build/src/plugins/edge/plugin.d.ts

@@ -1,8 +1,32 @@
-import { PluginFn } from 'edge.js/types';
-
+import type { PluginFn } from 'edge.js/types';
 /**
- * Register the Inertia tags and globals within Edge
+ * Edge.js plugin that registers Inertia.js tags and global functions
+ *
+ * This plugin adds the @inertia and @inertiaHead tags to Edge templates,
+ * along with global helper functions for rendering Inertia pages.
+ *
+ * @returns Edge plugin function that registers Inertia functionality
+ *
+ * @example
+ * ```js
+ * // Configure in config/edge.ts
+ * import { edgePluginInertia } from '@adonisjs/inertia/plugins/edge'
+ *
+ * edge.use(edgePluginInertia())
+ * ```
+ *
+ * @example
+ * ```edge
+ * {{-- Use in Edge templates --}}
+ * <!DOCTYPE html>
+ * <html>
+ * <head>
+ *   @inertiaHead()
+ * </head>
+ * <body>
+ *   @inertia({ id: 'app', class: 'min-h-screen' })
+ * </body>
+ * </html>
+ * ```
  */
-declare const edgePluginInertia: () => PluginFn<undefined>;
-
-export { edgePluginInertia };
+export declare const edgePluginInertia: () => PluginFn<undefined>;

package/build/src/plugins/edge/plugin.js

@@ -1,10 +1,11 @@
+import {
+  debug_default
+} from "../../../chunk-4EZ2J6OA.js";
+import "../../../chunk-MLKGABMK.js";
+
 // src/plugins/edge/plugin.ts
 import { encode } from "html-entities";
 
-// src/debug.ts
-import { debuglog } from "node:util";
-var debug_default = debuglog("adonisjs:inertia");
-
 // src/plugins/edge/tags.ts
 import { EdgeError } from "edge-error";
 
@@ -40,10 +41,11 @@ var inertiaTag = {
       );
     });
     const attributes = parser.utils.stringify(parsed);
-    buffer.writeExpression(
-      `out += state.inertia(state.page, ${attributes})`,
+    buffer.outputExpression(
+      `state.inertia(state.page, ${attributes})`,
       filename,
-      loc.start.line
+      loc.start.line,
+      false
     );
   }
 };
@@ -52,7 +54,7 @@ var inertiaHeadTag = {
   tagName: "inertiaHead",
   seekable: false,
   compile(_, buffer, { filename, loc }) {
-    buffer.writeExpression(`out += state.inertiaHead(state.page)`, filename, loc.start.line);
+    buffer.outputExpression("state.inertiaHead(state.page)", filename, loc.start.line, false);
   }
 };
 
@@ -63,7 +65,9 @@ var edgePluginInertia = () => {
     edge.global(
       "inertia",
       (page = {}, attributes = {}) => {
-        if (page.ssrBody) return page.ssrBody;
+        if (page.ssrBody) {
+          return page.ssrBody;
+        }
         const className = attributes?.class ? ` class="${attributes.class}"` : "";
         const id = attributes?.id ? ` id="${attributes.id}"` : ' id="app"';
         const tag = attributes?.as || "div";

package/build/src/plugins/edge/tags.d.ts

@@ -0,0 +1,47 @@
+import { type TagContract } from 'edge.js/types';
+/**
+ * Edge tag that generates the root element for Inertia.js applications
+ *
+ * The @inertia tag creates a container element with encoded page data that Inertia.js
+ * uses to hydrate the client-side application. Supports customization through attributes.
+ *
+ * @example
+ * ```edge
+ * {{-- Basic usage with default div element and id="app" --}}
+ * @inertia()
+ *
+ * {{-- Custom element and attributes --}}
+ * @inertia({ as: 'main', id: 'app-root', class: 'min-h-screen' })
+ *
+ * {{-- Results in: --}}
+ * {{-- <main id="app-root" class="min-h-screen" data-page="{...encoded page data...}"></main> --}}
+ * ```
+ *
+ * Supported attributes:
+ * - `as`: HTML tag name for the root element (defaults to 'div')
+ * - `id`: Element ID (defaults to 'app')
+ * - `class`: CSS class names for the element
+ */
+export declare const inertiaTag: TagContract;
+/**
+ * Edge tag that renders server-side rendered head content for Inertia.js
+ *
+ * The @inertiaHead tag outputs head tags (title, meta, etc.) that were generated
+ * during server-side rendering. Only relevant when SSR is enabled.
+ *
+ * @example
+ * ```edge
+ * <!DOCTYPE html>
+ * <html>
+ * <head>
+ *   <meta charset="utf-8">
+ *   <meta name="viewport" content="width=device-width, initial-scale=1">
+ *   @inertiaHead()
+ * </head>
+ * <body>
+ *   @inertia()
+ * </body>
+ * </html>
+ * ```
+ */
+export declare const inertiaHeadTag: TagContract;

package/build/src/plugins/edge/utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Validates that an AST expression is one of the allowed expression types
+ *
+ * This utility function is used during Edge template compilation to ensure
+ * that only specific expression types are allowed in certain contexts.
+ *
+ * @param expression - The AST expression to validate
+ * @param expressions - Array of allowed expression type names
+ * @param errorCallback - Function to call when validation fails
+ *
+ * @example
+ * ```js
+ * // Ensure expression is either a literal or identifier
+ * isSubsetOf(astNode, ['Literal', 'Identifier'], () => {
+ *   throw new Error('Invalid expression type')
+ * })
+ *
+ * // Allow only object expressions
+ * isSubsetOf(astNode, ['ObjectExpression'], () => {
+ *   throw new EdgeError('Expected object expression')
+ * })
+ * ```
+ */
+export declare function isSubsetOf(expression: {
+    type: string;
+}, expressions: string[], errorCallback: () => void): void;

package/build/src/plugins/japa/api_client.d.ts

@@ -1,43 +1,157 @@
-import { PluginFn } from '@japa/runner/types';
-import { ApplicationService } from '@adonisjs/core/types';
-import { c as PageProps } from '../../../types-DVqEHBD1.js';
-import '@adonisjs/core/http';
-import '@tuyau/utils/types';
-
+import type { PluginFn } from '@japa/runner/types';
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { PageProps, InertiaPages } from '../../types.js';
 declare module '@japa/api-client' {
+    /**
+     * Extended ApiRequest interface with Inertia.js specific methods
+     *
+     * Adds methods to configure requests for testing Inertia applications,
+     * including setting required headers and configuring partial reloads.
+     */
     interface ApiRequest {
         /**
-         * Set `X-Inertia` header on the request
+         * Set `X-Inertia` header on the request to mark it as an Inertia request
+         *
+         * This method configures the request to be treated as an Inertia AJAX request
+         * by setting the required headers that Inertia.js uses for identification.
+         *
+         * @returns The ApiRequest instance for method chaining
+         *
+         * @example
+         * ```js
+         * const response = await client
+         *   .get('/dashboard')
+         *   .withInertia()
+         * ```
          */
-        withInertia(): this;
+        withInertia(this: ApiRequest): this;
         /**
-         * Set `X-Inertia-Partial-Data` and `X-Inertia-Partial-Component` headers on the request
+         * Set headers for partial data requests (partial reloads)
+         *
+         * Configures the request to only fetch specific props from a component,
+         * simulating Inertia's partial reload functionality in tests.
+         *
+         * @param component - The component name to partially reload
+         * @param props - Array of prop names to include in the partial request
+         * @returns The ApiRequest instance for method chaining
+         *
+         * @example
+         * ```js
+         * const response = await client
+         *   .get('/users')
+         *   .withInertiaPartialReload('Users/Index', ['users', 'pagination'])
+         * ```
          */
-        withInertiaPartialReload(component: string, data: string[]): this;
+        withInertiaPartialReload<K extends keyof InertiaPages>(this: ApiRequest, component: K, props: (keyof InertiaPages[K])[]): this;
     }
+    /**
+     * Extended ApiResponse interface with Inertia.js specific properties and assertions
+     *
+     * Provides getters for accessing Inertia response data and assertion methods
+     * for validating Inertia responses in tests.
+     */
     interface ApiResponse {
         /**
-         * The inertia component
+         * The name of the Inertia component returned in the response
+         *
+         * @example
+         * ```js
+         * console.log(response.inertiaComponent) // 'Users/Index'
+         * ```
          */
-        inertiaComponent?: string;
+        inertiaComponent?: keyof InertiaPages;
         /**
-         * The inertia response props
+         * The props data returned in the Inertia response
+         *
+         * @example
+         * ```js
+         * console.log(response.inertiaProps.users) // [{ id: 1, name: 'John' }]
+         * ```
          */
         inertiaProps: Record<string, any>;
         /**
-         * Assert component name of inertia response
+         * Assert that the response contains the expected Inertia component
+         *
+         * @param component - Expected component name
+         * @returns The ApiResponse instance for method chaining
+         *
+         * @throws AssertionError when component names don't match
+         *
+         * @example
+         * ```js
+         * response.assertInertiaComponent('Users/Index')
+         * ```
          */
-        assertInertiaComponent(component: string): this;
+        assertInertiaComponent(this: ApiResponse, component: string): this;
         /**
-         * Assert props to be exactly the same as the given props
+         * Assert that the response props exactly match the provided props
+         *
+         * @param props - Expected props object to match exactly
+         * @returns The ApiResponse instance for method chaining
+         *
+         * @throws AssertionError when props don't match exactly
+         *
+         * @example
+         * ```js
+         * response.assertInertiaProps({
+         *   users: [{ id: 1, name: 'John' }],
+         *   total: 1
+         * })
+         * ```
          */
-        assertInertiaProps(props: PageProps): this;
+        assertInertiaProps(this: ApiResponse, props: PageProps): this;
         /**
-         * Assert inertia props contains a subset of the given props
+         * Assert that the response props contain a subset of the provided props
+         *
+         * @param props - Expected subset of props to be present
+         * @returns The ApiResponse instance for method chaining
+         *
+         * @throws AssertionError when expected props are not found
+         *
+         * @example
+         * ```js
+         * response.assertInertiaPropsContains({
+         *   user: { name: 'John' }
+         * })
+         * ```
          */
-        assertInertiaPropsContains(props: PageProps): this;
+        assertInertiaPropsContains(this: ApiResponse, props: PageProps): this;
     }
 }
-declare function inertiaApiClient(app: ApplicationService): PluginFn;
-
-export { inertiaApiClient };
+/**
+ * Japa plugin that extends the API client with Inertia.js testing capabilities
+ *
+ * This plugin adds methods to ApiRequest and ApiResponse classes to support
+ * testing Inertia applications, including partial reloads and response assertions.
+ *
+ * @param app - The AdonisJS application service instance
+ * @returns Japa plugin function
+ *
+ * @example
+ * ```js
+ * // Configure in tests/bootstrap.ts
+ * import { inertiaApiClient } from '@adonisjs/inertia/plugins/japa/api_client'
+ *
+ * export const plugins: Config['plugins'] = [
+ *   assert(),
+ *   apiClient(app),
+ *   inertiaApiClient(app)
+ * ]
+ * ```
+ *
+ * @example
+ * ```js
+ * // Use in tests
+ * test('renders dashboard page', async ({ client }) => {
+ *   const response = await client
+ *     .get('/dashboard')
+ *     .withInertia()
+ *
+ *   response.assertInertiaComponent('Dashboard')
+ *   response.assertInertiaPropsContains({
+ *     user: { name: 'John' }
+ *   })
+ * })
+ * ```
+ */
+export declare function inertiaApiClient(app: ApplicationService): PluginFn;

package/build/src/plugins/japa/api_client.js

@@ -1,37 +1,38 @@
+import {
+  InertiaHeaders
+} from "../../../chunk-DISC5OYC.js";
+import "../../../chunk-MLKGABMK.js";
+
 // src/plugins/japa/api_client.ts
-import { configProvider } from "@adonisjs/core";
-import { RuntimeException } from "@poppinss/utils";
 import { ApiRequest, ApiResponse } from "@japa/api-client";
 function ensureIsInertiaResponse() {
   if (!this.header("x-inertia")) {
     throw new Error(
-      "Response is not an Inertia response. Make sure to call `withInertia()` on the request"
+      'Not an Inertia response. Make sure to use "withInertia()" method when making the request'
+    );
+  }
+}
+function ensureHasAssert(assertLib) {
+  if (!assertLib) {
+    throw new Error(
+      "Response assertions are not available. Make sure to install the @japa/assert plugin"
     );
   }
 }
 function inertiaApiClient(app) {
   return async () => {
-    const inertiaConfigProvider = app.config.get("inertia");
-    const config = await configProvider.resolve(app, inertiaConfigProvider);
-    if (!config) {
-      throw new RuntimeException(
-        'Invalid "config/inertia.ts" file. Make sure you are using the "defineConfig" method'
-      );
-    }
+    const inertiaConfig = app.config.get("inertia");
     ApiRequest.macro("withInertia", function() {
-      this.header("x-inertia", "true");
-      this.header("x-inertia-version", config.versionCache.getVersion().toString());
+      this.header(InertiaHeaders.Inertia, "true");
+      this.header(InertiaHeaders.Version, String(inertiaConfig.assetsVersion ?? "1"));
+      return this;
+    });
+    ApiRequest.macro("withInertiaPartialReload", function(component, data) {
+      this.withInertia();
+      this.header(InertiaHeaders.PartialComponent, component);
+      this.header(InertiaHeaders.PartialOnly, data.join(","));
       return this;
     });
-    ApiRequest.macro(
-      "withInertiaPartialReload",
-      function(component, data) {
-        this.withInertia();
-        this.header("X-Inertia-Partial-Data", data.join(","));
-        this.header("X-Inertia-Partial-Component", component);
-        return this;
-      }
-    );
     ApiResponse.getter("inertiaComponent", function() {
       ensureIsInertiaResponse.call(this);
       return this.body().component;
@@ -42,35 +43,22 @@ function inertiaApiClient(app) {
     });
     ApiResponse.macro("assertInertiaComponent", function(component) {
       ensureIsInertiaResponse.call(this);
-      this.assert.deepEqual(this.body().component, component);
+      ensureHasAssert(this.assert);
+      this.assert.equal(this.body().component, component);
+      return this;
+    });
+    ApiResponse.macro("assertInertiaProps", function(props) {
+      ensureIsInertiaResponse.call(this);
+      ensureHasAssert(this.assert);
+      this.assert.deepEqual(this.body().props, props);
+      return this;
+    });
+    ApiResponse.macro("assertInertiaPropsContains", function(props) {
+      ensureIsInertiaResponse.call(this);
+      ensureHasAssert(this.assert);
+      this.assert.containSubset(this.body().props, props);
       return this;
     });
-    ApiResponse.macro(
-      "assertInertiaProps",
-      function(props) {
-        if (!this.assert) {
-          throw new Error(
-            "Response assertions are not available. Make sure to install the @japa/assert plugin"
-          );
-        }
-        ensureIsInertiaResponse.call(this);
-        this.assert.deepEqual(this.body().props, props);
-        return this;
-      }
-    );
-    ApiResponse.macro(
-      "assertInertiaPropsContains",
-      function(props) {
-        if (!this.assert) {
-          throw new Error(
-            "Response assertions are not available. Make sure to install the @japa/assert plugin"
-          );
-        }
-        ensureIsInertiaResponse.call(this);
-        this.assert.containsSubset(this.body().props, props);
-        return this;
-      }
-    );
   };
 }
 export {