make-service 0.0.2 → 0.0.3

package/README.md

@@ -40,9 +40,9 @@ This library exports the `makeService` function and some primitives used to buil
 
 # makeService
 
-The main function of this lib is built on top of the primitives described in the following sections. It allows you to create an "API" object with a `baseURL` and common `headers` for every request.
+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 "api" 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) object as it uses the [`enhancedFetch`](#enhancedfetch) internally.
 
 ```ts
 import { makeService } from 'make-service'
@@ -107,7 +107,7 @@ await api.options("/users")
 ## enhancedFetch
 
 A wrapper around the `fetch` API.
-It returns a [`typedResponse`](#typedresponse) instead of a `Response`.
+It returns a [`TypedResponse`](#typedresponse) instead of a `Response`.
 
 ```ts
 import { enhancedFetch } from 'make-service'
@@ -123,6 +123,8 @@ const json = await response.json()
 
 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 slightly different `RequestInit` is typed as `EnhancedRequestInit`.
+
 ```ts
 import { enhancedFetch } from 'make-service'
 
@@ -150,9 +152,10 @@ A type-safe wrapper around the `Response` object. It adds a `json` and `text` me
 
 ```ts
 import { typedResponse } from 'make-service'
+import type { TypedResponse } from 'make-service'
 
 // With JSON
-const response = new Response(JSON.stringify({ foo: "bar" }))
+const response: TypedResponse = new Response(JSON.stringify({ foo: "bar" }))
 const json = await typedResponse(response).json()
 //    ^? unknown
 const json = await typedResponse(response).json<{ foo: string }>()
@@ -161,7 +164,7 @@ const json = await typedResponse(response).json(z.object({ foo: z.string() }))
 //    ^? { foo: string }
 
 // With text
-const response = new Response("foo")
+const response: TypedResponse = new Response("foo")
 const text = await typedResponse(response).text()
 //    ^? string
 const text = await typedResponse(response).text<`foo${string}`>()

package/dist/index.d.ts

@@ -1,10 +1,4 @@
-type Schema<T> = {
-    parse: (d: unknown) => T;
-};
-type JSONValue = string | number | boolean | {
-    [x: string]: JSONValue;
-} | Array<JSONValue>;
-type SearchParams = ConstructorParameters<typeof URLSearchParams>[0];
+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.
@@ -18,6 +12,27 @@ declare function getJson(response: Response): <T = unknown>(schema?: Schema<T> |
  */
 declare function getText(response: Response): <T extends string = string>(schema?: Schema<T> | undefined) => Promise<T>;
 
+type Schema<T> = {
+    parse: (d: unknown) => T;
+};
+type JSONValue = string | number | boolean | {
+    [x: string]: JSONValue;
+} | Array<JSONValue>;
+type SearchParams = ConstructorParameters<typeof URLSearchParams>[0];
+type TypedResponse = Omit<Response, 'json' | 'text'> & {
+    json: TypedResponseJson;
+    text: TypedResponseText;
+};
+type EnhancedRequestInit = Omit<RequestInit, 'body'> & {
+    body?: JSONValue;
+    query?: SearchParams;
+    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>;
+
 /**
  * @param input a string or URL to which the query parameters will be added
  * @param searchParams the query parameters
@@ -43,27 +58,19 @@ declare function makeGetApiUrl(baseURL: string): (path: string, searchParams?: S
  * const typedJson = await response.json<User[]>();
  * //    ^? User[]
  */
-declare function typedResponse(response: Response): Omit<Response, "json" | "text"> & {
-    json: ReturnType<typeof getJson>;
-    text: ReturnType<typeof getText>;
-};
+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;
-type Options = Omit<RequestInit, 'body'> & {
-    body?: JSONValue;
-    query?: SearchParams;
-    trace?: (...args: Parameters<typeof fetch>) => void;
-};
 /**
  *
  * @param input a string or URL to be fetched
- * @param options the options 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 options.body the body of the request. It will be automatically stringified so you can send a JSON-like object
- * @param options.query the query parameters to be added to the URL
- * @param options.trace a function that receives the URL and the requestInit and can be used to log the request
+ * @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
+ * @param requestInit.trace a function that receives the URL and the requestInit and can be used to log the request
  * @returns a Response with typed json and text methods
  * @example const response = await fetch("https://example.com/api/users");
  * const users = await response.json(userSchema);
@@ -71,24 +78,26 @@ type Options = Omit<RequestInit, 'body'> & {
  * const untyped = await response.json();
  * //    ^? unknown
  */
-declare function enhancedFetch(input: string | URL, options?: Options): Promise<Omit<Response, "json" | "text"> & {
-    json: <T = unknown>(schema?: Schema<T> | undefined) => Promise<T>;
-    text: <T_1 extends string = string>(schema?: Schema<T_1> | undefined) => Promise<T_1>;
-}>;
+declare function enhancedFetch(input: string | URL, requestInit?: EnhancedRequestInit): Promise<TypedResponse>;
 /**
  *
  * @param baseURL the base URL to the API
  * @param baseHeaders any headers that should be sent with every request
- * @returns an API object with HTTP methods that are functions that receive a path and options and return a serialized json response that can be typed or not.
+ * @returns a service object with HTTP methods that are functions 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 api = makeService("https://example.com/api", headers);
  * const response = await api.get("/users")
  * const users = await response.json(userSchema);
  * //    ^? User[]
  */
-declare function makeService(baseURL: string, baseHeaders?: HeadersInit): Record<"get" | "post" | "put" | "delete" | "patch" | "options" | "head", (path: string, options?: Omit<Options, 'method'>) => Promise<Omit<Response, "json" | "text"> & {
-    json: <T = unknown>(schema?: Schema<T> | undefined) => Promise<T>;
-    text: <T_1 extends string = string>(schema?: Schema<T_1> | undefined) => Promise<T_1>;
-}>>;
+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>;
+};
 
-export { addQueryToInput, enhancedFetch, ensureStringBody, makeGetApiUrl, makeService, typedResponse };
+export { EnhancedRequestInit, HTTPMethod, JSONValue, Schema, SearchParams, ServiceRequestInit, TypedResponse, TypedResponseJson, TypedResponseText, addQueryToInput, enhancedFetch, ensureStringBody, makeGetApiUrl, makeService, typedResponse };

package/dist/index.js

@@ -94,24 +94,24 @@ function ensureStringBody(body) {
     return body;
   return JSON.stringify(body);
 }
-async function enhancedFetch(input, options) {
-  const { query, trace, ...reqInit } = options != null ? options : {};
+async function enhancedFetch(input, requestInit) {
+  const { query, trace, ...reqInit } = requestInit != null ? requestInit : {};
   const headers = { "content-type": "application/json", ...reqInit.headers };
   const url = addQueryToInput(input, query);
   const body = ensureStringBody(reqInit.body);
-  const requestInit = { ...reqInit, headers, body };
-  trace == null ? void 0 : trace(url, requestInit);
-  const request = new Request(url, requestInit);
+  const enhancedReqInit = { ...reqInit, headers, body };
+  trace == null ? void 0 : trace(url, enhancedReqInit);
+  const request = new Request(url, enhancedReqInit);
   const response = await fetch(request);
   return typedResponse(response);
 }
 function makeService(baseURL, baseHeaders) {
-  const api = (method) => {
-    return async (path, options = {}) => {
+  const service = (method) => {
+    return async (path, requestInit = {}) => {
       const response = await enhancedFetch(`${baseURL}${path}`, {
-        ...options,
+        ...requestInit,
         method,
-        headers: { ...baseHeaders, ...options == null ? void 0 : options.headers }
+        headers: { ...baseHeaders, ...requestInit == null ? void 0 : requestInit.headers }
       });
       return response;
     };
@@ -119,7 +119,7 @@ function makeService(baseURL, baseHeaders) {
   return new Proxy({}, {
     get(_target, prop) {
       if (isHTTPMethod(prop))
-        return api(prop);
+        return service(prop);
       throw new Error(`Invalid HTTP method: ${prop.toString()}`);
     }
   });

package/dist/index.mjs

@@ -63,24 +63,24 @@ function ensureStringBody(body) {
     return body;
   return JSON.stringify(body);
 }
-async function enhancedFetch(input, options) {
-  const { query, trace, ...reqInit } = options != null ? options : {};
+async function enhancedFetch(input, requestInit) {
+  const { query, trace, ...reqInit } = requestInit != null ? requestInit : {};
   const headers = { "content-type": "application/json", ...reqInit.headers };
   const url = addQueryToInput(input, query);
   const body = ensureStringBody(reqInit.body);
-  const requestInit = { ...reqInit, headers, body };
-  trace == null ? void 0 : trace(url, requestInit);
-  const request = new Request(url, requestInit);
+  const enhancedReqInit = { ...reqInit, headers, body };
+  trace == null ? void 0 : trace(url, enhancedReqInit);
+  const request = new Request(url, enhancedReqInit);
   const response = await fetch(request);
   return typedResponse(response);
 }
 function makeService(baseURL, baseHeaders) {
-  const api = (method) => {
-    return async (path, options = {}) => {
+  const service = (method) => {
+    return async (path, requestInit = {}) => {
       const response = await enhancedFetch(`${baseURL}${path}`, {
-        ...options,
+        ...requestInit,
         method,
-        headers: { ...baseHeaders, ...options == null ? void 0 : options.headers }
+        headers: { ...baseHeaders, ...requestInit == null ? void 0 : requestInit.headers }
       });
       return response;
     };
@@ -88,7 +88,7 @@ function makeService(baseURL, baseHeaders) {
   return new Proxy({}, {
     get(_target, prop) {
       if (isHTTPMethod(prop))
-        return api(prop);
+        return service(prop);
       throw new Error(`Invalid HTTP method: ${prop.toString()}`);
     }
   });

package/package.json

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