@mmstack/resource 19.2.0 → 20.0.1

package/index.d.ts

@@ -1 +1,520 @@
-export * from './lib/public_api';
+import { HttpResponse, HttpInterceptorFn, HttpContext, HttpResourceOptions, HttpResourceRequest, HttpResourceRef } from '@angular/common/http';
+import { Signal, Injector, Provider, ValueEqualityFn } from '@angular/core';
+
+/**
+ * Options for configuring the Least Recently Used (LRU) cache cleanup strategy.
+ * @internal
+ */
+type LRUCleanupType = {
+    type: 'lru';
+    /**
+     * How often to check for expired or excess entries, in milliseconds.
+     */
+    checkInterval: number;
+    /**
+     * The maximum number of entries to keep in the cache.  When the cache exceeds this size,
+     * the least recently used entries will be removed.
+     */
+    maxSize: number;
+};
+/**
+ * Options for configuring the "oldest first" cache cleanup strategy.
+ * @internal
+ */
+type OldsetCleanupType = {
+    type: 'oldest';
+    /**
+     * How often to check for expired or excess entries, in milliseconds.
+     */
+    checkInterval: number;
+    /**
+     * The maximum number of entries to keep in the cache.  When the cache exceeds this size,
+     * the oldest entries will be removed.
+     */
+    maxSize: number;
+};
+/**
+ * Represents an entry in the cache.
+ * @internal
+ */
+type CacheEntry<T> = {
+    value: T;
+    created: number;
+    stale: number;
+    useCount: number;
+    expiresAt: number;
+    timeout: ReturnType<typeof setTimeout>;
+};
+/**
+ * Defines the types of cleanup strategies available for the cache.
+ * - `lru`: Least Recently Used.  Removes the least recently accessed entries when the cache is full.
+ * - `oldest`: Removes the oldest entries when the cache is full.
+ */
+type CleanupType = LRUCleanupType | OldsetCleanupType;
+/**
+ * A generic cache implementation that stores data with time-to-live (TTL) and stale-while-revalidate capabilities.
+ *
+ * @typeParam T - The type of data to be stored in the cache.
+ */
+declare class Cache<T> {
+    protected readonly ttl: number;
+    protected readonly staleTime: number;
+    private readonly internal;
+    private readonly cleanupOpt;
+    /**
+     * Creates a new `Cache` instance.
+     *
+     * @param ttl - The default Time To Live (TTL) for cache entries, in milliseconds.  Defaults to one day.
+     * @param staleTime - The default duration, in milliseconds, during which a cache entry is considered
+     *                    stale but can still be used while revalidation occurs in the background. Defaults to 1 hour.
+     * @param cleanupOpt - Options for configuring the cache cleanup strategy.  Defaults to LRU with a
+     *                     `maxSize` of 200 and a `checkInterval` of one hour.
+     */
+    constructor(ttl?: number, staleTime?: number, cleanupOpt?: Partial<CleanupType>);
+    /** @internal */
+    private getInternal;
+    /**
+     * Retrieves a cache entry without affecting its usage count (for LRU).  This is primarily
+     * for internal use or debugging.
+     * @internal
+     * @param key - The key of the entry to retrieve.
+     * @returns The cache entry, or `null` if not found or expired.
+     */
+    getUntracked(key: string): (CacheEntry<T> & {
+        isStale: boolean;
+    }) | null;
+    /**
+     * Retrieves a cache entry as a signal.
+     *
+     * @param key - A function that returns the cache key. The key is a signal, allowing for dynamic keys. If the function returns null the value is also null.
+     * @returns A signal that holds the cache entry, or `null` if not found or expired.  The signal
+     *          updates whenever the cache entry changes (e.g., due to revalidation or expiration).
+     */
+    get(key: () => string | null): Signal<(CacheEntry<T> & {
+        isStale: boolean;
+    }) | null>;
+    /**
+     * Stores a value in the cache.
+     *
+     * @param key - The key under which to store the value.
+     * @param value - The value to store.
+     * @param staleTime - (Optional) The stale time for this entry, in milliseconds. Overrides the default `staleTime`.
+     * @param ttl - (Optional) The TTL for this entry, in milliseconds. Overrides the default `ttl`.
+     */
+    store(key: string, value: T, staleTime?: number, ttl?: number): void;
+    /**
+     * Invalidates (removes) a cache entry.
+     *
+     * @param key - The key of the entry to invalidate.
+     */
+    invalidate(key: string): void;
+    /** @internal */
+    private cleanup;
+}
+/**
+ * Options for configuring the cache.
+ */
+type CacheOptions = {
+    /**
+     * The default Time To Live (TTL) for cache entries, in milliseconds.
+     */
+    ttl?: number;
+    /**
+     * The default duration, in milliseconds, during which a cache entry is considered
+     * stale but can still be used while revalidation occurs in the background.
+     */
+    staleTime?: number;
+    /**
+     * Options for configuring the cache cleanup strategy.
+     */
+    cleanup?: Partial<CleanupType>;
+};
+/**
+ * Provides the instance of the QueryCache for queryResource. This should probably be called
+ * in your application's root configuration, but can also be overriden with component/module providers.
+ *
+ * @param options - Optional configuration options for the cache.
+ * @returns An Angular `Provider` for the cache.
+ *
+ * @example
+ * // In your app.config.ts or AppModule providers:
+ *
+ * import { provideQueryCache } from './your-cache';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideQueryCache({
+ *       ttl: 60000, // Default TTL of 60 seconds
+ *       staleTime: 30000, // Default staleTime of 30 seconds
+ *     }),
+ *     // ... other providers
+ *   ]
+ * };
+ */
+declare function provideQueryCache(opt?: CacheOptions): Provider;
+/**
+ * Injects the `QueryCache` instance that is used within queryResource.
+ * Allows for direct modification of cached data, but is mostly meant for internal use.
+ *
+ * @param injector - (Optional) The injector to use.  If not provided, the current
+ *                   injection context is used.
+ * @returns The `QueryCache` instance.
+ *
+ * @example
+ * // In your component or service:
+ *
+ * import { injectQueryCache } from './your-cache';
+ *
+ * constructor() {
+ *   const cache = injectQueryCache();
+ *
+ *   const myData = cache.get(() => 'my-data-key');
+ *   if (myData() !== null) {
+ *     // ... use cached data ...
+ *   }
+ * }
+ */
+declare function injectQueryCache(injector?: Injector): Cache<HttpResponse<unknown>>;
+
+/**
+ * Creates an `HttpInterceptorFn` that implements caching for HTTP requests. This interceptor
+ * checks for a caching configuration in the request's `HttpContext` (internally set by the queryResource).
+ * If caching is enabled, it attempts to retrieve responses from the cache. If a cached response
+ * is found and is not stale, it's returned directly.  If the cached response is stale, it's returned,
+ * and a background revalidation request is made.  If no cached response is found, the request
+ * is made to the server, and the response is cached according to the configured TTL and staleness.
+ * The interceptor also respects `Cache-Control` headers from the server.
+ *
+ * @param allowedMethods - An array of HTTP methods for which caching should be enabled.
+ *                        Defaults to `['GET', 'HEAD', 'OPTIONS']`.
+ *
+ * @returns An `HttpInterceptorFn` that implements the caching logic.
+ *
+ * @example
+ * // In your app.config.ts or module providers:
+ *
+ * import { provideHttpClient, withInterceptors } from '@angular/common/http';
+ * import { createCacheInterceptor } from '@mmstack/resource';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(withInterceptors([createCacheInterceptor()])),
+ *     // ... other providers
+ *   ],
+ * };
+ */
+declare function createCacheInterceptor(allowedMethods?: string[]): HttpInterceptorFn;
+
+/**
+ * Represents the possible states of a circuit breaker.
+ * - `CLOSED`: The circuit breaker is closed, and operations are allowed to proceed.
+ * - `OPEN`: The circuit breaker is open, and operations are blocked.
+ * - `HALF_OPEN`: The circuit breaker is in a half-open state, allowing a limited number of operations to test if the underlying issue is resolved.
+ */
+type CircuitBreakerState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+/**
+ * Represents a circuit breaker, which monitors operations and prevents failures from cascading.
+ */
+type CircuitBreaker = {
+    /**
+     * A signal indicating whether the circuit breaker is currently closed (allowing operations).
+     */
+    isClosed: Signal<boolean>;
+    /**
+     * A signal representing the current state of the circuit breaker.
+     */
+    status: Signal<CircuitBreakerState>;
+    /**
+     * Signals a failure to the circuit breaker.  This may cause the circuit breaker to open.
+     */
+    fail: () => void;
+    /**
+     * Signals a success to the circuit breaker.  This may cause the circuit breaker to close.
+     */
+    success: () => void;
+    /**
+     * Attempts to transition the circuit breaker to the half-open state. This is typically used
+     * to test if the underlying issue has been resolved after the circuit breaker has been open.
+     */
+    halfOpen: () => void;
+    /**
+     * Destroys the circuit breaker & initiates related cleanup
+     */
+    destroy: () => void;
+};
+/**
+ * Options for creating a circuit breaker.
+ *  - `false`: Disables circuit breaker functionality (always open).
+ *  - true: Creates a new circuit breaker with default options.
+ *  - `CircuitBreaker`: Provides an existing `CircuitBreaker` instance to use.
+ *  - `{ treshold?: number; timeout?: number; }`: Creates a new circuit breaker with the specified options.
+ */
+type CircuitBreakerOptions = false | CircuitBreaker | {
+    treshold?: number;
+    timeout?: number;
+};
+/**
+ * Creates a circuit breaker instance.
+ *
+ * @param options - Configuration options for the circuit breaker.  Can be:
+ *   - `undefined`:  Creates a "no-op" circuit breaker that is always open (never trips).
+ *   - `true`: Creates a circuit breaker with default settings (threshold: 5, timeout: 30000ms).
+ *   - `CircuitBreaker`:  Reuses an existing `CircuitBreaker` instance.
+ *   - `{ threshold?: number; timeout?: number; }`: Creates a circuit breaker with the specified threshold and timeout.
+ *
+ * @returns A `CircuitBreaker` instance.
+ *
+ * @example
+ * // Create a circuit breaker with default settings:
+ * const breaker = createCircuitBreaker();
+ *
+ * // Create a circuit breaker with custom settings:
+ * const customBreaker = createCircuitBreaker({ threshold: 10, timeout: 60000 });
+ *
+ * // Share a single circuit breaker instance across multiple resources:
+ * const sharedBreaker = createCircuitBreaker();
+ * const resource1 = queryResource(..., { circuitBreaker: sharedBreaker });
+ * const resource2 = mutationResource(..., { circuitBreaker: sharedBreaker });
+ */
+declare function createCircuitBreaker(opt?: CircuitBreakerOptions): CircuitBreaker;
+
+/**
+ * Disables request deduplication for a specific HTTP request.
+ *
+ * @param ctx - The `HttpContext` to modify. If not provided, a new `HttpContext` is created.
+ * @returns The modified `HttpContext` with the `NO_DEDUPE` token set to `true`.
+ *
+ * @example
+ * // Disable deduplication for a specific POST request:
+ * const context = noDedupe();
+ * this.http.post('/api/data', payload, { context }).subscribe(...);
+ *
+ * // Disable deduplication, modifying an existing context:
+ * let context = new HttpContext();
+ * context = noDedupe(context);
+ * this.http.post('/api/data', payload, { context }).subscribe(...);
+ */
+declare function noDedupe(ctx?: HttpContext): HttpContext;
+/**
+ * Creates an `HttpInterceptorFn` that deduplicates identical HTTP requests.
+ * If multiple identical requests (same URL and parameters) are made concurrently,
+ * only the first request will be sent to the server. Subsequent requests will
+ * receive the response from the first request.
+ *
+ * @param allowed - An array of HTTP methods for which deduplication should be enabled.
+ *                  Defaults to `['GET', 'DELETE', 'HEAD', 'OPTIONS']`.
+ *
+ * @returns An `HttpInterceptorFn` that implements the request deduplication logic.
+ *
+ * @example
+ * // In your app.config.ts or module providers:
+ * import { provideHttpClient, withInterceptors } from '@angular/common/http';
+ * import { createDedupeRequestsInterceptor } from './your-dedupe-interceptor';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(withInterceptors([createDedupeRequestsInterceptor()])),
+ *     // ... other providers
+ *   ],
+ * };
+ *
+ * // You can also specify which methods should be deduped
+ *  export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(withInterceptors([createDedupeRequestsInterceptor(['GET'])])), // only dedupe GET calls
+ *     // ... other providers
+ *   ],
+ * };
+ */
+declare function createDedupeRequestsInterceptor(allowed?: string[]): HttpInterceptorFn;
+
+type RetryOptions = number | {
+    max?: number;
+    backoff?: number;
+};
+
+/**
+ * Options for configuring caching behavior of a `queryResource`.
+ * - `true`: Enables caching with default settings.
+ * - `{ ttl?: number; staleTime?: number; hash?: (req: HttpResourceRequest) => string; }`:  Configures caching with custom settings.
+ */
+type ResourceCacheOptions = true | {
+    /**
+     * The Time To Live (TTL) for the cached data, in milliseconds. After this time, the cached data is
+     * considered expired and will be refetched.
+     */
+    ttl?: number;
+    /**
+     * The duration, in milliseconds, during which stale data can be served while a revalidation request
+     * is made in the background.
+     */
+    staleTime?: number;
+    /**
+     * A custom function to generate the cache key. Defaults to using the request URL with parameters.
+     * Provide a custom hash function if you need more control over how cache keys are generated,
+     * for instance, to ignore certain query parameters or to use request body for the cache key.
+     */
+    hash?: (req: HttpResourceRequest) => string;
+};
+/**
+ * Options for configuring a `queryResource`.
+ */
+type QueryResourceOptions<TResult, TRaw = TResult> = HttpResourceOptions<TResult, TRaw> & {
+    /**
+     * Whether to keep the previous value of the resource while a refresh is in progress.
+     * Defaults to `false`. Also keeps status & headers while refreshing.
+     */
+    keepPrevious?: boolean;
+    /**
+     * The refresh interval, in milliseconds. If provided, the resource will automatically
+     * refresh its data at the specified interval.
+     */
+    refresh?: number;
+    /**
+     * Options for retrying failed requests.
+     */
+    retry?: RetryOptions;
+    /**
+     * An optional error handler callback.  This function will be called whenever the
+     * underlying HTTP request fails. Useful for displaying toasts or other error messages.
+     */
+    onError?: (err: unknown) => void;
+    /**
+     * Options for configuring a circuit breaker for the resource.
+     */
+    circuitBreaker?: CircuitBreakerOptions | true;
+    /**
+     * Options for enabling and configuring caching for the resource.
+     */
+    cache?: ResourceCacheOptions;
+    /**
+     * Trigger a request every time the request function is triggered, even if the request parameters are the same.
+     * @default false
+     */
+    triggerOnSameRequest?: boolean;
+};
+/**
+ * Represents a resource created by `queryResource`. Extends `HttpResourceRef` with additional properties.
+ */
+type QueryResourceRef<TResult> = HttpResourceRef<TResult> & {
+    /**
+     * A signal indicating whether the resource is currently disabled (due to circuit breaker or undefined request).
+     */
+    disabled: Signal<boolean>;
+    /**
+     * Prefetches data for the resource, populating the cache if caching is enabled.  This can be
+     * used to proactively load data before it's needed.  If a slow connection is detected, prefetching is skipped.
+     *
+     * @param req - Optional partial request parameters to use for the prefetch.  This allows you
+     *              to prefetch data with different parameters than the main resource request.
+     */
+    prefetch: (req?: Partial<HttpResourceRequest>) => Promise<void>;
+};
+declare function queryResource<TResult, TRaw = TResult>(request: () => HttpResourceRequest | undefined | void, options: QueryResourceOptions<TResult, TRaw> & {
+    defaultValue: NoInfer<TResult>;
+}): QueryResourceRef<TResult>;
+/**
+ * Creates an extended HTTP resource with features like caching, retries, refresh intervals,
+ * circuit breaker, and optimistic updates. Without additional options it is equivalent to simply calling `httpResource`.
+ *
+ * @param request A function that returns the `HttpResourceRequest` to be made.  This function
+ *                is called reactively, so the request can change over time.  If the function
+ *                returns `undefined`, the resource is considered "disabled" and no request will be made.
+ * @param options Configuration options for the resource.  These options extend the basic
+ *                `HttpResourceOptions` and add features like `keepPrevious`, `refresh`, `retry`,
+ *                `onError`, `circuitBreaker`, and `cache`.
+ * @returns An `QueryResourceRef` instance, which extends the basic `HttpResourceRef` with additional features.
+ */
+declare function queryResource<TResult, TRaw = TResult>(request: () => HttpResourceRequest | undefined | void, options?: QueryResourceOptions<TResult, TRaw>): QueryResourceRef<TResult | undefined>;
+
+/**
+ * @internal
+ * Helper type for inferring the request body type based on the HTTP method.
+ */
+type NextRequest<TMethod extends HttpResourceRequest['method'], TMutation> = TMethod extends 'DELETE' | 'delete' ? Omit<HttpResourceRequest, 'body' | 'method'> & {
+    method?: TMethod;
+} : Omit<HttpResourceRequest, 'body' | 'method'> & {
+    body: TMutation;
+    method?: TMethod;
+};
+/**
+ * Options for configuring a `mutationResource`.
+ *
+ * @typeParam TResult - The type of the expected result from the mutation.
+ * @typeParam TRaw - The raw response type from the HTTP request (defaults to TResult).
+ * @typeParam TCTX - The type of the context value returned by `onMutate`.
+ */
+type MutationResourceOptions<TResult, TRaw = TResult, TMutation = TResult, TCTX = void, TICTX = TCTX> = Omit<QueryResourceOptions<TResult, TRaw>, 'equal' | 'onError' | 'keepPrevious' | 'refresh' | 'cache'> & {
+    /**
+     * A callback function that is called before the mutation request is made.
+     * @param value The value being mutated (the `body` of the request).
+     * @returns An optional context value that will be passed to the `onError`, `onSuccess`, and `onSettled` callbacks. This is useful for storing
+     *  information needed during the mutation lifecycle, such as previous values for optimistic updates or rollback.
+     */
+    onMutate?: (value: TMutation, initialCTX?: TICTX) => TCTX;
+    /**
+     * A callback function that is called if the mutation request fails.
+     * @param error The error that occurred.
+     * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
+     */
+    onError?: (error: unknown, ctx: NoInfer<TCTX>) => void;
+    /**
+     * A callback function that is called if the mutation request succeeds.
+     * @param value The result of the mutation (the parsed response body).
+     * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
+     */
+    onSuccess?: (value: NoInfer<TResult>, ctx: NoInfer<TCTX>) => void;
+    /**
+     * A callback function that is called when the mutation request settles (either succeeds or fails).
+     * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
+     */
+    onSettled?: (ctx: NoInfer<TCTX>) => void;
+    equal?: ValueEqualityFn<TMutation>;
+};
+/**
+ * Represents a mutation resource created by `mutationResource`.  Extends `QueryResourceRef`
+ * but removes methods that don't make sense for mutations (like `prefetch`, `value`, etc.).
+ *
+ * @typeParam TResult - The type of the expected result from the mutation.
+ */
+type MutationResourceRef<TResult, TMutation = TResult, TICTX = void, TMethod extends HttpResourceRequest['method'] = HttpResourceRequest['method']> = Omit<QueryResourceRef<TResult>, 'prefetch' | 'value' | 'hasValue' | 'set' | 'update'> & {
+    /**
+     * Executes the mutation.
+     *
+     * @param value The request body and any other request parameters to use for the mutation.  The `body` property is *required*.
+     */
+    mutate: (value: Omit<NextRequest<TMethod, TMutation>, 'url'> & {
+        url?: string;
+    }, ctx?: TICTX) => void;
+    /**
+     * A signal that holds the current mutation request, or `null` if no mutation is in progress.
+     * This can be useful for tracking the state of the mutation or for displaying loading indicators.
+     */
+    current: Signal<(Omit<NextRequest<TMethod, TMutation>, 'url'> & {
+        url?: string;
+    }) | null>;
+};
+/**
+ * Creates a resource for performing mutations (e.g., POST, PUT, PATCH, DELETE requests).
+ * Unlike `queryResource`, `mutationResource` is designed for one-off operations that change data.
+ * It does *not* cache responses and does not provide a `value` signal.  Instead, it focuses on
+ * managing the mutation lifecycle (pending, error, success) and provides callbacks for handling
+ * these states.
+ *
+ * @param request A function that returns the base `HttpResourceRequest` to be made.  This
+ *               function is called reactively.  Unlike `queryResource`, the `body` property
+ *               of the request is provided when `mutate` is called, *not* here.  If the
+ *               function returns `undefined`, the mutation is considered "disabled." All properties,
+ *               except the body, can be set here.
+ * @param options Configuration options for the mutation resource.  This includes callbacks
+ *               for `onMutate`, `onError`, `onSuccess`, and `onSettled`.
+ * @typeParam TResult - The type of the expected result from the mutation.
+ * @typeParam TRaw - The raw response type from the HTTP request (defaults to TResult).
+ * @typeParam TCTX - The type of the context value returned by `onMutate`.
+ * @returns A `MutationResourceRef` instance, which provides methods for triggering the mutation
+ *          and observing its status.
+ */
+declare function mutationResource<TResult, TRaw = TResult, TMutation = TResult, TCTX = void, TICTX = TCTX, TMethod extends HttpResourceRequest['method'] = HttpResourceRequest['method']>(request: () => Omit<NextRequest<TMethod, TMutation>, 'body'> | undefined | void, options?: MutationResourceOptions<TResult, TRaw, TMutation, TCTX, TICTX>): MutationResourceRef<TResult, TMutation, TICTX, TMethod>;
+
+export { Cache, createCacheInterceptor, createCircuitBreaker, createDedupeRequestsInterceptor, injectQueryCache, mutationResource, noDedupe, provideQueryCache, queryResource };
+export type { MutationResourceOptions, MutationResourceRef, QueryResourceOptions, QueryResourceRef };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmstack/resource",
-  "version": "19.2.0",
+  "version": "20.0.1",
   "keywords": [
     "angular",
     "signals",
@@ -18,13 +18,13 @@
   "homepage": "https://github.com/mihajm/mmstack/blob/master/packages/resource",
   "dependencies": {
     "uuid": "~11.1.0",
-    "@mmstack/primitives": "^19.2.1",
-    "@mmstack/object": "^19.2.0",
+    "@mmstack/primitives": "^20.0.1",
+    "@mmstack/object": "^20.0.0",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/common": "~19.2.3",
-    "@angular/core": "~19.2.3",
+    "@angular/common": "~20.0.3",
+    "@angular/core": "~20.0.3",
     "rxjs": "~7.8.2"
   },
   "sideEffects": false,

package/lib/mutation-resource.d.ts

@@ -1,92 +0,0 @@
-import { type HttpResourceRequest } from '@angular/common/http';
-import { Signal, ValueEqualityFn } from '@angular/core';
-import { type QueryResourceOptions, type QueryResourceRef } from './query-resource';
-/**
- * @internal
- * Helper type for inferring the request body type based on the HTTP method.
- */
-type NextRequest<TMethod extends HttpResourceRequest['method'], TMutation> = TMethod extends 'DELETE' | 'delete' ? Omit<HttpResourceRequest, 'body' | 'method'> & {
-    method?: TMethod;
-} : Omit<HttpResourceRequest, 'body' | 'method'> & {
-    body: TMutation;
-    method?: TMethod;
-};
-/**
- * Options for configuring a `mutationResource`.
- *
- * @typeParam TResult - The type of the expected result from the mutation.
- * @typeParam TRaw - The raw response type from the HTTP request (defaults to TResult).
- * @typeParam TCTX - The type of the context value returned by `onMutate`.
- */
-export type MutationResourceOptions<TResult, TRaw = TResult, TMutation = TResult, TCTX = void, TICTX = TCTX> = Omit<QueryResourceOptions<TResult, TRaw>, 'equal' | 'onError' | 'keepPrevious' | 'refresh' | 'cache'> & {
-    /**
-     * A callback function that is called before the mutation request is made.
-     * @param value The value being mutated (the `body` of the request).
-     * @returns An optional context value that will be passed to the `onError`, `onSuccess`, and `onSettled` callbacks. This is useful for storing
-     *  information needed during the mutation lifecycle, such as previous values for optimistic updates or rollback.
-     */
-    onMutate?: (value: TMutation, initialCTX?: TICTX) => TCTX;
-    /**
-     * A callback function that is called if the mutation request fails.
-     * @param error The error that occurred.
-     * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
-     */
-    onError?: (error: unknown, ctx: NoInfer<TCTX>) => void;
-    /**
-     * A callback function that is called if the mutation request succeeds.
-     * @param value The result of the mutation (the parsed response body).
-     * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
-     */
-    onSuccess?: (value: NoInfer<TResult>, ctx: NoInfer<TCTX>) => void;
-    /**
-     * A callback function that is called when the mutation request settles (either succeeds or fails).
-     * @param ctx The context value returned by the `onMutate` callback (or `undefined` if `onMutate` was not provided or returned `undefined`).
-     */
-    onSettled?: (ctx: NoInfer<TCTX>) => void;
-    equal?: ValueEqualityFn<TMutation>;
-};
-/**
- * Represents a mutation resource created by `mutationResource`.  Extends `QueryResourceRef`
- * but removes methods that don't make sense for mutations (like `prefetch`, `value`, etc.).
- *
- * @typeParam TResult - The type of the expected result from the mutation.
- */
-export type MutationResourceRef<TResult, TMutation = TResult, TICTX = void, TMethod extends HttpResourceRequest['method'] = HttpResourceRequest['method']> = Omit<QueryResourceRef<TResult>, 'prefetch' | 'value' | 'hasValue' | 'set' | 'update'> & {
-    /**
-     * Executes the mutation.
-     *
-     * @param value The request body and any other request parameters to use for the mutation.  The `body` property is *required*.
-     */
-    mutate: (value: Omit<NextRequest<TMethod, TMutation>, 'url'> & {
-        url?: string;
-    }, ctx?: TICTX) => void;
-    /**
-     * A signal that holds the current mutation request, or `null` if no mutation is in progress.
-     * This can be useful for tracking the state of the mutation or for displaying loading indicators.
-     */
-    current: Signal<(Omit<NextRequest<TMethod, TMutation>, 'url'> & {
-        url?: string;
-    }) | null>;
-};
-/**
- * Creates a resource for performing mutations (e.g., POST, PUT, PATCH, DELETE requests).
- * Unlike `queryResource`, `mutationResource` is designed for one-off operations that change data.
- * It does *not* cache responses and does not provide a `value` signal.  Instead, it focuses on
- * managing the mutation lifecycle (pending, error, success) and provides callbacks for handling
- * these states.
- *
- * @param request A function that returns the base `HttpResourceRequest` to be made.  This
- *               function is called reactively.  Unlike `queryResource`, the `body` property
- *               of the request is provided when `mutate` is called, *not* here.  If the
- *               function returns `undefined`, the mutation is considered "disabled." All properties,
- *               except the body, can be set here.
- * @param options Configuration options for the mutation resource.  This includes callbacks
- *               for `onMutate`, `onError`, `onSuccess`, and `onSettled`.
- * @typeParam TResult - The type of the expected result from the mutation.
- * @typeParam TRaw - The raw response type from the HTTP request (defaults to TResult).
- * @typeParam TCTX - The type of the context value returned by `onMutate`.
- * @returns A `MutationResourceRef` instance, which provides methods for triggering the mutation
- *          and observing its status.
- */
-export declare function mutationResource<TResult, TRaw = TResult, TMutation = TResult, TCTX = void, TICTX = TCTX, TMethod extends HttpResourceRequest['method'] = HttpResourceRequest['method']>(request: () => Omit<NextRequest<TMethod, TMutation>, 'body'> | undefined | void, options?: MutationResourceOptions<TResult, TRaw, TMutation, TCTX, TICTX>): MutationResourceRef<TResult, TMutation, TICTX, TMethod>;
-export {};

package/lib/public_api.d.ts

@@ -1,3 +0,0 @@
-export * from './mutation-resource';
-export * from './query-resource';
-export * from './util/public_api';