feat: add fetch[method](url) aliases

src/fetch.ts

@@ -15,6 +15,7 @@ import type {
   ResponseType,
   FetchContext,
   $Fetch,
+  FetchWithAliases,
   FetchRequest,
   FetchOptions,
 } from "./types";
@@ -246,10 +247,10 @@ export function createFetch(globalOptions: CreateFetchOptions = {}): $Fetch {
     return context.response;
   };
 
-  const $fetch = async function $fetch(request, options) {
+  const $fetch: FetchWithAliases = async function $fetch(request, options) {
     const r = await $fetchRaw(request, options);
     return r._data;
-  } as $Fetch;
+  } as FetchWithAliases;
 
   $fetch.raw = $fetchRaw;
 
@@ -266,5 +267,13 @@ export function createFetch(globalOptions: CreateFetchOptions = {}): $Fetch {
       },
     });
 
+  const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+
+  for (const method of methods) {
+    $fetch[method] = (request, options = {}) => {
+      return $fetch(request, { ...options, method: method.toUpperCase() });
+    };
+  }
+
   return $fetch;
 }

src/types.ts

@@ -13,8 +13,50 @@ export interface $Fetch {
   ): Promise<FetchResponse<MappedResponseType<R, T>>>;
   native: Fetch;
   create(defaults: FetchOptions, globalOptions?: CreateFetchOptions): $Fetch;
+  // Method Aliases
+  get<T = any, R extends ResponseType = "json">(
+    request: FetchRequest,
+    options?: FetchOptions<R>
+  ): Promise<MappedResponseType<R, T>>;
+
+  post<T = any, R extends ResponseType = "json">(
+    request: FetchRequest,
+    options?: FetchOptions<R>
+  ): Promise<MappedResponseType<R, T>>;
+
+  put<T = any, R extends ResponseType = "json">(
+    request: FetchRequest,
+    options?: FetchOptions<R>
+  ): Promise<MappedResponseType<R, T>>;
+
+  delete<T = any, R extends ResponseType = "json">(
+    request: FetchRequest,
+    options?: FetchOptions<R>
+  ): Promise<MappedResponseType<R, T>>;
+
+  patch<T = any, R extends ResponseType = "json">(
+    request: FetchRequest,
+    options?: FetchOptions<R>
+  ): Promise<MappedResponseType<R, T>>;
+
+  head<T = any, R extends ResponseType = "json">(
+    request: FetchRequest,
+    options?: FetchOptions<R>
+  ): Promise<MappedResponseType<R, T>>;
+
+  options<T = any, R extends ResponseType = "json">(
+    request: FetchRequest,
+    options?: FetchOptions<R>
+  ): Promise<MappedResponseType<R, T>>;
 }
 
+export type FetchWithAliases = $Fetch & {
+  [method: string]: <T = any, R extends ResponseType = "json">(
+    request: FetchRequest,
+    options?: FetchOptions<R>
+  ) => Promise<MappedResponseType<R, T>>;
+};
+
 // --------------------------
 // Options
 // --------------------------

test/index.test.ts

@@ -510,4 +510,31 @@ describe("ofetch", () => {
     expect(onResponse).toHaveBeenCalledTimes(2);
     expect(onResponseError).toHaveBeenCalledTimes(2);
   });
+
+  it("should support method aliases like get, post, put, etc.", async () => {
+    // Test the GET alias
+    expect(await $fetch.get(getURL("ok"))).to.equal("ok");
+
+    // Test the POST alias
+    const { body: postBody } = await $fetch.post(getURL("post"), {
+      body: { test: "post" },
+    });
+    expect(postBody).to.deep.eq({ test: "post" });
+
+    // Test the PUT alias
+    const { body: putBody } = await $fetch.put(getURL("post"), {
+      body: { test: "put" },
+    });
+    expect(putBody).to.deep.eq({ test: "put" });
+
+    // Test the DELETE alias
+    const deleteResponse = await $fetch.delete(getURL("ok"));
+    expect(deleteResponse).to.equal("ok");
+
+    // Test the PATCH alias
+    const { body: patchBody } = await $fetch.patch(getURL("post"), {
+      body: { test: "patch" },
+    });
+    expect(patchBody).to.deep.eq({ test: "patch" });
+  });
 });