make-service 1.1.0 → 2.0.0

package/README.md

@@ -6,18 +6,20 @@ It adds a set of little features and allows you to parse responses with [zod](ht
 
 ## Features
 - 🤩 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.
+- 🚦 Easily setup an API with a `baseURL` and common options like `headers` for every request.
 - 🏗️ Compose URL from the base by just calling the endpoints and an object-like `query`.
 - 🐾 Replaces URL wildcards with a **strongly-typed** 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.
-- 🔥 Transforms responses and payloads back and forth to support interchangeability of casing styles (kebab-case -> camelCase -> snake_case -> kebab-case).
+- 🔥 It can transform responses and payloads back and forth to (e.g.) support interchangeability of casing styles (kebab-case -> camelCase -> snake_case -> kebab-case).
 
 ## Example
 
 ```ts
 const service = makeService("https://example.com/api", {
-  Authorization: "Bearer 123",
+  headers: {
+    Authorization: "Bearer 123",
+  },
 });
 
 const response = await service.get("/users")
@@ -33,9 +35,12 @@ const users = await response.json(usersSchema);
     - [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)
+      - [Passing a function as `headers`](#passing-a-function-as-headers)
       - [Deleting a previously set header](#deleting-a-previously-set-header)
     - [Base URL](#base-url)
+    - [Transformers](#transformers)
+      - [Request transformers](#request-transformers)
+      - [Response transformers](#response-transformers)
     - [Body](#body)
     - [Query](#query)
     - [Params](#params)
@@ -43,7 +48,7 @@ const users = await response.json(usersSchema);
   - [makeFetcher](#makefetcher)
   - [enhancedFetch](#enhancedfetch)
   - [typedResponse](#typedresponse)
-- [Payload transformers](#payload-transformers)
+- [Transform the Payload](#transform-the-payload)
 - [Other available primitives](#other-available-primitives)
   - [addQueryToURL](#addquerytourl)
   - [ensureStringBody](#ensurestringbody)
@@ -68,7 +73,7 @@ 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
-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.
+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 options like `headers` for every request.
 
 This service object can be called with every HTTP method and it will return a [`typedResponse`](#typedresponse).
 
@@ -76,7 +81,9 @@ This service object can be called with every HTTP method and it will return a [`
 import { makeService } from 'make-service'
 
 const service = makeService("https://example.com/api", {
-  authorization: "Bearer 123"
+  headers :{
+    authorization: "Bearer 123",
+  },
 })
 
 const response = await service.get("/users")
@@ -146,15 +153,17 @@ await service.options("/users")
 
 ### 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.
+The `headers` option on `baseOptions` and the `headers` argument will be merged together, with the `headers` argument taking precedence.
 
 ```ts
 import { makeService } from 'make-service'
 
-const service = makeService("https://example.com/api", new Headers({
-  authorization: "Bearer 123",
-  accept: "*/*",
-}))
+const service = makeService("https://example.com/api", {
+  headers: new Headers({
+    authorization: "Bearer 123",
+    accept: "*/*",
+  }),
+})
 
 const response = await service.get("/users", {
   headers: [['accept', 'application/json']],
@@ -164,8 +173,8 @@ const response = await service.get("/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.
+#### Passing a function as `headers`
+The `headers` option on `baseOptions` 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
@@ -173,16 +182,21 @@ import { makeService } from 'make-service'
 
 declare getAuthorizationToken: () => Promise<HeadersInit>
 
-const service = makeService("https://example.com/api", async () => ({
-  authorization: await getAuthorizationToken(),
-}))
+const service = makeService("https://example.com/api", {
+  headers: 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 service = makeService("https://example.com/api", { authorization: "Bearer 123" })
+const service = makeService("https://example.com/api", {
+  headers: { authorization: "Bearer 123" },
+})
+
 const response = await service.get("/users", {
   headers: new Headers({ authorization: 'undefined', "Content-Type": undefined }),
 })
@@ -210,6 +224,37 @@ const response = await service.get("/users?admin=true")
 ```
 You can use the [`makeGetApiUrl`](#makegetapiurl) method to do that kind of URL composition.
 
+### Transformers
+`makeService` can also receive `requestTransformer` and `responseTransformer` as options that will be applied to all requests.
+
+#### Request transformers
+You can transform the request in any way you want, like:
+
+```ts
+const service = makeService('https://example.com/api', {
+  requestTransformer: (request) => ({ ...request, query: { admin: 'true' } }),
+})
+
+const response = await service.get("/users")
+
+// It will call "https://example.com/api/users?admin=true"
+```
+
+Please note that the `headers` option will be applied _after_ the request transformer runs. If you're using a request transformer, we recommend adding custom headers inside your transformer instead of using both options.
+
+#### Response transformers
+You can also transform the response in any way you want, like:
+
+```ts
+const service = makeService('https://example.com/api', {
+  responseTransformer: (response) => ({ ...response, statusText: 'It worked!' }),
+})
+
+const response = await service.get("/users")
+
+// response.statusText will be 'It worked!'
+```
+
 ### Body
 The function can also receive a `body` object that will be stringified and sent as the request body:
 
@@ -392,33 +437,27 @@ const text = await response.text(z.string().email())
 //    ^? string
 ```
 
-# Payload transformers
-The `make-service` library has a few payload transformers that you can use to transform the request body before sending it or the response body after returning from the server.
+# Transform the payload
+The combination of `make-service` and [`string-ts`](https://github.com/gustavoguichard/string-ts) libraries makes it easy to work with APIs that follow a different convention for object key's casing, so you can transform the request body before sending it or the response body after returning from the server.
 The resulting type will be **properly typed** 🤩.
 ```ts
-import { makeService, kebabToCamel, camelToKebab } from 'make-service'
+import { makeService } from 'make-service'
+import { deepCamelKeys, deepKebabKeys } from 'string-ts'
 
 const service = makeService("https://example.com/api")
 const response = service.get("/users")
 const users = await response.json(
   z
     .array(z.object({ "first-name": z.string(), contact: z.object({ "home-address": z.string() }) }))
-    .transform(kebabToCamel)
+    .transform(deepCamelKeys)
 )
 console.log(users)
 //          ^? { firstName: string, contact: { homeAddress: string } }[]
 
-const body = camelToKebab({ firstName: "John", contact: { homeAddress: "123 Main St" } })
+const body = deepKebabKeys({ firstName: "John", contact: { homeAddress: "123 Main St" } })
 //    ^? { "first-name": string, contact: { "home-address": string } }
 service.patch("/users/:id", { body, params: { id: "1" } })
 ```
-The available transformations are:
-- `camelToKebab`: `"someProp" -> "some-prop"`
-- `camelToSnake`: `"someProp" -> "some_prop"`
-- `kebabToCamel`: `"some-prop" -> "someProp"`
-- `kebabToSnake`: `"some-prop" -> "some_prop"`
-- `snakeToCamel`: `"some_prop" -> "someProp"`
-- `snakeToKebab`: `"some_prop" -> "some-prop"`
 
 # 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.

package/dist/index.d.ts

@@ -1,17 +1,5 @@
 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.
- * @param response the Response to be parsed
- * @returns the response.json method that accepts a type or Zod schema for a typed json response
- */
-declare function getJson(response: Response): <T = unknown>(schema?: Schema<T> | undefined) => Promise<T>;
-/**
- * @param response the Response to be parsed
- * @returns the response.text method that accepts a type or Zod schema for a typed response
- */
-declare function getText(response: Response): <T extends string = string>(schema?: Schema<T> | undefined) => Promise<T>;
-
 type Schema<T> = {
     parse: (d: unknown) => T;
 };
@@ -32,9 +20,18 @@ type EnhancedRequestInit<T = string> = Omit<RequestInit, 'body' | 'method'> & {
     trace?: (...args: Parameters<typeof fetch>) => void;
 };
 type ServiceRequestInit<T = string> = Omit<EnhancedRequestInit<T>, 'method'>;
+type RequestTransformer = (request: EnhancedRequestInit) => EnhancedRequestInit | Promise<EnhancedRequestInit>;
+type ResponseTransformer = (response: TypedResponse) => TypedResponse | Promise<TypedResponse>;
+type BaseOptions = {
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    requestTransformer?: RequestTransformer;
+    responseTransformer?: ResponseTransformer;
+};
 type HTTPMethod = (typeof HTTP_METHODS)[number];
-type TypedResponseJson = ReturnType<typeof getJson>;
-type TypedResponseText = ReturnType<typeof getText>;
+type TypedResponseJson = <T = unknown>(schema?: Schema<T>) => Promise<T>;
+type TypedResponseText = <T extends string = string>(schema?: Schema<T>) => Promise<T>;
+type GetJson = (response: Response) => TypedResponseJson;
+type GetText = (response: Response) => TypedResponseText;
 type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
@@ -58,7 +55,10 @@ type ExtractPathParams<T extends string> = T extends `${infer _}:${infer Param}/
  * const typedJson = await response.json<User[]>();
  * //    ^? User[]
  */
-declare function typedResponse(response: Response): TypedResponse;
+declare function typedResponse(response: Response, options?: {
+    getJson?: GetJson;
+    getText?: GetText;
+}): TypedResponse;
 /**
  *
  * @param url a string or URL to be fetched
@@ -77,7 +77,10 @@ declare function enhancedFetch<T extends string | URL>(url: T, requestInit?: Enh
 /**
  *
  * @param baseURL the base URL to be fetched in every request
- * @param baseHeaders any headers that should be sent with every request
+ * @param baseOptions options that will be applied to all requests
+ * @param baseOptions.headers any headers that should be sent with every request
+ * @param baseOptions.requestTransformer a function that will transform the enhanced request init of every request
+ * @param baseOptions.responseTransformer a function that will transform the typed response of 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);
@@ -85,11 +88,14 @@ declare function enhancedFetch<T extends string | URL>(url: T, requestInit?: Enh
  * const users = await response.json(userSchema);
  * //    ^? User[]
  */
-declare function makeFetcher(baseURL: string | URL, baseHeaders?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>)): <T extends string>(path: T, requestInit?: EnhancedRequestInit<T>) => Promise<TypedResponse>;
+declare function makeFetcher(baseURL: string | URL, baseOptions?: BaseOptions): <T extends string>(path: T, requestInit?: EnhancedRequestInit<T>) => Promise<TypedResponse>;
 /**
  *
  * @param baseURL the base URL to the API
- * @param baseHeaders any headers that should be sent with every request
+ * @param baseOptions options that will be applied to all requests
+ * @param baseOptions.headers any headers that should be sent with every request
+ * @param baseOptions.requestTransformer a function that will transform the enhanced request init of every request
+ * @param baseOptions.responseTransformer a function that will transform the typed response of every request
  * @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);
@@ -97,7 +103,7 @@ declare function makeFetcher(baseURL: string | URL, baseHeaders?: HeadersInit |
  * const users = await response.json(userSchema);
  * //    ^? User[]
  */
-declare function makeService(baseURL: string | URL, baseHeaders?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>)): Record<"get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "connect", <T extends string>(path: T, requestInit?: ServiceRequestInit<T>) => Promise<TypedResponse>>;
+declare function makeService(baseURL: string | URL, baseOptions?: BaseOptions): Record<"get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "connect", <T extends string>(path: T, requestInit?: ServiceRequestInit<T>) => Promise<TypedResponse>>;
 
 /**
  * @param url a string or URL to which the query parameters will be added
@@ -129,50 +135,4 @@ declare function mergeHeaders(...entries: (HeadersInit | [string, undefined][] |
  */
 declare function replaceURLParams<T extends string | URL>(url: T, params: PathParams<T>): T;
 
-type KebabToCamel<Str> = Str extends `${infer First}-${infer Rest}` ? `${First}${Capitalize<KebabToCamel<Rest>>}` : Str;
-type SnakeToCamel<Str> = Str extends `${infer First}_${infer Rest}` ? `${First}${Capitalize<SnakeToCamel<Rest>>}` : Str;
-type KebabToSnake<Str> = Str extends `${infer First}-${infer Rest}` ? `${First}_${KebabToSnake<Rest>}` : Str;
-type SnakeToKebab<Str> = Str extends `${infer First}_${infer Rest}` ? `${First}-${SnakeToKebab<Rest>}` : Str;
-type HandleFirstChar<Str> = Str extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : Str;
-type CamelToSnakeFn<Str> = Str extends `${infer First}${infer Rest}` ? `${First extends Capitalize<First> ? '_' : ''}${Lowercase<First>}${CamelToSnakeFn<Rest>}` : Str;
-type CamelToSnake<Str> = CamelToSnakeFn<HandleFirstChar<Str>>;
-type CamelToKebabFn<Str> = Str extends `${infer First}${infer Rest}` ? `${First extends Capitalize<First> ? '-' : ''}${Lowercase<First>}${CamelToKebabFn<Rest>}` : Str;
-type CamelToKebab<Str> = CamelToKebabFn<HandleFirstChar<Str>>;
-type DeepKebabToCamel<T> = T extends [any, ...any] ? {
-    [I in keyof T]: DeepKebabToCamel<T[I]>;
-} : T extends (infer V)[] ? DeepKebabToCamel<V>[] : {
-    [K in keyof T as KebabToCamel<K>]: DeepKebabToCamel<T[K]>;
-};
-declare function kebabToCamel<T>(obj: T): DeepKebabToCamel<T>;
-type DeepSnakeToCamel<T> = T extends [any, ...any] ? {
-    [I in keyof T]: DeepSnakeToCamel<T[I]>;
-} : T extends (infer V)[] ? DeepSnakeToCamel<V>[] : {
-    [K in keyof T as SnakeToCamel<K>]: DeepSnakeToCamel<T[K]>;
-};
-declare function snakeToCamel<T>(obj: T): DeepSnakeToCamel<T>;
-type DeepCamelToSnake<T> = T extends [any, ...any] ? {
-    [I in keyof T]: DeepCamelToSnake<T[I]>;
-} : T extends (infer V)[] ? DeepCamelToSnake<V>[] : {
-    [K in keyof T as CamelToSnake<K>]: DeepCamelToSnake<T[K]>;
-};
-declare function camelToSnake<T>(obj: T): DeepCamelToSnake<T>;
-type DeepCamelToKebab<T> = T extends [any, ...any] ? {
-    [I in keyof T]: DeepCamelToKebab<T[I]>;
-} : T extends (infer V)[] ? DeepCamelToKebab<V>[] : {
-    [K in keyof T as CamelToKebab<K>]: DeepCamelToKebab<T[K]>;
-};
-declare function camelToKebab<T>(obj: T): DeepCamelToKebab<T>;
-type DeepSnakeToKebab<T> = T extends [any, ...any] ? {
-    [I in keyof T]: DeepSnakeToKebab<T[I]>;
-} : T extends (infer V)[] ? DeepSnakeToKebab<V>[] : {
-    [K in keyof T as SnakeToKebab<K>]: DeepSnakeToKebab<T[K]>;
-};
-declare function snakeToKebab<T>(obj: T): DeepSnakeToKebab<T>;
-type DeepKebabToSnake<T> = T extends [any, ...any] ? {
-    [I in keyof T]: DeepKebabToSnake<T[I]>;
-} : T extends (infer V)[] ? DeepKebabToSnake<V>[] : {
-    [K in keyof T as KebabToSnake<K>]: DeepKebabToSnake<T[K]>;
-};
-declare function kebabToSnake<T>(obj: T): DeepKebabToSnake<T>;
-
-export { CamelToKebab, CamelToSnake, DeepCamelToKebab, DeepCamelToSnake, DeepKebabToCamel, DeepKebabToSnake, DeepSnakeToCamel, DeepSnakeToKebab, EnhancedRequestInit, HTTPMethod, JSONValue, KebabToCamel, KebabToSnake, PathParams, Schema, SearchParams, ServiceRequestInit, SnakeToCamel, SnakeToKebab, TypedResponse, TypedResponseJson, TypedResponseText, addQueryToURL, camelToKebab, camelToSnake, enhancedFetch, ensureStringBody, kebabToCamel, kebabToSnake, makeFetcher, makeGetApiURL, makeService, mergeHeaders, replaceURLParams, snakeToCamel, snakeToKebab, typedResponse };
+export { BaseOptions, EnhancedRequestInit, GetJson, GetText, HTTPMethod, JSONValue, PathParams, RequestTransformer, ResponseTransformer, Schema, SearchParams, ServiceRequestInit, TypedResponse, TypedResponseJson, TypedResponseText, addQueryToURL, enhancedFetch, ensureStringBody, makeFetcher, makeGetApiURL, makeService, mergeHeaders, replaceURLParams, typedResponse };

package/dist/index.js

@@ -21,19 +21,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   addQueryToURL: () => addQueryToURL,
-  camelToKebab: () => camelToKebab,
-  camelToSnake: () => camelToSnake,
   enhancedFetch: () => enhancedFetch,
   ensureStringBody: () => ensureStringBody,
-  kebabToCamel: () => kebabToCamel,
-  kebabToSnake: () => kebabToSnake,
   makeFetcher: () => makeFetcher,
   makeGetApiURL: () => makeGetApiURL,
   makeService: () => makeService,
   mergeHeaders: () => mergeHeaders,
   replaceURLParams: () => replaceURLParams,
-  snakeToCamel: () => snakeToCamel,
-  snakeToKebab: () => snakeToKebab,
   typedResponse: () => typedResponse
 });
 module.exports = __toCommonJS(src_exports);
@@ -52,18 +46,14 @@ var HTTP_METHODS = [
 ];
 
 // src/internals.ts
-function getJson(response) {
-  return async (schema) => {
-    const json = await response.json();
-    return schema ? schema.parse(json) : json;
-  };
-}
-function getText(response) {
-  return async (schema) => {
-    const text = await response.text();
-    return schema ? schema.parse(text) : text;
-  };
-}
+var getJson = (response) => async (schema) => {
+  const json = await response.json();
+  return schema ? schema.parse(json) : json;
+};
+var getText = (response) => async (schema) => {
+  const text = await response.text();
+  return schema ? schema.parse(text) : text;
+};
 function typeOf(t) {
   return Object.prototype.toString.call(t).replace(/^\[object (.+)\]$/, "$1").toLowerCase();
 }
@@ -124,13 +114,17 @@ function replaceURLParams(url, params) {
 }
 
 // src/api.ts
-function typedResponse(response) {
+var identity = (value) => value;
+function typedResponse(response, options) {
+  var _a, _b;
+  const getJsonFn = (_a = options == null ? void 0 : options.getJson) != null ? _a : getJson;
+  const getTextFn = (_b = options == null ? void 0 : options.getText) != null ? _b : getText;
   return new Proxy(response, {
     get(target, prop) {
       if (prop === "json")
-        return getJson(target);
+        return getJsonFn(target);
       if (prop === "text")
-        return getText(target);
+        return getTextFn(target);
       return target[prop];
     }
   });
@@ -152,95 +146,51 @@ async function enhancedFetch(url, requestInit) {
   const response = await fetch(fullURL, enhancedReqInit);
   return typedResponse(response);
 }
-function makeFetcher(baseURL, baseHeaders) {
+function makeFetcher(baseURL, baseOptions = {}) {
   return async (path, requestInit = {}) => {
-    var _a;
+    var _a, _b;
+    const { headers } = baseOptions;
+    const requestTransformer = (_a = baseOptions.requestTransformer) != null ? _a : identity;
+    const responseTransformer = (_b = baseOptions.responseTransformer) != null ? _b : identity;
+    const headerTransformer = async (ri) => {
+      var _a2;
+      return {
+        ...ri,
+        headers: mergeHeaders(
+          typeof headers === "function" ? await headers() : headers != null ? headers : {},
+          (_a2 = requestInit == null ? void 0 : requestInit.headers) != null ? _a2 : {}
+        )
+      };
+    };
     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;
+    const response = await enhancedFetch(
+      url,
+      await headerTransformer(await requestTransformer(requestInit))
+    );
+    return responseTransformer(response);
   };
 }
-function makeService(baseURL, baseHeaders) {
-  const fetcher = makeFetcher(baseURL, baseHeaders);
+function makeService(baseURL, baseOptions) {
+  const fetcher = makeFetcher(baseURL, baseOptions);
   function appliedService(method) {
     return async (path, requestInit = {}) => fetcher(path, { ...requestInit, method });
   }
-  let service = {};
+  const service = {};
   for (const method of HTTP_METHODS) {
     const lowerMethod = method.toLowerCase();
     service[lowerMethod] = appliedService(method);
   }
   return service;
 }
-
-// src/transforms.ts
-function words(str) {
-  const matches = str.match(
-    /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g
-  );
-  return matches ? Array.from(matches) : [str];
-}
-function toCamelCase(str) {
-  const result = words(str).map((x) => x.slice(0, 1).toUpperCase() + x.slice(1).toLowerCase()).join("");
-  return result.slice(0, 1).toLowerCase() + result.slice(1);
-}
-function toKebabCase(str) {
-  return words(str).map((x) => x.toLowerCase()).join("-");
-}
-function toSnakeCase(str) {
-  return words(str).map((x) => x.toLowerCase()).join("_");
-}
-function deepTransformKeys(obj, transform) {
-  if (!["object", "array"].includes(typeOf(obj)))
-    return obj;
-  if (Array.isArray(obj)) {
-    return obj.map((x) => deepTransformKeys(x, transform));
-  }
-  const res = {};
-  for (const key in obj) {
-    res[transform(key)] = deepTransformKeys(obj[key], transform);
-  }
-  return res;
-}
-function kebabToCamel(obj) {
-  return deepTransformKeys(obj, toCamelCase);
-}
-function snakeToCamel(obj) {
-  return deepTransformKeys(obj, toCamelCase);
-}
-function camelToSnake(obj) {
-  return deepTransformKeys(obj, toSnakeCase);
-}
-function camelToKebab(obj) {
-  return deepTransformKeys(obj, toKebabCase);
-}
-function snakeToKebab(obj) {
-  return deepTransformKeys(obj, toKebabCase);
-}
-function kebabToSnake(obj) {
-  return deepTransformKeys(obj, toSnakeCase);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addQueryToURL,
-  camelToKebab,
-  camelToSnake,
   enhancedFetch,
   ensureStringBody,
-  kebabToCamel,
-  kebabToSnake,
   makeFetcher,
   makeGetApiURL,
   makeService,
   mergeHeaders,
   replaceURLParams,
-  snakeToCamel,
-  snakeToKebab,
   typedResponse
 });

package/dist/index.mjs

@@ -12,18 +12,14 @@ var HTTP_METHODS = [
 ];
 
 // src/internals.ts
-function getJson(response) {
-  return async (schema) => {
-    const json = await response.json();
-    return schema ? schema.parse(json) : json;
-  };
-}
-function getText(response) {
-  return async (schema) => {
-    const text = await response.text();
-    return schema ? schema.parse(text) : text;
-  };
-}
+var getJson = (response) => async (schema) => {
+  const json = await response.json();
+  return schema ? schema.parse(json) : json;
+};
+var getText = (response) => async (schema) => {
+  const text = await response.text();
+  return schema ? schema.parse(text) : text;
+};
 function typeOf(t) {
   return Object.prototype.toString.call(t).replace(/^\[object (.+)\]$/, "$1").toLowerCase();
 }
@@ -84,13 +80,17 @@ function replaceURLParams(url, params) {
 }
 
 // src/api.ts
-function typedResponse(response) {
+var identity = (value) => value;
+function typedResponse(response, options) {
+  var _a, _b;
+  const getJsonFn = (_a = options == null ? void 0 : options.getJson) != null ? _a : getJson;
+  const getTextFn = (_b = options == null ? void 0 : options.getText) != null ? _b : getText;
   return new Proxy(response, {
     get(target, prop) {
       if (prop === "json")
-        return getJson(target);
+        return getJsonFn(target);
       if (prop === "text")
-        return getText(target);
+        return getTextFn(target);
       return target[prop];
     }
   });
@@ -112,94 +112,50 @@ async function enhancedFetch(url, requestInit) {
   const response = await fetch(fullURL, enhancedReqInit);
   return typedResponse(response);
 }
-function makeFetcher(baseURL, baseHeaders) {
+function makeFetcher(baseURL, baseOptions = {}) {
   return async (path, requestInit = {}) => {
-    var _a;
+    var _a, _b;
+    const { headers } = baseOptions;
+    const requestTransformer = (_a = baseOptions.requestTransformer) != null ? _a : identity;
+    const responseTransformer = (_b = baseOptions.responseTransformer) != null ? _b : identity;
+    const headerTransformer = async (ri) => {
+      var _a2;
+      return {
+        ...ri,
+        headers: mergeHeaders(
+          typeof headers === "function" ? await headers() : headers != null ? headers : {},
+          (_a2 = requestInit == null ? void 0 : requestInit.headers) != null ? _a2 : {}
+        )
+      };
+    };
     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;
+    const response = await enhancedFetch(
+      url,
+      await headerTransformer(await requestTransformer(requestInit))
+    );
+    return responseTransformer(response);
   };
 }
-function makeService(baseURL, baseHeaders) {
-  const fetcher = makeFetcher(baseURL, baseHeaders);
+function makeService(baseURL, baseOptions) {
+  const fetcher = makeFetcher(baseURL, baseOptions);
   function appliedService(method) {
     return async (path, requestInit = {}) => fetcher(path, { ...requestInit, method });
   }
-  let service = {};
+  const service = {};
   for (const method of HTTP_METHODS) {
     const lowerMethod = method.toLowerCase();
     service[lowerMethod] = appliedService(method);
   }
   return service;
 }
-
-// src/transforms.ts
-function words(str) {
-  const matches = str.match(
-    /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g
-  );
-  return matches ? Array.from(matches) : [str];
-}
-function toCamelCase(str) {
-  const result = words(str).map((x) => x.slice(0, 1).toUpperCase() + x.slice(1).toLowerCase()).join("");
-  return result.slice(0, 1).toLowerCase() + result.slice(1);
-}
-function toKebabCase(str) {
-  return words(str).map((x) => x.toLowerCase()).join("-");
-}
-function toSnakeCase(str) {
-  return words(str).map((x) => x.toLowerCase()).join("_");
-}
-function deepTransformKeys(obj, transform) {
-  if (!["object", "array"].includes(typeOf(obj)))
-    return obj;
-  if (Array.isArray(obj)) {
-    return obj.map((x) => deepTransformKeys(x, transform));
-  }
-  const res = {};
-  for (const key in obj) {
-    res[transform(key)] = deepTransformKeys(obj[key], transform);
-  }
-  return res;
-}
-function kebabToCamel(obj) {
-  return deepTransformKeys(obj, toCamelCase);
-}
-function snakeToCamel(obj) {
-  return deepTransformKeys(obj, toCamelCase);
-}
-function camelToSnake(obj) {
-  return deepTransformKeys(obj, toSnakeCase);
-}
-function camelToKebab(obj) {
-  return deepTransformKeys(obj, toKebabCase);
-}
-function snakeToKebab(obj) {
-  return deepTransformKeys(obj, toKebabCase);
-}
-function kebabToSnake(obj) {
-  return deepTransformKeys(obj, toSnakeCase);
-}
 export {
   addQueryToURL,
-  camelToKebab,
-  camelToSnake,
   enhancedFetch,
   ensureStringBody,
-  kebabToCamel,
-  kebabToSnake,
   makeFetcher,
   makeGetApiURL,
   makeService,
   mergeHeaders,
   replaceURLParams,
-  snakeToCamel,
-  snakeToKebab,
   typedResponse
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "make-service",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Some utilities to extend the 'fetch' API to better interact with external APIs.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -15,11 +15,13 @@
     "test": "vitest run"
   },
   "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^6.3.0",
     "eslint": "latest",
-    "jsdom": "^21.1.1",
+    "jsdom": "^22.1.0",
     "prettier": "latest",
+    "string-ts": "^0.4.1",
     "tsup": "^6.7.0",
-    "typescript": "^5.0.4",
+    "typescript": "^5.1.3",
     "vitest": "latest",
     "zod": "latest"
   },