@rexeus/typeweaver-types 0.0.2 → 0.0.4

package/dist/lib/RequestValidator.ts

@@ -1,8 +1,16 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
 import type {
   IHttpRequest,
   IRequestValidator,
   SafeRequestValidationResult,
 } from "@rexeus/typeweaver-core";
+import { Validator } from "./Validator";
 
 /**
  * Abstract base class for HTTP request validation.
@@ -17,9 +25,12 @@ import type {
  * - Return validated data (for `validate`)
  * - Return success/error result (for `safeValidate`)
  */
-export abstract class RequestValidator implements IRequestValidator {
+export abstract class RequestValidator
+  extends Validator
+  implements IRequestValidator
+{
   public constructor() {
-    //
+    super();
   }
 
   /**

package/dist/lib/ResponseValidator.ts

@@ -1,8 +1,20 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
 import type {
+  HttpBodySchema,
+  HttpHeaderSchema,
   IHttpResponse,
   IResponseValidator,
+  ResponseValidationError,
   SafeResponseValidationResult,
 } from "@rexeus/typeweaver-core";
+import { Validator } from "./Validator";
+import type { ZodSafeParseResult } from "zod/v4";
 
 /**
  * Abstract base class for HTTP response validation.
@@ -16,7 +28,10 @@ import type {
  * Response validators are typically used in API clients to ensure
  * responses match the expected format before processing.
  */
-export abstract class ResponseValidator implements IResponseValidator {
+export abstract class ResponseValidator
+  extends Validator
+  implements IResponseValidator
+{
   /**
    * Validates a response without throwing errors.
    *
@@ -36,4 +51,70 @@ export abstract class ResponseValidator implements IResponseValidator {
    * @throws {ResponseValidationError} If response structure fails validation
    */
   public abstract validate(response: IHttpResponse): IHttpResponse;
+
+  /**
+   * Generic response validation method that validates header and body schemas.
+   * This method reduces code duplication across individual response validators.
+   *
+   * @param responseName - Name of the response type for error reporting
+   * @param headerSchema - Zod schema for header validation (optional)
+   * @param bodySchema - Zod schema for body validation (optional)
+   * @returns Function that validates response and returns result
+   */
+  protected validateResponseType<Response extends IHttpResponse>(
+    responseName: string,
+    headerSchema: HttpHeaderSchema | undefined,
+    bodySchema: HttpBodySchema | undefined
+  ): (
+    response: IHttpResponse,
+    error: ResponseValidationError
+  ) => SafeResponseValidationResult<Response> {
+    return (response, error) => {
+      let isValid = true;
+      const validatedResponse: IHttpResponse = {
+        statusCode: response.statusCode,
+        header: undefined,
+        body: undefined,
+      };
+
+      if (bodySchema) {
+        const validateBodyResult = bodySchema.safeParse(
+          response.body
+        ) as unknown as ZodSafeParseResult<Response["body"]>;
+
+        if (!validateBodyResult.success) {
+          error.addBodyIssues(responseName, validateBodyResult.error.issues);
+          isValid = false;
+        } else {
+          validatedResponse.body = validateBodyResult.data;
+        }
+      }
+
+      if (headerSchema) {
+        const coercedHeader = this.coerceHeaderToSchema(
+          response.header,
+          headerSchema.shape
+        );
+        const validateHeaderResult = headerSchema.safeParse(
+          coercedHeader
+        ) as unknown as ZodSafeParseResult<Response["header"]>;
+
+        if (!validateHeaderResult.success) {
+          error.addHeaderIssues(
+            responseName,
+            validateHeaderResult.error.issues
+          );
+          isValid = false;
+        } else {
+          validatedResponse.header = validateHeaderResult.data;
+        }
+      }
+
+      if (!isValid) {
+        return { isValid: false, error };
+      }
+
+      return { isValid: true, data: validatedResponse as Response };
+    };
+  }
 }

package/dist/lib/Validator.ts

@@ -0,0 +1,207 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
+import { $ZodArray, $ZodOptional } from "zod/v4/core";
+import type { $ZodShape } from "zod/v4/core";
+
+type SchemaInfo = { readonly originalKey: string; readonly isArray: boolean };
+
+/**
+ * Abstract base class for HTTP validation.
+ *
+ * This class provides the foundation for request and response validators that:
+ * - Analyze Zod schemas for correct single/multi value handling of headers and query parameters
+ * - Coerce objects to match schema expectations
+ */
+export abstract class Validator {
+  private static readonly schemaCacheCaseSensitive = new WeakMap<
+    $ZodShape,
+    Map<string, SchemaInfo>
+  >();
+  private static readonly schemaCacheCaseInsensitive = new WeakMap<
+    $ZodShape,
+    Map<string, SchemaInfo>
+  >();
+  /**
+   * Analyzes a Zod schema shape to create an efficient lookup map.
+   * Results are cached using WeakMap for optimal performance.
+   *
+   * @param shape - The Zod schema shape to analyze
+   * @param caseSensitive - Whether to preserve key casing (true) or normalize to lowercase (false)
+   * @returns Map with lookup keys pointing to original key and array type information
+   */
+  protected analyzeSchema(
+    shape: $ZodShape,
+    caseSensitive: boolean
+  ): Map<string, SchemaInfo> {
+    const cache = caseSensitive
+      ? Validator.schemaCacheCaseSensitive
+      : Validator.schemaCacheCaseInsensitive;
+
+    const cached = cache.get(shape);
+    if (cached) {
+      return cached;
+    }
+
+    const schemaMap = this.buildSchemaMap(shape, caseSensitive);
+    cache.set(shape, schemaMap);
+    return schemaMap;
+  }
+
+  /**
+   * Builds a schema map by analyzing the Zod shape structure.
+   * Extracts type information for each field to support proper coercion.
+   */
+  private buildSchemaMap(
+    shape: $ZodShape,
+    caseSensitive: boolean
+  ): Map<string, SchemaInfo> {
+    const schemaMap = new Map<string, SchemaInfo>();
+    for (const [key, zodType] of Object.entries(shape)) {
+      if (!zodType) continue;
+
+      const isArray =
+        zodType instanceof $ZodArray ||
+        (zodType instanceof $ZodOptional &&
+          zodType._zod.def.innerType instanceof $ZodArray);
+
+      const lookupKey = caseSensitive ? key : key.toLowerCase();
+      schemaMap.set(lookupKey, { originalKey: key, isArray });
+    }
+    return schemaMap;
+  }
+
+  /**
+   * Coerces objects to match schema expectations with configurable case sensitivity.
+   * Values not in the schema are ignored.
+   *
+   * @param data - The data object to coerce
+   * @param shape - The Zod schema shape to match against
+   * @param caseSensitive - Whether keys should match exactly (true) or case-insensitively (false)
+   * @returns Coerced data object with proper key casing and array coercion
+   */
+  protected coerceToSchema(
+    data: unknown,
+    shape: $ZodShape,
+    caseSensitive: boolean
+  ): unknown {
+    if (typeof data !== "object" || data === null) {
+      return data;
+    }
+
+    const schemaMap = this.analyzeSchema(shape, caseSensitive);
+    const coerced: Record<string, unknown | unknown[]> = {};
+
+    for (const [key, value] of Object.entries(data)) {
+      const normalizedKey = caseSensitive ? key : key.toLowerCase();
+      const schemaInfo = schemaMap.get(normalizedKey);
+
+      if (schemaInfo) {
+        this.addValueToCoerced(
+          coerced,
+          normalizedKey,
+          value,
+          schemaInfo.isArray
+        );
+      }
+      // Headers/params not in schema are ignored (strict validation)
+    }
+
+    // If case-sensitive, return coerced object as is
+    if (caseSensitive) {
+      return coerced;
+    }
+
+    // If case-insensitive, map back to original keys from schema
+    return this.mapToOriginalKeys(coerced, schemaMap);
+  }
+
+  /**
+   * Adds a value to the coerced object, handling collisions when multiple
+   * values exist for the same key (e.g., duplicate headers with different casing).
+   * Preserves all values as arrays when collisions occur to prevent data loss.
+   */
+  private addValueToCoerced(
+    coerced: Record<string, unknown | unknown[]>,
+    key: string,
+    value: unknown,
+    expectsArray: boolean
+  ): void {
+    const existing = coerced[key];
+    const newValue = this.coerceValueStructure(value, expectsArray);
+
+    if (existing === undefined) {
+      coerced[key] = newValue;
+      return;
+    }
+
+    // Merge existing and new values
+    const existingArray = Array.isArray(existing) ? existing : [existing];
+    const newArray = Array.isArray(newValue) ? newValue : [newValue];
+    const merged = [...existingArray, ...newArray];
+
+    // If schema expects a single value but we have multiple, preserve as array
+    // to avoid data loss (validation will catch this later)
+    coerced[key] = expectsArray || merged.length > 1 ? merged : merged[0];
+  }
+
+  /**
+   * Coerces a value's structure to match schema expectations.
+   * Wraps single values in arrays when schema expects array type,
+   * unwraps single-element arrays when schema expects single value.
+   */
+  private coerceValueStructure(
+    value: unknown,
+    expectsArray: boolean
+  ): unknown | unknown[] {
+    if (expectsArray && !Array.isArray(value)) {
+      return [value];
+    }
+    if (!expectsArray && Array.isArray(value) && value.length === 1) {
+      return value[0];
+    }
+    return value;
+  }
+
+  /**
+   * Maps normalized (lowercase) keys back to their original casing as defined in the schema.
+   * Used for case-insensitive matching where the output should preserve schema-defined casing.
+   */
+  private mapToOriginalKeys(
+    coerced: Record<string, unknown | unknown[]>,
+    schemaMap: Map<string, SchemaInfo>
+  ): Record<string, unknown | unknown[]> {
+    const withOriginalKeys: Record<string, unknown | unknown[]> = {};
+    for (const [key, value] of Object.entries(coerced)) {
+      const originalKey = schemaMap.get(key)?.originalKey ?? key;
+      withOriginalKeys[originalKey] = value;
+    }
+    return withOriginalKeys;
+  }
+
+  /**
+   * Coerces header data to match schema expectations with case-insensitive matching.
+   *
+   * @param header - The header object to coerce
+   * @param shape - The Zod schema shape for headers
+   * @returns Coerced header object
+   */
+  protected coerceHeaderToSchema(header: unknown, shape: $ZodShape): unknown {
+    return this.coerceToSchema(header, shape, false); // case-insensitive
+  }
+
+  /**
+   * Coerces query data to match schema expectations with case-sensitive matching.
+   *
+   * @param query - The query object to coerce
+   * @param shape - The Zod schema shape for query parameters
+   * @returns Coerced query object
+   */
+  protected coerceQueryToSchema(query: unknown, shape: $ZodShape): unknown {
+    return this.coerceToSchema(query, shape, true); // case-sensitive
+  }
+}

package/dist/lib/assert.ts

@@ -1,3 +1,10 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
 export function assert(value: any, message?: string): asserts value {
   if (!value) {
     throw new Error(message || "Assertion failed");

package/dist/lib/index.ts

@@ -1,4 +1,11 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
 export * from "./assert";
-export * from "./InvalidResponseStatusCodeError";
 export * from "./RequestValidator";
 export * from "./ResponseValidator";
+export * from "./Validator";

package/dist/templates/Request.ejs

@@ -1,14 +1,19 @@
-import definition from "<%= sourcePath %>";
-import { HttpMethod, type IHttpResponse } from "@rexeus/typeweaver-core";
-import { RequestCommand } from "../lib/clients";
-import { <%= pascalCaseOperationId %>ResponseValidator } from "<%= responseValidationFile %>";
+/* eslint-disable */
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ * 
+ * @generated by @rexeus/typeweaver
+ */
+
+import { HttpMethod } from "@rexeus/typeweaver-core";
 import {
     type <%= pascalCaseOperationId %>Response,
-    <% for (const ownResponse of [...ownSuccessResponses, ...ownErrorResponses]) { %>
+    <% for (const ownResponse of ownErrorResponses) { %>
         <%= ownResponse.name %>Response,
     <% } %>
 } from "<%= responseFile %>";
-<% for (const sharedResponse of [...sharedSuccessResponses, ...sharedErrorResponses]) { %>
+<% for (const sharedResponse of sharedErrorResponses) { %>
     import { <%= sharedResponse.name %>Response } from "<%= sharedResponse.path %>";
 <% } %>
 
@@ -44,50 +49,4 @@ export type I<%= pascalCaseOperationId %>Request = {
 <% } else { %>
     export type Successful<%= pascalCaseOperationId %>Response = Exclude<<%= pascalCaseOperationId %>Response, <%= [...ownErrorResponses, ...sharedErrorResponses].map(({ name }) => `${name}Response`).join(" | ") %>
     >;
-<% } %>
-
-export class <%= pascalCaseOperationId %>RequestCommand extends RequestCommand implements I<%= pascalCaseOperationId %>Request {
-    public override readonly method = definition.method as HttpMethod.<%= method %>;
-    public override readonly path = definition.path;
-
-    public <%= headerTsType ? `override` : `declare` %> readonly header: <%= headerTsType ? `I${pascalCaseOperationId}RequestHeader` : `undefined` %>;
-    public  <%= paramTsType ? `override` : `declare` %> readonly param: <%= paramTsType ? `I${pascalCaseOperationId}RequestParam` : `undefined` %>;
-    public <%= queryTsType ? `override` : `declare` %> readonly query: <%= queryTsType ? `I${pascalCaseOperationId}RequestQuery` : `undefined` %>;
-    public <%= bodyTsType ? `override` : `declare` %> readonly body: <%= bodyTsType ? `I${pascalCaseOperationId}RequestBody` : `undefined` %>;
-
-    private readonly responseValidator: <%= pascalCaseOperationId %>ResponseValidator;
-
-    public constructor(input: Omit<I<%= pascalCaseOperationId %>Request, "method" | "path">) {
-        super();
-
-        <% if (headerTsType) { %>
-        this.header = input.header;
-        <% } %>
-
-        <% if (paramTsType) { %>
-        this.param = input.param;
-        <% } %>
-
-        <% if (queryTsType) { %>
-        this.query = input.query;
-        <% } %>
-
-        <% if (bodyTsType) { %>
-        this.body = input.body;
-        <% } %>
-
-        this.responseValidator = new <%= pascalCaseOperationId %>ResponseValidator();
-    }
-
-    public processResponse(response: IHttpResponse): Successful<%= pascalCaseOperationId %>Response {
-        const result = this.responseValidator.validate(response);
-
-        <% for (const successResponse of [...ownSuccessResponses, ...sharedSuccessResponses]) { %>
-            if (result instanceof <%= successResponse.name %>Response) {
-                return result;
-            }
-        <% } %>
-
-        throw result;
-    }
-}
+<% } %>

package/dist/templates/RequestValidator.ejs

@@ -1,3 +1,11 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ * 
+ * @generated by @rexeus/typeweaver
+ */
+
 import definition from "<%= sourcePath %>";
 import { 
   type IHttpRequest,
@@ -33,7 +41,8 @@ export class <%= pascalCaseOperationId %>RequestValidator extends RequestValidat
 
         <% if(header) { %>
             if (definition.request.header) {
-                const result = definition.request.header.safeParse(request.header);
+                const coercedHeader = this.coerceHeaderToSchema(request.header, definition.request.header.shape);
+                const result = definition.request.header.safeParse(coercedHeader);
           
                 if (!result.success) {
                   error.addHeaderIssues(result.error.issues);
@@ -57,7 +66,8 @@ export class <%= pascalCaseOperationId %>RequestValidator extends RequestValidat
 
         <% if(query) { %>
             if (definition.request.query) {
-                const result = definition.request.query.safeParse(request.query);
+                const coercedQuery = this.coerceQueryToSchema(request.query, definition.request.query.shape);
+                const result = definition.request.query.safeParse(coercedQuery);
           
                 if (!result.success) {
                   error.addQueryIssues(result.error.issues);

package/dist/templates/Response.ejs

@@ -1,3 +1,11 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ * 
+ * @generated by @rexeus/typeweaver
+ */
+
 import { HttpResponse, HttpStatusCode } from "<%= coreDir %>";
 <% for(const sharedResponse of sharedResponses) { %>
 import type { I<%= sharedResponse.name %>Response, <%= sharedResponse.name %>Response } from "<%= sharedResponse.path %>";

package/dist/templates/ResponseValidator.ejs

@@ -1,4 +1,13 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ * 
+ * @generated by @rexeus/typeweaver
+ */
+
 import definition from "<%= sourcePath %>";
+import type { ZodSafeParseResult } from "zod/v4";
 import { 
     type IHttpResponse,
     type SafeResponseValidationResult,
@@ -6,8 +15,6 @@ import {
 } from "@rexeus/typeweaver-core";
 import {
     ResponseValidator,
-    InvalidResponseStatusCodeError,
-    assert,
 } from "../lib/types";
 import {
 type <%= pascalCaseOperationId %>Response,
@@ -25,42 +32,16 @@ type <%= pascalCaseOperationId %>Response,
 
 export class <%= pascalCaseOperationId %>ResponseValidator extends ResponseValidator {
     public safeValidate(response: IHttpResponse): SafeResponseValidationResult<<%= pascalCaseOperationId %>Response> {
-        const error = new ResponseValidationError(response.statusCode);
-        const validationResult = this.validateAgainstDefinedResponses(response, error);
+        const result = this.validateAgainstDefinedResponses(response);
 
-        if (error.hasIssues() && !validationResult.validResponseName) {
-            return {
-              isValid: false,
-              error,
-            };
+        if(!result.isValid && !result.error.hasResponseIssues()) {
+            result.error.addStatusCodeIssue([
+                <% const sortedStatusCodes = allStatusCodes.map(statusCode => statusCode.statusCode).sort() %>
+                <% for (const statusCode of sortedStatusCodes) { %><%= statusCode %>,<% } %>
+            ]);
         }
 
-        let data: <%= pascalCaseOperationId %>Response;
-        switch (response.statusCode) {
-            <% for (const statusCode of allStatusCodes) { %>
-                case <%= statusCode.statusCode %>: {
-                    <%
-                        for (const response of [...ownResponses, ...sharedResponses]) {
-                            if (response.statusCode === statusCode.statusCode) {
-                    %>
-                        if (validationResult.validResponseName === "<%= response.name %>") {
-                            data = new <%= response.name %>Response(validationResult.validatedResponse as unknown as I<%= response.name %>Response);
-                            break;
-                        }
-                    <% } } %>
-                    throw new Error("Could not find a response for status code '<%= statusCode.statusCode %>'");
-                }
-            <% } %>
-
-            default: {
-                throw new InvalidResponseStatusCodeError(response);
-            }
-        }
-
-        return {
-            isValid: true,
-            data,
-        };
+        return result;
     }
 
     public validate(response: IHttpResponse): <%= pascalCaseOperationId %>Response {
@@ -73,12 +54,8 @@ export class <%= pascalCaseOperationId %>ResponseValidator extends ResponseValid
         return result.data;
     }
 
-    private validateAgainstDefinedResponses(response: IHttpResponse, error: ResponseValidationError): { validResponseName?: string; validatedResponse?: IHttpResponse } {
-        const validatedResponse: IHttpResponse = {
-            statusCode: response.statusCode,
-            header: undefined,
-            body: undefined,
-        };
+    private validateAgainstDefinedResponses(response: IHttpResponse): SafeResponseValidationResult<<%= pascalCaseOperationId %>Response> {
+        const error = new ResponseValidationError(response.statusCode);
 
         <% for (const statusCode of allStatusCodes) { %>
             if (response.statusCode === <%= statusCode.statusCode %>) {
@@ -86,57 +63,34 @@ export class <%= pascalCaseOperationId %>ResponseValidator extends ResponseValid
             for (const response of [...ownResponses, ...sharedResponses]) {
             if (response.statusCode === statusCode.statusCode) {
             %>
-                const is<%= response.name %>Response = this.validate<%= response.name %>Response(response, validatedResponse, error);
-                if (is<%= response.name %>Response) {
-                    return { validResponseName: "<%= response.name %>", validatedResponse };
+                const validate<%= response.name %>ResponseResult = this.validate<%= response.name %>Response(response, error);
+                if (validate<%= response.name %>ResponseResult.isValid) {
+                    return validate<%= response.name %>ResponseResult;
                 }
             <% } } %>
             }
 
         <% } %>
 
-        return {};
+        return {
+            isValid: false,
+            error
+        };
     }
 
     <% for (const response of [...ownResponses, ...sharedResponses]) { %>
-    private validate<%= response.name %>Response(response: IHttpResponse, validatedResponse: IHttpResponse, error: ResponseValidationError): boolean {
-        let isValid = true;
-
-        <% if(response.hasBody) { %>
-            assert(
-                definition.responses[<%= response.index %>] 
-                && "body" in definition.responses[<%= response.index %>] 
-                && definition.responses[<%= response.index %>].body,
-                "'<%= response.name %>ResponseBody' has to be defined in the definition"
-            );
-            const validateBodyResult = definition.responses[<%= response.index %>].body.safeParse(response.body);
-
-            if (!validateBodyResult.success) {
-                error.addBodyIssues(validateBodyResult.error.issues);
-                isValid = false;
-            } else {
-                validatedResponse.body = validateBodyResult.data;
-            }
-        <% } %>
+    private validate<%= response.name %>Response(response: IHttpResponse, error: ResponseValidationError): SafeResponseValidationResult<<%= response.name %>Response> {
+        const result = this.validateResponseType<<%= response.name %>Response>(
+            "<%= response.name.replace(/Response$/, '') %>",
+            <% if(response.hasHeader) { %>definition.responses[<%= response.index %>] && "header" in definition.responses[<%= response.index %>] ? definition.responses[<%= response.index %>]!.header : undefined<% } else { %>undefined<% } %>,
+            <% if(response.hasBody) { %>definition.responses[<%= response.index %>] && "body" in definition.responses[<%= response.index %>] ? definition.responses[<%= response.index %>]!.body : undefined<% } else { %>undefined<% } %>,
+        )(response, error);
 
-        <% if(response.hasHeader) { %>
-            assert(
-                definition.responses[<%= response.index %>] 
-                && "header" in definition.responses[<%= response.index %>] 
-                && definition.responses[<%= response.index %>].header,
-                "'<%= response.name %>ResponseHeader' has to be defined in the definition"
-            );
-            const validateHeaderResult = definition.responses[<%= response.index %>].header.safeParse(response.header);
-
-            if (!validateHeaderResult.success) {
-                error.addHeaderIssues(validateHeaderResult.error.issues);
-                isValid = false;
-            } else {
-                validatedResponse.header = validateHeaderResult.data;
-            }
-        <% } %>
+        if (!result.isValid) {
+            return result;
+        }
 
-        return isValid;
+        return { isValid: true, data: new <%= response.name %>Response(result.data as I<%= response.name %>Response) };
     }
     <% } %>
 }

package/dist/templates/SharedResponse.ejs

@@ -1,3 +1,11 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ * 
+ * @generated by @rexeus/typeweaver
+ */
+
 import { HttpResponse, HttpStatusCode } from "<%= coreDir %>";
 
 <% if (headerTsType) { %>