Make reviver and parse dates options work together. Add new functional helpers. Update readme.

ejsmith · ejsmith · commit 43e3e6917a9c · 2025-01-07T19:26:46.000-06:00
diff --git a/deno.json b/deno.json
@@ -11,8 +11,9 @@
   },
   "imports": {
     "@deno/dnt": "jsr:@deno/dnt@^0.41.3",
-    "@std/assert": "jsr:@std/assert@^1.0.9",
-    "@std/path": "jsr:@std/path@^1.0.8"
+    "@std/assert": "jsr:@std/assert@^1.0.10",
+    "@std/path": "jsr:@std/path@^1.0.8",
+    "zod": "npm:zod@^3.24.1"
   },
   "exclude": ["npm"]
 }
diff --git a/deno.lock b/deno.lock
diff --git a/readme.md b/readme.md
@@ -3,11 +3,11 @@
 
 FetchClient is a library that makes it easier to use the fetch API for JSON APIs. It provides the following features:
 
-* Makes fetch easier to use for JSON APIs
-* Automatic model validation
-* Caching
-* Middleware
-* Problem Details support
+* [Makes fetch easier to use for JSON APIs](#typed-response)
+* [Automatic model validation](#model-validator)
+* [Caching](#caching)
+* [Middleware](#middleware)
+* [Problem Details](https://www.rfc-editor.org/rfc/rfc9457.html) support
 * Option to parse dates in responses
 
 ## Install
@@ -22,7 +22,7 @@ npm install --save @exceptionless/fetchclient
 
 ## Usage
 
-Get a typed JSON response:
+### Typed Response
 
 ```ts
 import { FetchClient } from '@exceptionless/fetchclient';
@@ -39,23 +39,23 @@ const response = await client.getJSON<Products>(
 const products = response.data;
 ```
 
-Get a typed JSON response using a function:
+### Typed Response Using a Function
 
 ```ts
-import { useFetchClient } from '@exceptionless/fetchclient';
+import { getJSON } from '@exceptionless/fetchclient';
 
 type Products = {
   products: Array<{ id: number; name: string }>;
 };
 
-const response = await useFetchClient().getJSON<Products>(
+const response = await getJSON<Products>(
   `https://dummyjson.com/products/search?q=iphone&limit=10`,
 );
 
 const products = response.data;
 ```
 
-Use a model validator:
+### Model Validator
 
 ```ts
 import { FetchClient, setModelValidator } from '@exceptionless/fetchclient';
@@ -89,7 +89,7 @@ if (!response.ok) {
 }
 ```
 
-Use caching:
+### Caching
 
 ```ts
 import { FetchClient } from '@exceptionless/fetchclient';
@@ -109,7 +109,7 @@ const response = await client.getJSON<Todo>(
 client.cache.delete(["todos", "1"]);
 ```
 
-Use middleware:
+### Middleware
 
 ```ts
 import { FetchClient, useMiddleware } from '@exceptionless/fetchclient';
@@ -139,7 +139,7 @@ Also, take a look at the tests:
 Run tests:
 
 ```shell
-deno test --allow-net
+deno run test
 ```
 
 Lint code:
@@ -157,7 +157,7 @@ deno fmt
 Type check code:
 
 ```shell
-deno check scripts/*.ts *.ts src/*.ts
+deno run check
 ```
 
 ## License
diff --git a/src/DefaultHelpers.ts b/src/DefaultHelpers.ts
@@ -5,19 +5,99 @@ import {
   defaultInstance as defaultProvider,
   type FetchClientProvider,
 } from "./FetchClientProvider.ts";
+import type { FetchClientResponse } from "./FetchClientResponse.ts";
 import type { ProblemDetails } from "./ProblemDetails.ts";
-import type { RequestOptions } from "./RequestOptions.ts";
+import type { GetRequestOptions, RequestOptions } from "./RequestOptions.ts";
 
 let getCurrentProviderFunc: () => FetchClientProvider | null = () => null;
 
 /**
- * Gets a FetchClient instance.
+ * Gets a FetchClient instance from the current provider.
  * @returns The FetchClient instance.
  */
 export function useFetchClient(options?: FetchClientOptions): FetchClient {
   return getCurrentProvider().getFetchClient(options);
 }
 
+/**
+ * Sends a GET request to the specified URL using the default client and provider and returns the response as JSON.
+ * @param url - The URL to send the GET request to.
+ * @param options - Optional request options.
+ * @returns A promise that resolves to the response as JSON.
+ */
+export function getJSON<T>(
+  url: string,
+  options?: GetRequestOptions,
+): Promise<FetchClientResponse<T>> {
+  return useFetchClient().getJSON(url, options);
+}
+
+/**
+ * Sends a POST request with JSON payload using the default client and provider to the specified URL.
+ *
+ * @template T - The type of the response data.
+ * @param {string} url - The URL to send the request to.
+ * @param {object | string | FormData} [body] - The JSON payload or form data to send with the request.
+ * @param {RequestOptions} [options] - Additional options for the request.
+ * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ */
+export function postJSON<T>(
+  url: string,
+  body?: object | string | FormData,
+  options?: RequestOptions,
+): Promise<FetchClientResponse<T>> {
+  return useFetchClient().postJSON(url, body, options);
+}
+
+/**
+ * Sends a PUT request with JSON payload using the default client and provider to the specified URL.
+ *
+ * @template T - The type of the response data.
+ * @param {string} url - The URL to send the request to.
+ * @param {object | string} [body] - The JSON payload to send with the request.
+ * @param {RequestOptions} [options] - Additional options for the request.
+ * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ */
+export function putJSON<T>(
+  url: string,
+  body?: object | string,
+  options?: RequestOptions,
+): Promise<FetchClientResponse<T>> {
+  return useFetchClient().putJSON(url, body, options);
+}
+
+/**
+ * Sends a PATCH request with JSON payload using the default client and provider to the specified URL.
+ *
+ * @template T - The type of the response data.
+ * @param {string} url - The URL to send the request to.
+ * @param {object | string} [body] - The JSON payload to send with the request.
+ * @param {RequestOptions} [options] - Additional options for the request.
+ * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ */
+export function patchJSON<T>(
+  url: string,
+  body?: object | string,
+  options?: RequestOptions,
+): Promise<FetchClientResponse<T>> {
+  return useFetchClient().patchJSON(url, body, options);
+}
+
+/**
+ * Sends a DELETE request with JSON payload using the default client and provider to the specified URL.
+ *
+ * @template T - The type of the response data.
+ * @param {string} url - The URL to send the request to.
+ * @param {RequestOptions} [options] - Additional options for the request.
+ * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ */
+export function deleteJSON<T>(
+  url: string,
+  options?: RequestOptions,
+): Promise<FetchClientResponse<T>> {
+  return useFetchClient().deleteJSON(url, options);
+}
+
 /**
  * Gets the current FetchClientProvider.
  * @returns The current FetchClientProvider.
diff --git a/src/FetchClient.test.ts b/src/FetchClient.test.ts
@@ -2,12 +2,13 @@ import { assert, assertEquals, assertFalse, assertRejects } from "@std/assert";
 import {
   FetchClient,
   type FetchClientContext,
+  getJSON,
   ProblemDetails,
   setBaseUrl,
   useFetchClient,
 } from "../mod.ts";
 import { FetchClientProvider } from "./FetchClientProvider.ts";
-import { z, type ZodTypeAny } from "https://deno.land/x/zod@v3.23.8/mod.ts";
+import { z, type ZodTypeAny } from "zod";
 
 export const TodoSchema = z.object({
   userId: z.number(),
@@ -32,7 +33,7 @@ Deno.test("can getJSON", async () => {
 });
 
 Deno.test("can use function", async () => {
-  const res = await useFetchClient().getJSON<Products>(
+  const res = await getJSON<Products>(
     `https://dummyjson.com/products/search?q=iphone&limit=10`,
   );
 
@@ -662,6 +663,52 @@ Deno.test("can use reviver", async () => {
   assert(res.data.completedTime instanceof Date);
 });
 
+Deno.test("can parse dates and use reviver", async () => {
+  const provider = new FetchClientProvider();
+  const fakeFetch = (): Promise<Response> =>
+    new Promise((resolve) => {
+      const data = JSON.stringify({
+        userId: 1,
+        id: 1,
+        title: "A random title",
+        completed: false,
+        completedTime: "2021-01-01T00:00:00.000Z",
+      });
+      resolve(new Response(data));
+    });
+
+  provider.fetch = fakeFetch;
+
+  const api = provider.getFetchClient();
+
+  let res = await api.getJSON<Todo>(
+    `https://jsonplaceholder.typicode.com/todos/1`,
+  );
+
+  assertEquals(res.status, 200);
+  assert(res.data);
+  assertEquals(res.data.title, "A random title");
+  assertFalse(res.data.completedTime instanceof Date);
+
+  res = await api.getJSON<Todo>(
+    `https://jsonplaceholder.typicode.com/todos/1`,
+    {
+      shouldParseDates: true,
+      reviver: (key: string, value: unknown) => {
+        if (key === "title") {
+          return "revived";
+        }
+        return value;
+      },
+    },
+  );
+
+  assertEquals(res.status, 200);
+  assert(res.data);
+  assertEquals(res.data.title, "revived");
+  assert(res.data.completedTime instanceof Date);
+});
+
 Deno.test("can use kitchen sink", async () => {
   let called = false;
   let optionsCalled = false;
diff --git a/src/FetchClient.ts b/src/FetchClient.ts
@@ -520,13 +520,11 @@ export class FetchClient {
   ): Promise<FetchClientResponse<T>> {
     let data = null;
     try {
-      if (options.reviver) {
+      if (options.reviver || options.shouldParseDates) {
         const body = await response.text();
-        data = JSON.parse(body, options.reviver);
-      } else if (options.shouldParseDates) {
-        // TODO: Combine reviver and shouldParseDates into a single function
-        const body = await response.text();
-        data = JSON.parse(body, this.parseDates);
+        data = JSON.parse(body, (key, value) => {
+          return this.reviveJsonValue(options, key, value);
+        });
       } else {
         data = await response.json();
       }
@@ -554,7 +552,25 @@ export class FetchClient {
     return jsonResponse;
   }
 
-  private parseDates(this: unknown, _key: string, value: unknown): unknown {
+  private reviveJsonValue(
+    options: RequestOptions,
+    key: string,
+    value: unknown,
+  ): unknown {
+    let revivedValued = value;
+
+    if (options.reviver) {
+      revivedValued = options.reviver.call(this, key, revivedValued);
+    }
+
+    if (options.shouldParseDates) {
+      revivedValued = this.tryParseDate(key, revivedValued);
+    }
+
+    return revivedValued;
+  }
+
+  private tryParseDate(_key: string, value: unknown): unknown {
     if (typeof value !== "string") {
       return value;
     }
