ts-procedures 5.3.0 → 5.4.0

package/src/index.ts

@@ -26,9 +26,11 @@ export type TProcedureRegistration<TContext = unknown, TExtendedConfig = unknown
     schema?: {
       params?: TJSONSchema
       returnType?: TJSONSchema
+      input?: Record<string, TJSONSchema>
     }
     validation?: {
       params?: (params: any) => { errors?: any[] }
+      input?: Record<string, (value: any) => { errors?: any[] }>
     }
   } & TExtendedConfig
 
@@ -44,10 +46,12 @@ export type TStreamProcedureRegistration<TContext = unknown, TExtendedConfig = u
       params?: TJSONSchema
       yieldType?: TJSONSchema
       returnType?: TJSONSchema
+      input?: Record<string, TJSONSchema>
     }
     validation?: {
       params?: (params: any) => { errors?: any[] }
       yield?: (value: any) => { errors?: any[] }
+      input?: Record<string, (value: any) => { errors?: any[] }>
     }
   } & TExtendedConfig
 
@@ -73,10 +77,12 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
               params?: TJSONSchema
               yieldType?: TJSONSchema
               returnType?: TJSONSchema
+              input?: Record<string, TJSONSchema>
             }
             validation?: {
               params?: (params: any) => { errors?: any[] }
               yield?: (value: any) => { errors?: any[] }
+              input?: Record<string, (value: any) => { errors?: any[] }>
             }
           } & TExtendedConfig
         >
@@ -90,18 +96,26 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
     | TStreamProcedureRegistration<TContext, TExtendedConfig>
   > = new Map()
 
-  function Create<TName extends string, TParams, TReturnType>(
+  function Create<
+    TName extends string,
+    TParams,
+    TReturnType,
+    TInput extends Record<string, unknown> | undefined = undefined,
+  >(
     name: TName,
     config: {
       description?: string
       schema?: {
         params?: TParams
         returnType?: TReturnType
+        input?: TInput
       }
     } & TExtendedConfig,
     handler: (
       ctx: Prettify<TContext & TLocalContext & { isPrevalidated?: boolean }>,
-      params: TSchemaLib<TParams>
+      params: TInput extends Record<string, unknown>
+        ? Prettify<{ [K in keyof TInput]: TSchemaLib<TInput[K]> }>
+        : TSchemaLib<TParams>
     ) => Promise<TSchemaLib<TReturnType>>
   ) {
     // Capture definition location as first action
@@ -128,6 +142,7 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
         schema: jsonSchema,
         validation: {
           params: validations.params,
+          ...(validations.input && { input: validations.input }),
         },
       },
 
@@ -148,16 +163,37 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
             }
           }
 
+          // Validate each input channel independently for better error messages.
+          // Double validation (per-channel + merged) is intentional for developer experience;
+          // the cost is negligible — revisit if validation becomes a performance bottleneck.
+          if (validations?.input && !isPrevalidated) {
+            for (const [channel, validator] of Object.entries(validations.input)) {
+              const channelValue = (params as Record<string, unknown>)?.[channel]
+              const { errors } = validator(channelValue)
+
+              if (errors) {
+                throw new ProcedureValidationError(
+                  name,
+                  `Validation error for ${name} in input.${channel}`,
+                  errors,
+                  definitionInfo
+                )
+              }
+            }
+          }
+
           const localCtx: TLocalContext = {
             error: errorFactory, // Reuse pre-created factory
           }
 
+          // params is correctly typed at the public API boundary via conditional type;
+          // cast here because TS cannot narrow conditional generics inside implementations
           return await handler(
             {
               ...ctx,
               ...localCtx,
             } as Prettify<TContext & TLocalContext & { isPrevalidated?: boolean }>,
-            params
+            params as any
           )
         } catch (error: any) {
           if (error instanceof ProcedureError) {
@@ -204,12 +240,16 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
     } as {
       [K in TName]: (
         ctx: Prettify<TContext>,
-        params: TSchemaLib<TParams>
+        params: TInput extends Record<string, unknown>
+          ? Prettify<{ [K in keyof TInput]: TSchemaLib<TInput[K]> }>
+          : TSchemaLib<TParams>
       ) => Promise<TSchemaLib<TReturnType>>
     } & {
       procedure: (
         ctx: Prettify<TContext>,
-        params: TSchemaLib<TParams>
+        params: TInput extends Record<string, unknown>
+          ? Prettify<{ [K in keyof TInput]: TSchemaLib<TInput[K]> }>
+          : TSchemaLib<TParams>
       ) => Promise<TSchemaLib<TReturnType>>
       info: {
         name: TName
@@ -217,15 +257,23 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
         schema: {
           params?: TParams
           returnType?: TReturnType
+          input?: TInput
         }
         validation?: {
           params?: (params: any) => { errors?: any[] }
+          input?: Record<string, (value: any) => { errors?: any[] }>
         }
       } & TExtendedConfig
     }
   }
 
-  function CreateStream<TName extends string, TParams, TYieldType, TReturnType = void>(
+  function CreateStream<
+    TName extends string,
+    TParams,
+    TYieldType,
+    TReturnType = void,
+    TInput extends Record<string, unknown> | undefined = undefined,
+  >(
     name: TName,
     config: {
       description?: string
@@ -233,12 +281,15 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
         params?: TParams
         yieldType?: TYieldType
         returnType?: TReturnType
+        input?: TInput
       }
       validateYields?: boolean
     } & TExtendedConfig,
     handler: (
       ctx: Prettify<TContext & TStreamContext & { isPrevalidated?: boolean }>,
-      params: TSchemaLib<TParams>
+      params: TInput extends Record<string, unknown>
+        ? Prettify<{ [K in keyof TInput]: TSchemaLib<TInput[K]> }>
+        : TSchemaLib<TParams>
     ) => AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>
   ) {
     // Capture definition location as first action
@@ -268,6 +319,7 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
         validation: {
           params: validations.params,
           yield: validations.yield,
+          ...(validations.input && { input: validations.input }),
         },
       },
 
@@ -293,6 +345,23 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
           }
         }
 
+        // Validate each input channel independently (see Create for rationale)
+        if (validations?.input && !isPrevalidated) {
+          for (const [channel, validator] of Object.entries(validations.input)) {
+            const channelValue = (params as Record<string, unknown>)?.[channel]
+            const { errors } = validator(channelValue)
+
+            if (errors) {
+              throw new ProcedureValidationError(
+                name,
+                `Validation error for ${name} in input.${channel}`,
+                errors,
+                definitionInfo
+              )
+            }
+          }
+        }
+
         // Combine with external signal (e.g., from HTTP request) if provided
         const incomingSignal = (ctx as { signal?: AbortSignal }).signal
         const signal = incomingSignal
@@ -304,12 +373,14 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
           signal,
         }
 
+        // params is correctly typed at the public API boundary via conditional type;
+        // cast here because TS cannot narrow conditional generics inside implementations
         const userGenerator = handler(
           {
             ...ctx,
             ...streamCtx,
           } as Prettify<TContext & TStreamContext & { isPrevalidated?: boolean }>,
-          params
+          params as any
         )
 
         try {
@@ -376,12 +447,16 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
     } as {
       [K in TName]: (
         ctx: Prettify<TContext>,
-        params: TSchemaLib<TParams>
+        params: TInput extends Record<string, unknown>
+          ? Prettify<{ [K in keyof TInput]: TSchemaLib<TInput[K]> }>
+          : TSchemaLib<TParams>
       ) => AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>
     } & {
       procedure: (
         ctx: Prettify<TContext>,
-        params: TSchemaLib<TParams>
+        params: TInput extends Record<string, unknown>
+          ? Prettify<{ [K in keyof TInput]: TSchemaLib<TInput[K]> }>
+          : TSchemaLib<TParams>
       ) => AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>
       info: {
         name: TName
@@ -391,10 +466,12 @@ export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unkn
           params?: TParams
           yieldType?: TYieldType
           returnType?: TReturnType
+          input?: TInput
         }
         validation?: {
           params?: (params: any) => { errors?: any[] }
           yield?: (value: any) => { errors?: any[] }
+          input?: Record<string, (value: any) => { errors?: any[] }>
         }
       } & TExtendedConfig
     }

package/src/schema/compute-schema.ts

@@ -17,6 +17,7 @@ export function computeSchema<TParamsSchemaType, TReturnTypeSchemaType, TYieldTy
     params?: TParamsSchemaType
     returnType?: TReturnTypeSchemaType
     yieldType?: TYieldTypeSchemaType
+    input?: Record<string, unknown>
   },
   // Used for error stack trace details
   definitionInfo?: DefinitionInfo
@@ -25,26 +26,44 @@ export function computeSchema<TParamsSchemaType, TReturnTypeSchemaType, TYieldTy
     params?: TJSONSchema
     returnType?: TJSONSchema
     yieldType?: TJSONSchema
+    input?: Record<string, TJSONSchema>
   }
   validations: {
     params?: (params?: any) => { errors?: TSchemaValidationError[] }
     yield?: (value?: any) => { errors?: TSchemaValidationError[] }
+    input?: Record<string, (value?: any) => { errors?: TSchemaValidationError[] }>
   }
 } {
-  const jsonSchema: { params?: TJSONSchema; returnType?: TJSONSchema; yieldType?: TJSONSchema } = {
+  const jsonSchema: {
+    params?: TJSONSchema
+    returnType?: TJSONSchema
+    yieldType?: TJSONSchema
+    input?: Record<string, TJSONSchema>
+  } = {
     params: undefined,
     returnType: undefined,
     yieldType: undefined,
+    input: undefined,
   }
 
   const validations: {
     params?: (params?: any) => { errors?: TSchemaValidationError[] }
     yield?: (value?: any) => { errors?: TSchemaValidationError[] }
+    input?: Record<string, (value?: any) => { errors?: TSchemaValidationError[] }>
   } = {}
 
+  // Mutual exclusivity: params and input cannot both be defined
+  if (schema?.params && schema?.input) {
+    throw new ProcedureRegistrationError(
+      name,
+      `schema.params and schema.input are mutually exclusive for procedure "${name}". Use schema.params for flat input or schema.input for structured multi-channel input.`,
+      definitionInfo
+    )
+  }
+
   if (schema) {
     const {
-      jsonSchema: { params, returnType, yieldType },
+      jsonSchema: { params, returnType, yieldType, input },
       validation,
     } = schemaParser(schema, (errors) => {
       throw new ProcedureRegistrationError(
@@ -59,8 +78,10 @@ export function computeSchema<TParamsSchemaType, TReturnTypeSchemaType, TYieldTy
     jsonSchema.params = params
     jsonSchema.returnType = returnType
     jsonSchema.yieldType = yieldType
+    jsonSchema.input = input
     validations.params = validation.params
     validations.yield = validation.yield
+    validations.input = validation.input
   }
 
   return { jsonSchema, validations }

package/src/schema/parser.ts

@@ -4,10 +4,16 @@ import { extractJsonSchema } from './extract-json-schema.js'
 import { TJSONSchema } from './types.js'
 
 export type TSchemaParsed = {
-  jsonSchema: { params?: TJSONSchema; returnType?: TJSONSchema; yieldType?: TJSONSchema }
+  jsonSchema: {
+    params?: TJSONSchema
+    returnType?: TJSONSchema
+    yieldType?: TJSONSchema
+    input?: Record<string, TJSONSchema>
+  }
   validation: {
     params?: (params: any) => { errors?: TSchemaValidationError[] }
     yield?: (value: any) => { errors?: TSchemaValidationError[] }
+    input?: Record<string, (value: any) => { errors?: TSchemaValidationError[] }>
   }
 }
 
@@ -24,8 +30,8 @@ const ajv = addFormats(
 )
 
 export function schemaParser(
-  schema: { params?: unknown; returnType?: unknown; yieldType?: unknown },
-  onParseError: (errors: { params?: string; returnType?: string; yieldType?: string }) => void
+  schema: { params?: unknown; returnType?: unknown; yieldType?: unknown; input?: Record<string, unknown> },
+  onParseError: (errors: Record<string, string>) => void
 ): TSchemaParsed {
   const jsonSchema: TSchemaParsed['jsonSchema'] = {}
   const validation: TSchemaParsed['validation'] = {}
@@ -144,5 +150,66 @@ export function schemaParser(
     }
   }
 
+  if (schema.input) {
+    jsonSchema.input = {}
+    validation.input = {}
+
+    for (const [channelName, channelSchema] of Object.entries(schema.input)) {
+      if (!channelSchema) continue
+
+      let channelJsonSchema: TJSONSchema | undefined
+
+      try {
+        const extracted = extractJsonSchema(channelSchema as TJSONSchema)
+        if (extracted) {
+          channelJsonSchema = extracted
+          jsonSchema.input[channelName] = extracted
+        }
+      } catch (e: any) {
+        onParseError({
+          [`input.${channelName}`]: `Error extracting json schema schema.input.${channelName} - ${e.message}`,
+        })
+      }
+
+      if (!channelJsonSchema) {
+        onParseError({
+          [`input.${channelName}`]: `Error extracting json schema schema.input.${channelName} - might be empty or not a valid suretype or typebox type`,
+        })
+      } else {
+        let channelValidator: AJV.ValidateFunction | undefined
+
+        try {
+          channelValidator = ajv.compile(channelJsonSchema as TJSONSchema)
+        } catch (e: any) {
+          onParseError({
+            [`input.${channelName}`]: `Error compiling schema.input.${channelName} for validator - ${e.message}`,
+          })
+        }
+
+        validation.input[channelName] = (value: any) => {
+          if (!channelValidator) {
+            return {
+              errors: [
+                { message: 'Validator not initialized', keyword: 'internal' } as TSchemaValidationError,
+              ],
+            }
+          }
+
+          const valid = channelValidator(value)
+
+          if (!valid) {
+            const errors = channelValidator.errors
+
+            return {
+              errors: errors?.length ? errors : undefined,
+            }
+          }
+
+          return {}
+        }
+      }
+    }
+  }
+
   return { jsonSchema, validation }
 }