@warp-drive/core 5.9.0-alpha.17 → 5.9.0-alpha.19

package/dist/unpkg/dev/index.js

@@ -1,4 +1,4 @@
-export { C as CacheHandler, F as Fetch, y as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, D as setIdentifierForgetMethod, A as setIdentifierGenerationMethod, E as setIdentifierResetMethod, B as setIdentifierUpdateMethod, G as setKeyInfoForResource, s as storeFor, z as useRecommendedStore } from "./index-BZRBBa34.js";
+export { C as CacheHandler, F as Fetch, y as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, D as setIdentifierForgetMethod, A as setIdentifierGenerationMethod, E as setIdentifierResetMethod, B as setIdentifierUpdateMethod, G as setKeyInfoForResource, s as storeFor, z as useRecommendedStore } from "./index-DU_HLpg-.js";
 import "./-private-sql1_mdx.js";
 import "./-leaked-BohmerbH.js";
 import './store.js';

package/dist/unpkg/dev/reactive.js

@@ -1,3 +1,3 @@
-export { q as SchemaService, o as checkout, x as commit, u as fromIdentity, p as instantiateRecord, v as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-BZRBBa34.js";
+export { q as SchemaService, o as checkout, x as commit, u as fromIdentity, p as instantiateRecord, v as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-DU_HLpg-.js";
 export { a as Checkout } from "./-private-sql1_mdx.js";
 export { k as createRequestSubscription, m as getPromiseState, l as getRequestState } from "./-leaked-BohmerbH.js";

package/dist/unpkg/dev/store/-private.js

@@ -1,6 +1,6 @@
 import '../types/request.js';
-import { i as isResourceKey, c as coerceId } from "../index-BZRBBa34.js";
-export { C as CacheHandler, R as RecordArrayManager, S as Store, j as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, g as assertPrivateCapabilities, b as assertPrivateStore, k as createLegacyManyArray, e as ensureStringId, f as fastPush, d as isPrivateStore, a as isRequestKey, l as log, m as logGroup, r as recordIdentifierFor, h as setRecordIdentifier, s as storeFor } from "../index-BZRBBa34.js";
+import { i as isResourceKey, c as coerceId } from "../index-DU_HLpg-.js";
+export { C as CacheHandler, R as RecordArrayManager, S as Store, j as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, g as assertPrivateCapabilities, b as assertPrivateStore, k as createLegacyManyArray, e as ensureStringId, f as fastPush, d as isPrivateStore, a as isRequestKey, l as log, m as logGroup, r as recordIdentifierFor, h as setRecordIdentifier, s as storeFor } from "../index-DU_HLpg-.js";
 function isNonEmptyString(str) {
   return Boolean(str && typeof str === 'string');
 }

package/dist/unpkg/dev/types/-private.js

@@ -1,5 +1,5 @@
 const name = "@warp-drive/core";
-const version = "5.9.0-alpha.17";
+const version = "5.9.0-alpha.19";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import

package/dist/unpkg/dev/types/runtime.js

@@ -31,4 +31,23 @@ function setLogging(config) {
   Object.assign(RuntimeConfig.debug, config);
   storage?.setItem('WarpDriveRuntimeConfig', JSON.stringify(RuntimeConfig));
 }
-export { getRuntimeConfig, setLogging };
+
+/**
+ * Explicitly declares whether requests may be served by Mirage (or another
+ * Pretender-based fetch mock) instead of a native `fetch` implementation.
+ *
+ * The `Fetch` request handler otherwise infers this via a heuristic (the
+ * presence of `window.server.pretender`, or `window.fetch` appearing to be
+ * patched), which can be wrong in either direction: some Mirage setups don't
+ * expose `window.server`, while some unrelated tools (APM agents, browser
+ * extensions) also patch `fetch`. Call this to override that heuristic:
+ * `true` to force Mirage-compatible behavior on, `false` to force it off.
+ *
+ * globalThis.setWarpDriveIsMaybeMirage(true);
+ *
+ */
+function setIsMaybeMirage(value) {
+  RuntimeConfig.mirage = value;
+  storage?.setItem('WarpDriveRuntimeConfig', JSON.stringify(RuntimeConfig));
+}
+export { getRuntimeConfig, setIsMaybeMirage, setLogging };

package/dist/unpkg/dev-deprecated/graph/-private.js

@@ -59,9 +59,14 @@ function assertValidRelationshipPayload(graph, op) {
     kind
   } = definition;
   if (payload.links) {
-    console.warn(`You pushed a record of type '${type}' with a relationship '${field}' configured as 'async: false'. You've included a link but no primary data, this may be an error in your payload. WarpDrive will treat this relationship as known-to-be-empty.`, isAsync || payload.data === null || !!payload.data || state.hasReceivedData, {
-      id: 'ds.store.push-link-for-sync-relationship'
-    });
+    // once JSON_API_CACHE_VALIDATION_ERRORS is active, this warning is instead
+    // the responsibility of the new document validator (see validateResourceRelationships
+    // in warp-drive-packages/json-api/src/-private/validator/1.1/7.2_resource-objects.ts)
+    {
+      console.warn(`You pushed a record of type '${type}' with a relationship '${field}' configured as 'async: false'. You've included a link but no primary data, this may be an error in your payload. WarpDrive will treat this relationship as known-to-be-empty.`, isAsync || payload.data === null || !!payload.data || state.hasReceivedData, {
+        id: 'ds.store.push-link-for-sync-relationship'
+      });
+    }
   } else if (payload.data) {
     if (kind === 'belongsTo') {
       (test => {
@@ -752,7 +757,7 @@ let assertInheritedSchema;
       errors.set('type', ` <---- should be '${definition.inverseType}'`);
     }
     if (definition.inverseKind !== meta.kind) {
-      errors.set('type', ` <---- should be '${definition.inverseKind}'`);
+      errors.set('kind', ` <---- should be '${definition.inverseKind}'`);
     }
     if (definition.inverseIsAsync !== meta.options.async) {
       errors.set('async', ` <---- should be ${definition.inverseIsAsync}`);
@@ -763,7 +768,12 @@ let assertInheritedSchema;
     if (definition.key !== meta.options.inverse) {
       errors.set('inverse', ` <---- should be '${definition.key}'`);
     }
-    if (definition.type !== meta.options.as) {
+    // `as` is only meaningful when `definition` itself is polymorphic (i.e. it
+    // points at an abstract type that `meta` is expected to implement). When
+    // `definition` isn't polymorphic, there's no abstract type for `meta` to
+    // declare `as` against, so `meta.options.as` is correctly absent - that's
+    // not an error to report.
+    if (definition.isPolymorphic && definition.type !== meta.options.as) {
       errors.set('as', ` <---- should be '${definition.type}'`);
     }
     return errors;
@@ -802,18 +812,6 @@ let assertInheritedSchema;
 
 `;
   }
-  function metaFrom(definition) {
-    return {
-      name: definition.key,
-      type: definition.type,
-      kind: definition.kind,
-      options: {
-        async: definition.isAsync,
-        polymorphic: definition.isPolymorphic,
-        inverse: definition.inverseKey
-      }
-    };
-  }
   function inverseMetaFrom(definition) {
     return {
       name: definition.inverseKey,
@@ -856,15 +854,18 @@ let assertInheritedSchema;
     });
   }
   assertInheritedSchema = function assertInheritedSchema(definition, type) {
-    const meta1 = metaFrom(definition);
+    // `definition` is the only source of truth we have here - there is no
+    // second, independently-declared schema available to diff it against.
+    // That means the only thing we can actually verify is internal: does
+    // `definition`'s own resolved inverse agree that this relationship is
+    // polymorphic? Every other field of `meta2` below (name/type/kind/async/
+    // inverse) is derived directly from `definition` itself, so comparing
+    // them back to `definition` can never disagree - only the polymorphic
+    // flag is independently meaningful, because `definitionWithPolymorphic`
+    // asserts what it *should* be rather than mirroring what it already is.
     const meta2 = inverseMetaFrom(definition);
-    const errors1 = validateSchema(inverseDefinition(definition), meta1);
     const errors2 = validateSchema(definitionWithPolymorphic(definition), meta2);
-    if (errors2.size === 0 && errors1.size > 0) {
-      throw new Error(`The schema for the relationship '${type}.${definition.key}' is not configured to satisfy '${definition.inverseType}' and thus cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}'\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${type}' should include:${printSchema(meta1, errors1)}`);
-    } else if (errors1.size > 0) {
-      throw new Error(`The schema for the relationship '${type}.${definition.key}' is not configured to satisfy '${definition.inverseType}' and thus cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}'\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${type}' should include:${printSchema(meta1, errors1)} and the relationships schema definition for '${definition.type}' should include:${printSchema(meta2, errors2)}`);
-    } else if (errors2.size > 0) {
+    if (errors2.size > 0) {
       throw new Error(`The schema for the relationship '${type}.${definition.key}' satisfies '${definition.inverseType}' but cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}' because that relationship is not polymorphic.\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${definition.type}' should include:${printSchema(meta2, errors2)}`);
     }
   };
@@ -1409,8 +1410,10 @@ function replaceRelatedRecord(graph, op, isRemote = false) {
   if (op.value === existingState) {
     // if we were empty before but now know we are empty this needs to be true
     state.hasReceivedData = true;
+
     // if this is a remote update we still sync
     if (isRemote) {
+      state.hasReceivedRemoteData = true;
       const {
         localState
       } = relationship;
@@ -1441,6 +1444,15 @@ function replaceRelatedRecord(graph, op, isRemote = false) {
   // update value to the new value
   relationship[prop] = op.value;
   state.hasReceivedData = true;
+  /**
+   * Local mutations never give us additional information about
+   * whether the relationship has received *remote* data. This is
+   * what `getRemoteRelationship` relies on to avoid reflecting
+   * local-only edits.
+   */
+  if (isRemote) {
+    state.hasReceivedRemoteData = true;
+  }
   state.isEmpty = op.value === null;
   state.isStale = false;
   state.hasFailedLoadAttempt = false;
@@ -2085,8 +2097,30 @@ function rollbackRelationship(graph, key, field, relationship) {
   }
 }
 function createState() {
+  {
+    {
+      if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) {
+        let hasReceivedData = false;
+        return {
+          get hasReceivedData() {
+            return hasReceivedData;
+          },
+          set hasReceivedData(value) {
+            hasReceivedData = value;
+          },
+          hasReceivedRemoteData: false,
+          isEmpty: true,
+          isStale: false,
+          hasFailedLoadAttempt: false,
+          shouldForceReload: false,
+          hasDematerializedInverse: false
+        };
+      }
+    }
+  }
   return {
     hasReceivedData: false,
+    hasReceivedRemoteData: false,
     isEmpty: true,
     isStale: false,
     hasFailedLoadAttempt: false,
@@ -2191,13 +2225,10 @@ function legacyGetResourceRelationshipData(source, getRemoteState) {
   source.accessed = true;
   let data;
   const payload = {};
-  if (getRemoteState && source.remoteState) {
-    data = source.remoteState;
-  } else if (!getRemoteState && source.localState) {
-    data = source.localState;
-  }
-  if ((getRemoteState && source.remoteState === null || source.localState === null) && source.state.hasReceivedData) {
-    data = null;
+  if (getRemoteState && (source.remoteState || source.state.hasReceivedRemoteData)) {
+    data = source.remoteState ?? null;
+  } else if (!getRemoteState && (source.localState || source.state.hasReceivedData)) {
+    data = source.localState ?? null;
   }
   if (source.links) {
     payload.links = source.links;
@@ -2411,7 +2442,6 @@ function updateRelationshipOperation(graph, op) {
   })(isHasMany(relationship) || isBelongsTo(relationship));
   const {
     definition,
-    state,
     identifier
   } = relationship;
   const {
@@ -2451,23 +2481,6 @@ function updateRelationshipOperation(graph, op) {
         value: payload.data ? graph.store.cacheKeyManager.upgradeIdentifier(payload.data) : null
       }, true);
     }
-  } else if (definition.isAsync === false && !state.hasReceivedData) {
-    hasRelationshipDataProperty = true;
-    if (isCollection) {
-      graph.update({
-        op: 'replaceRelatedRecords',
-        record: identifier,
-        field: op.field,
-        value: []
-      }, true);
-    } else {
-      graph.update({
-        op: 'replaceRelatedRecord',
-        record: identifier,
-        field: op.field,
-        value: null
-      }, true);
-    }
   }
   if (payload.links) {
     const originalLinks = relationship.links;
@@ -2477,9 +2490,10 @@ function updateRelationshipOperation(graph, op) {
       const currentLink = originalLinks && originalLinks.related ? _normalizeLink(originalLinks.related) : null;
       const currentLinkHref = currentLink ? currentLink.href : null;
       if (relatedLink && relatedLink.href && relatedLink.href !== currentLinkHref) {
-        console.warn(`You pushed a record of type '${identifier.type}' with a relationship '${definition.key}' configured as 'async: false'. You've included a link but no primary data, this may be an error in your payload. WarpDrive will treat this relationship as known-to-be-empty.`, definition.isAsync || state.hasReceivedData, {
-          id: 'ds.store.push-link-for-sync-relationship'
-        });
+        // Note: the equivalent warning for this case is issued eagerly (and with a more
+        // complete condition, since it also accounts for `payload.data` being present) by
+        // `assertValidRelationshipPayload` in `-utils.ts`, which always runs immediately
+        // before this operation in DEBUG builds. Warning here too would double-warn.
         (test => {
           if (!test) {
             throw new Error(`You have pushed a record of type '${identifier.type}' with '${definition.key}' as a link, but the value of that link is not a string.`);
@@ -2510,6 +2524,7 @@ function updateRelationshipOperation(graph, op) {
     // we don't need to notify here as the update op we pushed in above will notify once
     // membership is in the correct state.
     relationship.state.hasReceivedData = true;
+    relationship.state.hasReceivedRemoteData = true;
     relationship.state.isStale = false;
     relationship.state.hasDematerializedInverse = false;
     relationship.state.isEmpty = relationshipIsEmpty;