@gravito/ion 3.1.0 → 4.0.0

package/dist/index.js

@@ -65,8 +65,71 @@ var InertiaService = class {
     this.onRenderCallback = config.onRender;
   }
   sharedProps = {};
+  errorBags = {};
+  encryptHistoryFlag = false;
+  clearHistoryFlag = false;
   logLevel;
   onRenderCallback;
+  /**
+   * Creates a deferred prop that will be loaded after the initial render.
+   *
+   * @param factory - Function that resolves to the prop value.
+   * @param group - Optional group name for organizing deferred props.
+   * @returns A deferred prop definition.
+   *
+   * @example
+   * ```typescript
+   * props: {
+   *   user: { id: 1 },
+   *   stats: InertiaService.defer(() => fetchStats())
+   * }
+   * ```
+   */
+  static defer(factory, group = "default") {
+    return {
+      _type: "deferred",
+      factory,
+      group
+    };
+  }
+  /**
+   * Marks a prop to be merged (shallow) with existing data during partial reloads.
+   *
+   * @param value - The prop value to merge.
+   * @param matchOn - Optional key(s) to match on when merging arrays.
+   * @returns A merge prop definition.
+   */
+  static merge(value, matchOn) {
+    return {
+      _type: "merge",
+      value,
+      matchOn
+    };
+  }
+  /**
+   * Marks a prop to prepend to an array during partial reloads.
+   *
+   * @param value - The prop value to prepend.
+   * @returns A prepend prop definition.
+   */
+  static prepend(value) {
+    return {
+      _type: "prepend",
+      value
+    };
+  }
+  /**
+   * Marks a prop to be deep-merged with existing data during partial reloads.
+   *
+   * @param value - The prop value to deep merge.
+   * @returns A deep merge prop definition.
+   */
+  static deepMerge(value) {
+    return {
+      _type: "deepMerge",
+      value
+    };
+  }
   /**
    * Internal logging helper that respects the configured log level.
    *
@@ -154,10 +217,14 @@ var InertiaService = class {
         const partialData = this.context.req.header("X-Inertia-Partial-Data");
         const partialExcept = this.context.req.header("X-Inertia-Partial-Except");
         const partialComponent = this.context.req.header("X-Inertia-Partial-Component");
+        const resetKeys = this.context.req.header("X-Inertia-Reset");
         const isPartial = partialComponent === component;
         const only = partialData && isPartial ? partialData.split(",") : [];
         const except = partialExcept && isPartial ? partialExcept.split(",") : [];
+        const resetKeyList = resetKeys ? resetKeys.split(",") : [];
         const resolved = {};
+        const deferredGroups2 = {};
+        const mergedKeys2 = [];
         for (const [key, value] of Object.entries(p)) {
           if (only.length > 0 && !only.includes(key)) {
             continue;
@@ -165,6 +232,33 @@ var InertiaService = class {
           if (except.length > 0 && except.includes(key)) {
             continue;
           }
+          if (value && typeof value === "object" && "_type" in value && value._type === "deferred") {
+            const deferred = value;
+            const group = deferred.group ?? "default";
+            if (!deferredGroups2[group]) {
+              deferredGroups2[group] = [];
+            }
+            deferredGroups2[group].push(key);
+            continue;
+          }
+          if (value && typeof value === "object" && "_type" in value && ["merge", "prepend", "deepMerge"].includes(value._type)) {
+            const merged = value;
+            const existing = mergedKeys2.find((m) => m.mode === merged._type);
+            if (existing) {
+              existing.keys.push(key);
+            } else {
+              mergedKeys2.push({
+                keys: [key],
+                mode: merged._type
+              });
+            }
+            resolved[key] = merged.value;
+            continue;
+          }
+          if (resetKeyList.includes(key)) {
+            resolved[key] = void 0;
+            continue;
+          }
           if (typeof value === "function") {
             const propStart = performance.now();
             try {
@@ -180,7 +274,7 @@ var InertiaService = class {
             resolved[key] = value;
           }
         }
-        return resolved;
+        return { resolved, deferredGroups: deferredGroups2, mergedKeys: mergedKeys2 };
       };
       const resolveVersion = async () => {
         if (typeof this.config.version === "function") {
@@ -196,12 +290,32 @@ var InertiaService = class {
         }
         return { ...this.sharedProps, ...propsToMerge };
       };
+      const {
+        resolved: resolvedPropsData,
+        deferredGroups,
+        mergedKeys
+      } = await resolveProps(getMergedProps());
       const page = {
         component,
-        props: await resolveProps(getMergedProps()),
+        props: resolvedPropsData,
         url: pageUrl,
         version
       };
+      if (Object.keys(deferredGroups).length > 0) {
+        page.deferredProps = deferredGroups;
+      }
+      if (mergedKeys.length > 0) {
+        page.mergeProps = mergedKeys;
+      }
+      if (this.encryptHistoryFlag) {
+        page.encryptHistory = true;
+      }
+      if (this.clearHistoryFlag) {
+        page.clearHistory = true;
+      }
+      if (Object.keys(this.errorBags).length > 0) {
+        page.errorBags = this.errorBags;
+      }
       let pageJson;
       try {
         pageJson = JSON.stringify(page);
@@ -290,6 +404,42 @@ var InertiaService = class {
         duration: `${duration.toFixed(2)}ms`,
         error
       });
+      const isDev = process.env.NODE_ENV !== "production";
+      if (isDev && error instanceof Error) {
+        const errorHtml = `
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1">
+              <title>Inertia Render Error</title>
+              <style>
+                * { margin: 0; padding: 0; box-sizing: border-box; }
+                body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto; background: #f5f5f5; padding: 20px; }
+                .container { max-width: 800px; margin: 40px auto; background: white; border-radius: 8px; padding: 30px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
+                h1 { color: #d32f2f; margin-bottom: 10px; font-size: 24px; }
+                .meta { color: #666; margin-bottom: 20px; font-size: 14px; }
+                .component { background: #f5f5f5; padding: 10px 15px; border-left: 3px solid #1976d2; margin-bottom: 20px; font-family: monospace; }
+                .error-message { background: #ffebee; border: 1px solid #ef5350; border-radius: 4px; padding: 15px; margin-bottom: 20px; color: #c62828; }
+                .stack { background: #f5f5f5; border: 1px solid #ddd; border-radius: 4px; padding: 15px; overflow-x: auto; font-family: monospace; font-size: 12px; color: #333; line-height: 1.5; }
+                .hint { background: #e8f5e9; border-left: 3px solid #4caf50; padding: 15px; margin-top: 20px; color: #2e7d32; }
+              </style>
+            </head>
+            <body>
+              <div class="container">
+                <h1>\u{1F6A8} Inertia Render Error</h1>
+                <div class="meta">Component: <span class="component">${component}</span></div>
+                <div class="error-message">${error.message || "Unknown error"}</div>
+                ${error.stack ? `<div><strong>Stack Trace:</strong><div class="stack">${error.stack.split("\n").map((line) => line.replace(/</g, "&lt;").replace(/>/g, "&gt;")).join("\n")}</div></div>` : ""}
+                <div class="hint">
+                  <strong>\u{1F4A1} Dev Mode Tip:</strong> This enhanced error page is only visible in development mode. In production, a generic error message is shown.
+                </div>
+              </div>
+            </body>
+          </html>
+        `;
+        return this.context.html(errorHtml, 500);
+      }
       return new Response("Inertia Render Error", { status: 500 });
     }
   }
@@ -330,7 +480,7 @@ var InertiaService = class {
    * ```
    */
   shareAll(props) {
-    Object.assign(this.sharedProps, props);
+    this.sharedProps = { ...this.sharedProps, ...props };
   }
   /**
    * Returns a shallow copy of the current shared props.
@@ -350,6 +500,94 @@ var InertiaService = class {
   getSharedProps() {
     return { ...this.sharedProps };
   }
+  /**
+   * Instructs the Inertia client to navigate to a different URL.
+   *
+   * For Inertia AJAX requests, this returns a 409 Conflict with the `X-Inertia-Location` header.
+   * For regular page loads, this returns a 302 Found redirect.
+   *
+   * This is useful for server-side redirects triggered by authentication or authorization checks.
+   *
+   * @param url - The URL to redirect to.
+   * @returns A redirect response.
+   *
+   * @example
+   * ```typescript
+   * if (!ctx.get('user')) {
+   *   return inertia.location('/login');
+   * }
+   * ```
+   */
+  location(url) {
+    const isInertiaRequest = Boolean(this.context.req.header("X-Inertia"));
+    if (isInertiaRequest) {
+      this.context.header("X-Inertia-Location", url);
+      return new Response("", { status: 409 });
+    }
+    this.context.header("Location", url);
+    return new Response("", { status: 302 });
+  }
+  /**
+   * Controls whether the Inertia client should encrypt browser history.
+   *
+   * When enabled, history is not written to the browser's History API,
+   * preventing users from using the browser back button to return to previous pages.
+   *
+   * @param encrypt - Whether to encrypt history (defaults to true).
+   * @returns The service instance for method chaining.
+   *
+   * @example
+   * ```typescript
+   * return await inertia.encryptHistory(true).render('SecurePage');
+   * ```
+   */
+  encryptHistory(encrypt = true) {
+    this.encryptHistoryFlag = encrypt;
+    return this;
+  }
+  /**
+   * Clears the browser history after the page load.
+   *
+   * Useful for sensitive operations or multi-step wizards where you don't want
+   * users navigating back to previous states.
+   *
+   * @returns The service instance for method chaining.
+   *
+   * @example
+   * ```typescript
+   * return await inertia.clearHistory().render('SuccessPage');
+   * ```
+   */
+  clearHistory() {
+    this.clearHistoryFlag = true;
+    return this;
+  }
+  /**
+   * Registers form validation errors organized into named bags.
+   *
+   * Error bags allow multiple validation failure scenarios to coexist.
+   * For example, you might have 'default' errors and 'import' errors from different forms.
+   *
+   * @param errors - Validation errors, with field names as keys and error messages as values.
+   * @param bag - The error bag name (defaults to 'default').
+   * @returns The service instance for method chaining.
+   *
+   * @example
+   * ```typescript
+   * inertia.withErrors({
+   *   email: 'Email is required',
+   *   password: 'Must be 8+ characters'
+   * }, 'login');
+   *
+   * inertia.withErrors({
+   *   line_1: 'Invalid CSV format'
+   * }, 'import');
+   * ```
+   */
+  withErrors(errors, bag = "default") {
+    this.errorBags[bag] = errors;
+    return this;
+  }
 };
 
 // src/index.ts
@@ -381,9 +619,35 @@ var OrbitIon = class {
     core.logger.info("\u{1F6F0}\uFE0F Orbit Inertia installed (Callable Interface)");
     const appVersion = this.options.version ?? core.config.get("APP_VERSION", "1.0.0");
     const rootView = this.options.rootView ?? "app";
+    const csrfEnabled = this.options.csrf?.enabled !== false;
+    const csrfCookieName = this.options.csrf?.cookieName ?? "XSRF-TOKEN";
+    const VERSION_CACHE_TTL = 6e4;
+    let cachedVersion;
+    let versionCacheTime = 0;
+    const resolveAppVersion = async () => {
+      if (typeof appVersion !== "function") {
+        return appVersion;
+      }
+      const now = Date.now();
+      if (cachedVersion && now - versionCacheTime < VERSION_CACHE_TTL) {
+        return cachedVersion;
+      }
+      cachedVersion = await appVersion();
+      versionCacheTime = now;
+      return cachedVersion;
+    };
+    if (csrfEnabled) {
+      core.adapter.use("*", async (c, next) => {
+        const token = crypto.randomUUID();
+        const secure = process.env.NODE_ENV === "production";
+        const cookieValue = `${csrfCookieName}=${token}; Path=/; ${secure ? "Secure; " : ""}SameSite=Lax`;
+        c.header("Set-Cookie", cookieValue);
+        return await next();
+      });
+    }
     core.adapter.use("*", async (c, next) => {
       const service = new InertiaService(c, {
-        version: appVersion,
+        version: resolveAppVersion,
         rootView,
         ssr: this.options.ssr
       });
@@ -395,6 +659,10 @@ var OrbitIon = class {
         shareAll: service.shareAll.bind(service),
         getSharedProps: service.getSharedProps.bind(service),
         render: service.render.bind(service),
+        location: service.location.bind(service),
+        encryptHistory: service.encryptHistory.bind(service),
+        clearHistory: service.clearHistory.bind(service),
+        withErrors: service.withErrors.bind(service),
         service
       });
       c.set("inertia", inertiaProxy);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gravito/ion",
-  "version": "3.1.0",
-  "description": "Inertia.js adapter for Gravito",
+  "version": "4.0.0",
+  "description": "Inertia.js v2 adapter for Gravito",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "type": "module",