@warp-drive/legacy 5.7.0-alpha.0 → 5.7.0-alpha.2

package/declarations/adapter/error.d.ts

@@ -1,8 +1,8 @@
-import type { JsonApiError } from "@warp-drive/core/store/-types/q/record-data-json-api";
+import type { ApiError } from "@warp-drive/core/types/spec/error";
 export interface AdapterRequestError<T extends string = string> extends Error {
 	isAdapterError: true;
 	code: T;
-	errors: JsonApiError[];
+	errors: ApiError[];
 }
 export interface AdapterRequestErrorConstructor<Instance extends AdapterRequestError = AdapterRequestError> {
 	new (errors?: unknown[], message?: string): Instance;

package/declarations/model/-private/model-methods.d.ts

@@ -32,9 +32,12 @@ export declare function hasMany<
 	K extends MaybeHasManyFields<T>
 >(this: T, prop: K): HasManyReference<T, K>;
 export declare function reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function changedAttributes<T extends MinimalLegacyRecord>(this: T): ChangedAttributesHash;
 export declare function serialize<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): unknown;
 export declare function deleteRecord<T extends MinimalLegacyRecord>(this: T): void;
 export declare function save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function createSnapshot<T extends MinimalLegacyRecord>(this: T): Snapshot<T>;

package/declarations/model/-private/model.d.ts

@@ -47,6 +47,8 @@ interface Model {
 	/** @internal */
 	___private_notifications: object;
 	/** @internal */
+	_isReloading: boolean;
+	/** @internal */
 	[RecordStore]: Store;
 	/**
 	Create a JSON representation of the record, using the serialization
@@ -1319,4 +1321,5 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	*/
 	static toString(): string;
 }
+export declare function restoreDeprecatedModelRequestBehaviors(ModelKlass: typeof Model): void;
 export { Model };

package/declarations/model/migration-support.d.ts

@@ -1,22 +1,3 @@
-/**
-* This module provides support for migrating away from @ember-data/model
-* to @warp-drive/schema-record.
-*
-* It includes:
-*
-* - A `withDefaults` function to assist in creating a schema in LegacyMode
-* - A `registerDerivations` function to register the derivations necessary to support LegacyMode
-* - A `DelegatingSchemaService` that can be used to provide a schema service that works with both
-*   @ember-data/model and @warp-drive/schema-record simultaneously for migration purposes.
-* - A `WithLegacy` type util that can be used to create a type that includes the legacy
-*   properties and methods of a record.
-*
-* Using LegacyMode features on a ReactiveResource *requires* the use of these derivations and schema
-* additions. LegacyMode is not intended to be a long-term solution, but rather a stepping stone
-* to assist in more rapidly adopting modern WarpDrive features.
-*
-* @module
-*/
 import type { Store } from "@warp-drive/core";
 import type { CAUTION_MEGA_DANGER_ZONE_Extension, ProcessedExtension } from "@warp-drive/core/reactive";
 import type { ExtensibleField } from "@warp-drive/core/reactive/-private/schema";
@@ -170,6 +151,7 @@ export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
 * @public
 */
 export declare function withDefaults(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
+export declare function withRestoredDeprecatedModelRequestBehaviors(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
 /**
 * A function which registers the necessary derivations to support
 * the LegacyMode features of @ember-data/model while migrating to WarpDrive.

package/declarations/model.d.ts

@@ -39,7 +39,7 @@ and dasherized.
 export { attr } from "./model/-private/attr.js";
 export { belongsTo } from "./model/-private/belongs-to.js";
 export { hasMany } from "./model/-private/has-many.js";
-export { Model } from "./model/-private/model.js";
+export { Model, restoreDeprecatedModelRequestBehaviors } from "./model/-private/model.js";
 export { Model as default } from "./model/-private/model.js";
 export type { PromiseBelongsTo as AsyncBelongsTo } from "./model/-private/promise-belongs-to.js";
 export type { PromiseManyArray as AsyncHasMany } from "./model/-private/promise-many-array.js";

package/declarations/store/-private.d.ts

@@ -0,0 +1,235 @@
+import { type InstanceCache } from "@warp-drive/core/store/-private";
+import type { StableNewRecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { Value } from "@warp-drive/core/types/json/raw";
+import type { Includes, OpaqueRecordInstance, TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
+import type { SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
+import type { Store } from "../store.js";
+export declare function preloadData(store: Store, identifier: StableNewRecordIdentifier, preload: Record<string, Value>): void;
+export interface BaseFinderOptions<T = unknown> {
+	reload?: boolean;
+	backgroundReload?: boolean;
+	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+	adapterOptions?: Record<string, unknown>;
+}
+export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
+	/**
+	* Data to preload into the store before the request is made.
+	* This feature is *highly* discouraged and has no corresponding
+	* feature when using builders and handlers.
+	*
+	* Excepting relationships: the data should be in the form of a
+	* JSON object where the keys are fields on the record and the value
+	* is the raw value to be added to the cache.
+	*
+	* Relationships can either be provided as string IDs from which
+	* an identifier will be built base upon the relationship's expected
+	* resource type, or be record instances from which the identifier
+	* will be extracted.
+	*
+	*/
+	preload?: Record<string, Value>;
+}
+export type QueryOptions = { [K in string | "adapterOptions"]? : K extends "adapterOptions" ? Record<string, unknown> : unknown };
+export type FindAllOptions<T = unknown> = BaseFinderOptions<T>;
+export type LegacyResourceQuery<T = unknown> = {
+	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+	[key: string]: Value | undefined;
+};
+export type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
+/**
+* Minimum subset of static schema methods and properties on the
+* "model" class.
+*
+* Only used when using the legacy schema-service implementation
+* for @ember-data/model or when wrapping schema for legacy
+* Adapters/Serializers.
+*
+*/
+export interface ModelSchema<T = unknown> {
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	fields: Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	attributes: Map<KeyOrString<T>, LegacyAttributeField>;
+	relationshipsByName: Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, type: string | null) => void, binding?: T): void;
+}
+export declare function resourceIsFullyDeleted(instanceCache: InstanceCache, identifier: StableRecordIdentifier): boolean;
+/**
+A `RecordReference` is a low-level API that allows users and
+addon authors to perform meta-operations on a record.
+
+@hideconstructor
+@public
+*/
+export declare class RecordReference {
+	/** @internal */
+	private store;
+	/** @internal */
+	// unsubscribe token given to us by the notification manager
+	private ___token;
+	/** @internal */
+	private ___identifier;
+	/** @internal */
+	private _ref;
+	constructor(store: Store, identifier: StableRecordIdentifier);
+	/** @internal */
+	destroy(): void;
+	get type(): string;
+	/**
+	The `id` of the record that this reference refers to.
+	
+	Together, the `type` and `id` properties form a composite key for
+	the identity map.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.id(); // '1'
+	```
+	
+	@public
+	@return The id of the record.
+	*/
+	id(): string | null;
+	/**
+	The `identifier` of the record that this reference refers to.
+	
+	Together, the `type` and `id` properties form a composite key for
+	the identity map.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.identifier(); // '1'
+	```
+	
+	@public
+	@return The identifier of the record.
+	*/
+	identifier(): StableRecordIdentifier;
+	/**
+	How the reference will be looked up when it is loaded. Currently
+	this always returns `identity` to signify that a record will be
+	loaded by its `type` and `id`.
+	
+	Example
+	
+	```javascript
+	const userRef = store.getReference('user', 1);
+	
+	userRef.remoteType(); // 'identity'
+	```
+	
+	@public
+	*/
+	remoteType(): "identity";
+	/**
+	This API allows you to provide a reference with new data. The
+	simplest usage of this API is similar to `store.push`: you provide a
+	normalized hash of data and the object represented by the reference
+	will update.
+	
+	If you pass a promise to `push`, Ember Data will not ask the adapter
+	for the data if another attempt to fetch it is made in the
+	interim. When the promise resolves, the underlying object is updated
+	with the new data, and the promise returned by *this function* is resolved
+	with that object.
+	
+	For example, `recordReference.push(promise)` will be resolved with a
+	record.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	// provide data for reference
+	userRef.push({
+	data: {
+	id: "1",
+	type: "user",
+	attributes: {
+	username: "@user"
+	}
+	}
+	}).then(function(user) {
+	userRef.value() === user;
+	});
+	```
+	
+	@public
+	@param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
+	@return a promise for the value (record or relationship)
+	*/
+	push(objectOrPromise: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<OpaqueRecordInstance>;
+	/**
+	If the entity referred to by the reference is already loaded, it is
+	present as `reference.value`. Otherwise the value returned by this function
+	is `null`.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.value(); // user
+	```
+	
+	@public
+	@return {Model} the record for this RecordReference
+	*/
+	value(): OpaqueRecordInstance | null;
+	/**
+	Triggers a fetch for the backing entity based on its `remoteType`
+	(see `remoteType` definitions per reference type).
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	// load user (via store.find)
+	userRef.load().then(...)
+	```
+	
+	@public
+	@return the record for this RecordReference
+	*/
+	load(): Promise<unknown>;
+	/**
+	Reloads the record if it is already loaded. If the record is not
+	loaded it will load the record via `store.findRecord`
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	// or trigger a reload
+	userRef.reload().then(...)
+	```
+	
+	@public
+	@return the record for this RecordReference
+	*/
+	reload(): Promise<unknown>;
+}
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+// Mimics the static apis of @ember-data/model
+export declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
+	__store: Store;
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+	get fields(): Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	get attributes(): Map<KeyOrString<T>, LegacyAttributeField>;
+	get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}

package/declarations/store.d.ts

@@ -0,0 +1,3 @@
+import type { Store } from "@warp-drive/core";
+export declare function restoreDeprecatedStoreBehaviors(StoreKlass: typeof Store): void;
+export { Store };

package/dist/adapter/error.js

@@ -4,6 +4,72 @@ import { macroCondition, getGlobalConfig } from '@embroider/macros';
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 
+/**
+  ## Overview
+
+  <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
+  <p>
+    ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
+    If starting a new app or thinking of implementing a new adapter, consider writing a
+    <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
+  </p>
+  </blockquote>
+
+  An `AdapterError` is used by an adapter to signal that an error occurred
+  during a request to an external API. It indicates a generic error, and
+  subclasses are used to indicate specific error states.
+
+  To create a custom error to signal a specific error state in communicating
+  with an external API, extend the `AdapterError`. For example, if the
+  external API exclusively used HTTP `503 Service Unavailable` to indicate
+  it was closed for maintenance:
+
+  ```js [app/adapters/maintenance-error.js]
+  import AdapterError from '@ember-data/adapter/error';
+
+  export default AdapterError.extend({ message: "Down for maintenance." });
+  ```
+
+  This error would then be returned by an adapter's `handleResponse` method:
+
+  ```js [app/adapters/application.js]
+  import JSONAPIAdapter from '@ember-data/adapter/json-api';
+  import MaintenanceError from './maintenance-error';
+
+  export default class ApplicationAdapter extends JSONAPIAdapter {
+    handleResponse(status) {
+      if (503 === status) {
+        return new MaintenanceError();
+      }
+
+      return super.handleResponse(...arguments);
+    }
+  }
+  ```
+
+  And can then be detected in an application and used to send the user to an
+  `under-maintenance` route:
+
+  ```js [app/routes/application.js]
+  import MaintenanceError from '../adapters/maintenance-error';
+
+  export default class ApplicationRoute extends Route {
+    actions: {
+      error(error, transition) {
+        if (error instanceof MaintenanceError) {
+          this.transitionTo('under-maintenance');
+          return;
+        }
+
+        // ...other error handling logic
+      }
+    }
+  }
+  ```
+
+  @class AdapterError
+  @public
+*/
 function _AdapterError(errors, message = 'Adapter operation failed') {
   this.isAdapterError = true;
   const error = Error.call(this, message);

package/dist/adapter/rest.js

@@ -776,7 +776,7 @@ class RESTAdapter extends AdapterWithBuildURLMixin {
     if (this.isSuccess(status, headers, payload)) {
       return payload;
     } else if (this.isInvalid(status, headers, payload)) {
-      // @ts-expect-error needs cast to JsonApiError
+      // @ts-expect-error needs cast to ApiError
       return new InvalidError(typeof payload === 'object' && 'errors' in payload ? payload.errors : undefined);
     }
     const errors = this.normalizeErrorResponse(status, headers, payload);

package/dist/compat/builders.js

@@ -1,28 +1,8 @@
 import { SkipCache } from '@warp-drive/core/types/request';
-import { deprecate } from '@ember/debug';
-import { dasherize } from '@warp-drive/utilities/string';
+import { n as normalizeModelName, i as isMaybeIdentifier } from "../utils-Cqw9eRj5.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { ensureStringId, constructResource } from '@warp-drive/core/store/-private';
 import { storeFor, recordIdentifierFor } from '@warp-drive/core';
-function isMaybeIdentifier(maybeIdentifier) {
-  return Boolean(maybeIdentifier !== null && typeof maybeIdentifier === 'object' && ('id' in maybeIdentifier && 'type' in maybeIdentifier && maybeIdentifier.id && maybeIdentifier.type || maybeIdentifier.lid));
-}
-function normalizeModelName(type) {
-  if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_TYPES)) {
-    const result = dasherize(type);
-    deprecate(`The resource type '${type}' is not normalized. Update your application code to use '${result}' instead of '${type}'.`, result === type, {
-      id: 'ember-data:deprecate-non-strict-types',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.3'
-      }
-    });
-    return result;
-  }
-  return type;
-}
 
 /**
   This function builds a request config to perform a `findAll` request for the given type.

package/dist/model/migration-support.js

@@ -1,9 +1,10 @@
+import { deprecate } from '@ember/debug';
 import { recordIdentifierFor } from '@warp-drive/core';
 import { notifyInternalSignal, ARRAY_SIGNAL } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { Type } from '@warp-drive/core/types/symbols';
 import { l as lookupLegacySupport, E as Errors } from "../errors-BX5wowuz.js";
-import { b as buildSchema, u as unloadRecord, s as serialize, a as save, r as rollbackAttributes, c as reload, h as hasMany, d as destroyRecord, e as deleteRecord, R as RecordState, f as changedAttributes, g as belongsTo, i as createSnapshot } from "../schema-provider-BdQhkT-Q.js";
+import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, g as deleteRecord, R as RecordState, i as changedAttributes, j as belongsTo, k as createSnapshot } from "../schema-provider-Cbnf6sKm.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 /**
@@ -25,7 +26,6 @@ import { macroCondition, getGlobalConfig } from '@embroider/macros';
  *
  * @module
  */
-
 // 'isDestroying', 'isDestroyed'
 const LegacyFields = ['_createSnapshot', 'adapterError', 'belongsTo', 'changedAttributes', 'constructor', 'currentState', 'deleteRecord', 'destroyRecord', 'dirtyType', 'errors', 'hasDirtyAttributes', 'hasMany', 'isDeleted', 'isEmpty', 'isError', 'isLoaded', 'isLoading', 'isNew', 'isSaving', 'isValid', 'reload', 'rollbackAttributes', 'save', 'serialize', 'unloadRecord'];
 
@@ -78,10 +78,13 @@ function legacySupport(record, options, prop) {
     state = {};
     LegacySupport.set(record, state);
   }
+  const suppressDeprecation = Boolean(options && options.suppressDeprecation);
   switch (prop) {
     case '_createSnapshot':
+      // FIXME should be deprecated too?
       return createSnapshot;
     case 'adapterError':
+      // FIXME should be deprecated too?
       return record.currentState.adapterError;
     case 'belongsTo':
       return belongsTo;
@@ -98,10 +101,11 @@ function legacySupport(record, options, prop) {
     case 'deleteRecord':
       return deleteRecord;
     case 'destroyRecord':
-      return destroyRecord;
+      return suppressDeprecation ? _destroyRecord : destroyRecord;
     case 'dirtyType':
       return record.currentState.dirtyType;
     case 'errors':
+      // FIXME should be deprecated too?
       // @ts-expect-error
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
       return state.errors = state.errors || Errors.create({
@@ -128,12 +132,13 @@ function legacySupport(record, options, prop) {
     case 'isValid':
       return record.currentState.isValid;
     case 'reload':
-      return reload;
+      return suppressDeprecation ? _reload : reload;
     case 'rollbackAttributes':
       return rollbackAttributes;
     case 'save':
-      return save;
+      return suppressDeprecation ? _save : save;
     case 'serialize':
+      // FIXME should be deprecated too? (is somewhat deprecated via store.serializeRecord)
       return serialize;
     case 'unloadRecord':
       return unloadRecord;
@@ -214,6 +219,50 @@ function withDefaults(schema) {
       kind: 'derived'
     });
   });
+  schema.fields.push({
+    name: '_isReloading',
+    kind: '@local',
+    type: 'boolean',
+    options: {
+      defaultValue: false
+    }
+  });
+  schema.fields.push({
+    name: 'isDestroying',
+    kind: '@local',
+    type: 'boolean',
+    options: {
+      defaultValue: false
+    }
+  });
+  schema.fields.push({
+    name: 'isDestroyed',
+    kind: '@local',
+    type: 'boolean',
+    options: {
+      defaultValue: false
+    }
+  });
+  schema.objectExtensions = schema.objectExtensions || [];
+  schema.objectExtensions.push('deprecated-model-behaviors');
+  return schema;
+}
+function withRestoredDeprecatedModelRequestBehaviors(schema) {
+  schema.legacy = true;
+  schema.identity = {
+    kind: '@id',
+    name: 'id'
+  };
+  LegacyFields.forEach(field => {
+    schema.fields.push({
+      type: '@legacy',
+      name: field,
+      kind: 'derived',
+      options: {
+        suppressDeprecation: true
+      }
+    });
+  });
   schema.fields.push({
     name: 'isReloading',
     kind: '@local',
@@ -297,6 +346,34 @@ function registerDerivations(schema) {
       }
     }
   });
+  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension({
+    name: 'deprecated-model-behaviors',
+    kind: 'object',
+    features: {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      get isReloading() {
+        deprecate(`record.isReloading is deprecated, please use store.request and either <Request> or getRequuestState to keep track of the request state instead.`, false, {
+          id: 'warp-drive:deprecate-legacy-request-methods',
+          until: '6.0',
+          for: '@warp-drive/core',
+          url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
+          since: {
+            enabled: '5.7',
+            available: '5.7'
+          }
+        });
+        // @ts-expect-error
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this._isReloading;
+      },
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      set isReloading(v) {
+        // @ts-expect-error
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        this._isReloading = v;
+      }
+    }
+  });
 }
 
 /**
@@ -461,4 +538,4 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
     return this._preferred.doesTypeExist?.(type) || this._secondary.doesTypeExist?.(type) || false;
   };
 }
-export { DelegatingSchemaService, registerDerivations, withDefaults };
+export { DelegatingSchemaService, registerDerivations, withDefaults, withRestoredDeprecatedModelRequestBehaviors };

package/dist/model.js

@@ -1,13 +1,14 @@
 import { computed } from '@ember/object';
 import { recordIdentifierFor } from '@warp-drive/core';
 import { peekCache, setRecordIdentifier, StoreMap, setCacheFor } from '@warp-drive/core/store/-private';
-import { j as isElementDescriptor, n as normalizeModelName, k as getModelFactory } from "./schema-provider-BdQhkT-Q.js";
-export { M as Model, b as buildSchema, M as default } from "./schema-provider-BdQhkT-Q.js";
+import { i as isElementDescriptor, n as normalizeModelName } from "./util-Dul6TZts.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
 import { RecordStore } from '@warp-drive/core/types/symbols';
 import { l as lookupLegacySupport } from "./errors-BX5wowuz.js";
 import { singularize, dasherize } from '@warp-drive/utilities/string';
+import { l as getModelFactory } from "./schema-provider-Cbnf6sKm.js";
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-Cbnf6sKm.js";
 import { setOwner, getOwner } from '@ember/application';
 function _attr(type, options) {
   if (typeof type === 'object') {