@zap-studio/fetch 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @zap-studio/fetch
 
+## 0.1.1
+
+### Patch Changes
+
+- 5f1812b: Change files field in package.json to distribute only necessary artifacts
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -0,0 +1,169 @@
+# @zap-studio/fetch
+
+A type-safe fetch wrapper with Zod validation for TypeScript.
+
+## Features
+
+- 🎯 **Type-safe requests** with automatic type inference
+- 🛡️ **Runtime validation** using Zod schemas
+- 🔄 **Automatic content-type** detection and handling
+- ⚡️ **Convenient API methods** (GET, POST, PUT, PATCH, DELETE)
+- 📦 **Multiple response types** (JSON, text, blob, arrayBuffer)
+- 🚨 **Custom error handling** with FetchError class
+- 📘 **Full TypeScript support** with zero configuration
+
+## Installation
+
+```bash
+pnpm add @zap-studio/fetch
+#or
+npm install @zap-studio/fetch
+```
+
+## Quick Start
+
+```typescript
+import { z } from "zod";
+import { api } from "@zap-studio/fetch";
+
+// Define your schema
+const UserSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  email: z.email(),
+});
+
+// Make a type-safe request
+const user = await api.get(
+  "https://api.example.com/users/1",
+  UserSchema
+);
+
+// user is fully typed and validated! ✨
+console.log(user.name); // TypeScript knows this is a string
+```
+
+## API
+
+### `api.get(url, schema, options?)`
+
+```typescript
+const user = await api.get("/api/users/1", UserSchema);
+```
+
+### `api.post(url, schema, body?, options?)`
+
+```typescript
+const newUser = await api.post("/api/users", UserSchema, {
+  name: "John Doe",
+  email: "john@example.com",
+});
+```
+
+### `api.put(url, schema, body?, options?)`
+
+```typescript
+const updated = await api.put("/api/users/1", UserSchema, {
+  name: "Jane Doe",
+});
+```
+
+### `api.patch(url, schema, body?, options?)`
+
+```typescript
+const patched = await api.patch("/api/users/1", UserSchema, {
+  email: "newemail@example.com",
+});
+```
+
+### `api.delete(url, schema, options?)`
+
+```typescript
+const deleted = await api.delete("/api/users/1", UserSchema);
+```
+
+## Advanced Usage
+
+### Using `safeFetch` directly
+
+```typescript
+import { safeFetch } from "@zap-studio/fetch";
+
+const result = await safeFetch(
+  "https://api.example.com/users/1",
+  UserSchema,
+  {
+    method: "GET",
+    headers: {
+      "Authorization": "Bearer token",
+    },
+  }
+);
+```
+
+### Custom response types
+
+```typescript
+// Get text response
+const text = await safeFetch(
+  "/api/data",
+  z.string(),
+  { responseType: "text" }
+);
+
+// Get blob response
+const blob = await safeFetch(
+  "/api/file",
+  z.instanceof(Blob),
+  { responseType: "blob" }
+);
+```
+
+### Error handling
+
+```typescript
+import { FetchError } from "@zap-studio/fetch/errors";
+
+try {
+  const user = await api.get("/api/users/1", UserSchema);
+} catch (error) {
+  if (error instanceof FetchError) {
+    console.error(`HTTP ${error.status}: ${error.statusText}`);
+  }
+}
+```
+
+### Flexible validation
+
+```typescript
+// Throw on validation error (default)
+const user = await safeFetch(url, UserSchema, {
+  throwOnValidationError: true,
+});
+
+// Return validation result without throwing
+const result = await safeFetch(url, UserSchema, {
+  throwOnValidationError: false,
+});
+
+if (result.success) {
+  console.log(result.data);
+} else {
+  console.error(result.error);
+}
+```
+
+## Why @zap-studio/fetch?
+
+**Before:**
+```typescript
+const response = await fetch("/api/users/1");
+const data = await response.json();
+const user = data as User; // 😱 Unsafe type assertion
+```
+
+**After:**
+```typescript
+const user = await api.get("/api/users/1", UserSchema);
+// ✨ Typed, validated, and safe!
+```

package/dist/errors/index.d.ts

@@ -0,0 +1,10 @@
+//#region src/errors/index.d.ts
+declare class FetchError extends Error {
+  status: number;
+  statusText: string;
+  response: Response;
+  constructor(message: string, status: number, statusText: string, response: Response);
+}
+//#endregion
+export { FetchError };
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/errors/index.ts"],"sourcesContent":[],"mappings":";cAAa,UAAA,SAAmB,KAAA;EAAnB,MAAA,EAAA,MAAW;EAKL,UAAA,EAAA,MAAA;EAAA,QAAA,EAAA,QAAA;EALa,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,EAAA,QAAA,EAKb,QALa"}

package/dist/errors/index.js

@@ -0,0 +1,3 @@
+import { t as FetchError } from "../errors-DrfSty0J.js";
+
+export { FetchError };

package/dist/errors-DrfSty0J.js

@@ -0,0 +1,14 @@
+//#region src/errors/index.ts
+var FetchError = class extends Error {
+	constructor(message, status, statusText, response) {
+		super(message);
+		this.status = status;
+		this.statusText = statusText;
+		this.response = response;
+		this.name = "FetchError";
+	}
+};
+
+//#endregion
+export { FetchError as t };
+//# sourceMappingURL=errors-DrfSty0J.js.map

package/dist/errors-DrfSty0J.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DrfSty0J.js","names":["status: number","statusText: string","response: Response"],"sources":["../src/errors/index.ts"],"sourcesContent":["export class FetchError extends Error {\n\tconstructor(\n\t\tmessage: string,\n\t\tpublic status: number,\n\t\tpublic statusText: string,\n\t\tpublic response: Response,\n\t) {\n\t\tsuper(message);\n\t\tthis.name = \"FetchError\";\n\t}\n}\n"],"mappings":";AAAA,IAAa,aAAb,cAAgC,MAAM;CACrC,YACC,SACA,AAAOA,QACP,AAAOC,YACP,AAAOC,UACN;AACD,QAAM,QAAQ;EAJP;EACA;EACA;AAGP,OAAK,OAAO"}

package/dist/index-BkzLFXkF.d.ts

@@ -0,0 +1,9 @@
+//#region src/types/index.d.ts
+type FetchConfig<TBody> = Omit<RequestInit, "body"> & {
+  body?: TBody;
+  throwOnValidationError?: boolean;
+};
+type ResponseType = "json" | "text" | "blob" | "arrayBuffer" | "formData";
+//#endregion
+export { ResponseType as n, FetchConfig as t };
+//# sourceMappingURL=index-BkzLFXkF.d.ts.map

package/dist/index-BkzLFXkF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BkzLFXkF.d.ts","names":[],"sources":["../src/types/index.ts"],"sourcesContent":[],"mappings":";KAAY,qBAAqB,KAAK;EAA1B,IAAA,CAAA,EACJ,KADI;EAA0B,sBAAA,CAAA,EAAA,OAAA;CAAL;AACzB,KAII,YAAA,GAJJ,MAAA,GAAA,MAAA,GAAA,MAAA,GAAA,aAAA,GAAA,UAAA"}

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+import { n as ResponseType, t as FetchConfig } from "./index-BkzLFXkF.js";
+import { z } from "zod";
+
+//#region src/index.d.ts
+
+/**
+ * Type-safe fetch wrapper with Zod validation
+ *
+ * @example
+ * import { z } from "zod";
+ * import { safeFetch } from "@zap-studio/fetch";
+ *
+ * const UserSchema = z.object({
+ *   id: z.number(),
+ *   name: z.string(),
+ *   email: z.string().email(),
+ * });
+ *
+ * async function getUser(userId: number) {
+ *   const user = await safeFetch(
+ *     `https://api.example.com/users/${userId}`,
+ *     UserSchema,
+ *     { method: "GET" }
+ *   );
+ *   return user; // user is typed as { id: number; name: string; email: string; }
+ * }
+ */
+declare function safeFetch<TResponse$1, TBody$1 = unknown>(url: string, responseSchema: z.ZodType<TResponse$1>, config?: FetchConfig<TBody$1> & {
+  throwOnValidationError?: true;
+  responseType?: ResponseType;
+}): Promise<TResponse$1>;
+declare function safeFetch<TResponse$1, TBody$1 = unknown>(url: string, responseSchema: z.ZodType<TResponse$1>, config?: FetchConfig<TBody$1> & {
+  throwOnValidationError: false;
+  responseType?: ResponseType;
+}): Promise<ReturnType<typeof responseSchema.safeParse>>;
+/**
+ * Convenience methods for common HTTP verbs
+ *
+ * @example
+ * import { z } from "zod";
+ * import { api } from "@zap-studio/fetch";
+ *
+ * const PostSchema = z.object({
+ *   id: z.number(),
+ *   title: z.string(),
+ *   content: z.string(),
+ * });
+ *
+ * async function fetchPost(postId: number) {
+ *  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+ *   return post; // post is typed as { id: number; title: string; content: string; }
+ * }
+ */
+declare const api: {
+  get: <TResponse>(url: string, schema: z.ZodType<TResponse>, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
+  post: <TResponse, TBody = unknown>(url: string, schema: z.ZodType<TResponse>, body?: TBody, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
+  put: <TResponse, TBody = unknown>(url: string, schema: z.ZodType<TResponse>, body?: TBody, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
+  patch: <TResponse, TBody = unknown>(url: string, schema: z.ZodType<TResponse>, body?: TBody, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
+  delete: <TResponse>(url: string, schema: z.ZodType<TResponse>, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
+};
+//#endregion
+export { api, safeFetch };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;;;;;AASA;;;;;;;;;;AAoHA;AAGoB,iBAhIE,SAgIF,CAAA,WAAA,EAAA,UAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,cAAA,EA9HH,CAAA,CAAE,OA8HC,CA9HO,WA8HP,CAAA,EAAA,MACT,CADS,EA7HV,WA6HU,CA7HE,OA6HF,CAAA,GAAA;EAAR,sBAAA,CAAA,EAAA,IAAA;EACI,YAAA,CAAA,EA5HC,YA4HD;CAAL,CAAA,EA1HR,OA0HQ,CA1HA,WA0HA,CAAA;AAAoC,iBAxHzB,SAwHyB,CAAA,WAAA,EAAA,UAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,cAAA,EAtH9B,CAAA,CAAE,OAsH4B,CAtHpB,WAsHoB,CAAA,EAAA,MAKrC,CALqC,EArHrC,WAqHqC,CArHzB,OAqHyB,CAAA,GAAA;EAAA,sBAAA,EAAA,KAAA;EAK3B,YAAA,CAAA,EAxHH,YAwHG;CAAV,CAAA,EAtHP,OAsHS,CAtHD,UAsHC,CAAA,OAtHiB,cAAA,CAAe,SAsHhC,CAAA,CAAA;;;;;;;;;;;;;;;;;;;AAgBmC,cAzBlC,GAyBkC,EAAA;EAK3B,GAAA,EAAA,CAAA,SAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EA3BV,CAAA,CAAE,OA2BQ,CA3BA,SA2BA,CAAA,EAAA,MAAA,CAAA,EA1BT,IA0BS,CA1BJ,WA0BI,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GA1B2B,OA0B3B,CA1B2B,SA0B3B,CAAA;EAAR,IAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EArBF,CAAA,CAAE,OAqBA,CArBQ,SAqBR,CAAA,EAAA,IAAA,CAAA,EApBH,KAoBG,EAAA,MAAA,CAAA,EAnBD,IAmBC,CAnBI,WAmBJ,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAnBmC,OAmBnC,CAnBmC,SAmBnC,CAAA;EACI,GAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EAfN,CAAA,CAAE,OAeI,CAfI,SAeJ,CAAA,EAAA,IAAA,CAAA,EAdP,KAcO,EAAA,MAAA,CAAA,EAbL,IAaK,CAbA,WAaA,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAb+B,OAa/B,CAb+B,SAa/B,CAAA;EAAL,KAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EARD,CAAA,CAAE,OAQD,CARS,SAQT,CAAA,EAAA,IAAA,CAAA,EAPF,KAOE,EAAA,MAAA,CAAA,EANA,IAMA,CANK,WAML,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GANoC,OAMpC,CANoC,SAMpC,CAAA;EAAoC,MAAA,EAAA,CAAA,SAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EADrC,CAAA,CAAE,OACmC,CAD3B,SAC2B,CAAA,EAAA,MAAA,CAAA,EAApC,IAAoC,CAA/B,WAA+B,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAAA,OAAA,CAAA,SAAA,CAAA;CAAA"}

package/dist/index.js

@@ -0,0 +1,79 @@
+import { t as FetchError } from "./errors-DrfSty0J.js";
+
+//#region src/index.ts
+async function safeFetch(url, responseSchema, config) {
+	const { body, headers, throwOnValidationError = true, responseType = "json",...rest } = config || {};
+	const fetchConfig = {
+		...rest,
+		headers: { ...headers }
+	};
+	if (body !== void 0) {
+		const shouldSetContentType = !headers || typeof headers === "object" && !Array.isArray(headers) && !(headers instanceof Headers) && !("Content-Type" in headers);
+		if (body instanceof FormData) fetchConfig.body = body;
+		else if (typeof body === "string") {
+			fetchConfig.body = body;
+			if (shouldSetContentType) fetchConfig.headers["Content-Type"] = "text/plain";
+		} else {
+			fetchConfig.body = JSON.stringify(body);
+			if (shouldSetContentType) fetchConfig.headers["Content-Type"] = "application/json";
+		}
+	}
+	const response = await fetch(url, fetchConfig);
+	if (!response.ok) throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response.status, response.statusText, response);
+	let data;
+	if (responseType === "json") if (response.headers.get("content-type")?.includes("application/json")) data = await response.json();
+	else throw new FetchError("Expected JSON response but received different content type", response.status, response.statusText, response);
+	else if (responseType === "text") data = await response.text();
+	else if (responseType === "blob") data = await response.blob();
+	else if (responseType === "arrayBuffer") data = await response.arrayBuffer();
+	else if (responseType === "formData") data = await response.formData();
+	if (throwOnValidationError) return responseSchema.parse(data);
+	return responseSchema.safeParse(data);
+}
+/**
+* Convenience methods for common HTTP verbs
+*
+* @example
+* import { z } from "zod";
+* import { api } from "@zap-studio/fetch";
+*
+* const PostSchema = z.object({
+*   id: z.number(),
+*   title: z.string(),
+*   content: z.string(),
+* });
+*
+* async function fetchPost(postId: number) {
+*  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+*   return post; // post is typed as { id: number; title: string; content: string; }
+* }
+*/
+const api = {
+	get: (url, schema, config) => safeFetch(url, schema, {
+		...config,
+		method: "GET"
+	}),
+	post: (url, schema, body, config) => safeFetch(url, schema, {
+		...config,
+		method: "POST",
+		body
+	}),
+	put: (url, schema, body, config) => safeFetch(url, schema, {
+		...config,
+		method: "PUT",
+		body
+	}),
+	patch: (url, schema, body, config) => safeFetch(url, schema, {
+		...config,
+		method: "PATCH",
+		body
+	}),
+	delete: (url, schema, config) => safeFetch(url, schema, {
+		...config,
+		method: "DELETE"
+	})
+};
+
+//#endregion
+export { api, safeFetch };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["fetchConfig: RequestInit","data: unknown"],"sources":["../src/index.ts"],"sourcesContent":["import type { z } from \"zod\";\nimport { FetchError } from \"./errors\";\nimport type { FetchConfig, ResponseType } from \"./types\";\n\n/**\n * Type-safe fetch wrapper with Zod validation\n *\n * @example\n * import { z } from \"zod\";\n * import { safeFetch } from \"@zap-studio/fetch\";\n *\n * const UserSchema = z.object({\n *   id: z.number(),\n *   name: z.string(),\n *   email: z.string().email(),\n * });\n *\n * async function getUser(userId: number) {\n *   const user = await safeFetch(\n *     `https://api.example.com/users/${userId}`,\n *     UserSchema,\n *     { method: \"GET\" }\n *   );\n *   return user; // user is typed as { id: number; name: string; email: string; }\n * }\n */\nexport async function safeFetch<TResponse, TBody = unknown>(\n\turl: string,\n\tresponseSchema: z.ZodType<TResponse>,\n\tconfig?: FetchConfig<TBody> & {\n\t\tthrowOnValidationError?: true;\n\t\tresponseType?: ResponseType;\n\t},\n): Promise<TResponse>;\n\nexport async function safeFetch<TResponse, TBody = unknown>(\n\turl: string,\n\tresponseSchema: z.ZodType<TResponse>,\n\tconfig?: FetchConfig<TBody> & {\n\t\tthrowOnValidationError: false;\n\t\tresponseType?: ResponseType;\n\t},\n): Promise<ReturnType<typeof responseSchema.safeParse>>;\n\nexport async function safeFetch<TResponse, TBody = unknown>(\n\turl: string,\n\tresponseSchema: z.ZodType<TResponse>,\n\tconfig?: FetchConfig<TBody> & { responseType?: ResponseType },\n): Promise<TResponse | ReturnType<typeof responseSchema.safeParse>> {\n\tconst {\n\t\tbody,\n\t\theaders,\n\t\tthrowOnValidationError = true,\n\t\tresponseType = \"json\",\n\t\t...rest\n\t} = config || {};\n\n\tconst fetchConfig: RequestInit = {\n\t\t...rest,\n\t\theaders: {\n\t\t\t...(headers as Record<string, string>),\n\t\t},\n\t};\n\n\t// Only set Content-Type if body exists and it's not FormData\n\tif (body !== undefined) {\n\t\tconst shouldSetContentType =\n\t\t\t!headers ||\n\t\t\t(typeof headers === \"object\" &&\n\t\t\t\t!Array.isArray(headers) &&\n\t\t\t\t!(headers instanceof Headers) &&\n\t\t\t\t!(\"Content-Type\" in headers));\n\n\t\tif (body instanceof FormData) {\n\t\t\tfetchConfig.body = body;\n\t\t} else if (typeof body === \"string\") {\n\t\t\tfetchConfig.body = body;\n\t\t\tif (shouldSetContentType) {\n\t\t\t\t(fetchConfig.headers as Record<string, string>)[\"Content-Type\"] =\n\t\t\t\t\t\"text/plain\";\n\t\t\t}\n\t\t} else {\n\t\t\tfetchConfig.body = JSON.stringify(body);\n\t\t\tif (shouldSetContentType) {\n\t\t\t\t(fetchConfig.headers as Record<string, string>)[\"Content-Type\"] =\n\t\t\t\t\t\"application/json\";\n\t\t\t}\n\t\t}\n\t}\n\n\tconst response = await fetch(url, fetchConfig);\n\n\tif (!response.ok) {\n\t\tthrow new FetchError(\n\t\t\t`HTTP ${response.status}: ${response.statusText}`,\n\t\t\tresponse.status,\n\t\t\tresponse.statusText,\n\t\t\tresponse,\n\t\t);\n\t}\n\n\t// Parse response based on responseType\n\tlet data: unknown;\n\n\tif (responseType === \"json\") {\n\t\tconst contentType = response.headers.get(\"content-type\");\n\t\tif (contentType?.includes(\"application/json\")) {\n\t\t\tdata = await response.json();\n\t\t} else {\n\t\t\tthrow new FetchError(\n\t\t\t\t\"Expected JSON response but received different content type\",\n\t\t\t\tresponse.status,\n\t\t\t\tresponse.statusText,\n\t\t\t\tresponse,\n\t\t\t);\n\t\t}\n\t} else if (responseType === \"text\") {\n\t\tdata = await response.text();\n\t} else if (responseType === \"blob\") {\n\t\tdata = await response.blob();\n\t} else if (responseType === \"arrayBuffer\") {\n\t\tdata = await response.arrayBuffer();\n\t} else if (responseType === \"formData\") {\n\t\tdata = await response.formData();\n\t}\n\n\tif (throwOnValidationError) {\n\t\treturn responseSchema.parse(data);\n\t}\n\n\treturn responseSchema.safeParse(data);\n}\n\n/**\n * Convenience methods for common HTTP verbs\n *\n * @example\n * import { z } from \"zod\";\n * import { api } from \"@zap-studio/fetch\";\n *\n * const PostSchema = z.object({\n *   id: z.number(),\n *   title: z.string(),\n *   content: z.string(),\n * });\n *\n * async function fetchPost(postId: number) {\n *  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);\n *   return post; // post is typed as { id: number; title: string; content: string; }\n * }\n */\nexport const api = {\n\tget: <TResponse>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"GET\" }),\n\n\tpost: <TResponse, TBody = unknown>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tbody?: TBody,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"POST\", body }),\n\n\tput: <TResponse, TBody = unknown>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tbody?: TBody,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"PUT\", body }),\n\n\tpatch: <TResponse, TBody = unknown>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tbody?: TBody,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"PATCH\", body }),\n\n\tdelete: <TResponse>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"DELETE\" }),\n};\n"],"mappings":";;;AA4CA,eAAsB,UACrB,KACA,gBACA,QACmE;CACnE,MAAM,EACL,MACA,SACA,yBAAyB,MACzB,eAAe,OACf,GAAG,SACA,UAAU,EAAE;CAEhB,MAAMA,cAA2B;EAChC,GAAG;EACH,SAAS,EACR,GAAI,SACJ;EACD;AAGD,KAAI,SAAS,QAAW;EACvB,MAAM,uBACL,CAAC,WACA,OAAO,YAAY,YACnB,CAAC,MAAM,QAAQ,QAAQ,IACvB,EAAE,mBAAmB,YACrB,EAAE,kBAAkB;AAEtB,MAAI,gBAAgB,SACnB,aAAY,OAAO;WACT,OAAO,SAAS,UAAU;AACpC,eAAY,OAAO;AACnB,OAAI,qBACH,CAAC,YAAY,QAAmC,kBAC/C;SAEI;AACN,eAAY,OAAO,KAAK,UAAU,KAAK;AACvC,OAAI,qBACH,CAAC,YAAY,QAAmC,kBAC/C;;;CAKJ,MAAM,WAAW,MAAM,MAAM,KAAK,YAAY;AAE9C,KAAI,CAAC,SAAS,GACb,OAAM,IAAI,WACT,QAAQ,SAAS,OAAO,IAAI,SAAS,cACrC,SAAS,QACT,SAAS,YACT,SACA;CAIF,IAAIC;AAEJ,KAAI,iBAAiB,OAEpB,KADoB,SAAS,QAAQ,IAAI,eAAe,EACvC,SAAS,mBAAmB,CAC5C,QAAO,MAAM,SAAS,MAAM;KAE5B,OAAM,IAAI,WACT,8DACA,SAAS,QACT,SAAS,YACT,SACA;UAEQ,iBAAiB,OAC3B,QAAO,MAAM,SAAS,MAAM;UAClB,iBAAiB,OAC3B,QAAO,MAAM,SAAS,MAAM;UAClB,iBAAiB,cAC3B,QAAO,MAAM,SAAS,aAAa;UACzB,iBAAiB,WAC3B,QAAO,MAAM,SAAS,UAAU;AAGjC,KAAI,uBACH,QAAO,eAAe,MAAM,KAAK;AAGlC,QAAO,eAAe,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;AAqBtC,MAAa,MAAM;CAClB,MACC,KACA,QACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAO,CAAC;CAEzD,OACC,KACA,QACA,MACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAQ;EAAM,CAAC;CAEhE,MACC,KACA,QACA,MACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAO;EAAM,CAAC;CAE/D,QACC,KACA,QACA,MACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAS;EAAM,CAAC;CAEjE,SACC,KACA,QACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAU,CAAC;CAC5D"}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { n as ResponseType, t as FetchConfig } from "../index-BkzLFXkF.js";
+export { FetchConfig, ResponseType };

package/dist/types/index.js

@@ -0,0 +1 @@
+export {  };

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@zap-studio/fetch",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "dependencies": {
     "zod": "^4.1.12"
   },
@@ -15,9 +20,9 @@
     "tsdown": "latest",
     "typescript": "latest",
     "vitest": "latest",
-    "@zap-studio/typescript-config": "0.0.0",
+    "@zap-studio/tsdown-config": "0.0.0",
     "@zap-studio/vitest-config": "0.0.0",
-    "@zap-studio/tsdown-config": "0.0.0"
+    "@zap-studio/typescript-config": "0.0.0"
   },
   "exports": {
     ".": "./dist/index.js",

package/src/errors/index.ts

@@ -1,11 +0,0 @@
-export class FetchError extends Error {
-	constructor(
-		message: string,
-		public status: number,
-		public statusText: string,
-		public response: Response,
-	) {
-		super(message);
-		this.name = "FetchError";
-	}
-}

package/src/index.ts

@@ -1,126 +0,0 @@
-import type { z } from "zod";
-import { FetchError } from "./errors";
-import type { FetchConfig, ResponseType } from "./types";
-import { parseResponse, prepareHeadersAndBody } from "./utils";
-
-/**
- * Type-safe fetch wrapper with Zod validation
- *
- * @example
- * import { z } from "zod";
- * import { safeFetch } from "@zap-studio/fetch";
- *
- * const UserSchema = z.object({
- *   id: z.number(),
- *   name: z.string(),
- *   email: z.string().email(),
- * });
- *
- * async function getUser(userId: number) {
- *   const user = await safeFetch(
- *     `https://api.example.com/users/${userId}`,
- *     UserSchema,
- *     { method: "GET" }
- *   );
- *   return user; // user is typed as { id: number; name: string; email: string; }
- * }
- */
-export async function safeFetch<
-	TResponse,
-	TBody = unknown,
-	TResponseType extends ResponseType = "json",
->(
-	resource: string,
-	responseSchema: z.ZodType<TResponse>,
-	config?: FetchConfig<TBody> & {
-		throwOnValidationError?: boolean;
-		responseType?: TResponseType;
-	},
-): Promise<
-	TResponse | z.ZodSafeParseSuccess<TResponse> | z.ZodSafeParseError<TResponse>
-> {
-	const {
-		body,
-		headers,
-		throwOnValidationError = true,
-		responseType = "json" as TResponseType,
-		...rest
-	} = config || {};
-
-	const { body: preparedBody, headers: preparedHeaders } =
-		prepareHeadersAndBody(body, headers);
-
-	const response = await fetch(resource, {
-		...rest,
-		body: preparedBody,
-		headers: preparedHeaders,
-	});
-
-	if (!response.ok) {
-		throw new FetchError(
-			`HTTP ${response.status}: ${response.statusText}`,
-			response.status,
-			response.statusText,
-			response,
-		);
-	}
-
-	const data = await parseResponse(response, responseType);
-
-	return throwOnValidationError
-		? responseSchema.parse(data)
-		: responseSchema.safeParse(data);
-}
-
-/**
- * Convenience methods for common HTTP verbs
- *
- * @example
- * import { z } from "zod";
- * import { api } from "@zap-studio/fetch";
- *
- * const PostSchema = z.object({
- *   id: z.number(),
- *   title: z.string(),
- *   content: z.string(),
- * });
- *
- * async function fetchPost(postId: number) {
- *  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
- *   return post; // post is typed as { id: number; title: string; content: string; }
- * }
- */
-export const api = {
-	get: <TResponse>(
-		resource: string,
-		schema: z.ZodType<TResponse>,
-		options?: Omit<RequestInit, "method" | "body">,
-	) => safeFetch(resource, schema, { ...options, method: "GET" }),
-
-	post: <TResponse, TBody = unknown>(
-		resource: string,
-		schema: z.ZodType<TResponse>,
-		body?: TBody,
-		options?: Omit<RequestInit, "method" | "body">,
-	) => safeFetch(resource, schema, { ...options, method: "POST", body }),
-
-	put: <TResponse, TBody = unknown>(
-		resource: string,
-		schema: z.ZodType<TResponse>,
-		body?: TBody,
-		options?: Omit<RequestInit, "method" | "body">,
-	) => safeFetch(resource, schema, { ...options, method: "PUT", body }),
-
-	patch: <TResponse, TBody = unknown>(
-		resource: string,
-		schema: z.ZodType<TResponse>,
-		body?: TBody,
-		options?: Omit<RequestInit, "method" | "body">,
-	) => safeFetch(resource, schema, { ...options, method: "PATCH", body }),
-
-	delete: <TResponse>(
-		resource: string,
-		schema: z.ZodType<TResponse>,
-		options?: Omit<RequestInit, "method" | "body">,
-	) => safeFetch(resource, schema, { ...options, method: "DELETE" }),
-};

package/src/types/index.ts

@@ -1,23 +0,0 @@
-export type FetchConfig<TBody> = Omit<RequestInit, "body"> & {
-	body?: TBody;
-	throwOnValidationError?: boolean;
-};
-
-export type ResponseType =
-	| "arrayBuffer"
-	| "blob"
-	| "bytes"
-	| "clone"
-	| "formData"
-	| "json"
-	| "text";
-
-export type ResponseTypeMap = {
-	arrayBuffer: ArrayBuffer;
-	blob: Blob;
-	bytes: Uint8Array;
-	clone: Response;
-	formData: FormData;
-	json: unknown;
-	text: string;
-};