hanzio 1.2.0 → 2.0.0

package/src/zod/zodToTypeString.ts

@@ -1,222 +1,225 @@
 import type { z } from 'zod'
+import { isRecord } from '../guard'
 
-// Helper to safely get a property from an unknown def object
-function getDefProp<T>(def: unknown, prop: string): T | undefined {
-	return (def as Record<string, unknown>)?.[prop] as T | undefined
+export type Schema = z.core.$ZodType
+export type Def = z.core.$ZodTypes['_zod']['def']
+
+// Schemas on the current render path, so recursive (lazy/getter) schemas terminate
+const visiting = new Set<Schema>()
+
+export function walk<T>(schema: Schema, onCycle: T, fn: (def: Def) => T): T {
+	if (visiting.has(schema)) return onCycle
+	visiting.add(schema)
+	try {
+		return fn(defOf(schema))
+	} finally {
+		visiting.delete(schema)
+	}
+}
+
+export function defOf(schema: Schema): Def {
+	return (schema as z.core.$ZodTypes)._zod.def
+}
+
+// Pipes are described by their output, except transforms, whose output can't be inspected
+function pipeTarget(def: z.core.$ZodPipeDef): Schema {
+	return defOf(def.out).type === 'transform' ? def.in : def.out
+}
+
+function literal(value: unknown): string {
+	if (typeof value === 'string') return JSON.stringify(value)
+	return typeof value === 'bigint' ? `${value}n` : String(value)
+}
+
+// Parenthesize unions/intersections where they'd otherwise bind wrongly (e.g. `(a | b)[]`)
+function wrap(type: string): string {
+	return /[|&]/.test(type) ? `(${type})` : type
 }
 
 /**
  * Convert a Zod schema to a human-readable TypeScript-like interface string
  */
-export function zodToTypeString(schema: z.ZodType, indent = 0): string {
-	const pad = '  '.repeat(indent)
-	const innerPad = '  '.repeat(indent + 1)
-
-	// Get the schema definition - try both Zod 4 and Zod 3 patterns
-	const def =
-		(schema as unknown as { _zod?: { def: unknown } })._zod?.def ??
-		(schema as unknown as { _def: unknown })._def
-
-	if (!def) return 'unknown'
-
-	// Zod 4 uses 'type' property with lowercase values (e.g., 'object', 'string')
-	// Zod 3 uses 'typeName' with 'Zod' prefix (e.g., 'ZodObject', 'ZodString')
-	const schemaType =
-		getDefProp<string>(def, 'type') ?? getDefProp<string>(def, 'typeName')
-
-	switch (schemaType) {
-		// Zod 4 lowercase types
-		case 'object': {
-			const shape = getDefProp<Record<string, z.ZodType>>(def, 'shape')
-			if (!shape || Object.keys(shape).length === 0) return '{}'
-
-			const fields = Object.entries(shape).map(([key, value]) => {
-				// Zod 4: check value.type === 'optional', Zod 3: check _def.typeName
-				const valueType = getDefProp<string>(
-					(value as unknown as { _zod?: { def: unknown } })._zod?.def ??
-						(value as unknown as { _def?: unknown })._def,
-					'type'
-				)
-				const isOptional = valueType === 'optional'
-				const innerSchema = isOptional
-					? (getDefProp<z.ZodType>(
-							(value as unknown as { _zod?: { def: unknown } })._zod?.def ??
-								(value as unknown as { _def?: unknown })._def,
-							'innerType'
-						) ?? value)
-					: value
-				const typeStr = zodToTypeString(innerSchema, indent + 1)
-				return `${innerPad}${key}${isOptional ? '?' : ''}: ${typeStr}`
-			})
-
-			return `{\n${fields.join('\n')}\n${pad}}`
-		}
+export function zodToTypeString(schema: Schema, indent = 0): string {
+	return walk(schema, 'unknown', (def) => {
+		const pad = '  '.repeat(indent)
+		const innerPad = '  '.repeat(indent + 1)
+		const render = (inner: Schema) => zodToTypeString(inner, indent)
+
+		switch (def.type) {
+			case 'object': {
+				const entries = Object.entries(def.shape)
+				if (entries.length === 0) return '{}'
+
+				const fields = entries.map(([key, value]) => {
+					const valueDef = defOf(value)
+					const isOptional = valueDef.type === 'optional'
+					const typeStr = zodToTypeString(
+						isOptional ? valueDef.innerType : value,
+						indent + 1
+					)
+					return `${innerPad}${key}${isOptional ? '?' : ''}: ${typeStr}`
+				})
+
+				return `{\n${fields.join('\n')}\n${pad}}`
+			}
 
-		case 'array': {
-			// Zod 4 uses 'element', Zod 3 uses 'type'
-			const itemType =
-				getDefProp<z.ZodType>(def, 'element') ??
-				getDefProp<z.ZodType>(def, 'type')
-			return itemType ? `${zodToTypeString(itemType, indent)}[]` : 'unknown[]'
-		}
+			case 'array':
+				return `${wrap(render(def.element))}[]`
 
-		case 'string':
-			return 'string'
+			case 'tuple': {
+				const items = def.items.map(render)
+				if (def.rest) items.push(`...${wrap(render(def.rest))}[]`)
+				return `[${items.join(', ')}]`
+			}
 
-		case 'number':
-			return 'number'
+			case 'string':
+			case 'number':
+			case 'bigint':
+			case 'boolean':
+			case 'symbol':
+			case 'null':
+			case 'undefined':
+			case 'void':
+			case 'never':
+			case 'any':
+			case 'unknown':
+				return def.type
 
-		case 'boolean':
-			return 'boolean'
+			case 'date':
+				return 'Date'
 
-		case 'date':
-			return 'Date'
+			case 'record':
+				return `Record<${render(def.keyType)}, ${render(def.valueType)}>`
 
-		case 'null':
-			return 'null'
+			case 'map':
+				return `Map<${render(def.keyType)}, ${render(def.valueType)}>`
 
-		case 'undefined':
-			return 'undefined'
+			case 'set':
+				return `Set<${render(def.valueType)}>`
 
-		case 'any':
-			return 'any'
+			case 'promise':
+				return `Promise<${render(def.innerType)}>`
 
-		case 'unknown':
-			return 'unknown'
+			case 'enum':
+				return Object.values(def.entries).map(literal).join(' | ')
 
-		case 'record': {
-			const valueType = getDefProp<z.ZodType>(def, 'valueType')
-			return valueType
-				? `Record<string, ${zodToTypeString(valueType, indent)}>`
-				: 'Record<string, unknown>'
-		}
+			case 'literal':
+				return def.values.map(literal).join(' | ')
 
-		case 'enum': {
-			const values = getDefProp<string[]>(def, 'values')
-			return values ? values.map((v) => `"${v}"`).join(' | ') : 'string'
-		}
+			case 'union':
+				return def.options.map(render).join(' | ')
 
-		case 'literal': {
-			const value = getDefProp<unknown>(def, 'value')
-			return typeof value === 'string' ? `"${value}"` : String(value)
-		}
+			case 'intersection':
+				return `${wrap(render(def.left))} & ${wrap(render(def.right))}`
 
-		case 'union': {
-			const options = getDefProp<z.ZodType[]>(def, 'options')
-			return options
-				? options.map((o) => zodToTypeString(o, indent)).join(' | ')
-				: 'unknown'
-		}
+			case 'optional':
+				return `${render(def.innerType)} | undefined`
 
-		case 'optional': {
-			const inner = getDefProp<z.ZodType>(def, 'innerType')
-			return inner ? `${zodToTypeString(inner, indent)} | undefined` : 'unknown'
-		}
+			case 'nullable':
+				return `${render(def.innerType)} | null`
 
-		case 'nullable': {
-			const inner = getDefProp<z.ZodType>(def, 'innerType')
-			return inner ? `${zodToTypeString(inner, indent)} | null` : 'unknown'
-		}
+			case 'nonoptional': {
+				const innerDef = defOf(def.innerType)
+				return render(
+					innerDef.type === 'optional' ? innerDef.innerType : def.innerType
+				)
+			}
 
-		case 'default': {
-			const inner = getDefProp<z.ZodType>(def, 'innerType')
-			return inner ? zodToTypeString(inner, indent) : 'unknown'
-		}
+			case 'default':
+			case 'prefault':
+			case 'catch':
+			case 'readonly':
+				return render(def.innerType)
 
-		// Zod 3 compatibility (with 'Zod' prefix)
-		case 'ZodObject':
-		case 'ZodArray':
-		case 'ZodString':
-		case 'ZodNumber':
-		case 'ZodBoolean':
-		case 'ZodDate':
-		case 'ZodNull':
-		case 'ZodUndefined':
-		case 'ZodAny':
-		case 'ZodUnknown':
-		case 'ZodRecord':
-		case 'ZodEnum':
-		case 'ZodLiteral':
-		case 'ZodUnion':
-		case 'ZodOptional':
-		case 'ZodNullable':
-		case 'ZodDefault':
-			// For Zod 3, recurse with the lowercase version
-			return zodToTypeString(schema, indent)
-
-		default:
-			return 'unknown'
-	}
+			case 'lazy':
+				return render(def.getter())
+
+			case 'pipe':
+				return render(pipeTarget(def))
+
+			default:
+				return 'unknown'
+		}
+	})
 }
 
 /**
- * Generate example JSON from a Zod schema
+ * Generate example JSON from a Zod schema. Values are JSON-safe: dates become ISO
+ * strings, bigints numbers, sets arrays and maps/records empty objects.
  */
-export function zodToExample(schema: z.ZodType): unknown {
-	const def =
-		(schema as unknown as { _zod?: { def: unknown } })._zod?.def ??
-		(schema as unknown as { _def: unknown })._def
-	if (!def) return null
-
-	// Zod 4 uses 'type', Zod 3 uses 'typeName'
-	const schemaType =
-		getDefProp<string>(def, 'type') ?? getDefProp<string>(def, 'typeName')
-
-	switch (schemaType) {
-		case 'object': {
-			const shape = getDefProp<Record<string, z.ZodType>>(def, 'shape')
-			if (!shape) return {}
-			const result: Record<string, unknown> = {}
-			for (const [key, value] of Object.entries(shape)) {
-				const valueType = getDefProp<string>(
-					(value as unknown as { _zod?: { def: unknown } })._zod?.def ??
-						(value as unknown as { _def?: unknown })._def,
-					'type'
-				)
-				const isOptional = valueType === 'optional'
-				if (!isOptional) {
-					result[key] = zodToExample(value)
+export function zodToExample(schema: Schema): unknown {
+	return walk(schema, null, (def): unknown => {
+		switch (def.type) {
+			case 'object': {
+				const result: Record<string, unknown> = {}
+				for (const [key, value] of Object.entries(def.shape)) {
+					if (defOf(value).type !== 'optional') {
+						result[key] = zodToExample(value)
+					}
 				}
+				return result
 			}
-			return result
-		}
 
-		case 'array': {
-			// Zod 4 uses 'element', Zod 3 uses 'type'
-			const itemType =
-				getDefProp<z.ZodType>(def, 'element') ??
-				getDefProp<z.ZodType>(def, 'type')
 			// Always return array with one item for better example
-			return itemType ? [zodToExample(itemType)] : []
-		}
+			case 'array':
+				return [zodToExample(def.element)]
 
-		case 'string':
-			return ''
+			case 'set':
+				return [zodToExample(def.valueType)]
 
-		case 'number':
-			return 0
+			case 'tuple':
+				return def.items.map(zodToExample)
 
-		case 'boolean':
-			return false
+			case 'string':
+				return ''
 
-		case 'enum': {
-			const values = getDefProp<string[]>(def, 'values')
-			return values?.[0] ?? ''
-		}
+			case 'number':
+			case 'bigint':
+				return 0
 
-		case 'literal':
-			return getDefProp<unknown>(def, 'value')
+			case 'boolean':
+				return false
 
-		case 'optional':
-		case 'default': {
-			const inner = getDefProp<z.ZodType>(def, 'innerType')
-			return inner ? zodToExample(inner) : null
-		}
+			case 'date':
+				return new Date(0).toISOString()
 
-		case 'record':
-			return {}
+			case 'enum':
+				return Object.values(def.entries)[0]
 
-		default:
-			return null
-	}
+			case 'literal':
+				return def.values[0]
+
+			case 'union':
+				return zodToExample(def.options[0] as Schema)
+
+			case 'intersection': {
+				const left = zodToExample(def.left)
+				const right = zodToExample(def.right)
+				return isRecord(left) && isRecord(right) ? { ...left, ...right } : left
+			}
+
+			case 'optional':
+			case 'nullable':
+			case 'nonoptional':
+			case 'default':
+			case 'prefault':
+			case 'catch':
+			case 'readonly':
+			case 'promise':
+				return zodToExample(def.innerType)
+
+			case 'lazy':
+				return zodToExample(def.getter())
+
+			case 'pipe':
+				return zodToExample(pipeTarget(def))
+
+			case 'record':
+			case 'map':
+				return {}
+
+			default:
+				return null
+		}
+	})
 }

package/dist/api-wrapper/index.js

@@ -1,250 +0,0 @@
-// src/api-wrapper/index.ts
-import { ZodError } from "zod";
-
-class ResponseValidationError extends Error {
-  zodError;
-  rawResponse;
-  validationIssues;
-  constructor(zodError, rawResponse) {
-    const issues = zodError.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
-    super(`Response validation failed: ${issues}`);
-    this.name = "ResponseValidationError";
-    this.zodError = zodError;
-    this.rawResponse = rawResponse;
-    this.validationIssues = issues;
-  }
-}
-
-class HttpResponseError extends Error {
-  status;
-  body;
-  constructor(status, body) {
-    super(`HTTP error: ${status} - ${body}`);
-    this.name = "HttpResponseError";
-    this.status = status;
-    this.body = body;
-  }
-}
-function createApiClient(apiConfig) {
-  const request = async (endpointKey, input = {}) => {
-    const endpoint = apiConfig.endpoints[endpointKey];
-    if (!endpoint) {
-      throw new Error(`Unknown API endpoint: ${String(endpointKey)}`);
-    }
-    const { finalUrl, fullUrl } = buildUrl(endpoint, input.reqParams, input.reqQuery, apiConfig.baseApiUrls, apiConfig.defaultBaseApiUrl, input.url);
-    const endpointName = apiConfig.name ? `${apiConfig.name}.${String(endpointKey)}` : String(endpointKey);
-    const startedAt = Date.now();
-    let retryCount = 0;
-    let httpStatus = 0;
-    apiConfig.onRequestStart?.({ endpoint: endpointName, url: fullUrl });
-    try {
-      const config = {
-        method: endpoint.method,
-        url: finalUrl,
-        queryParams: buildQueryParams(endpoint, input.reqQuery),
-        body: buildRequestBody(endpoint, input.reqBody),
-        headers: buildHeaders(endpoint, input.reqHeaders, apiConfig.defaultHeaders ?? {}),
-        doNotEncodeQueryParams: endpoint.doNotEncodeQueryParams,
-        timeoutMs: apiConfig.timeoutMs,
-        fetchFn: apiConfig.fetch ?? fetch
-      };
-      const result = await makeRequestWithRetry(config, apiConfig.retries ?? 3, apiConfig.retryDelayMs ?? 300, (response) => validateAndTransformResponse(endpoint, response), apiConfig.shouldRetry ?? defaultShouldRetry, apiConfig.logger);
-      retryCount = result.retryCount;
-      httpStatus = result.httpStatus;
-      const responseTimeMs = Date.now() - startedAt;
-      const responseSizeMb = calculateSizeInMb(result.validatedData);
-      const requestSizeMb = calculateSizeInMb({
-        method: config.method,
-        url: fullUrl,
-        body: config.body,
-        headers: config.headers
-      });
-      apiConfig.onRequestEnd?.({
-        endpoint: endpointName,
-        url: fullUrl,
-        status: httpStatus,
-        retryCount,
-        responseTimeMs
-      });
-      return {
-        data: result.validatedData,
-        requestSizeMb,
-        responseSizeMb,
-        requestSizeTotalMb: requestSizeMb + responseSizeMb,
-        responseTimeMs,
-        httpStatus,
-        retryCount
-      };
-    } catch (error) {
-      apiConfig.logger?.error?.(error);
-      throw error;
-    }
-  };
-  return { request };
-}
-var createApiWrapper = createApiClient;
-async function validateResponse(schema, data) {
-  try {
-    return await schema.parseAsync(data);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw new ResponseValidationError(error, data);
-    }
-    throw error;
-  }
-}
-async function httpRequest(config) {
-  const queryString = config.doNotEncodeQueryParams ? Object.entries(config.queryParams).map(([key, value]) => `${key}=${value}`).join("&") : new URLSearchParams(config.queryParams).toString();
-  const fullUrl = queryString ? `${config.url}?${queryString}` : config.url;
-  const abortController = new AbortController;
-  const timeout = config.timeoutMs === undefined ? undefined : setTimeout(() => abortController.abort(), config.timeoutMs);
-  try {
-    return await config.fetchFn(fullUrl, {
-      method: config.method,
-      headers: config.headers,
-      body: buildFetchBody(config.body, config.headers),
-      signal: abortController.signal
-    });
-  } finally {
-    if (timeout)
-      clearTimeout(timeout);
-  }
-}
-async function makeRequestWithRetry(config, maxRetries, retryDelayMs, validateFn, shouldRetry, logger) {
-  let retryCount = 0;
-  while (true) {
-    try {
-      logger?.debug?.("API request", config);
-      const response = await httpRequest(config);
-      if (response.status >= 400) {
-        if (retryCount < maxRetries && shouldRetry({ response, retryCount, maxRetries })) {
-          retryCount++;
-          await delay(retryDelayMs);
-          continue;
-        }
-        throw new HttpResponseError(response.status, await response.text());
-      }
-      return {
-        validatedData: await validateFn(response),
-        retryCount,
-        httpStatus: response.status
-      };
-    } catch (error) {
-      if (error instanceof HttpResponseError)
-        throw error;
-      if (retryCount >= maxRetries || !shouldRetry({ error, retryCount, maxRetries })) {
-        throw error;
-      }
-      retryCount++;
-      await delay(retryDelayMs);
-    }
-  }
-}
-async function validateAndTransformResponse(endpoint, response) {
-  const responseHeaders = getHeadersAsObject(response.headers);
-  const contentType = responseHeaders["content-type"] ?? "";
-  const responseData = contentType.includes("application/json") ? await response.json() : await response.text();
-  const transformedData = endpoint.resFormatter ? endpoint.resFormatter(responseData, responseHeaders) : responseData;
-  return validateResponse(endpoint.resSchema, transformedData);
-}
-function buildUrl(endpoint, params, reqQuery, baseApiUrls, defaultBaseApiUrl, url) {
-  if (url) {
-    const finalUrl2 = replacePathParams(url, params);
-    const queryString2 = new URLSearchParams(buildQueryParams(endpoint, reqQuery)).toString();
-    return {
-      finalUrl: finalUrl2,
-      fullUrl: queryString2 ? `${finalUrl2}?${queryString2}` : finalUrl2
-    };
-  }
-  const defaultBaseUrl = defaultBaseApiUrl ?? Object.keys(baseApiUrls)[0];
-  if (!defaultBaseUrl) {
-    throw new Error("At least one base API URL is required");
-  }
-  const baseUrlKey = endpoint.baseApiUrl ?? defaultBaseUrl;
-  const configBaseUrl = baseApiUrls[baseUrlKey];
-  if (!configBaseUrl) {
-    throw new Error(`Unknown base API URL: ${baseUrlKey}`);
-  }
-  const baseUrl = typeof configBaseUrl === "function" ? configBaseUrl() : configBaseUrl;
-  const path = typeof endpoint.path === "function" ? endpoint.path(baseUrl) : endpoint.path;
-  const finalUrl = replacePathParams(`${baseUrl}${path}`, params);
-  const queryString = new URLSearchParams(buildQueryParams(endpoint, reqQuery)).toString();
-  return {
-    finalUrl,
-    fullUrl: queryString ? `${finalUrl}?${queryString}` : finalUrl
-  };
-}
-function buildQueryParams(endpoint, query) {
-  const defaultParams = endpoint.reqDefaultQueryParams ?? {};
-  const parsedQuery = endpoint.reqQuerySchema ? endpoint.reqQuerySchema.parse(query) : query ?? {};
-  const merged = { ...defaultParams, ...parsedQuery };
-  return Object.fromEntries(Object.entries(merged).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)]));
-}
-function buildRequestBody(endpoint, body) {
-  if (!endpoint.reqBodySchema)
-    return body;
-  const parsedBody = endpoint.reqBodySchema.parse(body);
-  if (endpoint.reqBodyFormat !== "form-data") {
-    return parsedBody;
-  }
-  const formData = new FormData;
-  for (const [key, value] of Object.entries(parsedBody)) {
-    if (value == null)
-      continue;
-    formData.set(key, value instanceof Blob ? value : String(value));
-  }
-  return formData;
-}
-function buildHeaders(endpoint, headers, defaultHeaders) {
-  const contentType = endpoint.reqBodyFormat === "json" ? "application/json" : undefined;
-  const parsedHeaders = endpoint.reqHeadersSchema ? endpoint.reqHeadersSchema.parse(headers) : headers ?? {};
-  return {
-    ...defaultHeaders,
-    ...contentType && { "Content-Type": contentType },
-    ...endpoint.defaultHeaders,
-    ...parsedHeaders
-  };
-}
-function buildFetchBody(body, headers) {
-  if (body === undefined || body === null)
-    return;
-  if (body instanceof FormData || body instanceof Blob)
-    return body;
-  if (headers["Content-Type"] === "application/json")
-    return JSON.stringify(body);
-  return body;
-}
-function replacePathParams(path, params) {
-  return path.replace(/:(\w+)/g, (_, key) => {
-    const value = params?.[key];
-    if (value === undefined) {
-      throw new Error(`Missing required path parameter: ${key}`);
-    }
-    return encodeURIComponent(String(value));
-  });
-}
-function getHeadersAsObject(headers) {
-  const result = {};
-  headers.forEach((value, key) => {
-    result[key] = value;
-  });
-  return result;
-}
-function calculateSizeInMb(data) {
-  const sizeInBytes = new TextEncoder().encode(JSON.stringify(data)).length;
-  return sizeInBytes / (1024 * 1024);
-}
-function defaultShouldRetry({ error, response }) {
-  if (error)
-    return true;
-  return response ? response.status >= 500 : false;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export {
-  createApiWrapper,
-  createApiClient,
-  ResponseValidationError,
-  HttpResponseError
-};

package/dist/gzip/index.d.ts

@@ -1,2 +0,0 @@
-export declare function compressString(input: string): string;
-export declare function decompressString(compressedString: string): string;

package/dist/gzip/index.js

@@ -1,16 +0,0 @@
-// src/gzip/index.ts
-import pako from "pako";
-function compressString(input) {
-  const uint8Array = new TextEncoder().encode(input);
-  const compressed = pako.deflate(uint8Array);
-  return btoa(String.fromCharCode.apply(null, compressed));
-}
-function decompressString(compressedString) {
-  const compressedData = new Uint8Array(atob(compressedString).split("").map((char) => char.charCodeAt(0)));
-  const decompressed = pako.inflate(compressedData);
-  return new TextDecoder().decode(decompressed);
-}
-export {
-  decompressString,
-  compressString
-};