prapti 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kiran Ojha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,153 @@
+![prapti](media/logo.png)
+
+# Prapti 🚀
+
+_"प्राप्ति" (Prapti) - Sanskrit for "fetch" or "obtain"_
+
+> A minimal, type-safe HTTP client that extends the native `fetch` API with runtime schema validation.
+
+```typescript
+// Without Prapti
+const response = await safeFetch("/api/users");
+const data = await response.json(); // any type
+const validatedData = UserSchema.parse(data); // manual validation
+
+// With Prapti
+const { fetch: safeFetch } = createPrapti(adapters.zod);
+const response = await safeFetch("/api/users", {
+  responseSchema: UserSchema,
+});
+const data = await response.json(); // fully typed + validated
+```
+
+## Why switch from `fetch`?
+
+**🎯 Stop writing `any` types**  
+Get automatic TypeScript inference from your schemas. No more manual type assertions.
+
+**🛡️ Catch API breaks at runtime**  
+Validate responses against your schema. Know immediately when APIs change unexpectedly.
+
+**🔧 Eliminate validation boilerplate**  
+No more `schema.parse(await response.json())` on every API call. It's built-in.
+
+**⚡ Drop-in replacement**  
+Same API as `fetch()` with optional superpowers. Add validation only where you need it.
+
+**🎨 Use any validation library**  
+Bring your own: Zod, Valibot, Yup, Joi, or build custom adapters.
+
+## Install
+
+```bash
+npm install prapti zod
+```
+
+## Usage
+
+```typescript
+import { createPrapti, adapters } from "prapti";
+import { z } from "zod";
+
+const UserSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  email: z.string().email(),
+});
+
+// Create client with Zod adapter
+const { fetch: safeFetch } = createPrapti(adapters.zod);
+
+// GET with response validation
+const response = await safeFetch("/api/users/1", {
+  responseSchema: UserSchema,
+});
+const user = await response.json(); // Type: { id: number, name: string, email: string }
+
+// POST with request + response validation
+const CreateUserSchema = UserSchema.omit({ id: true });
+
+const newUser = await safeFetch("/api/users", {
+  method: "POST",
+  body: { name: "John", email: "john@example.com" },
+  requestSchema: CreateUserSchema,
+  responseSchema: UserSchema,
+});
+```
+
+## API
+
+### `Prapti(adapter)`
+
+Main client class. Pass a validation adapter for your schema library.
+
+**Available adapters:**
+
+- `adapters.zod` - for Zod schemas
+
+**Methods:**
+
+- `fetch(url, options)` - Enhanced fetch with validation
+
+### `PraptiOptions`
+
+Standard fetch options plus:
+
+- `requestSchema?` - Schema to validate request body
+- `responseSchema?` - Schema to validate response data
+
+### `ValidatedResponse`
+
+Enhanced Response with validation:
+
+- `json()` - Parse and validate JSON
+- `text()` - Parse and validate text
+- `blob()` - Get blob (no validation)
+- `arrayBuffer()` - Get buffer (no validation)
+- `formData()` - Parse and validate form data
+
+## Custom Adapters
+
+```typescript
+const customAdapter = {
+  parse: <T>(schema: MySchema, data: unknown): T => {
+    return schema.validate(data);
+  },
+};
+
+const { fetch: safeFetch } = createPrapti(customAdapter);
+```
+
+## Error Handling
+
+```typescript
+try {
+  const response = await safeFetch("/api/users", {
+    responseSchema: UserSchema,
+  });
+  const users = await response.json();
+} catch (error) {
+  // Validation errors from your schema library
+  // Network errors from fetch
+}
+```
+
+## Upcoming Features
+
+- 🔄 **Built-in adapters for Valibot, Yup, Joi, AJV**
+- 🎨 **Custom adapter utilities and helpers**
+- 🛡️ **Enhanced error types with validation details**
+- 🎯 **Header validation with schemas**
+- ⚡ **Zero-config TypeScript integration**
+- 📦 **FormData and URLSearchParams validation**
+- 🔄 **Streaming response validation**
+
+## License
+
+MIT
+
+---
+
+<div align="center">
+Made with ❤️ from 🇳🇵
+</div>

package/dist/index.cjs.js

@@ -0,0 +1,110 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  createPrapti: () => createPrapti,
+  adapters: () => adapters,
+  ValidatedResponse: () => ValidatedResponse,
+  Prapti: () => Prapti
+});
+module.exports = __toCommonJS(exports_src);
+
+class ValidatedResponse extends Response {
+  adapter;
+  responseSchema;
+  constructor(response, adapter, responseSchema) {
+    super(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    this.adapter = adapter;
+    this.responseSchema = responseSchema;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  async json() {
+    const data = await super.json();
+    return this.responseSchema ? this.adapter.parse(this.responseSchema, data) : data;
+  }
+  async text() {
+    const data = await super.text();
+    return this.responseSchema ? this.adapter.parse(this.responseSchema, data) : data;
+  }
+  async blob() {
+    return super.blob();
+  }
+  async arrayBuffer() {
+    return super.arrayBuffer();
+  }
+  async formData() {
+    const data = await super.formData();
+    if (this.responseSchema) {
+      const obj = Object.fromEntries(data.entries());
+      this.adapter.parse(this.responseSchema, obj);
+    }
+    return data;
+  }
+}
+
+class Prapti {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async fetch(input, options) {
+    const { requestSchema, responseSchema, body, ...fetchOptions } = options || {};
+    let finalBody;
+    const headers = new Headers(fetchOptions.headers);
+    if (requestSchema && body !== undefined && body !== null) {
+      const parsedBody = typeof body === "string" ? JSON.parse(body) : body;
+      const validatedBody = this.adapter.parse(requestSchema, parsedBody);
+      finalBody = JSON.stringify(validatedBody);
+      if (!headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+      }
+    } else {
+      finalBody = body;
+    }
+    const response = await fetch(input, {
+      ...fetchOptions,
+      headers,
+      body: finalBody
+    });
+    return new ValidatedResponse(response, this.adapter, responseSchema);
+  }
+}
+function createPrapti(adapter) {
+  return new Prapti(adapter);
+}
+var adapters = {
+  zod: {
+    parse: (schema, data) => schema.parse(data)
+  }
+};

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * Prapti - Type-safe HTTP client with schema validation
+ * "प्राप्ति" (Prapti) - Sanskrit for "fetch" or "obtain"
+ */
+/**
+ * Validation adapter interface for different schema libraries
+ * Supports Zod, Valibot, Yup, Joi, and other validation libraries
+ */
+export interface ValidationAdapter<TSchema = unknown> {
+	/**
+	 * Parse and validate data against the provided schema
+	 * @param schema - The validation schema
+	 * @param data - Data to validate
+	 * @returns Validated and typed data
+	 * @throws Validation error if data doesn't match schema
+	 */
+	parse<T>(schema: TSchema, data: unknown): T;
+}
+/**
+ * Type helper to infer output type from various schema formats
+ * Supports multiple validation library conventions
+ */
+export type InferOutput<T> = T extends {
+	_output: infer U;
+} ? U : T extends {
+	_type: infer U;
+} ? U : T extends (...args: any[]) => infer U ? U : unknown;
+/**
+ * Extended fetch options with optional validation schemas
+ * Maintains compatibility with native RequestInit while adding validation
+ */
+export interface PraptiOptions<TRequestSchema = unknown, TResponseSchema = unknown> extends Omit<RequestInit, "body"> {
+	/** Request body - can be any serializable data when using requestSchema */
+	body?: BodyInit | null | unknown;
+	/** Schema to validate request body against */
+	requestSchema?: TRequestSchema;
+	/** Schema to validate response data against */
+	responseSchema?: TResponseSchema;
+}
+/**
+ * Enhanced Response class with validation-aware methods
+ * Extends native Response to provide type-safe data parsing
+ */
+export declare class ValidatedResponse<T = unknown> extends Response {
+	private adapter;
+	private responseSchema?;
+	constructor(response: Response, adapter: ValidationAdapter<any>, responseSchema?: any | undefined);
+	/**
+	 * Parse JSON response and validate with schema if provided
+	 * @returns Promise resolving to validated JSON data
+	 */
+	json(): Promise<T>;
+	/**
+	 * Parse text response and validate with schema if provided
+	 * @returns Promise resolving to validated text data
+	 */
+	text(): Promise<string>;
+	/**
+	 * Get blob response - no validation as it's binary data
+	 * @returns Promise resolving to Blob
+	 */
+	blob(): Promise<Blob>;
+	/**
+	 * Get array buffer response - no validation as it's binary data
+	 * @returns Promise resolving to ArrayBuffer
+	 */
+	arrayBuffer(): Promise<ArrayBuffer>;
+	/**
+	 * Parse form data response and validate with schema if provided
+	 * Note: Validation converts FormData to plain object for schema checking
+	 * @returns Promise resolving to FormData
+	 */
+	formData(): Promise<FormData>;
+}
+/**
+ * Type-safe HTTP client with validation capabilities
+ * Wraps native fetch API with schema validation support
+ */
+export declare class Prapti<TSchema = unknown> {
+	private adapter;
+	/**
+	 * Create a new Prapti instance
+	 * @param adapter - Validation adapter for chosen schema library
+	 */
+	constructor(adapter: ValidationAdapter<TSchema>);
+	/**
+	 * Make an HTTP request with optional request/response validation
+	 * @param input - Request URL or Request object
+	 * @param options - Extended fetch options with validation schemas
+	 * @returns Promise resolving to ValidatedResponse with inferred types
+	 */
+	fetch<TResponseSchema extends TSchema = never>(input: RequestInfo | URL, options?: PraptiOptions<TSchema, TResponseSchema>): Promise<ValidatedResponse<TResponseSchema extends never ? unknown : InferOutput<TResponseSchema>>>;
+}
+/**
+ * Convenience function to create Prapti instance
+ * @param adapter - Validation adapter
+ * @returns New Prapti instance
+ */
+export declare function createPrapti<TSchema>(adapter: ValidationAdapter<TSchema>): Prapti<TSchema>;
+/**
+ * Pre-built adapters for some popular validation libraries
+ * TODO: add more
+ */
+export declare const adapters: {
+	/**
+	 * Zod adapter factory
+	 * @param zod - Zod library import
+	 * @returns ValidationAdapter for Zod schemas
+	 */
+	zod: ValidationAdapter;
+};
+
+export {};

package/dist/index.esm.js

@@ -0,0 +1,79 @@
+// src/index.ts
+class ValidatedResponse extends Response {
+  adapter;
+  responseSchema;
+  constructor(response, adapter, responseSchema) {
+    super(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    this.adapter = adapter;
+    this.responseSchema = responseSchema;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  async json() {
+    const data = await super.json();
+    return this.responseSchema ? this.adapter.parse(this.responseSchema, data) : data;
+  }
+  async text() {
+    const data = await super.text();
+    return this.responseSchema ? this.adapter.parse(this.responseSchema, data) : data;
+  }
+  async blob() {
+    return super.blob();
+  }
+  async arrayBuffer() {
+    return super.arrayBuffer();
+  }
+  async formData() {
+    const data = await super.formData();
+    if (this.responseSchema) {
+      const obj = Object.fromEntries(data.entries());
+      this.adapter.parse(this.responseSchema, obj);
+    }
+    return data;
+  }
+}
+
+class Prapti {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async fetch(input, options) {
+    const { requestSchema, responseSchema, body, ...fetchOptions } = options || {};
+    let finalBody;
+    const headers = new Headers(fetchOptions.headers);
+    if (requestSchema && body !== undefined && body !== null) {
+      const parsedBody = typeof body === "string" ? JSON.parse(body) : body;
+      const validatedBody = this.adapter.parse(requestSchema, parsedBody);
+      finalBody = JSON.stringify(validatedBody);
+      if (!headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+      }
+    } else {
+      finalBody = body;
+    }
+    const response = await fetch(input, {
+      ...fetchOptions,
+      headers,
+      body: finalBody
+    });
+    return new ValidatedResponse(response, this.adapter, responseSchema);
+  }
+}
+function createPrapti(adapter) {
+  return new Prapti(adapter);
+}
+var adapters = {
+  zod: {
+    parse: (schema, data) => schema.parse(data)
+  }
+};
+export {
+  createPrapti,
+  adapters,
+  ValidatedResponse,
+  Prapti
+};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "prapti",
+  "version": "0.0.1",
+  "description": "Type-safe HTTP client with runtime schema validation support for Zod, Valibot, Yup, and more",
+  "files": [
+    "dist/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "types": "dist/index.d.ts",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs.js",
+      "import": "./dist/index.esm.js"
+    }
+  },
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "release": "npx bumpp --commit --push --tag && npm publish",
+    "size": "size-limit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+git@github.com:kiranojhanp/prapti.git"
+  },
+  "keywords": [
+    "prapti",
+    "fetch",
+    "http",
+    "client",
+    "validation",
+    "schema",
+    "typescript",
+    "zod",
+    "valibot",
+    "yup",
+    "joi",
+    "type-safe"
+  ],
+  "author": "Kiran Ojha",
+  "license": "MIT",
+  "bugs": {
+    "url": "git@github.com:kiranojhanp/prapti.git/issues"
+  },
+  "homepage": "git@github.com:kiranojhanp/prapti.git#readme",
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^11.2.0",
+    "@types/bun": "latest",
+    "bun-plugin-dts": "0.3.0",
+    "size-limit": "^11.2.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5",
+    "zod": "^3.25.28"
+  },
+  "size-limit": [
+    {
+      "path": "dist/index.cjs.js",
+      "limit": "5 KB"
+    },
+    {
+      "path": "dist/index.esm.js",
+      "limit": "5 KB"
+    }
+  ]
+}