make-service 0.0.3 → 0.2.0

package/README.md

@@ -76,7 +76,7 @@ Its [`typedResponse`](#typedresponse) can also be parsed with a zod schema. Here
 ```ts
 const response = await api.get("/users", {
   query: { search: "John" },
-  trace: (input, requestInit) => console.log(input, requestInit),
+  trace: (url, requestInit) => console.log(url, requestInit),
 })
 const json = await response.json(
   z.object({
@@ -104,6 +104,38 @@ await api.head("/users")
 await api.options("/users")
 ```
 
+This function can also correctly merge any sort of `URL`, `URLSearchParams`, and `Headers`.
+
+```ts
+import { makeService } from 'make-service'
+
+const api = makeService(new URL("https://example.com/api"), new Headers({
+  authorization: "Bearer 123"
+}))
+
+const response = await api.get("/users?admin=true", {
+  headers: [['accept', 'application/json']],
+  query: { page: "2" },
+})
+
+// It will call "https://example.com/api/users?admin=true&page=2"
+// with headers: { authorization: "Bearer 123", accept: "application/json" }
+```
+
+In case you want to delete a header previously set you can pass `undefined` or `'undefined'` as its value:
+```ts
+const api = makeService("https://example.com/api", { authorization: "Bearer 123" })
+const response = await api.get("/users", {
+  headers: new Headers({ authorization: 'undefined', "Content-Type": undefined }),
+})
+// headers will be empty.
+```
+Note: Don't forget headers are case insensitive.
+```ts
+const headers = new Headers({ 'Content-Type': 'application/json' })
+Object.fromEntries(headers) // equals to: { 'content-type': 'application/json' }
+```
+
 ## enhancedFetch
 
 A wrapper around the `fetch` API.
@@ -121,7 +153,7 @@ const json = await response.json()
 // You can pass it a generic or schema to type the result
 ```
 
-This function accepts the same arguments as the `fetch` API - with exception of [JSON-like body](/src/make-service.ts) -, and it also accepts an object-like [`query`](/src/make-service.ts) and a `trace` function that will be called with the `input` and `requestInit` arguments.
+This function accepts the same arguments as the `fetch` API - with exception of [JSON-like body](/src/make-service.ts) -, and it also accepts an object-like [`query`](/src/make-service.ts) and a `trace` function that will be called with the `url` and `requestInit` arguments.
 
 This slightly different `RequestInit` is typed as `EnhancedRequestInit`.
 
@@ -132,7 +164,7 @@ await enhancedFetch("https://example.com/api/users", {
   method: 'POST',
   body: { some: { object: { as: { body } } } },
   query: { page: "1" },
-  trace: (input, requestInit) => console.log(input, requestInit)
+  trace: (url, requestInit) => console.log(url, requestInit)
 })
 
 // The trace function will be called with the following arguments:
@@ -155,21 +187,21 @@ import { typedResponse } from 'make-service'
 import type { TypedResponse } from 'make-service'
 
 // With JSON
-const response: TypedResponse = new Response(JSON.stringify({ foo: "bar" }))
-const json = await typedResponse(response).json()
+const response: TypedResponse = typedResponse(new Response(JSON.stringify({ foo: "bar" })))
+const json = await response.json()
 //    ^? unknown
-const json = await typedResponse(response).json<{ foo: string }>()
+const json = await response.json<{ foo: string }>()
 //    ^? { foo: string }
-const json = await typedResponse(response).json(z.object({ foo: z.string() }))
+const json = await response.json(z.object({ foo: z.string() }))
 //    ^? { foo: string }
 
 // With text
-const response: TypedResponse = new Response("foo")
-const text = await typedResponse(response).text()
+const response: TypedResponse = typedResponse(new Response("foo"))
+const text = await response.text()
 //    ^? string
-const text = await typedResponse(response).text<`foo${string}`>()
+const text = await response.text<`foo${string}`>()
 //    ^? `foo${string}`
-const text = await typedResponse(response).text(z.string().email())
+const text = await response.text(z.string().email())
 //    ^? string
 ```
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-declare const HTTP_METHODS: readonly ["get", "post", "put", "delete", "patch", "options", "head"];
+declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"];
 
 /**
  * It returns the JSON object or throws an error if the response is not ok.
@@ -26,24 +26,44 @@ type TypedResponse = Omit<Response, 'json' | 'text'> & {
 type EnhancedRequestInit = Omit<RequestInit, 'body'> & {
     body?: JSONValue;
     query?: SearchParams;
+    params?: Record<string, string>;
     trace?: (...args: Parameters<typeof fetch>) => void;
 };
 type ServiceRequestInit = Omit<EnhancedRequestInit, 'method'>;
 type HTTPMethod = (typeof HTTP_METHODS)[number];
 type TypedResponseJson = ReturnType<typeof getJson>;
 type TypedResponseText = ReturnType<typeof getText>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type NoEmpty<T> = keyof T extends never ? never : T;
+type PathParams<T extends string> = NoEmpty<T extends `${infer _}:${infer Param}/${infer Rest}` ? Prettify<{
+    [K in Param]: string;
+} & PathParams<Rest>> : T extends `${infer _}:${infer Param}` ? {
+    [K in Param]: string;
+} : {}>;
 
 /**
- * @param input a string or URL to which the query parameters will be added
+ * It merges multiple HeadersInit objects into a single Headers object
+ * @param entries Any number of HeadersInit objects
+ * @returns a new Headers object with the merged headers
+ */
+declare function mergeHeaders(...entries: (HeadersInit | [string, undefined][] | Record<string, undefined>)[]): Headers;
+/**
+ * @param url a string or URL to which the query parameters will be added
  * @param searchParams the query parameters
- * @returns the input with the query parameters added with the same type as the input
+ * @returns the url with the query parameters added with the same type as the url
  */
-declare function addQueryToInput(input: string | URL, searchParams?: SearchParams): string | URL;
+declare function addQueryToUrl(url: string | URL, searchParams?: SearchParams): string | URL;
+/**
+ * @deprecated method renamed to addQueryToUrl
+ */
+declare const addQueryToInput: typeof addQueryToUrl;
 /**
  * @param baseURL the base path to the API
  * @returns a function that receives a path and an object of query parameters and returns a URL
  */
-declare function makeGetApiUrl(baseURL: string): (path: string, searchParams?: SearchParams) => string | URL;
+declare function makeGetApiUrl(baseURL: string | URL): (path: string, searchParams?: SearchParams) => string | URL;
 /**
  * It hacks the Response object to add typed json and text methods
  * @param response the Response to be proxied
@@ -66,7 +86,7 @@ declare function typedResponse(response: Response): TypedResponse;
 declare function ensureStringBody(body?: JSONValue): string | undefined;
 /**
  *
- * @param input a string or URL to be fetched
+ * @param url a string or URL to be fetched
  * @param requestInit the requestInit to be passed to the fetch request. It is the same as the `RequestInit` type, but it also accepts a JSON-like `body` and an object-like `query` parameter.
  * @param requestInit.body the body of the request. It will be automatically stringified so you can send a JSON-like object
  * @param requestInit.query the query parameters to be added to the URL
@@ -78,7 +98,7 @@ declare function ensureStringBody(body?: JSONValue): string | undefined;
  * const untyped = await response.json();
  * //    ^? unknown
  */
-declare function enhancedFetch(input: string | URL, requestInit?: EnhancedRequestInit): Promise<TypedResponse>;
+declare function enhancedFetch(url: string | URL, requestInit?: EnhancedRequestInit): Promise<TypedResponse>;
 /**
  *
  * @param baseURL the base URL to the API
@@ -90,14 +110,6 @@ declare function enhancedFetch(input: string | URL, requestInit?: EnhancedReques
  * const users = await response.json(userSchema);
  * //    ^? User[]
  */
-declare function makeService(baseURL: string, baseHeaders?: HeadersInit): {
-    get: (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>;
-    post: (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>;
-    put: (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>;
-    delete: (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>;
-    patch: (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>;
-    options: (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>;
-    head: (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>;
-};
+declare function makeService(baseURL: string | URL, baseHeaders?: HeadersInit): Record<"delete" | "get" | "post" | "put" | "patch" | "options" | "head", (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>>;
 
-export { EnhancedRequestInit, HTTPMethod, JSONValue, Schema, SearchParams, ServiceRequestInit, TypedResponse, TypedResponseJson, TypedResponseText, addQueryToInput, enhancedFetch, ensureStringBody, makeGetApiUrl, makeService, typedResponse };
+export { EnhancedRequestInit, HTTPMethod, JSONValue, PathParams, Schema, SearchParams, ServiceRequestInit, TypedResponse, TypedResponseJson, TypedResponseText, addQueryToInput, addQueryToUrl, enhancedFetch, ensureStringBody, makeGetApiUrl, makeService, mergeHeaders, typedResponse };

package/dist/index.js

@@ -21,23 +21,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   addQueryToInput: () => addQueryToInput,
+  addQueryToUrl: () => addQueryToUrl,
   enhancedFetch: () => enhancedFetch,
   ensureStringBody: () => ensureStringBody,
   makeGetApiUrl: () => makeGetApiUrl,
   makeService: () => makeService,
+  mergeHeaders: () => mergeHeaders,
   typedResponse: () => typedResponse
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/constants.ts
 var HTTP_METHODS = [
-  "get",
-  "post",
-  "put",
-  "delete",
-  "patch",
-  "options",
-  "head"
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS",
+  "HEAD"
 ];
 
 // src/internals.ts
@@ -56,25 +58,54 @@ function getText(response) {
     return schema ? schema.parse(text) : text;
   };
 }
-function isHTTPMethod(method) {
-  return HTTP_METHODS.includes(method);
+function replaceUrlParams(url, params) {
+  if (!params)
+    return url;
+  let urlString = String(url);
+  Object.entries(params).forEach(([key, value]) => {
+    urlString = urlString.replace(new RegExp(`:${key}($|/)`), `${value}$1`);
+  });
+  return url instanceof URL ? new URL(urlString) : urlString;
 }
 
 // src/make-service.ts
-function addQueryToInput(input, searchParams) {
+function mergeHeaders(...entries) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const headers = new Headers(entry);
+    for (const [key, value] of headers.entries()) {
+      if (value === void 0 || value === "undefined") {
+        result.delete(key);
+      } else {
+        result.set(key, value);
+      }
+    }
+  }
+  return new Headers(Array.from(result.entries()));
+}
+function addQueryToUrl(url, searchParams) {
   if (!searchParams)
-    return input;
-  if (searchParams && typeof input === "string") {
-    const separator = input.includes("?") ? "&" : "?";
-    return `${input}${separator}${new URLSearchParams(searchParams)}`;
+    return url;
+  if (typeof url === "string") {
+    const separator = url.includes("?") ? "&" : "?";
+    return `${url}${separator}${new URLSearchParams(searchParams)}`;
   }
-  if (searchParams && input instanceof URL) {
-    input.search = new URLSearchParams(searchParams).toString();
+  if (searchParams && url instanceof URL) {
+    for (const [key, value] of Object.entries(
+      new URLSearchParams(searchParams)
+    )) {
+      url.searchParams.set(key, value);
+    }
   }
-  return input;
+  return url;
 }
+var addQueryToInput = addQueryToUrl;
 function makeGetApiUrl(baseURL) {
-  return (path, searchParams) => addQueryToInput(`${baseURL}${path}`, searchParams);
+  const base = baseURL instanceof URL ? baseURL.toString() : baseURL;
+  return (path, searchParams) => {
+    const url = `${base}${path}`.replace(/([^https?:]\/)\/+/g, "$1");
+    return addQueryToUrl(url, searchParams);
+  };
 }
 function typedResponse(response) {
   return new Proxy(response, {
@@ -94,42 +125,51 @@ function ensureStringBody(body) {
     return body;
   return JSON.stringify(body);
 }
-async function enhancedFetch(input, requestInit) {
+async function enhancedFetch(url, requestInit) {
+  var _a, _b;
   const { query, trace, ...reqInit } = requestInit != null ? requestInit : {};
-  const headers = { "content-type": "application/json", ...reqInit.headers };
-  const url = addQueryToInput(input, query);
+  const headers = mergeHeaders(
+    {
+      "content-type": "application/json"
+    },
+    (_a = reqInit.headers) != null ? _a : {}
+  );
+  const withParams = replaceUrlParams(url, (_b = reqInit.params) != null ? _b : {});
+  const fullUrl = addQueryToUrl(withParams, query);
   const body = ensureStringBody(reqInit.body);
   const enhancedReqInit = { ...reqInit, headers, body };
-  trace == null ? void 0 : trace(url, enhancedReqInit);
-  const request = new Request(url, enhancedReqInit);
-  const response = await fetch(request);
+  trace == null ? void 0 : trace(fullUrl, enhancedReqInit);
+  const response = await fetch(fullUrl, enhancedReqInit);
   return typedResponse(response);
 }
 function makeService(baseURL, baseHeaders) {
   const service = (method) => {
     return async (path, requestInit = {}) => {
-      const response = await enhancedFetch(`${baseURL}${path}`, {
+      var _a;
+      const url = makeGetApiUrl(baseURL)(path);
+      const response = await enhancedFetch(url, {
         ...requestInit,
         method,
-        headers: { ...baseHeaders, ...requestInit == null ? void 0 : requestInit.headers }
+        headers: mergeHeaders(baseHeaders != null ? baseHeaders : {}, (_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {})
       });
       return response;
     };
   };
-  return new Proxy({}, {
-    get(_target, prop) {
-      if (isHTTPMethod(prop))
-        return service(prop);
-      throw new Error(`Invalid HTTP method: ${prop.toString()}`);
-    }
-  });
+  let api = {};
+  for (const method of HTTP_METHODS) {
+    const lowerMethod = method.toLowerCase();
+    api[lowerMethod] = service(method);
+  }
+  return api;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addQueryToInput,
+  addQueryToUrl,
   enhancedFetch,
   ensureStringBody,
   makeGetApiUrl,
   makeService,
+  mergeHeaders,
   typedResponse
 });

package/dist/index.mjs

@@ -1,12 +1,12 @@
 // src/constants.ts
 var HTTP_METHODS = [
-  "get",
-  "post",
-  "put",
-  "delete",
-  "patch",
-  "options",
-  "head"
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS",
+  "HEAD"
 ];
 
 // src/internals.ts
@@ -25,25 +25,54 @@ function getText(response) {
     return schema ? schema.parse(text) : text;
   };
 }
-function isHTTPMethod(method) {
-  return HTTP_METHODS.includes(method);
+function replaceUrlParams(url, params) {
+  if (!params)
+    return url;
+  let urlString = String(url);
+  Object.entries(params).forEach(([key, value]) => {
+    urlString = urlString.replace(new RegExp(`:${key}($|/)`), `${value}$1`);
+  });
+  return url instanceof URL ? new URL(urlString) : urlString;
 }
 
 // src/make-service.ts
-function addQueryToInput(input, searchParams) {
+function mergeHeaders(...entries) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const headers = new Headers(entry);
+    for (const [key, value] of headers.entries()) {
+      if (value === void 0 || value === "undefined") {
+        result.delete(key);
+      } else {
+        result.set(key, value);
+      }
+    }
+  }
+  return new Headers(Array.from(result.entries()));
+}
+function addQueryToUrl(url, searchParams) {
   if (!searchParams)
-    return input;
-  if (searchParams && typeof input === "string") {
-    const separator = input.includes("?") ? "&" : "?";
-    return `${input}${separator}${new URLSearchParams(searchParams)}`;
+    return url;
+  if (typeof url === "string") {
+    const separator = url.includes("?") ? "&" : "?";
+    return `${url}${separator}${new URLSearchParams(searchParams)}`;
   }
-  if (searchParams && input instanceof URL) {
-    input.search = new URLSearchParams(searchParams).toString();
+  if (searchParams && url instanceof URL) {
+    for (const [key, value] of Object.entries(
+      new URLSearchParams(searchParams)
+    )) {
+      url.searchParams.set(key, value);
+    }
   }
-  return input;
+  return url;
 }
+var addQueryToInput = addQueryToUrl;
 function makeGetApiUrl(baseURL) {
-  return (path, searchParams) => addQueryToInput(`${baseURL}${path}`, searchParams);
+  const base = baseURL instanceof URL ? baseURL.toString() : baseURL;
+  return (path, searchParams) => {
+    const url = `${base}${path}`.replace(/([^https?:]\/)\/+/g, "$1");
+    return addQueryToUrl(url, searchParams);
+  };
 }
 function typedResponse(response) {
   return new Proxy(response, {
@@ -63,41 +92,50 @@ function ensureStringBody(body) {
     return body;
   return JSON.stringify(body);
 }
-async function enhancedFetch(input, requestInit) {
+async function enhancedFetch(url, requestInit) {
+  var _a, _b;
   const { query, trace, ...reqInit } = requestInit != null ? requestInit : {};
-  const headers = { "content-type": "application/json", ...reqInit.headers };
-  const url = addQueryToInput(input, query);
+  const headers = mergeHeaders(
+    {
+      "content-type": "application/json"
+    },
+    (_a = reqInit.headers) != null ? _a : {}
+  );
+  const withParams = replaceUrlParams(url, (_b = reqInit.params) != null ? _b : {});
+  const fullUrl = addQueryToUrl(withParams, query);
   const body = ensureStringBody(reqInit.body);
   const enhancedReqInit = { ...reqInit, headers, body };
-  trace == null ? void 0 : trace(url, enhancedReqInit);
-  const request = new Request(url, enhancedReqInit);
-  const response = await fetch(request);
+  trace == null ? void 0 : trace(fullUrl, enhancedReqInit);
+  const response = await fetch(fullUrl, enhancedReqInit);
   return typedResponse(response);
 }
 function makeService(baseURL, baseHeaders) {
   const service = (method) => {
     return async (path, requestInit = {}) => {
-      const response = await enhancedFetch(`${baseURL}${path}`, {
+      var _a;
+      const url = makeGetApiUrl(baseURL)(path);
+      const response = await enhancedFetch(url, {
         ...requestInit,
         method,
-        headers: { ...baseHeaders, ...requestInit == null ? void 0 : requestInit.headers }
+        headers: mergeHeaders(baseHeaders != null ? baseHeaders : {}, (_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {})
       });
       return response;
     };
   };
-  return new Proxy({}, {
-    get(_target, prop) {
-      if (isHTTPMethod(prop))
-        return service(prop);
-      throw new Error(`Invalid HTTP method: ${prop.toString()}`);
-    }
-  });
+  let api = {};
+  for (const method of HTTP_METHODS) {
+    const lowerMethod = method.toLowerCase();
+    api[lowerMethod] = service(method);
+  }
+  return api;
 }
 export {
   addQueryToInput,
+  addQueryToUrl,
   enhancedFetch,
   ensureStringBody,
   makeGetApiUrl,
   makeService,
+  mergeHeaders,
   typedResponse
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "make-service",
-  "version": "0.0.3",
+  "version": "0.2.0",
   "description": "Some utilities to extend the 'fetch' API to better interact with external APIs.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",