openapi-typesafe-fetch 1.0.0-rc.2 → 1.0.0-rc.4

package/dist/index.cjs

@@ -3,13 +3,15 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const PATH_PARAM_RE = /\{[^{}]+\}/g;
-const DOT_SEGMENT_RE = /(^|\/)\.\.?(\/|$)/;
+const DOT_SEGMENT_RE = /^\.\.?$/;
 const QUERY_OR_FRAGMENT_RE = /[?#]/;
-const JSON_MEDIA_TYPE_RE = /json/i;
+const JSON_MEDIA_TYPE_RE = /^[^/]+\/([^;]*\+)?json\s*(;|$)/i;
+const TEXT_MEDIA_TYPE_RE = /^text\//i;
 const FORM_MEDIA_TYPE_RE = /^application\/x-www-form-urlencoded(;|$)/i;
 const MULTIPART_MEDIA_TYPE_RE = /^multipart\/form-data(;|$)/i;
 const NESTED_FORM_VALUE_MESSAGE = "Nested form values need your own `bodySerializer()`.";
 const BOUNDARY_PARAMETER_RE = /;\s*boundary=/i;
+const CLIENT_BUILT_FORM = Symbol.for("openapi-typesafe-fetch/form");
 const supportsRequestInitExt = () => {
   return typeof process === "object" && process.versions?.undici;
 };
@@ -80,12 +82,14 @@ function createClient(clientOptions) {
       headers,
       params.header
     );
-    if (serializedBody instanceof FormData && !BOUNDARY_PARAMETER_RE.test(finalHeaders.get("Content-Type"))) {
-      finalHeaders.delete("Content-Type");
+    if (isPlatformInstance(serializedBody, "FormData")) {
+      dropFormContentType(finalHeaders, serializedBody[CLIENT_BUILT_FORM] === true);
     }
     const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
     const requestInit = {
       redirect: "follow",
+      // The Fetch standard requires `duplex: "half"` (its only value) for a stream body.
+      duplex: isStreamBody(serializedBody) ? "half" : void 0,
       ...baseOptions,
       ...init,
       body: serializedBody,
@@ -145,8 +149,8 @@ function createClient(clientOptions) {
     if (!response) {
       try {
         response = await fetch(request, requestInitExt);
-      } catch (error2) {
-        let errorAfterMiddleware = error2;
+      } catch (error) {
+        let errorAfterMiddleware = error;
         if (finalMiddlewares.length) {
           for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
             const m = finalMiddlewares[i];
@@ -178,6 +182,9 @@ function createClient(clientOptions) {
           throw errorAfterMiddleware;
         }
       }
+      if (!isResponse(response)) {
+        throw new Error("fetch: must return new Response()");
+      }
       if (finalMiddlewares.length) {
         for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
           const m = finalMiddlewares[i];
@@ -207,28 +214,9 @@ function createClient(clientOptions) {
       return response.ok ? { data: void 0, response } : { error: void 0, response };
     }
     if (response.ok) {
-      const getResponseData = async () => {
-        if (parseAs === "stream") {
-          return response.body;
-        }
-        if (parseAs === "json" && !contentLength) {
-          const raw2 = await response.text();
-          return raw2 ? JSON.parse(raw2) : void 0;
-        }
-        return await response[parseAs]();
-      };
-      return { data: await getResponseData(), response };
-    }
-    const raw = await response.text();
-    if (!raw) {
-      return { error: void 0, response };
-    }
-    let error = raw;
-    try {
-      error = JSON.parse(raw);
-    } catch {
+      return { data: await readSuccessBody(response, parseAs), response };
     }
-    return { error, response };
+    return { error: await readErrorBody(response), response };
   }
   return {
     request(method, url, init) {
@@ -352,6 +340,11 @@ function wrapAsPathBasedClient(coreClient) {
 function createPathBasedClient(clientOptions) {
   return wrapAsPathBasedClient(createClient(clientOptions));
 }
+function dropFormContentType(headers, isClientBuilt) {
+  if (isClientBuilt || !BOUNDARY_PARAMETER_RE.test(headers.get("Content-Type"))) {
+    headers.delete("Content-Type");
+  }
+}
 function isHeaders(value) {
   return typeof value?.get === "function";
 }
@@ -359,142 +352,183 @@ function isRequest(value) {
   return typeof value?.method === "string" && typeof value.url === "string" && isHeaders(value.headers);
 }
 function isResponse(value) {
-  return typeof value?.status === "number" && isHeaders(value.headers);
+  return typeof value?.ok === "boolean" && typeof value.status === "number" && typeof value.text === "function" && isHeaders(value.headers);
+}
+function parseJSON(raw, response) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    const contentType = response.headers.get("Content-Type");
+    const hint = TEXT_MEDIA_TYPE_RE.test(contentType) ? 'set `parseAs: "text"`' : "set `parseAs`";
+    const subject = `Response ${response.status} (${contentType ?? "no Content-Type"})`;
+    throw new SyntaxError(`${subject} is not JSON (${raw.length} characters); ${hint}`);
+  }
+}
+async function readSuccessBody(response, parseAs) {
+  if (parseAs === "stream") {
+    return response.body;
+  }
+  if (parseAs !== "json") {
+    return response[parseAs]();
+  }
+  const raw = await response.text();
+  return raw ? parseJSON(raw, response) : void 0;
+}
+async function readErrorBody(response) {
+  const raw = await response.text();
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
 }
 const KEPT_NAME_ESCAPES = /%(?:5B|5D|24|3A|40|2C)/g;
 function encodeName(name) {
   return encodeURIComponent(name).replace(KEPT_NAME_ESCAPES, decodeURIComponent);
 }
+function isDate(value) {
+  return typeof value?.toISOString === "function";
+}
+function valueText(value) {
+  return isDate(value) ? value.toISOString() : value;
+}
+function encodeValue(value, allowReserved) {
+  const text = valueText(value);
+  return allowReserved === true ? text : encodeURIComponent(text);
+}
 function serializePrimitiveParam(name, value, options) {
   if (value === void 0 || value === null) {
     return "";
   }
-  if (typeof value === "object") {
+  if (typeof value === "object" && !isDate(value)) {
     throw new Error(
       "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
     );
   }
-  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+  return `${name}=${encodeValue(value, options?.allowReserved)}`;
+}
+function joinExploded(values, style) {
+  const joiner = { simple: ",", label: ".", matrix: ";" }[style] || "&";
+  const final = values.join(joiner);
+  return style === "label" || style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeUnexplodedObject(name, value, options) {
+  const values = [];
+  for (const k in value) {
+    values.push(encodeValue(k), encodeValue(value[k], options.allowReserved));
+  }
+  const final = values.join(",");
+  switch (options.style) {
+    case "form": {
+      return `${name}=${final}`;
+    }
+    case "label": {
+      return `.${final}`;
+    }
+    case "matrix": {
+      return `;${name}=${final}`;
+    }
+    default: {
+      return final;
+    }
+  }
 }
 function serializeObjectParam(name, value, options) {
-  if (!value || typeof value !== "object") {
+  if (!value || typeof value !== "object" || !Object.keys(value).length) {
     return "";
   }
-  const values = [];
-  const joiner = {
-    simple: ",",
-    label: ".",
-    matrix: ";"
-  }[options.style] || "&";
   if (options.style !== "deepObject" && options.explode === false) {
-    for (const k in value) {
-      values.push(
-        encodeName(k),
-        options.allowReserved === true ? value[k] : encodeURIComponent(value[k])
-      );
-    }
-    const final2 = values.join(",");
-    switch (options.style) {
-      case "form": {
-        return `${name}=${final2}`;
-      }
-      case "label": {
-        return `.${final2}`;
-      }
-      case "matrix": {
-        return `;${name}=${final2}`;
-      }
-      default: {
-        return final2;
-      }
-    }
+    return serializeUnexplodedObject(name, value, options);
   }
+  const values = [];
   for (const k in value) {
-    const finalName = options.style === "deepObject" ? `${name}[${encodeName(k)}]` : encodeName(k);
-    values.push(serializePrimitiveParam(finalName, value[k], options));
+    const key = encodeValue(k);
+    const finalName = options.style === "deepObject" ? `${name}[${key}]` : key;
+    if (value[k] != null) {
+      values.push(serializePrimitiveParam(finalName, value[k], options));
+    }
+  }
+  return values.length ? joinExploded(values, options.style) : "";
+}
+function serializeUnexplodedArray(name, value, options) {
+  const joiner = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+  const final = value.map((v) => encodeValue(v, options.allowReserved)).join(joiner);
+  switch (options.style) {
+    case "simple": {
+      return final;
+    }
+    case "label": {
+      return `.${final}`;
+    }
+    case "matrix": {
+      return `;${name}=${final}`;
+    }
+    default: {
+      return `${name}=${final}`;
+    }
   }
-  const final = values.join(joiner);
-  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
 }
 function serializeArrayParam(name, value, options) {
-  if (!Array.isArray(value)) {
+  if (!Array.isArray(value) || !value.length) {
     return "";
   }
   if (options.explode === false) {
-    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
-    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
-    switch (options.style) {
-      case "simple": {
-        return final;
-      }
-      case "label": {
-        return `.${final}`;
-      }
-      case "matrix": {
-        return `;${name}=${final}`;
-      }
-      // case "spaceDelimited":
-      // case "pipeDelimited":
-      default: {
-        return `${name}=${final}`;
-      }
-    }
+    return serializeUnexplodedArray(name, value, options);
   }
-  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
   const values = [];
   for (const v of value) {
     if (options.style === "simple" || options.style === "label") {
-      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
-    } else {
+      values.push(encodeValue(v, options.allowReserved));
+    } else if (v != null) {
       values.push(serializePrimitiveParam(name, v, options));
     }
   }
-  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+  return values.length ? joinExploded(values, options.style) : "";
+}
+function serializeQueryParam(name, value, options) {
+  const allowReserved = options?.allowReserved || false;
+  if (Array.isArray(value)) {
+    return serializeArrayParam(name, value, {
+      style: "form",
+      explode: true,
+      ...options?.array,
+      allowReserved
+    });
+  }
+  if (value && typeof value === "object" && !isDate(value)) {
+    return serializeObjectParam(name, value, {
+      style: "deepObject",
+      explode: true,
+      ...options?.object,
+      allowReserved
+    });
+  }
+  return serializePrimitiveParam(name, value, options);
 }
 function createQuerySerializer(options) {
   return function querySerializer(queryParams) {
     const search = [];
     if (queryParams && typeof queryParams === "object") {
       for (const key in queryParams) {
-        const value = queryParams[key];
-        const name = encodeName(key);
-        if (value === void 0 || value === null) {
-          continue;
-        }
-        if (Array.isArray(value)) {
-          if (value.length === 0) {
-            continue;
-          }
-          search.push(
-            serializeArrayParam(name, value, {
-              style: "form",
-              explode: true,
-              ...options?.array,
-              allowReserved: options?.allowReserved || false
-            })
-          );
-          continue;
-        }
-        if (typeof value === "object") {
-          search.push(
-            serializeObjectParam(name, value, {
-              style: "deepObject",
-              explode: true,
-              ...options?.object,
-              allowReserved: options?.allowReserved || false
-            })
-          );
-          continue;
+        const part = serializeQueryParam(encodeName(key), queryParams[key], options);
+        if (part) {
+          search.push(part);
         }
-        search.push(serializePrimitiveParam(name, value, options));
       }
     }
     return search.join("&");
   };
 }
 function defaultPathSerializer(pathname, pathParams) {
+  const matches = pathname.match(PATH_PARAM_RE);
+  if (!matches) {
+    return pathname;
+  }
   let nextURL = pathname;
-  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+  for (const match of matches) {
     let name = match.substring(1, match.length - 1);
     let explode = false;
     let style = "simple";
@@ -516,26 +550,49 @@ function defaultPathSerializer(pathname, pathParams) {
     let serialized;
     if (Array.isArray(value)) {
       serialized = serializeArrayParam(name, value, { style, explode });
-    } else if (typeof value === "object") {
+    } else if (typeof value === "object" && !isDate(value)) {
       serialized = serializeObjectParam(name, value, { style, explode });
     } else if (style === "matrix") {
       serialized = `;${serializePrimitiveParam(name, value)}`;
     } else {
-      serialized = style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value);
+      serialized = style === "label" ? `.${encodeValue(value)}` : encodeValue(value);
     }
     nextURL = nextURL.replace(match, () => serialized);
   }
-  const path = nextURL.split(QUERY_OR_FRAGMENT_RE, 1)[0];
-  if (DOT_SEGMENT_RE.test(path)) {
-    throw new Error(`Dot path segment in ${nextURL}`);
+  checkSerializedPath(pathname, nextURL);
+  return nextURL;
+}
+function checkSerializedPath(template, url) {
+  const fixed = template.slice(0, template.search(PATH_PARAM_RE));
+  const path = url.split(QUERY_OR_FRAGMENT_RE, 1)[0];
+  const first = fixed.split("/").length - 1;
+  let index = path.split("/").findIndex((segment, at) => at >= first && DOT_SEGMENT_RE.test(segment));
+  let problem = "Dot";
+  if (index === -1 && path.startsWith("//") && !fixed.startsWith("//")) {
+    [index, problem] = [1, "Empty first"];
   }
-  if (path.startsWith("//")) {
-    throw new Error(`Empty first path segment in ${nextURL}`);
+  if (index !== -1) {
+    const name = template.split(QUERY_OR_FRAGMENT_RE, 1)[0].split("/")[index];
+    throw new Error(`${problem} path segment in "${name}"`);
   }
-  return nextURL;
+}
+function isPlatformInstance(value, name) {
+  const type = globalThis[name];
+  return typeof type === "function" && value instanceof type;
+}
+function isStreamBody(body) {
+  return isPlatformInstance(body, "ReadableStream") || typeof body?.[Symbol.asyncIterator] === "function";
 }
 function isRawBody(body) {
-  return body instanceof FormData || body instanceof Blob || body instanceof URLSearchParams || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+  return ["FormData", "Blob", "URLSearchParams", "ArrayBuffer"].some(
+    (name) => isPlatformInstance(body, name)
+  ) || ArrayBuffer.isView(body) || isStreamBody(body);
+}
+function isNestedFormValue(value) {
+  return value && typeof value === "object" && !isDate(value);
+}
+function formItems(value) {
+  return Array.isArray(value) ? Array.from(value) : [value];
 }
 function formBody(body) {
   if (!body || typeof body !== "object" || Array.isArray(body)) {
@@ -543,25 +600,27 @@ function formBody(body) {
   }
   const form = new URLSearchParams();
   for (const [name, value] of Object.entries(body)) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
+    const items = formItems(value);
+    if (items.some(isNestedFormValue)) {
       throw new Error(NESTED_FORM_VALUE_MESSAGE);
     }
     if (value != null) {
-      form.append(name, value);
+      form.append(name, items.map(valueText).join(","));
     }
   }
   return form.toString();
 }
 function multipartBody(body) {
   const formData = new FormData();
+  formData[CLIENT_BUILT_FORM] = true;
   for (const [name, value] of Object.entries(body)) {
-    for (const item of [value].flat()) {
-      if (item instanceof Blob) {
+    for (const item of formItems(value)) {
+      if (isPlatformInstance(item, "Blob")) {
         formData.append(name, item);
-      } else if (item && typeof item === "object") {
+      } else if (isNestedFormValue(item)) {
         throw new Error(NESTED_FORM_VALUE_MESSAGE);
       } else if (item != null) {
-        formData.append(name, String(item));
+        formData.append(name, String(valueText(item)));
       }
     }
   }