@arkyn/server 3.0.1-beta.20 → 3.0.1-beta.201

package/README.md

@@ -1,116 +1,472 @@
-The `@arkyn/server` package provides utilities and services to streamline backend application development. It includes API configurations, HTTP error handlers, and various services for file manipulation.
+# @arkyn/server
 
----
+Comprehensive server-side utilities for building robust backend applications, featuring HTTP response helpers, error handlers, request utilities, and API configurations.
 
-## Installation
+[![npm version](https://img.shields.io/npm/v/@arkyn/server.svg)](https://www.npmjs.com/package/@arkyn/server)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
 
-Install the package using npm:
+## 🎯 What it solves
+
+Backend code — Remix/React Router loaders and actions, or any fetch-based server — tends to reinvent the same plumbing on every project: consistent success/error response shapes, centralized error handling, request body/form parsing, schema validation, and validation of Brazilian documents (CPF/CNPJ/CEP/RG) plus generic fields (email/password/phone/date). `@arkyn/server` packages all of that into small, well-typed primitives so route handlers stay focused on business logic instead of response boilerplate.
+
+## ✨ Features
+
+- 🌐 **HTTP success responses** - `Success`, `Created`, `Updated`, `Found`, `NoContent` with `.toResponse()` / `.toJson()`
+- 🚨 **HTTP error responses** - `BadRequest`, `Unauthorized`, `Forbidden`, `NotFound`, `Conflict`, `UnprocessableEntity`, `ServerError`, `BadGateway`, `NotImplemented`
+- 🧵 **Request utilities** - body decoding, scoped query params, form parsing (sync/async), error-message extraction
+- 🧪 **Schema validation via Zod** - `SchemaValidator` and the underlying `formParse` / `formAsyncParse` helpers
+- 🇧🇷 **Brazilian document validators** - `validateCpf`, `validateCnpj`, `validateCep`, `validateRg`
+- 🔤 **Generic validators** - `validateEmail`, `validatePassword`, `validatePhone`, `validateDate`
+- 🛠️ **Debug & logging services** - `DebugService`, `LogService`, `flushDebugLogs`, plus `ApiService` for outbound HTTP calls
+
+## 📋 Prerequisites
+
+- **Node.js** `>=24.16.0` or **Bun** `>=1.3.14`
+- Peer dependencies (install alongside `@arkyn/server`):
+  - `zod >=4.4.3` — required by `SchemaValidator`, `formParse`, and `formAsyncParse`.
+  - `libphonenumber-js >=1.13.7` — required by `validatePhone`.
+
+## 📦 Installation
+
+> **ESM only.** This package ships as native ES modules with no CommonJS build — use `import`, not `require()`.
 
 ```bash
-npm install @arkyn/server
+npm install @arkyn/server zod libphonenumber-js
+```
+
+## 🚀 Quick Start
+
+```typescript
+import { Success, BadRequest, errorHandler, decodeRequestBody } from "@arkyn/server";
+
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    const body = await decodeRequestBody(request);
+
+    if (!body.email) throw new BadRequest("Email is required");
+
+    const user = await createUser(body);
+    return new Success("User created", { user }).toJson();
+  } catch (error) {
+    return errorHandler(error);
+  }
+}
+```
+
+## 📖 API Reference
+
+### HTTP Responses
+
+Every response class extends a base with `.toResponse()` (returns a `Response` with a `Content-Type: application/json` header) and `.toJson()` (built on `Response.json()`). Both produce an equivalent JSON body — pick whichever reads better at the call site. `NoContent` only exposes `.toResponse()`, since it always returns a `null` body.
+
+#### BadGateway
+
+HTTP 502 — the upstream server returned an invalid or unexpected response.
+
+```typescript
+throw new BadGateway("Payment gateway unavailable");
+```
+
+#### BadRequest
+
+HTTP 400 — the request is malformed or contains invalid data.
+
+```typescript
+throw new BadRequest("Invalid request body");
+```
+
+#### Conflict
+
+HTTP 409 — the request conflicts with the current state of the server (e.g. duplicate record).
+
+```typescript
+throw new Conflict("Email already in use");
+```
+
+#### Forbidden
+
+HTTP 403 — authenticated but not authorized to access this resource.
+
+```typescript
+throw new Forbidden("You don't have permission to delete this resource");
+```
+
+#### NotFound
+
+HTTP 404 — the requested resource does not exist.
+
+```typescript
+throw new NotFound("Product not found");
 ```
 
----
+#### NotImplemented
 
-## Features
+HTTP 501 — the server does not support the functionality required to fulfill the request.
 
-### Settings
+```typescript
+throw new NotImplemented("Webhook delivery is not yet implemented");
+```
 
-- **`ApiInstance`**  
-  Pre-configured instance for API calls.
+#### ServerError
 
-- **`ArkynLogInstance`**  
-  Pre-configured instance for integration with Inbox Flow.
+HTTP 500 — an unexpected condition prevented the server from fulfilling the request.
 
----
+```typescript
+throw new ServerError("Failed to connect to the database");
+```
 
-### HTTP Responses - Errors
+#### Unauthorized
 
-- **`BadGateway(message: string): Error`**  
-  Represents an HTTP 502 error.
+HTTP 401 — the request lacks valid authentication credentials.
 
-- **`BadRequest(message: string): Error`**  
-  Represents an HTTP 400 error.
+```typescript
+throw new Unauthorized("Invalid or expired token");
+```
 
-- **`Conflict(message: string): Error`**  
-  Represents an HTTP 409 error.
+#### UnprocessableEntity
 
-- **`Forbidden(message: string): Error`**  
-  Represents an HTTP 403 error.
+HTTP 422 — the request is well-formed but contains semantic validation errors. Typically used for form field validation failures.
 
-- **`NotFound(message: string): Error`**  
-  Represents an HTTP 404 error.
+```typescript
+throw new UnprocessableEntity({
+  message: "Validation failed",
+  fieldErrors: { email: "Invalid email format", age: "Must be 18 or older" },
+  fields: { email: "not-an-email", age: "15" },
+});
+```
 
-- **`NotImplemented(message: string): Error`**  
-  Represents an HTTP 501 error.
+#### Created
 
-- **`ServerError(message: string): Error`**  
-  Represents an HTTP 500 error.
+HTTP 201 — the request succeeded and a new resource was created.
 
-- **`Unauthorized(message: string): Error`**  
-  Represents an HTTP 401 error.
+```typescript
+return new Created("User created successfully", { id: user.id }).toJson();
+```
 
-- **`UnprocessableEntity(message: string): Error`**  
-  Represents an HTTP 422 error.
+#### Found
 
----
+HTTP 302 — the resource was located and the response includes it in the body.
 
-### HTTP Responses - Success
+```typescript
+return new Found("Products retrieved", { products }).toJson();
+```
 
-- **`Created(data: any): Response`**  
-  Represents an HTTP 201 response.
+#### NoContent
 
-- **`Found(data: any): Response`**  
-  Represents an HTTP 302 response.
+HTTP 204 — the request succeeded but there is no content to return. Typically used for delete or update operations where a body is not needed.
 
-- **`NoContent(): Response`**  
-  Represents an HTTP 204 response.
+```typescript
+return new NoContent("Record deleted").toResponse();
+```
+
+#### Success
+
+HTTP 200 — the request succeeded and the response body contains the result.
+
+```typescript
+return new Success("Order fetched", { order }).toJson();
+```
 
-- **`Success(data: any): Response`**  
-  Represents an HTTP 200 response.
+#### Updated
 
-- **`Updated(data: any): Response`**  
-  Represents an HTTP 200 response for updates.
+HTTP 200 — the request succeeded and the resource was updated. Semantically equivalent to `Success` but signals an update operation to consumers.
 
----
+```typescript
+return new Updated("Profile updated", { user }).toJson();
+```
 
 ### Services
 
-- **`decodeErrorMessageFromRequest(request: Request): string`**  
-  Decodes error messages from a request.
+#### ApiService
 
-- **`decodeRequestBody(request: Request): any`**  
-  Decodes the body of a request.
+HTTP client for external API calls. Wraps `fetch` with a base URL, default headers, an optional auth token, and per-request overrides for `get`, `post`, `put`, `patch`, and `delete`.
 
-- **`errorHandler(error: Error): Response`**  
-  Handles errors and returns an appropriate response.
+```typescript
+const api = new ApiService({
+  baseUrl: "https://api.example.com",
+  baseToken: session.token,
+  enableDebug: true,
+});
 
-- **`formParse(request: Request): FormData`**  
-  Parses form data.
+const { data } = await api.get("/users/me");
+const { data: created } = await api.post("/orders", { body: { productId: 1 } });
+```
 
-- **`getCaller(): string`**  
-  Returns the name of the function that invoked the method.
+#### DebugService
 
-- **`getScopedParams(request: Request): URLSearchParams`**  
-  Retrieves scoped parameters from a request.
+Static service that manages stack-trace configuration for debug output, allowing specific adapter/wrapper files to be skipped so logs show the actual business-logic caller. Used internally by the HTTP response classes; `setIgnoreFile` / `clearIgnoreFiles` let you tune it, and `getCaller()` returns `{ functionName, callerInfo }`.
 
-- **`httpDebug(request: Request): void`**  
-  Displays debug information for an HTTP request.
+```typescript
+// Skip httpAdapter.ts so debug output shows the calling route instead
+DebugService.setIgnoreFile("httpAdapter.ts");
+```
 
-- **`SchemaValidator(schema: any, data: any): boolean`**  
-  Validates data against a schema.
+#### LogService
 
-- **`sendFileToS3(file: File, config: AwsConfig): Promise<{ url: string }>`**  
-  Uploads a file to AWS S3.
+Static service for log endpoint configuration. Stores a singleton configuration containing the traffic source identifier, user token, and log ingestion URL; `setConfig` only applies on the first call, `getConfig` reads it back, and `resetConfig` clears it.
+
+```typescript
+LogService.setConfig({
+  trafficSourceId: "my-app",
+  userToken: session.token,
+});
+
+LogService.getConfig(); // { trafficSourceId, userToken, apiUrl }
+```
+
+### Utilities
+
+#### decodeRequestBody
+
+Decodes a request body into a plain object, trying JSON first then URL-encoded form data. Throws `BadRequest` if neither format can be parsed.
+
+```typescript
+export async function action({ request }: ActionFunctionArgs) {
+  const body = await decodeRequestBody(request);
+  // body is now a plain JS object
+}
+```
+
+#### decodeRequestErrorMessage
+
+Extracts a human-readable error message from an API response body or a `Response` object. Checks `data.message`, `data.operator_erro_message`, `data.error`, `data.error.message`, and `response.statusText` in that order, falling back to `"Missing error message"`.
+
+```typescript
+const res = await fetch("/api/orders");
+const data = await res.json().catch(() => null);
+const message = decodeRequestErrorMessage(data, res);
+```
+
+#### errorHandler
+
+Converts any thrown value into a `Response`. Recognizes all `@arkyn/server` success and error response classes, native `Response` objects, and falls back to a 500 `ServerError` for anything else. Intended to be used as the catch handler of a route action or loader.
+
+```typescript
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    const user = await findUser(id);
+    if (!user) throw new NotFound("User not found");
+    return new Success("User retrieved", { user }).toJson();
+  } catch (error) {
+    return errorHandler(error);
+  }
+}
+```
 
----
+#### flushDebugLogs
 
-## Contribution
+Writes colored `[name] message` lines to the console, but only when `NODE_ENV === "development"` or `DEBUG_MODE === "true"`. No-op in production.
+
+```typescript
+flushDebugLogs({
+  name: "API",
+  scheme: "cyan",
+  debugs: ["POST /api/users", "Status: 201"],
+});
+```
+
+#### formAsyncParse
+
+Async variant of `formParse` — uses `safeParseAsync` to support Zod schemas with async refinements. Returns `{ success: true, data }` on success or `{ success: false, fieldErrors, fields }` on failure.
+
+```typescript
+const schema = z.object({ email: z.string().email() });
+const result = await formAsyncParse([{ email: "bad" }, schema]);
+
+if (!result.success) {
+  console.log(result.fieldErrors); // { email: "Invalid email" }
+}
+```
+
+#### formParse
+
+Validates form data against a Zod schema synchronously. Returns `{ success: true, data }` on success or `{ success: false, fieldErrors, fields }` on failure.
+
+```typescript
+const schema = z.object({ name: z.string().min(1, "Required"), age: z.number().min(18) });
+const result = formParse([{ name: "", age: 15 }, schema]);
+
+if (!result.success) {
+  console.log(result.fieldErrors); // { name: "Required", age: "..." }
+}
+```
+
+#### getScopedParams
+
+Extracts URL search parameters from a request, optionally filtered by a namespace prefix (e.g. `scope:key` → `key`). Without a scope, returns all search params as-is.
+
+```typescript
+// URL: /products?table:page=2&table:sort=asc&other=1
+const params = getScopedParams(request, "table");
+params.get("page"); // "2"
+params.get("sort"); // "asc"
+```
+
+#### SchemaValidator
+
+Wraps a Zod schema with convenience validation methods suited for server-side use: `isValid` (boolean check, never throws), `safeValidate` (raw Zod result, never throws), `validate` (throws `ServerError`, for trusted/internal data), and `formValidate` / `formAsyncValidate` (throw `UnprocessableEntity` with structured field errors, for user-submitted forms).
+
+```typescript
+const validator = new SchemaValidator(z.object({ email: z.string().email() }));
+
+// Inside a Remix action:
+const body = validator.formValidate(await decodeRequestBody(request));
+```
+
+### Validators
+
+#### validateCep
+
+Validates a Brazilian CEP (postal code). A valid CEP must contain exactly 8 numeric digits, optionally formatted as `"12345-678"`.
+
+```typescript
+validateCep("12345-678"); // true
+validateCep("12345678"); // true
+validateCep("ABCDE-123"); // false
+```
+
+#### validateCnpj
+
+Validates a Brazilian CNPJ (Cadastro Nacional da Pessoa Jurídica) number: sanitizes non-digit characters, checks length (14 digits), rejects repeating-digit sequences, and verifies both check digits.
+
+```typescript
+validateCnpj("12.345.678/0001-95"); // false
+validateCnpj("11.444.777/0001-61"); // true
+```
+
+#### validateCpf
+
+Validates a Brazilian CPF number. Strips formatting, checks length, rejects repeated-digit sequences, and verifies both check digits with the CPF algorithm.
+
+```typescript
+validateCpf("123.456.789-09"); // false
+validateCpf("111.444.777-35"); // true
+```
+
+#### validateDate
+
+Validates a date string against a format and optional year bounds. `inputFormat` accepts `"brazilianDate"` (`DD/MM/YYYY`, default), `"isoDate"` (`MM-DD-YYYY`), or `"timestamp"` (`YYYY-MM-DD`); `minYear` defaults to `1900` and `maxYear` to `3000`.
+
+```typescript
+validateDate("31/12/2023"); // true
+validateDate("2023-12-31", { inputFormat: "timestamp", minYear: 2000, maxYear: 2100 }); // true
+validateDate("29/02/2023"); // false (not a leap year)
+```
+
+#### validateEmail
+
+Validates an email address comprehensively: basic format, advanced RFC 5322 syntax rules, and DNS resolution (MX/A/AAAA records) of the domain. Async because of the DNS lookup.
+
+```typescript
+await validateEmail("user@gmail.com"); // true
+await validateEmail("user@gmil.com"); // false (invalid domain)
+await validateEmail("invalid-email"); // false (invalid format)
+```
+
+#### validatePassword
+
+Validates a password: at least 8 characters, at least 1 uppercase letter, at least 1 letter, at least 1 number, and at least 1 special character.
+
+```typescript
+validatePassword("Senha@123"); // true
+validatePassword("senha123"); // false (no uppercase, no special char)
+```
+
+#### validatePhone
+
+Validates an international phone number using `libphonenumber-js`, then confirms the parsed country code is present in the supported countries list.
+
+```typescript
+validatePhone("+5532912345678"); // true (Brazil)
+validatePhone("+55329123456178"); // false (invalid)
+```
+
+#### validateRg
+
+Validates a Brazilian RG (Registro Geral) with a generic structural check: removes non-alphanumeric characters, requires a length of 7–9 characters, and optionally allows a trailing letter verifier.
+
+```typescript
+validateRg("12.345.678-9"); // true
+validateRg("MG-12.345.678"); // false (not supported)
+validateRg("12345678X"); // true
+```
+
+## 🔧 Advanced Usage
+
+### Parse → validate → respond pipeline
+
+```typescript
+import {
+  decodeRequestBody,
+  SchemaValidator,
+  Success,
+  errorHandler,
+} from "@arkyn/server";
+import { z } from "zod";
+
+const createUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(2),
+});
+
+const userValidator = new SchemaValidator(createUserSchema);
+
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    const body = await decodeRequestBody(request);
+
+    // Throws UnprocessableEntity with fieldErrors/fields on failure
+    const data = userValidator.formValidate(body);
+
+    const user = await createUser(data);
+    return new Success("User created", { user }).toJson();
+  } catch (error) {
+    return errorHandler(error);
+  }
+}
+```
+
+### Brazilian document validation before persisting
+
+```typescript
+import {
+  decodeRequestBody,
+  validateCpf,
+  validateEmail,
+  UnprocessableEntity,
+  Created,
+  errorHandler,
+} from "@arkyn/server";
+
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    const body = await decodeRequestBody(request);
+    const fieldErrors: Record<string, string> = {};
+
+    if (!validateCpf(body.cpf)) fieldErrors.cpf = "Invalid CPF";
+    if (!(await validateEmail(body.email))) fieldErrors.email = "Invalid email";
+
+    if (Object.keys(fieldErrors).length > 0) {
+      throw new UnprocessableEntity({
+        message: "Validation failed",
+        fieldErrors,
+        fields: body,
+      });
+    }
+
+    const customer = await createCustomer(body);
+    return new Created("Customer created", { customer }).toJson();
+  } catch (error) {
+    return errorHandler(error);
+  }
+}
+```
 
-Contributions are welcome! Feel free to open issues or submit pull requests to improve the project.
+## 📚 Documentation
 
----
+Full documentation: [https://docs.arkyn.dev/docs/server/introduction](https://docs.arkyn.dev/docs/server/introduction)
 
-## License
+## 📄 License
 
-This project is licensed under the Apache 2.0 License. See the `LICENSE` file for more details.
+This project is licensed under the Apache 2.0 License - see the [LICENSE](./LICENSE.txt) file for details.

package/dist/{api/arkynLogRequest.d.ts → http/api/_logRequest.d.ts}

@@ -13,25 +13,28 @@ type ConfigProps = {
 /**
  * Sends a request to the inbox flow API with the provided configuration.
  *
- * @param config - The configuration object for the request.
- * @param config.rawUrl - The raw URL of the request.
- * @param config.status - The HTTP status code associated with the request.
- * @param config.method - The HTTP method used for the request. Can be "POST", "GET", "PUT", "DELETE", or "PATCH".
- * @param config.token - The authentication token for the request.
- * @param config.elapsedTime - The elapsed time for the request in milliseconds.
- * @param config.requestHeaders - The headers sent with the request.
- * @param config.requestBody - The body of the request, if applicable.
- * @param config.queryParams - The query parameters for the request.
- * @param config.responseHeaders - The headers received in the response.
- * @param config.responseBody - The body of the response received.
- *
- * @remarks
- * - This function retrieves the inbox flow configuration using `InboxFlowInstance.getInboxConfig()`.
+ * - This function retrieves the inbox flow configuration using `LogService.getConfig()`.
  * - If the configuration is not available, the function will return early without performing any action.
  * - In a development environment (`NODE_ENV === "development"`), the function will also return early.
  * - The request is sent as a POST request to the inbox API URL with the provided configuration details.
  * - If an error occurs during the request, it will be logged using the `httpDebug` service.
  *
+ * @param {ConfigProps} config - The configuration object for the request.
+ * @param {string} config.rawUrl - The raw URL of the request.
+ * @param {number} config.status - The HTTP status code associated with the request.
+ * @param {"GET" | "POST" | "PUT" | "DELETE" | "PATCH"} config.method - The HTTP method used for the request. Can be "POST", "GET", "PUT", "DELETE", or "PATCH".
+ * @param {string | null} config.token - The authentication token for the request.
+ * @param {number} config.elapsedTime - The elapsed time for the request in milliseconds.
+ * @param {Record<string, string>} config.requestHeaders - The headers sent with the request.
+ * @param {Record<string, string>} config.requestBody - The body of the request, if applicable.
+ * @param {Record<string, string>} config.queryParams - The query parameters for the request.
+ * @param {Record<string, string>} config.responseHeaders - The headers received in the response.
+ * @param {Record<string, string>} config.responseBody - The body of the response received.
+ *
+ * @remarks
+ *
+ * @returns {Promise<void>} A promise that resolves when the request is complete.
+ *
  * @example
  * ```typescript
  * const config = {
@@ -39,7 +42,7 @@ type ConfigProps = {
  *   status: 200,
  *   method: "GET",
  *   token: "auth-token-123",
- *   elapsedTime: "150ms",
+ *   elapsedTime: 150,
  *   requestHeaders: { "Accept": "application/json", "Authorization": "Bearer token123" },
  *   requestBody: {},
  *   queryParams: { "page": "1", "limit": "10" },
@@ -47,9 +50,9 @@ type ConfigProps = {
  *   responseBody: { "data": "example response" }
  * };
  *
- * await arkynLogRequest(config);
+ * await logRequest(config);
  * ```
  */
-declare function arkynLogRequest(config: ConfigProps): Promise<void>;
-export { arkynLogRequest };
-//# sourceMappingURL=arkynLogRequest.d.ts.map
+declare function logRequest(config: ConfigProps): Promise<void>;
+export { logRequest };
+//# sourceMappingURL=_logRequest.d.ts.map

package/dist/{api/arkynLogRequest.d.ts.map → http/api/_logRequest.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"arkynLogRequest.d.ts","sourceRoot":"","sources":["../../src/api/arkynLogRequest.ts"],"names":[],"mappings":"AAGA,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,iBAAe,eAAe,CAAC,MAAM,EAAE,WAAW,iBA0DjD;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"_logRequest.d.ts","sourceRoot":"","sources":["../../../src/http/api/_logRequest.ts"],"names":[],"mappings":"AAIA,KAAK,WAAW,GAAG;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,iBAAe,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA6E5D;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/http/api/_makeRequest.d.ts

@@ -0,0 +1,61 @@
+type InputProps = {
+    url: string;
+    method: "POST" | "PUT" | "DELETE" | "PATCH" | "GET";
+    urlParams?: Record<string, string>;
+    headers?: HeadersInit;
+    body?: any;
+};
+type ApiSuccessResponse<T = any> = {
+    success: true;
+    status: number;
+    message: string;
+    response: T;
+    cause: null;
+};
+type ApiFailedResponse = {
+    success: false;
+    status: number;
+    message: string;
+    response: any;
+    cause: string | Error | null;
+};
+type ApiResponseDTO<T = any> = ApiSuccessResponse<T> | ApiFailedResponse;
+/**
+ * Makes an HTTP request using the Fetch API and returns a standardized response.
+ *
+ * @template {any} T - The expected type of the response data.
+ *
+ * @param {"POST" | "PUT" | "DELETE" | "PATCH" | "GET"} method - The HTTP method to use for the request. Supported methods are:
+ *   - "POST": Create a new resource.
+ *   - "PUT": Update an existing resource.
+ *   - "DELETE": Remove a resource.
+ *   - "PATCH": Partially update a resource.
+ *   - "GET": Retrieve a resource.
+ * @param {string} url - The URL to which the request is sent.
+ * @param {HeadersInit} headers - Optional headers to include in the request. Defaults to an empty object.
+ * @param {any} body - Optional body to include in the request. Should be serializable to JSON.
+ *
+ * @returns {ApiResponseDTO<T>} A promise that resolves to an `ApiResponseDTO<T>` object containing:
+ *   - `success`: A boolean indicating whether the request was successful.
+ *   - `status`: The HTTP status code of the response.
+ *   - `message`: A message describing the result of the request.
+ *   - `response`: The parsed JSON response data, or `null` if parsing fails.
+ *   - `cause`: Additional error information, if applicable.
+ *
+ * @example
+ * ```typescript
+ * import { makeRequest } from "./makeRequest";
+ *
+ * async function fetchData() {
+ *   const response = await makeRequest("GET", "https://api.example.com/data");
+ *   if (response.success) {
+ *     console.log("Data:", response.response);
+ *   } else {
+ *     console.error("Error:", response.message);
+ *   }
+ * }
+ * ```
+ */
+declare function makeRequest<T = any>(input: InputProps): Promise<ApiResponseDTO<T>>;
+export { type ApiResponseDTO, makeRequest };
+//# sourceMappingURL=_makeRequest.d.ts.map

package/dist/http/api/_makeRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_makeRequest.d.ts","sourceRoot":"","sources":["../../../src/http/api/_makeRequest.ts"],"names":[],"mappings":"AAIA,KAAK,UAAU,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAC;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,WAAW,CAAC;IAEtB,IAAI,CAAC,EAAE,GAAG,CAAC;CACX,CAAC;AAGF,KAAK,kBAAkB,CAAC,CAAC,GAAG,GAAG,IAAI;IAClC,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,CAAC;IACZ,KAAK,EAAE,IAAI,CAAC;CACZ,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACxB,OAAO,EAAE,KAAK,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAEhB,QAAQ,EAAE,GAAG,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAAC;CAC7B,CAAC;AAGF,KAAK,cAAc,CAAC,CAAC,GAAG,GAAG,IAAI,kBAAkB,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,iBAAe,WAAW,CAAC,CAAC,GAAG,GAAG,EACjC,KAAK,EAAE,UAAU,GACf,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAqF5B;AAED,OAAO,EAAE,KAAK,cAAc,EAAE,WAAW,EAAE,CAAC"}