enlace 0.0.1-beta.3 → 0.0.1-beta.5

package/dist/index.mjs

@@ -2,9 +2,7 @@
 export * from "enlace-core";
 
 // src/react/createEnlaceHook.ts
-import {
-  createEnlace
-} from "enlace-core";
+import { createEnlace } from "enlace-core";
 
 // src/react/useQueryMode.ts
 import { useRef, useReducer, useEffect } from "react";
@@ -20,7 +18,7 @@ var initialState = {
 function hookReducer(state, action) {
   switch (action.type) {
     case "RESET":
-      return action.state;
+      return action.state ?? initialState;
     case "FETCH_START":
       return {
         ...state,
@@ -157,11 +155,29 @@ function onRevalidate(callback) {
 }
 
 // src/react/useQueryMode.ts
+function resolvePath(path, pathParams) {
+  if (!pathParams) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = pathParams[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
 function useQueryMode(api, trackedCall, options) {
-  const { autoGenerateTags, staleTime } = options;
+  const { autoGenerateTags, staleTime, enabled } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(trackedCall.path) : []);
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
+  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
     const hasCachedData = cached?.data !== void 0;
@@ -175,17 +191,22 @@ function useQueryMode(api, trackedCall, options) {
       error: cached?.error
     };
   };
-  const [state, dispatch] = useReducer(hookReducer, null, () => getCacheState(true));
+  const [state, dispatch] = useReducer(
+    hookReducer,
+    null,
+    () => getCacheState(true)
+  );
   const mountedRef = useRef(true);
   const fetchRef = useRef(null);
   useEffect(() => {
     mountedRef.current = true;
+    if (!enabled) {
+      dispatch({ type: "RESET" });
+      return () => {
+        mountedRef.current = false;
+      };
+    }
     dispatch({ type: "RESET", state: getCacheState(true) });
-    const unsubscribe = subscribeCache(queryKey, () => {
-      if (mountedRef.current) {
-        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
-      }
-    });
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -193,7 +214,7 @@ function useQueryMode(api, trackedCall, options) {
       }
       dispatch({ type: "FETCH_START" });
       let current = api;
-      for (const segment of trackedCall.path) {
+      for (const segment of resolvedPath) {
         current = current[segment];
       }
       const method = current[trackedCall.method];
@@ -201,7 +222,7 @@ function useQueryMode(api, trackedCall, options) {
         if (mountedRef.current) {
           setCache(queryKey, {
             data: res.ok ? res.data : void 0,
-            error: res.ok ? void 0 : res.error,
+            error: res.ok || res.status === 0 ? void 0 : res.error,
             ok: res.ok,
             timestamp: Date.now(),
             tags: queryTags
@@ -220,12 +241,17 @@ function useQueryMode(api, trackedCall, options) {
     } else {
       doFetch();
     }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
       unsubscribe();
     };
-  }, [queryKey]);
+  }, [queryKey, enabled]);
   useEffect(() => {
     if (queryTags.length === 0) return;
     return onRevalidate((invalidatedTags) => {
@@ -272,23 +298,56 @@ function createTrackingProxy(onTrack) {
 
 // src/react/useSelectorMode.ts
 import { useRef as useRef2, useReducer as useReducer2 } from "react";
-function useSelectorMode(method, path, autoRevalidateTags) {
+function resolvePath2(path, pathParams) {
+  if (!pathParams) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = pathParams[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
+function hasPathParams(path) {
+  return path.some((segment) => segment.startsWith(":"));
+}
+function useSelectorMode(config) {
+  const { method, api, path, methodName, autoRevalidateTags } = config;
   const [state, dispatch] = useReducer2(hookReducer, initialState);
   const methodRef = useRef2(method);
+  const apiRef = useRef2(api);
   const triggerRef = useRef2(null);
   const pathRef = useRef2(path);
+  const methodNameRef = useRef2(methodName);
   const autoRevalidateRef = useRef2(autoRevalidateTags);
   methodRef.current = method;
+  apiRef.current = api;
   pathRef.current = path;
+  methodNameRef.current = methodName;
   autoRevalidateRef.current = autoRevalidateTags;
   if (!triggerRef.current) {
     triggerRef.current = (async (...args) => {
       dispatch({ type: "FETCH_START" });
-      const res = await methodRef.current(...args);
+      const options = args[0];
+      const resolvedPath = resolvePath2(pathRef.current, options?.pathParams);
+      let res;
+      if (hasPathParams(pathRef.current)) {
+        let current = apiRef.current;
+        for (const segment of resolvedPath) {
+          current = current[segment];
+        }
+        const resolvedMethod = current[methodNameRef.current];
+        res = await resolvedMethod(...args);
+      } else {
+        res = await methodRef.current(...args);
+      }
       if (res.ok) {
         dispatch({ type: "FETCH_SUCCESS", data: res.data });
-        const options = args[0];
-        const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(pathRef.current) : []);
+        const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(resolvedPath) : []);
         if (tagsToInvalidate.length > 0) {
           invalidateTags(tagsToInvalidate);
         }
@@ -306,13 +365,15 @@ function useSelectorMode(method, path, autoRevalidateTags) {
 
 // src/react/createEnlaceHook.ts
 function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
-  const api = createEnlace(baseUrl, defaultOptions);
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
-    staleTime = 0
+    staleTime = 0,
+    onSuccess,
+    onError
   } = hookOptions;
-  function useEnlaceHook(selectorOrQuery) {
+  const api = createEnlace(baseUrl, defaultOptions, { onSuccess, onError });
+  function useEnlaceHook(selectorOrQuery, queryOptions) {
     let trackingResult = {
       trackedCall: null,
       selectorPath: null,
@@ -326,16 +387,18 @@ function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
     );
     if (typeof result === "function") {
       const actualResult = selectorOrQuery(api);
-      return useSelectorMode(
-        actualResult,
-        trackingResult.selectorPath ?? [],
+      return useSelectorMode({
+        method: actualResult,
+        api,
+        path: trackingResult.selectorPath ?? [],
+        methodName: trackingResult.selectorMethod ?? "",
         autoRevalidateTags
-      );
+      });
     }
     return useQueryMode(
       api,
       trackingResult.trackedCall,
-      { autoGenerateTags, staleTime }
+      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
     );
   }
   return useEnlaceHook;

package/dist/next/hook/index.d.mts

@@ -1,4 +1,4 @@
-import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, WildcardClient, EnlaceClient, EnlaceResponse, EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
 
 /** Per-request options for React hooks */
 type ReactRequestOptionsBase = {
@@ -10,6 +10,23 @@ type ReactRequestOptionsBase = {
     tags?: string[];
     /** Tags to invalidate after mutation (triggers refetch in matching queries) */
     revalidateTags?: string[];
+    /**
+     * Path parameters for dynamic URL segments.
+     * Used to replace :paramName placeholders in the URL path.
+     * @example
+     * // With path api.products[':id'].delete
+     * trigger({ pathParams: { id: '123' } }) // → DELETE /products/123
+     */
+    pathParams?: Record<string, string | number>;
+};
+/** Options for query mode hooks */
+type UseEnlaceQueryOptions = {
+    /**
+     * Whether the query should execute.
+     * Set to false to skip fetching (useful when ID is "new" or undefined).
+     * @default true
+     */
+    enabled?: boolean;
 };
 type ApiClient<TSchema, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TOptions>;
 type QueryFn<TSchema, TData, TError, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
@@ -41,7 +58,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-
+/** Options for createEnlaceHook factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -53,6 +70,10 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 
 /**
@@ -62,7 +83,7 @@ type EnlaceHookOptions = {
  */
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
 /** Next.js-specific options (third argument for createEnlace) */
-type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & {
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
@@ -96,13 +117,14 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
      */
     skipRevalidator?: boolean;
 };
-
 type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
+/** Hook type returned by Next.js createEnlaceHook */
 type NextEnlaceHook<TSchema> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError>): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
 };
+
 /**
  * Creates a React hook for making API calls in Next.js Client Components.
  * Uses Next.js-specific features like revalidator for server-side cache invalidation.

package/dist/next/hook/index.d.ts

@@ -1,4 +1,4 @@
-import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, WildcardClient, EnlaceClient, EnlaceResponse, EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
 
 /** Per-request options for React hooks */
 type ReactRequestOptionsBase = {
@@ -10,6 +10,23 @@ type ReactRequestOptionsBase = {
     tags?: string[];
     /** Tags to invalidate after mutation (triggers refetch in matching queries) */
     revalidateTags?: string[];
+    /**
+     * Path parameters for dynamic URL segments.
+     * Used to replace :paramName placeholders in the URL path.
+     * @example
+     * // With path api.products[':id'].delete
+     * trigger({ pathParams: { id: '123' } }) // → DELETE /products/123
+     */
+    pathParams?: Record<string, string | number>;
+};
+/** Options for query mode hooks */
+type UseEnlaceQueryOptions = {
+    /**
+     * Whether the query should execute.
+     * Set to false to skip fetching (useful when ID is "new" or undefined).
+     * @default true
+     */
+    enabled?: boolean;
 };
 type ApiClient<TSchema, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TOptions>;
 type QueryFn<TSchema, TData, TError, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
@@ -41,7 +58,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-
+/** Options for createEnlaceHook factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -53,6 +70,10 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
 
 /**
@@ -62,7 +83,7 @@ type EnlaceHookOptions = {
  */
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
 /** Next.js-specific options (third argument for createEnlace) */
-type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & {
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
@@ -96,13 +117,14 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
      */
     skipRevalidator?: boolean;
 };
-
 type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
+/** Hook type returned by Next.js createEnlaceHook */
 type NextEnlaceHook<TSchema> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError>): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
 };
+
 /**
  * Creates a React hook for making API calls in Next.js Client Components.
  * Uses Next.js-specific features like revalidator for server-side cache invalidation.

package/dist/next/hook/index.js

@@ -48,20 +48,22 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     autoGenerateTags = true,
     autoRevalidateTags = true,
     revalidator,
-    headers: defaultHeaders,
-    ...restOptions
+    onSuccess,
+    ...coreOptions
   } = combinedOptions;
-  const url = (0, import_enlace_core.buildUrl)(baseUrl, path, requestOptions?.query);
-  let headers = (0, import_enlace_core.mergeHeaders)(defaultHeaders, requestOptions?.headers);
   const isGet = method === "GET";
   const autoTags = generateTags(path);
-  const fetchOptions = {
-    ...restOptions,
-    method
+  const nextOnSuccess = (payload) => {
+    if (!isGet && !requestOptions?.skipRevalidator) {
+      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
+      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
+      if (revalidateTags.length || revalidatePaths.length) {
+        revalidator?.(revalidateTags, revalidatePaths);
+      }
+    }
+    onSuccess?.(payload);
   };
-  if (requestOptions?.cache) {
-    fetchOptions.cache = requestOptions.cache;
-  }
+  const nextRequestOptions = { ...requestOptions };
   if (isGet) {
     const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
     const nextFetchOptions = {};
@@ -71,51 +73,27 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
     if (requestOptions?.revalidate !== void 0) {
       nextFetchOptions.revalidate = requestOptions.revalidate;
     }
-    fetchOptions.next = nextFetchOptions;
-  }
-  if (headers) {
-    fetchOptions.headers = headers;
-  }
-  if (requestOptions?.body !== void 0) {
-    if ((0, import_enlace_core.isJsonBody)(requestOptions.body)) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = (0, import_enlace_core.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) {
-    if (!isGet && !requestOptions?.skipRevalidator) {
-      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
-      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
-      if (revalidateTags.length || revalidatePaths.length) {
-        revalidator?.(revalidateTags, revalidatePaths);
-      }
-    }
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
+    nextRequestOptions.next = nextFetchOptions;
   }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
+  return (0, import_enlace_core.executeFetch)(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
 }
 
 // src/next/index.ts
 __reExport(next_exports, require("enlace-core"));
 function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
-  return (0, import_enlace_core2.createProxyHandler)(baseUrl, combinedOptions, [], executeNextFetch);
+  return (0, import_enlace_core2.createProxyHandler)(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }
 
 // src/react/useQueryMode.ts
@@ -132,7 +110,7 @@ var initialState = {
 function hookReducer(state, action) {
   switch (action.type) {
     case "RESET":
-      return action.state;
+      return action.state ?? initialState;
     case "FETCH_START":
       return {
         ...state,
@@ -257,11 +235,29 @@ function onRevalidate(callback) {
 }
 
 // src/react/useQueryMode.ts
+function resolvePath(path, pathParams) {
+  if (!pathParams) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = pathParams[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
 function useQueryMode(api, trackedCall, options) {
-  const { autoGenerateTags, staleTime } = options;
+  const { autoGenerateTags, staleTime, enabled } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(trackedCall.path) : []);
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
+  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
     const hasCachedData = cached?.data !== void 0;
@@ -275,17 +271,22 @@ function useQueryMode(api, trackedCall, options) {
       error: cached?.error
     };
   };
-  const [state, dispatch] = (0, import_react.useReducer)(hookReducer, null, () => getCacheState(true));
+  const [state, dispatch] = (0, import_react.useReducer)(
+    hookReducer,
+    null,
+    () => getCacheState(true)
+  );
   const mountedRef = (0, import_react.useRef)(true);
   const fetchRef = (0, import_react.useRef)(null);
   (0, import_react.useEffect)(() => {
     mountedRef.current = true;
+    if (!enabled) {
+      dispatch({ type: "RESET" });
+      return () => {
+        mountedRef.current = false;
+      };
+    }
     dispatch({ type: "RESET", state: getCacheState(true) });
-    const unsubscribe = subscribeCache(queryKey, () => {
-      if (mountedRef.current) {
-        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
-      }
-    });
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -293,7 +294,7 @@ function useQueryMode(api, trackedCall, options) {
       }
       dispatch({ type: "FETCH_START" });
       let current = api;
-      for (const segment of trackedCall.path) {
+      for (const segment of resolvedPath) {
         current = current[segment];
       }
       const method = current[trackedCall.method];
@@ -301,7 +302,7 @@ function useQueryMode(api, trackedCall, options) {
         if (mountedRef.current) {
           setCache(queryKey, {
             data: res.ok ? res.data : void 0,
-            error: res.ok ? void 0 : res.error,
+            error: res.ok || res.status === 0 ? void 0 : res.error,
             ok: res.ok,
             timestamp: Date.now(),
             tags: queryTags
@@ -320,12 +321,17 @@ function useQueryMode(api, trackedCall, options) {
     } else {
       doFetch();
     }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
       unsubscribe();
     };
-  }, [queryKey]);
+  }, [queryKey, enabled]);
   (0, import_react.useEffect)(() => {
     if (queryTags.length === 0) return;
     return onRevalidate((invalidatedTags) => {
@@ -340,23 +346,56 @@ function useQueryMode(api, trackedCall, options) {
 
 // src/react/useSelectorMode.ts
 var import_react2 = require("react");
-function useSelectorMode(method, path, autoRevalidateTags) {
+function resolvePath2(path, pathParams) {
+  if (!pathParams) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = pathParams[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
+function hasPathParams(path) {
+  return path.some((segment) => segment.startsWith(":"));
+}
+function useSelectorMode(config) {
+  const { method, api, path, methodName, autoRevalidateTags } = config;
   const [state, dispatch] = (0, import_react2.useReducer)(hookReducer, initialState);
   const methodRef = (0, import_react2.useRef)(method);
+  const apiRef = (0, import_react2.useRef)(api);
   const triggerRef = (0, import_react2.useRef)(null);
   const pathRef = (0, import_react2.useRef)(path);
+  const methodNameRef = (0, import_react2.useRef)(methodName);
   const autoRevalidateRef = (0, import_react2.useRef)(autoRevalidateTags);
   methodRef.current = method;
+  apiRef.current = api;
   pathRef.current = path;
+  methodNameRef.current = methodName;
   autoRevalidateRef.current = autoRevalidateTags;
   if (!triggerRef.current) {
     triggerRef.current = (async (...args) => {
       dispatch({ type: "FETCH_START" });
-      const res = await methodRef.current(...args);
+      const options = args[0];
+      const resolvedPath = resolvePath2(pathRef.current, options?.pathParams);
+      let res;
+      if (hasPathParams(pathRef.current)) {
+        let current = apiRef.current;
+        for (const segment of resolvedPath) {
+          current = current[segment];
+        }
+        const resolvedMethod = current[methodNameRef.current];
+        res = await resolvedMethod(...args);
+      } else {
+        res = await methodRef.current(...args);
+      }
       if (res.ok) {
         dispatch({ type: "FETCH_SUCCESS", data: res.data });
-        const options = args[0];
-        const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(pathRef.current) : []);
+        const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(resolvedPath) : []);
         if (tagsToInvalidate.length > 0) {
           invalidateTags(tagsToInvalidate);
         }
@@ -417,26 +456,30 @@ function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
     autoRevalidateTags,
     ...nextOptions
   });
-  function useEnlaceHook(selectorOrQuery) {
+  function useEnlaceHook(selectorOrQuery, queryOptions) {
     let trackedCall = null;
     let selectorPath = null;
+    let selectorMethod = null;
     const trackingProxy = createTrackingProxy((result2) => {
       trackedCall = result2.trackedCall;
       selectorPath = result2.selectorPath;
+      selectorMethod = result2.selectorMethod;
     });
     const result = selectorOrQuery(trackingProxy);
     if (typeof result === "function") {
       const actualResult = selectorOrQuery(api);
-      return useSelectorMode(
-        actualResult,
-        selectorPath ?? [],
+      return useSelectorMode({
+        method: actualResult,
+        api,
+        path: selectorPath ?? [],
+        methodName: selectorMethod ?? "",
         autoRevalidateTags
-      );
+      });
     }
     return useQueryMode(
       api,
       trackedCall,
-      { autoGenerateTags, staleTime }
+      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
     );
   }
   return useEnlaceHook;