enlace 0.0.1-beta.5 → 0.0.1-beta.6

package/dist/{next/hook → hook}/index.mjs

@@ -1,96 +1,8 @@
 "use client";
 "use client";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createEnlace: () => createEnlace
-});
-import {
-  createProxyHandler
-} from "enlace-core";
-
-// src/next/fetch.ts
-import {
-  executeFetch
-} from "enlace-core";
-
-// src/utils/generateTags.ts
-function generateTags(path) {
-  return path.map((_, i) => path.slice(0, i + 1).join("/"));
-}
-
-// src/next/fetch.ts
-async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
-  const {
-    autoGenerateTags = true,
-    autoRevalidateTags = true,
-    revalidator,
-    onSuccess,
-    ...coreOptions
-  } = combinedOptions;
-  const isGet = method === "GET";
-  const autoTags = generateTags(path);
-  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);
-  };
-  const nextRequestOptions = { ...requestOptions };
-  if (isGet) {
-    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
-    const nextFetchOptions = {};
-    if (tags) {
-      nextFetchOptions.tags = tags;
-    }
-    if (requestOptions?.revalidate !== void 0) {
-      nextFetchOptions.revalidate = requestOptions.revalidate;
-    }
-    nextRequestOptions.next = nextFetchOptions;
-  }
-  return executeFetch(
-    baseUrl,
-    path,
-    method,
-    { ...coreOptions, onSuccess: nextOnSuccess },
-    nextRequestOptions
-  );
-}
 
-// src/next/index.ts
-__reExport(next_exports, enlace_core_star);
-import * as enlace_core_star from "enlace-core";
-function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
-  const combinedOptions = { ...defaultOptions, ...nextOptions };
-  return createProxyHandler(
-    baseUrl,
-    combinedOptions,
-    [],
-    executeNextFetch
-  );
-}
+// src/react/createEnlaceHookReact.ts
+import { createEnlace } from "enlace-core";
 
 // src/react/useQueryMode.ts
 import { useRef, useReducer, useEffect } from "react";
@@ -136,6 +48,11 @@ function hookReducer(state, action) {
   }
 }
 
+// src/utils/generateTags.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
+}
+
 // src/utils/sortObjectKeys.ts
 function sortObjectKeys(obj) {
   if (obj === null || typeof obj !== "object") return obj;
@@ -340,6 +257,38 @@ function useQueryMode(api, trackedCall, options) {
   return state;
 }
 
+// src/react/types.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+
+// src/react/trackingProxy.ts
+function createTrackingProxy(onTrack) {
+  const createProxy = (path = []) => {
+    return new Proxy(() => {
+    }, {
+      get(_, prop) {
+        if (HTTP_METHODS.includes(prop)) {
+          const methodFn = (options) => {
+            onTrack({
+              trackedCall: { path, method: prop, options },
+              selectorPath: null,
+              selectorMethod: null
+            });
+            return Promise.resolve({ ok: true, data: void 0 });
+          };
+          onTrack({
+            trackedCall: null,
+            selectorPath: path,
+            selectorMethod: prop
+          });
+          return methodFn;
+        }
+        return createProxy([...path, prop]);
+      }
+    });
+  };
+  return createProxy();
+}
+
 // src/react/useSelectorMode.ts
 import { useRef as useRef2, useReducer as useReducer2 } from "react";
 function resolvePath2(path, pathParams) {
@@ -407,47 +356,117 @@ function useSelectorMode(config) {
   };
 }
 
-// src/react/types.ts
-var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+// src/react/createEnlaceHookReact.ts
+function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    staleTime = 0,
+    onSuccess,
+    onError
+  } = hookOptions;
+  const api = createEnlace(baseUrl, defaultOptions, { onSuccess, onError });
+  function useEnlaceHook(selectorOrQuery, queryOptions) {
+    let trackingResult = {
+      trackedCall: null,
+      selectorPath: null,
+      selectorMethod: null
+    };
+    const trackingProxy = createTrackingProxy((result2) => {
+      trackingResult = result2;
+    });
+    const result = selectorOrQuery(
+      trackingProxy
+    );
+    if (typeof result === "function") {
+      const actualResult = selectorOrQuery(api);
+      return useSelectorMode({
+        method: actualResult,
+        api,
+        path: trackingResult.selectorPath ?? [],
+        methodName: trackingResult.selectorMethod ?? "",
+        autoRevalidateTags
+      });
+    }
+    return useQueryMode(
+      api,
+      trackingResult.trackedCall,
+      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+    );
+  }
+  return useEnlaceHook;
+}
 
-// src/react/trackingProxy.ts
-function createTrackingProxy(onTrack) {
-  const createProxy = (path = []) => {
-    return new Proxy(() => {
-    }, {
-      get(_, prop) {
-        if (HTTP_METHODS.includes(prop)) {
-          const methodFn = (options) => {
-            onTrack({
-              trackedCall: { path, method: prop, options },
-              selectorPath: null,
-              selectorMethod: null
-            });
-            return Promise.resolve({ ok: true, data: void 0 });
-          };
-          onTrack({
-            trackedCall: null,
-            selectorPath: path,
-            selectorMethod: prop
-          });
-          return methodFn;
-        }
-        return createProxy([...path, prop]);
+// src/next/index.ts
+import {
+  createProxyHandler
+} from "enlace-core";
+
+// src/next/fetch.ts
+import {
+  executeFetch
+} from "enlace-core";
+async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    revalidator,
+    onSuccess,
+    ...coreOptions
+  } = combinedOptions;
+  const isGet = method === "GET";
+  const autoTags = generateTags(path);
+  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);
   };
-  return createProxy();
+  const nextRequestOptions = { ...requestOptions };
+  if (isGet) {
+    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
+    const nextFetchOptions = {};
+    if (tags) {
+      nextFetchOptions.tags = tags;
+    }
+    if (requestOptions?.revalidate !== void 0) {
+      nextFetchOptions.revalidate = requestOptions.revalidate;
+    }
+    nextRequestOptions.next = nextFetchOptions;
+  }
+  return executeFetch(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
+}
+
+// src/next/index.ts
+function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+  const combinedOptions = { ...defaultOptions, ...nextOptions };
+  return createProxyHandler(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }
 
-// src/next/createEnlaceHook.ts
-function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/next/createEnlaceHookNext.ts
+function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
     staleTime = 0,
     ...nextOptions
   } = hookOptions;
-  const api = createEnlace(baseUrl, defaultOptions, {
+  const api = createEnlaceNext(baseUrl, defaultOptions, {
     autoGenerateTags,
     autoRevalidateTags,
     ...nextOptions
@@ -481,5 +500,7 @@ function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
   return useEnlaceHook;
 }
 export {
-  createEnlaceHook
+  HTTP_METHODS,
+  createEnlaceHookNext,
+  createEnlaceHookReact
 };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceResponse, WildcardClient, EnlaceClient, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceCallbacks, EnlaceOptions, WildcardClient, EnlaceClient } from 'enlace-core';
 export * from 'enlace-core';
 
 /** Per-request options for React hooks */
@@ -20,59 +20,7 @@ type ReactRequestOptionsBase = {
      */
     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>>;
-type SelectorFn<TSchema, TMethod, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => TMethod;
-type HookState = {
-    loading: boolean;
-    fetching: boolean;
-    ok: boolean | undefined;
-    data: unknown;
-    error: unknown;
-};
-type TrackedCall = {
-    path: string[];
-    method: string;
-    options: unknown;
-};
-declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete"];
-type ExtractData<T> = T extends (...args: any[]) => Promise<EnlaceResponse<infer D, unknown>> ? D : never;
-type ExtractError<T> = T extends (...args: any[]) => Promise<EnlaceResponse<unknown, infer E>> ? E : never;
-/** Discriminated union for hook response state - enables type narrowing on ok check */
-type HookResponseState<TData, TError> = {
-    ok: undefined;
-    data: undefined;
-    error: undefined;
-} | {
-    ok: true;
-    data: TData;
-    error: undefined;
-} | {
-    ok: false;
-    data: undefined;
-    error: TError;
-};
-/** Result when hook is called with query function (auto-fetch mode) */
-type UseEnlaceQueryResult<TData, TError> = {
-    loading: boolean;
-    fetching: boolean;
-} & HookResponseState<TData, TError>;
-/** Result when hook is called with method selector (trigger mode) */
-type UseEnlaceSelectorResult<TMethod> = {
-    trigger: TMethod;
-    loading: boolean;
-    fetching: boolean;
-} & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-/** Options for createEnlaceHook factory */
+/** Options for createEnlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -89,32 +37,47 @@ type EnlaceHookOptions = {
     /** Callback called on error responses (HTTP errors or network failures) */
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
-/** Hook type returned by createEnlaceHook */
-type EnlaceHook<TSchema> = {
-    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
-};
 
 /**
- * Creates a React hook for making API calls.
- * Called at module level to create a reusable hook.
- *
- * @example
- * const useAPI = createEnlaceHook<ApiSchema>('https://api.com');
- *
- * // Query mode - auto-fetch (auto-tracks changes, no deps array needed)
- * const { loading, data, error } = useAPI((api) => api.posts.get({ query: { userId } }));
- *
- * // Selector mode - typed trigger for lazy calls
- * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
- * onClick={() => trigger({ body: { id: 1 } })}
+ * Handler function called after successful mutations to trigger server-side revalidation.
+ * @param tags - Cache tags to revalidate
+ * @param paths - URL paths to revalidate
  */
-declare function createEnlaceHook<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
-
-type Listener = (tags: string[]) => void;
-declare function invalidateTags(tags: string[]): void;
-declare function onRevalidate(callback: Listener): () => void;
+type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
+/** Next.js-specific options (third argument for createEnlaceNext) */
+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.
+     * @example
+     * ```ts
+     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     *   revalidator: (tags, paths) => revalidateServerAction(tags, paths)
+     * });
+     * ```
+     */
+    revalidator?: RevalidateHandler;
+};
+/** Per-request options for Next.js fetch - extends React's base options */
+type NextRequestOptionsBase = ReactRequestOptionsBase & {
+    /** Time in seconds to revalidate, or false to disable */
+    revalidate?: number | false;
+    /**
+     * URL paths to revalidate after mutation
+     * This doesn't do anything on the client by itself - it's passed to the revalidator handler.
+     * You must implement the revalidation logic in the revalidator.
+     */
+    revalidatePaths?: string[];
+    /**
+     * Skip server-side revalidation for this request.
+     * Useful when autoRevalidateTags is enabled but you want to opt-out for specific mutations.
+     * You can still pass empty [] to revalidateTags to skip triggering revalidation.
+     * But this flag can be used if you want to revalidate client-side and skip server-side entirely.
+     * Eg. you don't fetch any data on server component and you might want to skip the overhead of revalidation.
+     */
+    skipRevalidator?: boolean;
+};
 
-declare function clearCache(key?: string): void;
+declare function createEnlaceNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };
+export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceResponse, WildcardClient, EnlaceClient, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceCallbacks, EnlaceOptions, WildcardClient, EnlaceClient } from 'enlace-core';
 export * from 'enlace-core';
 
 /** Per-request options for React hooks */
@@ -20,59 +20,7 @@ type ReactRequestOptionsBase = {
      */
     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>>;
-type SelectorFn<TSchema, TMethod, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => TMethod;
-type HookState = {
-    loading: boolean;
-    fetching: boolean;
-    ok: boolean | undefined;
-    data: unknown;
-    error: unknown;
-};
-type TrackedCall = {
-    path: string[];
-    method: string;
-    options: unknown;
-};
-declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete"];
-type ExtractData<T> = T extends (...args: any[]) => Promise<EnlaceResponse<infer D, unknown>> ? D : never;
-type ExtractError<T> = T extends (...args: any[]) => Promise<EnlaceResponse<unknown, infer E>> ? E : never;
-/** Discriminated union for hook response state - enables type narrowing on ok check */
-type HookResponseState<TData, TError> = {
-    ok: undefined;
-    data: undefined;
-    error: undefined;
-} | {
-    ok: true;
-    data: TData;
-    error: undefined;
-} | {
-    ok: false;
-    data: undefined;
-    error: TError;
-};
-/** Result when hook is called with query function (auto-fetch mode) */
-type UseEnlaceQueryResult<TData, TError> = {
-    loading: boolean;
-    fetching: boolean;
-} & HookResponseState<TData, TError>;
-/** Result when hook is called with method selector (trigger mode) */
-type UseEnlaceSelectorResult<TMethod> = {
-    trigger: TMethod;
-    loading: boolean;
-    fetching: boolean;
-} & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-/** Options for createEnlaceHook factory */
+/** Options for createEnlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -89,32 +37,47 @@ type EnlaceHookOptions = {
     /** Callback called on error responses (HTTP errors or network failures) */
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
-/** Hook type returned by createEnlaceHook */
-type EnlaceHook<TSchema> = {
-    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
-};
 
 /**
- * Creates a React hook for making API calls.
- * Called at module level to create a reusable hook.
- *
- * @example
- * const useAPI = createEnlaceHook<ApiSchema>('https://api.com');
- *
- * // Query mode - auto-fetch (auto-tracks changes, no deps array needed)
- * const { loading, data, error } = useAPI((api) => api.posts.get({ query: { userId } }));
- *
- * // Selector mode - typed trigger for lazy calls
- * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
- * onClick={() => trigger({ body: { id: 1 } })}
+ * Handler function called after successful mutations to trigger server-side revalidation.
+ * @param tags - Cache tags to revalidate
+ * @param paths - URL paths to revalidate
  */
-declare function createEnlaceHook<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
-
-type Listener = (tags: string[]) => void;
-declare function invalidateTags(tags: string[]): void;
-declare function onRevalidate(callback: Listener): () => void;
+type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
+/** Next.js-specific options (third argument for createEnlaceNext) */
+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.
+     * @example
+     * ```ts
+     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     *   revalidator: (tags, paths) => revalidateServerAction(tags, paths)
+     * });
+     * ```
+     */
+    revalidator?: RevalidateHandler;
+};
+/** Per-request options for Next.js fetch - extends React's base options */
+type NextRequestOptionsBase = ReactRequestOptionsBase & {
+    /** Time in seconds to revalidate, or false to disable */
+    revalidate?: number | false;
+    /**
+     * URL paths to revalidate after mutation
+     * This doesn't do anything on the client by itself - it's passed to the revalidator handler.
+     * You must implement the revalidation logic in the revalidator.
+     */
+    revalidatePaths?: string[];
+    /**
+     * Skip server-side revalidation for this request.
+     * Useful when autoRevalidateTags is enabled but you want to opt-out for specific mutations.
+     * You can still pass empty [] to revalidateTags to skip triggering revalidation.
+     * But this flag can be used if you want to revalidate client-side and skip server-side entirely.
+     * Eg. you don't fetch any data on server component and you might want to skip the overhead of revalidation.
+     */
+    skipRevalidator?: boolean;
+};
 
-declare function clearCache(key?: string): void;
+declare function createEnlaceNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };
+export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };