@warp-drive/legacy 5.9.0-alpha.2 → 5.9.0-alpha.21

package/dist/unpkg/prod/adapter/json-api.js

@@ -117,7 +117,7 @@ import { RESTAdapter } from './rest.js';
   namespace property on the adapter:
 
   ```js [app/adapters/application.js]
-  import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';
+  import { JSONAPIAdapter } from '@warp-drive/legacy/adapter/json-api';
 
   export default class ApplicationAdapter extends JSONAPIAdapter {
     namespace = 'api/1';
@@ -146,6 +146,10 @@ import { RESTAdapter } from './rest.js';
   @constructor
 */
 class JSONAPIAdapter extends RESTAdapter {
+  /**
+   * The `Content-Type` header used when serializing request bodies
+   * that don't otherwise specify one.
+   */
   _defaultContentType = 'application/vnd.api+json';
 
   /**
@@ -227,6 +231,14 @@ class JSONAPIAdapter extends RESTAdapter {
       }
     });
   }
+
+  /**
+   * Determines the pathname for a given type.
+   *
+   * Unlike the base `BuildURLMixin` implementation, dasherizes (rather
+   * than camelizes) the type name before pluralizing it, per the
+   * {json:api} convention for member names.
+   */
   pathForType(modelName) {
     const dasherized = dasherize(modelName);
     return pluralize(dasherized);

package/dist/unpkg/prod/adapter/rest.js

@@ -234,13 +234,39 @@ const AdapterWithBuildURLMixin = Adapter.extend(BuildURLMixin);
   @public
 */
 class RESTAdapter extends AdapterWithBuildURLMixin {
+  /**
+   * @private
+   */
+
+  /**
+   * @private
+   */
+
+  /**
+   * See "Host customization" above.
+   */
+
+  /**
+   * See "Namespace customization" above.
+   */
+
   /**
     This property allows ajax to still be used instead when `false`.
      @default true
     @public
   */
   useFetch = true;
+
+  /**
+   * The `Content-Type` header used when serializing request bodies
+   * that don't otherwise specify one.
+   */
   _defaultContentType = 'application/json; charset=utf-8';
+
+  /**
+   * The FastBoot service instance, if running in a FastBoot environment.
+   * Lazily looked up on first access.
+   */
   get fastboot() {
     // Avoid computed property override deprecation in fastboot as suggested by:
     // https://deprecations.emberjs.com/v3.x/#toc_computed-property-override
@@ -250,6 +276,10 @@ class RESTAdapter extends AdapterWithBuildURLMixin {
     }
     return this._fastboot = getOwner(this).lookup('service:fastboot');
   }
+
+  /**
+   * Sets the FastBoot service instance to use.
+   */
   static {
     decorateMethodV2(this.prototype, "fastboot", [computed()]);
   }
@@ -621,7 +651,13 @@ class RESTAdapter extends AdapterWithBuildURLMixin {
     return expandedURL.join('/');
   }
 
-  // http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
+  /**
+   * The maximum URL length to allow when coalescing `findRecord` requests
+   * into a single `findMany` request via {@link RESTAdapter.groupRecordsForFindMany | groupRecordsForFindMany}.
+   * Requests that would exceed this length are split into multiple groups.
+   *
+   * See http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
+   */
   maxURLLength = 2048;
 
   /**
@@ -682,8 +718,8 @@ class RESTAdapter extends AdapterWithBuildURLMixin {
     if (this.isSuccess(status, headers, payload)) {
       return payload;
     } else if (this.isInvalid(status, headers, payload)) {
-      // @ts-expect-error needs cast to ApiError
-      return new InvalidError(typeof payload === 'object' && 'errors' in payload ? payload.errors : undefined);
+      const errorPayload = payload ?? {};
+      return new InvalidError(typeof errorPayload === 'object' && 'errors' in errorPayload ? errorPayload.errors : undefined);
     }
     const errors = this.normalizeErrorResponse(status, headers, payload);
     const detailedMessage = this.generatedDetailedMessage(status, headers, payload, requestData);

package/dist/unpkg/prod/adapter.js

@@ -4,6 +4,8 @@ import { a as decorateFieldV2, i as initializeDeferredDecorator } from "./runtim
 import Mixin from '@ember/object/mixin';
 import { camelize, pluralize } from '@warp-drive/utilities/string';
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
 /*
  The structure of this file is such because typing Mixins is hard. Here we've structured it in
  such a way as to maximize the type information that a consumer can utilize. There are simpler
@@ -14,37 +16,18 @@ import { camelize, pluralize } from '@warp-drive/utilities/string';
 // `interface BuildURLMixin { buildURL: typeof buildURL }`
 // then an extending class overwriting one of the methods will break because typescript
 // thinks it is a switch from an instance prop (that is a method) to an instance method.
+/**
+ * The methods provided by the `BuildURLMixin` mixin (see the exported
+ * `BuildURLMixin` {@link Mixin} below).
+ *
+ * See also {@link MixtBuildURLMixin}, the interface used to type `this`
+ * within these methods.
+ */
 
 // prevents the final constructed object from needing to add
 // host and namespace which are provided by the final consuming
 // class to the prototype which can result in overwrite errors
 
-/**
-  ## Using BuildURLMixin
-
-  To use URL building, include the mixin when extending an adapter, and call `buildURL` where needed.
-  The default behaviour is designed for RESTAdapter.
-
-  ### Example
-
-  ```javascript
-  import Adapter, { BuildURLMixin } from '@ember-data/adapter';
-
-  export default class ApplicationAdapter extends Adapter.extend(BuildURLMixin) {
-    findRecord(store, type, id, snapshot) {
-      var url = this.buildURL(type.modelName, id, snapshot, 'findRecord');
-      return this.ajax(url, 'GET');
-    }
-  }
-  ```
-
-  ### Attributes
-
-  The `host` and `namespace` attributes will be used if defined, and are optional.
-
-  @class BuildURLMixin
-  @public
-*/
 /**
     Builds a URL for a given type and optional ID.
 
@@ -490,6 +473,13 @@ const mixinProps = {
   urlPrefix,
   pathForType
 };
+
+/**
+ * The `Mixin` implementation of {@link BuildURLMixin}, ready to be applied
+ * to an `EmberObject` subclass such as an `Adapter`.
+ *
+ * @public
+ */
 const BuildURLMixin = Mixin.create(mixinProps);
 
 /**
@@ -739,6 +729,13 @@ class Adapter extends EmberObject {
     decorateFieldV2(this.prototype, "store", [service]);
   }
   #store = (initializeDeferredDecorator(this, "store"), void 0);
+  /**
+   * The Store service instance that owns this Adapter.
+   */
+  /**
+   * @private
+   */
+
   /**
     The `findRecord()` method is invoked when the store is asked for a record that
     has not previously been loaded. In response to `findRecord()` being called, you

package/dist/unpkg/prod/compat/builders.js

@@ -15,7 +15,6 @@ import { storeFor, recordIdentifierFor } from '@warp-drive/core';
   @deprecated
   @public
   @param type the name of the resource
-  @param query a query to be used by the adapter
   @param options optional, may include `adapterOptions` hash which will be passed to adapter.findAll
   @return request config
 */

package/dist/unpkg/prod/compat/extensions.js

@@ -1,18 +1,64 @@
-import { get, set } from '@ember/object';
+import { get, set, setProperties, notifyPropertyChange, getProperties } from '@ember/object';
+import { removeObserver, addObserver } from '@ember/object/observers';
 import { compare } from '@ember/utils';
-import Ember from 'ember';
 const EmberObjectFeatures = {};
 const EmberObjectMethods = ['addObserver', 'cacheFor', 'decrementProperty', 'get', 'getProperties', 'incrementProperty', 'notifyPropertyChange', 'removeObserver', 'set', 'setProperties', 'toggleProperty'];
 EmberObjectMethods.forEach(method => {
   EmberObjectFeatures[method] = function delegatedMethod(...args) {
-    return Ember[method](this, ...args);
+    switch (method) {
+      case 'addObserver':
+        return addObserver(this, ...args);
+      case 'cacheFor':
+        throw new Error('cacheFor has been removed and will not be replaced');
+      case 'decrementProperty':
+        {
+          const keyName = args[0];
+          const decrement = args[1] ?? 1;
+          return set(this, keyName, (get(this, keyName) || 0) - decrement);
+        }
+      case 'get':
+        return get(this, ...args);
+      case 'getProperties':
+        return getProperties(this, ...args);
+      case 'incrementProperty':
+        {
+          const keyName = args[0];
+          const increment = args[1] ?? 1;
+          return set(this, keyName, (parseFloat(get(this, keyName)) || 0) + increment);
+        }
+      case 'notifyPropertyChange':
+        return notifyPropertyChange(this, ...args);
+      case 'removeObserver':
+        return removeObserver(this, ...args);
+      case 'set':
+        return set(this, ...args);
+      case 'setProperties':
+        return setProperties(this, ...args);
+      case 'toggleProperty':
+        {
+          const key = args[0];
+          return set(this, key, !get(this, key));
+        }
+    }
   };
 });
+/**
+ * A schema extension that adds the classic `EmberObject` API (`get`, `set`,
+ * `getProperties`, `setProperties`, `incrementProperty`, `decrementProperty`,
+ * `toggleProperty`, `notifyPropertyChange`, `addObserver`, `removeObserver`)
+ * to reactive array resources.
+ */
 const EmberObjectArrayExtension = {
   kind: 'array',
   name: 'ember-object',
   features: EmberObjectFeatures
 };
+/**
+ * A schema extension that adds the classic `EmberObject` API (`get`, `set`,
+ * `getProperties`, `setProperties`, `incrementProperty`, `decrementProperty`,
+ * `toggleProperty`, `notifyPropertyChange`, `addObserver`, `removeObserver`)
+ * to reactive object resources.
+ */
 const EmberObjectExtension = {
   kind: 'object',
   name: 'ember-object',
@@ -224,9 +270,30 @@ const EmberArrayLikeFeatures = {
     return this.at(-1);
   }
 };
+
+/**
+ * A schema extension that adds Ember's classic `MutableArray`/`Enumerable`
+ * style methods (`pushObject`, `removeObject`, `mapBy`, `filterBy`,
+ * `sortBy`, `firstObject`, `lastObject`, etc.) to reactive array resources.
+ */
 const EmberArrayLikeExtension = {
   kind: 'array',
   name: 'ember-array-like',
   features: EmberArrayLikeFeatures
 };
+
+/**
+ * Extracts the element type of an array type, or `never` if `T` is not an array.
+ */
+
+/**
+ * Adds the classic `EmberObject` API (as registered by {@link EmberObjectExtension}/
+ * {@link EmberObjectArrayExtension}) to the type of a reactive resource.
+ */
+
+/**
+ * Adds Ember's classic array-like API (as registered by {@link EmberArrayLikeExtension})
+ * to the type of a reactive array resource.
+ */
+
 export { EmberArrayLikeExtension, EmberObjectArrayExtension, EmberObjectExtension };

package/dist/unpkg/prod/compat/utils.js

@@ -140,6 +140,20 @@ function formattedId(id) {
   }
   return id === null ? null : String(id);
 }
+
+/**
+ * Like {@link formattedId}, but asserts that `id` is not `null` rather
+ * than allowing and passing through `null`.
+ *
+ * @public
+ */
+
+/**
+ * Throws, since `id` is `null`.
+ *
+ * @public
+ */
+
 function expectId(id) {
   AssertFn('expectId: id must not be null', id !== null);
   return formattedId(id);

package/dist/unpkg/prod/compat.js

@@ -176,6 +176,14 @@ function fixRelationshipData(relationshipData, relationshipKind, {
   return payload;
 }
 const PotentialLegacyOperations = new Set(['findRecord', 'findAll', 'query', 'queryRecord', 'findBelongsTo', 'findHasMany', 'updateRecord', 'createRecord', 'deleteRecord']);
+
+/**
+ * A {@link Handler} that fulfills legacy `findRecord`/`findAll`/`query`/
+ * `queryRecord`/`findBelongsTo`/`findHasMany`/`createRecord`/`updateRecord`/
+ * `deleteRecord` requests using the store's configured {@link MinimumAdapterInterface | adapter}
+ * and {@link MinimumSerializerInterface | serializer}, passing any other
+ * request through to the next handler unchanged.
+ */
 const LegacyNetworkHandler = {
   request(context, next) {
     // if we are not a legacy request, move on
@@ -701,6 +709,10 @@ function pushPayload(modelName, inputPayload) {
   serializer.pushPayload(this, payload);
 }
 
+/**
+ * Serializes a record using the store's legacy network layer, as with
+ * {@link LegacyStoreCompat.serializeRecord | store.serializeRecord}.
+ */
 // TODO @runspired @deprecate records should implement their own serialization if desired
 function serializeRecord(record, options) {
   // TODO we used to check if the record was destroyed here
@@ -709,6 +721,11 @@ function serializeRecord(record, options) {
   }
   return this._fetchManager.createSnapshot(recordIdentifierFor(record)).serialize(options);
 }
+
+/**
+ * Destroys any adapters/serializers the legacy network layer has created
+ * for this store, invoked when the store itself is destroyed.
+ */
 function cleanup() {
   // enqueue destruction of any adapters/serializers we have created
   for (const adapterName in this._adapterCache) {

package/dist/unpkg/prod/{errors-BGVFCBmi.js → errors-B-PWeYlW.js}

@@ -63,7 +63,7 @@ PromiseBelongsTo.prototype[LegacyPromiseProxy] = true;
 
 /**
   This class is returned as the result of accessing an async hasMany relationship
-  on an instance of a Model extending from `@ember-data/model`.
+  on an instance of a Model extending from `@warp-drive/legacy/model`.
 
   A PromiseManyArray is an iterable proxy that allows templates to consume related
   ManyArrays and update once their contents are no longer pending.
@@ -77,6 +77,20 @@ PromiseBelongsTo.prototype[LegacyPromiseProxy] = true;
   @public
 */
 class PromiseManyArray {
+  /**
+   * The promise for the relationship's content, or `null` once
+   * {@link PromiseManyArray.destroy | destroy} has been called.
+   */
+
+  /**
+   * Whether {@link PromiseManyArray.destroy | destroy} has been called.
+   */
+
+  /**
+   * The resolved `ManyArray` for the relationship, if the promise has
+   * resolved, else `null`.
+   */
+
   constructor(promise, content) {
     this._update(promise, content);
     this.isDestroyed = false;
@@ -94,6 +108,9 @@ class PromiseManyArray {
     return this.content ? this.content.length : 0;
   }
 
+  /**
+   * @private
+   */
   // this will error if someone tries to call
   // A(identifierArray) since it is not configurable
   // which is preferrable to the `meta` override we used
@@ -190,6 +207,12 @@ class PromiseManyArray {
 
   //---- Methods on EmberObject that we should keep
 
+  /**
+   * Tears down this proxy, releasing its {@link PromiseManyArray.content | content} and
+   * {@link PromiseManyArray.promise | promise} and marking it as {@link PromiseManyArray.isDestroyed | destroyed}.
+   *
+   * @public
+   */
   destroy() {
     this.isDestroyed = true;
     this.content = null;

package/dist/unpkg/prod/{hooks-BztVA_x0.js → hooks-Bx-zBziU.js}

@@ -1,7 +1,15 @@
 import { setOwner, getOwner } from '@ember/application';
 import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
-import { g as getModelFactory } from "./schema-provider-DJtD_8jZ.js";
+import { g as getModelFactory } from "./schema-provider-BgRqk8i9.js";
 import { n as normalizeModelName } from "./util-DvanW33H.js";
+
+/**
+ * The `instantiateRecord` hook implementation for use with `Model`. Pass
+ * this to your store's `instantiateRecord` method when configuring the
+ * store to use `Model` for schema/record instantiation.
+ *
+ * @public
+ */
 function instantiateRecord(identifier, createRecordArgs) {
   const type = identifier.type;
 
@@ -21,9 +29,32 @@ function instantiateRecord(identifier, createRecordArgs) {
   const factory = getModelFactory(this, type);
   return factory.class.create(createOptions);
 }
+
+/**
+ * The `teardownRecord` hook implementation for use with `Model`. Pass this
+ * to your store's `teardownRecord` method when configuring the store to
+ * use `Model` for schema/record instantiation.
+ *
+ * @public
+ */
 function teardownRecord(record) {
   record.destroy();
 }
+
+/**
+ * The `modelFor` implementation for use with `Model`, exposed on the store
+ * as `store.modelFor(type)` when the store is configured to use `Model`.
+ * Returns the `Model` subclass registered for the given type, if any.
+ *
+ * @public
+ */
+
+/**
+ * Overload accepting a raw type string instead of a typed record instance.
+ *
+ * @public
+ */
+
 function modelFor(modelName) {
   assertPrivateStore(this);
   const type = normalizeModelName(modelName);

package/dist/unpkg/prod/index.js

@@ -7,12 +7,12 @@ import '@ember/object';
 import '@warp-drive/core/types/symbols';
 import '@warp-drive/utilities/string';
 import '@warp-drive/core/store/-private';
-import "./errors-BGVFCBmi.js";
-import "./schema-provider-DJtD_8jZ.js";
-import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-BztVA_x0.js";
+import "./errors-B-PWeYlW.js";
+import "./schema-provider-BgRqk8i9.js";
+import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-Bx-zBziU.js";
 import '@ember/application';
 import { registerDerivations as registerDerivations$1, DelegatingSchemaService } from './model/migration-support.js';
-import { F as FragmentExtension, a as FragmentArrayExtension, f as fragmentsModelFor } from "./model-for-CqXsIKws.js";
+import { F as FragmentExtension, a as FragmentArrayExtension, f as fragmentsModelFor } from "./model-for-CXkJw59V.js";
 import { restoreDeprecatedStoreBehaviors } from './store.js';
 
 /**
@@ -20,17 +20,183 @@ import { restoreDeprecatedStoreBehaviors } from './store.js';
  * @mergeModuleWith <project>
  */
 
+/**
+ * Setup options for a legacy store configured to use `Model` with `linksMode`
+ * enabled, meaning no legacy adapter/serializer request infrastructure is required.
+ *
+ * @public
+ */
+
+/**
+ * Setup options for a legacy store configured to use `Model` along with the
+ * legacy adapter/serializer network layer, but without the deprecated
+ * `store.findRecord`/`findAll`/`query`/etc. request methods.
+ *
+ * @public
+ */
+
+/**
+ * Setup options for a legacy store configured to use `Model` along with the
+ * legacy adapter/serializer network layer and the deprecated
+ * `store.findRecord`/`findAll`/`query`/etc. request methods.
+ *
+ * @public
+ */
+
 //export type ConfiguredStore<T = unknown> = typeof Store;
 
+/**
+ * The available options when setting up the legacy store,
+ * one of:
+ *
+ * - {@link LegacyModelStoreSetupOptions}
+ * - {@link LegacyModelAndNetworkStoreSetupOptions}
+ * - {@link LegacyModelAndNetworkAndRequestStoreSetupOptions}
+ */
+
 /**
  * Use the legacy store with the given options.
+ *
+ * See {@link LegacyStoreSetupOptions} for details on the available options.
+ *
+ * ```ts
+ * import { useLegacyStore } from '@warp-drive/legacy';
+ * import { JSONAPICache } from '@warp-drive/json-api';
+ *
+ * export default useLegacyStore({
+ *   linksMode: false,
+ *   legacyRequests: true,
+ *   cache: JSONAPICache,
+ *   schemas: [],
+ * });
+ * ```
+ *
+ * ### Adding Stateful Handlers
+ *
+ * A request {@link Handler} is sometimes more than a plain object or class
+ * with a `request` method — it may need access to a stateful dependency such
+ * as an Ember service (an auth token, a feature-flags service, an i18n
+ * helper, etc.).
+ *
+ * A plain class handler that only relies on Ember's `@service` decorator will
+ * not work here on its own: the handler is never instantiated *through*
+ * Ember's container (it's just `new`'d up), so it has no owner and its
+ * `@service` injections would fail to resolve.
+ *
+ * Instead, give `handlers` a function. It receives the {@link Store} instance
+ * being configured, which by the time the function runs already has an owner
+ * assigned. Use `getOwner`/`setOwner` from `@ember/owner` to transfer that
+ * owner onto your handler instance before returning it, exactly as you would
+ * when constructing any other DI-aware object outside of the container:
+ *
+ * ```ts
+ * import { getOwner, setOwner } from '@ember/owner';
+ * import { service } from '@ember/service';
+ * import { useLegacyStore } from '@warp-drive/legacy';
+ * import type { NextFn } from '@warp-drive/core/request';
+ * import type { RequestContext } from '@warp-drive/core/types/request';
+ * import { JSONAPICache } from '@warp-drive/json-api';
+ *
+ * class AuthHandler {
+ *   @service session;
+ *
+ *   request<T>(context: RequestContext, next: NextFn<T>) {
+ *     const headers = new Headers(context.request.headers);
+ *     headers.append('Authorization', `Bearer ${this.session.accessToken}`);
+ *     return next(Object.assign({}, context.request, { headers }));
+ *   }
+ * }
+ *
+ * export default useLegacyStore({
+ *   linksMode: false,
+ *   legacyRequests: true,
+ *   cache: JSONAPICache,
+ *   handlers: (store) => {
+ *     const authHandler = new AuthHandler();
+ *     setOwner(authHandler, getOwner(store)!);
+ *     return [authHandler];
+ *   },
+ * });
+ * ```
+ *
+ * The `handlers` function is invoked lazily and only once per store instance,
+ * the first time `store.requestManager` is accessed, so it is safe to do
+ * owner-dependent setup like this inside of it.
+ *
+ * ### Accessing the Store from a Handler's Context
+ *
+ * If a handler only needs to read something *off of the store itself*
+ * (its cache, or a property/service you've attached to a custom store
+ * subclass) rather than an unrelated Ember service, there is a second,
+ * simpler option that requires no DI/`setOwner` wiring at all.
+ *
+ * Every request issued via {@link Store.request | store.request(...)}
+ * automatically carries the originating store along as
+ * {@link RequestInfo.store | context.request.store}. Any handler — a plain
+ * object, a function-built handler, or a class — can read it directly,
+ * without needing the `handlers` callback form shown above:
+ *
+ * ```ts
+ * import { useLegacyStore } from '@warp-drive/legacy';
+ * import type { NextFn } from '@warp-drive/core/request';
+ * import type { RequestContext } from '@warp-drive/core/types/request';
+ * import { JSONAPICache } from '@warp-drive/json-api';
+ *
+ * const LoggingHandler = {
+ *   request<T>(context: RequestContext, next: NextFn<T>) {
+ *     // only present when the request was made via `store.request(...)`
+ *     const store = context.request.store;
+ *     if (store) {
+ *       console.log(`[${store.constructor.name}] ${context.request.url ?? ''}`);
+ *     }
+ *     return next(context.request);
+ *   },
+ * };
+ *
+ * export default useLegacyStore({
+ *   linksMode: false,
+ *   legacyRequests: true,
+ *   cache: JSONAPICache,
+ *   handlers: [LoggingHandler],
+ * });
+ * ```
+ *
+ * The trade-off versus the `getOwner`/`setOwner` pattern above is that
+ * `context.request.store` is only populated for requests issued via
+ * `store.request(...)`; a request made directly against a
+ * {@link RequestManager} won't have it set unless the caller supplies it
+ * explicitly, so a handler relying on it should treat it as optional (as
+ * `LoggingHandler` does above).
  */
 
 function useLegacyStore(options, StoreKlass = Store) {
   // we extend the store to ensure we don't leak our prototype overrides to other stores below.
   class BaseKlass extends StoreKlass {}
   class LegacyConfiguredStore extends BaseKlass {
-    requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...(options.handlers ?? []), Fetch].filter(Boolean)).useCache(CacheHandler);
+    constructor(createArgs) {
+      super(createArgs);
+      // installed via defineProperty (rather than a class field/accessor) so that
+      // this lazy override of the inherited `requestManager` field does not
+      // conflict with the documented pattern of assigning it directly on
+      // consumer-authored Store subclasses. The setter preserves the ability
+      // to replace `requestManager` outright after construction.
+      let requestManager;
+      Object.defineProperty(this, 'requestManager', {
+        configurable: true,
+        enumerable: true,
+        get: () => {
+          if (!requestManager) {
+            const handlersOption = options.handlers;
+            const handlers = typeof handlersOption === 'function' ? handlersOption(this) : handlersOption ?? [];
+            requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...handlers, Fetch].filter(Boolean)).useCache(CacheHandler);
+          }
+          return requestManager;
+        },
+        set: value => {
+          requestManager = value;
+        }
+      });
+    }
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,
       // 15 minutes