@tuyau/core 1.0.0-beta.8 → 1.0.0-next.17

package/README.md

@@ -1,2 +1,11 @@
 # @tuyau/core
 
+Core package for Tuyau. Includes the backend integration and the E2E typesafe client to consume your AdonisJS APIs.
+
+## Documentation
+
+Available soon.
+
+## License
+
+MIT

package/build/backend/generate_registry.d.ts

@@ -1,7 +1,190 @@
+/**
+ * Extending the HTTP response interface to include status and response
+ * in the return type.
+ *
+ * This is ONLY type information and the properties will not be available
+ * at runtime. This is needed to infer the correct response type
+ */
+
+declare module '@adonisjs/core/http' {
+    interface HttpResponse {
+        continue(): {
+            __status: 100;
+        };
+        switchingProtocols(etag?: boolean): {
+            __status: 101;
+        };
+        ok<T>(body: T, etag?: boolean): {
+            __response: T;
+            __status: 200;
+        };
+        created<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 201;
+        };
+        accepted<T>(body: T, etag?: boolean): {
+            __response: T;
+            __status: 202;
+        };
+        nonAuthoritativeInformation<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 203;
+        };
+        noContent<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 204;
+        };
+        resetContent<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 205;
+        };
+        partialContent<T>(body: T, etag?: boolean): {
+            __response: T;
+            __status: 206;
+        };
+        multipleChoices<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 300;
+        };
+        movedPermanently<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 301;
+        };
+        movedTemporarily<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 302;
+        };
+        seeOther<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 303;
+        };
+        notModified<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 304;
+        };
+        useProxy<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 305;
+        };
+        temporaryRedirect<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 307;
+        };
+        badRequest<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 400;
+        };
+        unauthorized<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 401;
+        };
+        paymentRequired<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 402;
+        };
+        forbidden<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 403;
+        };
+        notFound<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 404;
+        };
+        methodNotAllowed<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 405;
+        };
+        notAcceptable<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 406;
+        };
+        proxyAuthenticationRequired<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 407;
+        };
+        requestTimeout<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 408;
+        };
+        conflict<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 409;
+        };
+        gone<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 410;
+        };
+        lengthRequired<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 411;
+        };
+        preconditionFailed<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 412;
+        };
+        requestEntityTooLarge<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 413;
+        };
+        requestUriTooLong<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 414;
+        };
+        unsupportedMediaType<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 415;
+        };
+        requestedRangeNotSatisfiable<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 416;
+        };
+        expectationFailed<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 417;
+        };
+        unprocessableEntity<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 422;
+        };
+        tooManyRequests<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 429;
+        };
+        internalServerError<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 500;
+        };
+        notImplemented<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 501;
+        };
+        badGateway<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 502;
+        };
+        serviceUnavailable<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 503;
+        };
+        gatewayTimeout<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 504;
+        };
+        httpVersionNotSupported<T>(body?: T, etag?: boolean): {
+            __response: T;
+            __status: 505;
+        };
+        json<T>(body: T, generateEtag?: boolean): {
+            __response: T;
+            __status: 200;
+        };
+    }
+}
+
 interface GenerateRegistryConfig {
     /**
-     * Path to write the generated registry file
-     * @default ./.adonisjs/client/registry.ts
+     * Path to write the generated registry directory
+     * @default ./.adonisjs/client/registry
      */
     output?: string;
     /**

package/build/backend/generate_registry.js

@@ -1,6 +1,10 @@
+// src/backend/types.ts
+import "@adonisjs/core/http";
+
 // src/backend/generate_registry.ts
 import { dirname } from "path";
 import { writeFile, mkdir } from "fs/promises";
+import stringHelpers from "@adonisjs/core/helpers/string";
 async function writeOutputFile(filePath, content) {
   const dir = dirname(filePath);
   await mkdir(dir, { recursive: true });
@@ -29,26 +33,34 @@ function filterRoute(route, filters) {
 }
 function generateRouteParams(route) {
   const dynamicParams = route.tokens.filter((token) => token.type === 1);
-  const paramsType = dynamicParams.map((token) => `${token.val}: string`).join("; ");
-  const paramsTuple = dynamicParams.map(() => "string").join(", ");
+  const paramsType = dynamicParams.map((token) => `${token.val}: ParamValue`).join("; ");
+  const paramsTuple = dynamicParams.map(() => "ParamValue").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 segment = stringHelpers.camelCase(segments[i]);
       const isLast = i === segments.length - 1;
       if (isLast) {
-        current.set(segment, { routeName: route.name, route });
+        if (current.has(segment) && current.get(segment) instanceof Map) {
+          current.get(segment).set("$self", { routeName: route.name, route });
+        } else {
+          current.set(segment, { routeName: route.name, route });
+        }
       } else {
         if (!current.has(segment)) {
           current.set(segment, /* @__PURE__ */ new Map());
+        } else {
+          const existing = current.get(segment);
+          if (!(existing instanceof Map)) {
+            const newMap = /* @__PURE__ */ new Map();
+            newMap.set("$self", existing);
+            current.set(segment, newMap);
+          }
         }
         current = current.get(segment);
       }
@@ -60,10 +72,18 @@ function generateTreeInterface(tree, indent = 2) {
   const spaces = " ".repeat(indent);
   const lines = [];
   for (const [key, value] of tree) {
+    if (key === "$self") continue;
     if (value instanceof Map) {
-      lines.push(`${spaces}${key}: {`);
-      lines.push(generateTreeInterface(value, indent + 2));
-      lines.push(`${spaces}}`);
+      const selfRoute = value.get("$self");
+      if (selfRoute) {
+        lines.push(`${spaces}${key}: typeof routes['${selfRoute.routeName}'] & {`);
+        lines.push(generateTreeInterface(value, indent + 2));
+        lines.push(`${spaces}}`);
+      } else {
+        lines.push(`${spaces}${key}: {`);
+        lines.push(generateTreeInterface(value, indent + 2));
+        lines.push(`${spaces}}`);
+      }
     } else {
       lines.push(`${spaces}${key}: typeof routes['${value.routeName}']`);
     }
@@ -73,21 +93,25 @@ function generateTreeInterface(tree, indent = 2) {
 function normalizeImportPaths(typeString) {
   return typeString.replace(/import\('app\//g, "import('#app/").replace(/\.ts'\)/g, "')");
 }
+function sanitizeTokens(tokens) {
+  return tokens.map(({ old, type, val, end }) => ({ old, type, val, end }));
+}
 function generateRuntimeRegistryEntry(route) {
   const routeName = route.name;
+  const sanitizedTokens = sanitizeTokens(route.tokens);
   return `  '${routeName}': {
     methods: ${JSON.stringify(route.methods)},
     pattern: '${route.pattern}',
-    tokens: ${JSON.stringify(route.tokens)},
+    tokens: ${JSON.stringify(sanitizedTokens)},
     types: placeholder as Registry['${routeName}']['types'],
   }`;
 }
 function wrapResponseType(responseType) {
   if (responseType === "unknown" || responseType === "{}") return responseType;
   if (responseType.startsWith("ReturnType<")) {
-    return `Awaited<${responseType}>`;
+    return `ExtractResponse<Awaited<${responseType}>>`;
   }
-  return responseType;
+  return `ExtractResponse<${responseType}>`;
 }
 function determineBodyAndQueryTypes(options) {
   const { methods, requestType } = options;
@@ -98,7 +122,7 @@ function determineBodyAndQueryTypes(options) {
     return { bodyType: "{}", queryType: "{}" };
   }
   if (isGetLike) {
-    return { bodyType: "{}", queryType: requestType };
+    return { bodyType: "{}", queryType: `ExtractQueryForGet<${requestType}>` };
   }
   return {
     bodyType: `ExtractBody<${requestType}>`,
@@ -130,8 +154,8 @@ function generateRuntimeContent(routes) {
   const registryEntries = routes.map(generateRuntimeRegistryEntry).join(",\n");
   return `/* eslint-disable prettier/prettier */
 import type { AdonisEndpoint } from '@tuyau/core/types'
-import type { Registry } from './registry.schema.d.ts'
-import type { ApiDefinition } from './registry.schema.tree.d.ts'
+import type { Registry } from './schema.d.ts'
+import type { ApiDefinition } from './tree.d.ts'
 
 const placeholder: any = {}
 
@@ -158,7 +182,7 @@ function generateTreeContent(routes) {
   const tree = buildTreeStructure(routes);
   const treeInterface = generateTreeInterface(tree);
   return `/* eslint-disable prettier/prettier */
-import type { routes } from './registry.ts'
+import type { routes } from './index.ts'
 
 export interface ApiDefinition {
 ${treeInterface}
@@ -168,11 +192,13 @@ ${treeInterface}
 function generateTypesContent(routes) {
   const registryEntries = routes.map(generateTypesRegistryEntry).join("\n");
   return `/* eslint-disable prettier/prettier */
-/// <reference path="../../adonisrc.ts" />
+/// <reference path="../manifest.d.ts" />
 
-import type { ExtractBody, ExtractQuery } from '@tuyau/core/types'
+import type { ExtractBody, ExtractQuery, ExtractQueryForGet, ExtractResponse } from '@tuyau/core/types'
 import type { InferInput } from '@vinejs/vine/types'
 
+export type ParamValue = string | number | bigint | boolean
+
 export interface Registry {
 ${registryEntries}
 }
@@ -180,7 +206,7 @@ ${registryEntries}
 }
 function generateRegistry(options) {
   const config = {
-    output: "./.adonisjs/client/registry.ts",
+    output: "./.adonisjs/client/registry",
     ...options
   };
   return {
@@ -196,18 +222,18 @@ function generateRegistry(options) {
         const runtimeContent = generateRuntimeContent(scannedRoutes);
         const typesContent = generateTypesContent(scannedRoutes);
         const treeContent = generateTreeContent(scannedRoutes);
-        const basePath = config.output.replace(/\.(ts|js)$/, "");
-        const runtimePath = `${basePath}.ts`;
-        const typesPath = `${basePath}.schema.d.ts`;
-        const treePath = `${basePath}.schema.tree.d.ts`;
+        const registryDir = config.output.replace(/\/$/, "");
+        const runtimePath = `${registryDir}/index.ts`;
+        const typesPath = `${registryDir}/schema.d.ts`;
+        const treePath = `${registryDir}/tree.d.ts`;
         await Promise.all([
           writeOutputFile(runtimePath, runtimeContent),
           writeOutputFile(typesPath, typesContent),
           writeOutputFile(treePath, treeContent)
         ]);
-        devServer.ui.logger.info(`created ${runtimePath}`, { startTime });
-        devServer.ui.logger.info(`created ${typesPath}`, { startTime });
-        devServer.ui.logger.info(`created ${treePath}`, { startTime });
+        devServer.ui.logger.info(`tuyau: created api client registry (${registryDir})`, {
+          startTime
+        });
       });
     }
   };

package/build/client/index.js

@@ -26,7 +26,7 @@ function buildSearchParams(query) {
     }
   }
   serialize2(query);
-  return parts.length ? `?${parts.join("&")}` : "";
+  return parts.length ? parts.join("&") : "";
 }
 
 // src/client/errors.ts
@@ -78,6 +78,9 @@ function isObject(value) {
 var isServer = typeof FileList === "undefined";
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 function segmentsToRouteName(segments) {
+  return segments.map((segment) => segment.replace(/[A-Z]/g, (g) => `_${g.toLowerCase()}`)).join(".");
+}
+function segmentsToKebabRouteName(segments) {
   return segments.map((segment) => segment.replace(/[A-Z]/g, (g) => `-${g.toLowerCase()}`)).join(".");
 }
 
@@ -284,8 +287,12 @@ var Tuyau = class {
    * Creates a proxy-based fluent API for accessing endpoints by name
    */
   #makeNamed(segments) {
-    const routeName = segmentsToRouteName(segments);
-    const def = this.#config.registry.routes[routeName];
+    let routeName = segmentsToRouteName(segments);
+    let def = this.#config.registry.routes[routeName];
+    if (!def) {
+      routeName = segmentsToKebabRouteName(segments);
+      def = this.#config.registry.routes[routeName];
+    }
     if (def) {
       const fn = (args) => this.#doFetch(routeName, def.methods[0], args);
       return new Proxy(fn, {

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

@@ -34,16 +34,38 @@ interface AdonisEndpoint extends SchemaEndpoint {
 /**
  * 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.
+ * For GET/HEAD, use ExtractQueryForGet instead.
  */
 type ExtractQuery<T> = T extends {
     query?: infer Q;
 } ? 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.
+ * Extract query params for GET/HEAD requests.
+ * Excludes headers, cookies, and params from the validator type since these are not query params.
  */
-type ExtractBody<T> = Omit<T, 'query' | 'params'>;
+type ExtractQueryForGet<T> = Omit<T, 'headers' | 'cookies' | 'params'>;
+/**
+ * Extract body from a validator type, excluding reserved properties.
+ * Excludes 'query', 'params', 'headers', and 'cookies' as these are handled separately by AdonisJS.
+ */
+type ExtractBody<T> = Omit<T, 'query' | 'params' | 'headers' | 'cookies'>;
+/**
+ * Success status codes (2xx)
+ */
+type SuccessStatus = 200 | 201 | 202 | 203 | 204 | 205 | 206;
+/**
+ * Extract the actual response type from a controller return type.
+ * - Success responses (2xx): extracts `__response`
+ * - Error responses (non-2xx with __response/__status): returns `never` to filter from unions
+ * - Plain types (no __status): returns as-is
+ */
+type ExtractResponse<T> = T extends {
+    __response: infer R;
+    __status: SuccessStatus;
+} ? R : T extends {
+    __response: unknown;
+    __status: number;
+} ? never : T;
 /**
  * Registry mapping endpoint names to their definitions
  */
@@ -114,13 +136,17 @@ type ResponseOf<E extends SchemaEndpoint> = E['types']['response'];
  * Function type for calling an endpoint
  */
 type EndpointFn<E extends SchemaEndpoint> = (args: RequestArgs<E>) => Promise<E['types']['response']>;
+/**
+ * Function type for an endpoint with inlined args
+ */
+type EndpointFnInline<E extends AdonisEndpoint> = (args: ParamsArg<E['types']['params']> & QueryArg<E['types']['query']> & BodyArg<E['types']['body']> & BaseRequestOptions) => 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
+ * Handles intersection types where a node is both an endpoint AND has children
  */
 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]>;
+    [K in keyof T]: T[K] extends AdonisEndpoint ? EndpointFnInline<T[K]> & TransformApiDefinition<Omit<T[K], keyof AdonisEndpoint>> : TransformApiDefinition<T[K]>;
 };
 /**
  * Filters endpoints by HTTP method
@@ -236,4 +262,4 @@ type RegistryGroupedByMethod<R extends Record<string, AdonisEndpoint>, M extends
     };
 };
 
-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 UserRegistry, type ValueOf };
+export { type AdonisEndpoint, type AdonisRegistry, type BaseRequestOptions, type EndpointByMethodPattern, type EndpointByName, type EndpointFn, type EndpointTypes, type Endpoints, type EndpointsByMethod, type ExtractBody, type ExtractQuery, type ExtractQueryForGet, type ExtractResponse, 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 UserRegistry, type ValueOf };

package/package.json

@@ -1,14 +1,27 @@
 {
   "name": "@tuyau/core",
   "type": "module",
-  "version": "1.0.0-beta.8",
-  "description": "e2e client for AdonisJS",
+  "version": "1.0.0-next.17",
+  "description": "E2E typesafe client for AdonisJS",
   "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "MIT",
+  "homepage": "https://github.com/Julien-R44/tuyau#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Julien-R44/tuyau.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/Julien-R44/tuyau/issues"
+  },
   "keywords": [
     "adonisjs",
-    "e2e",
-    "client"
+    "typescript",
+    "typesafe",
+    "api",
+    "rpc",
+    "client",
+    "e2e"
   ],
   "exports": {
     "./client": "./build/client/index.js",
@@ -23,22 +36,30 @@
     "node": ">=24.0.0"
   },
   "peerDependencies": {
-    "@adonisjs/assembler": "^8.0.0-next.26",
-    "@adonisjs/core": "^7.0.0-next.14"
+    "@adonisjs/assembler": "^8.0.0-next.27",
+    "@adonisjs/core": "^7.0.0-next.16"
+  },
+  "peerDependenciesMeta": {
+    "@adonisjs/assembler": {
+      "optional": true
+    },
+    "@adonisjs/core": {
+      "optional": true
+    }
   },
   "dependencies": {
-    "ky": "^1.14.0",
+    "ky": "^1.14.2",
     "object-to-formdata": "^4.5.1"
   },
   "devDependencies": {
-    "@adonisjs/assembler": "^8.0.0-next.26",
-    "@adonisjs/core": "^7.0.0-next.14",
+    "@adonisjs/assembler": "^8.0.0-next.27",
+    "@adonisjs/core": "^7.0.0-next.16",
     "@adonisjs/http-server": "^8.0.0-next.16",
     "@faker-js/faker": "^10.1.0",
     "@poppinss/ts-exec": "^1.4.1",
-    "@types/node": "^24.10.1",
+    "@types/node": "^25.0.3",
     "@typescript/analyze-trace": "^0.10.1",
-    "@vinejs/vine": "^4.1.0"
+    "@vinejs/vine": "^4.2.0"
   },
   "publishConfig": {
     "access": "public",