@tuyau/core 0.4.1 → 1.0.0-beta.0

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

@@ -0,0 +1,195 @@
+import { Options } from 'ky';
+import { ClientRouteMatchItTokens } from '@adonisjs/http-server/client/url_builder';
+
+/**
+ * Supported HTTP methods for API endpoints
+ */
+type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/**
+ * Definition of an AdonisJS endpoint with types and metadata
+ */
+interface AdonisEndpoint {
+    methods: Method[];
+    pattern: string;
+    tokens: ClientRouteMatchItTokens[];
+    types: {
+        paramsTuple: [...any[]];
+        params: Record<string, string | number | boolean>;
+        query: Record<string, any>;
+        body: unknown;
+        response: unknown;
+    };
+}
+/**
+ * Registry mapping endpoint names to their definitions
+ */
+type AdonisRegistry = 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;
+type Endpoints = ValueOf<AdonisRegistry>;
+type EndpointByName<Name extends keyof AdonisRegistry & string> = AdonisRegistry[Name];
+/**
+ * Checks if a type has any keys
+ */
+type HasKeys<T> = keyof T extends never ? false : true;
+/**
+ * Checks if a type has required keys (non-optional properties)
+ */
+type HasRequiredKeys<T> = T extends Record<string, any> ? keyof T extends never ? false : {} extends Pick<T, keyof T> ? false : true : false;
+/**
+ * Constructs the request arguments type for an endpoint
+ */
+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'>;
+/**
+ * Extracts response type from an endpoint
+ */
+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 union type to an intersection type
+ */
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+/**
+ * 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]>>;
+}[keyof Reg & string]>;
+/**
+ * Sets a value at a specific path in a nested object type
+ */
+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>;
+} : {};
+/**
+ * Function type for calling an endpoint
+ */
+type EndpointFn<E extends AdonisEndpoint> = (args: RequestArgs<E>) => Promise<E['types']['response']>;
+/**
+ * Filters endpoints by HTTP method
+ */
+type EndpointsByMethod<Reg extends Record<string, AdonisEndpoint>, M extends Method> = {
+    [K in keyof Reg]: M extends Reg[K]['methods'][number] ? Reg[K] : never;
+}[keyof Reg];
+type StrKeys<R> = Extract<keyof R, string>;
+type RegValues<R> = R[StrKeys<R>];
+/**
+ * Gets URL patterns for endpoints matching a specific HTTP method
+ */
+type PatternsByMethod<Reg extends Record<string, AdonisEndpoint>, M extends Method> = EndpointsByMethod<Reg, M>['pattern'];
+/**
+ * Finds an endpoint by HTTP method and URL pattern
+ */
+type EndpointByMethodPattern<R extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<R, M>> = FilterByMethodPathForRegistry<R, M, P>;
+/**
+ * Plugin function type for extending Tuyau functionality
+ */
+type 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>>;
+/**
+ * Configuration options for creating a Tuyau client
+ */
+type TuyauConfiguration<T extends Record<string, AdonisEndpoint>> = Omit<Options, 'prefixUrl' | 'body' | 'json' | 'method' | 'searchParams'> & {
+    registry: T;
+    baseUrl: string;
+    plugins?: TuyauPlugin[];
+};
+/**
+ * Should be augmented by the user to provide their endpoint registry
+ */
+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;
+}[keyof Reg];
+type EndpointByNameForRegistry<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = Reg[Name];
+/**
+ * Internal type utilities for working with endpoints by HTTP method and path pattern
+ * Accepts a registry as generic parameter
+ */
+declare namespace PathWithRegistry {
+    type Request<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = RequestArgs<FilterByMethodPathForRegistry<Reg, M, P>>;
+    type Response<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = ResponseOf<FilterByMethodPathForRegistry<Reg, M, P>>;
+    type Params<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = FilterByMethodPathForRegistry<Reg, M, P>['types']['params'];
+    type Body<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = FilterByMethodPathForRegistry<Reg, M, P>['types']['body'];
+    type Query<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = FilterByMethodPathForRegistry<Reg, M, P>['types']['query'];
+}
+/**
+ * Internal type utilities for working with endpoints by route name
+ * Accepts a registry as generic parameter
+ */
+declare namespace RouteWithRegistry {
+    type Request<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = RequestArgs<EndpointByNameForRegistry<Reg, Name>>;
+    type Response<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = ResponseOf<EndpointByNameForRegistry<Reg, Name>>;
+    type Params<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = EndpointByNameForRegistry<Reg, Name>['types']['params'];
+    type Body<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = EndpointByNameForRegistry<Reg, Name>['types']['body'];
+    type Query<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = EndpointByNameForRegistry<Reg, Name>['types']['query'];
+}
+/**
+ * Type utilities for working with endpoints by HTTP method and path pattern
+ * Uses the user-augmented registry
+ */
+declare namespace Path {
+    type Request<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = RequestArgs<FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>>;
+    type Response<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = ResponseOf<FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>>;
+    type Params<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>['types']['params'];
+    type Body<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>['types']['body'];
+    type Query<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>['types']['query'];
+}
+/**
+ * Type utilities for working with endpoints by route name
+ * Uses the user-augmented registry
+ */
+declare namespace Route {
+    type Request<Name extends keyof UserAdonisRegistry> = RequestArgs<UserEndpointByName<Name>>;
+    type Response<Name extends keyof UserAdonisRegistry> = ResponseOf<UserEndpointByName<Name>>;
+    type Params<Name extends keyof UserAdonisRegistry> = UserEndpointByName<Name>['types']['params'];
+    type Body<Name extends keyof UserAdonisRegistry> = UserEndpointByName<Name>['types']['body'];
+    type Query<Name extends keyof UserAdonisRegistry> = UserEndpointByName<Name>['types']['query'];
+}
+type ParamsShape<E> = E extends {
+    types: {
+        paramsTuple: infer PT;
+        params: infer P;
+    };
+} ? (IsEmptyTuple<PT> extends true ? {
+    paramsTuple?: PT;
+} : {
+    paramsTuple: PT;
+}) & (IsEmptyObj<P> extends true ? {} : {
+    params: P;
+}) : never;
+type RegistryGroupedByMethod<R extends Record<string, AdonisEndpoint>, M extends Method = Method> = {
+    [K in M | 'ALL']: {
+        [Route in keyof R as K extends 'ALL' ? Route : K extends R[Route]['methods'][number] ? Route : never]: ParamsShape<R[Route]>;
+    };
+};
+
+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 };

package/build/commands/commands.json

@@ -1 +1 @@
-{"commands":[{"commandName":"tuyau:generate","description":"Tuyau generator command","help":"","namespace":"tuyau","aliases":[],"flags":[{"name":"verbose","flagName":"verbose","required":false,"type":"boolean","description":"Verbose logs","default":false,"alias":"v"}],"args":[],"options":{"startApp":true},"filePath":"generate.js"}],"version":1}
+{"commands":[],"version":1}

package/package.json

@@ -1,41 +1,49 @@
 {
   "name": "@tuyau/core",
   "type": "module",
-  "version": "0.4.1",
-  "description": "",
-  "author": "",
+  "version": "1.0.0-beta.0",
+  "description": "e2e client for AdonisJS",
+  "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "MIT",
-  "keywords": [],
+  "keywords": [
+    "adonisjs",
+    "e2e",
+    "client"
+  ],
   "exports": {
-    ".": "./build/index.js",
-    "./types": "./build/src/types.js",
+    "./client": "./build/client/index.js",
+    "./types": "./build/client/types/index.js",
     "./commands": "./build/commands/main.js",
-    "./tuyau_provider": "./build/providers/tuyau_provider.js",
-    "./build_hook": "./build/src/hooks/build_hook.js"
+    "./hooks": "./build/backend/generate_registry.js"
   },
   "files": [
     "build"
   ],
   "engines": {
-    "node": ">=20.6.0"
+    "node": ">=24.0.0"
   },
   "peerDependencies": {
-    "@adonisjs/core": "^6.2.0"
+    "@adonisjs/assembler": "8.0.0-next.19",
+    "@adonisjs/core": "7.0.0-next.8"
   },
   "dependencies": {
-    "ts-morph": "^25.0.1",
-    "@tuyau/utils": "0.0.8"
+    "ky": "^1.14.0",
+    "object-to-formdata": "^4.5.1"
   },
   "devDependencies": {
-    "@adonisjs/assembler": "^7.8.2",
-    "@adonisjs/core": "^6.18.0",
-    "@poppinss/cliui": "^6.4.3",
-    "@poppinss/matchit": "^3.1.2",
-    "@tuyau/client": "0.2.9"
+    "@adonisjs/assembler": "8.0.0-next.19",
+    "@adonisjs/core": "7.0.0-next.8",
+    "@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",
+    "@typescript/analyze-trace": "^0.10.1",
+    "@vinejs/vine": "^4.1.0"
   },
   "publishConfig": {
     "access": "public",
-    "tag": "latest"
+    "tag": "beta"
   },
   "c8": {
     "reporter": [
@@ -48,11 +56,9 @@
   },
   "tsup": {
     "entry": [
-      "./index.ts",
-      "./src/types.ts",
-      "./src/hooks/build_hook.ts",
-      "./commands/generate.ts",
-      "./providers/tuyau_provider.ts"
+      "./src/backend/generate_registry.ts",
+      "./src/client/index.ts",
+      "./src/client/types/index.ts"
     ],
     "outDir": "./build",
     "clean": false,
@@ -65,7 +71,7 @@
     "copy:templates": "copyfiles --up 1 \"stubs/**/*.stub\" build",
     "typecheck": "tsc --noEmit",
     "format": "prettier --write .",
-    "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts",
+    "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts --force-exit",
     "test": "c8 npm run quick:test",
     "index:commands": "adonis-kit index build/commands",
     "prebuild": "npm run clean",

package/build/chunk-ADS4GRIL.js

@@ -1,14 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-
-export {
-  __decorateClass
-};

package/build/commands/generate.d.ts

@@ -1,16 +0,0 @@
-import { BaseCommand } from '@adonisjs/core/ace';
-import { CommandOptions } from '@adonisjs/core/types/ace';
-
-declare class CodegenTypes extends BaseCommand {
-    #private;
-    static commandName: string;
-    static description: string;
-    static options: CommandOptions;
-    verbose: boolean;
-    /**
-     * Execute command
-     */
-    run(): Promise<void>;
-}
-
-export { CodegenTypes as default };