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

package/build/backend/generate_registry.d.ts

@@ -1,164 +1,16 @@
-import * as _adonisjs_assembler_routes_scanner from '@adonisjs/assembler/routes_scanner';
-import * as _poppinss_cliui_types from '@poppinss/cliui/types';
-import * as _poppinss_cliui from '@poppinss/cliui';
-import * as _poppinss_colors_types from '@poppinss/colors/types';
-import { DevServerOptions } from './types/common.ts';
-
-/**
- * Exposes the API to start the development server in HMR, watch or static mode
- *
- * In HMR mode, the DevServer will exec the "bin/server.ts" file and let hot-hook
- * manage the changes using hot module reloading.
- *
- * In watch mode, the DevServer will start an internal watcher and restarts the server
- * after every file change. The files must be part of the TypeScript project (via tsconfig.json),
- * or registered as metaFiles.
- *
- * In static mode, the server runs without file watching or hot reloading.
- *
- * @example
- * const devServer = new DevServer(cwd, { hmr: true, hooks: [] })
- * await devServer.start(ts)
- */
-declare class DevServer {
-    #private;
-    /**
-     * CLI UI instance for displaying colorful messages and progress information
-     */
-    ui: {
-        colors: _poppinss_colors_types.Colors;
-        logger: _poppinss_cliui.Logger;
-        table: (tableOptions?: Partial<_poppinss_cliui_types.TableOptions>) => _poppinss_cliui.Table;
-        tasks: (tasksOptions?: Partial<_poppinss_cliui_types.TaskManagerOptions>) => _poppinss_cliui.TaskManager;
-        icons: {
-            tick: string;
-            cross: string;
-            bullet: string;
-            nodejs: string;
-            pointer: string;
-            info: string;
-            warning: string;
-            squareSmallFilled: string;
-        };
-        sticker: () => _poppinss_cliui.Instructions;
-        instructions: () => _poppinss_cliui.Instructions;
-        switchMode(modeToUse: "raw" | "silent" | "normal"): void;
-        useRenderer(rendererToUse: _poppinss_cliui_types.RendererContract): void;
-        useColors(colorsToUse: _poppinss_colors_types.Colors): void;
-    };
-    /**
-     * The mode in which the DevServer is running
-     *
-     * Returns the current operating mode of the development server:
-     * - 'hmr': Hot Module Reloading enabled
-     * - 'watch': File system watching with full restarts
-     * - 'static': No file watching or hot reloading
-     */
-    get mode(): "hmr" | "watch" | "static";
-    /**
-     * Script file to start the development server
-     */
-    scriptFile: string;
-    /**
-     * The current working directory URL
-     */
-    cwd: URL;
-    /**
-     * File path computed from the cwd
-     */
-    cwdPath: string;
-    /**
-     * Development server configuration options including hooks and environment variables
-     */
-    options: DevServerOptions;
-    /**
-     * Create a new DevServer instance
-     *
-     * @param cwd - The current working directory URL
-     * @param options - Development server configuration options
-     */
-    constructor(cwd: URL, options: DevServerOptions);
-    /**
-     * Adds listener to get notified when dev server is closed
-     *
-     * Registers a callback function that will be invoked when the development
-     * server's child process exits. The callback receives the exit code.
-     *
-     * @param callback - Function to call when dev server closes
-     * @returns This DevServer instance for method chaining
-     *
-     * @example
-     * devServer.onClose((exitCode) => {
-     *   console.log(`Server closed with exit code: ${exitCode}`)
-     * })
-     */
-    onClose(callback: (exitCode: number) => any): this;
-    /**
-     * Adds listener to get notified when dev server encounters an error
-     *
-     * Registers a callback function that will be invoked when the development
-     * server's child process encounters an error or fails to start.
-     *
-     * @param callback - Function to call when dev server encounters an error
-     * @returns This DevServer instance for method chaining
-     *
-     * @example
-     * devServer.onError((error) => {
-     *   console.error('Dev server error:', error.message)
-     * })
-     */
-    onError(callback: (error: any) => any): this;
-    /**
-     * Closes watchers and terminates the running child process
-     *
-     * Cleans up keyboard shortcuts, stops file system watchers, and kills
-     * the HTTP server child process. This should be called when shutting down
-     * the development server.
-     *
-     * @example
-     * await devServer.close()
-     */
-    close(): Promise<void>;
-    /**
-     * Starts the development server in static or HMR mode
-     *
-     * Initializes the server and starts the HTTP server. The mode is determined
-     * by the `hmr` option in DevServerOptions. In HMR mode, hot-hook is configured
-     * to enable hot module reloading.
-     *
-     * @param ts - TypeScript module reference
-     *
-     * @example
-     * const devServer = new DevServer(cwd, { hmr: true, hooks: [] })
-     * await devServer.start(ts)
-     */
-    start(): Promise<void>;
-    /**
-     * Starts the development server in watch mode and restarts on file changes
-     *
-     * Initializes the server, starts the HTTP server, and sets up a file system
-     * watcher that monitors for changes. When files are added, modified, or deleted,
-     * the server automatically restarts. The watcher respects TypeScript project
-     * configuration and metaFiles settings.
-     *
-     * @param ts - TypeScript module reference
-     * @param options - Watch options including polling mode
-     *
-     * @example
-     * const devServer = new DevServer(cwd, { hooks: [] })
-     * await devServer.startAndWatch(ts, { poll: false })
-     */
-    startAndWatch(options?: {
-        poll: boolean;
-    }): Promise<void>;
-}
-
 interface GenerateRegistryConfig {
     /**
      * Path to write the generated registry file
      * @default ./.adonisjs/client/registry.ts
      */
     output?: string;
+    /**
+     * Whether to split runtime values and TypeScript types into separate files
+     * When true, generates registry.ts (runtime) and registry.schema.d.ts (types)
+     * When false, generates a single file with both runtime and types
+     * @default true
+     */
+    splitTypesFromRuntime?: boolean;
     /**
      * Routes filtering configuration
      */
@@ -176,7 +28,7 @@ interface GenerateRegistryConfig {
     };
 }
 declare function generateRegistry(options?: GenerateRegistryConfig): {
-    run(devServer: DevServer, routesScanner: _adonisjs_assembler_routes_scanner.RoutesScanner): Promise<void>;
+    run(devServer: any, routesScanner: any): Promise<void>;
 };
 
 export { generateRegistry };

package/build/backend/generate_registry.js

@@ -1,6 +1,5 @@
 // src/backend/generate_registry.ts
 import { dirname } from "path";
-import string from "@adonisjs/core/helpers/string";
 import { writeFile, mkdir } from "fs/promises";
 async function writeOutputFile(filePath, content) {
   const dir = dirname(filePath);
@@ -32,11 +31,37 @@ function generateRouteParams(route) {
   const paramsTuple = dynamicParams.map(() => "string").join(", ");
   return { paramsType, paramsTuple };
 }
+function generateRuntimeRegistryEntry(route) {
+  const routeName = route.name;
+  return `  '${routeName}': {
+    methods: ${JSON.stringify(route.methods)},
+    pattern: '${route.pattern}',
+    tokens: ${JSON.stringify(route.tokens)},
+    types: placeholder as Registry['${routeName}']['types'],
+  }`;
+}
+function generateTypesRegistryEntry(route) {
+  const requestType = route.request?.type || "{}";
+  const responseType = route.response?.type || "unknown";
+  const { paramsType, paramsTuple } = generateRouteParams(route);
+  const routeName = route.name;
+  return `  '${routeName}': {
+    methods: ${JSON.stringify(route.methods)}
+    pattern: '${route.pattern}'
+    types: {
+      body: ${requestType}
+      paramsTuple: [${paramsTuple}]
+      params: ${paramsType ? `{ ${paramsType} }` : "{}"}
+      query: {}
+      response: ${responseType}
+    }
+  }`;
+}
 function generateRegistryEntry(route) {
   const requestType = route.request?.type || "{}";
   const responseType = route.response?.type || "unknown";
   const { paramsType, paramsTuple } = generateRouteParams(route);
-  const routeName = route.name.split(".").map((segment) => string.camelCase(segment)).join(".");
+  const routeName = route.name;
   return `  '${routeName}': {
     methods: ${JSON.stringify(route.methods)},
     pattern: '${route.pattern}',
@@ -50,6 +75,35 @@ function generateRegistryEntry(route) {
     },
   }`;
 }
+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'
+const placeholder: any = {}
+
+export const registry = {
+${registryEntries}
+} as const satisfies Record<string, AdonisEndpoint>
+`;
+}
+function generateTypesContent(routes) {
+  const registryEntries = routes.map(generateTypesRegistryEntry).join("\n");
+  return `/* eslint-disable prettier/prettier */
+/// <reference path="../../adonisrc.ts" />
+
+import type { AdonisEndpoint } from '@tuyau/core/types'
+import type { Infer } from '@vinejs/vine/types'
+
+export interface Registry {
+${registryEntries}
+}
+
+declare module '@tuyau/core/types' {
+  export interface UserRegistry extends Registry {}
+}
+`;
+}
 function generateRegistryContent(routes) {
   const registryEntries = routes.map(generateRegistryEntry).join(",\n");
   return `/* eslint-disable prettier/prettier */
@@ -70,6 +124,7 @@ declare module '@tuyau/core/types' {
 function generateRegistry(options) {
   const config = {
     output: "./.adonisjs/client/registry.ts",
+    splitTypesFromRuntime: true,
     ...options
   };
   return {
@@ -77,9 +132,21 @@ function generateRegistry(options) {
       const startTime = process.hrtime();
       const scannedRoutes = routesScanner.getScannedRoutes();
       const filteredRoutes = filterRoutes(scannedRoutes, config.routes);
-      const registryContent = generateRegistryContent(filteredRoutes);
-      await writeOutputFile(config.output, registryContent);
-      devServer.ui.logger.info(`created ${config.output}`, { startTime });
+      if (config.splitTypesFromRuntime) {
+        const runtimeContent = generateRuntimeContent(filteredRoutes);
+        const typesContent = generateTypesContent(filteredRoutes);
+        const basePath = config.output.replace(/\.(ts|js)$/, "");
+        const runtimePath = `${basePath}.ts`;
+        const typesPath = `${basePath}.schema.d.ts`;
+        await writeOutputFile(runtimePath, runtimeContent);
+        await writeOutputFile(typesPath, typesContent);
+        devServer.ui.logger.info(`created ${runtimePath}`, { startTime });
+        devServer.ui.logger.info(`created ${typesPath}`, { startTime });
+      } else {
+        const registryContent = generateRegistryContent(filteredRoutes);
+        await writeOutputFile(config.output, registryContent);
+        devServer.ui.logger.info(`created ${config.output}`, { startTime });
+      }
     }
   };
 }

package/build/client/index.js

@@ -70,6 +70,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(".");
+}
 
 // src/client/tuyau.ts
 var Tuyau = class {
@@ -267,10 +270,10 @@ var Tuyau = class {
    * Creates a proxy-based fluent API for accessing endpoints by name
    */
   makeNamed(segments) {
-    const dot = segments.join(".");
-    const def = this.config.registry[dot];
+    const routeName = segmentsToRouteName(segments);
+    const def = this.config.registry[routeName];
     if (def) {
-      const fn = (args) => this.#doFetch(dot, def.methods[0], args);
+      const fn = (args) => this.#doFetch(routeName, def.methods[0], args);
       return new Proxy(fn, {
         get: (_t, prop) => this.makeNamed([...segments, String(prop)]),
         apply: (_t, _this, argArray) => fn(...argArray)

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

@@ -23,7 +23,8 @@ interface AdonisEndpoint {
 /**
  * Registry mapping endpoint names to their definitions
  */
-type AdonisRegistry = Record<string, AdonisEndpoint>;
+interface AdonisRegistry extends Record<string, AdonisEndpoint> {
+}
 type ValueOf<T> = T[keyof T];
 type IsEmptyObj<T> = keyof T extends never ? true : false;
 type IsEmptyTuple<T> = T extends [] ? true : false;
@@ -61,6 +62,18 @@ type ResponseOf<E extends AdonisEndpoint> = E['types']['response'];
  * Splits a dot-separated string into an array of strings
  */
 type Split<S extends string> = S extends `${infer H}.${infer T}` ? [H, ...Split<T>] : [S];
+/**
+ * Converts a string to camelCase
+ */
+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;
+/**
+ * Applies camelCase to each segment in a split array
+ */
+type CamelCaseSplit<T extends string[]> = T extends [
+    infer H extends string,
+    ...infer Rest extends string[]
+] ? [CamelCase<H>, ...CamelCaseSplit<Rest>] : [];
 /**
  * Converts a union type to an intersection type
  */
@@ -69,7 +82,7 @@ type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
  * Builds a nested object type for the fluent API based on endpoint names
  */
 type BuildNamed<Reg extends Record<string, AdonisEndpoint>> = UnionToIntersection<{
-    [K in keyof Reg & string]: SetAtPath<Split<K>, EndpointFn<Reg[K]>>;
+    [K in keyof Reg & string]: SetAtPath<CamelCaseSplit<Split<K>>, EndpointFn<Reg[K]>>;
 }[keyof Reg & string]>;
 /**
  * Sets a value at a specific path in a nested object type
@@ -103,22 +116,25 @@ type EndpointByMethodPattern<R extends Record<string, AdonisEndpoint>, M extends
 /**
  * Plugin function type for extending Tuyau functionality
  */
-type TuyauPlugin = (params: {
-    options: TuyauConfiguration<any>;
-}) => void;
+interface TuyauPlugin {
+    (params: {
+        options: TuyauConfiguration<any>;
+    }): void;
+}
 type MaybeArray<T> = T | T[];
 /**
  * Type for URL query parameters
  */
-type QueryParameters = Record<string, MaybeArray<string | number | boolean | null | undefined>>;
+interface QueryParameters extends Record<string, MaybeArray<string | number | boolean | null | undefined>> {
+}
 /**
  * Configuration options for creating a Tuyau client
  */
-type TuyauConfiguration<T extends Record<string, AdonisEndpoint>> = Omit<Options, 'prefixUrl' | 'body' | 'json' | 'method' | 'searchParams'> & {
+interface TuyauConfiguration<T extends Record<string, AdonisEndpoint>> extends Omit<Options, 'prefixUrl' | 'body' | 'json' | 'method' | 'searchParams'> {
     registry: T;
     baseUrl: string;
     plugins?: TuyauPlugin[];
-};
+}
 /**
  * Should be augmented by the user to provide their endpoint registry
  */
@@ -192,4 +208,4 @@ type RegistryGroupedByMethod<R extends Record<string, AdonisEndpoint>, M extends
     };
 };
 
-export { type AdonisEndpoint, type AdonisRegistry, type BuildNamed, 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 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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuyau/core",
   "type": "module",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.2",
   "description": "e2e client for AdonisJS",
   "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "MIT",
@@ -24,7 +24,7 @@
   },
   "peerDependencies": {
     "@adonisjs/assembler": "8.0.0-next.19",
-    "@adonisjs/core": "7.0.0-next.8"
+    "@adonisjs/core": "^7.0.0-next.10"
   },
   "dependencies": {
     "ky": "^1.14.0",
@@ -32,7 +32,7 @@
   },
   "devDependencies": {
     "@adonisjs/assembler": "8.0.0-next.19",
-    "@adonisjs/core": "7.0.0-next.8",
+    "@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",