@metamask-previews/base-data-service 1.0.0-preview-8bfa290fb → 2.0.0-preview-0a30e47

package/CHANGELOG.md

@@ -7,17 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Added
-
-- Add `executeMutation` protected method to `BaseDataService` to allow for making server-state-mutating requests ([#9324](https://github.com/MetaMask/core/pull/9324))
-  - These kinds of requests are never retried, unlike queries.
-  - To use this, create a method in your data service class which takes whatever arguments you need, plus a optional final argument called `globalId`; then call `executeMutation` with a `mutationKey`, `globalId`, and `mutationFn`. See `ExampleDataService` in this package for an example.
-  - A `MutationKey` type is also available.
-- The payload for `:cacheUpdated` and `:cacheUpdated:${hash}` events now includes an `objectType` property, which is either "query" or "mutation" ([#9324](https://github.com/MetaMask/core/pull/9324))
+## [2.0.0]
 
 ### Changed
 
+- **BREAKING:** Drop CommonJS support ([#9536](https://github.com/MetaMask/core/pull/9536))
+  - This package is now ESM-only, but can still be used in CommonJS projects via `require(esm)` in modern Node.js versions (22+), or dynamic imports in older Node.js versions.
+- **BREAKING:** Bump minimum Node.js version to 22 ([#9976](https://github.com/MetaMask/core/pull/9976))
+- **BREAKING:** Bump TypeScript target to ES2022 ([#10019](https://github.com/MetaMask/core/pull/10019))
+  - This package now ships ES2022 code, requiring a compatible modern environment or bundler configuration to consume.
 - Bump `@metamask/utils` from `^11.11.0` to `^11.12.0` ([#10076](https://github.com/MetaMask/core/pull/10076))
+- Bump `@metamask/messenger` from `^2.0.0` to `^3.0.0` ([#10160](https://github.com/MetaMask/core/pull/10160))
+- Bump `@metamask/storage-service` from `^1.0.2` to `^2.0.0` ([#10160](https://github.com/MetaMask/core/pull/10160))
 
 ### Fixed
 
@@ -95,7 +96,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release ([#8039](https://github.com/MetaMask/core/pull/8039), [#8292](https://github.com/MetaMask/core/pull/8292))
 
-[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/base-data-service@1.0.0...HEAD
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/base-data-service@2.0.0...HEAD
+[2.0.0]: https://github.com/MetaMask/core/compare/@metamask/base-data-service@1.0.0...@metamask/base-data-service@2.0.0
 [1.0.0]: https://github.com/MetaMask/core/compare/@metamask/base-data-service@0.1.3...@metamask/base-data-service@1.0.0
 [0.1.3]: https://github.com/MetaMask/core/compare/@metamask/base-data-service@0.1.2...@metamask/base-data-service@0.1.3
 [0.1.2]: https://github.com/MetaMask/core/compare/@metamask/base-data-service@0.1.1...@metamask/base-data-service@0.1.2

package/dist/{BaseDataService.d.mts → BaseDataService.d.ts}

@@ -1,16 +1,10 @@
-import { Messenger, ActionConstraint, EventConstraint, MessengerActions, MessengerEvents } from "@metamask/messenger";
-import type { StorageServiceGetItemAction, StorageServiceRemoveItemAction, StorageServiceSetItemAction } from "@metamask/storage-service";
-import { Struct } from "@metamask/superstruct";
-import type { Json } from "@metamask/utils";
-import { DefaultError, DehydratedState, FetchQueryOptions, InfiniteData, InfiniteQueryPageParamsOptions, InvalidateOptions, InvalidateQueryFilters, MutationOptions, OmitKeyof, QueryClientConfig, QueryFunction, WithRequired, MutationFunction } from "@tanstack/query-core";
-import { CreateServicePolicyOptions } from "./createServicePolicy.mjs";
-/**
- * Data service mutations and queries use the following format:
- * `['${ServiceName}:${ActionName}', ...params]`
- */
-type Key = [string, ...Json[]] | readonly [string, ...Json[]];
-export type QueryKey = Key;
-export type MutationKey = Key;
+import { Messenger, ActionConstraint, EventConstraint, MessengerActions, MessengerEvents } from '@metamask/messenger';
+import type { StorageServiceGetItemAction, StorageServiceRemoveItemAction, StorageServiceSetItemAction } from '@metamask/storage-service';
+import { Struct } from '@metamask/superstruct';
+import type { Json } from '@metamask/utils';
+import { DefaultError, DehydratedState, FetchQueryOptions, InfiniteData, InfiniteQueryPageParamsOptions, InvalidateOptions, InvalidateQueryFilters, OmitKeyof, QueryClientConfig, QueryFunction, WithRequired } from '@tanstack/query-core';
+import { CreateServicePolicyOptions } from './createServicePolicy.js';
+export type QueryKey = [string, ...Json[]] | readonly [string, ...Json[]];
 /**
  * The supertype of all messengers, scoped to a namespace.
  *
@@ -19,14 +13,12 @@ export type MutationKey = Key;
  */
 export type BaseMessenger<Namespace extends string> = Messenger<Namespace, ActionConstraint, EventConstraint, any>;
 export type DataServiceGranularCacheUpdatedPayload = {
-    objectType: 'query' | 'mutation';
-} & ({
     type: 'added' | 'updated';
     state: DehydratedState;
 } | {
     type: 'removed';
     state: null;
-});
+};
 export type DataServiceCacheUpdatedPayload = DataServiceGranularCacheUpdatedPayload & {
     hash: string;
 };
@@ -81,11 +73,10 @@ export declare class BaseDataService<ServiceName extends string, ServiceMessenge
      *
      * @param options - The options defining the query. Keep in mind that `queryKey` and `queryFn` are required when using data services.
      * Additionally `retry` and `retryDelay` are not available, retries can be customized using the `servicePolicyOptions`.
-     * @param options.queryFn - The query function.
      * @param options.responseStruct - An optional struct for validating the response of the query function.
      * @returns The query results.
      */
-    protected fetchQuery<TQueryFnData extends Json, TError = DefaultError, TDataStruct extends Struct<TQueryFnData> | undefined = undefined, TData = TDataStruct extends Struct<infer StructType> ? StructType : TQueryFnData, TQueryKey extends QueryKey = QueryKey>({ queryFn, responseStruct, ...options }: WithRequired<OmitKeyof<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'retry' | 'retryDelay' | 'queryFn'>, 'queryKey'> & {
+    protected fetchQuery<TQueryFnData extends Json, TError = DefaultError, TDataStruct extends Struct<TQueryFnData> | undefined = undefined, TData = TDataStruct extends Struct<infer StructType> ? StructType : TQueryFnData, TQueryKey extends QueryKey = QueryKey>({ responseStruct, ...options }: WithRequired<OmitKeyof<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'retry' | 'retryDelay' | 'queryFn'>, 'queryKey'> & {
         queryFn: QueryFunction<TQueryFnData, TQueryKey>;
         responseStruct?: TDataStruct;
     }): Promise<TData>;
@@ -102,28 +93,6 @@ export declare class BaseDataService<ServiceName extends string, ServiceMessenge
         queryFn: QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
         responseStruct?: TDataStruct;
     }, pageParam?: TPageParam): Promise<TData>;
-    /**
-     * Execute a mutation (e.g. a request that is expected to change server-side data).
-     * Unlike `fetchQuery`, the request will not be cached or retried.
-     *
-     * @param options - The options defining the mutation. Keep in mind that `mutationKey` and `mutationFn` are required when using data services.
-     * Additionally, `retry` and `retryDelay` are not available.
-     * @param options.mutationFn - The mutation function.
-     * @param options.responseStruct - An optional struct for validating the response of the mutation function.
-     * @param options.globalId - A string which uniquely identifies this mutation
-     * across different query clients — specifically, the one in this data service
-     * and the one that `createUIQueryClient` in `@metamask/react-data-query`
-     * holds (in fact usually you don't need to pass this — `createUIQueryClient`
-     * will do it automatically). This global ID will be stored in the new
-     * mutation `meta` data and included in `:cacheUpdated` payloads.
-     * @returns The mutation results.
-     */
-    protected executeMutation<TMutationFnData extends Json, TDataStruct extends Struct<any> | undefined = undefined, TData = TDataStruct extends Struct<infer StructType> ? StructType : TMutationFnData, TError = DefaultError, TOnMutateResult = unknown, TMutationKey extends MutationKey = MutationKey>({ mutationFn, responseStruct, globalId, ...options }: OmitKeyof<MutationOptions<TData, TError, Record<never, never>, TOnMutateResult>, 'retry' | 'retryDelay' | 'mutationKey' | 'mutationFn'> & {
-        mutationKey: TMutationKey;
-        mutationFn: MutationFunction<TMutationFnData, Record<never, never>>;
-        responseStruct?: TDataStruct;
-        globalId?: string;
-    }): Promise<TData>;
     /**
      * Invalidate queries serviced by this data service.
      *
@@ -143,4 +112,4 @@ export declare class BaseDataService<ServiceName extends string, ServiceMessenge
     destroy(): void;
 }
 export {};
-//# sourceMappingURL=BaseDataService.d.mts.map
+//# sourceMappingURL=BaseDataService.d.ts.map

package/dist/BaseDataService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseDataService.d.ts","sourceRoot":"","sources":["../src/BaseDataService.ts"],"names":[],"mappings":"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"}

package/dist/BaseDataService.js

@@ -0,0 +1,212 @@
+import { Duration, inMilliseconds } from '@metamask/utils';
+import { QueryClient, dehydrate, hydrate, } from '@tanstack/query-core';
+import deepEqual from 'fast-deep-equal';
+import { debounce } from 'lodash-es';
+import { createServicePolicy, } from './createServicePolicy.js';
+import { processQueryResponse } from './utils.js';
+// Defaults to apply to all data service queries if no default option specified
+const QUERY_CLIENT_DEFAULTS = {
+    queries: {
+        retry: false,
+        staleTime: inMilliseconds(1, Duration.Minute),
+    },
+};
+export const STORAGE_SERVICE_KEY = 'cache';
+export class BaseDataService {
+    name;
+    #messenger;
+    #externalMessenger;
+    messenger;
+    #policy;
+    #queryClient;
+    #queryCacheUnsubscribe;
+    #debouncedPersist;
+    #persistenceConfig;
+    constructor({ name, messenger, queryClientConfig = {}, policyOptions, persistenceConfig, }) {
+        this.name = name;
+        // We store two narrowly-typed messengers alongside the generic public one:
+        // - #messenger handles the service's own action registration and event publishing
+        // - #externalMessenger handles calls to external actions
+        // Splitting them avoids TypeScript issues with mixing template-literals with regular strings
+        this.#messenger = messenger;
+        this.#externalMessenger = messenger;
+        this.messenger = messenger;
+        this.#queryClient = new QueryClient({
+            ...queryClientConfig,
+            defaultOptions: {
+                queries: {
+                    ...QUERY_CLIENT_DEFAULTS.queries,
+                    ...queryClientConfig.defaultOptions?.queries,
+                },
+                mutations: queryClientConfig.defaultOptions?.mutations,
+            },
+        });
+        this.#persistenceConfig = persistenceConfig;
+        this.#policy = createServicePolicy(policyOptions);
+        this.#debouncedPersist =
+            this.#persistenceConfig &&
+                debounce(() => {
+                    this.#persistCache().catch(
+                    /* istanbul ignore next */
+                    (error) => this.#messenger.captureException?.(error));
+                }, this.#persistenceConfig.writeDelay ??
+                    inMilliseconds(10, Duration.Second), {
+                    maxWait: this.#persistenceConfig.maxWriteDelay ??
+                        inMilliseconds(1, Duration.Minute),
+                });
+        this.#queryCacheUnsubscribe = this.#queryClient
+            .getQueryCache()
+            .subscribe((event) => {
+            if (['added', 'updated', 'removed'].includes(event.type)) {
+                this.#publishCacheUpdate(event.query.queryHash, event.type);
+                this.#debouncedPersist?.();
+            }
+        });
+        this.#messenger.registerActionHandler(`${this.name}:invalidateQueries`, this.invalidateQueries.bind(this));
+    }
+    /**
+     * Fetch a query.
+     *
+     * @param options - The options defining the query. Keep in mind that `queryKey` and `queryFn` are required when using data services.
+     * Additionally `retry` and `retryDelay` are not available, retries can be customized using the `servicePolicyOptions`.
+     * @param options.responseStruct - An optional struct for validating the response of the query function.
+     * @returns The query results.
+     */
+    async fetchQuery({ responseStruct, ...options }) {
+        return this.#queryClient.fetchQuery({
+            ...options,
+            queryFn: async (context) => {
+                const response = await this.#policy.execute(() => options.queryFn(context));
+                return processQueryResponse(options.queryKey, response, responseStruct);
+            },
+        });
+    }
+    /**
+     * Fetch a paginated query.
+     *
+     * @param options - The options defining the query. Keep in mind that `queryKey` and `queryFn` are required when using data services.
+     * Additionally `retry` and `retryDelay` are not available, retries can be customized using the `servicePolicyOptions`.
+     * @param options.responseStruct - An optional struct for validating the response of the query function.
+     * @param pageParam - An optional page parameter.
+     * @returns The query result, exclusively the requested page is returned.
+     */
+    async fetchInfiniteQuery({ responseStruct, ...options }, pageParam) {
+        const cache = this.#queryClient.getQueryCache();
+        const query = cache.find({
+            queryKey: options.queryKey,
+        });
+        if (!query?.state.data || !pageParam) {
+            const result = await this.#queryClient.fetchInfiniteQuery({
+                ...options,
+                initialPageParam: pageParam ?? options.initialPageParam,
+                queryFn: async (context) => {
+                    const response = await this.#policy.execute(async () => options.queryFn({
+                        ...context,
+                        pageParam: context.meta?.pageParam ?? context.pageParam,
+                    }));
+                    return processQueryResponse(options.queryKey, response, responseStruct);
+                },
+            });
+            return result.pages[0];
+        }
+        const { pages, pageParams } = query.state.data;
+        const next = options.getNextPageParam(pages[pages.length - 1], pages, pageParams[pageParams.length - 1], pageParams);
+        const direction = deepEqual(pageParam, next) ? 'forward' : 'backward';
+        const result = await query.fetch({ ...query.options, meta: { pageParam } }, { meta: { fetchMore: { direction } } });
+        const pageIndex = result.pageParams.findIndex((param) => deepEqual(param, pageParam));
+        return result.pages[pageIndex];
+    }
+    /**
+     * Invalidate queries serviced by this data service.
+     *
+     * @param filters - Optional filter for selecting specific queries.
+     * @param options - Additional optional options for query invalidations.
+     * @returns Nothing.
+     */
+    async invalidateQueries(filters, options) {
+        return this.#queryClient.invalidateQueries(filters, options);
+    }
+    /**
+     * Initialize the service, rehydrating the cache with persisted data if possible.
+     */
+    init() {
+        this.#loadCache().catch(
+        /* istanbul ignore next */
+        (error) => this.#messenger.captureException?.(error));
+    }
+    /**
+     * Prepares the service for garbage collection. This should be extended
+     * by any subclasses to clean up any additional connections or events.
+     */
+    destroy() {
+        this.#debouncedPersist?.cancel();
+        this.#queryCacheUnsubscribe();
+        this.#queryClient.clear();
+        this.messenger.clearSubscriptions();
+        this.messenger.clearActions();
+    }
+    /**
+     * Publish `cacheUpdated` events when a given query changes.
+     *
+     * @param hash The hash of the query.
+     * @param type The type of cache update.
+     */
+    #publishCacheUpdate(hash, type) {
+        const state = type === 'added' || type === 'updated'
+            ? dehydrate(this.#queryClient, {
+                shouldDehydrateQuery: (query) => query.queryHash === hash,
+            })
+            : null;
+        this.#messenger.publish(`${this.name}:cacheUpdated`, {
+            type,
+            hash,
+            state,
+        });
+        this.#messenger.publish(`${this.name}:cacheUpdated:${hash}`, {
+            type,
+            state,
+        });
+    }
+    /**
+     * Persist the query client cache using the StorageService, if the cache is not empty.
+     *
+     * @returns Nothing.
+     */
+    async #persistCache() {
+        const state = dehydrate(this.#queryClient, {
+            // This is the default, but we specify it to be explicit.
+            shouldDehydrateQuery: (query) => query.state.status === 'success',
+        });
+        if (state.queries.length === 0 && state.mutations.length === 0) {
+            await this.#externalMessenger.call('StorageService:removeItem', this.name, STORAGE_SERVICE_KEY);
+            return;
+        }
+        const cache = {
+            timestamp: Date.now(),
+            state,
+        };
+        await this.#externalMessenger.call('StorageService:setItem', this.name, STORAGE_SERVICE_KEY, cache);
+    }
+    /**
+     * Load the query client cache from the StorageService, if persistence is configured
+     * and the persisted cache is not expired.
+     *
+     * @returns Nothing.
+     */
+    async #loadCache() {
+        if (!this.#persistenceConfig) {
+            return;
+        }
+        const { result: untypedCache } = await this.#externalMessenger.call('StorageService:getItem', this.name, STORAGE_SERVICE_KEY);
+        if (!untypedCache) {
+            return;
+        }
+        const cache = untypedCache;
+        if (Date.now() - cache.timestamp >= this.#persistenceConfig.maxAge) {
+            await this.#externalMessenger.call('StorageService:removeItem', this.name, STORAGE_SERVICE_KEY);
+            return;
+        }
+        hydrate(this.#queryClient, cache.state);
+    }
+}
+//# sourceMappingURL=BaseDataService.js.map

package/dist/BaseDataService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseDataService.js","sourceRoot":"","sources":["../src/BaseDataService.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Messenger,\n  ActionConstraint,\n  EventConstraint,\n  MessengerActions,\n  MessengerEvents,\n} from '@metamask/messenger';\nimport type {\n  StorageServiceGetItemAction,\n  StorageServiceRemoveItemAction,\n  StorageServiceSetItemAction,\n} from '@metamask/storage-service';\nimport { Struct } from '@metamask/superstruct';\nimport { Duration, inMilliseconds } from '@metamask/utils';\nimport type { Json } from '@metamask/utils';\nimport {\n  DefaultError,\n  DefaultOptions,\n  DehydratedState,\n  FetchQueryOptions,\n  InfiniteData,\n  InfiniteQueryPageParamsOptions,\n  InvalidateOptions,\n  InvalidateQueryFilters,\n  OmitKeyof,\n  QueryClient,\n  QueryClientConfig,\n  QueryFunction,\n  WithRequired,\n  dehydrate,\n  hydrate,\n} from '@tanstack/query-core';\nimport deepEqual from 'fast-deep-equal';\nimport { debounce, DebouncedFunc } from 'lodash-es';\n\nimport {\n  createServicePolicy,\n  CreateServicePolicyOptions,\n  ServicePolicy,\n} from './createServicePolicy.js';\nimport { processQueryResponse } from './utils.js';\n\n// Data service queries use the following format: ['ServiceActionName', ...params]\nexport type QueryKey = [string, ...Json[]] | readonly [string, ...Json[]];\n\n/**\n * The supertype of all messengers, scoped to a namespace.\n *\n * @template Namespace - The namespace for the messenger's own actions and\n * events.\n */\nexport type BaseMessenger<Namespace extends string> = Messenger<\n  Namespace,\n  ActionConstraint,\n  EventConstraint,\n  // Use `any` to allow any parent to be set. `any` is harmless in a type constraint anyway,\n  // it's the one totally safe place to use it.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\nexport type DataServiceGranularCacheUpdatedPayload =\n  | { type: 'added' | 'updated'; state: DehydratedState }\n  | {\n      type: 'removed';\n      state: null;\n    };\n\nexport type DataServiceCacheUpdatedPayload =\n  DataServiceGranularCacheUpdatedPayload & {\n    hash: string;\n  };\n\ntype CacheUpdatedType = DataServiceCacheUpdatedPayload['type'];\n\nexport type DataServiceInvalidateQueriesAction<ServiceName extends string> = {\n  type: `${ServiceName}:invalidateQueries`;\n  handler: BaseDataService<\n    ServiceName,\n    BaseMessenger<ServiceName>\n  >['invalidateQueries'];\n};\n\nexport type DataServiceActions<ServiceName extends string> =\n  DataServiceInvalidateQueriesAction<ServiceName>;\n\ntype DataServiceAllowedActions =\n  | StorageServiceGetItemAction\n  | StorageServiceSetItemAction\n  | StorageServiceRemoveItemAction;\n\nexport type DataServiceCacheUpdatedEvent<ServiceName extends string> = {\n  type: `${ServiceName}:cacheUpdated`;\n  payload: [DataServiceCacheUpdatedPayload];\n};\n\nexport type DataServiceGranularCacheUpdatedEvent<ServiceName extends string> = {\n  type: `${ServiceName}:cacheUpdated:${string}`;\n  payload: [DataServiceGranularCacheUpdatedPayload];\n};\n\nexport type DataServiceEvents<ServiceName extends string> =\n  | DataServiceCacheUpdatedEvent<ServiceName>\n  | DataServiceGranularCacheUpdatedEvent<ServiceName>;\n\n// Defaults to apply to all data service queries if no default option specified\nconst QUERY_CLIENT_DEFAULTS: DefaultOptions = {\n  queries: {\n    retry: false,\n    staleTime: inMilliseconds(1, Duration.Minute),\n  },\n};\n\nexport const STORAGE_SERVICE_KEY = 'cache';\n\n/**\n * Options for persistence configuration.\n */\nexport type PersistenceConfiguration = {\n  /**\n   * The maximum age before the cache is treated as expired in milliseconds.\n   * This is relevant for rehydrating the state during initialization,\n   * if the cached state is too old it will be discarded.\n   */\n  maxAge: number;\n  /**\n   * The number of milliseconds to wait before triggering persistence following a cache update.\n   */\n  writeDelay?: number;\n  /**\n   * The maximum number of milliseconds to wait between persistence writes.\n   */\n  maxWriteDelay?: number;\n};\n\ntype PersistedCache = {\n  state: DehydratedState;\n  timestamp: number;\n};\n\nexport class BaseDataService<\n  ServiceName extends string,\n  ServiceMessenger extends BaseMessenger<ServiceName>,\n> {\n  public readonly name: ServiceName;\n\n  readonly #messenger: Messenger<\n    ServiceName,\n    DataServiceActions<ServiceName>,\n    DataServiceEvents<ServiceName>\n  >;\n\n  readonly #externalMessenger: Messenger<\n    ServiceName,\n    DataServiceAllowedActions\n  >;\n\n  protected messenger: ServiceMessenger;\n\n  readonly #policy: ServicePolicy;\n\n  readonly #queryClient: QueryClient;\n\n  readonly #queryCacheUnsubscribe: () => void;\n\n  readonly #debouncedPersist?: DebouncedFunc<() => void>;\n\n  readonly #persistenceConfig?: PersistenceConfiguration;\n\n  constructor({\n    name,\n    messenger,\n    queryClientConfig = {},\n    policyOptions,\n    persistenceConfig,\n  }: {\n    name: ServiceName;\n    messenger: DataServiceActions<ServiceName>['type'] extends\n      | MessengerActions<ServiceMessenger>['type']\n      | DataServiceAllowedActions['type']\n      ? DataServiceEvents<ServiceName>['type'] extends MessengerEvents<ServiceMessenger>['type']\n        ? ServiceMessenger\n        : never\n      : never;\n    queryClientConfig?: QueryClientConfig;\n    policyOptions?: CreateServicePolicyOptions;\n    persistenceConfig?: PersistenceConfiguration;\n  }) {\n    this.name = name;\n\n    // We store two narrowly-typed messengers alongside the generic public one:\n    // - #messenger handles the service's own action registration and event publishing\n    // - #externalMessenger handles calls to external actions\n    // Splitting them avoids TypeScript issues with mixing template-literals with regular strings\n    this.#messenger = messenger as unknown as Messenger<\n      ServiceName,\n      DataServiceActions<ServiceName>,\n      DataServiceEvents<ServiceName>\n    >;\n    this.#externalMessenger = messenger as unknown as Messenger<\n      ServiceName,\n      DataServiceAllowedActions\n    >;\n    this.messenger = messenger;\n\n    this.#queryClient = new QueryClient({\n      ...queryClientConfig,\n      defaultOptions: {\n        queries: {\n          ...QUERY_CLIENT_DEFAULTS.queries,\n          ...queryClientConfig.defaultOptions?.queries,\n        },\n        mutations: queryClientConfig.defaultOptions?.mutations,\n      },\n    });\n\n    this.#persistenceConfig = persistenceConfig;\n\n    this.#policy = createServicePolicy(policyOptions);\n\n    this.#debouncedPersist =\n      this.#persistenceConfig &&\n      debounce(\n        () => {\n          this.#persistCache().catch(\n            /* istanbul ignore next */\n            (error) => this.#messenger.captureException?.(error),\n          );\n        },\n        this.#persistenceConfig.writeDelay ??\n          inMilliseconds(10, Duration.Second),\n        {\n          maxWait:\n            this.#persistenceConfig.maxWriteDelay ??\n            inMilliseconds(1, Duration.Minute),\n        },\n      );\n\n    this.#queryCacheUnsubscribe = this.#queryClient\n      .getQueryCache()\n      .subscribe((event) => {\n        if (['added', 'updated', 'removed'].includes(event.type)) {\n          this.#publishCacheUpdate(\n            event.query.queryHash,\n            event.type as CacheUpdatedType,\n          );\n\n          this.#debouncedPersist?.();\n        }\n      });\n\n    this.#messenger.registerActionHandler(\n      `${this.name}:invalidateQueries`,\n      this.invalidateQueries.bind(this),\n    );\n  }\n\n  /**\n   * Fetch a query.\n   *\n   * @param options - The options defining the query. Keep in mind that `queryKey` and `queryFn` are required when using data services.\n   * Additionally `retry` and `retryDelay` are not available, retries can be customized using the `servicePolicyOptions`.\n   * @param options.responseStruct - An optional struct for validating the response of the query function.\n   * @returns The query results.\n   */\n  protected async fetchQuery<\n    TQueryFnData extends Json,\n    TError = DefaultError,\n    TDataStruct extends Struct<TQueryFnData> | undefined = undefined,\n    TData = TDataStruct extends Struct<infer StructType>\n      ? StructType\n      : TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >({\n    responseStruct,\n    ...options\n  }: WithRequired<\n    OmitKeyof<\n      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n      'retry' | 'retryDelay' | 'queryFn'\n    >,\n    'queryKey'\n  > & {\n    queryFn: QueryFunction<TQueryFnData, TQueryKey>;\n    responseStruct?: TDataStruct;\n  }): Promise<TData> {\n    return this.#queryClient.fetchQuery({\n      ...options,\n      queryFn: async (context) => {\n        const response = await this.#policy.execute(() =>\n          options.queryFn(context),\n        );\n        return processQueryResponse(options.queryKey, response, responseStruct);\n      },\n    });\n  }\n\n  /**\n   * Fetch a paginated query.\n   *\n   * @param options - The options defining the query. Keep in mind that `queryKey` and `queryFn` are required when using data services.\n   * Additionally `retry` and `retryDelay` are not available, retries can be customized using the `servicePolicyOptions`.\n   * @param options.responseStruct - An optional struct for validating the response of the query function.\n   * @param pageParam - An optional page parameter.\n   * @returns The query result, exclusively the requested page is returned.\n   */\n  protected async fetchInfiniteQuery<\n    TQueryFnData extends Json,\n    TError = DefaultError,\n    TDataStruct extends Struct<TQueryFnData> | undefined = undefined,\n    TData extends TQueryFnData = TDataStruct extends Struct<infer StructType>\n      ? StructType\n      : TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam extends Json = Json,\n  >(\n    {\n      responseStruct,\n      ...options\n    }: WithRequired<\n      OmitKeyof<\n        FetchQueryOptions<\n          TQueryFnData,\n          TError,\n          InfiniteData<TData, TPageParam>,\n          TQueryKey,\n          TPageParam\n        >,\n        'retry' | 'retryDelay' | 'queryFn' | 'initialPageParam'\n      >,\n      'queryKey'\n    > &\n      InfiniteQueryPageParamsOptions<TQueryFnData, TPageParam> & {\n        queryFn: QueryFunction<TQueryFnData, TQueryKey, TPageParam>;\n        responseStruct?: TDataStruct;\n      },\n    pageParam?: TPageParam,\n  ): Promise<TData> {\n    const cache = this.#queryClient.getQueryCache();\n\n    const query = cache.find<\n      TQueryFnData,\n      TError,\n      InfiniteData<TData, TPageParam>\n    >({\n      queryKey: options.queryKey,\n    });\n\n    if (!query?.state.data || !pageParam) {\n      const result = await this.#queryClient.fetchInfiniteQuery({\n        ...options,\n        initialPageParam: pageParam ?? options.initialPageParam,\n        queryFn: async (context) => {\n          const response = await this.#policy.execute(async () =>\n            options.queryFn({\n              ...context,\n              pageParam: context.meta?.pageParam ?? context.pageParam,\n            }),\n          );\n          return processQueryResponse(\n            options.queryKey,\n            response,\n            responseStruct,\n          );\n        },\n      });\n\n      return result.pages[0];\n    }\n\n    const { pages, pageParams } = query.state.data;\n    const next = options.getNextPageParam(\n      pages[pages.length - 1],\n      pages,\n      pageParams[pageParams.length - 1],\n      pageParams,\n    );\n\n    const direction = deepEqual(pageParam, next) ? 'forward' : 'backward';\n\n    const result = await query.fetch(\n      { ...query.options, meta: { pageParam } },\n      { meta: { fetchMore: { direction } } },\n    );\n\n    const pageIndex = result.pageParams.findIndex((param) =>\n      deepEqual(param, pageParam),\n    );\n\n    return result.pages[pageIndex];\n  }\n\n  /**\n   * Invalidate queries serviced by this data service.\n   *\n   * @param filters - Optional filter for selecting specific queries.\n   * @param options - Additional optional options for query invalidations.\n   * @returns Nothing.\n   */\n  async invalidateQueries(\n    filters?: InvalidateQueryFilters<QueryKey>,\n    options?: InvalidateOptions,\n  ): Promise<void> {\n    return this.#queryClient.invalidateQueries(filters, options);\n  }\n\n  /**\n   * Initialize the service, rehydrating the cache with persisted data if possible.\n   */\n  init(): void {\n    this.#loadCache().catch(\n      /* istanbul ignore next */\n      (error) => this.#messenger.captureException?.(error),\n    );\n  }\n\n  /**\n   * Prepares the service for garbage collection. This should be extended\n   * by any subclasses to clean up any additional connections or events.\n   */\n  destroy(): void {\n    this.#debouncedPersist?.cancel();\n    this.#queryCacheUnsubscribe();\n    this.#queryClient.clear();\n    this.messenger.clearSubscriptions();\n    this.messenger.clearActions();\n  }\n\n  /**\n   * Publish `cacheUpdated` events when a given query changes.\n   *\n   * @param hash The hash of the query.\n   * @param type The type of cache update.\n   */\n  #publishCacheUpdate(hash: string, type: CacheUpdatedType): void {\n    const state =\n      type === 'added' || type === 'updated'\n        ? dehydrate(this.#queryClient, {\n            shouldDehydrateQuery: (query) => query.queryHash === hash,\n          })\n        : null;\n\n    this.#messenger.publish(\n      `${this.name}:cacheUpdated` as const,\n      {\n        type,\n        hash,\n        state,\n      } as DataServiceCacheUpdatedPayload,\n    );\n\n    this.#messenger.publish(\n      `${this.name}:cacheUpdated:${hash}` as const,\n      {\n        type,\n        state,\n      } as DataServiceGranularCacheUpdatedPayload,\n    );\n  }\n\n  /**\n   * Persist the query client cache using the StorageService, if the cache is not empty.\n   *\n   * @returns Nothing.\n   */\n  async #persistCache(): Promise<void> {\n    const state = dehydrate(this.#queryClient, {\n      // This is the default, but we specify it to be explicit.\n      shouldDehydrateQuery: (query) => query.state.status === 'success',\n    });\n\n    if (state.queries.length === 0 && state.mutations.length === 0) {\n      await this.#externalMessenger.call(\n        'StorageService:removeItem',\n        this.name,\n        STORAGE_SERVICE_KEY,\n      );\n      return;\n    }\n\n    const cache: PersistedCache = {\n      timestamp: Date.now(),\n      state,\n    };\n\n    await this.#externalMessenger.call(\n      'StorageService:setItem',\n      this.name,\n      STORAGE_SERVICE_KEY,\n      cache as unknown as Json,\n    );\n  }\n\n  /**\n   * Load the query client cache from the StorageService, if persistence is configured\n   * and the persisted cache is not expired.\n   *\n   * @returns Nothing.\n   */\n  async #loadCache(): Promise<void> {\n    if (!this.#persistenceConfig) {\n      return;\n    }\n\n    const { result: untypedCache } = await this.#externalMessenger.call(\n      'StorageService:getItem',\n      this.name,\n      STORAGE_SERVICE_KEY,\n    );\n\n    if (!untypedCache) {\n      return;\n    }\n\n    const cache = untypedCache as unknown as PersistedCache;\n\n    if (Date.now() - cache.timestamp >= this.#persistenceConfig.maxAge) {\n      await this.#externalMessenger.call(\n        'StorageService:removeItem',\n        this.name,\n        STORAGE_SERVICE_KEY,\n      );\n      return;\n    }\n\n    hydrate(this.#queryClient, cache.state);\n  }\n}\n"]}

package/dist/{createServicePolicy.d.mts → createServicePolicy.d.ts}

@@ -1,5 +1,5 @@
-import { CircuitState } from "cockatiel";
-import type { CircuitBreakerPolicy, Event as CockatielEvent, FailureReason, IBackoffFactory, IPolicy, Policy, RetryPolicy } from "cockatiel";
+import { CircuitState } from 'cockatiel';
+import type { CircuitBreakerPolicy, Event as CockatielEvent, FailureReason, IBackoffFactory, IPolicy, Policy, RetryPolicy } from 'cockatiel';
 /**
  * The options for `createServicePolicy`.
  */
@@ -176,4 +176,4 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * ```
  */
 export declare function createServicePolicy(options?: CreateServicePolicyOptions): ServicePolicy;
-//# sourceMappingURL=createServicePolicy.d.mts.map
+//# sourceMappingURL=createServicePolicy.d.ts.map

package/dist/createServicePolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServicePolicy.d.ts","sourceRoot":"","sources":["../src/createServicePolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EACV,oBAAoB,EACpB,KAAK,IAAI,cAAc,EACvB,aAAa,EACb,eAAe,EACf,OAAO,EACP,MAAM,EACN,WAAW,EACZ,MAAM,WAAW,CAAC;AAEnB;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC;;;;OAIG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IACnC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;OAEG;IACH,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC/C;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG;IACpC;;;OAGG;IACH,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;OAEG;IACH,eAAe,EAAE,MAAM,YAAY,CAAC;IACpC;;;;OAIG;IACH,+BAA+B,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACrD;;;OAGG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,cAAc,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1E;;;;OAIG;IACH,WAAW,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;IAClC;;;;OAIG;IACH,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;CACjC,CAAC;AAiCF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAqChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,0BAA+B,GACvC,aAAa,CAsIf"}

package/dist/{createServicePolicy.mjs → createServicePolicy.js}

@@ -1,4 +1,4 @@
-import { CircuitState, EventEmitter as CockatielEventEmitter, ConsecutiveBreaker, ExponentialBackoff, circuitBreaker, handleAll, handleWhen, retry, wrap } from "cockatiel";
+import { CircuitState, EventEmitter as CockatielEventEmitter, ConsecutiveBreaker, ExponentialBackoff, circuitBreaker, handleAll, handleWhen, retry, wrap, } from 'cockatiel';
 /**
  * Availability statuses that the service can be in.
  *
@@ -31,7 +31,7 @@ export const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;
  * The default length of time (in milliseconds) that governs when the service is
  * regarded as degraded (affecting when `onDegraded` is called).
  */
-export const DEFAULT_DEGRADED_THRESHOLD = 5000;
+export const DEFAULT_DEGRADED_THRESHOLD = 5_000;
 const defaultIsServiceFailure = (error) => {
     if (typeof error === 'object' &&
         error !== null &&
@@ -221,4 +221,4 @@ export function createServicePolicy(options = {}) {
         onRetry,
     };
 }
-//# sourceMappingURL=createServicePolicy.mjs.map
+//# sourceMappingURL=createServicePolicy.js.map

package/dist/createServicePolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServicePolicy.js","sourceRoot":"","sources":["../src/createServicePolicy.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CircuitState,\n  EventEmitter as CockatielEventEmitter,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  circuitBreaker,\n  handleAll,\n  handleWhen,\n  retry,\n  wrap,\n} from 'cockatiel';\nimport type {\n  CircuitBreakerPolicy,\n  Event as CockatielEvent,\n  FailureReason,\n  IBackoffFactory,\n  IPolicy,\n  Policy,\n  RetryPolicy,\n} from 'cockatiel';\n\n/**\n * The options for `createServicePolicy`.\n */\nexport type CreateServicePolicyOptions = {\n  /**\n   * The backoff strategy to use. Mainly useful for testing so that a constant\n   * backoff can be used when mocking timers. Defaults to an instance of\n   * ExponentialBackoff.\n   */\n  backoff?: IBackoffFactory<unknown>;\n  /**\n   * The length of time (in milliseconds) to pause retries of the action after\n   * the number of failures reaches `maxConsecutiveFailures`.\n   */\n  circuitBreakDuration?: number;\n  /**\n   * The length of time (in milliseconds) that governs when the service is\n   * regarded as degraded (affecting when `onDegraded` is called).\n   */\n  degradedThreshold?: number;\n  /**\n   * Predicate function for when an error should be considered a service failure.\n   */\n  isServiceFailure?: (error: unknown) => boolean;\n  /**\n   * The maximum number of times that the service is allowed to fail before\n   * pausing further retries.\n   */\n  maxConsecutiveFailures?: number;\n  /**\n   * The maximum number of times that a failing service should be re-invoked\n   * before giving up.\n   */\n  maxRetries?: number;\n  /**\n   * The policy used to control when the service should be retried based on\n   * either the result of the service or an error that it throws. For instance,\n   * you could use this to retry only certain errors. See `handleWhen` and\n   * friends from Cockatiel for more.\n   */\n  retryFilterPolicy?: Policy;\n};\n\n/**\n * The service policy object.\n */\nexport type ServicePolicy = IPolicy & {\n  /**\n   * The Cockatiel circuit breaker policy that the service policy uses\n   * internally.\n   */\n  circuitBreakerPolicy: CircuitBreakerPolicy;\n  /**\n   * The amount of time to pause requests to the service if the number of\n   * maximum consecutive failures is reached.\n   */\n  circuitBreakDuration: number;\n  /**\n   * @returns The state of the underlying circuit.\n   */\n  getCircuitState: () => CircuitState;\n  /**\n   * If the circuit is open and ongoing requests are paused, returns the number\n   * of milliseconds before the requests will be attempted again. If the circuit\n   * is not open, returns null.\n   */\n  getRemainingCircuitOpenDuration: () => number | null;\n  /**\n   * Resets the internal circuit breaker policy (if it is open, it will now be\n   * closed).\n   */\n  reset: () => void;\n  /**\n   * The Cockatiel retry policy that the service policy uses internally.\n   */\n  retryPolicy: RetryPolicy;\n  /**\n   * A function which is called when the number of times that the service fails\n   * in a row meets the set maximum number of consecutive failures.\n   */\n  onBreak: CircuitBreakerPolicy['onBreak'];\n  /**\n   * A function which is called in two circumstances: 1) when the service\n   * succeeds before the maximum number of consecutive failures is reached, but\n   * takes more time than the `degradedThreshold` to run, or 2) if the service\n   * never succeeds before the retry policy gives up and before the maximum\n   * number of consecutive failures has been reached.\n   */\n  onDegraded: CockatielEvent<FailureReason<unknown> | { duration: number }>;\n  /**\n   * A function which is called when the service succeeds for the first time,\n   * or when the service fails enough times to cause the circuit to break and\n   * then recovers.\n   */\n  onAvailable: CockatielEvent<void>;\n  /**\n   * A function which will be called by the retry policy each time the service\n   * fails and the policy kicks off a timer to re-run the service. This is\n   * primarily useful in tests where we are mocking timers.\n   */\n  onRetry: RetryPolicy['onRetry'];\n};\n\n/**\n * Parts of the circuit breaker's internal and external state as necessary in\n * order to compute the time remaining before the circuit will reopen.\n */\ntype InternalCircuitState =\n  | {\n      state: CircuitState.Open;\n      openedAt: number;\n    }\n  | { state: Exclude<CircuitState, CircuitState.Open> };\n\n/**\n * Availability statuses that the service can be in.\n *\n * Used to keep track of whether the `onAvailable` event should be fired.\n */\nconst AVAILABILITY_STATUSES = {\n  Available: 'available',\n  Degraded: 'degraded',\n  Unavailable: 'unavailable',\n  Unknown: 'unknown',\n} as const;\n\n/**\n * Availability statuses that the service can be in.\n *\n * Used to keep track of whether the `onAvailable` event should be fired.\n */\ntype AvailabilityStatus =\n  (typeof AVAILABILITY_STATUSES)[keyof typeof AVAILABILITY_STATUSES];\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries. This is set to a value such that if given a\n * service that continually fails, the policy needs to be executed 3 times\n * before further retries are paused.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\nconst defaultIsServiceFailure = (error: unknown): boolean => {\n  if (\n    typeof error === 'object' &&\n    error !== null &&\n    'httpStatus' in error &&\n    typeof error.httpStatus === 'number'\n  ) {\n    return error.httpStatus >= 500;\n  }\n\n  // If the error is not an object, or doesn't have a numeric httpStatus\n  // property, consider it a service failure (e.g., network errors, timeouts,\n  // etc.)\n  return true;\n};\n\n/**\n * The circuit breaker policy inside of the Cockatiel library exposes some of\n * its state, but not all of it. Notably, the time that the circuit opened is\n * not publicly accessible. So we have to record this ourselves.\n *\n * This function therefore allows us to obtain the circuit breaker state that we\n * wish we could access.\n *\n * @param state - The public state of a circuit breaker policy.\n * @returns if the circuit is open, the state of the circuit breaker policy plus\n * the time that it opened, otherwise just the circuit state.\n */\nfunction getInternalCircuitState(state: CircuitState): InternalCircuitState {\n  if (state === CircuitState.Open) {\n    return { state, openedAt: Date.now() };\n  }\n  return { state };\n}\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function. See\n * {@link CreateServicePolicyOptions}.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxRetries: 3,\n *       retryFilterPolicy: handleWhen((error) => {\n *         return error.message.includes('oops');\n *       }),\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy(\n  options: CreateServicePolicyOptions = {},\n): ServicePolicy {\n  const {\n    maxRetries = DEFAULT_MAX_RETRIES,\n    retryFilterPolicy = handleAll,\n    maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n    circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n    degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n    backoff = new ExponentialBackoff(),\n    isServiceFailure = defaultIsServiceFailure,\n  } = options;\n\n  let availabilityStatus: AvailabilityStatus = AVAILABILITY_STATUSES.Unknown;\n\n  const retryPolicy = retry(retryFilterPolicy, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: maxRetries,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff,\n  });\n  const onRetry = retryPolicy.onRetry.bind(retryPolicy);\n\n  const consecutiveBreaker = new ConsecutiveBreaker(maxConsecutiveFailures);\n  const circuitBreakerPolicy = circuitBreaker(handleWhen(isServiceFailure), {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: consecutiveBreaker,\n  });\n\n  let internalCircuitState: InternalCircuitState = getInternalCircuitState(\n    circuitBreakerPolicy.state,\n  );\n  circuitBreakerPolicy.onStateChange((state) => {\n    internalCircuitState = getInternalCircuitState(state);\n  });\n\n  circuitBreakerPolicy.onBreak(() => {\n    availabilityStatus = AVAILABILITY_STATUSES.Unavailable;\n  });\n  const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);\n\n  const onDegradedEventEmitter = new CockatielEventEmitter<\n    FailureReason<unknown> | { duration: number }\n  >();\n  const onDegraded = onDegradedEventEmitter.addListener;\n\n  const onAvailableEventEmitter = new CockatielEventEmitter<void>();\n  const onAvailable = onAvailableEventEmitter.addListener;\n\n  retryPolicy.onGiveUp((data) => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      availabilityStatus = AVAILABILITY_STATUSES.Degraded;\n      onDegradedEventEmitter.emit(data);\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      if (duration > degradedThreshold) {\n        availabilityStatus = AVAILABILITY_STATUSES.Degraded;\n        onDegradedEventEmitter.emit({ duration });\n      } else if (availabilityStatus !== AVAILABILITY_STATUSES.Available) {\n        availabilityStatus = AVAILABILITY_STATUSES.Available;\n        onAvailableEventEmitter.emit();\n      }\n    }\n  });\n\n  // Every time the retry policy makes an attempt, it executes the circuit\n  // breaker policy, which executes the service.\n  //\n  // Calling:\n  //\n  //   policy.execute(() => {\n  //     // do what the service does\n  //   })\n  //\n  // is equivalent to:\n  //\n  //   retryPolicy.execute(() => {\n  //     circuitBreakerPolicy.execute(() => {\n  //       // do what the service does\n  //     });\n  //   });\n  //\n  // So if the retry policy succeeds or fails, it is because the circuit breaker\n  // policy succeeded or failed. And if there are any event listeners registered\n  // on the retry policy, by the time they are called, the state of the circuit\n  // breaker will have already changed.\n  const policy = wrap(retryPolicy, circuitBreakerPolicy);\n\n  const getRemainingCircuitOpenDuration = (): number | null => {\n    if (internalCircuitState.state === CircuitState.Open) {\n      return internalCircuitState.openedAt + circuitBreakDuration - Date.now();\n    }\n    return null;\n  };\n\n  const getCircuitState = (): CircuitState => {\n    return circuitBreakerPolicy.state;\n  };\n\n  const reset = (): void => {\n    // Set the state of the policy to \"isolated\" regardless of its current state\n    const { dispose } = circuitBreakerPolicy.isolate();\n    // Reset the state to \"closed\"\n    dispose();\n\n    // Reset the counter on the breaker as well\n    consecutiveBreaker.success();\n\n    // Re-initialize the availability status so that if the service is executed\n    // successfully, onAvailable listeners will be called again\n    availabilityStatus = AVAILABILITY_STATUSES.Unknown;\n  };\n\n  return {\n    ...policy,\n    circuitBreakerPolicy,\n    circuitBreakDuration,\n    getCircuitState,\n    getRemainingCircuitOpenDuration,\n    reset,\n    retryPolicy,\n    onBreak,\n    onDegraded,\n    onAvailable,\n    onRetry,\n  };\n}\n"]}

package/dist/{index.d.cts → index.d.ts}

@@ -1,7 +1,7 @@
-export type { Event as CockatielEvent, FailureReason as CockatielFailureReason, } from "cockatiel";
-export { BrokenCircuitError, EventEmitter as CockatielEventEmitter, CircuitState, ConstantBackoff, ExponentialBackoff, handleAll, handleWhen, } from "cockatiel";
-export type { DataServiceActions, DataServiceEvents, DataServiceCacheUpdatedPayload, DataServiceGranularCacheUpdatedPayload, DataServiceInvalidateQueriesAction, DataServiceCacheUpdatedEvent, DataServiceGranularCacheUpdatedEvent, QueryKey, MutationKey, PersistenceConfiguration, } from "./BaseDataService.cjs";
-export { BaseDataService } from "./BaseDataService.cjs";
-export { DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, } from "./createServicePolicy.cjs";
-export type { CreateServicePolicyOptions, ServicePolicy, } from "./createServicePolicy.cjs";
-//# sourceMappingURL=index.d.cts.map
+export type { Event as CockatielEvent, FailureReason as CockatielFailureReason, } from 'cockatiel';
+export { BrokenCircuitError, EventEmitter as CockatielEventEmitter, CircuitState, ConstantBackoff, ExponentialBackoff, handleAll, handleWhen, } from 'cockatiel';
+export type { DataServiceActions, DataServiceEvents, DataServiceCacheUpdatedPayload, DataServiceGranularCacheUpdatedPayload, DataServiceInvalidateQueriesAction, DataServiceCacheUpdatedEvent, DataServiceGranularCacheUpdatedEvent, QueryKey, PersistenceConfiguration, } from './BaseDataService.js';
+export { BaseDataService } from './BaseDataService.js';
+export { DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, } from './createServicePolicy.js';
+export type { CreateServicePolicyOptions, ServicePolicy, } from './createServicePolicy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,KAAK,IAAI,cAAc,EACvB,aAAa,IAAI,sBAAsB,GACxC,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,kBAAkB,EAClB,YAAY,IAAI,qBAAqB,EACrC,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,SAAS,EACT,UAAU,GACX,MAAM,WAAW,CAAC;AAEnB,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,8BAA8B,EAC9B,sCAAsC,EACtC,kCAAkC,EAClC,4BAA4B,EAC5B,oCAAoC,EACpC,QAAQ,EACR,wBAAwB,GACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,0BAA0B,EAC1B,aAAa,GACd,MAAM,0BAA0B,CAAC"}

package/dist/{index.mjs → index.js}

@@ -1,4 +1,4 @@
-export { BrokenCircuitError, EventEmitter as CockatielEventEmitter, CircuitState, ConstantBackoff, ExponentialBackoff, handleAll, handleWhen } from "cockatiel";
-export { BaseDataService } from "./BaseDataService.mjs";
-export { DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy } from "./createServicePolicy.mjs";
-//# sourceMappingURL=index.mjs.map
+export { BrokenCircuitError, EventEmitter as CockatielEventEmitter, CircuitState, ConstantBackoff, ExponentialBackoff, handleAll, handleWhen, } from 'cockatiel';
+export { BaseDataService } from './BaseDataService.js';
+export { DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, } from './createServicePolicy.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,kBAAkB,EAClB,YAAY,IAAI,qBAAqB,EACrC,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,SAAS,EACT,UAAU,GACX,MAAM,WAAW,CAAC;AAanB,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,0BAA0B,CAAC","sourcesContent":["export type {\n  Event as CockatielEvent,\n  FailureReason as CockatielFailureReason,\n} from 'cockatiel';\n\nexport {\n  BrokenCircuitError,\n  EventEmitter as CockatielEventEmitter,\n  CircuitState,\n  ConstantBackoff,\n  ExponentialBackoff,\n  handleAll,\n  handleWhen,\n} from 'cockatiel';\n\nexport type {\n  DataServiceActions,\n  DataServiceEvents,\n  DataServiceCacheUpdatedPayload,\n  DataServiceGranularCacheUpdatedPayload,\n  DataServiceInvalidateQueriesAction,\n  DataServiceCacheUpdatedEvent,\n  DataServiceGranularCacheUpdatedEvent,\n  QueryKey,\n  PersistenceConfiguration,\n} from './BaseDataService.js';\nexport { BaseDataService } from './BaseDataService.js';\n\nexport {\n  DEFAULT_CIRCUIT_BREAK_DURATION,\n  DEFAULT_DEGRADED_THRESHOLD,\n  DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  DEFAULT_MAX_RETRIES,\n  createServicePolicy,\n} from './createServicePolicy.js';\nexport type {\n  CreateServicePolicyOptions,\n  ServicePolicy,\n} from './createServicePolicy.js';\n"]}

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+import { Struct } from '@metamask/superstruct';
+import type { QueryKey } from './BaseDataService.js';
+/**
+ * Process query responses, validating them using Superstruct if a struct is defined.
+ *
+ * @param queryKey - The query key.
+ * @param response - The query response
+ * @param struct - The struct defining the schema for the query response.
+ * @returns The query response, coerced by Superstruct if needed.
+ * @throws If the query response does not match the struct.
+ */
+export declare function processQueryResponse<Response>(queryKey: QueryKey, response: Response, struct?: Struct<Response>): Response;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAC3C,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,QAAQ,EAClB,MAAM,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,GACxB,QAAQ,CAcV"}

package/dist/utils.js

@@ -0,0 +1,21 @@
+import { validate } from '@metamask/superstruct';
+/**
+ * Process query responses, validating them using Superstruct if a struct is defined.
+ *
+ * @param queryKey - The query key.
+ * @param response - The query response
+ * @param struct - The struct defining the schema for the query response.
+ * @returns The query response, coerced by Superstruct if needed.
+ * @throws If the query response does not match the struct.
+ */
+export function processQueryResponse(queryKey, response, struct) {
+    if (!struct) {
+        return response;
+    }
+    const [error, result] = validate(response, struct);
+    if (error) {
+        throw new Error(`Query function for "${queryKey[0]}" returned an unexpected response: ${error.message}.`);
+    }
+    return result;
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIzD;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAClC,QAAkB,EAClB,QAAkB,EAClB,MAAyB;IAEzB,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAEnD,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CACb,uBAAuB,QAAQ,CAAC,CAAC,CAAC,sCAAsC,KAAK,CAAC,OAAO,GAAG,CACzF,CAAC;IACJ,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import { Struct, validate } from '@metamask/superstruct';\n\nimport type { QueryKey } from './BaseDataService.js';\n\n/**\n * Process query responses, validating them using Superstruct if a struct is defined.\n *\n * @param queryKey - The query key.\n * @param response - The query response\n * @param struct - The struct defining the schema for the query response.\n * @returns The query response, coerced by Superstruct if needed.\n * @throws If the query response does not match the struct.\n */\nexport function processQueryResponse<Response>(\n  queryKey: QueryKey,\n  response: Response,\n  struct?: Struct<Response>,\n): Response {\n  if (!struct) {\n    return response;\n  }\n\n  const [error, result] = validate(response, struct);\n\n  if (error) {\n    throw new Error(\n      `Query function for \"${queryKey[0]}\" returned an unexpected response: ${error.message}.`,\n    );\n  }\n\n  return result;\n}\n"]}