@veloxts/router 0.6.78 → 0.6.80

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @veloxts/router
 
+## 0.6.80
+
+### Patch Changes
+
+- fix(router,client): preserve procedure type literals for query/mutation discrimination + lint fixes
+- Updated dependencies
+  - @veloxts/core@0.6.80
+  - @veloxts/validation@0.6.80
+
+## 0.6.79
+
+### Patch Changes
+
+- fix(router,client): preserve namespace literal types for proper type narrowing
+- Updated dependencies
+  - @veloxts/core@0.6.79
+  - @veloxts/validation@0.6.79
+
 ## 0.6.78
 
 ### Patch Changes

package/dist/procedure/builder.d.ts

@@ -79,11 +79,12 @@ export interface DefineProceduresOptions {
  * In development mode, emits warnings for procedure names that don't follow
  * naming conventions (which means they won't generate REST routes).
  *
+ * @template TNamespace - The literal namespace string (inferred from argument)
  * @template TProcedures - The record of named procedures
  * @param namespace - Resource namespace (e.g., 'users', 'posts')
  * @param procedures - Object containing named procedures
  * @param options - Optional configuration for warnings
- * @returns Procedure collection with preserved types
+ * @returns Procedure collection with preserved types including literal namespace
  *
  * @example
  * ```typescript
@@ -102,6 +103,7 @@ export interface DefineProceduresOptions {
  * });
  *
  * // Types are fully preserved:
+ * // userProcedures.namespace -> 'users' (literal type)
  * // userProcedures.procedures.getUser.inputSchema -> { id: string }
  * // userProcedures.procedures.createUser -> mutation type
  * ```
@@ -136,7 +138,7 @@ export interface DefineProceduresOptions {
  * });
  * ```
  */
-export declare function defineProcedures<TProcedures extends ProcedureDefinitions>(namespace: string, procedures: TProcedures, options?: DefineProceduresOptions): ProcedureCollection<InferProcedures<TProcedures>>;
+export declare function defineProcedures<const TNamespace extends string, TProcedures extends ProcedureDefinitions>(namespace: TNamespace, procedures: TProcedures, options?: DefineProceduresOptions): ProcedureCollection<TNamespace, InferProcedures<TProcedures>>;
 /**
  * Short alias for defineProcedures
  *

package/dist/procedure/builder.js

@@ -303,11 +303,12 @@ function createPrecompiledMiddlewareExecutor(middlewares, handler) {
  * In development mode, emits warnings for procedure names that don't follow
  * naming conventions (which means they won't generate REST routes).
  *
+ * @template TNamespace - The literal namespace string (inferred from argument)
  * @template TProcedures - The record of named procedures
  * @param namespace - Resource namespace (e.g., 'users', 'posts')
  * @param procedures - Object containing named procedures
  * @param options - Optional configuration for warnings
- * @returns Procedure collection with preserved types
+ * @returns Procedure collection with preserved types including literal namespace
  *
  * @example
  * ```typescript
@@ -326,6 +327,7 @@ function createPrecompiledMiddlewareExecutor(middlewares, handler) {
  * });
  *
  * // Types are fully preserved:
+ * // userProcedures.namespace -> 'users' (literal type)
  * // userProcedures.procedures.getUser.inputSchema -> { id: string }
  * // userProcedures.procedures.createUser -> mutation type
  * ```

package/dist/procedure/types.d.ts

@@ -268,7 +268,7 @@ export interface ProcedureBuilder<TInput = unknown, TOutput = unknown, TContext
      *   })
      * ```
      */
-    query(handler: ProcedureHandler<TInput, TOutput, TContext>): CompiledProcedure<TInput, TOutput, TContext>;
+    query(handler: ProcedureHandler<TInput, TOutput, TContext>): CompiledProcedure<TInput, TOutput, TContext, 'query'>;
     /**
      * Finalizes the procedure as a mutation (write operation)
      *
@@ -287,7 +287,7 @@ export interface ProcedureBuilder<TInput = unknown, TOutput = unknown, TContext
      *   })
      * ```
      */
-    mutation(handler: ProcedureHandler<TInput, TOutput, TContext>): CompiledProcedure<TInput, TOutput, TContext>;
+    mutation(handler: ProcedureHandler<TInput, TOutput, TContext>): CompiledProcedure<TInput, TOutput, TContext, 'mutation'>;
 }
 /**
  * Internal runtime state for the procedure builder
@@ -322,7 +322,7 @@ export interface BuilderRuntimeState {
  * The actual type safety is preserved through InferProcedures<T> which captures
  * the concrete types at definition time. This `any` only allows the assignment.
  */
-export type ProcedureDefinitions = Record<string, CompiledProcedure<any, any, any>>;
+export type ProcedureDefinitions = Record<string, CompiledProcedure<any, any, any, any>>;
 /**
  * Type helper to preserve procedure types in a collection
  *

package/dist/rest/routes.d.ts

@@ -87,7 +87,7 @@ export declare function extractRoutes(collections: ProcedureCollection[]): Route
  * ```
  */
 export type ExtractRoutesType<TRouter> = {
-    [K in keyof TRouter]: TRouter[K] extends ProcedureCollection<infer P> ? ExtractNamespaceRoutes<P> : never;
+    [K in keyof TRouter]: TRouter[K] extends ProcedureCollection<infer _N, infer P> ? ExtractNamespaceRoutes<P> : never;
 };
 /**
  * Helper type to extract routes from a procedure record

package/dist/router-utils.d.ts

@@ -7,21 +7,25 @@
  */
 import type { ProcedureCollection, ProcedureRecord } from './types.js';
 /**
- * Extracts the namespace from a ProcedureCollection as a literal type
+ * Extracts the namespace literal type from a ProcedureCollection
+ *
+ * With the updated ProcedureCollection<TNamespace, TProcedures> signature,
+ * TNamespace is now a literal type (e.g., 'users', 'auth') rather than just string.
  */
-type ExtractNamespace<T> = T extends ProcedureCollection<infer _P> & {
-    readonly namespace: infer N;
-} ? N extends string ? N : never : never;
+type ExtractNamespace<T> = T extends ProcedureCollection<infer N, infer _P> ? N : never;
 /**
  * Creates a union of namespaces from an array of ProcedureCollections
  */
-type CollectionNamespaces<T extends readonly ProcedureCollection[]> = {
+type CollectionNamespaces<T extends readonly ProcedureCollection<string, ProcedureRecord>[]> = {
     [K in keyof T]: ExtractNamespace<T[K]>;
 }[number];
 /**
  * Maps namespaces to their corresponding ProcedureCollections
+ *
+ * The Extract utility type now works correctly because TNamespace is a literal type,
+ * allowing proper narrowing from `'users' | 'auth'` to the specific `'users'` collection.
  */
-type RouterFromCollections<T extends readonly ProcedureCollection[]> = {
+type RouterFromCollections<T extends readonly ProcedureCollection<string, ProcedureRecord>[]> = {
     [K in CollectionNamespaces<T>]: Extract<T[number], {
         namespace: K;
     }>;
@@ -29,7 +33,7 @@ type RouterFromCollections<T extends readonly ProcedureCollection[]> = {
 /**
  * Result type from createRouter
  */
-export interface RouterResult<T extends readonly ProcedureCollection[]> {
+export interface RouterResult<T extends readonly ProcedureCollection<string, ProcedureRecord>[]> {
     /** Array of procedure collections for routing */
     readonly collections: T;
     /** Object mapping namespaces to procedure collections */
@@ -67,7 +71,7 @@ export interface RouterResult<T extends readonly ProcedureCollection[]> {
  * export const routes = extractRoutes(collections);
  * ```
  */
-export declare function createRouter<T extends ProcedureCollection<ProcedureRecord>[]>(...collections: T): RouterResult<T>;
+export declare function createRouter<T extends ProcedureCollection<string, ProcedureRecord>[]>(...collections: T): RouterResult<T>;
 /**
  * Creates a router object from procedure collections.
  *
@@ -87,5 +91,5 @@ export declare function createRouter<T extends ProcedureCollection<ProcedureReco
  * export type AppRouter = typeof router;
  * ```
  */
-export declare function toRouter<T extends ProcedureCollection<ProcedureRecord>[]>(...collections: T): RouterFromCollections<T>;
+export declare function toRouter<T extends ProcedureCollection<string, ProcedureRecord>[]>(...collections: T): RouterFromCollections<T>;
 export {};

package/dist/tokens.d.ts

@@ -104,4 +104,4 @@ export declare const TRPC_PLUGIN_OPTIONS: import("@veloxts/core").SymbolToken<TR
  *
  * Array of procedure collections to register with the router.
  */
-export declare const PROCEDURE_COLLECTIONS: import("@veloxts/core").SymbolToken<ProcedureCollection<import("./types.js").ProcedureRecord>[]>;
+export declare const PROCEDURE_COLLECTIONS: import("@veloxts/core").SymbolToken<ProcedureCollection<string, import("./types.js").ProcedureRecord>[]>;

package/dist/types.d.ts

@@ -227,10 +227,11 @@ export interface ParentResourceConfig {
  * @template TInput - The validated input type
  * @template TOutput - The handler output type
  * @template TContext - The context type
+ * @template TType - The procedure type literal ('query' or 'mutation')
  */
-export interface CompiledProcedure<TInput = unknown, TOutput = unknown, TContext extends BaseContext = BaseContext> {
+export interface CompiledProcedure<TInput = unknown, TOutput = unknown, TContext extends BaseContext = BaseContext, TType extends ProcedureType = ProcedureType> {
     /** Whether this is a query or mutation */
-    readonly type: ProcedureType;
+    readonly type: TType;
     /** The procedure handler function */
     readonly handler: ProcedureHandler<TInput, TOutput, TContext>;
     /** Input validation schema (if specified) */
@@ -277,32 +278,37 @@ export interface CompiledProcedure<TInput = unknown, TOutput = unknown, TContext
  *
  * NOTE: Uses `any` for variance compatibility - see ProcedureDefinitions for explanation.
  */
-export type ProcedureRecord = Record<string, CompiledProcedure<any, any, any>>;
+export type ProcedureRecord = Record<string, CompiledProcedure<any, any, any, any>>;
 /**
  * Procedure collection with namespace
  *
  * Groups related procedures under a common namespace for routing.
  *
+ * @template TNamespace - The literal namespace string (e.g., 'users', 'posts')
  * @template TProcedures - The record of named procedures
  */
-export interface ProcedureCollection<TProcedures extends ProcedureRecord = ProcedureRecord> {
+export interface ProcedureCollection<TNamespace extends string = string, TProcedures extends ProcedureRecord = ProcedureRecord> {
     /** Resource namespace (e.g., 'users', 'posts') */
-    readonly namespace: string;
+    readonly namespace: TNamespace;
     /** Named procedures in this collection */
     readonly procedures: TProcedures;
 }
 /**
  * Extracts the input type from a compiled procedure
  */
-export type InferProcedureInput<T> = T extends CompiledProcedure<infer I, unknown, BaseContext> ? I : never;
+export type InferProcedureInput<T> = T extends CompiledProcedure<infer I, unknown, BaseContext, ProcedureType> ? I : never;
 /**
  * Extracts the output type from a compiled procedure
  */
-export type InferProcedureOutput<T> = T extends CompiledProcedure<unknown, infer O, BaseContext> ? O : never;
+export type InferProcedureOutput<T> = T extends CompiledProcedure<unknown, infer O, BaseContext, ProcedureType> ? O : never;
 /**
  * Extracts the context type from a compiled procedure
  */
-export type InferProcedureContext<T> = T extends CompiledProcedure<unknown, unknown, infer C> ? C : never;
+export type InferProcedureContext<T> = T extends CompiledProcedure<unknown, unknown, infer C, ProcedureType> ? C : never;
+/**
+ * Extracts the type (query/mutation) from a compiled procedure
+ */
+export type InferProcedureType<T> = T extends CompiledProcedure<unknown, unknown, BaseContext, infer TType> ? TType : never;
 /**
  * Extracts procedure types from a collection
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/router",
-  "version": "0.6.78",
+  "version": "0.6.80",
   "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.78",
-    "@veloxts/validation": "0.6.78"
+    "@veloxts/core": "0.6.80",
+    "@veloxts/validation": "0.6.80"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.16",

package/dist/contracts.d.ts

@@ -1,180 +0,0 @@
-/**
- * Contract Utilities - Browser-Safe Type Definitions
- *
- * These utilities enable "Great DX" by allowing developers to define
- * type contracts in a concise, type-safe manner that's compatible
- * with browser bundling.
- *
- * The key insight is that Zod schemas are browser-safe, so we can
- * use them to define contracts without pulling in server code.
- *
- * @example
- * ```typescript
- * // schemas/user.ts - Browser-safe Zod schemas
- * export const GetUserInput = z.object({ id: z.string() });
- * export const UserSchema = z.object({ id: z.string(), name: z.string() });
- *
- * // contracts.ts - Type-safe contract definition
- * import { defineContract } from '@veloxts/router';
- * import { GetUserInput, UserSchema } from './schemas/user.js';
- *
- * export const userContracts = defineContract({
- *   getUser: { input: GetUserInput, output: UserSchema },
- *   createUser: { input: CreateUserInput, output: UserSchema },
- * });
- *
- * export type AppRouter = { users: typeof userContracts };
- * ```
- *
- * @module contracts
- */
-import type { ZodType, ZodTypeDef } from 'zod';
-/**
- * Represents a single procedure's input/output contract
- *
- * Both input and output are optional to support:
- * - Procedures with no input (e.g., getHealth)
- * - Procedures with inferred output (less common)
- */
-export interface ContractEntry {
-    /** Input validation schema (optional for procedures with no input) */
-    input?: ZodType<unknown, ZodTypeDef, unknown>;
-    /** Output validation schema (optional for inferred output) */
-    output?: ZodType<unknown, ZodTypeDef, unknown>;
-}
-/**
- * A collection of procedure contracts
- */
-export type ContractDefinition = Record<string, ContractEntry>;
-/**
- * Infers the TypeScript type from a Zod schema
- *
- * @template T - The Zod schema type
- */
-type InferZodType<T> = T extends ZodType<infer O, ZodTypeDef, unknown> ? O : undefined;
-/**
- * Transforms a contract entry into its inferred types
- *
- * @template T - The contract entry type
- */
-type InferContractEntry<T extends ContractEntry> = {
-    input: T['input'] extends ZodType ? InferZodType<T['input']> : undefined;
-    output: T['output'] extends ZodType ? InferZodType<T['output']> : undefined;
-};
-/**
- * Transforms a contract definition into inferred procedure types
- *
- * This is the core type utility that enables automatic type inference
- * from Zod schemas to procedure contracts.
- *
- * @template T - The contract definition type
- *
- * @example
- * ```typescript
- * const contracts = defineContract({
- *   getUser: { input: GetUserInput, output: UserSchema },
- * });
- *
- * // InferContract<typeof contracts> = {
- * //   getUser: { input: { id: string }; output: { id: string; name: string } }
- * // }
- * ```
- */
-export type InferContract<T extends ContractDefinition> = {
-    [K in keyof T]: InferContractEntry<T[K]>;
-};
-/**
- * Infers router types from a collection of contracts
- *
- * @template T - Record of namespace to contract definitions
- *
- * @example
- * ```typescript
- * export type AppRouter = InferRouterFromContracts<{
- *   users: typeof userContracts;
- *   auth: typeof authContracts;
- * }>;
- * ```
- */
-export type InferRouterFromContracts<T extends Record<string, ContractDefinition>> = {
-    [K in keyof T]: InferContract<T[K]>;
-};
-/**
- * Defines a type-safe procedure contract from Zod schemas
- *
- * This function provides compile-time validation and autocomplete while
- * returning the contract definition for type inference. The runtime value
- * is just passed through - the magic is all in the types.
- *
- * **Why use defineContract?**
- * - Automatic type inference from Zod schemas
- * - TypeScript validates schema existence at compile time
- * - Autocomplete for schema imports
- * - One-line per procedure (vs 5+ lines with manual types)
- * - Browser-safe - only imports Zod schemas, not server code
- *
- * @template T - The contract definition type (inferred)
- * @param contracts - Object mapping procedure names to their schemas
- * @returns The same object, typed for inference
- *
- * @example
- * ```typescript
- * // Define contracts alongside your schemas
- * import { GetUserInput, UserSchema, CreateUserInput } from './schemas/user.js';
- *
- * export const userContracts = defineContract({
- *   getUser: { input: GetUserInput, output: UserSchema },
- *   listUsers: { output: z.array(UserSchema) },
- *   createUser: { input: CreateUserInput, output: UserSchema },
- *   deleteUser: { input: z.object({ id: z.string() }), output: z.object({ success: z.boolean() }) },
- * });
- *
- * // Use in AppRouter type
- * export type AppRouter = {
- *   users: typeof userContracts;
- *   auth: typeof authContracts;
- * };
- * ```
- */
-export declare function defineContract<T extends ContractDefinition>(contracts: T): T;
-/**
- * HTTP method type
- */
-export type HttpMethodRoute = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-/**
- * A single route entry
- */
-export interface RouteDefinition {
-    method: HttpMethodRoute;
-    path: string;
-}
-/**
- * Collection of route definitions for a namespace
- */
-export type RoutesDefinition = Record<string, RouteDefinition>;
-/**
- * Defines route mappings for frontend client
- *
- * This helper provides type safety and autocomplete for route definitions,
- * making it easier to maintain route mappings that match your procedures.
- *
- * @template T - The routes definition type (inferred)
- * @param routes - Object mapping procedure names to their routes
- * @returns The same object, typed for client consumption
- *
- * @example
- * ```typescript
- * export const userRoutes = defineRoutes({
- *   getUser: { method: 'GET', path: '/users/:id' },
- *   listUsers: { method: 'GET', path: '/users' },
- *   createUser: { method: 'POST', path: '/users' },
- * });
- *
- * export const routes = {
- *   users: userRoutes,
- *   auth: authRoutes,
- * } as const;
- * ```
- */
-export declare function defineRoutes<T extends RoutesDefinition>(routes: T): T;
-export {};

package/dist/contracts.js

@@ -1,100 +0,0 @@
-/**
- * Contract Utilities - Browser-Safe Type Definitions
- *
- * These utilities enable "Great DX" by allowing developers to define
- * type contracts in a concise, type-safe manner that's compatible
- * with browser bundling.
- *
- * The key insight is that Zod schemas are browser-safe, so we can
- * use them to define contracts without pulling in server code.
- *
- * @example
- * ```typescript
- * // schemas/user.ts - Browser-safe Zod schemas
- * export const GetUserInput = z.object({ id: z.string() });
- * export const UserSchema = z.object({ id: z.string(), name: z.string() });
- *
- * // contracts.ts - Type-safe contract definition
- * import { defineContract } from '@veloxts/router';
- * import { GetUserInput, UserSchema } from './schemas/user.js';
- *
- * export const userContracts = defineContract({
- *   getUser: { input: GetUserInput, output: UserSchema },
- *   createUser: { input: CreateUserInput, output: UserSchema },
- * });
- *
- * export type AppRouter = { users: typeof userContracts };
- * ```
- *
- * @module contracts
- */
-// ============================================================================
-// Contract Definition Helper
-// ============================================================================
-/**
- * Defines a type-safe procedure contract from Zod schemas
- *
- * This function provides compile-time validation and autocomplete while
- * returning the contract definition for type inference. The runtime value
- * is just passed through - the magic is all in the types.
- *
- * **Why use defineContract?**
- * - Automatic type inference from Zod schemas
- * - TypeScript validates schema existence at compile time
- * - Autocomplete for schema imports
- * - One-line per procedure (vs 5+ lines with manual types)
- * - Browser-safe - only imports Zod schemas, not server code
- *
- * @template T - The contract definition type (inferred)
- * @param contracts - Object mapping procedure names to their schemas
- * @returns The same object, typed for inference
- *
- * @example
- * ```typescript
- * // Define contracts alongside your schemas
- * import { GetUserInput, UserSchema, CreateUserInput } from './schemas/user.js';
- *
- * export const userContracts = defineContract({
- *   getUser: { input: GetUserInput, output: UserSchema },
- *   listUsers: { output: z.array(UserSchema) },
- *   createUser: { input: CreateUserInput, output: UserSchema },
- *   deleteUser: { input: z.object({ id: z.string() }), output: z.object({ success: z.boolean() }) },
- * });
- *
- * // Use in AppRouter type
- * export type AppRouter = {
- *   users: typeof userContracts;
- *   auth: typeof authContracts;
- * };
- * ```
- */
-export function defineContract(contracts) {
-    return contracts;
-}
-/**
- * Defines route mappings for frontend client
- *
- * This helper provides type safety and autocomplete for route definitions,
- * making it easier to maintain route mappings that match your procedures.
- *
- * @template T - The routes definition type (inferred)
- * @param routes - Object mapping procedure names to their routes
- * @returns The same object, typed for client consumption
- *
- * @example
- * ```typescript
- * export const userRoutes = defineRoutes({
- *   getUser: { method: 'GET', path: '/users/:id' },
- *   listUsers: { method: 'GET', path: '/users' },
- *   createUser: { method: 'POST', path: '/users' },
- * });
- *
- * export const routes = {
- *   users: userRoutes,
- *   auth: authRoutes,
- * } as const;
- * ```
- */
-export function defineRoutes(routes) {
-    return routes;
-}