@rexeus/typeweaver-types 0.6.4 → 0.6.5

package/dist/lib/RequestValidator.d.ts

@@ -0,0 +1,17 @@
+import type {
+  IHttpRequest,
+  IRequestValidator,
+  SafeRequestValidationResult,
+} from "@rexeus/typeweaver-core";
+import { Validator } from "./Validator";
+
+export declare abstract class RequestValidator
+  extends Validator
+  implements IRequestValidator
+{
+  public constructor();
+  public abstract safeValidate(
+    request: IHttpRequest
+  ): SafeRequestValidationResult<IHttpRequest>;
+  public abstract validate(request: IHttpRequest): IHttpRequest;
+}

package/dist/lib/RequestValidator.js

@@ -0,0 +1,19 @@
+import { Validator } from "./Validator";
+/**
+* Abstract base class for HTTP request validation.
+*
+* This class provides the foundation for request validators that:
+* - Validate headers, body, query parameters, and path parameters
+* - Support both safe (non-throwing) and unsafe (throwing) validation
+* - Integrate with Zod schemas for runtime validation
+* - Provide detailed error information for debugging
+*
+* Implementations should validate all request components and either:
+* - Return validated data (for `validate`)
+* - Return success/error result (for `safeValidate`)
+*/
+export class RequestValidator extends Validator {
+	constructor() {
+		super();
+	}
+}

package/dist/lib/ResponseValidator.d.ts

@@ -0,0 +1,25 @@
+import type {
+  IHttpResponse,
+  IResponseValidator,
+  ResponseValidationError,
+  SafeResponseValidationResult,
+} from "@rexeus/typeweaver-core";
+import { Validator } from "./Validator";
+
+export declare abstract class ResponseValidator
+  extends Validator
+  implements IResponseValidator
+{
+  public abstract safeValidate(
+    response: IHttpResponse
+  ): SafeResponseValidationResult<IHttpResponse>;
+  public abstract validate(response: IHttpResponse): IHttpResponse;
+  protected validateResponseType<Response extends IHttpResponse>(
+    responseName: string,
+    headerSchema: unknown,
+    bodySchema: unknown
+  ): (
+    response: IHttpResponse,
+    error: ResponseValidationError
+  ) => SafeResponseValidationResult<Response>;
+}

package/dist/lib/ResponseValidator.js

@@ -0,0 +1,63 @@
+import { Validator } from "./Validator";
+/**
+* Abstract base class for HTTP response validation.
+*
+* This class provides the foundation for response validators that:
+* - Validate response status codes match expected values
+* - Validate response headers and body against schemas
+* - Support both safe (non-throwing) and unsafe (throwing) validation
+* - Integrate with Zod schemas for runtime validation
+*
+* Response validators are typically used in API clients to ensure
+* responses match the expected format before processing.
+*/
+export class ResponseValidator extends Validator {
+	/**
+	* 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
+	*/
+	validateResponseType(responseName, headerSchema, bodySchema) {
+		return (response, error) => {
+			let isValid = true;
+			const validatedResponse = {
+				statusCode: response.statusCode,
+				header: undefined,
+				body: undefined
+			};
+			if (bodySchema) {
+				const validateBodyResult = bodySchema.safeParse(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, this.getSchema(headerSchema));
+				const validateHeaderResult = headerSchema.safeParse(coercedHeader);
+				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
+			};
+		};
+	}
+}

package/dist/lib/Validator.d.ts

@@ -0,0 +1,25 @@
+type SchemaInfo = {
+  readonly originalKey: string;
+  readonly isArray: boolean;
+};
+
+export declare abstract class Validator {
+  protected analyzeSchema(
+    shape: Record<string, unknown>,
+    caseSensitive: boolean
+  ): Map<string, SchemaInfo>;
+  protected getSchema(headerSchema: unknown): Record<string, unknown>;
+  protected coerceToSchema(
+    data: unknown,
+    shape: Record<string, unknown>,
+    caseSensitive: boolean
+  ): unknown;
+  protected coerceHeaderToSchema(
+    header: unknown,
+    shape: Record<string, unknown>
+  ): unknown;
+  protected coerceQueryToSchema(
+    query: unknown,
+    shape: Record<string, unknown>
+  ): unknown;
+}

package/dist/lib/Validator.js

@@ -0,0 +1,185 @@
+import z from "zod";
+import { $ZodArray, $ZodOptional } from "zod/v4/core";
+/**
+* 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 class Validator {
+	static schemaCacheCaseSensitive = new WeakMap();
+	static schemaCacheCaseInsensitive = new WeakMap();
+	/**
+	* 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
+	*/
+	analyzeSchema(shape, caseSensitive) {
+		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;
+	}
+	/**
+	*
+	* Extracts a Zod schema shape from header or query schemas.
+	* This is used to support schema coercion and analysis.
+	*
+	* @param headerSchema
+	* @returns
+	*/
+	getSchema(headerSchema) {
+		if (headerSchema instanceof z.ZodObject) {
+			return headerSchema.shape;
+		}
+		if (headerSchema instanceof z.ZodOptional) {
+			const unwrapped = headerSchema.unwrap();
+			if (unwrapped instanceof z.ZodObject) {
+				return unwrapped.shape;
+			}
+		}
+		return {};
+	}
+	/**
+	* Builds a schema map by analyzing the Zod shape structure.
+	* Extracts type information for each field to support proper coercion.
+	*/
+	buildSchemaMap(shape, caseSensitive) {
+		const schemaMap = new Map();
+		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
+	*/
+	coerceToSchema(data, shape, caseSensitive) {
+		if (typeof data !== "object" || data === null) {
+			return data;
+		}
+		const schemaMap = this.analyzeSchema(shape, caseSensitive);
+		const coerced = {};
+		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);
+			}
+		}
+		// 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.
+	*/
+	addValueToCoerced(coerced, key, value, expectsArray) {
+		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.
+	*/
+	coerceValueStructure(value, expectsArray) {
+		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.
+	*/
+	mapToOriginalKeys(coerced, schemaMap) {
+		const withOriginalKeys = {};
+		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
+	*/
+	coerceHeaderToSchema(header, shape) {
+		if (typeof header !== "object" || header === null) {
+			return this.coerceToSchema(header ?? {}, shape, false);
+		}
+		const preprocessed = this.splitCommaDelimitedValues(header, shape);
+		return this.coerceToSchema(preprocessed, shape, false);
+	}
+	/**
+	* Splits comma-separated header strings into arrays per RFC 7230.
+	* Only applies to fields where the schema expects an array type.
+	* Values that are already arrays pass through unchanged.
+	*/
+	splitCommaDelimitedValues(header, shape) {
+		const schemaMap = this.analyzeSchema(shape, false);
+		const result = {};
+		for (const [key, value] of Object.entries(header)) {
+			const schemaInfo = schemaMap.get(key.toLowerCase());
+			if (schemaInfo?.isArray && typeof value === "string") {
+				result[key] = value.split(",").map((v) => v.trim()).filter((v) => v !== "");
+			} else {
+				result[key] = value;
+			}
+		}
+		return result;
+	}
+	/**
+	* 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
+	*/
+	coerceQueryToSchema(query, shape) {
+		return this.coerceToSchema(query ?? {}, shape, true);
+	}
+}

package/dist/lib/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(value: unknown, message?: string): asserts value;

package/dist/lib/assert.js

@@ -0,0 +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 function assert(value, message) {
+	if (!value) {
+		throw new Error(message || "Assertion failed");
+	}
+}

package/dist/templates/Request.ejs

@@ -2,7 +2,7 @@
 /**
  * This file was automatically generated by typeweaver.
  * DO NOT EDIT. Instead, modify the source definition file and generate again.
- * 
+ *
  * @generated by @rexeus/typeweaver
  */
 
@@ -13,8 +13,11 @@ import {
         <%= ownResponse.name %>Response,
     <% } %>
 } from "<%= responseFile %>";
-<% for (const sharedResponse of sharedErrorResponses) { %>
-    import { <%= sharedResponse.name %>Response } from "<%= sharedResponse.path %>";
+<% for (const sharedError of sharedErrorResponses) { %>
+import { <%= sharedError.name %>Response } from "<%= sharedError.path %>";
+<% } %>
+<% for (const entityError of entityErrorResponses) { %>
+import { <%= entityError.name %>Response } from "<%= entityError.path %>";
 <% } %>
 
 <% if (headerTsType) { %>
@@ -47,6 +50,10 @@ export type I<%= pascalCaseOperationId %>Request = {
 <% } else if (!hasErrorResponses) { %>
     export type Successful<%= pascalCaseOperationId %>Response = <%= pascalCaseOperationId %>Response;
 <% } else { %>
-    export type Successful<%= pascalCaseOperationId %>Response = Exclude<<%= pascalCaseOperationId %>Response, <%= [...ownErrorResponses, ...sharedErrorResponses].map(({ name }) => `${name}Response`).join(" | ") %>
+    export type Successful<%= pascalCaseOperationId %>Response = Exclude<<%= pascalCaseOperationId %>Response, <%= [
+        ...sharedErrorResponses,
+        ...ownErrorResponses,
+        ...entityErrorResponses,
+    ].map(({ name }) => `${name}Response`).join(" | ") %>
     >;
 <% } %>

package/dist/templates/Response.ejs

@@ -2,13 +2,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 { HttpResponse, HttpStatusCode } from "<%= coreDir %>";
-<% for(const sharedResponse of sharedResponses) { %>
-import type { I<%= sharedResponse.name %>Response, <%= sharedResponse.name %>Response } from "<%= sharedResponse.path %>";
+<% for (const shared of sharedResponses) { %>
+import type { I<%= shared.name %>Response, <%= shared.name %>Response } from "<%= shared.path %>";
+<% } %>
+<% for(const entityResponse of entityResponses) { %>
+import type { I<%= entityResponse.name %>Response, <%= entityResponse.name %>Response } from "<%= entityResponse.path %>";
 <% } %>
 
 <% for (const ownResponse of ownResponses) { %>
@@ -73,14 +76,20 @@ export type I<%= pascalCaseOperationId %>Response =
 <% for (const ownResponse of ownResponses) { %>
     | I<%= ownResponse.name %>Response
 <% } %>
-<% for (const sharedResponse of sharedResponses) { %>
-    | I<%= sharedResponse.name %>Response
+<% for (const shared of sharedResponses) { %>
+    | I<%= shared.name %>Response
+<% } %>
+<% for (const entityResponse of entityResponses) { %>
+    | I<%= entityResponse.name %>Response
 <% } %>;
 
 export type <%= pascalCaseOperationId %>Response =
 <% for (const ownResponse of ownResponses) { %>
     | <%= ownResponse.name %>Response
 <% } %>
-<% for (const sharedResponse of sharedResponses) { %>
-    | <%= sharedResponse.name %>Response
+<% for (const shared of sharedResponses) { %>
+    | <%= shared.name %>Response
+<% } %>
+<% for (const entityResponse of entityResponses) { %>
+    | <%= entityResponse.name %>Response
 <% } %>;

package/dist/templates/ResponseValidator.ejs

@@ -7,8 +7,7 @@
  */
 
 import definition from "<%= sourcePath %>";
-import type { ZodSafeParseResult } from "zod";
-import { 
+import {
     type IHttpResponse,
     type SafeResponseValidationResult,
     ResponseValidationError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexeus/typeweaver-types",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "Generates request and response types plus validators aligned with your API contract. Powered by Typeweaver 🧵✨",
   "type": "module",
   "sideEffects": false,
@@ -47,22 +47,23 @@
   },
   "homepage": "https://github.com/rexeus/typeweaver#readme",
   "peerDependencies": {
-    "@rexeus/typeweaver-core": "^0.6.4",
-    "@rexeus/typeweaver-gen": "^0.6.4"
+    "@rexeus/typeweaver-core": "^0.6.5",
+    "@rexeus/typeweaver-gen": "^0.6.5"
   },
   "devDependencies": {
+    "oxc-transform": "^0.115.0",
     "test-utils": "file:../test-utils",
-    "@rexeus/typeweaver-gen": "^0.6.4",
-    "@rexeus/typeweaver-core": "^0.6.4"
+    "@rexeus/typeweaver-core": "^0.6.5",
+    "@rexeus/typeweaver-gen": "^0.6.5"
   },
   "dependencies": {
     "case": "^1.6.3",
-    "@rexeus/typeweaver-zod-to-ts": "^0.6.4"
+    "@rexeus/typeweaver-zod-to-ts": "^0.6.5"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "format": "oxfmt",
-    "build": "tsdown && mkdir -p ./dist/templates ./dist/lib && cp -r ./src/templates/* ./dist/templates/ && cp -r ./src/lib/* ./dist/lib/ && cp ../../LICENSE ../../NOTICE ./dist/",
+    "build": "tsdown && mkdir -p ./dist/templates ./dist/lib && cp -r ./src/templates/* ./dist/templates/ && node scripts/compile-lib.mjs && cp src/lib-declarations/*.d.ts dist/lib/ && cp src/lib/index.ts dist/lib/ && cp ../../LICENSE ../../NOTICE ./dist/",
     "test": "vitest --run",
     "preversion": "npm run build"
   }

package/dist/lib/RequestValidator.ts

@@ -1,54 +0,0 @@
-/**
- * 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.
- *
- * This class provides the foundation for request validators that:
- * - Validate headers, body, query parameters, and path parameters
- * - Support both safe (non-throwing) and unsafe (throwing) validation
- * - Integrate with Zod schemas for runtime validation
- * - Provide detailed error information for debugging
- *
- * Implementations should validate all request components and either:
- * - Return validated data (for `validate`)
- * - Return success/error result (for `safeValidate`)
- */
-export abstract class RequestValidator
-  extends Validator
-  implements IRequestValidator
-{
-  public constructor() {
-    super();
-  }
-
-  /**
-   * Validates a request without throwing errors.
-   *
-   * @param request - The HTTP request to validate
-   * @returns A result object containing either the validated request or error details
-   */
-  public abstract safeValidate(
-    request: IHttpRequest
-  ): SafeRequestValidationResult<IHttpRequest>;
-
-  /**
-   * Validates a request and throws if validation fails.
-   *
-   * @param request - The HTTP request to validate
-   * @returns The validated request with proper typing
-   * @throws {RequestValidationError} If any part of the request fails validation
-   */
-  public abstract validate(request: IHttpRequest): IHttpRequest;
-}

package/dist/lib/ResponseValidator.ts

@@ -1,120 +0,0 @@
-/**
- * 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";
-
-/**
- * Abstract base class for HTTP response validation.
- *
- * This class provides the foundation for response validators that:
- * - Validate response status codes match expected values
- * - Validate response headers and body against schemas
- * - Support both safe (non-throwing) and unsafe (throwing) validation
- * - Integrate with Zod schemas for runtime validation
- *
- * Response validators are typically used in API clients to ensure
- * responses match the expected format before processing.
- */
-export abstract class ResponseValidator
-  extends Validator
-  implements IResponseValidator
-{
-  /**
-   * Validates a response without throwing errors.
-   *
-   * @param response - The HTTP response to validate
-   * @returns A result object containing either the validated response or error details
-   */
-  public abstract safeValidate(
-    response: IHttpResponse
-  ): SafeResponseValidationResult<IHttpResponse>;
-
-  /**
-   * Validates a response and throws if validation fails.
-   *
-   * @param response - The HTTP response to validate
-   * @returns The validated response with proper typing
-   * @throws {InvalidResponseStatusCodeError} If status code doesn't match expected
-   * @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,
-          this.getSchema(headerSchema)
-        );
-        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 };
-    };
-  }
-}