enlace 0.0.0-alpha.1 → 0.0.0-alpha.3

package/dist/chunk-PNORT7RX.mjs

@@ -0,0 +1,101 @@
+// src/utils/buildUrl.ts
+import qs from "query-string";
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(path.join("/"), baseUrl);
+  if (query) {
+    url.search = qs.stringify(query, { skipNull: true, skipEmptyString: true });
+  }
+  return url.toString();
+}
+
+// src/utils/isJsonBody.ts
+function isJsonBody(body) {
+  if (body === null || body === void 0) return false;
+  if (body instanceof FormData) return false;
+  if (body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer) return false;
+  if (body instanceof URLSearchParams) return false;
+  if (body instanceof ReadableStream) return false;
+  if (typeof body === "string") return false;
+  return typeof body === "object";
+}
+
+// src/utils/mergeHeaders.ts
+function mergeHeaders(defaultHeaders, requestHeaders) {
+  if (!defaultHeaders && !requestHeaders) return void 0;
+  if (!defaultHeaders) return requestHeaders;
+  if (!requestHeaders) return defaultHeaders;
+  return {
+    ...Object.fromEntries(new Headers(defaultHeaders)),
+    ...Object.fromEntries(new Headers(requestHeaders))
+  };
+}
+
+// src/core/fetch.ts
+async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
+  const url = buildUrl(baseUrl, path, requestOptions?.query);
+  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
+  const fetchOptions = {
+    ...defaultOptions,
+    method
+  };
+  if (headers) {
+    fetchOptions.headers = headers;
+  }
+  if (requestOptions?.body !== void 0) {
+    if (isJsonBody(requestOptions.body)) {
+      fetchOptions.body = JSON.stringify(requestOptions.body);
+      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
+      if (headers) {
+        fetchOptions.headers = headers;
+      }
+    } else {
+      fetchOptions.body = requestOptions.body;
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  const contentType = response.headers.get("content-type");
+  const isJson = contentType?.includes("application/json");
+  if (response.ok) {
+    return {
+      ok: true,
+      status: response.status,
+      data: isJson ? await response.json() : response
+    };
+  }
+  return {
+    ok: false,
+    status: response.status,
+    error: isJson ? await response.json() : response
+  };
+}
+
+// src/core/proxy.ts
+var HTTP_METHODS = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE"
+};
+function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
+  const handler = {
+    get(_target, prop) {
+      if (typeof prop === "symbol") return void 0;
+      const method = HTTP_METHODS[prop];
+      if (method) {
+        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
+      }
+      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
+    }
+  };
+  return new Proxy({}, handler);
+}
+
+export {
+  buildUrl,
+  isJsonBody,
+  mergeHeaders,
+  executeFetch,
+  createProxyHandler
+};

package/dist/index.d.mts

@@ -1,3 +1,20 @@
-declare const date: Date;
+import { E as EnlaceOptions, F as FetchExecutor, R as RequestOptions, H as HttpMethod, a as EnlaceResponse, W as WildcardClient, b as EnlaceClient } from './types-BX5MGIgP.mjs';
+export { c as Endpoint, M as MethodDefinition, S as SchemaMethod } from './types-BX5MGIgP.mjs';
 
-export { date };
+declare function createProxyHandler<TSchema extends object, TOptions = EnlaceOptions>(baseUrl: string, defaultOptions: TOptions, path?: string[], fetchExecutor?: FetchExecutor<TOptions, RequestOptions<unknown>>): TSchema;
+
+declare function executeFetch<TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: EnlaceOptions, requestOptions?: RequestOptions<unknown>): Promise<EnlaceResponse<TData, TError>>;
+
+/**
+ * Creates an API client.
+ *
+ * @example
+ * // Typed mode - with schema
+ * const api = createEnlace<MyApi>('https://api.example.com');
+ *
+ * // Untyped mode - no schema
+ * const api = createEnlace('https://api.example.com');
+ */
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions): unknown extends TSchema ? WildcardClient : EnlaceClient<TSchema>;
+
+export { EnlaceClient, EnlaceOptions, EnlaceResponse, FetchExecutor, HttpMethod, RequestOptions, WildcardClient, createEnlace, createProxyHandler, executeFetch };

package/dist/index.d.ts

@@ -1,3 +1,20 @@
-declare const date: Date;
+import { E as EnlaceOptions, F as FetchExecutor, R as RequestOptions, H as HttpMethod, a as EnlaceResponse, W as WildcardClient, b as EnlaceClient } from './types-BX5MGIgP.js';
+export { c as Endpoint, M as MethodDefinition, S as SchemaMethod } from './types-BX5MGIgP.js';
 
-export { date };
+declare function createProxyHandler<TSchema extends object, TOptions = EnlaceOptions>(baseUrl: string, defaultOptions: TOptions, path?: string[], fetchExecutor?: FetchExecutor<TOptions, RequestOptions<unknown>>): TSchema;
+
+declare function executeFetch<TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: EnlaceOptions, requestOptions?: RequestOptions<unknown>): Promise<EnlaceResponse<TData, TError>>;
+
+/**
+ * Creates an API client.
+ *
+ * @example
+ * // Typed mode - with schema
+ * const api = createEnlace<MyApi>('https://api.example.com');
+ *
+ * // Untyped mode - no schema
+ * const api = createEnlace('https://api.example.com');
+ */
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions): unknown extends TSchema ? WildcardClient : EnlaceClient<TSchema>;
+
+export { EnlaceClient, EnlaceOptions, EnlaceResponse, FetchExecutor, HttpMethod, RequestOptions, WildcardClient, createEnlace, createProxyHandler, executeFetch };

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,12 +17,120 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  date: () => date
+  createEnlace: () => createEnlace,
+  createProxyHandler: () => createProxyHandler,
+  executeFetch: () => executeFetch
 });
 module.exports = __toCommonJS(index_exports);
-var date = /* @__PURE__ */ new Date();
+
+// src/utils/buildUrl.ts
+var import_query_string = __toESM(require("query-string"));
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(path.join("/"), baseUrl);
+  if (query) {
+    url.search = import_query_string.default.stringify(query, { skipNull: true, skipEmptyString: true });
+  }
+  return url.toString();
+}
+
+// src/utils/isJsonBody.ts
+function isJsonBody(body) {
+  if (body === null || body === void 0) return false;
+  if (body instanceof FormData) return false;
+  if (body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer) return false;
+  if (body instanceof URLSearchParams) return false;
+  if (body instanceof ReadableStream) return false;
+  if (typeof body === "string") return false;
+  return typeof body === "object";
+}
+
+// src/utils/mergeHeaders.ts
+function mergeHeaders(defaultHeaders, requestHeaders) {
+  if (!defaultHeaders && !requestHeaders) return void 0;
+  if (!defaultHeaders) return requestHeaders;
+  if (!requestHeaders) return defaultHeaders;
+  return {
+    ...Object.fromEntries(new Headers(defaultHeaders)),
+    ...Object.fromEntries(new Headers(requestHeaders))
+  };
+}
+
+// src/core/fetch.ts
+async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
+  const url = buildUrl(baseUrl, path, requestOptions?.query);
+  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
+  const fetchOptions = {
+    ...defaultOptions,
+    method
+  };
+  if (headers) {
+    fetchOptions.headers = headers;
+  }
+  if (requestOptions?.body !== void 0) {
+    if (isJsonBody(requestOptions.body)) {
+      fetchOptions.body = JSON.stringify(requestOptions.body);
+      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
+      if (headers) {
+        fetchOptions.headers = headers;
+      }
+    } else {
+      fetchOptions.body = requestOptions.body;
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  const contentType = response.headers.get("content-type");
+  const isJson = contentType?.includes("application/json");
+  if (response.ok) {
+    return {
+      ok: true,
+      status: response.status,
+      data: isJson ? await response.json() : response
+    };
+  }
+  return {
+    ok: false,
+    status: response.status,
+    error: isJson ? await response.json() : response
+  };
+}
+
+// src/core/proxy.ts
+var HTTP_METHODS = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE"
+};
+function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
+  const handler = {
+    get(_target, prop) {
+      if (typeof prop === "symbol") return void 0;
+      const method = HTTP_METHODS[prop];
+      if (method) {
+        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
+      }
+      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
+    }
+  };
+  return new Proxy({}, handler);
+}
+
+// src/core/index.ts
+function createEnlace(baseUrl, defaultOptions = {}) {
+  return createProxyHandler(baseUrl, defaultOptions);
+}

package/dist/index.mjs

@@ -1,5 +1,14 @@
-// src/index.ts
-var date = /* @__PURE__ */ new Date();
+import {
+  createProxyHandler,
+  executeFetch
+} from "./chunk-PNORT7RX.mjs";
+
+// src/core/index.ts
+function createEnlace(baseUrl, defaultOptions = {}) {
+  return createProxyHandler(baseUrl, defaultOptions);
+}
 export {
-  date
+  createEnlace,
+  createProxyHandler,
+  executeFetch
 };

package/dist/next/index.d.mts

@@ -0,0 +1,16 @@
+import { E as EnlaceOptions, W as WildcardClient, b as EnlaceClient } from '../types-BX5MGIgP.mjs';
+export { c as Endpoint, a as EnlaceResponse, F as FetchExecutor, H as HttpMethod, M as MethodDefinition, R as RequestOptions, S as SchemaMethod } from '../types-BX5MGIgP.mjs';
+
+type NextFetchOptions = {
+    revalidate?: number | false;
+    tags?: string[];
+};
+type NextEnlaceOptions = EnlaceOptions;
+type NextRequestOptionsBase = {
+    cache?: 'force-cache' | 'no-store';
+    next?: NextFetchOptions;
+};
+
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: NextEnlaceOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
+
+export { EnlaceClient, EnlaceOptions, type NextEnlaceOptions, type NextFetchOptions, type NextRequestOptionsBase, WildcardClient, createEnlace };

package/dist/next/index.d.ts

@@ -0,0 +1,16 @@
+import { E as EnlaceOptions, W as WildcardClient, b as EnlaceClient } from '../types-BX5MGIgP.js';
+export { c as Endpoint, a as EnlaceResponse, F as FetchExecutor, H as HttpMethod, M as MethodDefinition, R as RequestOptions, S as SchemaMethod } from '../types-BX5MGIgP.js';
+
+type NextFetchOptions = {
+    revalidate?: number | false;
+    tags?: string[];
+};
+type NextEnlaceOptions = EnlaceOptions;
+type NextRequestOptionsBase = {
+    cache?: 'force-cache' | 'no-store';
+    next?: NextFetchOptions;
+};
+
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: NextEnlaceOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
+
+export { EnlaceClient, EnlaceOptions, type NextEnlaceOptions, type NextFetchOptions, type NextRequestOptionsBase, WildcardClient, createEnlace };

package/dist/next/index.js

@@ -0,0 +1,186 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  createEnlace: () => createEnlace
+});
+module.exports = __toCommonJS(next_exports);
+
+// src/utils/buildUrl.ts
+var import_query_string = __toESM(require("query-string"));
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(path.join("/"), baseUrl);
+  if (query) {
+    url.search = import_query_string.default.stringify(query, { skipNull: true, skipEmptyString: true });
+  }
+  return url.toString();
+}
+
+// src/utils/isJsonBody.ts
+function isJsonBody(body) {
+  if (body === null || body === void 0) return false;
+  if (body instanceof FormData) return false;
+  if (body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer) return false;
+  if (body instanceof URLSearchParams) return false;
+  if (body instanceof ReadableStream) return false;
+  if (typeof body === "string") return false;
+  return typeof body === "object";
+}
+
+// src/utils/mergeHeaders.ts
+function mergeHeaders(defaultHeaders, requestHeaders) {
+  if (!defaultHeaders && !requestHeaders) return void 0;
+  if (!defaultHeaders) return requestHeaders;
+  if (!requestHeaders) return defaultHeaders;
+  return {
+    ...Object.fromEntries(new Headers(defaultHeaders)),
+    ...Object.fromEntries(new Headers(requestHeaders))
+  };
+}
+
+// src/core/fetch.ts
+async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
+  const url = buildUrl(baseUrl, path, requestOptions?.query);
+  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
+  const fetchOptions = {
+    ...defaultOptions,
+    method
+  };
+  if (headers) {
+    fetchOptions.headers = headers;
+  }
+  if (requestOptions?.body !== void 0) {
+    if (isJsonBody(requestOptions.body)) {
+      fetchOptions.body = JSON.stringify(requestOptions.body);
+      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
+      if (headers) {
+        fetchOptions.headers = headers;
+      }
+    } else {
+      fetchOptions.body = requestOptions.body;
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  const contentType = response.headers.get("content-type");
+  const isJson = contentType?.includes("application/json");
+  if (response.ok) {
+    return {
+      ok: true,
+      status: response.status,
+      data: isJson ? await response.json() : response
+    };
+  }
+  return {
+    ok: false,
+    status: response.status,
+    error: isJson ? await response.json() : response
+  };
+}
+
+// src/core/proxy.ts
+var HTTP_METHODS = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE"
+};
+function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
+  const handler = {
+    get(_target, prop) {
+      if (typeof prop === "symbol") return void 0;
+      const method = HTTP_METHODS[prop];
+      if (method) {
+        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
+      }
+      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
+    }
+  };
+  return new Proxy({}, handler);
+}
+
+// src/next/fetch.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
+}
+async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOptions) {
+  const url = buildUrl(baseUrl, path, requestOptions?.query);
+  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
+  const nextOptions = requestOptions?.next;
+  const tags = nextOptions?.tags ?? generateTags(path);
+  const fetchOptions = {
+    ...defaultOptions,
+    method
+  };
+  if (requestOptions?.cache) {
+    fetchOptions.cache = requestOptions.cache;
+  }
+  const nextFetchOptions = { tags };
+  if (nextOptions?.revalidate !== void 0) {
+    nextFetchOptions.revalidate = nextOptions.revalidate;
+  }
+  fetchOptions.next = nextFetchOptions;
+  if (headers) {
+    fetchOptions.headers = headers;
+  }
+  if (requestOptions?.body !== void 0) {
+    if (isJsonBody(requestOptions.body)) {
+      fetchOptions.body = JSON.stringify(requestOptions.body);
+      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
+      if (headers) {
+        fetchOptions.headers = headers;
+      }
+    } else {
+      fetchOptions.body = requestOptions.body;
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  const contentType = response.headers.get("content-type");
+  const isJson = contentType?.includes("application/json");
+  if (response.ok) {
+    return {
+      ok: true,
+      status: response.status,
+      data: isJson ? await response.json() : response
+    };
+  }
+  return {
+    ok: false,
+    status: response.status,
+    error: isJson ? await response.json() : response
+  };
+}
+
+// src/next/index.ts
+function createEnlace(baseUrl, defaultOptions = {}) {
+  return createProxyHandler(baseUrl, defaultOptions, [], executeNextFetch);
+}

package/dist/next/index.mjs

@@ -0,0 +1,66 @@
+import {
+  buildUrl,
+  createProxyHandler,
+  isJsonBody,
+  mergeHeaders
+} from "../chunk-PNORT7RX.mjs";
+
+// src/next/fetch.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
+}
+async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOptions) {
+  const url = buildUrl(baseUrl, path, requestOptions?.query);
+  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
+  const nextOptions = requestOptions?.next;
+  const tags = nextOptions?.tags ?? generateTags(path);
+  const fetchOptions = {
+    ...defaultOptions,
+    method
+  };
+  if (requestOptions?.cache) {
+    fetchOptions.cache = requestOptions.cache;
+  }
+  const nextFetchOptions = { tags };
+  if (nextOptions?.revalidate !== void 0) {
+    nextFetchOptions.revalidate = nextOptions.revalidate;
+  }
+  fetchOptions.next = nextFetchOptions;
+  if (headers) {
+    fetchOptions.headers = headers;
+  }
+  if (requestOptions?.body !== void 0) {
+    if (isJsonBody(requestOptions.body)) {
+      fetchOptions.body = JSON.stringify(requestOptions.body);
+      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
+      if (headers) {
+        fetchOptions.headers = headers;
+      }
+    } else {
+      fetchOptions.body = requestOptions.body;
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  const contentType = response.headers.get("content-type");
+  const isJson = contentType?.includes("application/json");
+  if (response.ok) {
+    return {
+      ok: true,
+      status: response.status,
+      data: isJson ? await response.json() : response
+    };
+  }
+  return {
+    ok: false,
+    status: response.status,
+    error: isJson ? await response.json() : response
+  };
+}
+
+// src/next/index.ts
+function createEnlace(baseUrl, defaultOptions = {}) {
+  return createProxyHandler(baseUrl, defaultOptions, [], executeNextFetch);
+}
+export {
+  createEnlace
+};

package/dist/types-BX5MGIgP.d.mts

@@ -0,0 +1,104 @@
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type SchemaMethod = '$get' | '$post' | '$put' | '$patch' | '$delete';
+type EnlaceResponse<TData, TError> = {
+    ok: true;
+    status: number;
+    data: TData;
+    error?: never;
+} | {
+    ok: false;
+    status: number;
+    data?: never;
+    error: TError;
+};
+type EnlaceOptions = Omit<RequestInit, 'method' | 'body'>;
+type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
+type RequestOptions<TBody = never> = {
+    body?: TBody;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: HeadersInit;
+};
+type MethodDefinition = {
+    data: unknown;
+    error: unknown;
+    body?: unknown;
+};
+/**
+ * Helper to define an endpoint with proper typing.
+ * Provides cleaner syntax than writing { data, error, body } manually.
+ *
+ * @example
+ * type MyApi = {
+ *   posts: {
+ *     $get: Endpoint<Post[], ApiError>;
+ *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
+ *     _: {
+ *       $get: Endpoint<Post, NotFoundError>;
+ *     };
+ *   };
+ * };
+ */
+type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
+    data: TData;
+    error: TError;
+} : {
+    data: TData;
+    error: TError;
+    body: TBody;
+};
+type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: infer M;
+} ? M extends MethodDefinition ? M : never : never;
+type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    data: infer D;
+} ? D : never;
+type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    error: infer E;
+} ? E : never;
+type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    body: infer B;
+} ? B : never;
+type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: MethodDefinition;
+} ? true : false;
+type MethodFn<TSchema, TMethod extends SchemaMethod, TRequestOptionsBase = object> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
+type IsSpecialKey<K> = K extends SchemaMethod | '_' ? true : false;
+type StaticPathKeys<TSchema> = {
+    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
+};
+type ExtractDynamicSchema<TSchema> = TSchema extends {
+    _: infer D;
+} ? D : never;
+type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod, TRequestOptionsBase = object> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName], TRequestOptionsBase> : MethodFn<TSchema, TSchemaMethod, TRequestOptionsBase>;
+type HttpMethods<TSchema, TRequestOptionsBase = object> = {
+    get: MethodOrPath<TSchema, 'get', '$get', TRequestOptionsBase>;
+    post: MethodOrPath<TSchema, 'post', '$post', TRequestOptionsBase>;
+    put: MethodOrPath<TSchema, 'put', '$put', TRequestOptionsBase>;
+    patch: MethodOrPath<TSchema, 'patch', '$patch', TRequestOptionsBase>;
+    delete: MethodOrPath<TSchema, 'delete', '$delete', TRequestOptionsBase>;
+};
+type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
+    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+};
+type MethodNameKeys = 'get' | 'post' | 'put' | 'patch' | 'delete';
+type EnlaceClient<TSchema, TRequestOptionsBase = object> = HttpMethods<TSchema, TRequestOptionsBase> & DynamicAccess<TSchema, TRequestOptionsBase> & {
+    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K], TRequestOptionsBase>;
+};
+type WildcardMethodFn<TRequestOptionsBase = object> = (options?: RequestOptions<unknown> & TRequestOptionsBase) => Promise<EnlaceResponse<unknown, unknown>>;
+/**
+ * Wildcard client type - allows any path access when no schema is provided.
+ * All methods are available at every level and return unknown types.
+ */
+type WildcardClient<TRequestOptionsBase = object> = {
+    get: WildcardMethodFn<TRequestOptionsBase>;
+    post: WildcardMethodFn<TRequestOptionsBase>;
+    put: WildcardMethodFn<TRequestOptionsBase>;
+    patch: WildcardMethodFn<TRequestOptionsBase>;
+    delete: WildcardMethodFn<TRequestOptionsBase>;
+} & {
+    [key: string]: WildcardClient<TRequestOptionsBase>;
+    [key: number]: WildcardClient<TRequestOptionsBase>;
+};
+
+export type { EnlaceOptions as E, FetchExecutor as F, HttpMethod as H, MethodDefinition as M, RequestOptions as R, SchemaMethod as S, WildcardClient as W, EnlaceResponse as a, EnlaceClient as b, Endpoint as c };

package/dist/types-BX5MGIgP.d.ts

@@ -0,0 +1,104 @@
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type SchemaMethod = '$get' | '$post' | '$put' | '$patch' | '$delete';
+type EnlaceResponse<TData, TError> = {
+    ok: true;
+    status: number;
+    data: TData;
+    error?: never;
+} | {
+    ok: false;
+    status: number;
+    data?: never;
+    error: TError;
+};
+type EnlaceOptions = Omit<RequestInit, 'method' | 'body'>;
+type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
+type RequestOptions<TBody = never> = {
+    body?: TBody;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: HeadersInit;
+};
+type MethodDefinition = {
+    data: unknown;
+    error: unknown;
+    body?: unknown;
+};
+/**
+ * Helper to define an endpoint with proper typing.
+ * Provides cleaner syntax than writing { data, error, body } manually.
+ *
+ * @example
+ * type MyApi = {
+ *   posts: {
+ *     $get: Endpoint<Post[], ApiError>;
+ *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
+ *     _: {
+ *       $get: Endpoint<Post, NotFoundError>;
+ *     };
+ *   };
+ * };
+ */
+type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
+    data: TData;
+    error: TError;
+} : {
+    data: TData;
+    error: TError;
+    body: TBody;
+};
+type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: infer M;
+} ? M extends MethodDefinition ? M : never : never;
+type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    data: infer D;
+} ? D : never;
+type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    error: infer E;
+} ? E : never;
+type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    body: infer B;
+} ? B : never;
+type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: MethodDefinition;
+} ? true : false;
+type MethodFn<TSchema, TMethod extends SchemaMethod, TRequestOptionsBase = object> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
+type IsSpecialKey<K> = K extends SchemaMethod | '_' ? true : false;
+type StaticPathKeys<TSchema> = {
+    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
+};
+type ExtractDynamicSchema<TSchema> = TSchema extends {
+    _: infer D;
+} ? D : never;
+type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod, TRequestOptionsBase = object> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName], TRequestOptionsBase> : MethodFn<TSchema, TSchemaMethod, TRequestOptionsBase>;
+type HttpMethods<TSchema, TRequestOptionsBase = object> = {
+    get: MethodOrPath<TSchema, 'get', '$get', TRequestOptionsBase>;
+    post: MethodOrPath<TSchema, 'post', '$post', TRequestOptionsBase>;
+    put: MethodOrPath<TSchema, 'put', '$put', TRequestOptionsBase>;
+    patch: MethodOrPath<TSchema, 'patch', '$patch', TRequestOptionsBase>;
+    delete: MethodOrPath<TSchema, 'delete', '$delete', TRequestOptionsBase>;
+};
+type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
+    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+};
+type MethodNameKeys = 'get' | 'post' | 'put' | 'patch' | 'delete';
+type EnlaceClient<TSchema, TRequestOptionsBase = object> = HttpMethods<TSchema, TRequestOptionsBase> & DynamicAccess<TSchema, TRequestOptionsBase> & {
+    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K], TRequestOptionsBase>;
+};
+type WildcardMethodFn<TRequestOptionsBase = object> = (options?: RequestOptions<unknown> & TRequestOptionsBase) => Promise<EnlaceResponse<unknown, unknown>>;
+/**
+ * Wildcard client type - allows any path access when no schema is provided.
+ * All methods are available at every level and return unknown types.
+ */
+type WildcardClient<TRequestOptionsBase = object> = {
+    get: WildcardMethodFn<TRequestOptionsBase>;
+    post: WildcardMethodFn<TRequestOptionsBase>;
+    put: WildcardMethodFn<TRequestOptionsBase>;
+    patch: WildcardMethodFn<TRequestOptionsBase>;
+    delete: WildcardMethodFn<TRequestOptionsBase>;
+} & {
+    [key: string]: WildcardClient<TRequestOptionsBase>;
+    [key: number]: WildcardClient<TRequestOptionsBase>;
+};
+
+export type { EnlaceOptions as E, FetchExecutor as F, HttpMethod as H, MethodDefinition as M, RequestOptions as R, SchemaMethod as S, WildcardClient as W, EnlaceResponse as a, EnlaceClient as b, Endpoint as c };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enlace",
-  "version": "0.0.0-alpha.1",
+  "version": "0.0.0-alpha.3",
   "files": [
     "dist"
   ],
@@ -9,6 +9,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
+    },
+    "./next": {
+      "types": "./dist/next/index.d.ts",
+      "import": "./dist/next/index.mjs",
+      "require": "./dist/next/index.js"
     }
   },
   "license": "MIT",
@@ -27,9 +32,13 @@
     "eslint": "^9.39.1",
     "eslint-plugin-react": "^7.37.5",
     "globals": "^16.5.0",
+    "jiti": "^2.6.1",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "5.9.2",
     "typescript-eslint": "^8.48.1"
+  },
+  "dependencies": {
+    "query-string": "^9.3.1"
   }
 }