@ember-data/store 5.4.0-beta.1 → 5.4.0-beta.11

package/{addon → dist}/index.js

@@ -1 +1,4 @@
-export { C as CacheHandler, S as default, r as recordIdentifierFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./store-service-f6cb9898";
+export { C as CacheHandler, S as default, r as recordIdentifierFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, e as setKeyInfoForResource, s as storeFor } from "./cache-handler-C5ilAUZ5.js";
+import '@ember/debug';
+import '@embroider/macros';
+import '@ember-data/request-utils/string';

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/store",
-  "version": "5.4.0-beta.1",
+  "version": "5.4.0-beta.11",
   "description": "The core of EmberData. Provides the Store service which coordinates the cache with the network and presentation layers.",
   "keywords": [
     "ember-addon"
@@ -11,74 +11,87 @@
     "directory": "packages/store"
   },
   "license": "MIT",
-  "author": "",
-  "directories": {},
-  "ember-addon": {
-    "main": "addon-main.js",
-    "type": "addon",
-    "version": 1
-  },
+  "author": "Chris Thoburn <runspired@users.noreply.github.com>",
   "files": [
-    "addon-main.js",
-    "addon",
+    "unstable-preview-types",
+    "addon-main.cjs",
+    "dist",
     "README.md",
     "LICENSE.md",
     "ember-data-logo-dark.svg",
-    "ember-data-logo-light.svg",
-    "ember-data-logo-dark.svg",
     "ember-data-logo-light.svg"
   ],
-  "peerDependencies": {
-    "@ember-data/tracking": "5.4.0-beta.1",
-    "@ember/string": "^3.1.1",
-    "@glimmer/tracking": "^1.1.2"
+  "exports": {
+    ".": {
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "default": "./dist/*.js"
+    }
+  },
+  "scripts": {
+    "lint": "eslint . --quiet --cache --cache-strategy=content --report-unused-disable-directives",
+    "build:pkg": "vite build;",
+    "sync-hardlinks": "bun run sync-dependencies-meta-injected"
   },
   "dependenciesMeta": {
-    "@ember-data/private-build-infra": {
+    "@ember-data/tracking": {
+      "injected": true
+    },
+    "@ember-data/request": {
       "injected": true
     },
-    "@ember/string": {
+    "@ember-data/request-utils": {
+      "injected": true
+    },
+    "@warp-drive/core-types": {
+      "injected": true
+    },
+    "@warp-drive/build-config": {
       "injected": true
     }
   },
   "dependencies": {
-    "@ember-data/private-build-infra": "5.4.0-beta.1",
-    "@embroider/macros": "^1.13.1",
-    "ember-cached-decorator-polyfill": "^1.0.2",
-    "ember-cli-babel": "^8.0.0",
-    "@glimmer/validator": "^0.84.3"
+    "@embroider/macros": "^1.16.1",
+    "@warp-drive/build-config": "0.0.0-beta.6"
+  },
+  "peerDependencies": {
+    "@ember-data/request": "5.4.0-beta.11",
+    "@ember-data/request-utils": "5.4.0-beta.11",
+    "@ember-data/tracking": "5.4.0-beta.11",
+    "@warp-drive/core-types": "0.0.0-beta.11"
   },
   "devDependencies": {
-    "@babel/cli": "^7.22.15",
-    "@babel/core": "^7.22.20",
-    "@babel/plugin-proposal-decorators": "^7.22.15",
-    "@babel/plugin-transform-class-properties": "^7.22.5",
-    "@babel/plugin-transform-private-methods": "^7.22.5",
-    "@babel/plugin-transform-runtime": "^7.22.15",
-    "@babel/plugin-transform-typescript": "^7.22.15",
-    "@babel/preset-env": "^7.22.20",
-    "@babel/preset-typescript": "^7.22.15",
-    "@babel/runtime": "^7.22.15",
-    "@embroider/addon-dev": "^4.1.0",
+    "@babel/core": "^7.24.5",
+    "@babel/plugin-transform-typescript": "^7.24.5",
+    "@babel/preset-env": "^7.24.5",
+    "@babel/preset-typescript": "^7.24.1",
+    "@ember-data/request": "5.4.0-beta.11",
+    "@ember-data/request-utils": "5.4.0-beta.11",
+    "@ember-data/tracking": "5.4.0-beta.11",
     "@glimmer/component": "^1.1.2",
-    "@rollup/plugin-babel": "^6.0.3",
-    "@rollup/plugin-node-resolve": "^15.2.1",
-    "ember-source": "~5.3.0",
-    "rollup": "^3.29.3",
-    "tslib": "^2.6.2",
-    "typescript": "^5.2.2",
-    "walk-sync": "^3.0.0",
-    "webpack": "^5.88.2"
+    "@warp-drive/core-types": "0.0.0-beta.11",
+    "@warp-drive/internal-config": "5.4.0-beta.11",
+    "decorator-transforms": "^2.0.0",
+    "ember-source": "~5.8.0",
+    "expect-type": "^0.19.0",
+    "pnpm-sync-dependencies-meta-injected": "0.0.14",
+    "typescript": "^5.4.5",
+    "vite": "^5.2.11"
   },
   "engines": {
-    "node": "16.* || >= 18.*"
+    "node": ">= 18.20.3"
   },
   "volta": {
     "extends": "../../package.json"
   },
-  "packageManager": "pnpm@8.7.6",
-  "scripts": {
-    "build": "rollup --config && babel ./addon --out-dir addon --plugins=../private-build-infra/src/transforms/babel-plugin-transform-ext.js",
-    "start": "rollup --config --watch"
+  "packageManager": "pnpm@8.15.8",
+  "ember-addon": {
+    "main": "addon-main.cjs",
+    "type": "addon",
+    "version": 2
+  },
+  "ember": {
+    "edition": "octane"
   }
-}
+}

package/unstable-preview-types/-private/cache-handler.d.ts

@@ -0,0 +1,144 @@
+declare module '@ember-data/store/-private/cache-handler' {
+  /**
+   * @module @ember-data/store
+   */
+  import type { CacheHandler as CacheHandlerType } from '@ember-data/request';
+  import type { StableDocumentIdentifier } from '@warp-drive/core-types/identifier';
+  import type { ImmutableRequestInfo, RequestContext, ResponseInfo } from '@warp-drive/core-types/request';
+  import { EnableHydration } from '@warp-drive/core-types/request';
+  import type { ResourceIdentifierObject } from '@warp-drive/core-types/spec/json-api-raw';
+  import type { Store } from '@ember-data/store/-private/store-service';
+  /**
+   * A service which an application may provide to the store via
+   * the store's `lifetimes` property to configure the behavior
+   * of the CacheHandler.
+   *
+   * The default behavior for request lifetimes is to never expire
+   * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
+   *
+   * Implementing this service allows you to programatically define
+   * when a request should be considered expired.
+   *
+   * @class <Interface> CachePolicy
+   * @public
+   */
+  export interface CachePolicy {
+      /**
+       * Invoked to determine if the request may be fulfilled from cache
+       * if possible.
+       *
+       * Note, this is only invoked if the request has a cache-key.
+       *
+       * If no cache entry is found or the entry is hard expired,
+       * the request will be fulfilled from the configured request handlers
+       * and the cache will be updated before returning the response.
+       *
+       * @method isHardExpired
+       * @public
+       * @param {StableDocumentIdentifier} identifier
+       * @param {Store} store
+       * @return {boolean} true if the request is considered hard expired
+       */
+      isHardExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
+      /**
+       * Invoked if `isHardExpired` is false to determine if the request
+       * should be update behind the scenes if cache data is already available.
+       *
+       * Note, this is only invoked if the request has a cache-key.
+       *
+       * If true, the request will be fulfilled from cache while a backgrounded
+       * request is made to update the cache via the configured request handlers.
+       *
+       * @method isSoftExpired
+       * @public
+       * @param {StableDocumentIdentifier} identifier
+       * @param {Store} store
+       * @return {boolean} true if the request is considered soft expired
+       */
+      isSoftExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
+      /**
+       * Invoked when a request will be sent to the configured request handlers.
+       * This is invoked for both foreground and background requests.
+       *
+       * Note, this is invoked regardless of whether the request has a cache-key.
+       *
+       * @method willRequest [Optional]
+       * @public
+       * @param {ImmutableRequestInfo} request
+       * @param {StableDocumentIdentifier | null} identifier
+       * @param {Store} store
+       * @return {void}
+       */
+      willRequest?(request: ImmutableRequestInfo, identifier: StableDocumentIdentifier | null, store: Store): void;
+      /**
+       * Invoked when a request has been fulfilled from the configured request handlers.
+       * This is invoked for both foreground and background requests once the cache has
+       * been updated.
+       *
+       * Note, this is invoked regardless of whether the request has a cache-key.
+       *
+       * @method didRequest [Optional]
+       * @public
+       * @param {ImmutableRequestInfo} request
+       * @param {ImmutableResponse} response
+       * @param {StableDocumentIdentifier | null} identifier
+       * @param {Store} store
+       * @return {void}
+       */
+      didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: StableDocumentIdentifier | null, store: Store): void;
+  }
+  export type LooseStoreRequestInfo<T = unknown, RT = unknown> = Omit<ImmutableRequestInfo<T, RT>, 'records' | 'headers'> & {
+      records?: ResourceIdentifierObject[];
+      headers?: Headers;
+  };
+  export type StoreRequestInput<T = unknown, RT = unknown> = ImmutableRequestInfo<T, RT> | LooseStoreRequestInfo<T, RT>;
+  export interface StoreRequestContext extends RequestContext {
+      request: ImmutableRequestInfo & {
+          store: Store;
+          [EnableHydration]?: boolean;
+      };
+  }
+  /**
+   * A CacheHandler that adds support for using an EmberData Cache with a RequestManager.
+   *
+   * This handler will only run when a request has supplied a `store` instance. Requests
+   * issued by the store via `store.request()` will automatically have the `store` instance
+   * attached to the request.
+   *
+   * ```ts
+   * requestManager.request({
+   *   store: store,
+   *   url: '/api/posts',
+   *   method: 'GET'
+   * });
+   * ```
+   *
+   * When this handler elects to handle a request, it will return the raw `StructuredDocument`
+   * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
+   * return a `Document` instance that will automatically update the UI when the cache is updated
+   * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
+   *
+   * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
+   * means that if desired you can issue requests that utilize the cache without needing to also
+   * utilize Record instances if desired.
+   *
+   * Said differently, you could elect to issue all requests via a RequestManager, without ever using
+   * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
+   * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
+   * approach of EmberData allows for this flexibility.
+   *
+   * ```ts
+   * import { EnableHydration } from '@warp-drive/core-types/request';
+   *
+   * requestManager.request({
+   *   store: store,
+   *   url: '/api/posts',
+   *   method: 'GET',
+   *   [EnableHydration]: true
+   * });
+   *
+   * @typedoc
+   */
+  export const CacheHandler: CacheHandlerType;
+}
+//# sourceMappingURL=cache-handler.d.ts.map

package/unstable-preview-types/-private/cache-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-handler.d.ts","sourceRoot":"","sources":["../../src/-private/cache-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAE5F,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EAGV,oBAAoB,EAEpB,cAAc,EACd,YAAY,EAGb,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAa,MAAM,gCAAgC,CAAC;AAO5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AAIzF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;OAeG;IACH,aAAa,CAAC,UAAU,EAAE,wBAAwB,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAC3E;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,UAAU,EAAE,wBAAwB,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAE3E;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,CAAC,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,wBAAwB,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAE7G;;;;;;;;;;;;;;OAcG;IACH,UAAU,CAAC,CACT,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,QAAQ,GAAG,YAAY,GAAG,IAAI,EACxC,UAAU,EAAE,wBAAwB,GAAG,IAAI,EAC3C,KAAK,EAAE,KAAK,GACX,IAAI,CAAC;CACT;AAED,MAAM,MAAM,qBAAqB,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,GAAG,OAAO,IAAI,IAAI,CACjE,oBAAoB,CAAC,CAAC,EAAE,EAAE,CAAC,EAC3B,SAAS,GAAG,SAAS,CACtB,GAAG;IACF,OAAO,CAAC,EAAE,wBAAwB,EAAE,CAAC;IACrC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,GAAG,OAAO,IAAI,oBAAoB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,qBAAqB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAEtH,MAAM,WAAW,mBAAoB,SAAQ,cAAc;IACzD,OAAO,EAAE,oBAAoB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,CAAC,eAAe,CAAC,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC/E;AA6TD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,YAAY,EAAE,gBAuD1B,CAAC"}

package/unstable-preview-types/-private/caches/cache-utils.d.ts

@@ -0,0 +1,11 @@
+declare module '@ember-data/store/-private/caches/cache-utils' {
+  import type { Cache } from '@warp-drive/core-types/cache';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
+  export const CacheForIdentifierCache: Map<unknown, Cache>;
+  export function setCacheFor(identifier: StableRecordIdentifier | OpaqueRecordInstance, cache: Cache): void;
+  export function removeRecordDataFor(identifier: StableRecordIdentifier | OpaqueRecordInstance): void;
+  export function peekCache(instance: StableRecordIdentifier): Cache | null;
+  export function peekCache(instance: OpaqueRecordInstance): Cache;
+}
+//# sourceMappingURL=cache-utils.d.ts.map

package/unstable-preview-types/-private/caches/cache-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-utils.d.ts","sourceRoot":"","sources":["../../../src/-private/caches/cache-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAEhF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAO3E,eAAO,MAAM,uBAAuB,qBAGnC,CAAC;AAEF,wBAAgB,WAAW,CAAC,UAAU,EAAE,sBAAsB,GAAG,oBAAoB,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAMzG;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,sBAAsB,GAAG,oBAAoB,GAAG,IAAI,CAEnG;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,sBAAsB,GAAG,KAAK,GAAG,IAAI,CAAC;AAC1E,wBAAgB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,KAAK,CAAC"}

package/unstable-preview-types/-private/caches/identifier-cache.d.ts

@@ -0,0 +1,176 @@
+declare module '@ember-data/store/-private/caches/identifier-cache' {
+  import { type Identifier, type RecordIdentifier, type StableDocumentIdentifier, type StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type { ImmutableRequestInfo } from '@warp-drive/core-types/request';
+  import type { ResourceIdentifierObject } from '@warp-drive/core-types/spec/json-api-raw';
+  import type { ForgetMethod, GenerationMethod, KeyInfo, KeyInfoMethod, ResetMethod, UpdateMethod } from '@ember-data/store/-types/q/identifier';
+  export function isStableIdentifier(identifier: unknown): identifier is StableRecordIdentifier;
+  export function isDocumentIdentifier(identifier: unknown): identifier is StableDocumentIdentifier;
+  interface KeyOptions {
+      lid: IdentifierMap;
+      id: IdentifierMap;
+  }
+  type TypeMap = {
+      [key: string]: KeyOptions;
+  };
+  type IdentifierMap = Map<string, StableRecordIdentifier>;
+  type StableCache = {
+      resources: IdentifierMap;
+      documents: Map<string, StableDocumentIdentifier>;
+      resourcesByType: TypeMap;
+      polymorphicLidBackMap: Map<string, string[]>;
+  };
+  export type MergeMethod = (targetIdentifier: StableRecordIdentifier, matchedIdentifier: StableRecordIdentifier, resourceData: unknown) => StableRecordIdentifier;
+  export function setIdentifierGenerationMethod(method: GenerationMethod | null): void;
+  export function setIdentifierUpdateMethod(method: UpdateMethod | null): void;
+  export function setIdentifierForgetMethod(method: ForgetMethod | null): void;
+  export function setIdentifierResetMethod(method: ResetMethod | null): void;
+  export function setKeyInfoForResource(method: KeyInfoMethod | null): void;
+  /**
+   * Each instance of {Store} receives a unique instance of a IdentifierCache.
+   *
+   * This cache is responsible for assigning or retrieving the unique identify
+   * for arbitrary resource data encountered by the store. Data representing
+   * a unique resource or record should always be represented by the same
+   * identifier.
+   *
+   * It can be configured by consuming applications.
+   *
+   * @class IdentifierCache
+     @public
+   */
+  export class IdentifierCache {
+      _cache: StableCache;
+      _generate: GenerationMethod;
+      _update: UpdateMethod;
+      _forget: ForgetMethod;
+      _reset: ResetMethod;
+      _merge: MergeMethod;
+      _keyInfoForResource: KeyInfoMethod;
+      _id: number;
+      constructor();
+      /**
+       * Internal hook to allow management of merge conflicts with identifiers.
+       *
+       * we allow late binding of this private internal merge so that
+       * the cache can insert itself here to handle elimination of duplicates
+       *
+       * @method __configureMerge
+       * @private
+       */
+      __configureMerge(method: MergeMethod | null): void;
+      upgradeIdentifier(resource: {
+          type: string;
+          id: string | null;
+          lid?: string;
+      }): StableRecordIdentifier;
+      /**
+       * @method _getRecordIdentifier
+       * @private
+       */
+      _getRecordIdentifier(resource: {
+          type: string;
+          id: string | null;
+          lid?: string;
+      }, shouldGenerate: 2): StableRecordIdentifier;
+      _getRecordIdentifier(resource: unknown, shouldGenerate: 1): StableRecordIdentifier;
+      _getRecordIdentifier(resource: unknown, shouldGenerate: 0): StableRecordIdentifier | undefined;
+      /**
+       * allows us to peek without generating when needed
+       * useful for the "create" case when we need to see if
+       * we are accidentally overwritting something
+       *
+       * @method peekRecordIdentifier
+       * @param resource
+       * @return {StableRecordIdentifier | undefined}
+       * @private
+       */
+      peekRecordIdentifier(resource: ResourceIdentifierObject | Identifier): StableRecordIdentifier | undefined;
+      /**
+        Returns the DocumentIdentifier for the given Request, creates one if it does not yet exist.
+        Returns `null` if the request does not have a `cacheKey` or `url`.
+    
+        @method getOrCreateDocumentIdentifier
+        @param request
+        @return {StableDocumentIdentifier | null}
+        @public
+      */
+      getOrCreateDocumentIdentifier(request: ImmutableRequestInfo): StableDocumentIdentifier | null;
+      /**
+        Returns the Identifier for the given Resource, creates one if it does not yet exist.
+    
+        Specifically this means that we:
+    
+        - validate the `id` `type` and `lid` combo against known identifiers
+        - return an object with an `lid` that is stable (repeated calls with the same
+          `id` + `type` or `lid` will return the same `lid` value)
+        - this referential stability of the object itself is guaranteed
+    
+        @method getOrCreateRecordIdentifier
+        @param resource
+        @return {StableRecordIdentifier}
+        @public
+      */
+      getOrCreateRecordIdentifier(resource: unknown): StableRecordIdentifier;
+      /**
+       Returns a new Identifier for the supplied data. Call this method to generate
+       an identifier when a new resource is being created local to the client and
+       potentially does not have an `id`.
+    
+       Delegates generation to the user supplied `GenerateMethod` if one has been provided
+       with the signature `generateMethod({ type }, 'record')`.
+    
+       @method createIdentifierForNewRecord
+       @param data
+       @return {StableRecordIdentifier}
+       @public
+      */
+      createIdentifierForNewRecord(data: {
+          type: string;
+          id?: string | null;
+      }): StableRecordIdentifier;
+      /**
+       Provides the opportunity to update secondary lookup tables for existing identifiers
+       Called after an identifier created with `createIdentifierForNewRecord` has been
+       committed.
+    
+       Assigned `id` to an `Identifier` if `id` has not previously existed; however,
+       attempting to change the `id` or calling update without providing an `id` when
+       one is missing will throw an error.
+    
+        - sets `id` (if `id` was previously `null`)
+        - `lid` and `type` MUST NOT be altered post creation
+    
+        If a merge occurs, it is possible the returned identifier does not match the originally
+        provided identifier. In this case the abandoned identifier will go through the usual
+        `forgetRecordIdentifier` codepaths.
+    
+        @method updateRecordIdentifier
+        @param identifierObject
+        @param data
+        @return {StableRecordIdentifier}
+        @public
+      */
+      updateRecordIdentifier(identifierObject: RecordIdentifier, data: unknown): StableRecordIdentifier;
+      /**
+       * @method _mergeRecordIdentifiers
+       * @private
+       */
+      _mergeRecordIdentifiers(keyInfo: KeyInfo, identifier: StableRecordIdentifier, existingIdentifier: StableRecordIdentifier, data: unknown): StableRecordIdentifier;
+      /**
+       Provides the opportunity to eliminate an identifier from secondary lookup tables
+       as well as eliminates it from ember-data's own lookup tables and book keeping.
+    
+       Useful when a record has been deleted and the deletion has been persisted and
+       we do not care about the record anymore. Especially useful when an `id` of a
+       deleted record might be reused later for a new record.
+    
+       @method forgetRecordIdentifier
+       @param identifierObject
+       @public
+      */
+      forgetRecordIdentifier(identifierObject: RecordIdentifier): void;
+      destroy(): void;
+  }
+  export {};
+}
+//# sourceMappingURL=identifier-cache.d.ts.map

package/unstable-preview-types/-private/caches/identifier-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifier-cache.d.ts","sourceRoot":"","sources":["../../../src/-private/caches/identifier-cache.ts"],"names":[],"mappings":"AAWA,OAAO,EAKL,KAAK,UAAU,EAEf,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAE7B,KAAK,sBAAsB,EAC5B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,KAAK,EAA0B,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AAEjH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,WAAW,EACX,YAAY,EACb,MAAM,2BAA2B,CAAC;AAWnC,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,OAAO,GAAG,UAAU,IAAI,sBAAsB,CAE5F;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,UAAU,IAAI,wBAAwB,CAEhG;AAwBD,UAAU,UAAU;IAClB,GAAG,EAAE,aAAa,CAAC;IACnB,EAAE,EAAE,aAAa,CAAC;CACnB;AACD,KAAK,OAAO,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC;AAI7C,KAAK,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AAEzD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,aAAa,CAAC;IACzB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;IACjD,eAAe,EAAE,OAAO,CAAC;IACzB,qBAAqB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,CACxB,gBAAgB,EAAE,sBAAsB,EACxC,iBAAiB,EAAE,sBAAsB,EACzC,YAAY,EAAE,OAAO,KAClB,sBAAsB,CAAC;AAE5B,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,IAAI,CAEnF;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAE3E;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAE3E;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAEzE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAExE;AA+FD;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAe;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,mBAAmB,EAAE,aAAa,CAAC;IACnC,GAAG,EAAE,MAAM,CAAC;;IAsBpB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAI3C,iBAAiB,CAAC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,sBAAsB;IAItG;;;OAGG;IACH,oBAAoB,CAClB,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,EAC3D,cAAc,EAAE,CAAC,GAChB,sBAAsB;IACzB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,GAAG,sBAAsB;IAClF,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,GAAG,sBAAsB,GAAG,SAAS;IAsE9F;;;;;;;;;OASG;IACH,oBAAoB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,UAAU,GAAG,sBAAsB,GAAG,SAAS;IAIzG;;;;;;;;MAQE;IACF,6BAA6B,CAAC,OAAO,EAAE,oBAAoB,GAAG,wBAAwB,GAAG,IAAI;IAyB7F;;;;;;;;;;;;;;MAcE;IACF,2BAA2B,CAAC,QAAQ,EAAE,OAAO,GAAG,sBAAsB;IAItE;;;;;;;;;;;;MAYE;IACF,4BAA4B,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,sBAAsB;IAyBhG;;;;;;;;;;;;;;;;;;;;;MAqBE;IACF,sBAAsB,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,IAAI,EAAE,OAAO,GAAG,sBAAsB;IAoEjG;;;OAGG;IACH,uBAAuB,CACrB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,sBAAsB,EAClC,kBAAkB,EAAE,sBAAsB,EAC1C,IAAI,EAAE,OAAO,GACZ,sBAAsB;IAoCzB;;;;;;;;;;;MAWE;IACF,sBAAsB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI;IA+BhE,OAAO;CAOR"}

package/unstable-preview-types/-private/caches/instance-cache.d.ts

@@ -0,0 +1,61 @@
+declare module '@ember-data/store/-private/caches/instance-cache' {
+  import type { Cache } from '@warp-drive/core-types/cache';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type { Value } from '@warp-drive/core-types/json/raw';
+  import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core-types/record';
+  import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
+  import RecordReference from '@ember-data/store/-private/legacy-model-support/record-reference';
+  import { CacheCapabilitiesManager } from '@ember-data/store/-private/managers/cache-capabilities-manager';
+  import type { CacheManager } from '@ember-data/store/-private/managers/cache-manager';
+  import type { CreateRecordProperties, Store } from '@ember-data/store/-private/store-service';
+  export function peekRecordIdentifier(record: OpaqueRecordInstance): StableRecordIdentifier | undefined;
+  /**
+    Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/StableRecordIdentifier)
+    assigned to the given record instance.
+    ```js
+    import { recordIdentifierFor } from "@ember-data/store";
+    // ... gain access to a record, for instance with peekRecord or findRecord
+    const record = store.peekRecord("user", "1");
+    // get the identifier for the record (see docs for StableRecordIdentifier)
+    const identifier = recordIdentifierFor(record);
+    // access the identifier's properties.
+    const { id, type, lid } = identifier;
+    ```
+    @method recordIdentifierFor
+    @public
+    @static
+    @for @ember-data/store
+    @param {Object} record a record instance previously obstained from the store.
+    @return {StableRecordIdentifier}
+   */
+  export function recordIdentifierFor<T extends TypedRecordInstance>(record: T): StableRecordIdentifier<TypeFromInstance<T>>;
+  export function recordIdentifierFor(record: OpaqueRecordInstance): StableRecordIdentifier;
+  export function setRecordIdentifier(record: OpaqueRecordInstance, identifier: StableRecordIdentifier): void;
+  export const StoreMap: Map<unknown, Store>;
+  export function storeFor(record: OpaqueRecordInstance): Store | undefined;
+  type Caches = {
+      record: Map<StableRecordIdentifier, OpaqueRecordInstance>;
+      reference: WeakMap<StableRecordIdentifier, RecordReference>;
+  };
+  export class InstanceCache {
+      store: Store;
+      cache: Cache;
+      _storeWrapper: CacheCapabilitiesManager;
+      __cacheManager: CacheManager;
+      __instances: Caches;
+      constructor(store: Store);
+      peek(identifier: StableRecordIdentifier): Cache | OpaqueRecordInstance | undefined;
+      getRecord(identifier: StableRecordIdentifier, properties?: CreateRecordProperties): OpaqueRecordInstance;
+      getReference(identifier: StableRecordIdentifier): RecordReference;
+      recordIsLoaded(identifier: StableRecordIdentifier, filterDeleted?: boolean): boolean;
+      disconnect(identifier: StableRecordIdentifier): void;
+      unloadRecord(identifier: StableRecordIdentifier): void;
+      clear(type?: string): void;
+      setRecordId(identifier: StableRecordIdentifier, id: string): void;
+  }
+  export function resourceIsFullyDeleted(instanceCache: InstanceCache, identifier: StableRecordIdentifier): boolean;
+  export function preloadData(store: Store, identifier: StableRecordIdentifier, preload: Record<string, Value>): void;
+  export function _clearCaches(): void;
+  export {};
+}
+//# sourceMappingURL=instance-cache.d.ts.map

package/unstable-preview-types/-private/caches/instance-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-cache.d.ts","sourceRoot":"","sources":["../../../src/-private/caches/instance-cache.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAA4B,MAAM,+BAA+B,CAAC;AAQrH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,eAAe,MAAM,0CAA0C,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAoBtE,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,sBAAsB,GAAG,SAAS,CAErG;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,mBAAmB,EAC/D,MAAM,EAAE,CAAC,GACR,sBAAsB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/C,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,oBAAoB,GAAG,sBAAsB,CAAC;AAM1F,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,oBAAoB,EAAE,UAAU,EAAE,sBAAsB,GAAG,IAAI,CAgB1G;AAED,eAAO,MAAM,QAAQ,qBAAqE,CAAC;AAE3F,wBAAgB,QAAQ,CAAC,MAAM,EAAE,oBAAoB,GAAG,KAAK,GAAG,SAAS,CAQxE;AAED,KAAK,MAAM,GAAG;IACZ,MAAM,EAAE,GAAG,CAAC,sBAAsB,EAAE,oBAAoB,CAAC,CAAC;IAC1D,SAAS,EAAE,OAAO,CAAC,sBAAsB,EAAE,eAAe,CAAC,CAAC;CAC7D,CAAC;AAEF,qBAAa,aAAa;IAChB,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,EAAE,wBAAwB,CAAC;IAExC,cAAc,EAAE,YAAY,CAAC;IACrC,WAAW,EAAE,MAAM,CAGjB;gBAEU,KAAK,EAAE,KAAK;IAkExB,IAAI,CAAC,UAAU,EAAE,sBAAsB,GAAG,KAAK,GAAG,oBAAoB,GAAG,SAAS;IAIlF,SAAS,CAAC,UAAU,EAAE,sBAAsB,EAAE,UAAU,CAAC,EAAE,sBAAsB,GAAG,oBAAoB;IA2BxG,YAAY,CAAC,UAAU,EAAE,sBAAsB;IAW/C,cAAc,CAAC,UAAU,EAAE,sBAAsB,EAAE,aAAa,UAAQ;IAsBxE,UAAU,CAAC,UAAU,EAAE,sBAAsB;IAkB7C,YAAY,CAAC,UAAU,EAAE,sBAAsB;IAuD/C,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM;IAuBnB,WAAW,CAAC,UAAU,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM;CA+C3D;AAMD,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,sBAAsB,GAAG,OAAO,CAGhH;AAcD,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,sBAAsB,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,QAwB3G;AAiCD,wBAAgB,YAAY,SAI3B"}

package/unstable-preview-types/-private/caches/resource-utils.d.ts

@@ -0,0 +1,12 @@
+declare module '@ember-data/store/-private/caches/resource-utils' {
+  export function hasLid(resource: unknown): resource is {
+      lid: string;
+  };
+  export function hasId(resource: unknown): resource is {
+      id: string;
+  };
+  export function hasType(resource: unknown): resource is {
+      type: string;
+  };
+}
+//# sourceMappingURL=resource-utils.d.ts.map

package/unstable-preview-types/-private/caches/resource-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-utils.d.ts","sourceRoot":"","sources":["../../../src/-private/caches/resource-utils.ts"],"names":[],"mappings":"AAUA,wBAAgB,MAAM,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAErE;AAED,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAInE;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAEvE"}