@veloxts/router 0.6.64 → 0.6.66

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @veloxts/router
 
+## 0.6.66
+
+### Patch Changes
+
+- docs(skills): recommend namespace generator for AI agents
+- Updated dependencies
+  - @veloxts/core@0.6.66
+  - @veloxts/validation@0.6.66
+
+## 0.6.65
+
+### Patch Changes
+
+- improve ai integration and simplify api router definition
+- Updated dependencies
+  - @veloxts/core@0.6.65
+  - @veloxts/validation@0.6.65
+
 ## 0.6.64
 
 ### Patch Changes

package/dist/index.d.ts

@@ -55,8 +55,6 @@ export type { AnyRouter, InferAppRouter, TRPCInstance, TRPCPluginOptions, } from
 export { appRouter, buildTRPCRouter, createTRPCContextFactory, registerTRPCPlugin, trpc, veloxErrorToTRPCError, } from './trpc/index.js';
 export type { DiscoveryOptions, DiscoveryResult, DiscoveryWarning } from './discovery/index.js';
 export { DiscoveryError, DiscoveryErrorCode, directoryNotFound, discoverProcedures, discoverProceduresVerbose, fileLoadError, invalidExport, invalidFileType, isDiscoveryError, noProceduresFound, permissionDenied, } from './discovery/index.js';
-export type { ContractDefinition, ContractEntry, HttpMethodRoute, InferContract, InferRouterFromContracts, RouteDefinition, RoutesDefinition, } from './contracts.js';
-export { defineContract, defineRoutes } from './contracts.js';
 export type { ServeOptions } from './expose.js';
 export { serve } from './expose.js';
 /**

package/dist/index.js

@@ -59,7 +59,6 @@ export {
 // tRPC utilities
 appRouter, buildTRPCRouter, createTRPCContextFactory, registerTRPCPlugin, trpc, veloxErrorToTRPCError, } from './trpc/index.js';
 export { DiscoveryError, DiscoveryErrorCode, directoryNotFound, discoverProcedures, discoverProceduresVerbose, fileLoadError, invalidExport, invalidFileType, isDiscoveryError, noProceduresFound, permissionDenied, } from './discovery/index.js';
-export { defineContract, defineRoutes } from './contracts.js';
 export { serve } from './expose.js';
 // ============================================================================
 // Dependency Injection

package/dist/rest/index.d.ts

@@ -7,5 +7,5 @@ export type { RestAdapterOptions, RestPlugin, RestRoute } from './adapter.js';
 export { generateRestRoutes, getRouteSummary, registerRestRoutes, rest, } from './adapter.js';
 export type { RestMapping } from './naming.js';
 export { buildNestedRestPath, buildRestPath, followsNamingConvention, inferResourceName, parseNamingConvention, } from './naming.js';
-export type { ExtractRoutesType, RouteMap } from './routes.js';
+export type { ExtractRoutesType, RouteEntry, RouteMap } from './routes.js';
 export { extractRoutes } from './routes.js';

package/dist/rest/routes.d.ts

@@ -9,35 +9,47 @@
  */
 import type { ProcedureCollection, ProcedureRecord } from '../types.js';
 /**
- * Route map type - maps namespace -> procedure -> path
+ * A single route entry with method, path, and procedure kind
+ *
+ * Matches the RouteEntry interface in @veloxts/client
+ */
+export interface RouteEntry {
+    method: string;
+    path: string;
+    kind: 'query' | 'mutation';
+}
+/**
+ * Route map type - maps namespace -> procedure -> RouteEntry
  *
  * @example
  * ```typescript
  * {
  *   auth: {
- *     createSession: '/auth/login',
- *     createAccount: '/auth/register',
+ *     createSession: { method: 'POST', path: '/auth/login', kind: 'mutation' },
+ *     createAccount: { method: 'POST', path: '/auth/register', kind: 'mutation' },
  *   },
  *   users: {
- *     getProfile: '/users/me',
+ *     getProfile: { method: 'GET', path: '/users/me', kind: 'query' },
+ *     listUsers: { method: 'GET', path: '/users', kind: 'query' },
  *   },
  * }
  * ```
  */
-export type RouteMap = Record<string, Record<string, string>>;
+export type RouteMap = Record<string, Record<string, RouteEntry>>;
 /**
  * Extracts REST route mappings from procedure collections
  *
- * Reads `.rest()` override metadata from compiled procedures and generates
- * a RouteMap that frontend clients can import directly. This eliminates
- * the need to manually duplicate route mappings between backend and frontend.
+ * Generates a RouteMap with method, path, and kind for ALL procedures,
+ * enabling frontend clients to:
+ * 1. Know the correct REST endpoint for each procedure
+ * 2. Override naming convention heuristics with explicit `kind` field
  *
- * Only procedures with explicit `.rest({ path: '...' })` overrides are included.
- * Procedures using naming conventions (getUser, listUsers, etc.) don't need
- * explicit mappings since the client infers their paths automatically.
+ * For procedures with `.rest()` overrides, uses the specified path/method.
+ * For procedures following naming conventions, infers method/path automatically.
+ * For non-conventional procedures (like `health`), uses POST as default method.
  *
  * @param collections - Array of procedure collections to extract routes from
- * @returns RouteMap object with namespace -> procedure -> path mappings
+ * @returns RouteMap with namespace -> procedure -> { method, path, kind } mappings
  *
  * @example
  * ```typescript
@@ -46,15 +58,17 @@ export type RouteMap = Record<string, Record<string, string>>;
  * import { authProcedures } from './procedures/auth.js';
  * import { userProcedures } from './procedures/users.js';
  *
- * // Export for frontend
+ * // Export for frontend (includes kind for type detection)
  * export const routes = extractRoutes([authProcedures, userProcedures]);
  * export type AppRouter = typeof router;
  *
- * // Frontend: main.tsx
+ * // Frontend: api.ts
+ * import { createVeloxHooks } from '@veloxts/client/react';
  * import { routes } from '../../api/src/index.js';
  * import type { AppRouter } from '../../api/src/index.js';
  *
- * <VeloxProvider<AppRouter> config={{ baseUrl: '/api', routes }}>
+ * // Routes provide explicit kind for non-conventional procedure names
+ * export const api = createVeloxHooks<AppRouter>({ routes });
  * ```
  */
 export declare function extractRoutes(collections: ProcedureCollection[]): RouteMap;

package/dist/rest/routes.js

@@ -7,19 +7,21 @@
  *
  * @module rest/routes
  */
+import { buildRestPath, parseNamingConvention } from './naming.js';
 /**
  * Extracts REST route mappings from procedure collections
  *
- * Reads `.rest()` override metadata from compiled procedures and generates
- * a RouteMap that frontend clients can import directly. This eliminates
- * the need to manually duplicate route mappings between backend and frontend.
+ * Generates a RouteMap with method, path, and kind for ALL procedures,
+ * enabling frontend clients to:
+ * 1. Know the correct REST endpoint for each procedure
+ * 2. Override naming convention heuristics with explicit `kind` field
  *
- * Only procedures with explicit `.rest({ path: '...' })` overrides are included.
- * Procedures using naming conventions (getUser, listUsers, etc.) don't need
- * explicit mappings since the client infers their paths automatically.
+ * For procedures with `.rest()` overrides, uses the specified path/method.
+ * For procedures following naming conventions, infers method/path automatically.
+ * For non-conventional procedures (like `health`), uses POST as default method.
  *
  * @param collections - Array of procedure collections to extract routes from
- * @returns RouteMap object with namespace -> procedure -> path mappings
+ * @returns RouteMap with namespace -> procedure -> { method, path, kind } mappings
  *
  * @example
  * ```typescript
@@ -28,15 +30,17 @@
  * import { authProcedures } from './procedures/auth.js';
  * import { userProcedures } from './procedures/users.js';
  *
- * // Export for frontend
+ * // Export for frontend (includes kind for type detection)
  * export const routes = extractRoutes([authProcedures, userProcedures]);
  * export type AppRouter = typeof router;
  *
- * // Frontend: main.tsx
+ * // Frontend: api.ts
+ * import { createVeloxHooks } from '@veloxts/client/react';
  * import { routes } from '../../api/src/index.js';
  * import type { AppRouter } from '../../api/src/index.js';
  *
- * <VeloxProvider<AppRouter> config={{ baseUrl: '/api', routes }}>
+ * // Routes provide explicit kind for non-conventional procedure names
+ * export const api = createVeloxHooks<AppRouter>({ routes });
  * ```
  */
 export function extractRoutes(collections) {
@@ -44,15 +48,45 @@ export function extractRoutes(collections) {
     for (const collection of collections) {
         const namespaceRoutes = {};
         for (const [procedureName, procedure] of Object.entries(collection.procedures)) {
-            // Only include procedures with explicit .rest() path overrides
+            const kind = procedure.type;
+            // Check for explicit .rest() override first
             if (procedure.restOverride?.path) {
-                namespaceRoutes[procedureName] = procedure.restOverride.path;
+                const method = procedure.restOverride.method ?? inferMethodFromKind(kind);
+                namespaceRoutes[procedureName] = {
+                    method,
+                    path: procedure.restOverride.path,
+                    kind,
+                };
+                continue;
             }
+            // Try to infer from naming convention
+            const mapping = parseNamingConvention(procedureName, kind);
+            if (mapping) {
+                namespaceRoutes[procedureName] = {
+                    method: mapping.method,
+                    path: buildRestPath(collection.namespace, mapping),
+                    kind,
+                };
+                continue;
+            }
+            // Fallback for non-conventional names: use namespace path with POST for mutations
+            namespaceRoutes[procedureName] = {
+                method: inferMethodFromKind(kind),
+                path: `/${collection.namespace}`,
+                kind,
+            };
         }
-        // Only add namespace if it has custom routes
+        // Always add namespace (all procedures are included now)
         if (Object.keys(namespaceRoutes).length > 0) {
             routes[collection.namespace] = namespaceRoutes;
         }
     }
     return routes;
 }
+/**
+ * Infer HTTP method from procedure kind
+ * @internal
+ */
+function inferMethodFromKind(kind) {
+    return kind === 'query' ? 'GET' : 'POST';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/router",
-  "version": "0.6.64",
+  "version": "0.6.66",
   "description": "Procedure definitions with tRPC and REST routing for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",
@@ -40,8 +40,8 @@
     "@trpc/server": "11.8.0",
     "fastify": "5.6.2",
     "zod-to-json-schema": "3.24.5",
-    "@veloxts/core": "0.6.64",
-    "@veloxts/validation": "0.6.64"
+    "@veloxts/core": "0.6.66",
+    "@veloxts/validation": "0.6.66"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.16",