@diphyx/harlemify 1.0.4 → 2.0.0

package/README.md

@@ -9,7 +9,7 @@ Define your data schema once with Zod, and Harlemify handles the rest: type-safe
 ## Features
 
 - **Schema-Driven** - Zod schema defines types, validation, and API payloads
-- **Automatic API Client** - Built-in HTTP client with runtime configuration
+- **Custom Adapters** - Pluggable HTTP adapters for custom request handling
 - **Reactive Memory** - Unit and collection caching with Vue reactivity
 - **Request Monitoring** - Track pending, success, and failed states
 - **SSR Support** - Server-side rendering via Harlem SSR plugin
@@ -28,7 +28,10 @@ export default defineNuxtConfig({
     modules: ["@diphyx/harlemify"],
     harlemify: {
         api: {
-            url: "https://api.example.com",
+            adapter: {
+                baseURL: "https://api.example.com",
+                timeout: 10000,
+            },
         },
     },
 });
@@ -56,6 +59,89 @@ export const userStore = createStore("user", UserSchema, {
 });
 ```
 
+## Custom Adapters
+
+Harlemify supports custom HTTP adapters for advanced use cases like streaming responses, file uploads with progress, or custom authentication.
+
+### Adapter Hierarchy
+
+Adapters are resolved in the following order (highest to lowest priority):
+
+1. **Endpoint adapter** - Per-endpoint custom adapter
+2. **Store adapter** - Store-level adapter option
+3. **Module adapter** - Global config in `nuxt.config.ts`
+4. **Default adapter** - Built-in fetch adapter
+
+### Built-in Adapter
+
+Use `defineApiAdapter` to create an adapter with custom options:
+
+```typescript
+import { defineApiAdapter } from "@diphyx/harlemify";
+
+const customAdapter = defineApiAdapter({
+    baseURL: "/api",
+    timeout: 5000,
+    retry: 3,
+    retryDelay: 1000,
+    retryStatusCodes: [500, 502, 503],
+});
+```
+
+### Custom Adapter
+
+Create a fully custom adapter for advanced scenarios:
+
+```typescript
+import type { ApiAdapter, ApiAdapterRequest } from "@diphyx/harlemify";
+
+const streamingAdapter: ApiAdapter<MyType> = async (request: ApiAdapterRequest) => {
+    // Custom fetch logic with streaming, progress, etc.
+    const response = await fetch(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: JSON.stringify(request.body),
+    });
+
+    const data = await response.json();
+    return { data, status: response.status };
+};
+```
+
+### Using Adapters
+
+**Store-level adapter:**
+
+```typescript
+export const userStore = createStore(
+    "user",
+    UserSchema,
+    {
+        [Endpoint.GET_UNITS]: { method: EndpointMethod.GET, url: "/users" },
+    },
+    {
+        adapter: customAdapter, // Used for all endpoints in this store
+    },
+);
+```
+
+**Endpoint-level adapter:**
+
+```typescript
+export const userStore = createStore("user", UserSchema, {
+    [Endpoint.GET_UNIT]: {
+        method: EndpointMethod.GET,
+        url: (p) => `/users/${p.id}`,
+        adapter: detailAdapter, // Custom adapter for this endpoint only
+    },
+    [Endpoint.GET_UNITS]: {
+        method: EndpointMethod.GET,
+        url: "/users",
+        // Uses store or global adapter
+    },
+});
+```
+
 ## Why Harlemify?
 
 |                 |                                                   |
@@ -63,7 +149,7 @@ export const userStore = createStore("user", UserSchema, {
 | **Type-Safe**   | Full TypeScript support with Zod schema inference |
 | **Declarative** | Define schema once, derive everything else        |
 | **Reactive**    | Powered by Vue's reactivity through Harlem        |
-| **Simple**      | Minimal boilerplate, maximum productivity         |
+| **Extensible**  | Custom adapters for any HTTP requirement          |
 
 ## Documentation
 

package/dist/module.d.mts

@@ -1,9 +1,19 @@
 import * as _nuxt_schema from '@nuxt/schema';
 
+interface ApiFetchAdapterOptions {
+    baseURL?: string;
+    timeout?: number;
+    retry?: number | false;
+    retryDelay?: number;
+    retryStatusCodes?: number[];
+    responseType?: "json" | "text" | "blob" | "arrayBuffer";
+}
+
 type SharedConfig = {
     api?: {
-        url?: string;
-        timeout?: number;
+        headers?: Record<string, string>;
+        query?: Record<string, unknown>;
+        adapter?: ApiFetchAdapterOptions;
     };
 };
 

package/dist/module.d.ts

@@ -1,9 +1,19 @@
 import * as _nuxt_schema from '@nuxt/schema';
 
+interface ApiFetchAdapterOptions {
+    baseURL?: string;
+    timeout?: number;
+    retry?: number | false;
+    retryDelay?: number;
+    retryStatusCodes?: number[];
+    responseType?: "json" | "text" | "blob" | "arrayBuffer";
+}
+
 type SharedConfig = {
     api?: {
-        url?: string;
-        timeout?: number;
+        headers?: Record<string, string>;
+        query?: Record<string, unknown>;
+        adapter?: ApiFetchAdapterOptions;
     };
 };
 

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0 || >=4.0.0"
   },
-  "version": "1.0.4",
+  "version": "2.0.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -9,7 +9,11 @@ const module = defineNuxtModule({
     }
   },
   defaults: {
-    api: {}
+    api: {
+      headers: {},
+      query: {},
+      adapter: {}
+    }
   },
   setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);

package/dist/runtime/core/adapter.d.ts

@@ -0,0 +1,33 @@
+import type { EndpointMethod } from "../utils/endpoint.js";
+export interface ApiAdapterRequest {
+    method: EndpointMethod;
+    url: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+export interface ApiAdapterResponse<T = unknown> {
+    data: T;
+    status?: number;
+}
+export type ApiAdapter<T = unknown> = (request: ApiAdapterRequest) => Promise<ApiAdapterResponse<T>>;
+export type DefineApiAdapter<T = unknown, O = unknown> = (options?: O) => ApiAdapter<T>;
+export interface ApiFetchAdapterOptions {
+    baseURL?: string;
+    timeout?: number;
+    retry?: number | false;
+    retryDelay?: number;
+    retryStatusCodes?: number[];
+    responseType?: "json" | "text" | "blob" | "arrayBuffer";
+}
+/**
+ * Creates a built-in fetch adapter with configurable options.
+ *
+ * Adapter hierarchy (highest to lowest priority):
+ * 1. endpoint.adapter - Per-endpoint adapter
+ * 2. storeOptions.adapter - Store-level adapter
+ * 3. sharedConfig.api.adapter - Module config adapter options
+ * 4. Default adapter (no options)
+ */
+export declare function defineApiAdapter<T = unknown>(options?: ApiFetchAdapterOptions): ApiAdapter<T>;

package/dist/runtime/core/adapter.js

@@ -0,0 +1,33 @@
+import { ApiRequestError, ApiResponseError } from "./errors.js";
+export function defineApiAdapter(options) {
+  return async (request) => {
+    const data = await $fetch(request.url, {
+      baseURL: options?.baseURL,
+      method: request.method,
+      headers: request.headers,
+      query: request.query,
+      body: request.body,
+      timeout: options?.timeout,
+      signal: request.signal,
+      retry: options?.retry,
+      retryDelay: options?.retryDelay,
+      retryStatusCodes: options?.retryStatusCodes,
+      responseType: options?.responseType,
+      onRequestError({ request: request2, options: options2, error }) {
+        throw new ApiRequestError({
+          method: options2.method,
+          url: request2.toString(),
+          message: error?.message
+        });
+      },
+      onResponseError({ request: request2, options: options2, error }) {
+        throw new ApiResponseError({
+          method: options2.method,
+          url: request2.toString(),
+          message: error?.message
+        });
+      }
+    });
+    return { data };
+  };
+}

package/dist/runtime/core/api.d.ts

@@ -1,15 +1,6 @@
 import type { MaybeRefOrGetter } from "vue";
 import { EndpointMethod } from "../utils/endpoint.js";
-export declare enum ApiResponseType {
-    JSON = "json",
-    TEXT = "text",
-    BLOB = "blob",
-    ARRAY_BUFFER = "arrayBuffer"
-}
-export declare enum ApiErrorSource {
-    REQUEST = "request",
-    RESPONSE = "response"
-}
+import { type ApiAdapter } from "./adapter.js";
 export type ApiRequestHeader = MaybeRefOrGetter<Record<string, unknown>>;
 export type ApiRequestQuery = MaybeRefOrGetter<Record<string, unknown>>;
 export type ApiRequestBody = MaybeRefOrGetter<string | number | ArrayBuffer | FormData | Blob | Record<string, any>>;
@@ -18,43 +9,29 @@ export interface ApiRequestOptions<A extends EndpointMethod = EndpointMethod, H
     headers?: H;
     query?: Q;
     body?: B;
-    timeout?: number;
-    responseType?: ApiResponseType;
-    retry?: number | false;
-    retryDelay?: number;
-    retryStatusCodes?: number[];
     signal?: AbortSignal;
 }
 export interface ApiOptions {
-    url?: string;
     headers?: ApiRequestHeader;
     query?: ApiRequestQuery;
-    timeout?: number;
+    adapter?: ApiAdapter<any>;
 }
 export type EndpointMethodOptions<A extends EndpointMethod, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> = Omit<ApiRequestOptions<A, H, Q, B>, "action">;
-export interface ApiErrorOptions {
-    source: ApiErrorSource;
-    method: string;
-    url: string;
-    message?: string;
-}
-export declare class ApiError extends Error {
-    source: ApiErrorSource;
-    method: string;
-    url: string;
-    constructor(options: ApiErrorOptions);
-}
-export declare class ApiRequestError extends ApiError {
-    constructor(options: Omit<ApiErrorOptions, "source">);
-}
-export declare class ApiResponseError extends ApiError {
-    constructor(options: Omit<ApiErrorOptions, "source">);
-}
 export interface Api {
-    get: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.GET, H, Q, never>) => Promise<T>;
-    post: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.POST, H, Q, B>) => Promise<T>;
-    put: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.PUT, H, Q, B>) => Promise<T>;
-    patch: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.PATCH, H, Q, B>) => Promise<T>;
-    del: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.DELETE, H, Q, never>) => Promise<T>;
+    get: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.GET, H, Q, never> & {
+        adapter?: ApiAdapter<T>;
+    }) => Promise<T>;
+    post: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.POST, H, Q, B> & {
+        adapter?: ApiAdapter<T>;
+    }) => Promise<T>;
+    put: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.PUT, H, Q, B> & {
+        adapter?: ApiAdapter<T>;
+    }) => Promise<T>;
+    patch: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.PATCH, H, Q, B> & {
+        adapter?: ApiAdapter<T>;
+    }) => Promise<T>;
+    del: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.DELETE, H, Q, never> & {
+        adapter?: ApiAdapter<T>;
+    }) => Promise<T>;
 }
 export declare function createApi(options?: ApiOptions): Api;

package/dist/runtime/core/api.js

@@ -1,80 +1,26 @@
 import { toValue } from "vue";
 import { EndpointMethod } from "../utils/endpoint.js";
-export var ApiResponseType = /* @__PURE__ */ ((ApiResponseType2) => {
-  ApiResponseType2["JSON"] = "json";
-  ApiResponseType2["TEXT"] = "text";
-  ApiResponseType2["BLOB"] = "blob";
-  ApiResponseType2["ARRAY_BUFFER"] = "arrayBuffer";
-  return ApiResponseType2;
-})(ApiResponseType || {});
-export var ApiErrorSource = /* @__PURE__ */ ((ApiErrorSource2) => {
-  ApiErrorSource2["REQUEST"] = "request";
-  ApiErrorSource2["RESPONSE"] = "response";
-  return ApiErrorSource2;
-})(ApiErrorSource || {});
-export class ApiError extends Error {
-  source;
-  method;
-  url;
-  constructor(options) {
-    super(options.message ?? "Unknown error");
-    this.name = "ApiError";
-    this.source = options.source;
-    this.method = options.method;
-    this.url = options.url;
-  }
-}
-export class ApiRequestError extends ApiError {
-  constructor(options) {
-    super({
-      ...options,
-      source: "request" /* REQUEST */
-    });
-  }
-}
-export class ApiResponseError extends ApiError {
-  constructor(options) {
-    super({
-      ...options,
-      source: "response" /* RESPONSE */
-    });
-  }
-}
+import { defineApiAdapter } from "./adapter.js";
 export function createApi(options) {
+  const defaultAdapter = options?.adapter ?? defineApiAdapter();
   async function request(url, requestOptions) {
-    return $fetch(url, {
-      baseURL: options?.url,
+    const adapter = requestOptions?.adapter ?? defaultAdapter;
+    const adapterRequest = {
       method: requestOptions?.action ?? EndpointMethod.GET,
+      url,
+      body: toValue(requestOptions?.body),
+      query: {
+        ...toValue(options?.query),
+        ...toValue(requestOptions?.query)
+      },
       headers: {
         ...toValue(options?.headers),
         ...toValue(requestOptions?.headers)
       },
-      query: {
-        ...toValue(requestOptions?.query),
-        ...toValue(options?.query)
-      },
-      body: toValue(requestOptions?.body),
-      timeout: requestOptions?.timeout ?? options?.timeout,
-      responseType: requestOptions?.responseType,
-      retry: requestOptions?.retry,
-      retryDelay: requestOptions?.retryDelay,
-      retryStatusCodes: requestOptions?.retryStatusCodes,
-      signal: requestOptions?.signal,
-      onRequestError({ request: request2, options: options2, error }) {
-        throw new ApiRequestError({
-          method: options2.method,
-          url: request2.toString(),
-          message: error?.message
-        });
-      },
-      onResponseError({ request: request2, options: options2, error }) {
-        throw new ApiResponseError({
-          method: options2.method,
-          url: request2.toString(),
-          message: error?.message
-        });
-      }
-    });
+      signal: requestOptions?.signal
+    };
+    const response = await adapter(adapterRequest);
+    return response.data;
   }
   async function get(url, options2) {
     return request(url, {

package/dist/runtime/core/errors.d.ts

@@ -0,0 +1,22 @@
+export declare enum ApiErrorSource {
+    REQUEST = "request",
+    RESPONSE = "response"
+}
+export interface ApiErrorOptions {
+    source: ApiErrorSource;
+    method: string;
+    url: string;
+    message?: string;
+}
+export declare class ApiError extends Error {
+    source: ApiErrorSource;
+    method: string;
+    url: string;
+    constructor(options: ApiErrorOptions);
+}
+export declare class ApiRequestError extends ApiError {
+    constructor(options: Omit<ApiErrorOptions, "source">);
+}
+export declare class ApiResponseError extends ApiError {
+    constructor(options: Omit<ApiErrorOptions, "source">);
+}

package/dist/runtime/core/errors.js

@@ -0,0 +1,33 @@
+export var ApiErrorSource = /* @__PURE__ */ ((ApiErrorSource2) => {
+  ApiErrorSource2["REQUEST"] = "request";
+  ApiErrorSource2["RESPONSE"] = "response";
+  return ApiErrorSource2;
+})(ApiErrorSource || {});
+export class ApiError extends Error {
+  source;
+  method;
+  url;
+  constructor(options) {
+    super(options.message ?? "Unknown error");
+    this.name = "ApiError";
+    this.source = options.source;
+    this.method = options.method;
+    this.url = options.url;
+  }
+}
+export class ApiRequestError extends ApiError {
+  constructor(options) {
+    super({
+      ...options,
+      source: "request" /* REQUEST */
+    });
+  }
+}
+export class ApiResponseError extends ApiError {
+  constructor(options) {
+    super({
+      ...options,
+      source: "response" /* RESPONSE */
+    });
+  }
+}

package/dist/runtime/core/store.d.ts

@@ -2,7 +2,8 @@ import type { z } from "zod";
 import type { ComputedRef } from "vue";
 import type { Extension, BaseState } from "@harlem/core";
 import { Endpoint, EndpointStatus } from "../utils/endpoint.js";
-import type { EndpointMethodOptions, ApiOptions } from "./api.js";
+import type { EndpointMethodOptions } from "./api.js";
+import type { ApiAdapter } from "./adapter.js";
 import type { EndpointDefinition, EndpointStatusName } from "../utils/endpoint.js";
 import type { Pluralize } from "../utils/transform.js";
 export declare enum StoreMemoryAction {
@@ -19,7 +20,7 @@ export interface StoreHooks {
     after?: (error?: Error) => Promise<void> | void;
 }
 export interface StoreOptions {
-    api?: ApiOptions;
+    adapter?: ApiAdapter<any>;
     indicator?: string;
     hooks?: StoreHooks;
     extensions?: Extension<BaseState>[];

package/dist/runtime/core/store.js

@@ -1,6 +1,7 @@
 import { defu } from "defu";
 import { createStore as createHarlemStore } from "@harlem/core";
 import { createApi } from "./api.js";
+import { defineApiAdapter } from "./adapter.js";
 import { sharedConfig } from "../shared.js";
 import { resolveSchema } from "../utils/schema.js";
 import { pluralize } from "../utils/transform.js";
@@ -20,12 +21,14 @@ export function createStore(entity, schema, endpoints, options) {
   const { indicator } = resolveSchema(schema, {
     indicator: options?.indicator
   });
+  const defaultAdapter = options?.adapter ?? defineApiAdapter(sharedConfig.api?.adapter);
   let apiClient;
   function api() {
     if (!apiClient) {
       apiClient = createApi({
-        ...sharedConfig.api ?? {},
-        ...options?.api
+        headers: sharedConfig.api?.headers,
+        query: sharedConfig.api?.query,
+        adapter: defaultAdapter
       });
     }
     return apiClient;
@@ -127,18 +130,24 @@ export function createStore(entity, schema, endpoints, options) {
       throw error;
     }
   }
-  async function getUnitEndpoint(unit, options2) {
+  async function getUnitEndpoint(unit, requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.GET_UNIT);
     return withStatus(Endpoint.GET_UNIT, async () => {
-      const response = await api().get(resolveEndpointUrl(endpoint, unit), options2);
+      const response = await api().get(resolveEndpointUrl(endpoint, unit), {
+        ...requestOptions,
+        ...endpoint.adapter && { adapter: endpoint.adapter }
+      });
       setMemorizedUnit(response);
       return response;
     });
   }
-  async function getUnitsEndpoint(options2) {
+  async function getUnitsEndpoint(requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.GET_UNITS);
     return withStatus(Endpoint.GET_UNITS, async () => {
-      const response = await api().get(resolveEndpointUrl(endpoint), options2);
+      const response = await api().get(resolveEndpointUrl(endpoint), {
+        ...requestOptions,
+        ...endpoint.adapter && { adapter: endpoint.adapter }
+      });
       setMemorizedUnits(response);
       return response;
     });
@@ -152,27 +161,29 @@ export function createStore(entity, schema, endpoints, options) {
     return withStatus(Endpoint.POST_UNIT, async () => {
       const response = await api().post(resolveEndpointUrl(endpoint, unit), {
         ...actionOptions,
-        body: actionOptions?.body ?? resolvedSchema.values
+        body: actionOptions?.body ?? resolvedSchema.values,
+        ...endpoint.adapter && { adapter: endpoint.adapter }
       });
       setMemorizedUnit({ ...unit, ...response });
       return response;
     });
   }
-  async function postUnitsEndpoint(units, options2) {
+  async function postUnitsEndpoint(units, requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.POST_UNITS);
     return withStatus(Endpoint.POST_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
         const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-        if (options2?.validate) {
+        if (requestOptions?.validate) {
           schema.pick(resolvedSchema.keys).parse(unit);
         }
         const response = await api().post(resolveEndpointUrl(endpoint, unit), {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
+          ...requestOptions,
+          body: requestOptions?.body ?? resolvedSchema.values,
+          ...endpoint.adapter && { adapter: endpoint.adapter }
         });
         const clonedUnits = [...memorizedUnits.value];
-        if (options2?.position === "last" /* LAST */) {
+        if (requestOptions?.position === "last" /* LAST */) {
           clonedUnits.push({ ...unit, ...response });
         } else {
           clonedUnits.unshift({ ...unit, ...response });
@@ -183,33 +194,35 @@ export function createStore(entity, schema, endpoints, options) {
       return responses;
     });
   }
-  async function putUnitEndpoint(unit, options2) {
+  async function putUnitEndpoint(unit, requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNIT);
     const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-    if (options2?.validate) {
+    if (requestOptions?.validate) {
       schema.pick(resolvedSchema.keys).parse(unit);
     }
     return withStatus(Endpoint.PUT_UNIT, async () => {
       const response = await api().put(resolveEndpointUrl(endpoint, unit), {
-        ...options2,
-        body: options2?.body ?? resolvedSchema.values
+        ...requestOptions,
+        body: requestOptions?.body ?? resolvedSchema.values,
+        ...endpoint.adapter && { adapter: endpoint.adapter }
       });
       setMemorizedUnit({ ...unit, ...response });
       return response;
     });
   }
-  async function putUnitsEndpoint(units, options2) {
+  async function putUnitsEndpoint(units, requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNITS);
     return withStatus(Endpoint.PUT_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
         const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-        if (options2?.validate) {
+        if (requestOptions?.validate) {
           schema.pick(resolvedSchema.keys).parse(unit);
         }
         const response = await api().put(resolveEndpointUrl(endpoint, unit), {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
+          ...requestOptions,
+          body: requestOptions?.body ?? resolvedSchema.values,
+          ...endpoint.adapter && { adapter: endpoint.adapter }
         });
         editMemorizedUnits([{ ...unit, ...response }]);
         responses.push(response);
@@ -217,33 +230,35 @@ export function createStore(entity, schema, endpoints, options) {
       return responses;
     });
   }
-  async function patchUnitEndpoint(unit, options2) {
+  async function patchUnitEndpoint(unit, requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNIT);
     const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-    if (options2?.validate) {
+    if (requestOptions?.validate) {
       schema.pick(resolvedSchema.keys).partial().parse(unit);
     }
     return withStatus(Endpoint.PATCH_UNIT, async () => {
       const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
-        ...options2,
-        body: options2?.body ?? resolvedSchema.values
+        ...requestOptions,
+        body: requestOptions?.body ?? resolvedSchema.values,
+        ...endpoint.adapter && { adapter: endpoint.adapter }
       });
       editMemorizedUnit({ ...unit, ...response });
       return response;
     });
   }
-  async function patchUnitsEndpoint(units, options2) {
+  async function patchUnitsEndpoint(units, requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNITS);
     return withStatus(Endpoint.PATCH_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
         const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-        if (options2?.validate) {
+        if (requestOptions?.validate) {
           schema.pick(resolvedSchema.keys).partial().parse(unit);
         }
         const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
+          ...requestOptions,
+          body: requestOptions?.body ?? resolvedSchema.values,
+          ...endpoint.adapter && { adapter: endpoint.adapter }
         });
         editMemorizedUnits([{ ...unit, ...response }]);
         responses.push(response);
@@ -251,19 +266,25 @@ export function createStore(entity, schema, endpoints, options) {
       return responses;
     });
   }
-  async function deleteUnitEndpoint(unit, options2) {
+  async function deleteUnitEndpoint(unit, requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNIT);
     return withStatus(Endpoint.DELETE_UNIT, async () => {
-      await api().del(resolveEndpointUrl(endpoint, unit), options2);
+      await api().del(resolveEndpointUrl(endpoint, unit), {
+        ...requestOptions,
+        ...endpoint.adapter && { adapter: endpoint.adapter }
+      });
       dropMemorizedUnit(unit);
       return true;
     });
   }
-  async function deleteUnitsEndpoint(units, options2) {
+  async function deleteUnitsEndpoint(units, requestOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNITS);
     return withStatus(Endpoint.DELETE_UNITS, async () => {
       for (const unit of units) {
-        await api().del(resolveEndpointUrl(endpoint, unit), options2);
+        await api().del(resolveEndpointUrl(endpoint, unit), {
+          ...requestOptions,
+          ...endpoint.adapter && { adapter: endpoint.adapter }
+        });
         dropMemorizedUnits([unit]);
       }
       return true;

package/dist/runtime/index.d.ts

@@ -1,9 +1,13 @@
 export { EndpointMethod, Endpoint, EndpointStatus } from "./utils/endpoint.js";
 export { getMeta, resolveSchema } from "./utils/schema.js";
-export { createApi, ApiResponseType, ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./core/api.js";
+export { createApi } from "./core/api.js";
+export { ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./core/errors.js";
 export { createStore, StoreMemoryPosition } from "./core/store.js";
+export { defineApiAdapter } from "./core/adapter.js";
 export { useStoreAlias } from "./composables/use.js";
 export type { SharedConfig } from "./shared.js";
 export type { EndpointDefinition } from "./utils/endpoint.js";
 export type { SchemaMeta } from "./utils/schema.js";
-export type { ApiRequestHeader, ApiRequestQuery, ApiRequestBody, ApiRequestOptions, ApiOptions, EndpointMethodOptions, ApiErrorOptions, } from "./core/api.js";
+export type { Api, ApiRequestHeader, ApiRequestQuery, ApiRequestBody, ApiRequestOptions, ApiOptions, EndpointMethodOptions, } from "./core/api.js";
+export type { ApiErrorOptions } from "./core/errors.js";
+export type { ApiAdapter, DefineApiAdapter, ApiAdapterRequest, ApiAdapterResponse, ApiFetchAdapterOptions, } from "./core/adapter.js";

package/dist/runtime/index.js

@@ -1,5 +1,7 @@
 export { EndpointMethod, Endpoint, EndpointStatus } from "./utils/endpoint.js";
 export { getMeta, resolveSchema } from "./utils/schema.js";
-export { createApi, ApiResponseType, ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./core/api.js";
+export { createApi } from "./core/api.js";
+export { ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./core/errors.js";
 export { createStore, StoreMemoryPosition } from "./core/store.js";
+export { defineApiAdapter } from "./core/adapter.js";
 export { useStoreAlias } from "./composables/use.js";

package/dist/runtime/shared.d.ts

@@ -1,7 +1,9 @@
+import type { ApiFetchAdapterOptions } from "./core/adapter.js";
 export type SharedConfig = {
     api?: {
-        url?: string;
-        timeout?: number;
+        headers?: Record<string, string>;
+        query?: Record<string, unknown>;
+        adapter?: ApiFetchAdapterOptions;
     };
 };
 export declare const sharedConfig: SharedConfig;

package/dist/runtime/utils/endpoint.d.ts

@@ -1,3 +1,4 @@
+import type { ApiAdapter } from "../core/adapter.js";
 import type { Capitalize } from "./transform.js";
 export declare enum EndpointMethod {
     GET = "get",
@@ -27,6 +28,7 @@ export declare enum EndpointStatus {
 export interface EndpointDefinition<T = Record<string, unknown>> {
     method: EndpointMethod;
     url: string | ((params: T) => string);
+    adapter?: ApiAdapter<any>;
 }
 export type EndpointStatusFlag<S extends EndpointStatus = EndpointStatus> = `Is${Capitalize<S>}`;
 export type EndpointStatusName<K extends Endpoint = Endpoint, S extends EndpointStatus = EndpointStatus> = `${K}${EndpointStatusFlag<S>}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diphyx/harlemify",
-  "version": "1.0.4",
+  "version": "2.0.0",
   "description": "API state management for Nuxt powered by Harlem",
   "keywords": [
     "nuxt",