@mmstack/resource 20.2.6 → 20.2.7

package/index.d.ts

@@ -1 +1,578 @@
-export * from './lib/public_api';
+import { HttpResponse, HttpInterceptorFn, HttpContext, HttpResourceOptions, HttpResourceRequest, HttpResourceRef, HttpHeaders } from '@angular/common/http';
+import { Signal, Injector, Provider, WritableSignal, 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>;
+    key: string;
+};
+/**
+ * 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>;
+    /**
+     * Retrieves a cache entry or an object with the key if not found.
+     *
+     * @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 an object with the key if not found. The signal
+     *          updates whenever the cache entry changes (e.g., due to revalidation or expiration).
+     */
+    getEntryOrKey(key: () => string | null): Signal<(CacheEntry<T> & {
+        isStale: boolean;
+    }) | string | 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<TRaw = unknown>(injector?: Injector): Cache<HttpResponse<TRaw>>;
+
+/**
+ * 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 indicating whether the circuit breaker is either open or in a half-open state.
+     * This is useful for checking if operations are blocked.
+     * If the circuit breaker is open, operations should not proceed.
+     */
+    isOpen: 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: (err?: Error) => 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.
+ */
+type CreateCircuitBreakerOptions = {
+    /**
+     * The number of failures that will cause the circuit breaker to open.
+     * @default 5
+     */
+    treshold?: number;
+    /**
+     * The time in milliseconds after which the circuit breaker will reset and allow operations to proceed again.
+     * @default 30000 (30 seconds)
+     */
+    timeout?: number;
+    /**
+     * A function that determines whether an error should cause the circuit breaker to increment the failure count.
+     * @default Always returns true
+     */
+    shouldFail?: (err?: Error) => boolean;
+    /**
+     * A function that determines whether an error should cause the circuit breaker to be open forever.
+     * @default Always returns false
+     */
+    shouldFailForever?: (err?: Error) => boolean;
+};
+/**
+ * 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 | CreateCircuitBreakerOptions;
+declare function provideCircuitBreakerDefaultOptions(options: CircuitBreakerOptions): Provider;
+/**
+ * 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, injector?: Injector): 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;
+    /**
+     * Whether to bust the browser cache by appending a unique query parameter to the request URL.
+     * This is useful for ensuring that the latest data is fetched from the server, bypassing any
+     * cached responses in the browser. The unique parameter is removed before calling the cache function, so it does not affect the cache key.
+     * @default false - By default, the resource will not bust the browser cache.
+     */
+    bustBrowserCache?: boolean;
+    /**
+     * Whether to ignore the `Cache-Control` headers from the server when caching responses.
+     * If set to `true`, the resource will not respect any cache directives from the server,
+     * allowing you to control caching behavior entirely through the resource options.
+     * @default false - By default the resource will respect `Cache-Control` headers.
+     */
+    ignoreCacheControl?: boolean;
+};
+/**
+ * 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> = Omit<HttpResourceRef<TResult>, 'headers' | 'statusCode'> & {
+    /**
+     * Linkedsignal of the response headers, when available.
+     */
+    readonly headers: WritableSignal<HttpHeaders | undefined>;
+    /**
+     * Linkedsignal of the response status code, when available.
+     */
+    readonly statusCode: WritableSignal<number | undefined>;
+    /**
+     * 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> = Omit<QueryResourceRef<TResult>, 'prefetch' | 'value' | 'hasValue' | 'set' | 'update'> & {
+    /**
+     * Executes the mutation.
+     *
+     * @param value The mutation value (usually the request body).
+     * @param ctx An optional initial context value that will be passed to the `onMutate` callback.
+     */
+    mutate: (value: TMutation, 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<TMutation | 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. The parameter is the mutation value provided by the `mutate` method.
+ * @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 TMutation - The type of the mutation value (the request body).
+ * @typeParam TICTX - The type of the initial context value passed to `onMutate`.
+ * @typeParam TCTX - The type of the context value returned by `onMutate`.
+ * @typeParam TMethod - The HTTP method to be used for the mutation (defaults to `HttpResourceRequest['method']`).
+ * @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: (params: TMutation) => Omit<NextRequest<TMethod, TMutation>, 'body'> | undefined | void, options?: MutationResourceOptions<TResult, TRaw, TMutation, TCTX, TICTX>): MutationResourceRef<TResult, TMutation, TICTX>;
+
+export { Cache, createCacheInterceptor, createCircuitBreaker, createDedupeRequestsInterceptor, injectQueryCache, mutationResource, noDedupe, provideCircuitBreakerDefaultOptions, provideQueryCache, queryResource };
+export type { MutationResourceOptions, MutationResourceRef, QueryResourceOptions, QueryResourceRef };

package/package.json

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