@dudousxd/nestjs-inertia-client 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,72 @@
+# Changelog — @dudousxd/nestjs-inertia-client
+
+## 1.0.0
+
+### Minor Changes
+
+- [`c5878e3`](https://github.com/DavideCarvalho/nestjs-inertia/commit/c5878e3f8827d9e89710df0154ea76996b6db62a) - First public release — Inertia.js v3 adapter for NestJS.
+
+  - Core: InertiaModule.forRoot/forRootAsync/forFeature, @Inertia decorator, Inertia.optional/defer/merge/always markers, CSRF with tokenContext, SSR support, Express + Fastify adapters
+  - Vite: setupInertiaVite + nestInertia plugin, @inertia/@vite/@inertiaHead shell directives
+  - Codegen: nestjs-inertia init (full scaffold + auto-patch), auto-watch in dev, static AST discovery, class-validator DTO support, Route/Path type helpers, @As hierarchical naming
+  - Client: defineContract + @ApplyContract, typed Link for React/Vue/Svelte with context providers, createFetcher, SSR hydration, rich error messages
+  - Testing: expectInertia matchers, assertInertia, InertiaTestingModule, fakes
+
+### Patch Changes
+
+- Updated dependencies [[`c5878e3`](https://github.com/DavideCarvalho/nestjs-inertia/commit/c5878e3f8827d9e89710df0154ea76996b6db62a)]:
+  - @dudousxd/nestjs-inertia@1.0.0
+
+For the full repository changelog see [`../../CHANGELOG.md`](../../CHANGELOG.md).
+
+## 0.9.0-alpha.0 — 2026-05-22
+
+### Changed
+
+- Broadened peer deps: `@inertiajs/react ^2||^3`, `@inertiajs/vue3 ^2||^3`, `react ^18||^19`
+- Svelte `Link` component migrated to Svelte 5 Runes API (`$props` / `$derived` / children snippet)
+- `Link.svelte` is now copied to `dist/svelte/` as part of the build
+- Version bump to `0.9.0-alpha.0` (Inertia v3 monorepo coordination)
+
+## 0.8.0-alpha.0 — 2026-05-22
+
+### Added
+
+- **Typed `<Link>` for React** (`/react` subpath) — `<Link route="..." routeParams={{...}}>` with full TypeScript autocompletion; `routeParams` is omitted when the route has no dynamic segments
+- **Typed `<Link>` for Vue 3** (`/vue` subpath) — same typed API via a Vue 3 component; wraps `@inertiajs/vue3`'s `Link`
+- **Typed `<Link>` for Svelte** (`/svelte` subpath) — same typed API as a Svelte 5 component; wraps `@inertiajs/svelte`'s `Link`
+- **`setRouteResolver(fn)`** — boot-time helper to wire the codegen-emitted `route()` function into all typed `Link` components; call once in your entry file
+- **`RegistryRoutes` consumption** — `Link` components read typed route names and params from the `InertiaRegistry` augmentation emitted by codegen `init`
+
+### Changed
+
+- Version bump to `0.8.0-alpha.0`
+
+## 0.7.0-alpha.0 — 2026-05-22
+
+### Changed
+
+- Bundled with example app, CI workflows, Changesets, MIT LICENSE, and slim docs.
+
+## [0.6.0-alpha.0] - 2026-05-22
+
+### Added
+
+- **Initial release** of `@dudousxd/nestjs-inertia-client`
+- **`Contract` builders** — `Contract.get`, `.post`, `.put`, `.patch`, `.delete`; each accepts a URL path and a definition with optional `query` / `body` and required `response` Zod schemas, returning a typed `ContractDef`
+- **`@ApplyContract(contractDef)`** — NestJS method decorator that stores the contract under `CONTRACT_METADATA` (`Reflect` metadata) on the handler; enables codegen contract discovery and `api.ts` emission
+- **`CONTRACT_METADATA` symbol** + **`getContract(target, key)`** helper for reading contract metadata
+- **`createFetcher(opts?): Fetcher`** — thin `fetch` wrapper
+  - `buildUrl` path-param interpolation (`:param` → value) + `URLSearchParams` query-string serialization
+  - JSON body encoding (`Content-Type: application/json`) and `FormData` passthrough (no `Content-Type` override)
+  - `Accept: application/json` default header
+  - `ApiHttpError` thrown on non-2xx responses, with static `fromResponse(res)` async factory
+  - `onError` hook called before re-throwing
+  - Pluggable `fetch` implementation via `opts.fetch` (useful in tests and SSR)
+  - HTTP 204 → returns `undefined`
+- **`ApiHttpError`** — error class with `.status: number`, `.body: unknown`, and `.response: Response`
+- **`invalidate(queryClient, queryKey)`** — convenience wrapper around `queryClient.invalidateQueries`
+- **SSR hydration** (`./ssr` subpath export)
+  - `hydrateClientFromInertia(page)` — creates a `QueryClient` pre-seeded from `page.props._initialQueries`
+  - `seedInitialQueries(qc)` — serialises the full `QueryClient` cache into the `_initialQueries` array for Inertia shared props
+- **Full Vitest test suite** — 47 tests covering all exports

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Davide Carvalho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,274 @@
+# @dudousxd/nestjs-inertia-client
+
+Tuyau-style typed HTTP client for `@dudousxd/nestjs-inertia`, built on TanStack Query v5 core.
+
+[![npm version](https://img.shields.io/npm/v/@dudousxd/nestjs-inertia-client)](https://www.npmjs.com/package/@dudousxd/nestjs-inertia-client)
+
+> Alpha — in active development. API may change before 1.0.
+
+## Install
+
+```bash
+pnpm add @dudousxd/nestjs-inertia-client @tanstack/query-core zod
+```
+
+## Quick Start
+
+### 1. Define a Contract
+
+```ts
+import { defineContract } from '@dudousxd/nestjs-inertia-client';
+import { z } from 'zod';
+
+export const listUsersContract = defineContract({
+  query: z.object({ page: z.number().optional() }),
+  response: z.array(z.object({ id: z.string(), name: z.string() })),
+});
+
+export const createUserContract = defineContract({
+  body: z.object({ name: z.string(), email: z.string().email() }),
+  response: z.object({ id: z.string(), name: z.string() }),
+});
+```
+
+Contracts carry **no** `name`, `method`, or `path` — these are all routing concerns handled by NestJS decorators and codegen.
+
+### 2. How the API name is derived
+
+The API name is composed from a **class portion** and a **method portion**, joined with a dot:
+
+- **Class portion**: class-level `@As(...)` value if present, otherwise the class name with `Controller` stripped and first letter lowercased.
+- **Method portion**: method-level `@As(...)` value if present, otherwise the method name.
+- **Final name**: `${classPortion}.${methodPortion}`
+
+| Class-level `@As` | Method-level `@As` | Derived API name |
+|---|---|---|
+| absent | absent | `<classNameStripped>.<methodName>` (default) |
+| `@As('users')` | absent | `users.<methodName>` |
+| absent | `@As('directory')` | `<classNameStripped>.directory` |
+| `@As('users')` | `@As('directory')` | `users.directory` |
+| `@As('users.admin')` | `@As('list')` | `users.admin.list` |
+
+Examples:
+
+| Controller class | Method | Derived API name |
+|------------------|--------|-----------------|
+| `UsersController` | `list` | `users.list` → `api.users.list` |
+| `UsersController` | `create` | `users.create` → `api.users.create` |
+| `AdminUsersController` | `list` | `adminUsers.list` → `api.adminUsers.list` |
+
+To override, use `@As` at the class level, method level, or both:
+
+```ts
+import { As } from '@dudousxd/nestjs-inertia-client';
+
+// Class-level @As sets the class portion for all methods
+@Controller('/api/users')
+@As('users')
+class UsersController {
+  @Get()
+  @ApplyContract(listUsersContract)
+  list() { ... }              // → 'users.list'
+
+  @Get('/top')
+  @ApplyContract(listUsersContract)
+  @As('directory')            // → 'users.directory'
+  listDirectory() { ... }
+}
+```
+
+### 3. Bind a Contract to a NestJS Handler with `@ApplyContract`
+
+```ts
+import { Controller, Get, Post } from '@nestjs/common';
+import { ApplyContract } from '@dudousxd/nestjs-inertia-client';
+import { listUsersContract, createUserContract } from './contracts.js';
+
+@Controller()
+export class UserController {
+  @Get('/users')
+  @ApplyContract(listUsersContract)
+  listUsers() { /* ... */ }
+
+  @Post('/users')
+  @ApplyContract(createUserContract)
+  createUser() { /* ... */ }
+}
+```
+
+`@ApplyContract` only attaches the contract metadata (`CONTRACT_METADATA`) — it does **not** set the NestJS routing path or HTTP method. Always pair it with a NestJS HTTP verb decorator (`@Get`, `@Post`, `@Put`, `@Patch`, `@Delete`). `@dudousxd/nestjs-inertia-codegen` reads both the verb decorator and the contract to emit a typed `api.ts`.
+
+### Alternative: class-validator DTOs (no `defineContract` needed)
+
+If you already use class-validator DTOs and `@nestjs/swagger`, the codegen reads types automatically — no `defineContract` required:
+
+```ts
+import { Body, Controller, Get, Post, Query } from '@nestjs/common';
+import { ApiResponse } from '@nestjs/swagger';
+
+class ListPostsQuery { page?: number; }
+class PostDto { id: string; title: string; }
+class CreatePostBody { title: string; content: string; }
+
+@Controller('/api/posts')
+export class PostsController {
+  @Get()
+  @ApiResponse({ type: [PostDto] })
+  list(@Query() query: ListPostsQuery): Promise<PostDto[]> { ... }
+
+  @Post()
+  @ApiResponse({ type: PostDto })
+  create(@Body() body: CreatePostBody): Promise<PostDto> { ... }
+}
+```
+
+The codegen extracts `@Body()` → body type, `@Query()` → query type, `@ApiResponse({ type })` → response type, and return type annotation as a fallback. When `@ApplyContract` is present, Zod schemas take full priority and DTO extraction is skipped for that method.
+
+### 4. Create a Fetcher and Call Endpoints
+
+```ts
+import { createFetcher } from '@dudousxd/nestjs-inertia-client';
+
+const fetcher = createFetcher({
+  baseUrl: 'http://localhost:3000',
+  headers: () => ({
+    Authorization: `Bearer ${getToken()}`,
+  }),
+});
+
+// GET /users?page=1
+const users = await fetcher.get<User[]>('/users', { query: { page: 1 } });
+
+// POST /users
+const newUser = await fetcher.post<User>('/users', {
+  body: { name: 'Alice', email: 'alice@example.com' },
+});
+```
+
+The generated `api.ts` (emitted by `nestjs-inertia codegen`) wraps `createFetcher` with full request/response types derived from your contracts.
+
+### 5. Handle Errors
+
+```ts
+import { ApiHttpError } from '@dudousxd/nestjs-inertia-client';
+
+try {
+  await fetcher.post('/users', { body: { name: '' } });
+} catch (err) {
+  if (err instanceof ApiHttpError) {
+    console.error(err.status, err.body);
+  }
+}
+```
+
+## Type helpers (generated `api.ts`)
+
+The generated `api.ts` exports `Route.*` and `Path.*` namespaces for compile-time access to request/response shapes:
+
+```ts
+import type { Route, Path } from '.nestjs-inertia/api.js';
+
+// by contract name
+type UserList = Route.Response<'users.list'>;
+type CreateReq = Route.Request<'users.create'>;
+// → { body: ...; query: ...; params: ... }
+
+// by HTTP method + URL
+type ListResp = Path.Response<'GET', '/api/users'>;
+type CreateBody = Path.Body<'POST', '/api/users'>;
+```
+
+Use `Route.*` and `Path.*` — they are the canonical type helpers.
+
+## SSR Hydration
+
+Import SSR helpers from the `/ssr` subpath:
+
+```ts
+import {
+  hydrateClientFromInertia,
+  seedInitialQueries,
+} from '@dudousxd/nestjs-inertia-client/ssr';
+import { QueryClient } from '@tanstack/query-core';
+```
+
+### Server side (NestJS)
+
+```ts
+// In your Inertia controller, seed the QueryClient and attach its cache to shared props
+const qc = new QueryClient();
+await qc.prefetchQuery({ queryKey: ['users'], queryFn: fetchUsers });
+
+return inertia.render('Dashboard', {
+  _initialQueries: seedInitialQueries(qc),
+});
+```
+
+### Client side
+
+```ts
+// In your client entry point, rehydrate from Inertia's page props
+const page = window.__INERTIA_PAGE__;   // or however you access the Inertia page object
+const queryClient = hydrateClientFromInertia(page);
+```
+
+This avoids a second network round-trip for data the server already fetched during SSR.
+
+## API Reference
+
+### `defineContract(def)`
+
+Creates a typed contract definition. Accepts:
+
+| Field | Required | Description |
+|---|---|---|
+| `response` | yes | Zod schema for the response body |
+| `query` | no | Zod schema for URL query parameters |
+| `body` | no | Zod schema for the request body |
+| `params` | no | Zod schema for path parameters |
+| `error` | no | Zod schema for error responses |
+
+No `name`, `method`, or `path` — naming and routing come from NestJS decorators and codegen derivation.
+
+### `@As(name)`
+
+Override the auto-derived route name at the controller **class** or **method** level (or both). When applied at both levels the values compose: `${classAs}.${methodAs}`. Each dot-separated segment must match `/^[a-z][a-zA-Z0-9]*$/`.
+
+### `@ApplyContract(contractDef, opts?)`
+
+NestJS method decorator. Attaches the contract to the handler via `Reflect` metadata under `CONTRACT_METADATA`. Does **not** set HTTP method or path — always combine with `@Get`, `@Post`, etc.
+
+Options:
+
+| Option | Default | Description |
+|---|---|---|
+| `validate` | `false` | When `true`, installs a `ContractValidationPipe` that validates `body` and `query` against Zod schemas at runtime |
+
+### `createFetcher(opts?): Fetcher`
+
+Creates a typed fetch wrapper. Options:
+
+| Option | Type | Description |
+|---|---|---|
+| `baseUrl` | `string` | Prepended to every request path |
+| `headers` | `() => Record<string, string>` | Dynamic headers (auth tokens, etc.) |
+| `fetch` | `typeof fetch` | Custom fetch implementation (useful in tests) |
+| `onError` | `(err: ApiHttpError) => void` | Called before an `ApiHttpError` is thrown |
+
+### `ApiHttpError`
+
+Thrown when the server responds with a non-2xx status. Properties: `.status: number`, `.body: unknown`.
+
+### `invalidate(queryClient, queryKey)`
+
+Convenience wrapper around `queryClient.invalidateQueries({ queryKey })`.
+
+## See Also
+
+- Design spec: [`docs/superpowers/specs/2026-05-22-nestjs-inertia-plan-d-design.md`](../../docs/superpowers/specs/2026-05-22-nestjs-inertia-plan-d-design.md)
+- Codegen (emits `api.ts`): [`packages/codegen/README.md`](../codegen/README.md)
+- Implementation plan: [`docs/superpowers/plans/2026-05-22-nestjs-inertia-plan-d-client.md`](../../docs/superpowers/plans/2026-05-22-nestjs-inertia-plan-d-client.md)
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,294 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiHttpError: () => ApiHttpError,
+  ApplyContract: () => ApplyContract,
+  As: () => As,
+  CONTRACT_METADATA: () => CONTRACT_METADATA,
+  ContractValidationPipe: () => ContractValidationPipe,
+  ROUTE_NAME_METADATA: () => ROUTE_NAME_METADATA,
+  VERSION: () => VERSION,
+  buildUrl: () => buildUrl,
+  createFetcher: () => createFetcher,
+  defineContract: () => defineContract,
+  getContract: () => getContract,
+  invalidate: () => invalidate
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/fetcher/errors.ts
+var ApiHttpError = class _ApiHttpError extends Error {
+  static {
+    __name(this, "ApiHttpError");
+  }
+  status;
+  statusText;
+  body;
+  constructor(status, statusText, body) {
+    super(`HTTP ${status} ${statusText}`), this.status = status, this.statusText = statusText, this.body = body;
+    this.name = "ApiHttpError";
+  }
+  get isUnauthorized() {
+    return this.status === 401;
+  }
+  get isForbidden() {
+    return this.status === 403;
+  }
+  get isNotFound() {
+    return this.status === 404;
+  }
+  get isClient() {
+    return this.status >= 400 && this.status < 500;
+  }
+  get isServer() {
+    return this.status >= 500;
+  }
+  /**
+  * Returns a JSON-serializable representation of the error.
+  * The `body` field is **redacted by default** to prevent accidental logging of
+  * sensitive response bodies (e.g. API error payloads that may contain PII).
+  *
+  * Pass `verbose = true` to include the full body in the output.
+  *
+  * @example
+  * ```ts
+  * // Safe: body is redacted
+  * JSON.stringify(err);                  // { ..., body: '[redacted]' }
+  *
+  * // Verbose: includes full body (use only in trusted contexts)
+  * JSON.stringify(err.toJSON(true));     // { ..., body: { message: '...' } }
+  * ```
+  */
+  toJSON(verbose = false) {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      statusText: this.statusText,
+      body: verbose ? this.body : "[redacted \u2014 pass verbose=true to include]"
+    };
+  }
+  static async fromResponse(res) {
+    const ct = res.headers.get("content-type") ?? "";
+    const body = ct.includes("application/json") ? await res.json().catch(() => null) : await res.text().catch(() => "");
+    return new _ApiHttpError(res.status, res.statusText, body);
+  }
+};
+
+// src/fetcher/url-builder.ts
+function buildUrl(path, opts = {}, baseUrl) {
+  let resolved = path.replace(/:(\w+)/g, (_match, key) => {
+    const val = opts.params?.[key];
+    if (val === void 0 || val === null) {
+      throw new Error(`Missing param: ${key}`);
+    }
+    return encodeURIComponent(String(val));
+  });
+  const qs = new URLSearchParams();
+  if (opts.query) {
+    for (const [k, v] of Object.entries(opts.query)) {
+      if (v !== void 0) {
+        qs.set(k, String(v));
+      }
+    }
+  }
+  const qsStr = qs.toString();
+  if (qsStr) resolved += `?${qsStr}`;
+  if (baseUrl) {
+    const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    return base + resolved;
+  }
+  return resolved;
+}
+__name(buildUrl, "buildUrl");
+
+// src/fetcher/fetcher.ts
+function isFormData(b) {
+  return typeof FormData !== "undefined" && b instanceof FormData;
+}
+__name(isFormData, "isFormData");
+function createFetcher(opts = {}) {
+  const fetchImpl = opts.fetch ?? globalThis.fetch;
+  const baseUrl = opts.baseUrl ?? "";
+  async function request(method, path, ro = {}) {
+    if (!fetchImpl) {
+      throw new Error("No fetch implementation: pass opts.fetch or set globalThis.fetch");
+    }
+    const url = buildUrl(path, ro, baseUrl);
+    const headers = {
+      ...opts.headers?.()
+    };
+    let body = void 0;
+    if (ro.body !== void 0) {
+      if (isFormData(ro.body)) {
+        body = ro.body;
+      } else {
+        body = JSON.stringify(ro.body);
+        headers["content-type"] = "application/json";
+      }
+    }
+    if (!headers.accept) {
+      headers.accept = "application/json";
+    }
+    const res = await fetchImpl(url, {
+      method,
+      headers,
+      ...body !== void 0 ? {
+        body
+      } : {}
+    });
+    if (!res.ok) {
+      const err = await ApiHttpError.fromResponse(res);
+      opts.onError?.(err);
+      throw err;
+    }
+    if (res.status === 204) return void 0;
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json")) return await res.json();
+    return await res.text();
+  }
+  __name(request, "request");
+  return {
+    get: /* @__PURE__ */ __name((p, ro) => request("GET", p, ro), "get"),
+    post: /* @__PURE__ */ __name((p, ro) => request("POST", p, ro), "post"),
+    put: /* @__PURE__ */ __name((p, ro) => request("PUT", p, ro), "put"),
+    patch: /* @__PURE__ */ __name((p, ro) => request("PATCH", p, ro), "patch"),
+    delete: /* @__PURE__ */ __name((p, ro) => request("DELETE", p, ro), "delete")
+  };
+}
+__name(createFetcher, "createFetcher");
+
+// src/contract/contract.ts
+function defineContract(def) {
+  return def;
+}
+__name(defineContract, "defineContract");
+
+// src/contract/apply-contract.decorator.ts
+var import_common2 = require("@nestjs/common");
+
+// src/contract/contract-validation.pipe.ts
+var import_common = require("@nestjs/common");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var ContractValidationPipe = class {
+  static {
+    __name(this, "ContractValidationPipe");
+  }
+  contract;
+  constructor(contract) {
+    this.contract = contract;
+  }
+  transform(value, metadata) {
+    let schema;
+    if (metadata.type === "body" && this.contract.body) {
+      schema = this.contract.body;
+    } else if (metadata.type === "query" && this.contract.query) {
+      schema = this.contract.query;
+    } else {
+      return value;
+    }
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+      throw new import_common.BadRequestException({
+        message: "Contract validation failed",
+        issues: parsed.error.issues
+      });
+    }
+    return parsed.data;
+  }
+};
+ContractValidationPipe = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof C === "undefined" ? Object : C
+  ])
+], ContractValidationPipe);
+
+// src/contract/metadata.ts
+var CONTRACT_METADATA = /* @__PURE__ */ Symbol.for("nestjs-inertia:contract");
+function getContract(target) {
+  if (typeof target !== "function") return void 0;
+  return Reflect.getMetadata(CONTRACT_METADATA, target) ?? void 0;
+}
+__name(getContract, "getContract");
+
+// src/contract/apply-contract.decorator.ts
+function ApplyContract(c, opts = {}) {
+  const decorators = [
+    (0, import_common2.SetMetadata)(CONTRACT_METADATA, c)
+  ];
+  if (opts.validate) {
+    decorators.push((0, import_common2.UsePipes)(new ContractValidationPipe(c)));
+  }
+  return (0, import_common2.applyDecorators)(...decorators);
+}
+__name(ApplyContract, "ApplyContract");
+
+// src/contract/as.decorator.ts
+var import_common3 = require("@nestjs/common");
+var ROUTE_NAME_METADATA = /* @__PURE__ */ Symbol.for("nestjs-inertia:route-name");
+var As = /* @__PURE__ */ __name((name) => (0, import_common3.SetMetadata)(ROUTE_NAME_METADATA, name), "As");
+
+// src/invalidate.ts
+function invalidate(qc, name, queryArgs) {
+  const queryKey = queryArgs === void 0 ? [
+    name
+  ] : [
+    name,
+    queryArgs
+  ];
+  return qc.invalidateQueries({
+    queryKey
+  });
+}
+__name(invalidate, "invalidate");
+
+// src/index.ts
+var VERSION = "1.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiHttpError,
+  ApplyContract,
+  As,
+  CONTRACT_METADATA,
+  ContractValidationPipe,
+  ROUTE_NAME_METADATA,
+  VERSION,
+  buildUrl,
+  createFetcher,
+  defineContract,
+  getContract,
+  invalidate
+});
+//# sourceMappingURL=index.cjs.map