@warp-drive/legacy 5.9.0-alpha.18 → 5.9.0-alpha.19

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

@@ -36,6 +36,27 @@ export type AttrOptions<DV = PrimitiveValue | object | unknown[]> = {
 	*
 	*/
 	defaultValue?: DV extends PrimitiveValue ? DV : () => DV;
+	/**
+	* The name of the field as returned by the API and inserted into the
+	* cache if it differs from the name of the decorated property.
+	*
+	* For instance, if the API returns:
+	*
+	* ```ts
+	* {
+	*   attributes: {
+	*     'first-name': 'Chris'
+	*   }
+	* }
+	* ```
+	*
+	* But the app desires to use `record.firstName; // 'Chris'`, then the
+	* property should be named `firstName` and `sourceKey` should be set
+	* to `'first-name'`.
+	*
+	* This option is only needed when the value differs from the property name.
+	*/
+	sourceKey?: string;
 };
 type LooseTransformInstance<
 	V,

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

@@ -10,6 +10,27 @@ export type RelationshipOptions<
 	as?: string;
 	linksMode?: true;
 	resetOnRemoteUpdate?: boolean;
+	/**
+	* The name of the field as returned by the API and inserted into the
+	* cache if it differs from the name of the decorated property.
+	*
+	* For instance, if the API returns:
+	*
+	* ```ts
+	* {
+	*   relationships: {
+	*     'best-friend': { data: { type: 'user', id: '1' } }
+	*   }
+	* }
+	* ```
+	*
+	* But the app desires to use `record.bestFriend`, then the property
+	* should be named `bestFriend` and `sourceKey` should be set to
+	* `'best-friend'`.
+	*
+	* This option is only needed when the value differs from the property name.
+	*/
+	sourceKey?: string;
 };
 export type NoNull<T> = Exclude<T, null>;
 export type RelationshipDecorator<T> = <This>(target: This, key: string, desc?: PropertyDescriptor) => void;

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

@@ -3,7 +3,7 @@ import type { SchemaService } from "@warp-drive/core/types";
 import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
-import type { ArrayField, DerivedField, GenericField, HashField, LegacyField, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import type { ArrayField, CacheableFieldSchema, DerivedField, GenericField, HashField, IdentityField, LegacyField, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
 import type { ModelFactory, ModelStore } from "./model.js";
 type AttributesSchema = ReturnType<Exclude<SchemaService["attributesDefinitionFor"], undefined>>;
 type RelationshipsSchema = ReturnType<Exclude<SchemaService["relationshipsDefinitionFor"], undefined>>;
@@ -47,6 +47,9 @@ export declare class ModelSchemaProvider implements SchemaService {
 	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, LegacyField>;
+	cacheFields(resource: ResourceKey | {
+		type: string;
+	}): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
 	hasResource(resource: {
 		type: string;
 	}): boolean;

package/declarations/serializer/-private/utils.d.ts

@@ -1,3 +1,27 @@
+import type { Store } from "@warp-drive/core";
+import type { LegacyBelongsToField, LegacyHasManyField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
 type Coercable = string | number | boolean | null | undefined | symbol;
 export declare function coerceId(id: Coercable): string | null;
+/**
+Given the name of a relationship on a resource `type`, determines the
+inverse relationship field (if any) using only the schema service.
+
+Unlike `Model.inverseFor`, this does not require `type` to be backed by
+a `Model` class, so it works for both `Model`-based and schema-only
+(e.g. `withDefaults` migration-support) resources.
+
+@private
+*/
+export declare function inverseForRelationship(store: Store, type: string, name: string): LegacyRelationshipField | null;
+/**
+Given a relationship field on a resource `type`, determines the
+cardinality of the relationship using only the schema service.
+
+Unlike `Model.determineRelationshipType`, this does not require `type`
+to be backed by a `Model` class, so it works for both `Model`-based and
+schema-only (e.g. `withDefaults` migration-support) resources.
+
+@private
+*/
+export declare function determineRelationshipType(store: Store, type: string, knownSide: LegacyBelongsToField | LegacyHasManyField): "oneToOne" | "oneToMany" | "manyToOne" | "manyToMany" | "oneToNone" | "manyToNone";
 export {};

package/dist/{hooks-CoxuoIfB.js → hooks-DuAlm6Rk.js}

@@ -1,6 +1,6 @@
 import { setOwner, getOwner } from '@ember/application';
 import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
-import { g as getModelFactory } from "./schema-provider-qgBVdfoF.js";
+import { g as getModelFactory } from "./schema-provider-y3Wz44Br.js";
 import { n as normalizeModelName } from "./util-Dul6TZts.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 function instantiateRecord(identifier, createRecordArgs) {

package/dist/index.js

@@ -10,8 +10,8 @@ import '@warp-drive/utilities/string';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import '@warp-drive/core/store/-private';
 import "./errors-Cz5KrzBk.js";
-import "./schema-provider-qgBVdfoF.js";
-import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-CoxuoIfB.js";
+import "./schema-provider-y3Wz44Br.js";
+import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-DuAlm6Rk.js";
 import { registerDerivations as registerDerivations$1, DelegatingSchemaService } from './model/migration-support.js';
 import { F as FragmentExtension, a as FragmentArrayExtension, f as fragmentsModelFor } from "./model-for-DOiIKvY_.js";
 import { restoreDeprecatedStoreBehaviors } from './store.js';
@@ -43,7 +43,30 @@ function useLegacyStore(options, StoreKlass = Store) {
   // we extend the store to ensure we don't leak our prototype overrides to other stores below.
   class BaseKlass extends StoreKlass {}
   class LegacyConfiguredStore extends BaseKlass {
-    requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...(options.handlers ?? []), Fetch].filter(Boolean)).useCache(CacheHandler);
+    constructor(createArgs) {
+      super(createArgs);
+      // installed via defineProperty (rather than a class field/accessor) so that
+      // this lazy override of the inherited `requestManager` field does not
+      // conflict with the documented pattern of assigning it directly on
+      // consumer-authored Store subclasses. The setter preserves the ability
+      // to replace `requestManager` outright after construction.
+      let requestManager;
+      Object.defineProperty(this, 'requestManager', {
+        configurable: true,
+        enumerable: true,
+        get: () => {
+          if (!requestManager) {
+            const handlersOption = options.handlers;
+            const handlers = typeof handlersOption === 'function' ? handlersOption(this) : handlersOption ?? [];
+            requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...handlers, Fetch].filter(Boolean)).useCache(CacheHandler);
+          }
+          return requestManager;
+        },
+        set: value => {
+          requestManager = value;
+        }
+      });
+    }
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,
       // 15 minutes