@tuyau/core 1.0.0-beta.2 → 1.0.0-beta.4

package/build/backend/generate_registry.js

@@ -31,6 +31,46 @@ function generateRouteParams(route) {
   const paramsTuple = dynamicParams.map(() => "string").join(", ");
   return { paramsType, paramsTuple };
 }
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function buildTreeStructure(routes) {
+  const tree = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const segments = route.name.split(".");
+    let current = tree;
+    for (let i = 0; i < segments.length; i++) {
+      const segment = toCamelCase(segments[i]);
+      const isLast = i === segments.length - 1;
+      if (isLast) {
+        current.set(segment, { routeName: route.name, route });
+      } else {
+        if (!current.has(segment)) {
+          current.set(segment, /* @__PURE__ */ new Map());
+        }
+        current = current.get(segment);
+      }
+    }
+  }
+  return tree;
+}
+function generateTreeInterface(tree, indent = 2) {
+  const spaces = " ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of tree) {
+    if (value instanceof Map) {
+      lines.push(`${spaces}${key}: {`);
+      lines.push(generateTreeInterface(value, indent + 2));
+      lines.push(`${spaces}}`);
+    } else {
+      lines.push(`${spaces}${key}: Registry['${value.routeName}']`);
+    }
+  }
+  return lines.join("\n");
+}
+function normalizeImportPaths(typeString) {
+  return typeString.replace(/import\('app\//g, "import('#app/").replace(/\.ts'\)/g, "')");
+}
 function generateRuntimeRegistryEntry(route) {
   const routeName = route.name;
   return `  '${routeName}': {
@@ -40,51 +80,97 @@ function generateRuntimeRegistryEntry(route) {
     types: placeholder as Registry['${routeName}']['types'],
   }`;
 }
+function wrapResponseType(responseType) {
+  if (responseType === "unknown" || responseType === "{}") return responseType;
+  if (responseType.startsWith("ReturnType<")) {
+    return `Awaited<${responseType}>`;
+  }
+  return responseType;
+}
+function determineBodyAndQueryTypes(options) {
+  const { methods, requestType } = options;
+  const primaryMethod = methods[0];
+  const isGetLike = primaryMethod === "GET" || primaryMethod === "HEAD";
+  const hasValidator = requestType !== "{}";
+  if (!hasValidator) {
+    return { bodyType: "{}", queryType: "{}" };
+  }
+  if (isGetLike) {
+    return { bodyType: "{}", queryType: requestType };
+  }
+  return {
+    bodyType: `ExtractBody<${requestType}>`,
+    queryType: `ExtractQuery<${requestType}>`
+  };
+}
 function generateTypesRegistryEntry(route) {
-  const requestType = route.request?.type || "{}";
-  const responseType = route.response?.type || "unknown";
+  const requestType = normalizeImportPaths(route.request?.type || "{}");
+  const responseType = wrapResponseType(route.response?.type || "unknown");
   const { paramsType, paramsTuple } = generateRouteParams(route);
   const routeName = route.name;
+  const { bodyType, queryType } = determineBodyAndQueryTypes({
+    methods: route.methods,
+    requestType
+  });
   return `  '${routeName}': {
     methods: ${JSON.stringify(route.methods)}
     pattern: '${route.pattern}'
     types: {
-      body: ${requestType}
+      body: ${bodyType}
       paramsTuple: [${paramsTuple}]
       params: ${paramsType ? `{ ${paramsType} }` : "{}"}
-      query: {}
+      query: ${queryType}
       response: ${responseType}
     }
   }`;
 }
 function generateRegistryEntry(route) {
-  const requestType = route.request?.type || "{}";
-  const responseType = route.response?.type || "unknown";
+  const requestType = normalizeImportPaths(route.request?.type || "{}");
+  const responseType = wrapResponseType(route.response?.type || "unknown");
   const { paramsType, paramsTuple } = generateRouteParams(route);
   const routeName = route.name;
+  const { bodyType, queryType } = determineBodyAndQueryTypes({
+    methods: route.methods,
+    requestType
+  });
   return `  '${routeName}': {
     methods: ${JSON.stringify(route.methods)},
     pattern: '${route.pattern}',
     tokens: ${JSON.stringify(route.tokens)},
     types: placeholder as {
-      body: ${requestType}
+      body: ${bodyType}
       paramsTuple: [${paramsTuple}]
       params: ${paramsType ? `{ ${paramsType} }` : "{}"}
-      query: {}
+      query: ${queryType}
       response: ${responseType}
     },
   }`;
 }
 function generateRuntimeContent(routes) {
   const registryEntries = routes.map(generateRuntimeRegistryEntry).join(",\n");
+  const tree = buildTreeStructure(routes);
+  const treeInterface = generateTreeInterface(tree);
   return `/* eslint-disable prettier/prettier */
-import { type AdonisEndpoint } from '@tuyau/core/types'
-import type { Registry } from './registry.schema'
+import type { AdonisEndpoint } from '@tuyau/core/types'
+import type { Registry } from './registry.schema.d.ts'
 const placeholder: any = {}
 
-export const registry = {
-${registryEntries}
+export interface ApiDefinition {
+${treeInterface}
+}
+
+const routes = {
+${registryEntries},
 } as const satisfies Record<string, AdonisEndpoint>
+
+export const registry = {
+  routes,
+  $tree: {} as ApiDefinition,
+}
+
+declare module '@tuyau/core/types' {
+  export interface UserApiDefinition extends ApiDefinition {}
+}
 `;
 }
 function generateTypesContent(routes) {
@@ -92,7 +178,7 @@ function generateTypesContent(routes) {
   return `/* eslint-disable prettier/prettier */
 /// <reference path="../../adonisrc.ts" />
 
-import type { AdonisEndpoint } from '@tuyau/core/types'
+import type { ExtractBody, ExtractQuery } from '@tuyau/core/types'
 import type { Infer } from '@vinejs/vine/types'
 
 export interface Registry {
@@ -106,17 +192,29 @@ declare module '@tuyau/core/types' {
 }
 function generateRegistryContent(routes) {
   const registryEntries = routes.map(generateRegistryEntry).join(",\n");
+  const tree = buildTreeStructure(routes);
+  const treeInterface = generateTreeInterface(tree);
   return `/* eslint-disable prettier/prettier */
-import type { AdonisEndpoint } from '@tuyau/core/types'
+import type { AdonisEndpoint, ExtractBody, ExtractQuery } from '@tuyau/core/types'
 import type { Infer } from '@vinejs/vine/types'
 
 const placeholder: any = {}
-export const registry = {
+
+interface ApiDefinition {
+${treeInterface}
+}
+
+const routes = {
 ${registryEntries}
 } as const satisfies Record<string, AdonisEndpoint>
 
+export const registry = {
+  routes,
+  $tree: {} as ApiDefinition,
+}
+
 declare module '@tuyau/core/types' {
-  type Registry = typeof registry
+  type Registry = typeof routes
   export interface UserRegistry extends Registry {}
 }
 `;

package/build/client/index.d.ts

@@ -1,64 +1,62 @@
 import { UrlFor } from '@adonisjs/http-server/client/url_builder';
-import { AdonisEndpoint, TuyauConfiguration, BuildNamed, RegistryGroupedByMethod, PatternsByMethod, RequestArgs, EndpointByMethodPattern, StrKeys, Method } from './types/index.js';
+import { TuyauRegistry, TuyauConfiguration, AdonisEndpoint, InferRoutes, TransformApiDefinition, InferTree, RegistryGroupedByMethod, PatternsByMethod, RequestArgs, EndpointByMethodPattern, StrKeys, Method } from './types/index.js';
 import { KyResponse, KyRequest, HTTPError } from 'ky';
 
 /**
  * Main client class for making HTTP requests to AdonisJS endpoints
  * Provides both fluent API and direct method calling capabilities
+ *
+ * @typeParam Reg - The full registry containing routes and $tree
+ * @typeParam Routes - The routes record extracted from the registry
  */
-declare class Tuyau<R extends Record<string, AdonisEndpoint>> {
+declare class Tuyau<Reg extends TuyauRegistry, Routes extends Record<string, AdonisEndpoint> = InferRoutes<Reg>> {
     #private;
-    private config;
-    readonly api: BuildNamed<R>;
-    readonly urlFor: UrlFor<RegistryGroupedByMethod<R>>;
+    readonly api: TransformApiDefinition<InferTree<Reg>>;
+    readonly urlFor: UrlFor<RegistryGroupedByMethod<Routes>>;
     /**
      * Initializes the Tuyau client with provided configuration
      */
-    constructor(config: TuyauConfiguration<R>);
+    constructor(config: TuyauConfiguration<Reg>);
     /**
      * Makes a GET request to the specified pattern
      */
-    get<P extends PatternsByMethod<R, 'GET'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'GET', P>>): Promise<EndpointByMethodPattern<R, 'GET', P>['types']['response']>;
+    get<P extends PatternsByMethod<Routes, 'GET'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'GET', P>>): Promise<EndpointByMethodPattern<Routes, 'GET', P>['types']['response']>;
     /**
      * Makes a POST request to the specified pattern
      */
-    post<P extends PatternsByMethod<R, 'POST'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'POST', P>>): Promise<EndpointByMethodPattern<R, 'POST', P>['types']['response']>;
+    post<P extends PatternsByMethod<Routes, 'POST'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'POST', P>>): Promise<EndpointByMethodPattern<Routes, 'POST', P>['types']['response']>;
     /**
      * Makes a PUT request to the specified pattern
      */
-    put<P extends PatternsByMethod<R, 'PUT'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'PUT', P>>): Promise<EndpointByMethodPattern<R, 'PUT', P>['types']['response']>;
+    put<P extends PatternsByMethod<Routes, 'PUT'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'PUT', P>>): Promise<EndpointByMethodPattern<Routes, 'PUT', P>['types']['response']>;
     /**
      * Makes a PATCH request to the specified pattern
      */
-    patch<P extends PatternsByMethod<R, 'PATCH'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'PATCH', P>>): Promise<EndpointByMethodPattern<R, 'PATCH', P>['types']['response']>;
+    patch<P extends PatternsByMethod<Routes, 'PATCH'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'PATCH', P>>): Promise<EndpointByMethodPattern<Routes, 'PATCH', P>['types']['response']>;
     /**
      * Makes a DELETE request to the specified pattern
      */
-    delete<P extends PatternsByMethod<R, 'DELETE'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'DELETE', P>>): Promise<EndpointByMethodPattern<R, 'DELETE', P>['types']['response']>;
+    delete<P extends PatternsByMethod<Routes, 'DELETE'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'DELETE', P>>): Promise<EndpointByMethodPattern<Routes, 'DELETE', P>['types']['response']>;
     /**
      * Makes a HEAD request to the specified pattern
      */
-    head<P extends PatternsByMethod<R, 'HEAD'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'HEAD', P>>): Promise<EndpointByMethodPattern<R, 'HEAD', P>['types']['response']>;
+    head<P extends PatternsByMethod<Routes, 'HEAD'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<Routes, 'HEAD', P>>): Promise<EndpointByMethodPattern<Routes, 'HEAD', P>['types']['response']>;
     /**
      * Makes a request to a named endpoint
      */
-    request<Name extends StrKeys<R>>(name: Name, args: RequestArgs<R[Name]>): Promise<R[Name]['types']['response']>;
+    request<Name extends StrKeys<Routes>>(name: Name, args: RequestArgs<Routes[Name]>): Promise<Routes[Name]['types']['response']>;
     /**
      * Gets route information by name including URL and HTTP method
      */
-    getRoute<Name extends StrKeys<R>>(name: Name, args: RequestArgs<R[Name]>): {
+    getRoute<Name extends StrKeys<Routes>>(name: Name, args: RequestArgs<Routes[Name]>): {
         url: string;
         methods: Method[];
     };
-    /**
-     * Creates a proxy-based fluent API for accessing endpoints by name
-     */
-    private makeNamed;
 }
 /**
  * Factory function to create a new Tuyau client instance
  */
-declare function createTuyau<R extends Record<string, AdonisEndpoint>>(config: TuyauConfiguration<R>): Tuyau<R>;
+declare function createTuyau<Reg extends TuyauRegistry>(config: TuyauConfiguration<Reg>): Tuyau<Reg, InferRoutes<Reg>>;
 
 declare function parseResponse(response?: KyResponse): Promise<unknown>;
 declare class TuyauHTTPError extends Error {

package/build/client/index.js

@@ -1,6 +1,6 @@
 // src/client/tuyau.ts
-import ky, { HTTPError } from "ky";
 import { serialize } from "object-to-formdata";
+import ky, { HTTPError } from "ky";
 import { createUrlBuilder } from "@adonisjs/http-server/client/url_builder";
 
 // src/client/errors.ts
@@ -33,6 +33,7 @@ var TuyauHTTPError = class extends Error {
   }
 };
 var TuyauNetworkError = class extends Error {
+  cause;
   constructor(cause, request) {
     const message = request ? `Network error: ${request.method.toUpperCase()} ${request.url}` : "Network error occurred";
     super(message, { cause });
@@ -76,32 +77,22 @@ function segmentsToRouteName(segments) {
 
 // src/client/tuyau.ts
 var Tuyau = class {
-  /**
-   * Initializes the Tuyau client with provided configuration
-   */
-  constructor(config) {
-    this.config = config;
-    this.api = this.makeNamed([]);
-    this.#entries = Object.entries(this.config.registry);
-    this.urlFor = this.#createUrlBuilder();
-    this.#applyPlugins();
-    this.#client = ky.create(this.#mergeKyConfiguration());
-  }
   api;
   urlFor;
   #entries;
   #client;
+  #config;
   /**
    * Merges the default Ky configuration with user-provided config
    */
   #mergeKyConfiguration() {
     return {
-      prefixUrl: this.config.baseUrl,
-      ...this.config,
+      prefixUrl: this.#config.baseUrl,
+      ...this.#config,
       hooks: {
-        ...this.config.hooks,
+        ...this.#config.hooks,
         beforeRequest: [
-          ...this.config.hooks?.beforeRequest || [],
+          ...this.#config.hooks?.beforeRequest || [],
           this.#appendCsrfToken.bind(this)
         ]
       }
@@ -111,7 +102,7 @@ var Tuyau = class {
    * Applies registered plugins to the client configuration
    */
   #applyPlugins() {
-    this.config.plugins?.forEach((plugin) => plugin({ options: this.config }));
+    this.#config.plugins?.forEach((plugin) => plugin({ options: this.#config }));
   }
   /**
    * Creates a URL builder instance for generating URLs based on the route registry
@@ -120,6 +111,17 @@ var Tuyau = class {
     const rootEntries = this.#entries.map(([name, entry]) => ({ name, domain: "root", ...entry }));
     return createUrlBuilder({ root: rootEntries }, buildSearchParams);
   }
+  /**
+   * Initializes the Tuyau client with provided configuration
+   */
+  constructor(config) {
+    this.#config = config;
+    this.api = this.#makeNamed([]);
+    this.#entries = Object.entries(this.#config.registry.routes);
+    this.urlFor = this.#createUrlBuilder();
+    this.#applyPlugins();
+    this.#client = ky.create(this.#mergeKyConfiguration());
+  }
   /**
    * Automatically appends CSRF token from cookies to requests
    */
@@ -254,14 +256,14 @@ var Tuyau = class {
    * Makes a request to a named endpoint
    */
   request(name, args) {
-    const def = this.config.registry[name];
+    const def = this.#config.registry.routes[name];
     return this.#doFetch(name, def.methods[0], args);
   }
   /**
    * Gets route information by name including URL and HTTP method
    */
   getRoute(name, args) {
-    const def = this.config.registry[name];
+    const def = this.#config.registry.routes[name];
     if (!def) throw new Error(`Route ${String(name)} not found`);
     const url = this.#buildUrl(name, def.methods[0], args);
     return { url, methods: def.methods };
@@ -269,17 +271,17 @@ var Tuyau = class {
   /**
    * Creates a proxy-based fluent API for accessing endpoints by name
    */
-  makeNamed(segments) {
+  #makeNamed(segments) {
     const routeName = segmentsToRouteName(segments);
-    const def = this.config.registry[routeName];
+    const def = this.#config.registry.routes[routeName];
     if (def) {
       const fn = (args) => this.#doFetch(routeName, def.methods[0], args);
       return new Proxy(fn, {
-        get: (_t, prop) => this.makeNamed([...segments, String(prop)]),
+        get: (_t, prop) => this.#makeNamed([...segments, String(prop)]),
         apply: (_t, _this, argArray) => fn(...argArray)
       });
     }
-    return new Proxy({}, { get: (_t, prop) => this.makeNamed([...segments, String(prop)]) });
+    return new Proxy({}, { get: (_t, prop) => this.#makeNamed([...segments, String(prop)]) });
   }
 };
 function createTuyau(config) {

package/build/client/types/index.d.ts

@@ -6,97 +6,133 @@ import { ClientRouteMatchItTokens } from '@adonisjs/http-server/client/url_build
  */
 type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
 /**
- * Definition of an AdonisJS endpoint with types and metadata
+ * Base endpoint types structure
+ */
+interface EndpointTypes {
+    paramsTuple: [...any[]];
+    params: Record<string, string | number | boolean>;
+    query: Record<string, any>;
+    body: unknown;
+    response: unknown;
+}
+/**
+ * Schema endpoint, used in generated registry.schema.d.ts
+ * Does not include tokens (only present in runtime routes)
  */
-interface AdonisEndpoint {
+interface SchemaEndpoint {
     methods: Method[];
     pattern: string;
+    types: EndpointTypes;
+}
+/**
+ * Definition of an AdonisJS endpoint with types and metadata
+ * Includes tokens for runtime route building
+ */
+interface AdonisEndpoint extends SchemaEndpoint {
     tokens: ClientRouteMatchItTokens[];
-    types: {
-        paramsTuple: [...any[]];
-        params: Record<string, string | number | boolean>;
-        query: Record<string, any>;
-        body: unknown;
-        response: unknown;
-    };
 }
+/**
+ * Extract query params from a validator type if it has a 'query' property.
+ * Used in generated registry to separate query params from body for POST/PUT/PATCH/DELETE.
+ * For GET/HEAD, the validator type is used directly as query.
+ */
+type ExtractQuery<T> = T extends {
+    query: infer Q;
+} ? (Q extends undefined ? {} : Q) : {};
+/**
+ * Extract body from a validator type, excluding 'query' and 'params' properties.
+ * Used in generated registry to separate body from query/params for POST/PUT/PATCH/DELETE.
+ * Returns {} if the validator only contains query/params, otherwise returns the body fields.
+ */
+type ExtractBody<T> = T extends {
+    query: any;
+} | {
+    params: any;
+} ? Omit<T, 'query' | 'params'> extends infer B ? keyof B extends never ? {} : B : {} : T;
 /**
  * Registry mapping endpoint names to their definitions
  */
 interface AdonisRegistry extends Record<string, AdonisEndpoint> {
 }
+/**
+ * Should be augmented by the user to provide their API definition tree
+ * This is the pre-computed tree structure generated at build time
+ */
+interface UserApiDefinition {
+}
 type ValueOf<T> = T[keyof T];
-type IsEmptyObj<T> = keyof T extends never ? true : false;
-type IsEmptyTuple<T> = T extends [] ? true : false;
-type Endpoints = ValueOf<AdonisRegistry>;
-type EndpointByName<Name extends keyof AdonisRegistry & string> = AdonisRegistry[Name];
 /**
- * Checks if a type has any keys
+ * Split a string by a delimiter
  */
-type HasKeys<T> = keyof T extends never ? false : true;
+type Split<S extends string, D extends string = '.'> = S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
 /**
- * Checks if a type has required keys (non-optional properties)
+ * Convert a union type to an intersection type
  */
-type HasRequiredKeys<T> = T extends Record<string, any> ? keyof T extends never ? false : {} extends Pick<T, keyof T> ? false : true : false;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /**
- * Constructs the request arguments type for an endpoint
+ * Structure of a Tuyau registry containing routes and optional tree
  */
-type RequestArgs<E extends AdonisEndpoint> = (HasKeys<E['types']['params']> extends true ? HasRequiredKeys<E['types']['params']> extends true ? {
-    params: E['types']['params'];
-} : {
-    params?: E['types']['params'];
-} : {}) & (E['types']['query'] extends object ? HasRequiredKeys<E['types']['query']> extends true ? {
-    query: E['types']['query'];
-} : {
-    query?: E['types']['query'];
-} : {}) & (E['types']['body'] extends never | undefined ? {} : HasRequiredKeys<E['types']['body']> extends true ? {
-    body: E['types']['body'];
-} : {
-    body?: E['types']['body'];
-}) & Omit<Options, 'body' | 'params' | 'searchParams' | 'method' | 'json' | 'prefixUrl'>;
+interface TuyauRegistry<Routes extends Record<string, AdonisEndpoint> = Record<string, AdonisEndpoint>, Tree = unknown> {
+    routes: Routes;
+    $tree?: Tree;
+}
 /**
- * Extracts response type from an endpoint
+ * Extracts the $tree type from a registry
+ * Uses direct access instead of conditional type for performance
  */
-type ResponseOf<E extends AdonisEndpoint> = E['types']['response'];
+type InferTree<R extends TuyauRegistry> = R['$tree'];
 /**
- * Splits a dot-separated string into an array of strings
+ * Extracts the routes from a registry
  */
-type Split<S extends string> = S extends `${infer H}.${infer T}` ? [H, ...Split<T>] : [S];
+type InferRoutes<R extends TuyauRegistry> = R['routes'];
+type Endpoints = ValueOf<AdonisRegistry>;
+type EndpointByName<Name extends keyof AdonisRegistry & string> = AdonisRegistry[Name];
 /**
- * Converts a string to camelCase
+ * Pre-computed base Ky options to avoid recomputing Omit on every request
  */
-type CamelCase<S extends string> = S extends `${infer H}${infer T}` ? `${Lowercase<H>}${CamelCaseRest<T>}` : S;
-type CamelCaseRest<S extends string> = S extends `_${infer H}${infer T}` ? `${Uppercase<H>}${CamelCaseRest<T>}` : S extends `${infer H}${infer T}` ? `${H}${CamelCaseRest<T>}` : S;
+type BaseRequestOptions = Omit<Options, 'body' | 'params' | 'searchParams' | 'method' | 'json' | 'prefixUrl'>;
 /**
- * Applies camelCase to each segment in a split array
+ * Helper types for optional/required fields - using literal types instead of mapped types
  */
-type CamelCaseSplit<T extends string[]> = T extends [
-    infer H extends string,
-    ...infer Rest extends string[]
-] ? [CamelCase<H>, ...CamelCaseSplit<Rest>] : [];
+type ParamsArg<T> = keyof T extends never ? {} : {} extends T ? {
+    params?: T;
+} : {
+    params: T;
+};
+type QueryArg<T> = keyof T extends never ? {} : {} extends T ? {
+    query?: T;
+} : {
+    query: T;
+};
+type BodyArg<T> = keyof T extends never ? {} : {} extends T ? {
+    body?: T;
+} : {
+    body: T;
+};
 /**
- * Converts a union type to an intersection type
+ * Request args without ky options
  */
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type RawRequestArgs<E extends SchemaEndpoint> = ParamsArg<E['types']['params']> & QueryArg<E['types']['query']> & BodyArg<E['types']['body']>;
 /**
- * Builds a nested object type for the fluent API based on endpoint names
+ * Constructs the request arguments type for an endpoint
  */
-type BuildNamed<Reg extends Record<string, AdonisEndpoint>> = UnionToIntersection<{
-    [K in keyof Reg & string]: SetAtPath<CamelCaseSplit<Split<K>>, EndpointFn<Reg[K]>>;
-}[keyof Reg & string]>;
+type RequestArgs<E extends SchemaEndpoint> = RawRequestArgs<E> & BaseRequestOptions;
 /**
- * Sets a value at a specific path in a nested object type
+ * Extracts response type from an endpoint
  */
-type SetAtPath<Path extends string[], V> = Path extends [
-    infer H extends string,
-    ...infer T extends string[]
-] ? {
-    [K in H]: T['length'] extends 0 ? V : SetAtPath<T, V>;
-} : {};
+type ResponseOf<E extends SchemaEndpoint> = E['types']['response'];
 /**
  * Function type for calling an endpoint
  */
-type EndpointFn<E extends AdonisEndpoint> = (args: RequestArgs<E>) => Promise<E['types']['response']>;
+type EndpointFn<E extends SchemaEndpoint> = (args: RequestArgs<E>) => Promise<E['types']['response']>;
+/**
+ * Transforms a pre-computed ApiDefinition tree into callable endpoint functions
+ * This recursively converts each endpoint in the tree to a callable function
+ * Fully inlined for maximum performance
+ */
+type TransformApiDefinition<T> = {
+    [K in keyof T]: T[K] extends AdonisEndpoint ? (args: ParamsArg<T[K]['types']['params']> & QueryArg<T[K]['types']['query']> & BodyArg<T[K]['types']['body']> & BaseRequestOptions) => Promise<T[K]['types']['response']> : TransformApiDefinition<T[K]>;
+};
 /**
  * Filters endpoints by HTTP method
  */
@@ -130,7 +166,7 @@ interface QueryParameters extends Record<string, MaybeArray<string | number | bo
 /**
  * Configuration options for creating a Tuyau client
  */
-interface TuyauConfiguration<T extends Record<string, AdonisEndpoint>> extends Omit<Options, 'prefixUrl' | 'body' | 'json' | 'method' | 'searchParams'> {
+interface TuyauConfiguration<T extends TuyauRegistry> extends Omit<Options, 'prefixUrl' | 'body' | 'json' | 'method' | 'searchParams'> {
     registry: T;
     baseUrl: string;
     plugins?: TuyauPlugin[];
@@ -143,7 +179,7 @@ interface UserRegistry {
 type UserAdonisRegistry = UserRegistry extends Record<string, AdonisEndpoint> ? UserRegistry : Record<string, AdonisEndpoint>;
 type UserEndpointByName<Name extends keyof UserAdonisRegistry> = UserAdonisRegistry[Name];
 type FilterByMethodPathForRegistry<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends ValueOf<Reg>['pattern'] & string> = {
-    [K in keyof Reg]: [Reg[K]['pattern'], M] extends [P, Reg[K]['methods'][number]] ? Reg[K] : never;
+    [K in keyof Reg]: Reg[K]['pattern'] extends P ? M extends Reg[K]['methods'][number] ? Reg[K] : never : never;
 }[keyof Reg];
 type EndpointByNameForRegistry<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = Reg[Name];
 /**
@@ -195,11 +231,11 @@ type ParamsShape<E> = E extends {
         paramsTuple: infer PT;
         params: infer P;
     };
-} ? (IsEmptyTuple<PT> extends true ? {
+} ? (PT extends [] ? {
     paramsTuple?: PT;
 } : {
     paramsTuple: PT;
-}) & (IsEmptyObj<P> extends true ? {} : {
+}) & (keyof P extends never ? {} : {
     params: P;
 }) : never;
 type RegistryGroupedByMethod<R extends Record<string, AdonisEndpoint>, M extends Method = Method> = {
@@ -208,4 +244,4 @@ type RegistryGroupedByMethod<R extends Record<string, AdonisEndpoint>, M extends
     };
 };
 
-export { type AdonisEndpoint, type AdonisRegistry, type BuildNamed, type CamelCase, type CamelCaseSplit, type EndpointByMethodPattern, type EndpointByName, type Endpoints, type EndpointsByMethod, type HasKeys, type HasRequiredKeys, type MaybeArray, type Method, Path, PathWithRegistry, type PatternsByMethod, type QueryParameters, type RegValues, type RegistryGroupedByMethod, type RequestArgs, type ResponseOf, Route, RouteWithRegistry, type SetAtPath, type Split, type StrKeys, type TuyauConfiguration, type TuyauPlugin, type UnionToIntersection, type UserRegistry, type ValueOf };
+export { type AdonisEndpoint, type AdonisRegistry, type EndpointByMethodPattern, type EndpointByName, type EndpointFn, type EndpointTypes, type Endpoints, type EndpointsByMethod, type ExtractBody, type ExtractQuery, type InferRoutes, type InferTree, type MaybeArray, type Method, Path, PathWithRegistry, type PatternsByMethod, type QueryParameters, type RawRequestArgs, type RegValues, type RegistryGroupedByMethod, type RequestArgs, type ResponseOf, Route, RouteWithRegistry, type SchemaEndpoint, type Split, type StrKeys, type TransformApiDefinition, type TuyauConfiguration, type TuyauPlugin, type TuyauRegistry, type UnionToIntersection, type UserApiDefinition, type UserRegistry, type ValueOf };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuyau/core",
   "type": "module",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "description": "e2e client for AdonisJS",
   "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "MIT",
@@ -34,7 +34,6 @@
     "@adonisjs/assembler": "8.0.0-next.19",
     "@adonisjs/core": "^7.0.0-next.10",
     "@adonisjs/http-server": "8.0.0-next.12",
-    "@arktype/attest": "^0.53.0",
     "@faker-js/faker": "^10.1.0",
     "@poppinss/ts-exec": "^1.4.1",
     "@types/node": "^24.10.0",