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

package/dist/compat/utils.d.ts

@@ -1,10 +1,11 @@
-//#region src/compat/utils.d.ts
 type Reporter = (type: "formatted-id" | "formatted-type", actual: unknown, expected: unknown) => void;
 /**
  * Configure a function to be called when an id or type
  * changes during normalization. This is useful for instrumenting
  * to discover places where usage in the app is not consistent.
  *
+ * @summary Legacy migration helper that registers a callback invoked whenever `formattedId` or `formattedType`
+ * has to change the id or type it was given.
  * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
  * @public
  */
@@ -14,6 +15,8 @@ export declare function configureMismatchReporter(fn: Reporter): void;
  * fails validation. This is useful for instrumenting
  * to discover places where usage in the app is not consistent.
  *
+ * @summary Legacy migration helper that registers a callback invoked when an id or type passed to these utilities
+ * fails validation.
  * @param fn - a function which takes a message and a condition
  * @public
  */
@@ -28,6 +31,8 @@ export declare function configureAssertFn(fn: (message: string, condition: unkno
  * the configured mismatch reporter and assert functions will
  * be called.
  *
+ * @summary Legacy migration helper that replaces the singularize-and-dasherize function `formattedType` and
+ * `isEquivType` use to normalize resource types.
  * @param fn - a function which takes a string and returns a string
  * @public
  */
@@ -57,6 +62,8 @@ export declare function configureTypeNormalization(fn: (type: string) => string)
  * formattedType('PostComment'); // => 'post-comment'
  * ```
  *
+ * @summary Legacy migration helper that normalizes a resource type to the singular dasherized form the cache
+ * expects, such as `'PostComments'` to `'post-comment'`.
  * @param type the potentially un-normalized type
  * @return the normalized type
  * @public
@@ -78,6 +85,8 @@ export declare function formattedType<T extends string>(type: T | string): T;
  * formattedId(null); // => null
  *	```
  *
+ * @summary Legacy migration helper that normalizes a resource id to the `string` or `null` the cache expects,
+ * asserting on invalid ids such as `''` or `0`.
  * @param id the potentially un-normalized id
  * @return the normalized id
  * @public
@@ -89,6 +98,8 @@ export declare function formattedId(id: string | number | null): string | null;
  * Like {@link formattedId}, but asserts that `id` is not `null` rather
  * than allowing and passing through `null`.
  *
+ * @summary Legacy migration helper that normalizes a resource id to a string like `formattedId`, but asserts that
+ * it is not `null`.
  * @public
  */
 export declare function expectId(id: string | number): string;
@@ -118,6 +129,8 @@ export declare function expectId(id: null): never;
  * isEquivType('posts', null); // false
  * ```
  *
+ * @summary Legacy migration helper that reports whether two resource types match after normalization, so
+ * `'posts'` and `'post'` are equivalent.
  * @param expected a potentially unnormalized type to match against
  * @param actual a potentially unnormalized type to match against
  * @return true if the types are equivalent
@@ -140,11 +153,13 @@ export declare function isEquivType(expected: string, actual: string): boolean;
  * isEquivId(1, null); // false
  * ```
  *
+ * @summary Legacy migration helper that reports whether two resource ids match after normalization, so `1` and
+ * `'1'` are equivalent.
  * @param expected a potentially un-normalized id to match against
  * @param actual a potentially un-normalized id to match against
  * @return true if the ids are equivalent
  * @public
  */
 export declare function isEquivId(expected: string | number, actual: string | number | null): boolean;
-//#endregion
+export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/compat/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/compat/utils.ts"],"mappings":";KAcK,YAAY,yCAAyC,iBAAiB;;;;;;;;;wBA0B3D,0BAA0B,IAAI;;;;;;;;;wBAY9B,kBAAkB,KAAK,iBAAiB;;;;;;;;;;;;;;wBAiBxC,2BAA2B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAmChC,cAAc,kBAAkB,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;wBAuCnD,YAAY;wBACZ,YAAY;wBACZ,YAAY;;;;;;;wBA0BZ,SAAS;;;;;;wBAMT,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgCT,YAAY,kBAAkB;;;;;;;;;;;;;;;;;;;;;;wBAmC9B,UAAU,2BAA2B"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/compat/utils.ts"],"mappings":"A,KAgBK,YAAY,yCAAyC,iBAAiB;;;;;;;;;;;wBA4B3D,0BAA0B,IAAI;;;;;;;;;;;wBAc9B,kBAAkB,KAAK,iBAAiB;;;;;;;;;;;;;;;;wBAmBxC,2BAA2B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqChC,cAAc,kBAAkB,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;wBAyCnD,YAAY;wBACZ,YAAY;wBACZ,YAAY;;;;;;;;;wBA4BZ,SAAS;;;;;;wBAMT,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkCT,YAAY,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;wBAqC9B,UAAU,2BAA2B"}

package/dist/compat/utils.js

@@ -1,11 +1,13 @@
 import { getGlobalConfig, macroCondition } from "@embroider/macros";
 import { dasherize, singularize } from "@warp-drive/utilities/string";
 
-//#region src/compat/utils.ts
+// src/compat/utils.ts
 /**
 Utilities for helping to migrate to stricter
 and more consistent use of IDs and types.
 
+@summary Legacy helpers that normalize, compare, and report mismatched resource ids and types while migrating to
+stricter formats.
 @module
 */
 let MismatchReporter = function() {};
@@ -24,6 +26,8 @@ let NormalizedType = (str) => {
 * changes during normalization. This is useful for instrumenting
 * to discover places where usage in the app is not consistent.
 *
+* @summary Legacy migration helper that registers a callback invoked whenever `formattedId` or `formattedType`
+* has to change the id or type it was given.
 * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
 * @public
 */
@@ -35,6 +39,8 @@ function configureMismatchReporter(fn) {
 * fails validation. This is useful for instrumenting
 * to discover places where usage in the app is not consistent.
 *
+* @summary Legacy migration helper that registers a callback invoked when an id or type passed to these utilities
+* fails validation.
 * @param fn - a function which takes a message and a condition
 * @public
 */
@@ -51,6 +57,8 @@ function configureAssertFn(fn) {
 * the configured mismatch reporter and assert functions will
 * be called.
 *
+* @summary Legacy migration helper that replaces the singularize-and-dasherize function `formattedType` and
+* `isEquivType` use to normalize resource types.
 * @param fn - a function which takes a string and returns a string
 * @public
 */
@@ -83,6 +91,8 @@ const NORMALIZED_TYPES = /* @__PURE__ */ new Map();
 * formattedType('PostComment'); // => 'post-comment'
 * ```
 *
+* @summary Legacy migration helper that normalizes a resource type to the singular dasherized form the cache
+* expects, such as `'PostComments'` to `'post-comment'`.
 * @param type the potentially un-normalized type
 * @return the normalized type
 * @public
@@ -116,6 +126,8 @@ function formattedType(type) {
 * formattedId(null); // => null
 *	```
 *
+* @summary Legacy migration helper that normalizes a resource id to the `string` or `null` the cache expects,
+* asserting on invalid ids such as `''` or `0`.
 * @param id the potentially un-normalized id
 * @return the normalized id
 * @public
@@ -133,6 +145,8 @@ function formattedId(id) {
 * Like {@link formattedId}, but asserts that `id` is not `null` rather
 * than allowing and passing through `null`.
 *
+* @summary Legacy migration helper that normalizes a resource id to a string like `formattedId`, but asserts that
+* it is not `null`.
 * @public
 */
 /**
@@ -164,6 +178,8 @@ function expectId(id) {
 * isEquivType('posts', null); // false
 * ```
 *
+* @summary Legacy migration helper that reports whether two resource types match after normalization, so
+* `'posts'` and `'post'` are equivalent.
 * @param expected a potentially unnormalized type to match against
 * @param actual a potentially unnormalized type to match against
 * @return true if the types are equivalent
@@ -196,6 +212,8 @@ function isEquivType(expected, actual) {
 * isEquivId(1, null); // false
 * ```
 *
+* @summary Legacy migration helper that reports whether two resource ids match after normalization, so `1` and
+* `'1'` are equivalent.
 * @param expected a potentially un-normalized id to match against
 * @param actual a potentially un-normalized id to match against
 * @return true if the ids are equivalent
@@ -214,6 +232,5 @@ function isEquivId(expected, actual) {
 	return expected === actual || formattedId(expected) === formattedId(actual);
 }
 
-//#endregion
 export { configureAssertFn, configureMismatchReporter, configureTypeNormalization, expectId, formattedId, formattedType, isEquivId, isEquivType };
 //# sourceMappingURL=utils.js.map

package/dist/compat/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":["dasherize","singularize","macroCondition","getGlobalConfig","MismatchReporter","_AssertFn","AssertFn","message","condition","WarpDrive","env","DEBUG","test","Error","NormalizedType","str","configureMismatchReporter","fn","configureAssertFn","configureTypeNormalization","NORMALIZED_TYPES","Map","formattedType","type","undefined","length","normalized","get","set","formattedId","id","formatted","String","expectId","isEquivType","expected","actual","isEquivId"],"sources":["../../src/compat/utils.ts"],"sourcesContent":["/**\n  Utilities for helping to migrate to stricter\n  and more consistent use of IDs and types.\n\n  @module\n*/\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport { dasherize, singularize } from '@warp-drive/utilities/string';\n\ninterface AssertFunc {\n  (desc: string, condition: unknown): asserts condition;\n  (desc: string): never;\n}\n\ntype Reporter = (type: 'formatted-id' | 'formatted-type', actual: unknown, expected: unknown) => void;\ntype Normalizer = (type: string) => string;\n\nlet MismatchReporter: Reporter = function () {};\n\n// TODO: @runspired This pattern prevents AssertFn from being removed in production builds\n// but we should enable that if we can.\nlet _AssertFn: (message: string, condition: unknown) => void = function () {};\nconst AssertFn: AssertFunc = ((message: string, condition: unknown) => {\n  if (!condition) {\n    _AssertFn(message, condition);\n  }\n  assert(message, condition);\n}) as unknown as AssertFunc;\nlet NormalizedType: Normalizer = (str: string) => {\n  return singularize(dasherize(str));\n};\n\n/**\n * Configure a function to be called when an id or type\n * changes during normalization. This is useful for instrumenting\n * to discover places where usage in the app is not consistent.\n *\n * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value\n * @public\n */\nexport function configureMismatchReporter(fn: Reporter): void {\n  MismatchReporter = fn;\n}\n\n/**\n * Configure a function to be called when an id or type\n * fails validation. This is useful for instrumenting\n * to discover places where usage in the app is not consistent.\n *\n * @param fn - a function which takes a message and a condition\n * @public\n */\nexport function configureAssertFn(fn: (message: string, condition: unknown) => void): void {\n  _AssertFn = fn;\n}\n\n/**\n * Configure a function to be called to normalize\n * a resource type string. Used by both formattedType\n * and isEquivType to ensure consistent normalization\n * during comparison.\n *\n * If validation fails or the type turns out be unnormalized\n * the configured mismatch reporter and assert functions will\n * be called.\n *\n * @param fn - a function which takes a string and returns a string\n * @public\n */\nexport function configureTypeNormalization(fn: (type: string) => string): void {\n  NormalizedType = fn;\n}\n\nconst NORMALIZED_TYPES = new Map<string, string>();\n\n/**\n * Converts a potentially unnormalized type into the format expected\n * by our WarpDrive Cache. Currently this is singular-dasherized.\n *\n * you should not rely on this function to give you an exact format\n * for display purposes. Formatting for display should be handled\n * differently if the exact format matters.\n *\n * Asserts invalid types (undefined, null, '') in dev.\n *\n * **Usage**\n *\n * ```js\n * import formattedType from 'soxhub-client/helpers/formatted-type';\n *\n * formattedType('post'); // => 'post'\n * formattedType('posts'); // => 'post'\n * formattedType('Posts'); // => 'post'\n * formattedType('post-comment'); // => 'post-comment'\n * formattedType('post-comments'); // => 'post-comment'\n * formattedType('post_comment'); // => 'post-comment'\n * formattedType('postComment'); // => 'post-comment'\n * formattedType('PostComment'); // => 'post-comment'\n * ```\n *\n * @param type the potentially un-normalized type\n * @return the normalized type\n * @public\n */\nexport function formattedType<T extends string>(type: T | string): T {\n  AssertFn('formattedType: type must not be null', type !== null);\n  AssertFn('formattedType: type must not be undefined', type !== undefined);\n  AssertFn('formattedType: type must be a string', typeof type === 'string');\n  AssertFn('formattedType: type must not be empty', type.length > 0);\n  let normalized = NORMALIZED_TYPES.get(type);\n\n  if (normalized === undefined) {\n    normalized = NormalizedType(type);\n    NORMALIZED_TYPES.set(type, normalized);\n  }\n\n  if (normalized !== type) {\n    MismatchReporter('formatted-type', type, normalized);\n  }\n\n  return normalized as T;\n}\n\n/**\n * Format an id to the format expected by the WarpDrive Cache.\n * Currently this means that id should be `string | null`.\n *\n * Asserts invalid IDs (undefined, '', 0, '0') in dev.\n *\n * **Usage**\n *\n * ```js\n * import formattedId from 'client/utils/formatted-id';\n *\n * formattedId('1'); // => '1'\n * formattedId(1); // => '1'\n * formattedId(null); // => null\n *\t```\n *\n * @param id the potentially un-normalized id\n * @return the normalized id\n * @public\n */\nexport function formattedId(id: string | number): string;\nexport function formattedId(id: null): null;\nexport function formattedId(id: string | number | null): string | null;\nexport function formattedId(id: string | number | null): string | null {\n  AssertFn('formattedId: id must not be undefined', id !== undefined);\n  AssertFn(\n    'formattedId: id must be a number, string or null',\n    typeof id === 'number' || typeof id === 'string' || id === null\n  );\n  AssertFn(\n    'formattedId: id must not be empty',\n    typeof id === 'number' || id === null || (typeof id === 'string' && id.length > 0)\n  );\n  AssertFn('formattedId: id must not be 0', id !== '0' && id !== 0);\n\n  const formatted = id === null ? null : String(id);\n  if (formatted !== id) {\n    MismatchReporter('formatted-id', id, formatted);\n  }\n  return id === null ? null : String(id);\n}\n\n/**\n * Like {@link formattedId}, but asserts that `id` is not `null` rather\n * than allowing and passing through `null`.\n *\n * @public\n */\nexport function expectId(id: string | number): string;\n/**\n * Throws, since `id` is `null`.\n *\n * @public\n */\nexport function expectId(id: null): never;\nexport function expectId(id: string | number | null): string {\n  AssertFn('expectId: id must not be null', id !== null);\n\n  return formattedId(id);\n}\n\n/**\n * Compares two types for strict equality, converting them to\n * the format expected by the WarpDrive Cache to ensure\n * differences in format are accounted for in the comparison.\n *\n * Asserts when expected or actual are invalid types in dev.\n * Expected may never be null.\n *\n * ```js\n * isEquivType('posts', 'post'); // true\n * isEquivType('post', 'post'); // true\n * isEquivType('posts', 'posts'); // true\n * isEquivType('post-comment', 'postComment'); // true\n * isEquivType('post-comment', 'PostComment'); // true\n * isEquivType('post-comment', 'post_comment'); // true\n * isEquivType('post-comment', 'post-comment'); // true\n * isEquivType('post-comment', 'post'); // false\n * isEquivType('posts', null); // false\n * ```\n *\n * @param expected a potentially unnormalized type to match against\n * @param actual a potentially unnormalized type to match against\n * @return true if the types are equivalent\n * @public\n */\nexport function isEquivType(expected: string, actual: string): boolean {\n  AssertFn('isEquivType: Expected type must not be null', expected !== null);\n  AssertFn('isEquivType: Expected type must not be undefined', expected !== undefined);\n  AssertFn('isEquivType: Expected type must be a string', typeof expected === 'string');\n  AssertFn('isEquivType: Expected type must not be empty', expected.length > 0);\n\n  AssertFn('isEquivType: Actual type must not be null', actual !== null);\n  AssertFn('isEquivType: Actual type must not be undefined', actual !== undefined);\n  AssertFn('isEquivType: Actual type must be a string', typeof actual === 'string');\n  AssertFn('isEquivType: Actual type must not be empty', actual.length > 0);\n\n  return expected === actual || formattedType(expected) === formattedType(actual);\n}\n\n/**\n * Compares two IDs for strict equality, converting them to\n * the format expected by the WarpDrive Cache to ensure\n * differences in format are accounted for in the comparison.\n *\n * Asserts when expected or actual are invalid IDs in dev.\n * Expected may never be null.\n *\n * ```js\n * isEquivId('1', 1); // true\n * isEquivId('2', '2'); // true\n * isEquivId(3, '3'); // true\n * isEquivId(4, '3'); // false\n * isEquivId(1, null); // false\n * ```\n *\n * @param expected a potentially un-normalized id to match against\n * @param actual a potentially un-normalized id to match against\n * @return true if the ids are equivalent\n * @public\n */\nexport function isEquivId(expected: string | number, actual: string | number | null): boolean {\n  AssertFn('isEquivId: Expected id must not be null', expected !== null);\n  AssertFn('isEquivId: Expected id must not be undefined', expected !== undefined);\n  AssertFn(\n    'isEquivId: Expected id must be a number or string',\n    typeof expected === 'number' || typeof expected === 'string'\n  );\n  AssertFn(\n    'isEquivId: Expected id must not be empty',\n    typeof expected === 'number' || (typeof expected === 'string' && expected.length > 0)\n  );\n  AssertFn('isEquivId: Expected id must not be 0', expected !== '0' && expected !== 0);\n\n  AssertFn('isEquivId: Actual id must not be undefined', actual !== undefined);\n  AssertFn(\n    'isEquivId: Actual id must be a number, string or null',\n    typeof actual === 'number' || typeof actual === 'string' || actual === null\n  );\n  AssertFn(\n    'isEquivId: Actual id must not be empty',\n    actual === null || typeof actual === 'number' || (typeof actual === 'string' && actual.length > 0)\n  );\n  AssertFn('isEquivId: Actual id must not be 0', actual !== '0' && actual !== 0);\n\n  return expected === actual || formattedId(expected) === formattedId(actual);\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.js","names":["dasherize","singularize","macroCondition","getGlobalConfig","MismatchReporter","_AssertFn","AssertFn","message","condition","WarpDrive","env","DEBUG","test","Error","NormalizedType","str","configureMismatchReporter","fn","configureAssertFn","configureTypeNormalization","NORMALIZED_TYPES","Map","formattedType","type","undefined","length","normalized","get","set","formattedId","id","formatted","String","expectId","isEquivType","expected","actual","isEquivId"],"sources":["../../src/compat/utils.ts"],"sourcesContent":["/**\n  Utilities for helping to migrate to stricter\n  and more consistent use of IDs and types.\n\n  @summary Legacy helpers that normalize, compare, and report mismatched resource ids and types while migrating to\n  stricter formats.\n  @module\n*/\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport { dasherize, singularize } from '@warp-drive/utilities/string';\n\ninterface AssertFunc {\n  (desc: string, condition: unknown): asserts condition;\n  (desc: string): never;\n}\n\ntype Reporter = (type: 'formatted-id' | 'formatted-type', actual: unknown, expected: unknown) => void;\ntype Normalizer = (type: string) => string;\n\nlet MismatchReporter: Reporter = function () {};\n\n// TODO: @runspired This pattern prevents AssertFn from being removed in production builds\n// but we should enable that if we can.\nlet _AssertFn: (message: string, condition: unknown) => void = function () {};\nconst AssertFn: AssertFunc = ((message: string, condition: unknown) => {\n  if (!condition) {\n    _AssertFn(message, condition);\n  }\n  assert(message, condition);\n}) as unknown as AssertFunc;\nlet NormalizedType: Normalizer = (str: string) => {\n  return singularize(dasherize(str));\n};\n\n/**\n * Configure a function to be called when an id or type\n * changes during normalization. This is useful for instrumenting\n * to discover places where usage in the app is not consistent.\n *\n * @summary Legacy migration helper that registers a callback invoked whenever `formattedId` or `formattedType`\n * has to change the id or type it was given.\n * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value\n * @public\n */\nexport function configureMismatchReporter(fn: Reporter): void {\n  MismatchReporter = fn;\n}\n\n/**\n * Configure a function to be called when an id or type\n * fails validation. This is useful for instrumenting\n * to discover places where usage in the app is not consistent.\n *\n * @summary Legacy migration helper that registers a callback invoked when an id or type passed to these utilities\n * fails validation.\n * @param fn - a function which takes a message and a condition\n * @public\n */\nexport function configureAssertFn(fn: (message: string, condition: unknown) => void): void {\n  _AssertFn = fn;\n}\n\n/**\n * Configure a function to be called to normalize\n * a resource type string. Used by both formattedType\n * and isEquivType to ensure consistent normalization\n * during comparison.\n *\n * If validation fails or the type turns out be unnormalized\n * the configured mismatch reporter and assert functions will\n * be called.\n *\n * @summary Legacy migration helper that replaces the singularize-and-dasherize function `formattedType` and\n * `isEquivType` use to normalize resource types.\n * @param fn - a function which takes a string and returns a string\n * @public\n */\nexport function configureTypeNormalization(fn: (type: string) => string): void {\n  NormalizedType = fn;\n}\n\nconst NORMALIZED_TYPES = new Map<string, string>();\n\n/**\n * Converts a potentially unnormalized type into the format expected\n * by our WarpDrive Cache. Currently this is singular-dasherized.\n *\n * you should not rely on this function to give you an exact format\n * for display purposes. Formatting for display should be handled\n * differently if the exact format matters.\n *\n * Asserts invalid types (undefined, null, '') in dev.\n *\n * **Usage**\n *\n * ```js\n * import formattedType from 'soxhub-client/helpers/formatted-type';\n *\n * formattedType('post'); // => 'post'\n * formattedType('posts'); // => 'post'\n * formattedType('Posts'); // => 'post'\n * formattedType('post-comment'); // => 'post-comment'\n * formattedType('post-comments'); // => 'post-comment'\n * formattedType('post_comment'); // => 'post-comment'\n * formattedType('postComment'); // => 'post-comment'\n * formattedType('PostComment'); // => 'post-comment'\n * ```\n *\n * @summary Legacy migration helper that normalizes a resource type to the singular dasherized form the cache\n * expects, such as `'PostComments'` to `'post-comment'`.\n * @param type the potentially un-normalized type\n * @return the normalized type\n * @public\n */\nexport function formattedType<T extends string>(type: T | string): T {\n  AssertFn('formattedType: type must not be null', type !== null);\n  AssertFn('formattedType: type must not be undefined', type !== undefined);\n  AssertFn('formattedType: type must be a string', typeof type === 'string');\n  AssertFn('formattedType: type must not be empty', type.length > 0);\n  let normalized = NORMALIZED_TYPES.get(type);\n\n  if (normalized === undefined) {\n    normalized = NormalizedType(type);\n    NORMALIZED_TYPES.set(type, normalized);\n  }\n\n  if (normalized !== type) {\n    MismatchReporter('formatted-type', type, normalized);\n  }\n\n  return normalized as T;\n}\n\n/**\n * Format an id to the format expected by the WarpDrive Cache.\n * Currently this means that id should be `string | null`.\n *\n * Asserts invalid IDs (undefined, '', 0, '0') in dev.\n *\n * **Usage**\n *\n * ```js\n * import formattedId from 'client/utils/formatted-id';\n *\n * formattedId('1'); // => '1'\n * formattedId(1); // => '1'\n * formattedId(null); // => null\n *\t```\n *\n * @summary Legacy migration helper that normalizes a resource id to the `string` or `null` the cache expects,\n * asserting on invalid ids such as `''` or `0`.\n * @param id the potentially un-normalized id\n * @return the normalized id\n * @public\n */\nexport function formattedId(id: string | number): string;\nexport function formattedId(id: null): null;\nexport function formattedId(id: string | number | null): string | null;\nexport function formattedId(id: string | number | null): string | null {\n  AssertFn('formattedId: id must not be undefined', id !== undefined);\n  AssertFn(\n    'formattedId: id must be a number, string or null',\n    typeof id === 'number' || typeof id === 'string' || id === null\n  );\n  AssertFn(\n    'formattedId: id must not be empty',\n    typeof id === 'number' || id === null || (typeof id === 'string' && id.length > 0)\n  );\n  AssertFn('formattedId: id must not be 0', id !== '0' && id !== 0);\n\n  const formatted = id === null ? null : String(id);\n  if (formatted !== id) {\n    MismatchReporter('formatted-id', id, formatted);\n  }\n  return id === null ? null : String(id);\n}\n\n/**\n * Like {@link formattedId}, but asserts that `id` is not `null` rather\n * than allowing and passing through `null`.\n *\n * @summary Legacy migration helper that normalizes a resource id to a string like `formattedId`, but asserts that\n * it is not `null`.\n * @public\n */\nexport function expectId(id: string | number): string;\n/**\n * Throws, since `id` is `null`.\n *\n * @public\n */\nexport function expectId(id: null): never;\nexport function expectId(id: string | number | null): string {\n  AssertFn('expectId: id must not be null', id !== null);\n\n  return formattedId(id);\n}\n\n/**\n * Compares two types for strict equality, converting them to\n * the format expected by the WarpDrive Cache to ensure\n * differences in format are accounted for in the comparison.\n *\n * Asserts when expected or actual are invalid types in dev.\n * Expected may never be null.\n *\n * ```js\n * isEquivType('posts', 'post'); // true\n * isEquivType('post', 'post'); // true\n * isEquivType('posts', 'posts'); // true\n * isEquivType('post-comment', 'postComment'); // true\n * isEquivType('post-comment', 'PostComment'); // true\n * isEquivType('post-comment', 'post_comment'); // true\n * isEquivType('post-comment', 'post-comment'); // true\n * isEquivType('post-comment', 'post'); // false\n * isEquivType('posts', null); // false\n * ```\n *\n * @summary Legacy migration helper that reports whether two resource types match after normalization, so\n * `'posts'` and `'post'` are equivalent.\n * @param expected a potentially unnormalized type to match against\n * @param actual a potentially unnormalized type to match against\n * @return true if the types are equivalent\n * @public\n */\nexport function isEquivType(expected: string, actual: string): boolean {\n  AssertFn('isEquivType: Expected type must not be null', expected !== null);\n  AssertFn('isEquivType: Expected type must not be undefined', expected !== undefined);\n  AssertFn('isEquivType: Expected type must be a string', typeof expected === 'string');\n  AssertFn('isEquivType: Expected type must not be empty', expected.length > 0);\n\n  AssertFn('isEquivType: Actual type must not be null', actual !== null);\n  AssertFn('isEquivType: Actual type must not be undefined', actual !== undefined);\n  AssertFn('isEquivType: Actual type must be a string', typeof actual === 'string');\n  AssertFn('isEquivType: Actual type must not be empty', actual.length > 0);\n\n  return expected === actual || formattedType(expected) === formattedType(actual);\n}\n\n/**\n * Compares two IDs for strict equality, converting them to\n * the format expected by the WarpDrive Cache to ensure\n * differences in format are accounted for in the comparison.\n *\n * Asserts when expected or actual are invalid IDs in dev.\n * Expected may never be null.\n *\n * ```js\n * isEquivId('1', 1); // true\n * isEquivId('2', '2'); // true\n * isEquivId(3, '3'); // true\n * isEquivId(4, '3'); // false\n * isEquivId(1, null); // false\n * ```\n *\n * @summary Legacy migration helper that reports whether two resource ids match after normalization, so `1` and\n * `'1'` are equivalent.\n * @param expected a potentially un-normalized id to match against\n * @param actual a potentially un-normalized id to match against\n * @return true if the ids are equivalent\n * @public\n */\nexport function isEquivId(expected: string | number, actual: string | number | null): boolean {\n  AssertFn('isEquivId: Expected id must not be null', expected !== null);\n  AssertFn('isEquivId: Expected id must not be undefined', expected !== undefined);\n  AssertFn(\n    'isEquivId: Expected id must be a number or string',\n    typeof expected === 'number' || typeof expected === 'string'\n  );\n  AssertFn(\n    'isEquivId: Expected id must not be empty',\n    typeof expected === 'number' || (typeof expected === 'string' && expected.length > 0)\n  );\n  AssertFn('isEquivId: Expected id must not be 0', expected !== '0' && expected !== 0);\n\n  AssertFn('isEquivId: Actual id must not be undefined', actual !== undefined);\n  AssertFn(\n    'isEquivId: Actual id must be a number, string or null',\n    typeof actual === 'number' || typeof actual === 'string' || actual === null\n  );\n  AssertFn(\n    'isEquivId: Actual id must not be empty',\n    actual === null || typeof actual === 'number' || (typeof actual === 'string' && actual.length > 0)\n  );\n  AssertFn('isEquivId: Actual id must not be 0', actual !== '0' && actual !== 0);\n\n  return expected === actual || formattedId(expected) === formattedId(actual);\n}\n"],"mappings":"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"}

package/dist/{compat-DcHVxuuZ.js → compat-C-yQnbkF.js}

@@ -1,11 +1,11 @@
-import { a as normalizeResponseHelper, c as assertIdentifierHasId, l as SnapshotRecordArray, n as FetchManager, o as iterateData, r as SaveOp, s as payloadIsNotBlank, t as upgradeStore } from "./-private-DccRZQsm.js";
+import { a as normalizeResponseHelper, c as assertIdentifierHasId, l as SnapshotRecordArray, n as FetchManager, o as iterateData, r as SaveOp, s as payloadIsNotBlank, t as upgradeStore } from "./-private-0_Oc-M3x.js";
 import { recordIdentifierFor } from "@warp-drive/core";
 import { getOwner } from "@ember/application";
 import { _deprecatingNormalize, assertPrivateStore } from "@warp-drive/core/store/-private";
 import { waitFor } from "@warp-drive/core/signals/-leaked";
 import { getGlobalConfig, macroCondition } from "@embroider/macros";
 
-//#region src/compat/legacy-network-handler/legacy-data-fetch.ts
+// src/compat/legacy-network-handler/legacy-data-fetch.ts
 function _findHasMany(adapter, store, identifier, link, relationship, options) {
 	/* @__PURE__ */ upgradeStore(store);
 	return Promise.resolve().then(() => {
@@ -192,8 +192,7 @@ function validateRelationshipEntry({ id }, { id: parentModelID }) {
 	return !!id && id.toString() === parentModelID;
 }
 
-//#endregion
-//#region src/compat/legacy-network-handler/legacy-network-handler.ts
+// src/compat/legacy-network-handler/legacy-network-handler.ts
 const PotentialLegacyOperations = /* @__PURE__ */ new Set([
 	"findRecord",
 	"findAll",
@@ -211,6 +210,9 @@ const PotentialLegacyOperations = /* @__PURE__ */ new Set([
 * `deleteRecord` requests using the store's configured {@link MinimumAdapterInterface | adapter}
 * and {@link MinimumSerializerInterface | serializer}, passing any other
 * request through to the next handler unchanged.
+*
+* @summary Legacy `RequestManager` handler that fulfills find, query, create, update, and delete operations through
+* the store's adapters and serializers, passing other requests along.
 */
 const LegacyNetworkHandler = { request(context, next) {
 	if (context.request.url || !context.request.op || !PotentialLegacyOperations.has(context.request.op)) return next(context.request);
@@ -491,17 +493,57 @@ function queryRecord(context) {
 	});
 }
 
-//#endregion
-//#region src/compat.ts
+// src/compat.ts
+/**
+* Helps an app migrate incrementally from legacy EmberData patterns to modern ***Warp*Drive**.
+*
+* ## Why it exists
+*
+* While migrating, you may need to:
+*
+* - keep Adapters and Serializers working on a Store whose requests go through the
+*   {@link RequestManager}
+* - keep the deprecated request methods such as `store.findRecord` and `store.query`, which
+*   Adapters fulfill, working while you move calls to `store.request`
+* - adopt modern patterns one piece at a time rather than all at once
+*
+* ## What it provides
+*
+* - {@link LegacyNetworkHandler}, a request handler that fulfills those legacy requests through
+*   the store's Adapters and Serializers and passes every other request along
+* - {@link adapterFor}, {@link serializerFor}, {@link normalize}, {@link pushPayload} and
+*   {@link serializeRecord}, the store methods for working with Adapters and Serializers, and
+*   {@link LegacyStoreCompat}, the Store type that includes them
+*
+* The Store that [useLegacyStore](/api/@warp-drive/legacy/functions/useLegacyStore) produces
+* adds `LegacyNetworkHandler` to its RequestManager unless `linksMode` is `true`. The hooks
+* that present `Model` instances live in [@warp-drive/legacy/model](/api/@warp-drive/legacy/model/),
+* not here.
+*
+* ## When to use it
+*
+* Only during a migration from legacy EmberData to modern ***Warp*Drive**. It lets you adopt
+* modern patterns incrementally while your existing Adapters and Serializers keep working. For
+* incremental migration strategies, see the [Migration Guide](/upgrading/v5/) and the
+* [Two Store Migration Strategy](/upgrading/v5/two-store-migration).
+*
+* @module
+* @summary Legacy store support for adapters and serializers: the `LegacyNetworkHandler` plus store methods such as
+* `adapterFor`, `serializerFor`, `normalize` and `pushPayload`.
+*/
 /**
 * Extends the signature of {@link Store} with additional
 * methods available when using the legacy network layer.
 *
+* @summary Legacy `Store` type extended with `adapterFor`, `serializerFor`, `normalize`, `pushPayload`, and
+* `serializeRecord` from the adapter and serializer network layer.
 * @public
 * @noInheritDoc
 * @legacy
 */
 /**
+* @summary Deprecated alias of `LegacyStoreCompat`, the `Store` type extended with legacy adapter and serializer
+* methods.
 * @deprecated - use {@link LegacyStoreCompat} instead
 */
 /**
@@ -513,6 +555,8 @@ If no `person` adapter is found, this method will look
 for an `application` adapter (the default adapter for
 your entire application).
 
+@summary Legacy store method that returns the cached adapter for a model type, falling back to the `application`
+adapter.
 @public
 @param modelName
 */
@@ -560,6 +604,8 @@ your entire application).
 If a serializer cannot be found on the adapter, it will fall back
 to an instance of `JSONSerializer`.
 
+@summary Legacy store method that returns the cached serializer for a model type, falling back to the
+`application` serializer, or `null` if neither exists.
 @public
 @param modelName the record to serialize
 */
@@ -612,6 +658,8 @@ store.push(store.normalize(modelName, data));
 });
 ```
 
+@summary Legacy store method that converts a raw payload into the normalized document `store.push` expects, using
+the serializer for the given model type.
 @legacy
 @public
 @param modelName The name of the model type for this payload
@@ -687,6 +735,8 @@ store.pushPayload(pushData); // Will use the application serializer
 store.pushPayload('post', pushData); // Will use the post serializer
 ```
 
+@summary Legacy store method that pushes a raw payload into the store after the application serializer, or the
+given model type's serializer, normalizes it.
 @public
 @param modelName Optionally, a model type used to determine which serializer will be used
 @param inputPayload
@@ -707,6 +757,8 @@ function pushPayload(modelName, inputPayload) {
 /**
 * Serializes a record using the store's legacy network layer, as with
 * {@link LegacyStoreCompat.serializeRecord | store.serializeRecord}.
+*
+* @summary Legacy store method that serializes a record into a payload using its model type's serializer.
 */
 function serializeRecord(record, options) {
 	/* @__PURE__ */ upgradeStore(this);
@@ -716,6 +768,8 @@ function serializeRecord(record, options) {
 /**
 * Destroys any adapters/serializers the legacy network layer has created
 * for this store, invoked when the store itself is destroyed.
+*
+* @summary Legacy store teardown hook that destroys every adapter and serializer instance the store has cached.
 */
 function cleanup() {
 	/* @__PURE__ */ upgradeStore(this);
@@ -729,6 +783,5 @@ function cleanup() {
 	}
 }
 
-//#endregion
 export { serializeRecord as a, pushPayload as i, cleanup as n, serializerFor as o, normalize as r, LegacyNetworkHandler as s, adapterFor as t };
-//# sourceMappingURL=compat-DcHVxuuZ.js.map
+//# sourceMappingURL=compat-C-yQnbkF.js.map

package/dist/compat-C-yQnbkF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat-C-yQnbkF.js","names":["upgradeStore","iterateData","payloadIsNotBlank","normalizeResponseHelper","getGlobalConfig","macroCondition","_findHasMany","adapter","store","identifier","link","relationship","options","promise","Promise","resolve","then","snapshot","_fetchManager","createSnapshot","useLink","relatedLink","href","WarpDrive","env","DEBUG","test","Error","findHasMany","adapterPayload","type","name","JSON","stringify","modelClass","modelFor","serializer","serializerFor","payload","id","Array","isArray","data","syncRelationshipDataFromLink","_push","_findBelongsTo","adapterFor","findBelongsTo","links","meta","parentIdentifier","relationshipData","index","ensureRelationshipIsSetToParent","relatedDataHash","parentPayload","relationships","included","push","parentRelationship","inverse","getInverse","inverseKey","kind","relationshipDataPointsToParent","inspect","thing","quotedType","quotedInverse","expected","expectedModel","got","prefix","path","other","relationshipFetched","includedRecord","message","join","fixRelationshipData","inverseForRelationship","key","definition","schema","fields","get","length","lhs_relationshipName","parentType","i","entry","validateRelationshipEntry","relationshipKind","parentRelationshipData","relData","found","find","v","Object","assign","parentModelID","toString","waitFor","assertPrivateStore","upgradeStore","FetchManager","SaveOp","assertIdentifierHasId","_findBelongsTo","_findHasMany","payloadIsNotBlank","normalizeResponseHelper","SnapshotRecordArray","getGlobalConfig","macroCondition","PotentialLegacyOperations","Set","LegacyNetworkHandler","request","context","next","url","op","has","store","_fetchManager","findRecord","findAll","query","queryRecord","findBelongsTo","findHasMany","saveRecord","data","records","identifiers","options","record","links","useLink","field","identifier","pendingRequest","getPendingFetch","WarpDrive","env","DEBUG","test","Error","String","related","Array","isArray","length","manager","reload","scheduleFetch","fetchDataIfNeededForIdentifier","adapter","adapterFor","type","fetches","i","Promise","all","operation","cache","willCommit","saveOptions","Object","assign","fetchManagerPromise","scheduleSave","then","payload","result","_join","didCommit","content","lifetimes","didRequest","status","peekRecord","catch","e","err","adapterDidInvalidate","error","isAdapterError","code","serializer","serializerFor","extractErrors","errorsHash","modelFor","id","errors","errorsHashToArray","getErrors","jsonApiErrors","title","detail","source","pointer","commitWasRejected","makeArray","value","PRIMARY_ATTRIBUTE_KEY","out","keys","forEach","key","messages","push","promise","_instanceCache","recordIsLoaded","snapshot","shouldReloadRecord","createSnapshot","backgroundReload","shouldBackgroundReloadRecord","resolve","maybeRecordArray","recordArrayManager","_live","get","snapshotArray","shouldReload","shouldReloadAll","fetch","isUpdating","_findAll","peekAll","shouldBackgroundReloadAll","isAsyncFlush","schema","adapterPayload","_push","_recordArray","activeLogging","LOG_REQUESTS","debug","globalThis","getWarpDriveRuntimeConfig","console","log","TESTING","disableTestWaiter","recordArray","getCollection","populateManagedArray","assertSingleResourceDocument","getOwner","recordIdentifierFor","_deprecatingNormalize","FetchManager","upgradeStore","macroCondition","getGlobalConfig","LegacyNetworkHandler","adapterFor","modelName","_allowMissing","WarpDrive","env","DEBUG","test","Error","isDestroying","isDestroyed","_adapterCache","Object","create","normalizedModelName","adapter","owner","lookup","undefined","application","serializerFor","_serializerCache","serializer","normalize","payload","schema","modelFor","pushPayload","inputPayload","serializeRecord","record","options","_fetchManager","createSnapshot","serialize","cleanup","adapterName","destroy","serializerName"],"sources":["../src/compat/legacy-network-handler/legacy-data-fetch.ts","../src/compat/legacy-network-handler/legacy-network-handler.ts","../src/compat.ts"],"sourcesContent":["import type { Store } from '@warp-drive/core';\nimport { DEBUG } from '@warp-drive/core/build-config/env';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { BaseFinderOptions } from '@warp-drive/core/types';\nimport type { PersistedResourceKey, ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { LegacyRelationshipField as RelationshipSchema } from '@warp-drive/core/types/schema/fields';\nimport type { ExistingResourceObject, JsonApiDocument } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { upgradeStore } from '../-private.ts';\nimport { iterateData, payloadIsNotBlank } from './legacy-data-utils.ts';\nimport type { MinimumAdapterInterface } from './minimum-adapter-interface.ts';\nimport { normalizeResponseHelper } from './serializer-response.ts';\n\nexport function _findHasMany(\n  adapter: MinimumAdapterInterface,\n  store: Store,\n  identifier: ResourceKey,\n  link: string | null | { href: string },\n  relationship: RelationshipSchema,\n  options: BaseFinderOptions\n): Promise<PersistedResourceKey[]> {\n  upgradeStore(store);\n  const promise = Promise.resolve().then(() => {\n    const snapshot = store._fetchManager.createSnapshot(identifier, options);\n    const useLink = !link || typeof link === 'string';\n    const relatedLink = useLink ? link : link.href;\n    assert(\n      `Attempted to load a hasMany relationship from a specified 'link' in the original payload, but the specified link is empty. You must provide a valid 'link' in the original payload to use 'findHasMany'`,\n      relatedLink\n    );\n    assert(\n      `Expected the adapter to implement 'findHasMany' but it does not`,\n      typeof adapter.findHasMany === 'function'\n    );\n    return adapter.findHasMany(store, snapshot, relatedLink, relationship);\n  });\n\n  return promise.then((adapterPayload) => {\n    assert(\n      `You made a 'findHasMany' request for a ${identifier.type}'s '${\n        relationship.name\n      }' relationship, using link '${JSON.stringify(link)}' , but the adapter's response did not have any data`,\n      payloadIsNotBlank(adapterPayload)\n    );\n    const modelClass = store.modelFor(relationship.type);\n\n    const serializer = store.serializerFor(relationship.type);\n    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findHasMany');\n\n    assert(\n      `fetched the hasMany relationship '${relationship.name}' for ${identifier.type}:${\n        identifier.id\n      } with link '${JSON.stringify(\n        link\n      )}', but no data member is present in the response. If no data exists, the response should set { data: [] }`,\n      'data' in payload && Array.isArray(payload.data)\n    );\n\n    payload = syncRelationshipDataFromLink(store, payload, identifier as ResourceIdentity, relationship);\n    return store._push(payload, true) as PersistedResourceKey[];\n  }, null);\n}\n\nexport function _findBelongsTo(\n  store: Store,\n  identifier: ResourceKey,\n  link: string | null | { href: string },\n  relationship: RelationshipSchema,\n  options: BaseFinderOptions\n): Promise<PersistedResourceKey | null> {\n  upgradeStore(store);\n  const promise = Promise.resolve().then(() => {\n    const adapter = store.adapterFor(identifier.type);\n    assert(`You tried to load a belongsTo relationship but you have no adapter (for ${identifier.type})`, adapter);\n    assert(\n      `You tried to load a belongsTo relationship from a specified 'link' in the original payload but your adapter does not implement 'findBelongsTo'`,\n      typeof adapter.findBelongsTo === 'function'\n    );\n    const snapshot = store._fetchManager.createSnapshot(identifier, options);\n    const useLink = !link || typeof link === 'string';\n    const relatedLink = useLink ? link : link.href;\n    assert(\n      `Attempted to load a belongsTo relationship from a specified 'link' in the original payload, but the specified link is empty. You must provide a valid 'link' in the original payload to use 'findBelongsTo'`,\n      relatedLink\n    );\n    return adapter.findBelongsTo(store, snapshot, relatedLink, relationship);\n  });\n\n  return promise.then((adapterPayload) => {\n    const modelClass = store.modelFor(relationship.type);\n    const serializer = store.serializerFor(relationship.type);\n    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findBelongsTo');\n\n    assert(\n      `fetched the belongsTo relationship '${relationship.name}' for ${identifier.type}:${\n        identifier.id\n      } with link '${JSON.stringify(\n        link\n      )}', but no data member is present in the response. If no data exists, the response should set { data: null }`,\n      'data' in payload && (payload.data === null || (typeof payload.data === 'object' && !Array.isArray(payload.data)))\n    );\n\n    if (!payload.data && !payload.links && !payload.meta) {\n      return null;\n    }\n\n    payload = syncRelationshipDataFromLink(store, payload, identifier as ResourceIdentity, relationship);\n\n    return store._push(payload, true) as PersistedResourceKey | null;\n  }, null);\n}\n\n// sync\n// iterate over records in payload.data\n// for each record\n//   assert that record.relationships[inverse] is either undefined (so we can fix it)\n//     or provide a data: {id, type} that matches the record that requested it\n//   return the relationship data for the parent\nfunction syncRelationshipDataFromLink(\n  store: Store,\n  payload: JsonApiDocument,\n  parentIdentifier: ResourceIdentity,\n  relationship: RelationshipSchema\n) {\n  // ensure the right hand side (incoming payload) points to the parent record that\n  // requested this relationship\n  const relationshipData = payload.data\n    ? iterateData(payload.data, (data, index) => {\n        const { id, type } = data;\n        ensureRelationshipIsSetToParent(data, parentIdentifier, store, relationship, index);\n        return { id, type };\n      })\n    : null;\n\n  const relatedDataHash = {} as JsonApiDocument;\n\n  if ('meta' in payload) {\n    relatedDataHash.meta = payload.meta;\n  }\n  if ('links' in payload) {\n    relatedDataHash.links = payload.links;\n  }\n  if ('data' in payload) {\n    relatedDataHash.data = relationshipData;\n  }\n\n  // now, push the left hand side (the parent record) to ensure things are in sync, since\n  // the payload will be pushed with store._push\n  const parentPayload = {\n    id: parentIdentifier.id,\n    type: parentIdentifier.type,\n    relationships: {\n      [relationship.name]: relatedDataHash,\n    },\n  };\n\n  if (!Array.isArray(payload.included)) {\n    payload.included = [];\n  }\n  payload.included.push(parentPayload);\n\n  return payload;\n}\n\ntype ResourceIdentity = { id: string; type: string };\ntype RelationshipData = ResourceIdentity | ResourceIdentity[] | null;\n\nfunction ensureRelationshipIsSetToParent(\n  payload: ExistingResourceObject,\n  parentIdentifier: ResourceIdentity,\n  store: Store,\n  parentRelationship: RelationshipSchema,\n  index: number\n) {\n  const { id, type } = payload;\n\n  if (!payload.relationships) {\n    payload.relationships = {};\n  }\n  const { relationships } = payload;\n\n  const inverse = getInverse(store, parentIdentifier, parentRelationship, type);\n  if (inverse) {\n    const { inverseKey, kind } = inverse;\n\n    const relationshipData = relationships[inverseKey]?.data;\n\n    if (DEBUG) {\n      if (\n        typeof relationshipData !== 'undefined' &&\n        !relationshipDataPointsToParent(relationshipData, parentIdentifier)\n      ) {\n        const inspect = function inspect(thing: unknown) {\n          return `'${JSON.stringify(thing)}'`;\n        };\n        const quotedType = inspect(type);\n        const quotedInverse = inspect(inverseKey);\n        const expected = inspect({\n          id: parentIdentifier.id,\n          type: parentIdentifier.type,\n        });\n        const expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;\n        const got = inspect(relationshipData);\n        const prefix = typeof index === 'number' ? `data[${index}]` : `data`;\n        const path = `${prefix}.relationships.${inverseKey}.data`;\n        const data = Array.isArray(relationshipData) ? relationshipData[0] : relationshipData;\n        const other = data ? `<${data.type}:${data.id}>` : null;\n        const relationshipFetched = `${expectedModel}.${parentRelationship.kind}(\"${parentRelationship.name}\")`;\n        const includedRecord = `<${type}:${id}>`;\n        const message = [\n          `Encountered mismatched relationship: WarpDrive expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\\n`,\n          `The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`,\n          `This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentIdentifier.type} record instead.`,\n          `WarpDrive has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`,\n          `Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`,\n        ].join('\\n');\n\n        assert(message);\n      }\n    }\n\n    if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {\n      relationships[inverseKey] = relationships[inverseKey] || {};\n      relationships[inverseKey].data = fixRelationshipData(relationshipData ?? null, kind, parentIdentifier);\n    }\n  }\n}\n\nfunction inverseForRelationship(store: Store, identifier: { type: string; id?: string }, key: string) {\n  const definition = store.schema.fields(identifier).get(key);\n  if (!definition) {\n    return null;\n  }\n  assert(\n    `Expected the field definition to be a relationship`,\n    definition.kind === 'hasMany' || definition.kind === 'belongsTo'\n  );\n  assert(\n    `Expected the relationship defintion to specify the inverse type or null.`,\n    definition.options?.inverse === null ||\n      (typeof definition.options?.inverse === 'string' && definition.options.inverse.length > 0)\n  );\n  return definition.options.inverse;\n}\n\nfunction getInverse(\n  store: Store,\n  parentIdentifier: ResourceIdentity,\n  parentRelationship: RelationshipSchema,\n  type: string\n) {\n  const { name: lhs_relationshipName } = parentRelationship;\n  const { type: parentType } = parentIdentifier;\n  const inverseKey = inverseForRelationship(store, { type: parentType }, lhs_relationshipName);\n\n  if (inverseKey) {\n    const definition = store.schema.fields({ type }).get(inverseKey);\n    assert(\n      `Expected the field definition to be a relationship`,\n      definition && (definition.kind === 'hasMany' || definition.kind === 'belongsTo')\n    );\n    return {\n      inverseKey,\n      kind: definition.kind,\n    };\n  }\n}\n\nfunction relationshipDataPointsToParent(relationshipData: RelationshipData, identifier: ResourceIdentity): boolean {\n  if (relationshipData === null) {\n    return false;\n  }\n\n  if (Array.isArray(relationshipData)) {\n    if (relationshipData.length === 0) {\n      return false;\n    }\n    for (let i = 0; i < relationshipData.length; i++) {\n      const entry = relationshipData[i];\n      if (validateRelationshipEntry(entry, identifier)) {\n        return true;\n      }\n    }\n  } else {\n    return validateRelationshipEntry(relationshipData, identifier);\n  }\n\n  return false;\n}\n\nfunction fixRelationshipData(\n  relationshipData: RelationshipData,\n  relationshipKind: 'hasMany' | 'belongsTo',\n  { id, type }: ResourceIdentity\n) {\n  const parentRelationshipData = {\n    id,\n    type,\n  };\n\n  let payload: { type: string; id: string } | { type: string; id: string }[];\n\n  if (relationshipKind === 'hasMany') {\n    const relData = (relationshipData as { type: string; id: string }[]) || [];\n    if (relationshipData) {\n      assert('expected the relationship data to be an array', Array.isArray(relationshipData));\n      // these arrays could be massive so this is better than filter\n      // Note: this is potentially problematic if type/id are not in the\n      // same state of normalization.\n      const found = relationshipData.find((v) => {\n        return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;\n      });\n      if (!found) {\n        relData.push(parentRelationshipData);\n      }\n    } else {\n      relData.push(parentRelationshipData);\n    }\n    payload = relData;\n  } else {\n    const relData = (relationshipData as { type: string; id: string }) || {};\n    Object.assign(relData, parentRelationshipData);\n    payload = relData;\n  }\n\n  return payload;\n}\n\nfunction validateRelationshipEntry({ id }: ResourceIdentity, { id: parentModelID }: ResourceIdentity): boolean {\n  return !!id && id.toString() === parentModelID;\n}\n","import type { Store, StoreRequestContext } from '@warp-drive/core';\nimport { LOG_REQUESTS } from '@warp-drive/core/build-config/debugging';\nimport { DEBUG, TESTING } from '@warp-drive/core/build-config/env';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { Future, Handler, NextFn } from '@warp-drive/core/request';\nimport { waitFor } from '@warp-drive/core/signals/-leaked';\nimport { assertPrivateStore, type LegacyQueryArray } from '@warp-drive/core/store/-private';\nimport type { ModelSchema } from '@warp-drive/core/types';\nimport type { PersistedResourceKey, ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { ImmutableRequestInfo, StructuredDataDocument } from '@warp-drive/core/types/request';\nimport type { LegacyRelationshipField as RelationshipSchema } from '@warp-drive/core/types/schema/fields';\nimport type { SingleResourceDataDocument } from '@warp-drive/core/types/spec/document';\nimport type { ApiError } from '@warp-drive/core/types/spec/error';\nimport type {\n  CollectionResourceDocument,\n  JsonApiDocument,\n  Links,\n  PaginationLinks,\n  SingleResourceDocument,\n} from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { upgradeStore } from '../-private.ts';\nimport { FetchManager, SaveOp } from './fetch-manager.ts';\nimport { assertIdentifierHasId } from './identifier-has-id.ts';\nimport { _findBelongsTo, _findHasMany } from './legacy-data-fetch.ts';\nimport { payloadIsNotBlank } from './legacy-data-utils.ts';\nimport type { MinimumAdapterInterface } from './minimum-adapter-interface.ts';\nimport type { MinimumSerializerInterface } from './minimum-serializer-interface.ts';\nimport { normalizeResponseHelper } from './serializer-response.ts';\nimport { SnapshotRecordArray } from './snapshot-record-array.ts';\nimport type { Snapshot } from './snapshot.ts';\n\ntype AdapterErrors = Error & { errors?: unknown[]; isAdapterError?: true; code?: string };\ntype SerializerWithParseErrors = MinimumSerializerInterface & {\n  extractErrors?(store: Store, modelClass: ModelSchema, error: AdapterErrors, recordId: string | null): unknown;\n};\n\nconst PotentialLegacyOperations = new Set([\n  'findRecord',\n  'findAll',\n  'query',\n  'queryRecord',\n  'findBelongsTo',\n  'findHasMany',\n  'updateRecord',\n  'createRecord',\n  'deleteRecord',\n]);\n\n/**\n * A {@link Handler} that fulfills legacy `findRecord`/`findAll`/`query`/\n * `queryRecord`/`findBelongsTo`/`findHasMany`/`createRecord`/`updateRecord`/\n * `deleteRecord` requests using the store's configured {@link MinimumAdapterInterface | adapter}\n * and {@link MinimumSerializerInterface | serializer}, passing any other\n * request through to the next handler unchanged.\n *\n * @summary Legacy `RequestManager` handler that fulfills find, query, create, update, and delete operations through\n * the store's adapters and serializers, passing other requests along.\n */\nexport const LegacyNetworkHandler: Handler = {\n  request<T>(context: StoreRequestContext, next: NextFn<T>): Future<T> | Promise<StructuredDataDocument<T>> {\n    // if we are not a legacy request, move on\n    if (context.request.url || !context.request.op || !PotentialLegacyOperations.has(context.request.op)) {\n      return next(context.request);\n    }\n\n    const { store } = context.request;\n    upgradeStore(store);\n    if (!store._fetchManager) {\n      store._fetchManager = new FetchManager(store);\n    }\n\n    switch (context.request.op) {\n      case 'findRecord':\n        return findRecord(context);\n      case 'findAll':\n        return findAll(context);\n      case 'query':\n        return query(context);\n      case 'queryRecord':\n        return queryRecord(context);\n      case 'findBelongsTo':\n        return findBelongsTo(context);\n      case 'findHasMany':\n        return findHasMany(context);\n      case 'updateRecord':\n        return saveRecord(context);\n      case 'createRecord':\n        return saveRecord(context);\n      case 'deleteRecord':\n        return saveRecord(context);\n      default:\n        return next(context.request);\n    }\n  },\n};\n\nfunction findBelongsTo<T>(context: StoreRequestContext): Promise<T> {\n  const { store, data, records: identifiers } = context.request;\n  const { options, record, links, useLink, field } = data as {\n    record: ResourceKey;\n    options: Record<string, unknown>;\n    links?: Links;\n    useLink: boolean;\n    field: RelationshipSchema;\n  };\n  const identifier = identifiers?.[0];\n  upgradeStore(store);\n\n  // short circuit if we are already loading\n  const pendingRequest = identifier && store._fetchManager.getPendingFetch(identifier as PersistedResourceKey, options);\n  if (pendingRequest) {\n    return pendingRequest as Promise<T>;\n  }\n\n  if (useLink) {\n    assert(`Expected a related link when calling store.findBelongsTo, found ${String(links)}`, links && links.related);\n    return _findBelongsTo(store, record, links.related, field, options) as Promise<T>;\n  }\n\n  assert(`Expected an identifier`, Array.isArray(identifiers) && identifiers.length === 1);\n\n  const manager = store._fetchManager;\n  assertIdentifierHasId(identifier);\n\n  return options.reload\n    ? (manager.scheduleFetch(identifier, options, context.request) as Promise<T>)\n    : (manager.fetchDataIfNeededForIdentifier(identifier, options, context.request) as Promise<T>);\n}\n\nfunction findHasMany<T>(context: StoreRequestContext): Promise<T> {\n  const { store, data, records: identifiers } = context.request;\n  const { options, record, links, useLink, field } = data as {\n    record: ResourceKey;\n    options: Record<string, unknown>;\n    links?: PaginationLinks | Links;\n    useLink: boolean;\n    field: RelationshipSchema;\n  };\n  upgradeStore(store);\n\n  // link case\n  if (useLink) {\n    const adapter = store.adapterFor(record.type);\n    /*\n    If a relationship was originally populated by the adapter as a link\n    (as opposed to a list of IDs), this method is called when the\n    relationship is fetched.\n\n    The link (which is usually a URL) is passed through unchanged, so the\n    adapter can make whatever request it wants.\n\n    The usual use-case is for the server to register a URL as a link, and\n    then use that URL in the future to make a request for the relationship.\n  */\n    assert(`You tried to load a hasMany relationship but you have no adapter (for ${record.type})`, adapter);\n    assert(\n      `You tried to load a hasMany relationship from a specified 'link' in the original payload but your adapter does not implement 'findHasMany'`,\n      typeof adapter.findHasMany === 'function'\n    );\n    assert(`Expected a related link when calling store.findHasMany, found ${String(links)}`, links && links.related);\n\n    return _findHasMany(adapter, store, record, links.related, field, options) as Promise<T>;\n  }\n\n  // identifiers case\n  assert(`Expected an array of identifiers to fetch`, Array.isArray(identifiers));\n  const fetches = new Array<globalThis.Promise<ResourceKey>>(identifiers.length);\n  const manager = store._fetchManager;\n\n  for (let i = 0; i < identifiers.length; i++) {\n    const identifier = identifiers[i];\n    // TODO we probably can be lenient here and return from cache for the isNew case\n    assertIdentifierHasId(identifier);\n    fetches[i] = options.reload\n      ? manager.scheduleFetch(identifier, options, context.request)\n      : manager.fetchDataIfNeededForIdentifier(identifier, options, context.request);\n  }\n\n  return Promise.all(fetches) as Promise<T>;\n}\n\nfunction saveRecord<T>(context: StoreRequestContext): Promise<T> {\n  const { store, data, op: operation } = context.request;\n  const { options, record: identifier } = data as { record: ResourceKey; options: Record<string, unknown> };\n\n  upgradeStore(store);\n  assertPrivateStore(store);\n\n  store.cache.willCommit(identifier, context);\n\n  const saveOptions = Object.assign(\n    { [SaveOp]: operation as 'updateRecord' | 'deleteRecord' | 'createRecord' },\n    options\n  );\n  const fetchManagerPromise = store._fetchManager.scheduleSave(identifier, saveOptions);\n\n  return fetchManagerPromise\n    .then((payload) => {\n      let result: SingleResourceDataDocument;\n      store._join(() => {\n        // @ts-expect-error we don't have access to a response in legacy\n        result = store.cache.didCommit(identifier, { request: context.request, content: payload });\n      });\n\n      // blatantly lie if we were a createRecord request\n      // to give some semblance of cache-control to the\n      // CachePolicy while legacy is still around\n      if (store.lifetimes?.didRequest && operation === 'createRecord') {\n        store.lifetimes.didRequest(context.request, { status: 201 } as Response, null, store);\n      }\n      return store.peekRecord(result!.data!);\n    })\n    .catch((e: unknown) => {\n      let err = e;\n      if (!e) {\n        err = new Error(`Unknown Error Occurred During Request`);\n      } else if (typeof e === 'string') {\n        err = new Error(e);\n      }\n      adapterDidInvalidate(store, identifier, err as Error);\n      throw err;\n    }) as Promise<T>;\n}\n\nfunction adapterDidInvalidate(\n  store: Store,\n  identifier: ResourceKey,\n  error: Error & { errors?: ApiError[]; isAdapterError?: true; code?: string }\n) {\n  upgradeStore(store);\n  if (error && error.isAdapterError === true && error.code === 'InvalidError') {\n    const serializer = store.serializerFor(identifier.type) as SerializerWithParseErrors;\n\n    // TODO @deprecate extractErrors being called\n    // TODO remove extractErrors from the default serializers.\n    if (serializer && typeof serializer.extractErrors === 'function') {\n      const errorsHash = serializer.extractErrors(\n        store,\n        store.modelFor(identifier.type),\n        error,\n        identifier.id\n      ) as Record<string, string | string[]>;\n      error.errors = errorsHashToArray(errorsHash);\n    }\n  }\n  const cache = store.cache;\n\n  if (error.errors) {\n    assert(\n      `Expected the cache in use by resource ${String(\n        identifier\n      )} to have a getErrors(identifier) method for retrieving errors.`,\n      typeof cache.getErrors === 'function'\n    );\n\n    let jsonApiErrors: ApiError[] = error.errors;\n    if (jsonApiErrors.length === 0) {\n      jsonApiErrors = [{ title: 'Invalid Error', detail: '', source: { pointer: '/data' } }];\n    }\n    cache.commitWasRejected(identifier, jsonApiErrors);\n  } else {\n    cache.commitWasRejected(identifier);\n  }\n}\n\nfunction makeArray<T>(value: T | T[]): T[] {\n  return Array.isArray(value) ? value : [value];\n}\n\nconst PRIMARY_ATTRIBUTE_KEY = 'base';\nfunction errorsHashToArray(errors: Record<string, string | string[]>): ApiError[] {\n  const out: ApiError[] = [];\n\n  if (errors) {\n    Object.keys(errors).forEach((key) => {\n      const messages = makeArray(errors[key]);\n      for (let i = 0; i < messages.length; i++) {\n        let title = 'Invalid Attribute';\n        let pointer = `/data/attributes/${key}`;\n        if (key === PRIMARY_ATTRIBUTE_KEY) {\n          title = 'Invalid Document';\n          pointer = `/data`;\n        }\n        out.push({\n          title: title,\n          detail: messages[i],\n          source: {\n            pointer: pointer,\n          },\n        });\n      }\n    });\n  }\n\n  return out;\n}\n\nfunction findRecord<T>(context: StoreRequestContext): Promise<T> {\n  const { store, data } = context.request;\n  const { record: identifier, options } = data as {\n    record: PersistedResourceKey;\n    options: { reload?: boolean; backgroundReload?: boolean };\n  };\n  upgradeStore(store);\n  assertPrivateStore(store);\n  let promise: Promise<ResourceKey>;\n\n  // if not loaded start loading\n  if (!store._instanceCache.recordIsLoaded(identifier)) {\n    promise = store._fetchManager.fetchDataIfNeededForIdentifier(identifier, options, context.request);\n\n    // Refetch if the reload option is passed\n  } else if (options.reload) {\n    assertIdentifierHasId(identifier);\n\n    promise = store._fetchManager.scheduleFetch(identifier, options, context.request);\n  } else {\n    let snapshot: Snapshot | null = null;\n    const adapter = store.adapterFor(identifier.type);\n\n    // Refetch the record if the adapter thinks the record is stale\n    if (\n      typeof options.reload === 'undefined' &&\n      adapter.shouldReloadRecord &&\n      adapter.shouldReloadRecord(store, (snapshot = store._fetchManager.createSnapshot(identifier, options)))\n    ) {\n      assertIdentifierHasId(identifier);\n      if (DEBUG) {\n        promise = store._fetchManager.scheduleFetch(\n          identifier,\n          Object.assign({}, options, { reload: true }),\n          context.request\n        );\n      } else {\n        options.reload = true;\n        promise = store._fetchManager.scheduleFetch(identifier, options, context.request);\n      }\n    } else {\n      // Trigger the background refetch if backgroundReload option is passed\n      if (\n        options.backgroundReload !== false &&\n        (options.backgroundReload ||\n          !adapter.shouldBackgroundReloadRecord ||\n          adapter.shouldBackgroundReloadRecord(\n            store,\n            snapshot || store._fetchManager.createSnapshot(identifier, options)\n          ))\n      ) {\n        assertIdentifierHasId(identifier);\n\n        if (DEBUG) {\n          void store._fetchManager.scheduleFetch(\n            identifier,\n            Object.assign({}, options, { backgroundReload: true }),\n            context.request\n          );\n        } else {\n          options.backgroundReload = true;\n          void store._fetchManager.scheduleFetch(identifier, options, context.request);\n        }\n      }\n\n      // Return the cached record\n      promise = Promise.resolve(identifier);\n    }\n  }\n\n  return promise.then((i: ResourceKey) => store.peekRecord(i)) as Promise<T>;\n}\n\nfunction findAll<T>(context: StoreRequestContext): Promise<T> {\n  const { store, data } = context.request;\n  const { type, options } = data as {\n    type: string;\n    options: { reload?: boolean; backgroundReload?: boolean };\n  };\n  upgradeStore(store);\n  assertPrivateStore(store);\n  const adapter = store.adapterFor(type);\n\n  assert(`You tried to load all records but you have no adapter (for ${type})`, adapter);\n  assert(\n    `You tried to load all records but your adapter does not implement 'findAll'`,\n    typeof adapter.findAll === 'function'\n  );\n\n  // avoid initializing the liveArray just to set `isUpdating`\n  const maybeRecordArray = store.recordArrayManager._live.get(type);\n  const snapshotArray = new SnapshotRecordArray(store, type, options);\n\n  const shouldReload =\n    options.reload ||\n    (options.reload !== false &&\n      ((adapter.shouldReloadAll && adapter.shouldReloadAll(store, snapshotArray)) ||\n        (!adapter.shouldReloadAll && snapshotArray.length === 0)));\n\n  let fetch: Promise<T> | undefined;\n  if (shouldReload) {\n    // oxlint-disable-next-line no-unused-expressions\n    maybeRecordArray && (maybeRecordArray.isUpdating = true);\n    fetch = _findAll(adapter, store, type, snapshotArray, context.request, true);\n  } else {\n    fetch = Promise.resolve(store.peekAll(type)) as Promise<T>;\n\n    if (\n      options.backgroundReload ||\n      (options.backgroundReload !== false &&\n        (!adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(store, snapshotArray)))\n    ) {\n      // oxlint-disable-next-line no-unused-expressions\n      maybeRecordArray && (maybeRecordArray.isUpdating = true);\n      void _findAll(adapter, store, type, snapshotArray, context.request, false);\n    }\n  }\n\n  return fetch;\n}\n\nfunction _findAll<T>(\n  adapter: MinimumAdapterInterface,\n  store: Store,\n  type: string,\n  snapshotArray: SnapshotRecordArray,\n  request: ImmutableRequestInfo,\n  isAsyncFlush: boolean\n): Promise<T> {\n  const schema = store.modelFor(type);\n  let promise: Promise<T> = Promise.resolve().then(() =>\n    adapter.findAll(store, schema, null, snapshotArray)\n  ) as Promise<T>;\n\n  promise = promise.then((adapterPayload: T) => {\n    assert(\n      `You made a 'findAll' request for '${type}' records, but the adapter's response did not have any data`,\n      payloadIsNotBlank(adapterPayload)\n    );\n    upgradeStore(store);\n    const serializer = store.serializerFor(type);\n    const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'findAll');\n\n    store._push(payload, isAsyncFlush);\n    snapshotArray._recordArray.isUpdating = false;\n\n    if (LOG_REQUESTS) {\n      // oxlint-disable-next-line no-console\n      console.log(`request: findAll<${type}> background reload complete`);\n    }\n    return snapshotArray._recordArray;\n  }) as Promise<T>;\n\n  if (TESTING) {\n    if (!request.disableTestWaiter) {\n      promise = waitFor(promise);\n    }\n  }\n\n  return promise;\n}\n\nfunction query<T>(context: StoreRequestContext): Promise<T> {\n  const { store, data } = context.request;\n  upgradeStore(store);\n  assertPrivateStore(store);\n  let { options } = data as {\n    options: { _recordArray?: LegacyQueryArray; adapterOptions?: Record<string, unknown> };\n  };\n  // oxlint-disable-next-line no-shadow\n  const { type, query } = data as {\n    type: string;\n    query: Record<string, unknown>;\n    options: { _recordArray?: LegacyQueryArray; adapterOptions?: Record<string, unknown> };\n  };\n  const adapter = store.adapterFor(type);\n\n  assert(`You tried to make a query but you have no adapter (for ${type})`, adapter);\n  assert(`You tried to make a query but your adapter does not implement 'query'`, typeof adapter.query === 'function');\n\n  const recordArray =\n    options._recordArray ||\n    store.recordArrayManager.getCollection({\n      type,\n      query,\n    });\n\n  if (DEBUG) {\n    options = Object.assign({}, options);\n    delete options._recordArray;\n  } else {\n    delete options._recordArray;\n  }\n  const schema = store.modelFor(type);\n  const promise = Promise.resolve().then(() => adapter.query(store, schema, query, recordArray, options));\n\n  return promise.then((adapterPayload) => {\n    const serializer = store.serializerFor(type);\n    const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'query');\n    const identifiers = store._push(payload, true);\n\n    assert(\n      'The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.',\n      Array.isArray(identifiers)\n    );\n\n    store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload as CollectionResourceDocument);\n\n    return recordArray;\n  }) as Promise<T>;\n}\n\nfunction assertSingleResourceDocument(payload: JsonApiDocument): asserts payload is SingleResourceDocument {\n  assert(\n    `Expected the primary data returned by the serializer for a 'queryRecord' response to be a single object or null but instead it was an array.`,\n    !Array.isArray(payload.data)\n  );\n}\n\nfunction queryRecord<T>(context: StoreRequestContext): Promise<T> {\n  const { store, data } = context.request;\n  // oxlint-disable-next-line no-shadow\n  const { type, query, options } = data as { type: string; query: Record<string, unknown>; options: object };\n  upgradeStore(store);\n  const adapter = store.adapterFor(type);\n\n  assert(`You tried to make a query but you have no adapter (for ${type})`, adapter);\n  assert(\n    `You tried to make a query but your adapter does not implement 'queryRecord'`,\n    typeof adapter.queryRecord === 'function'\n  );\n\n  const schema = store.modelFor(type);\n  const promise = Promise.resolve().then(() => adapter.queryRecord(store, schema, query, options)) as Promise<T>;\n\n  return promise.then((adapterPayload: T) => {\n    const serializer = store.serializerFor(type);\n    const payload = normalizeResponseHelper(\n      serializer,\n      store,\n      schema,\n      adapterPayload as Record<string, unknown>,\n      null,\n      'queryRecord'\n    );\n\n    assertSingleResourceDocument(payload);\n\n    const identifier = store._push(payload, true) as ResourceKey;\n    return identifier ? store.peekRecord(identifier) : null;\n  }) as Promise<T>;\n}\n","/**\n * Helps an app migrate incrementally from legacy EmberData patterns to modern ***Warp*Drive**.\n *\n * ## Why it exists\n *\n * While migrating, you may need to:\n *\n * - keep Adapters and Serializers working on a Store whose requests go through the\n *   {@link RequestManager}\n * - keep the deprecated request methods such as `store.findRecord` and `store.query`, which\n *   Adapters fulfill, working while you move calls to `store.request`\n * - adopt modern patterns one piece at a time rather than all at once\n *\n * ## What it provides\n *\n * - {@link LegacyNetworkHandler}, a request handler that fulfills those legacy requests through\n *   the store's Adapters and Serializers and passes every other request along\n * - {@link adapterFor}, {@link serializerFor}, {@link normalize}, {@link pushPayload} and\n *   {@link serializeRecord}, the store methods for working with Adapters and Serializers, and\n *   {@link LegacyStoreCompat}, the Store type that includes them\n *\n * The Store that [useLegacyStore](/api/@warp-drive/legacy/functions/useLegacyStore) produces\n * adds `LegacyNetworkHandler` to its RequestManager unless `linksMode` is `true`. The hooks\n * that present `Model` instances live in [@warp-drive/legacy/model](/api/@warp-drive/legacy/model/),\n * not here.\n *\n * ## When to use it\n *\n * Only during a migration from legacy EmberData to modern ***Warp*Drive**. It lets you adopt\n * modern patterns incrementally while your existing Adapters and Serializers keep working. For\n * incremental migration strategies, see the [Migration Guide](/upgrading/v5/) and the\n * [Two Store Migration Strategy](/upgrading/v5/two-store-migration).\n *\n * @module\n * @summary Legacy store support for adapters and serializers: the `LegacyNetworkHandler` plus store methods such as\n * `adapterFor`, `serializerFor`, `normalize` and `pushPayload`.\n */\n\nimport { getOwner } from '@ember/application';\n\n// RequestManager is imported only so the @module comment can {@link} it.\n// oxlint-disable-next-line no-unused-vars\nimport { recordIdentifierFor, type RequestManager, type Store } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport { _deprecatingNormalize } from '@warp-drive/core/store/-private';\nimport type { ObjectValue } from '@warp-drive/core/types/json/raw';\nimport type { SingleResourceDocument } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { FetchManager, upgradeStore } from './compat/-private.ts';\nimport type {\n  AdapterPayload,\n  MinimumAdapterInterface,\n} from './compat/legacy-network-handler/minimum-adapter-interface.ts';\nimport type {\n  MinimumSerializerInterface,\n  SerializerOptions,\n} from './compat/legacy-network-handler/minimum-serializer-interface.ts';\n\nexport { LegacyNetworkHandler } from './compat/legacy-network-handler/legacy-network-handler.ts';\n\nexport type { MinimumAdapterInterface, MinimumSerializerInterface, SerializerOptions, AdapterPayload };\n\n/**\n * Extends the signature of {@link Store} with additional\n * methods available when using the legacy network layer.\n *\n * @summary Legacy `Store` type extended with `adapterFor`, `serializerFor`, `normalize`, `pushPayload`, and\n * `serializeRecord` from the adapter and serializer network layer.\n * @public\n * @noInheritDoc\n * @legacy\n */\nexport interface LegacyStoreCompat extends Store {\n  /**\n   * @private\n   */\n  _fetchManager: FetchManager;\n\n  /**\n   * Returns the adapter instance for the given model type, instantiating\n   * it (and caching the instance) if necessary. See {@link adapterFor}.\n   */\n  adapterFor(this: Store, modelName: string): MinimumAdapterInterface;\n  /**\n   * Same as the single-argument overload, but returns `undefined` instead\n   * of throwing/asserting when `_allowMissing` is `true` and no adapter\n   * is found.\n   */\n  adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;\n\n  /**\n   * Returns the serializer instance for the given model type, instantiating\n   * it (and caching the instance) if necessary. See {@link serializerFor}.\n   */\n  serializerFor<K extends string>(modelName: K, _allowMissing?: boolean): MinimumSerializerInterface | null;\n\n  /**\n   * Normalizes a payload for the given model type using its serializer.\n   * See {@link normalize}.\n   */\n  normalize(modelName: string, payload: ObjectValue): ObjectValue;\n\n  /**\n   * Pushes a payload into the store using the appropriate serializer to\n   * normalize it first. See {@link pushPayload}.\n   */\n  pushPayload(modelName: string, payload: ObjectValue): void;\n\n  /**\n   * Serializes a record using its serializer. See {@link serializeRecord}.\n   */\n  serializeRecord(record: unknown, options?: SerializerOptions): unknown;\n\n  /**\n   * @private\n   */\n  _adapterCache: Record<string, MinimumAdapterInterface & { store: Store }>;\n  /**\n   * @private\n   */\n  _serializerCache: Record<string, MinimumSerializerInterface & { store: Store }>;\n}\n\n/**\n * @summary Deprecated alias of `LegacyStoreCompat`, the `Store` type extended with legacy adapter and serializer\n * methods.\n * @deprecated - use {@link LegacyStoreCompat} instead\n */\nexport type CompatStore = LegacyStoreCompat;\n\n/**\n  Returns an instance of the adapter for a given type. For\n  example, `adapterFor('person')` will return an instance of\n  the adapter located at `app/adapters/person.js`\n\n  If no `person` adapter is found, this method will look\n  for an `application` adapter (the default adapter for\n  your entire application).\n\n  @summary Legacy store method that returns the cached adapter for a model type, falling back to the `application`\n  adapter.\n  @public\n  @param modelName\n*/\nexport function adapterFor(this: Store, modelName: string): MinimumAdapterInterface;\nexport function adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;\nexport function adapterFor(this: Store, modelName: string, _allowMissing?: true): MinimumAdapterInterface | undefined {\n  assert(\n    `Attempted to call store.adapterFor(), but the store instance has already been destroyed.`,\n    !(this.isDestroying || this.isDestroyed)\n  );\n  assert(`You need to pass a model name to the store's adapterFor method`, modelName);\n  assert(\n    `Passing classes to store.adapterFor has been removed. Please pass a dasherized string instead of ${modelName}`,\n    typeof modelName === 'string'\n  );\n  upgradeStore(this);\n  this._adapterCache =\n    this._adapterCache || (Object.create(null) as Record<string, MinimumAdapterInterface & { store: Store }>);\n\n  const normalizedModelName = _deprecatingNormalize(modelName);\n\n  const { _adapterCache } = this;\n  let adapter: (MinimumAdapterInterface & { store: Store }) | undefined = _adapterCache[normalizedModelName];\n  if (adapter) {\n    return adapter;\n  }\n\n  const owner = getOwner(this)!;\n\n  // name specific adapter\n  adapter = owner.lookup(`adapter:${normalizedModelName}`) as (MinimumAdapterInterface & { store: Store }) | undefined;\n  if (adapter !== undefined) {\n    _adapterCache[normalizedModelName] = adapter;\n    return adapter;\n  }\n\n  // no adapter found for the specific name, fallback and check for application adapter\n  adapter = _adapterCache.application || owner.lookup('adapter:application');\n  if (adapter !== undefined) {\n    _adapterCache[normalizedModelName] = adapter;\n    _adapterCache.application = adapter;\n    return adapter;\n  }\n\n  assert(\n    `No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`,\n    _allowMissing\n  );\n}\n\n/**\n  Returns an instance of the serializer for a given type. For\n  example, `serializerFor('person')` will return an instance of\n  `App.PersonSerializer`.\n\n  If no `App.PersonSerializer` is found, this method will look\n  for an `App.ApplicationSerializer` (the default serializer for\n  your entire application).\n\n  If a serializer cannot be found on the adapter, it will fall back\n  to an instance of `JSONSerializer`.\n\n  @summary Legacy store method that returns the cached serializer for a model type, falling back to the\n  `application` serializer, or `null` if neither exists.\n  @public\n  @param modelName the record to serialize\n  */\nexport function serializerFor(this: Store, modelName: string): MinimumSerializerInterface | null {\n  assert(\n    `Attempted to call store.serializerFor(), but the store instance has already been destroyed.`,\n    !(this.isDestroying || this.isDestroyed)\n  );\n  assert(`You need to pass a model name to the store's serializerFor method`, modelName);\n  assert(\n    `Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of ${modelName}`,\n    typeof modelName === 'string'\n  );\n  upgradeStore(this);\n  this._serializerCache =\n    this._serializerCache || (Object.create(null) as Record<string, MinimumSerializerInterface & { store: Store }>);\n  const normalizedModelName = _deprecatingNormalize(modelName);\n\n  const { _serializerCache } = this;\n  let serializer: (MinimumSerializerInterface & { store: Store }) | undefined = _serializerCache[normalizedModelName];\n  if (serializer) {\n    return serializer;\n  }\n\n  // by name\n  const owner = getOwner(this)!;\n  serializer = owner.lookup(`serializer:${normalizedModelName}`) as\n    | (MinimumSerializerInterface & { store: Store })\n    | undefined;\n  if (serializer !== undefined) {\n    _serializerCache[normalizedModelName] = serializer;\n    return serializer;\n  }\n\n  // no serializer found for the specific model, fallback and check for application serializer\n  serializer = _serializerCache.application || owner.lookup('serializer:application');\n  if (serializer !== undefined) {\n    _serializerCache[normalizedModelName] = serializer;\n    _serializerCache.application = serializer;\n    return serializer;\n  }\n\n  return null;\n}\n\n/**\n  `normalize` converts a json payload into the normalized form expected by\n  {@link Store.push | push} using the serializer specified by `modelName`\n\n  :::warning\n  Generally it would be better to invoke the serializer yourself directly,\n  or write a more specialized normalization utility.\n  :::\n\n  Example\n\n  ```js\n  socket.on('message', function(message) {\n    let modelName = message.model;\n    let data = message.data;\n    store.push(store.normalize(modelName, data));\n  });\n  ```\n\n  @summary Legacy store method that converts a raw payload into the normalized document `store.push` expects, using\n  the serializer for the given model type.\n  @legacy\n  @public\n  @param modelName The name of the model type for this payload\n  @return The normalized payload\n*/\n// TODO @runspired @deprecate users should call normalize on the associated serializer directly\nexport function normalize(this: Store, modelName: string, payload: ObjectValue): SingleResourceDocument {\n  upgradeStore(this);\n  assert(\n    `Attempted to call store.normalize(), but the store instance has already been destroyed.`,\n    !(this.isDestroying || this.isDestroyed)\n  );\n  assert(`You need to pass a model name to the store's normalize method`, modelName);\n  assert(\n    `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${typeof modelName}`,\n    typeof modelName === 'string'\n  );\n  const normalizedModelName = _deprecatingNormalize(modelName);\n  const serializer = this.serializerFor(normalizedModelName);\n  const schema = this.modelFor(normalizedModelName);\n  assert(\n    `You must define a normalize method in your serializer in order to call store.normalize`,\n    typeof serializer?.normalize === 'function'\n  );\n  return serializer.normalize(schema, payload);\n}\n\n/**\n    Push some raw data into the store.\n\n    This method can be used both to push in brand new\n    records, as well as to update existing records. You\n    can push in more than one type of object at once.\n    All objects should be in the format expected by the\n    serializer.\n\n    ```js [app/serializers/application.js]\n    import RESTSerializer from '@warp-drive/legacy/serializer/rest';\n\n    export default class ApplicationSerializer extends RESTSerializer;\n    ```\n\n    ```js\n    let pushData = {\n      posts: [\n        { id: 1, postTitle: \"Great post\", commentIds: [2] }\n      ],\n      comments: [\n        { id: 2, commentBody: \"Insightful comment\" }\n      ]\n    }\n\n    store.pushPayload(pushData);\n    ```\n\n    By default, the data will be deserialized using a default\n    serializer (the application serializer if it exists).\n\n    Alternatively, `pushPayload` will accept a model type which\n    will determine which serializer will process the payload.\n\n    ```js [app/serializers/application.js]\n    import RESTSerializer from '@warp-drive/legacy/serializer/rest';\n\n     export default class ApplicationSerializer extends RESTSerializer;\n    ```\n\n    ```js [app/serializers/post.js]\n    import JSONSerializer from '@warp-drive/legacy/serializer/json';\n\n    export default JSONSerializer;\n    ```\n\n    ```js\n    store.pushPayload(pushData); // Will use the application serializer\n    store.pushPayload('post', pushData); // Will use the post serializer\n    ```\n\n    @summary Legacy store method that pushes a raw payload into the store after the application serializer, or the\n    given model type's serializer, normalizes it.\n    @public\n    @param modelName Optionally, a model type used to determine which serializer will be used\n    @param inputPayload\n  */\n// TODO @runspired @deprecate pushPayload in favor of looking up the serializer\nexport function pushPayload(this: Store, modelName: string, inputPayload: ObjectValue): void {\n  upgradeStore(this);\n  assert(\n    `Attempted to call store.pushPayload(), but the store instance has already been destroyed.`,\n    !(this.isDestroying || this.isDestroyed)\n  );\n\n  const payload: ObjectValue = inputPayload || (modelName as unknown as ObjectValue);\n  const normalizedModelName = inputPayload ? _deprecatingNormalize(modelName) : 'application';\n  const serializer = this.serializerFor(normalizedModelName);\n\n  assert(\n    `You cannot use 'store.pushPayload(<type>, <payload>)' unless the serializer for '${normalizedModelName}' defines 'pushPayload'`,\n    serializer && typeof serializer.pushPayload === 'function'\n  );\n  serializer.pushPayload(this, payload);\n}\n\n/**\n * Serializes a record using the store's legacy network layer, as with\n * {@link LegacyStoreCompat.serializeRecord | store.serializeRecord}.\n *\n * @summary Legacy store method that serializes a record into a payload using its model type's serializer.\n */\n// TODO @runspired @deprecate records should implement their own serialization if desired\nexport function serializeRecord(this: Store, record: unknown, options?: SerializerOptions): unknown {\n  upgradeStore(this);\n  // TODO we used to check if the record was destroyed here\n  if (!this._fetchManager) {\n    this._fetchManager = new FetchManager(this);\n  }\n\n  return this._fetchManager.createSnapshot(recordIdentifierFor(record)).serialize(options);\n}\n\n/**\n * Destroys any adapters/serializers the legacy network layer has created\n * for this store, invoked when the store itself is destroyed.\n *\n * @summary Legacy store teardown hook that destroys every adapter and serializer instance the store has cached.\n */\nexport function cleanup(this: Store): void {\n  upgradeStore(this);\n  // enqueue destruction of any adapters/serializers we have created\n  for (const adapterName in this._adapterCache) {\n    const adapter = this._adapterCache[adapterName];\n    if (typeof adapter.destroy === 'function') {\n      adapter.destroy();\n    }\n  }\n\n  for (const serializerName in this._serializerCache) {\n    const serializer = this._serializerCache[serializerName];\n    if (typeof serializer.destroy === 'function') {\n      serializer.destroy();\n    }\n  }\n}\n"],"mappings":"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"}