feat: use body instead of data for response payload name

Author: nlf

lib/build/index.ts

@@ -120,7 +120,7 @@ export function generateClientType(server: Server) {
         ok: { name: (+code >= 200 && +code < 300) ? "true" : "false", required: true },
         headers: { name: "Headers", required: true },
         url: { name: "string", required: true },
-        data: { node: generateType(schema as ExtendedObjectSchema), required: isRequired(schema as ExtendedSchema) },
+        body: { node: generateType(schema as ExtendedObjectSchema), required: isRequired(schema as ExtendedSchema) },
       });
       statements.push(typeAliasDeclaration(responseCodeTypeName, responseNode, true));
       responseTypeList.push(responseCodeTypeName);
@@ -139,7 +139,7 @@ export function generateClientType(server: Server) {
       ok: { name: "boolean", required: true },
       headers: { name: "Headers", required: true },
       url: { name: "string", required: true },
-      data: { name: "unknown", required: false },
+      body: { name: "unknown", required: false },
     });
     statements.push(typeAliasDeclaration(unknownResponseName, unknownResponseNode, true));
     responseTypeList.push(unknownResponseName);

lib/index.ts

@@ -6,7 +6,7 @@ import type {
   MatchingRoute,
   RequestMethod,
   ResponseType,
-  ResultType,
+  BodyType,
   Route,
   Simplify,
   StatusCode,
@@ -84,7 +84,7 @@ export class Client<T extends Route> {
         status: injectResponse.statusCode as StatusCode,
         ok: injectResponse.statusCode >= 200 && injectResponse.statusCode < 300,
         headers: new Headers(injectResponse.headers as Record<string, string>),
-        data: isJsonResponse ? JSON.parse(injectResponse.payload) as ResultType<R> : injectResponse.payload,
+        body: isJsonResponse ? JSON.parse(injectResponse.payload) as BodyType<R> : injectResponse.payload,
       };
 
       return response;
@@ -111,7 +111,7 @@ export class Client<T extends Route> {
       status: fetchResponse.status as StatusCode,
       ok: fetchResponse.ok,
       headers: fetchResponse.headers,
-      data: isJsonResponse ? (await fetchResponse.json()) as ResultType<R> : (await fetchResponse.text()),
+      body: isJsonResponse ? (await fetchResponse.json()) as BodyType<R> : (await fetchResponse.text()),
     };
 
     return response;

lib/types.ts

@@ -76,7 +76,7 @@ export type RouteSettings = {
     ok: boolean;
     headers: Headers;
     url: string;
-    data?: unknown;
+    body?: unknown;
   };
 };
 
@@ -116,17 +116,17 @@ export type PayloadType<R extends Route> = R["settings"]["payload"];
  */
 export type ResponseType<R extends Route> = R["settings"]["response"];
 /**
- * Get the result type for a route (this is likely a union)
+ * Get the response body type for a route (this is likely a union)
  */
-export type ResultType<R extends Route> = R["settings"]["response"]["data"];
+export type BodyType<R extends Route> = R["settings"]["response"]["body"];
 /**
  * Get the response type for a route matching a specific status code
  */
 export type SpecificResponseType<R extends Route, S extends StatusCode = StatusCode> = Extract<R["settings"]["response"], { status: S }>;
 /**
- * Get the result type for a route matching a specific status code
+ * Get the response body type for a route matching a specific status code
  */
-export type SpecificResultType<R extends Route, S extends StatusCode = StatusCode> = SpecificResponseType<R, S>["data"];
+export type SpecificBodyType<R extends Route, S extends StatusCode = StatusCode> = SpecificResponseType<R, S>["body"];
 
 /**
  * Get a list of all available paths for a given method on a route union

test/fetch.ts

@@ -1,6 +1,6 @@
 import { test, type TestContext } from "node:test";
 import { server, Client } from "./fixture.ts";
-import type { MatchingRoute, QueryType, SpecificResultType } from "@code4rena/typed-client";
+import type { MatchingRoute, QueryType, SpecificBodyType } from "@code4rena/typed-client";
 import type { Routes } from "./generated.ts";
 
 await test("fetch()", async (t) => {
@@ -44,7 +44,7 @@ await test("fetch()", async (t) => {
     const res = await client.get("/simple");
     t.assert.equal(res.status, 200);
     t.assert.equal(res.url, `${server.info.uri}/simple`);
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 200>>(res.data, { success: true });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 200>>(res.body, { success: true });
   });
 
   await t.test("/query", async (t: TestContext) => {
@@ -53,13 +53,13 @@ await test("fetch()", async (t) => {
     const withoutQueryRes = await client.get("/query");
     t.assert.equal(withoutQueryRes.status, 200);
     t.assert.equal(withoutQueryRes.url, `${server.info.uri}/query`);
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 200>>(withoutQueryRes.data, { flag: false });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 200>>(withoutQueryRes.body, { flag: false });
 
     const query: QueryType<routeType> = { flag: true };
     const withQueryRes = await client.get("/query", { query });
     t.assert.equal(withQueryRes.status, 200);
     t.assert.equal(withQueryRes.url, `${server.info.uri}/query?flag=true`);
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 200>>(withQueryRes.data, { flag: true });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 200>>(withQueryRes.body, { flag: true });
   });
 
   await t.test("/param/{param}", async (t: TestContext) => {
@@ -68,11 +68,11 @@ await test("fetch()", async (t) => {
     const passingRes = await client.get("/param/{param}", { params: { param: "pass" } });
     t.assert.equal(passingRes.status, 200);
     t.assert.equal(passingRes.url, `${server.info.uri}/param/pass`);
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 200>>(passingRes.data, { success: true });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 200>>(passingRes.body, { success: true });
 
     const failingRes = await client.get("/param/{param}", { params: { param: "fail" } });
     t.assert.equal(failingRes.status, 400);
     t.assert.equal(failingRes.url, `${server.info.uri}/param/fail`);
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 400>>(failingRes.data, { success: false, message: "failed" });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 400>>(failingRes.body, { success: false, message: "failed" });
   });
 });

test/inject.ts

@@ -1,6 +1,6 @@
 import { test, type TestContext } from "node:test";
 import { server, Client } from "./fixture.ts";
-import type { MatchingRoute, QueryType, SpecificResultType } from "@code4rena/typed-client";
+import type { MatchingRoute, QueryType, SpecificBodyType } from "@code4rena/typed-client";
 import type { Routes } from "./generated.ts";
 
 await test("GET - server.inject", async (t) => {
@@ -12,7 +12,7 @@ await test("GET - server.inject", async (t) => {
     const res = await client.get("/simple");
     t.assert.equal(res.status, 200);
     t.assert.equal(res.url, "/simple");
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 200>>(res.data, { success: true });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 200>>(res.body, { success: true });
   });
 
   await t.test("/query", async (t: TestContext) => {
@@ -21,13 +21,13 @@ await test("GET - server.inject", async (t) => {
     const withoutQueryRes = await client.get("/query");
     t.assert.equal(withoutQueryRes.status, 200);
     t.assert.equal(withoutQueryRes.url, "/query");
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 200>>(withoutQueryRes.data, { flag: false });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 200>>(withoutQueryRes.body, { flag: false });
 
     const query: QueryType<routeType> = { flag: true };
     const withQueryRes = await client.get("/query", { query });
     t.assert.equal(withQueryRes.status, 200);
     t.assert.equal(withQueryRes.url, "/query?flag=true");
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 200>>(withQueryRes.data, { flag: true });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 200>>(withQueryRes.body, { flag: true });
   });
 
   await t.test("/param/{param}", async (t: TestContext) => {
@@ -36,11 +36,11 @@ await test("GET - server.inject", async (t) => {
     const passingRes = await client.get("/param/{param}", { params: { param: "pass" } });
     t.assert.equal(passingRes.status, 200);
     t.assert.equal(passingRes.url, "/param/pass");
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 200>>(passingRes.data, { success: true });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 200>>(passingRes.body, { success: true });
 
     const failingRes = await client.get("/param/{param}", { params: { param: "fail" } });
     t.assert.equal(failingRes.status, 400);
     t.assert.equal(failingRes.url, "/param/fail");
-    t.assert.deepStrictEqual<SpecificResultType<routeType, 400>>(failingRes.data, { success: false, message: "failed" });
+    t.assert.deepStrictEqual<SpecificBodyType<routeType, 400>>(failingRes.body, { success: false, message: "failed" });
   });
 });