make-service 0.2.0 → 1.0.0-next.2

package/README.md

@@ -8,22 +8,49 @@ It adds a set of little features and allows you to parse responses with [zod](ht
 - 🤩 Type-safe return of `response.json()` and `response.text()`. Defaults to `unknown` instead of `any`.
 - 🚦 Easily setup an API with a `baseURL` and common `headers` for every request.
 - 🏗️ Compose URL from the base by just calling the endpoints and an object-like `query`.
+- 🐾 Replaces URL wildcards with an object of `params`.
 - 🧙‍♀️ Automatically stringifies the `body` of a request so you can give it a JSON-like structure.
 - 🐛 Accepts a `trace` function for debugging.
 
 ## Example
 
 ```ts
-const api = makeService("https://example.com/api", {
+const service = makeService("https://example.com/api", {
   Authorization: "Bearer 123",
 });
 
-const response = await api.get("/users")
+const response = await service.get("/users")
 const users = await response.json(usersSchema);
 //    ^? User[]
 ```
 
-## Installation
+# Table of Contents
+- [Installation](#installation)
+- [API](#api)
+  - [makeService](#makeservice)
+    - [Type-checking the response body](#type-checking-the-response-body)
+    - [Runtime type-checking and parsing the response body](#runtime-type-checking-and-parsing-the-response-body)
+    - [Supported HTTP Verbs](#supported-http-verbs)
+    - [Headers](#headers)
+      - [Passing a function as `baseHeaders`](#passing-a-function-as-baseheaders)
+      - [Deleting a previously set header](#deleting-a-previously-set-header)
+    - [Base URL](#base-url)
+    - [Body](#body)
+    - [Query](#query)
+    - [Params](#params)
+    - [Trace](#trace)
+  - [makeFetcher](#makefetcher)
+  - [enhancedFetch](#enhancedfetch)
+  - [typedResponse](#typedresponse)
+- [Other available primitives](#other-available-primitives)
+  - [addQueryToURL](#addquerytourl)
+  - [ensureStringBody](#ensurestringbody)
+  - [makeGetApiURL](#makegetapiurl)
+  - [mergeHeaders](#mergeheaders)
+  - [replaceURLParams](#replaceurlparams)
+  - [Thank you](#thank-you)
+
+# Installation
 
 ```sh
 npm install make-service
@@ -38,25 +65,24 @@ import { makeService } from "https://deno.land/x/make_service/mod.ts";
 
 This library exports the `makeService` function and some primitives used to build it. You can use the primitives as you wish but the `makeService` will have all the features combined.
 
-# makeService
-
+## makeService
 The main function of this lib is built on top of the primitives described in the following sections. It allows you to create a service object with a `baseURL` and common `headers` for every request.
 
-This service object can be called with every HTTP method and it will return a [`typedResponse`](#typedresponse) object as it uses the [`enhancedFetch`](#enhancedfetch) internally.
+This service object can be called with every HTTP method and it will return a [`typedResponse`](#typedresponse).
 
 ```ts
 import { makeService } from 'make-service'
 
-const api = makeService("https://example.com/api", {
+const service = makeService("https://example.com/api", {
   authorization: "Bearer 123"
 })
 
-const response = await api.get("/users")
+const response = await service.get("/users")
 const json = await response.json()
 //    ^? unknown
 ```
 
-On the example above, the `api.get` will call the [`enhancedFetch`](#enhancedfetch) with the following arguments:
+On the example above, the request will be sent with the following arguments:
 
 ```ts
 // "https://example.com/api/users"
@@ -69,15 +95,22 @@ On the example above, the `api.get` will call the [`enhancedFetch`](#enhancedfet
 // }
 ```
 
-The `api` object can be called with the same arguments as the [`enhancedFetch`](#enhancedfetch), such as `query`, object-like `body`, and `trace`.
+### Type-checking the response body
+The `response` object returned by the `service` can be type-casted with a given generic type. This will type-check the `response.json()` and `response.text()` methods.
+
+```ts
+const response = await service.get("/users")
+const users = await response.json<{ data: User[] }>()
+//    ^? { data: User[] }
+const content = await response.text<`${string}@${string}`>()
+//    ^? `${string}@${string}`
+```
 
+### Runtime type-checking and parsing the response body
 Its [`typedResponse`](#typedresponse) can also be parsed with a zod schema. Here follows a little more complex example:
 
 ```ts
-const response = await api.get("/users", {
-  query: { search: "John" },
-  trace: (url, requestInit) => console.log(url, requestInit),
-})
+const response = await service.get("/users")
 const json = await response.json(
   z.object({
     data: z.object({
@@ -91,41 +124,64 @@ const json = await response.json(
   .catch([])
 )
 // type of json will be { name: string }[]
-// the URL called will be "https://example.com/api/users?search=John"
+
+const content = await response.text(z.string().email())
+// It will throw an error if the response.text is not a valid email
 ```
+You can transform any `Response` in a `TypedResponse` like that by using the [`typedResponse`](#typedresponse) function.
 
-It accepts more HTTP verbs:
+### Supported HTTP Verbs
+Other than the `get` it also accepts more HTTP verbs:
 ```ts
-await api.post("/users", { body: { name: "John" } })
-await api.put("/users/1", { body: { name: "John" } })
-await api.patch("/users/1", { body: { name: "John" } })
-await api.delete("/users/1")
-await api.head("/users")
-await api.options("/users")
+await service.get("/users")
+await service.post("/users", { body: { name: "John" } })
+await service.put("/users/1", { body: { name: "John" } })
+await service.patch("/users/1", { body: { name: "John" } })
+await service.delete("/users/1")
+await service.head("/users")
+await service.options("/users")
 ```
 
-This function can also correctly merge any sort of `URL`, `URLSearchParams`, and `Headers`.
+### Headers
+The `headers` argument can be a `Headers` object, a `Record<string, string>`, or an array of `[key, value]` tuples (entries).
+The `baseHeaders` and the `headers` will be merged together, with the `headers` taking precedence.
 
 ```ts
 import { makeService } from 'make-service'
 
-const api = makeService(new URL("https://example.com/api"), new Headers({
-  authorization: "Bearer 123"
+const service = makeService("https://example.com/api", new Headers({
+  authorization: "Bearer 123",
+  accept: "*/*",
 }))
 
-const response = await api.get("/users?admin=true", {
+const response = await service.get("/users", {
   headers: [['accept', 'application/json']],
-  query: { page: "2" },
 })
 
-// It will call "https://example.com/api/users?admin=true&page=2"
+// It will call "https://example.com/api/users"
 // with headers: { authorization: "Bearer 123", accept: "application/json" }
 ```
 
+#### Passing a function as `baseHeaders`
+The given `baseHeaders` can be a sync or async function that will run in every request before it gets merged with the other headers.
+This is particularly useful when you need to send a refreshed token or add a timestamp to the request.
+
+```ts
+import { makeService } from 'make-service'
+
+declare getAuthorizationToken: () => Promise<HeadersInit>
+
+const service = makeService("https://example.com/api", async () => ({
+  authorization: await getAuthorizationToken(),
+}))
+
+```
+
+#### Deleting a previously set header
 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", {
+const service = makeService("https://example.com/api", { authorization: "Bearer 123" })
+const response = await service.get("/users", {
   headers: new Headers({ authorization: 'undefined', "Content-Type": undefined }),
 })
 // headers will be empty.
@@ -135,10 +191,132 @@ Note: Don't forget headers are case insensitive.
 const headers = new Headers({ 'Content-Type': 'application/json' })
 Object.fromEntries(headers) // equals to: { 'content-type': 'application/json' }
 ```
+All the features above are done by using the [`mergeHeaders`](#mergeheaders) function internally.
+
+
+### Base URL
+The service function can receive a `string` or `URL` as base `url` and it will be able to merge them correctly with the given path:
+
+```ts
+import { makeService } from 'make-service'
+
+const service = makeService(new URL("https://example.com/api"))
+
+const response = await service.get("/users?admin=true")
+
+// It will call "https://example.com/api/users?admin=true"
+```
+You can use the [`makeGetApiUrl`](#makegetapiurl) method to do that kind of URL composition.
+
+### Body
+The function can also receive a `body` object that will be stringified and sent as the request body:
+
+```ts
+import { makeService } from 'make-service'
+
+const service = makeService("https://example.com/api")
+const response = await service.post("/users", {
+  body: { person: { firstName: "John", lastName: "Doe" } },
+})
+
+// It will make a POST request to "https://example.com/api/users"
+// with stringified body: "{\"person\":{\"firstName\":\"John\",\"lastName\":\"Doe\"}}"
+```
+
+You can also pass any other accepted `BodyInit` values as body, such as `FormData`, `URLSearchParams`, `Blob`, `ReadableStream`, `ArrayBuffer`, etc.
+
+```ts
+import { makeService } from 'make-service'
+
+const service = makeService("https://example.com/api")
+const formData = new FormData([["name", "John"], ["lastName", "Doe"]])
+const response = await service.post("/users", {
+  body: formData,
+})
+```
+This is achieved by using the [`ensureStringBody`](#ensurestringbody) function internally.
+
+### Query
+The service can also receive an `query` object that can be a `string`, a `URLSearchParams`, or an array of entries and it'll add that to the path as queryString:
+
+```ts
+import { makeService } from 'make-service'
+
+const service = makeService(new URL("https://example.com/api"))
+
+const response = await service.get("/users?admin=true", {
+  query: new URLSearchParams({ page: "2" }),
+})
+
+// It will call "https://example.com/api/users?admin=true&page=2"
+
+// It could also be:
+const response = await service.get("/users?admin=true", {
+  query: [["page", "2"]],
+})
+// or:
+const response = await service.get("/users?admin=true", {
+  query: "page=2",
+})
+```
+This is achieved by using the [`addQueryToURL`](#addquerytourl) function internally.
+
+### Params
+The function can also receive a `params` object that will be used to replace the `:param` wildcards in the path:
+
+```ts
+import { makeService } from 'make-service'
+
+const service = makeService(new URL("https://example.com/api"))
+const response = await service.get("/users/:id/article/:articleId", {
+  params: { id: "2", articleId: "3" },
+})
+
+// It will call "https://example.com/api/users/2/article/3"
+```
+This is achieved by using the [`replaceURLParams`](#replaceurlparams) function internally.
+
+### Trace
+The function can also receive a `trace` function that will be called with the final `url` and `requestInit` arguments.
+Therefore you can know what are the actual arguments that will be passed to the `fetch` API.
+
+```ts
+import { makeService } from 'make-service'
+
+const service = makeService("https://example.com/api")
+const response = await service.get("/users/:id", {
+  params: { id: "2" },
+  query: { page: "2"},
+  headers: { Accept: "application/json" },
+  trace: (url, requestInit) => {
+    console.log("The request was sent to " + url)
+    console.log("with the following params: " + JSON.stringify(requestInit))
+  },
+})
+
+// It will log:
+// "The request was sent to https://example.com/api/users/2?page=2"
+// with the following params: { headers: { "Accept": "application/json", "Content-type": "application/json" } }
+```
+
+## makeFetcher
+This method is the same as [`makeService`](#make-service) but it doesn't expose the HTTP methods as properties of the returned object.
+This is good for when you want to have a service setup but don't know the methods you'll be calling in advance, like in a proxy.
+
+```ts
+import { makeFetcher } from 'make-service'
+
+const fetcher = makeFetcher("https://example.com/api")
+const response = await fetcher("/users", { method: "POST", body: { email: "john@doe.com" } })
+const json = await response.json()
+//    ^? unknown
+```
+
+Other than having to pass the method in the `RequestInit` this is going to have all the features of [`makeService`](#make-service).
 
 ## enhancedFetch
 
-A wrapper around the `fetch` API.
+A wrapper around the `fetch` service.
 It returns a [`TypedResponse`](#typedresponse) instead of a `Response`.
 
 ```ts
@@ -153,22 +331,23 @@ 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 `url` and `requestInit` arguments.
+This function accepts the same arguments as the `fetch` API - with exception of [JSON-like body](#body) -, and it also accepts an object of [`params`](#params) to replace URL wildcards, an object-like [`query`](#query), and a [`trace`](#trace) function. Those are all described above in [`makeService`](#make-service).
 
 This slightly different `RequestInit` is typed as `EnhancedRequestInit`.
 
 ```ts
 import { enhancedFetch } from 'make-service'
 
-await enhancedFetch("https://example.com/api/users", {
+await enhancedFetch("https://example.com/api/users/:role", {
   method: 'POST',
   body: { some: { object: { as: { body } } } },
   query: { page: "1" },
-  trace: (url, requestInit) => console.log(url, requestInit)
+  params: { role: "admin" },
+  trace: console.log,
 })
 
 // The trace function will be called with the following arguments:
-// "https://example.com/api/users?page=1"
+// "https://example.com/api/users/admin?page=1"
 // {
 //   method: 'POST',
 //   body: '{"some":{"object":{"as":{"body":{}}}}}',
@@ -205,5 +384,124 @@ const text = await response.text(z.string().email())
 //    ^? string
 ```
 
+# Other available primitives
+This little library has plenty of other useful functions that you can use to build your own services and interactions with external APIs.
+
+## addQueryToURL
+It receives a URL instance or URL string and an object-like query and returns a new URL with the query appended to it.
+
+It will preserve the original query if it exists and will also preserve the type of the given URL.
+
+```ts
+import { addQueryToURL } from 'make-service'
+
+addQueryToURL("https://example.com/api/users", { page: "2" })
+// https://example.com/api/users?page=2
+
+addQueryToURL(
+  "https://example.com/api/users?role=admin",
+  { page: "2" },
+)
+// https://example.com/api/users?role=admin&page=2
+
+addQueryToURL(
+  new URL("https://example.com/api/users"),
+  { page: "2" },
+)
+// https://example.com/api/users?page=2
+
+addQueryToURL(
+  new URL("https://example.com/api/users?role=admin"),
+  { page: "2" },
+)
+// https://example.com/api/users?role=admin&page=2
+```
+
+## ensureStringBody
+It accepts any value considered a `BodyInit` (the type of the body in `fetch`, such as `ReadableStream` | `XMLHttpRequestBodyInit` | `null`) and also accepts a JSON-like structure such as a number, string, boolean, array or object.
+
+In case it detects a JSON-like structure it will return a stringified version of that payload. Otherwise the type will be preserved.
+
+```ts
+import { ensureStringBody } from 'make-service'
+
+ensureStringBody({ foo: "bar" })
+// '{"foo":"bar"}'
+ensureStringBody("foo")
+// 'foo'
+ensureStringBody(1)
+// '1'
+ensureStringBody(true)
+// 'true'
+ensureStringBody(null)
+// null
+ensureStringBody(new ReadableStream())
+// ReadableStream
+
+// and so on...
+```
+
+## makeGetApiURL
+It creates an URL builder for your API. It works similarly to [`makeFetcher`](#makefetcher) but will return the URL instead of a response.
+
+You create a `getApiURL` function by giving it a `baseURL` and then it accepts a path and an optional [query](#query) that will be merged into the final URL.
+
+```ts
+import { makeGetApiURL } from 'make-service'
+
+const getApiURL = makeGetApiURL("https://example.com/api")
+const url = getApiURL("/users?admin=true", { query: { page: "2" } })
+
+// "https://example.com/api/users?admin=true&page=2"
+```
+
+Notice the extra slashes are gonna be added or removed as needed.
+```ts
+makeGetApiURL("https://example.com/api/")("/users")
+// "https://example.com/api/users"
+makeGetApiURL("https://example.com/api")("users")
+// "https://example.com/api/users"
+```
+
+## mergeHeaders
+It merges multiple `HeadersInit` objects into a single `Headers` instance.
+They can be of any type that is accepted by the `Headers` constructor, like a `Headers` instance, a plain object, or an array of entries.
+
+```ts
+import { mergeHeaders } from 'make-service'
+
+const headers1 = new Headers({ "Content-Type": "application/json" })
+const headers2 = { Accept: "application/json" }
+const headers3 = [["accept", "*/*"]]
+
+const merged = mergeHeaders(headers1, headers2, headers3)
+//    ^? Headers({ "content-Type": "application/json", "accept": "*/*" })
+```
+
+It will delete previous headers if `undefined` or `"undefined"` is given:
+
+```ts
+import { mergeHeaders } from 'make-service'
+
+const headers1 = new Headers({ "Content-Type": "application/json", Accept: "application/json" })
+const headers2 = { accept: undefined }
+const headers3 = [["content-type", "undefined"]]
+
+const merged = mergeHeaders(headers1, headers2, headers3)
+//    ^? Headers({})
+```
+
+## replaceURLParams
+This function replaces URL wildcards with the given params.
+```ts
+import { replaceURLParams } from 'make-service'
+
+const url = replaceURLParams(
+  "https://example.com/users/:id/posts/:postId",
+  { id: "2", postId: "3" },
+)
+// It will return: "https://example.com/users/2/posts/3"
+```
+
 ## Thank you
 I really appreciate your feedback and contributions. If you have any questions, feel free to open an issue or contact me on [Twitter](https://twitter.com/gugaguichard).

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", "CONNECT"];
 
 /**
  * It returns the JSON object or throws an error if the response is not ok.
@@ -23,8 +23,9 @@ type TypedResponse = Omit<Response, 'json' | 'text'> & {
     json: TypedResponseJson;
     text: TypedResponseText;
 };
-type EnhancedRequestInit = Omit<RequestInit, 'body'> & {
-    body?: JSONValue;
+type EnhancedRequestInit = Omit<RequestInit, 'body' | 'method'> & {
+    method?: HTTPMethod | Lowercase<HTTPMethod>;
+    body?: JSONValue | BodyInit | null;
     query?: SearchParams;
     params?: Record<string, string>;
     trace?: (...args: Parameters<typeof fetch>) => void;
@@ -43,27 +44,6 @@ type PathParams<T extends string> = NoEmpty<T extends `${infer _}:${infer Param}
     [K in Param]: string;
 } : {}>;
 
-/**
- * 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 url with the query parameters added with the same type as the 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 | 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
@@ -79,11 +59,6 @@ declare function makeGetApiUrl(baseURL: string | URL): (path: string, searchPara
  * //    ^? User[]
  */
 declare function typedResponse(response: Response): TypedResponse;
-/**
- * @param body the JSON-like body of the request
- * @returns the body stringified if it is not a string
- */
-declare function ensureStringBody(body?: JSONValue): string | undefined;
 /**
  *
  * @param url a string or URL to be fetched
@@ -99,6 +74,18 @@ declare function ensureStringBody(body?: JSONValue): string | undefined;
  * //    ^? unknown
  */
 declare function enhancedFetch(url: string | URL, requestInit?: EnhancedRequestInit): Promise<TypedResponse>;
+/**
+ *
+ * @param baseURL the base URL to be fetched in every request
+ * @param baseHeaders any headers that should be sent with every request
+ * @returns a function that receive a path and requestInit and return a serialized json response that can be typed or not.
+ * @example const headers = { Authorization: "Bearer 123" }
+ * const fetcher = makeFetcher("https://example.com/api", headers);
+ * const response = await fetcher("/users", { method: "GET" })
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ */
+declare function makeFetcher(baseURL: string | URL, baseHeaders?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>)): (path: string, requestInit?: EnhancedRequestInit) => Promise<TypedResponse>;
 /**
  *
  * @param baseURL the base URL to the API
@@ -110,6 +97,36 @@ declare function enhancedFetch(url: string | URL, requestInit?: EnhancedRequestI
  * const users = await response.json(userSchema);
  * //    ^? User[]
  */
-declare function makeService(baseURL: string | URL, baseHeaders?: HeadersInit): Record<"delete" | "get" | "post" | "put" | "patch" | "options" | "head", (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>>;
+declare function makeService(baseURL: string | URL, baseHeaders?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>)): Record<"get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "connect", (path: string, requestInit?: ServiceRequestInit) => Promise<TypedResponse>>;
+
+/**
+ * @param url a string or URL to which the query parameters will be added
+ * @param searchParams the query parameters
+ * @returns the url with the query parameters added with the same type as the url
+ */
+declare function addQueryToURL(url: string | URL, searchParams?: SearchParams): string | URL;
+/**
+ * @param body the JSON-like body of the request
+ * @returns the body is stringified if it is not a string and it is a JSON-like object. It also accepts other types of BodyInit such as Blob, ReadableStream, etc.
+ */
+declare function ensureStringBody<B extends JSONValue | BodyInit | null>(body?: B): B extends JSONValue ? string : B;
+/**
+ * @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<T extends string | URL>(baseURL: T): (path: string, searchParams?: SearchParams) => T;
+/**
+ * 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 the url string or URL object to replace the params
+ * @param params the params map to be replaced in the url
+ * @returns the url with the params replaced and with the same type as the given url
+ */
+declare function replaceURLParams<T extends string | URL>(url: string | URL, params: EnhancedRequestInit['params']): T;
 
-export { EnhancedRequestInit, HTTPMethod, JSONValue, PathParams, Schema, SearchParams, ServiceRequestInit, TypedResponse, TypedResponseJson, TypedResponseText, addQueryToInput, addQueryToUrl, enhancedFetch, ensureStringBody, makeGetApiUrl, makeService, mergeHeaders, typedResponse };
+export { EnhancedRequestInit, HTTPMethod, JSONValue, PathParams, Schema, SearchParams, ServiceRequestInit, TypedResponse, TypedResponseJson, TypedResponseText, addQueryToURL, enhancedFetch, ensureStringBody, makeFetcher, makeGetApiURL, makeService, mergeHeaders, replaceURLParams, typedResponse };

package/dist/index.js

@@ -20,13 +20,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  addQueryToInput: () => addQueryToInput,
-  addQueryToUrl: () => addQueryToUrl,
+  addQueryToURL: () => addQueryToURL,
   enhancedFetch: () => enhancedFetch,
   ensureStringBody: () => ensureStringBody,
-  makeGetApiUrl: () => makeGetApiUrl,
+  makeFetcher: () => makeFetcher,
+  makeGetApiURL: () => makeGetApiURL,
   makeService: () => makeService,
   mergeHeaders: () => mergeHeaders,
+  replaceURLParams: () => replaceURLParams,
   typedResponse: () => typedResponse
 });
 module.exports = __toCommonJS(src_exports);
@@ -39,15 +40,14 @@ var HTTP_METHODS = [
   "DELETE",
   "PATCH",
   "OPTIONS",
-  "HEAD"
+  "HEAD",
+  "CONNECT"
+  // 'TRACE', it has no support in most browsers yet
 ];
 
 // src/internals.ts
 function getJson(response) {
   return async (schema) => {
-    if (!response.ok) {
-      throw new Error(await response.text());
-    }
     const json = await response.json();
     return schema ? schema.parse(json) : json;
   };
@@ -58,32 +58,12 @@ function getText(response) {
     return schema ? schema.parse(text) : text;
   };
 }
-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;
+function typeOf(t) {
+  return Object.prototype.toString.call(t).replace(/^\[object (.+)\]$/, "$1").toLowerCase();
 }
 
-// src/make-service.ts
-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) {
+// src/primitives.ts
+function addQueryToURL(url, searchParams) {
   if (!searchParams)
     return url;
   if (typeof url === "string") {
@@ -99,14 +79,45 @@ function addQueryToUrl(url, searchParams) {
   }
   return url;
 }
-var addQueryToInput = addQueryToUrl;
-function makeGetApiUrl(baseURL) {
+function ensureStringBody(body) {
+  if (typeof body === "undefined")
+    return body;
+  if (typeof body === "string")
+    return body;
+  return ["number", "boolean", "array", "object"].includes(typeOf(body)) ? JSON.stringify(body) : body;
+}
+function makeGetApiURL(baseURL) {
   const base = baseURL instanceof URL ? baseURL.toString() : baseURL;
   return (path, searchParams) => {
-    const url = `${base}${path}`.replace(/([^https?:]\/)\/+/g, "$1");
-    return addQueryToUrl(url, searchParams);
+    const url = `${base}/${path}`.replace(/([^https?:]\/)\/+/g, "$1");
+    return addQueryToURL(url, 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 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/api.ts
 function typedResponse(response) {
   return new Proxy(response, {
     get(target, prop) {
@@ -118,13 +129,6 @@ function typedResponse(response) {
     }
   });
 }
-function ensureStringBody(body) {
-  if (typeof body === "undefined")
-    return;
-  if (typeof body === "string")
-    return body;
-  return JSON.stringify(body);
-}
 async function enhancedFetch(url, requestInit) {
   var _a, _b;
   const { query, trace, ...reqInit } = requestInit != null ? requestInit : {};
@@ -134,42 +138,49 @@ async function enhancedFetch(url, requestInit) {
     },
     (_a = reqInit.headers) != null ? _a : {}
   );
-  const withParams = replaceUrlParams(url, (_b = reqInit.params) != null ? _b : {});
-  const fullUrl = addQueryToUrl(withParams, query);
+  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(fullUrl, enhancedReqInit);
-  const response = await fetch(fullUrl, enhancedReqInit);
+  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 = {}) => {
-      var _a;
-      const url = makeGetApiUrl(baseURL)(path);
-      const response = await enhancedFetch(url, {
-        ...requestInit,
-        method,
-        headers: mergeHeaders(baseHeaders != null ? baseHeaders : {}, (_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {})
-      });
-      return response;
-    };
+function makeFetcher(baseURL, baseHeaders) {
+  return async (path, requestInit = {}) => {
+    var _a;
+    const url = makeGetApiURL(baseURL)(path);
+    const response = await enhancedFetch(url, {
+      ...requestInit,
+      headers: mergeHeaders(
+        typeof baseHeaders === "function" ? await baseHeaders() : baseHeaders != null ? baseHeaders : {},
+        (_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {}
+      )
+    });
+    return response;
   };
-  let api = {};
+}
+function makeService(baseURL, baseHeaders) {
+  const fetcher = makeFetcher(baseURL, baseHeaders);
+  function appliedService(method) {
+    return async (path, requestInit = {}) => fetcher(path, { ...requestInit, method });
+  }
+  let service = {};
   for (const method of HTTP_METHODS) {
     const lowerMethod = method.toLowerCase();
-    api[lowerMethod] = service(method);
+    service[lowerMethod] = appliedService(method);
   }
-  return api;
+  return service;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  addQueryToInput,
-  addQueryToUrl,
+  addQueryToURL,
   enhancedFetch,
   ensureStringBody,
-  makeGetApiUrl,
+  makeFetcher,
+  makeGetApiURL,
   makeService,
   mergeHeaders,
+  replaceURLParams,
   typedResponse
 });

package/dist/index.mjs

@@ -6,15 +6,14 @@ var HTTP_METHODS = [
   "DELETE",
   "PATCH",
   "OPTIONS",
-  "HEAD"
+  "HEAD",
+  "CONNECT"
+  // 'TRACE', it has no support in most browsers yet
 ];
 
 // src/internals.ts
 function getJson(response) {
   return async (schema) => {
-    if (!response.ok) {
-      throw new Error(await response.text());
-    }
     const json = await response.json();
     return schema ? schema.parse(json) : json;
   };
@@ -25,32 +24,12 @@ function getText(response) {
     return schema ? schema.parse(text) : text;
   };
 }
-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;
+function typeOf(t) {
+  return Object.prototype.toString.call(t).replace(/^\[object (.+)\]$/, "$1").toLowerCase();
 }
 
-// src/make-service.ts
-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) {
+// src/primitives.ts
+function addQueryToURL(url, searchParams) {
   if (!searchParams)
     return url;
   if (typeof url === "string") {
@@ -66,14 +45,45 @@ function addQueryToUrl(url, searchParams) {
   }
   return url;
 }
-var addQueryToInput = addQueryToUrl;
-function makeGetApiUrl(baseURL) {
+function ensureStringBody(body) {
+  if (typeof body === "undefined")
+    return body;
+  if (typeof body === "string")
+    return body;
+  return ["number", "boolean", "array", "object"].includes(typeOf(body)) ? JSON.stringify(body) : body;
+}
+function makeGetApiURL(baseURL) {
   const base = baseURL instanceof URL ? baseURL.toString() : baseURL;
   return (path, searchParams) => {
-    const url = `${base}${path}`.replace(/([^https?:]\/)\/+/g, "$1");
-    return addQueryToUrl(url, searchParams);
+    const url = `${base}/${path}`.replace(/([^https?:]\/)\/+/g, "$1");
+    return addQueryToURL(url, 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 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/api.ts
 function typedResponse(response) {
   return new Proxy(response, {
     get(target, prop) {
@@ -85,13 +95,6 @@ function typedResponse(response) {
     }
   });
 }
-function ensureStringBody(body) {
-  if (typeof body === "undefined")
-    return;
-  if (typeof body === "string")
-    return body;
-  return JSON.stringify(body);
-}
 async function enhancedFetch(url, requestInit) {
   var _a, _b;
   const { query, trace, ...reqInit } = requestInit != null ? requestInit : {};
@@ -101,41 +104,48 @@ async function enhancedFetch(url, requestInit) {
     },
     (_a = reqInit.headers) != null ? _a : {}
   );
-  const withParams = replaceUrlParams(url, (_b = reqInit.params) != null ? _b : {});
-  const fullUrl = addQueryToUrl(withParams, query);
+  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(fullUrl, enhancedReqInit);
-  const response = await fetch(fullUrl, enhancedReqInit);
+  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 = {}) => {
-      var _a;
-      const url = makeGetApiUrl(baseURL)(path);
-      const response = await enhancedFetch(url, {
-        ...requestInit,
-        method,
-        headers: mergeHeaders(baseHeaders != null ? baseHeaders : {}, (_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {})
-      });
-      return response;
-    };
+function makeFetcher(baseURL, baseHeaders) {
+  return async (path, requestInit = {}) => {
+    var _a;
+    const url = makeGetApiURL(baseURL)(path);
+    const response = await enhancedFetch(url, {
+      ...requestInit,
+      headers: mergeHeaders(
+        typeof baseHeaders === "function" ? await baseHeaders() : baseHeaders != null ? baseHeaders : {},
+        (_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {}
+      )
+    });
+    return response;
   };
-  let api = {};
+}
+function makeService(baseURL, baseHeaders) {
+  const fetcher = makeFetcher(baseURL, baseHeaders);
+  function appliedService(method) {
+    return async (path, requestInit = {}) => fetcher(path, { ...requestInit, method });
+  }
+  let service = {};
   for (const method of HTTP_METHODS) {
     const lowerMethod = method.toLowerCase();
-    api[lowerMethod] = service(method);
+    service[lowerMethod] = appliedService(method);
   }
-  return api;
+  return service;
 }
 export {
-  addQueryToInput,
-  addQueryToUrl,
+  addQueryToURL,
   enhancedFetch,
   ensureStringBody,
-  makeGetApiUrl,
+  makeFetcher,
+  makeGetApiURL,
   makeService,
   mergeHeaders,
+  replaceURLParams,
   typedResponse
 };

package/package.json

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