@ps-aux/api-client-axios 0.7.0-rc.1 → 0.7.0-rc.3

package/README.md

@@ -3,6 +3,7 @@
 Axios-based HTTP client for OpenAPI-generated APIs with Node and browser builds.
 
 ## Installation
+
 ```bash
 npm install @ps-aux/api-client-axios axios
 ```
@@ -13,34 +14,37 @@ npm install @ps-aux/api-client-axios axios
 import axios from 'axios'
 import { createHttpClient } from '@ps-aux/api-client-axios'
 
-const http = createHttpClient(axios.create({ baseURL: 'https://api.example.com' }), {
-  querySerializer: null
-})
+const http = createHttpClient(
+    axios.create({ baseURL: 'https://api.example.com' }),
+    {
+        querySerializer: null
+    }
+)
 
 const users = await http.request({
-  path: '/users',
-  method: 'GET'
+    path: '/users',
+    method: 'GET'
 })
 ```
 
 ## Custom query serialization
 
 Use the `QuerySerializer` type to control how query params are serialized. Pass a serializer into
-`createHttpClient` and return a serialized `queryString`.
+`createHttpClient`; the serializer returns a serialized query string.
 
 ```ts
 import axios from 'axios'
 import {
-  createHttpClient,
-  type QuerySerializer
+    createHttpClient,
+    type QuerySerializer
 } from '@ps-aux/api-client-axios'
 import { qsQuerySerializer } from '@ps-aux/api-client-query-serializer-qs'
 
 const querySerializer: QuerySerializer = qsQuerySerializer()
 
 const http = createHttpClient(
-  axios.create({ baseURL: 'https://api.example.com' }),
-  { querySerializer }
+    axios.create({ baseURL: 'https://api.example.com' }),
+    { querySerializer }
 )
 ```
 
@@ -49,7 +53,9 @@ Query serializers live in their own packages (for example
 the one that matches your backend conventions.
 
 ## Notes
+
 - Bundlers will pick the browser build via the package browser field.
 
 ## License
+
 MIT

package/dist/browser.cjs

@@ -0,0 +1,239 @@
+'use strict';
+
+const fileResFilenameRegex = /filename="([^"]+)"/;
+const getFileNameFromContentDispositionHeader = (contentDispositionHeader) => {
+  if (!contentDispositionHeader) return "download-file";
+  const match = contentDispositionHeader.match(fileResFilenameRegex);
+  const fileName = match ? match[1] : "downloaded-file";
+  return fileName;
+};
+
+const convertToFormData = (payload) => {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("Multipart payload must be an object");
+  }
+  const formData = new FormData();
+  const source = payload;
+  const addProp = (key, value) => {
+    if (value === void 0) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item) => addProp(key, item));
+      return;
+    }
+    if (isFileList(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        addProp(key, value.item(i));
+      }
+      return;
+    }
+    if (isBlob(value)) {
+      formData.append(key, value);
+      return;
+    }
+    if (isNodeFileDescriptor(value)) {
+      const file = fileDescriptorToBlob(value);
+      formData.append(key, file, value.name);
+      return;
+    }
+    if (typeof value === "object" && value != null) {
+      throw new Error(
+        `Object serialization into FormData not supported: ${safeStringify(value)}`
+      );
+    }
+    formData.append(key, String(value));
+  };
+  Object.entries(source).forEach(([key, value]) => addProp(key, value));
+  return formData;
+};
+const withoutContentTypeHeader = (headers) => {
+  return Object.fromEntries(
+    Object.entries(headers).filter(
+      ([key]) => key.toLowerCase() !== "content-type"
+    )
+  );
+};
+const isBlob = (value) => {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+};
+const isFileList = (value) => {
+  return typeof FileList !== "undefined" && value instanceof FileList;
+};
+const isNodeFileDescriptor = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const typed = value;
+  return typeof typed.name === "string" && "file" in typed;
+};
+const fileDescriptorToBlob = (descriptor) => {
+  const { file, type } = descriptor;
+  if (isBlob(file)) {
+    if (type && type !== file.type) {
+      return new Blob([file], { type });
+    }
+    return file;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(file)) {
+    const bytes = new Uint8Array(file.byteLength);
+    bytes.set(file);
+    return new Blob([bytes.buffer], { type });
+  }
+  if (file instanceof ArrayBuffer) {
+    return new Blob([file], { type });
+  }
+  if (ArrayBuffer.isView(file)) {
+    const bytes = new Uint8Array(file.byteLength);
+    bytes.set(new Uint8Array(file.buffer, file.byteOffset, file.byteLength));
+    return new Blob([bytes.buffer], { type });
+  }
+  throw new Error(
+    "Object serialization into FormData not supported: Readable stream file descriptors are not supported"
+  );
+};
+const safeStringify = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+
+class HttpClientHelper {
+  validateRequest(req) {
+    this.assertRelativePathWithoutQuery(req.path);
+  }
+  assertRelativePathWithoutQuery(path) {
+    if (!path.startsWith("/")) {
+      throw new Error('Request path must start with "/".');
+    }
+    if (path.includes("?")) {
+      throw new Error(
+        "Request path must not contain a query string. Use req.query instead."
+      );
+    }
+  }
+  withQueryString(path, query, querySerializer) {
+    if (!query) {
+      return path;
+    }
+    const queryString = this.serializeQuery(query, querySerializer);
+    if (!queryString) {
+      return path;
+    }
+    return `${path}?${queryString}`;
+  }
+  serializeQuery(query, querySerializer) {
+    if (querySerializer) {
+      return querySerializer(query);
+    }
+    return this.toDefaultQueryString(query);
+  }
+  resolveUrl(path, baseUrl) {
+    if (!baseUrl) {
+      return path;
+    }
+    return new URL(path, baseUrl).toString();
+  }
+  convertToFormData(payload) {
+    return convertToFormData(payload);
+  }
+  withoutContentTypeHeader(headers) {
+    return withoutContentTypeHeader(headers);
+  }
+  getFileNameFromContentDispositionHeader(contentDispositionHeader) {
+    return getFileNameFromContentDispositionHeader(contentDispositionHeader);
+  }
+  toDefaultQueryString(query) {
+    const params = new URLSearchParams();
+    const addValue = (key, value) => {
+      if (value === void 0) return;
+      if (Array.isArray(value)) {
+        value.forEach((item) => addValue(key, item));
+        return;
+      }
+      params.append(key, String(value));
+    };
+    Object.entries(query).forEach(([key, value]) => addValue(key, value));
+    return params.toString();
+  }
+}
+
+const createHttpClient$1 = (axios, opts) => {
+  const { querySerializer } = opts;
+  const helper = new HttpClientHelper();
+  return {
+    request: (req) => {
+      helper.validateRequest(req);
+      const { query, requestContentType, body, headers: reqHeaders } = req;
+      const paramsSerializer = querySerializer ? (r) => helper.serializeQuery(r, querySerializer) : void 0;
+      const isBlobResponse = req.format === "document";
+      const headers = { ...reqHeaders || {} };
+      let data = body;
+      if (requestContentType === "multipart/form-data") {
+        data = helper.convertToFormData(body);
+      } else if (requestContentType) {
+        headers["Content-Type"] = requestContentType;
+      }
+      return axios.request({
+        method: req.method,
+        url: req.path,
+        params: query,
+        paramsSerializer,
+        data,
+        headers,
+        responseType: isBlobResponse ? "arraybuffer" : "json"
+      }).then((r) => {
+        const headers2 = normalizeHeaders(
+          r.headers
+        );
+        const response = {
+          body: r.data,
+          headers: headers2,
+          status: r.status
+        };
+        if (isBlobResponse) {
+          const contDist = getHeaderValue(
+            headers2["content-disposition"]
+          );
+          const fileName = helper.getFileNameFromContentDispositionHeader(
+            contDist
+          );
+          const type = getHeaderValue(headers2["content-type"]);
+          return {
+            ...response,
+            body: new File([r.data], fileName, {
+              type
+            })
+          };
+        }
+        return response;
+      });
+    }
+  };
+};
+const normalizeHeaders = (headers) => {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value == null) {
+      continue;
+    }
+    normalized[key.toLowerCase()] = Array.isArray(value) ? value.map(String) : String(value);
+  }
+  return normalized;
+};
+const getHeaderValue = (header) => {
+  if (Array.isArray(header)) {
+    return header[0];
+  }
+  return header;
+};
+
+const createHttpClient = (axios, opts) => {
+  return createHttpClient$1(axios, {
+    querySerializer: opts.querySerializer
+  });
+};
+
+exports.createHttpClient = createHttpClient;

package/dist/browser.d.cts

@@ -0,0 +1,44 @@
+import { AxiosInstance } from 'axios';
+
+type KnownRequestContentType = 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded';
+type RequestContentType = KnownRequestContentType | string;
+type QueryValue = string | number | boolean | null | undefined | QueryValue[] | Record<string, any> | unknown;
+type QueryParams = Record<string, QueryValue>;
+type Request = {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    format?: 'json' | 'document';
+    headers?: Record<string, string>;
+    query?: QueryParams;
+    body?: any;
+    requestContentType?: RequestContentType;
+};
+type HttpResponse<Data> = {
+    body: Data;
+    headers: Record<string, string | string[]>;
+    status: number;
+};
+type QuerySerializer = (params: QueryParams) => string;
+
+type HttpClient<RequestParams = never> = {
+    request: <Data>(req: Request, params?: RequestParams) => Promise<HttpResponse<Data>>;
+};
+
+/// <reference lib="esnext.asynciterable" />
+
+/**
+ * Note: This will add Symbol.observable globally for all TypeScript users,
+ * however, we are no longer polyfilling Symbol.observable
+ */
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+
+declare const createHttpClient: (axios: AxiosInstance, opts: {
+    querySerializer: QuerySerializer | null;
+}) => HttpClient;
+
+export { createHttpClient };
+export type { HttpResponse, HttpClient as PromiseHttpClient, QuerySerializer };

package/dist/browser.d.mts

@@ -0,0 +1,44 @@
+import { AxiosInstance } from 'axios';
+
+type KnownRequestContentType = 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded';
+type RequestContentType = KnownRequestContentType | string;
+type QueryValue = string | number | boolean | null | undefined | QueryValue[] | Record<string, any> | unknown;
+type QueryParams = Record<string, QueryValue>;
+type Request = {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    format?: 'json' | 'document';
+    headers?: Record<string, string>;
+    query?: QueryParams;
+    body?: any;
+    requestContentType?: RequestContentType;
+};
+type HttpResponse<Data> = {
+    body: Data;
+    headers: Record<string, string | string[]>;
+    status: number;
+};
+type QuerySerializer = (params: QueryParams) => string;
+
+type HttpClient<RequestParams = never> = {
+    request: <Data>(req: Request, params?: RequestParams) => Promise<HttpResponse<Data>>;
+};
+
+/// <reference lib="esnext.asynciterable" />
+
+/**
+ * Note: This will add Symbol.observable globally for all TypeScript users,
+ * however, we are no longer polyfilling Symbol.observable
+ */
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+
+declare const createHttpClient: (axios: AxiosInstance, opts: {
+    querySerializer: QuerySerializer | null;
+}) => HttpClient;
+
+export { createHttpClient };
+export type { HttpResponse, HttpClient as PromiseHttpClient, QuerySerializer };

package/dist/browser.d.ts

@@ -1,5 +1,29 @@
 import { AxiosInstance } from 'axios';
 
+type KnownRequestContentType = 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded';
+type RequestContentType = KnownRequestContentType | string;
+type QueryValue = string | number | boolean | null | undefined | QueryValue[] | Record<string, any> | unknown;
+type QueryParams = Record<string, QueryValue>;
+type Request = {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    format?: 'json' | 'document';
+    headers?: Record<string, string>;
+    query?: QueryParams;
+    body?: any;
+    requestContentType?: RequestContentType;
+};
+type HttpResponse<Data> = {
+    body: Data;
+    headers: Record<string, string | string[]>;
+    status: number;
+};
+type QuerySerializer = (params: QueryParams) => string;
+
+type HttpClient<RequestParams = never> = {
+    request: <Data>(req: Request, params?: RequestParams) => Promise<HttpResponse<Data>>;
+};
+
 /// <reference lib="esnext.asynciterable" />
 
 /**
@@ -12,28 +36,9 @@ declare global {
     }
 }
 
-type RequestContentType = 'application/json' | 'multipart/form-data';
-type Request = {
-    path: string;
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
-    format?: 'json' | 'document';
-    headers?: Record<string, string>;
-    query?: Record<string, unknown>;
-    body?: any;
-    requestContentType?: RequestContentType;
-};
-type QuerySerializer = (req: {
-    queryParams: Record<string, unknown>;
-}) => {
-    queryString: string;
-};
-type PromiseHttpClient<RequestParams = never> = {
-    request: <Data>(req: Request, params?: RequestParams) => Promise<Data>;
-};
-
 declare const createHttpClient: (axios: AxiosInstance, opts: {
     querySerializer: QuerySerializer | null;
-}) => PromiseHttpClient<never>;
+}) => HttpClient;
 
 export { createHttpClient };
-export type { PromiseHttpClient, QuerySerializer };
+export type { HttpResponse, HttpClient as PromiseHttpClient, QuerySerializer };

package/dist/browser.mjs

@@ -0,0 +1,237 @@
+const fileResFilenameRegex = /filename="([^"]+)"/;
+const getFileNameFromContentDispositionHeader = (contentDispositionHeader) => {
+  if (!contentDispositionHeader) return "download-file";
+  const match = contentDispositionHeader.match(fileResFilenameRegex);
+  const fileName = match ? match[1] : "downloaded-file";
+  return fileName;
+};
+
+const convertToFormData = (payload) => {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("Multipart payload must be an object");
+  }
+  const formData = new FormData();
+  const source = payload;
+  const addProp = (key, value) => {
+    if (value === void 0) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item) => addProp(key, item));
+      return;
+    }
+    if (isFileList(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        addProp(key, value.item(i));
+      }
+      return;
+    }
+    if (isBlob(value)) {
+      formData.append(key, value);
+      return;
+    }
+    if (isNodeFileDescriptor(value)) {
+      const file = fileDescriptorToBlob(value);
+      formData.append(key, file, value.name);
+      return;
+    }
+    if (typeof value === "object" && value != null) {
+      throw new Error(
+        `Object serialization into FormData not supported: ${safeStringify(value)}`
+      );
+    }
+    formData.append(key, String(value));
+  };
+  Object.entries(source).forEach(([key, value]) => addProp(key, value));
+  return formData;
+};
+const withoutContentTypeHeader = (headers) => {
+  return Object.fromEntries(
+    Object.entries(headers).filter(
+      ([key]) => key.toLowerCase() !== "content-type"
+    )
+  );
+};
+const isBlob = (value) => {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+};
+const isFileList = (value) => {
+  return typeof FileList !== "undefined" && value instanceof FileList;
+};
+const isNodeFileDescriptor = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const typed = value;
+  return typeof typed.name === "string" && "file" in typed;
+};
+const fileDescriptorToBlob = (descriptor) => {
+  const { file, type } = descriptor;
+  if (isBlob(file)) {
+    if (type && type !== file.type) {
+      return new Blob([file], { type });
+    }
+    return file;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(file)) {
+    const bytes = new Uint8Array(file.byteLength);
+    bytes.set(file);
+    return new Blob([bytes.buffer], { type });
+  }
+  if (file instanceof ArrayBuffer) {
+    return new Blob([file], { type });
+  }
+  if (ArrayBuffer.isView(file)) {
+    const bytes = new Uint8Array(file.byteLength);
+    bytes.set(new Uint8Array(file.buffer, file.byteOffset, file.byteLength));
+    return new Blob([bytes.buffer], { type });
+  }
+  throw new Error(
+    "Object serialization into FormData not supported: Readable stream file descriptors are not supported"
+  );
+};
+const safeStringify = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+
+class HttpClientHelper {
+  validateRequest(req) {
+    this.assertRelativePathWithoutQuery(req.path);
+  }
+  assertRelativePathWithoutQuery(path) {
+    if (!path.startsWith("/")) {
+      throw new Error('Request path must start with "/".');
+    }
+    if (path.includes("?")) {
+      throw new Error(
+        "Request path must not contain a query string. Use req.query instead."
+      );
+    }
+  }
+  withQueryString(path, query, querySerializer) {
+    if (!query) {
+      return path;
+    }
+    const queryString = this.serializeQuery(query, querySerializer);
+    if (!queryString) {
+      return path;
+    }
+    return `${path}?${queryString}`;
+  }
+  serializeQuery(query, querySerializer) {
+    if (querySerializer) {
+      return querySerializer(query);
+    }
+    return this.toDefaultQueryString(query);
+  }
+  resolveUrl(path, baseUrl) {
+    if (!baseUrl) {
+      return path;
+    }
+    return new URL(path, baseUrl).toString();
+  }
+  convertToFormData(payload) {
+    return convertToFormData(payload);
+  }
+  withoutContentTypeHeader(headers) {
+    return withoutContentTypeHeader(headers);
+  }
+  getFileNameFromContentDispositionHeader(contentDispositionHeader) {
+    return getFileNameFromContentDispositionHeader(contentDispositionHeader);
+  }
+  toDefaultQueryString(query) {
+    const params = new URLSearchParams();
+    const addValue = (key, value) => {
+      if (value === void 0) return;
+      if (Array.isArray(value)) {
+        value.forEach((item) => addValue(key, item));
+        return;
+      }
+      params.append(key, String(value));
+    };
+    Object.entries(query).forEach(([key, value]) => addValue(key, value));
+    return params.toString();
+  }
+}
+
+const createHttpClient$1 = (axios, opts) => {
+  const { querySerializer } = opts;
+  const helper = new HttpClientHelper();
+  return {
+    request: (req) => {
+      helper.validateRequest(req);
+      const { query, requestContentType, body, headers: reqHeaders } = req;
+      const paramsSerializer = querySerializer ? (r) => helper.serializeQuery(r, querySerializer) : void 0;
+      const isBlobResponse = req.format === "document";
+      const headers = { ...reqHeaders || {} };
+      let data = body;
+      if (requestContentType === "multipart/form-data") {
+        data = helper.convertToFormData(body);
+      } else if (requestContentType) {
+        headers["Content-Type"] = requestContentType;
+      }
+      return axios.request({
+        method: req.method,
+        url: req.path,
+        params: query,
+        paramsSerializer,
+        data,
+        headers,
+        responseType: isBlobResponse ? "arraybuffer" : "json"
+      }).then((r) => {
+        const headers2 = normalizeHeaders(
+          r.headers
+        );
+        const response = {
+          body: r.data,
+          headers: headers2,
+          status: r.status
+        };
+        if (isBlobResponse) {
+          const contDist = getHeaderValue(
+            headers2["content-disposition"]
+          );
+          const fileName = helper.getFileNameFromContentDispositionHeader(
+            contDist
+          );
+          const type = getHeaderValue(headers2["content-type"]);
+          return {
+            ...response,
+            body: new File([r.data], fileName, {
+              type
+            })
+          };
+        }
+        return response;
+      });
+    }
+  };
+};
+const normalizeHeaders = (headers) => {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value == null) {
+      continue;
+    }
+    normalized[key.toLowerCase()] = Array.isArray(value) ? value.map(String) : String(value);
+  }
+  return normalized;
+};
+const getHeaderValue = (header) => {
+  if (Array.isArray(header)) {
+    return header[0];
+  }
+  return header;
+};
+
+const createHttpClient = (axios, opts) => {
+  return createHttpClient$1(axios, {
+    querySerializer: opts.querySerializer
+  });
+};
+
+export { createHttpClient };