typespec-http-zod 0.3.0 → 0.4.0

package/README.md

@@ -146,6 +146,8 @@ carries the whole id, so `op readWidget` in `namespace Widgets` becomes `Widgets
 - [Guides](docs/guides.md): installing, validating a request, answering with the right body, content
   types, and building an emitter on the API.
 - [Reference](docs/reference.md): every option, every diagnostic, and the known limits.
+- [Oracles](docs/oracles.md): every artefact this emitter produces, and what compares it to the
+  thing it has to agree with.
 
 ## Licence
 

package/dist/src/api.js

@@ -517,6 +517,20 @@ const COLLECTION_DELIMITERS = {
 function isCollectionParameter(property) {
     return isArrayType(property.type);
 }
+/**
+ * Whether the values arrive one per OCCURRENCE (RFC 6570 explode) rather than joined into one.
+ *
+ * The distinction matters because of what `zValidator` hands the schema: for a repeated key it
+ * builds an array, but for a single occurrence it hands the bare string - and one `key=value` pair
+ * is exactly what a one-member exploded array looks like on the wire. A bare `z.array()` therefore
+ * refused a conformant request while accepting the same list sent twice, which no document
+ * describes. Found by the first consumer's `?topics=ip` (#1).
+ */
+function isExplodedCollection(parameter) {
+    return (isCollectionParameter(parameter.param) &&
+        (parameter.type === "query" || parameter.type === "header") &&
+        parameter.explode === true);
+}
 /**
  * The delimiter a parameter's values were joined with, or `undefined` when they were not joined.
  *
@@ -675,9 +689,18 @@ function parameterSchemasOf(program, operation, registry) {
         const decoded = parameter.type === "header" && parameter.name.toLowerCase() === "content-type"
             ? mediaTypeDecoded(declared)
             : wireDecoded(declared);
-        const expression = delimiter === undefined
-            ? decoded
-            : `z.preprocess((raw) => (typeof raw === "string" ? raw.split(${JSON.stringify(delimiter)}) : raw), ${decoded})`;
+        /**
+         * The boxing half of the same principle: an exploded array's single occurrence arrives as a
+         * bare string, so it is boxed into the one-element array the document describes before the
+         * schema runs - every constraint on the list still applies to the result. Several
+         * occurrences arrive already an array and pass through untouched, exactly as the delimiter
+         * arm leaves a pre-split value alone.
+         */
+        const expression = isExplodedCollection(parameter)
+            ? `z.preprocess((raw) => (typeof raw === "string" ? [raw] : raw), ${decoded})`
+            : delimiter === undefined
+                ? decoded
+                : `z.preprocess((raw) => (typeof raw === "string" ? raw.split(${JSON.stringify(delimiter)}) : raw), ${decoded})`;
         const entry = `\t${objectKey(parameter.name)}: ${expression},`;
         (byTarget[parameter.type] ??= []).push(entry);
         /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-http-zod",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "TypeSpec emitter and library: turn an HTTP service definition into Zod validators and framework-free contract types that agree, keyword for keyword, with the OpenAPI document @typespec/openapi3 publishes from the same source.",
   "keywords": [
     "codegen",