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

package/dist/unpkg/dev-deprecated/{index-Bu52tQ9I.js → index-BYFUHVPd.js}

@@ -2,6 +2,7 @@ import { d as defineGate, w as withSignalStore, n as notifyInternalSignal, p as
 import { EnableHydration, SkipCache, STRUCTURED } from './types/request.js';
 import { D as Destroy, a as Context, S as SOURCE, C as Checkout, b as Commit } from "./-private-3C1OkYtZ.js";
 import { isResourceSchema } from './types/schema/fields.js';
+import { setLogging, getRuntimeConfig, setIsMaybeMirage } from './types/runtime.js';
 import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./future-DUuPqyLj.js";
 import { getOrSetGlobal, peekTransient, setTransient, peekUniversalTransient, setUniversalTransient } from './types/-private.js';
 import { DefaultCachePolicy } from './store.js';
@@ -9,7 +10,6 @@ import { withBrand } from './request.js';
 import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_KEY_TYPE, DEBUG_CLIENT_ORIGINATED } from './types/identifier.js';
 import { dasherize } from './utils/string.js';
 import { g as getGlobalConfig } from "./runtime-DfhJzpZH.js";
-import { setLogging, getRuntimeConfig } from './types/runtime.js';
 import { RecordStore, Type } from './types/symbols.js';
 import * as _importSync20 from '@ember/object';
 function urlFromLink(link) {
@@ -7248,11 +7248,32 @@ function getBelongsToField(context) {
 }
 function setBelongsToField(context) {
   const {
+    field,
+    resourceKey,
     store
   } = context;
   const {
-    schema
+    schema,
+    cache
   } = store;
+
+  /**
+   * We currently only allow editing sync belongsTo relationships
+   * in PolarisMode
+   */
+  const isValidPolarisConfig = field.options.linksMode && !field.options.async;
+  if (!context.legacy && isValidPolarisConfig) {
+    const name = context.path.at(-1);
+    cache.mutate({
+      op: 'replaceRelatedRecord',
+      record: resourceKey,
+      field: name,
+      value: getResourceKey(context.value)
+    },
+    // @ts-expect-error
+    true);
+    return true;
+  }
   (test => {
     if (!test) {
       throw new Error(`Can only mutate belongsTo fields when the resource is in legacy mode`);
@@ -7261,6 +7282,12 @@ function setBelongsToField(context) {
   schema._kind('@legacy', 'belongsTo').set(store, context.record, context.resourceKey, context.field, context.value);
   return true;
 }
+function getResourceKey(record) {
+  if (!record) {
+    return null;
+  }
+  return recordIdentifierFor(record);
+}
 function getCollectionField(context) {
   entangleSignal(context.signals, context.record, context.path.at(-1), null);
   (test => {
@@ -7993,6 +8020,17 @@ function setSchemaObjectField(context) {
   // }
   return true;
 }
+
+/**
+ * A ReactiveResource context object passed to
+ * the get/set functions of a field kind implementation.
+ *
+ * This provides all the necessary information for
+ * the field kind to perform its operations.
+ *
+ * @internal
+ */
+
 const DefaultMode = {
   '@hash': {
     get: getHashField,
@@ -8288,6 +8326,9 @@ class ReactiveResource {
         if (prop === Destroy || prop === Checkout) {
           return true;
         }
+        if (prop === identityField?.name) {
+          return true;
+        }
         return fields.has(prop);
       },
       getOwnPropertyDescriptor(target, prop) {
@@ -8786,6 +8827,14 @@ const TypeField = {
     key: 'type'
   }
 };
+const IdentifierField = {
+  type: '@identity',
+  name: '$key',
+  kind: 'derived',
+  options: {
+    key: '^'
+  }
+};
 const DefaultIdentityField = {
   name: 'id',
   kind: '@id'
@@ -8974,6 +9023,7 @@ function withDefaults(schema) {
   // we add TypeField to the beginning so that it will
   // appear right next to the identity field
   schema.fields.unshift(TypeField);
+  schema.fields.unshift(IdentifierField);
   schema.fields.push(ConstructorField);
   return schema;
 }
@@ -9029,6 +9079,90 @@ function registerDerivations(schema) {
   schema.registerDerivation(fromIdentity);
   schema.registerDerivation(_constructor);
 }
+
+/**
+ * A relationship field capable of declaring `options.as`, marking it as a
+ * concrete implementation of an abstract polymorphic type.
+ */
+
+/**
+ * A relationship field contributed to an abstract type's schema, along with
+ * the name of the type that contributed it (either a concrete implementer,
+ * via `options.as`, or the abstract type's own schema), for use in assertion
+ * messages when two contributions disagree on shape.
+ */
+
+/**
+ * Reduces a field to a plain object with a fixed key order, covering every
+ * option any relationship-implementer field can declare, so two fields can
+ * be compared for exact equality via `JSON.stringify` regardless of the key
+ * order the schema author happened to write them in.
+ *
+ * `options.as` is included and is *not* special-cased: every contributor to
+ * a given field name on an abstract type - including the abstract type's
+ * own schema, if it has one - is expected to declare `as` equal to that
+ * abstract type's own name. This is redundant/self-referential for the
+ * abstract type's own schema, but required for consistency: relationship
+ * resolution elsewhere (e.g. `inverse` name-matching) does not itself
+ * validate `as`, so a field with a missing or incorrect `as` can otherwise
+ * be silently pulled into a relationship it never declared it implements.
+ */
+function comparableAbstractFieldShape(field) {
+  const {
+    kind,
+    name,
+    type,
+    sourceKey,
+    options
+  } = field;
+  return {
+    kind,
+    name,
+    type,
+    sourceKey,
+    options: {
+      as: options?.as,
+      async: options?.async,
+      inverse: options?.inverse,
+      polymorphic: options?.polymorphic,
+      linksMode: options?.linksMode,
+      resetOnRemoteUpdate: options?.resetOnRemoteUpdate,
+      arrayExtensions: options?.arrayExtensions
+    }
+  };
+}
+
+/**
+ * Asserts that two contributions to the same field name on an abstract
+ * polymorphic type - whether from two different concrete implementers, or
+ * from an implementer and the abstract type's own schema - declare an
+ * identical shape: `kind`, `type`, and every option, including `as` (which
+ * every contributor, the abstract type's own schema included, must declare
+ * equal to `abstractType`). A mismatch here (e.g. one implementer's field
+ * being a `hasMany` while another's is a `belongsTo`, the two disagreeing on
+ * `inverse`/`async`/`polymorphic`, or one omitting or misdeclaring `as`)
+ * cannot be resolved by picking one side arbitrarily, since that would
+ * silently leave whichever side lost the mismatch pointing at a relationship
+ * whose true shape differs from what its own schema declared.
+ */
+function assertConsistentAbstractFieldShape(abstractType, fieldName, existing, incoming) {
+  // This function exists solely to support the `assert()` call below - there
+  // is no other work here with an effect in production. Since `assert()`'s
+  // own babel-macro stripping only removes the call expression itself, not
+  // the (comparatively expensive, involving `JSON.stringify`) computation of
+  // its arguments, guard the whole body so none of it survives in production
+  // builds, matching how `assertPolymorphicType`/`assertInheritedSchema` and
+  // their call sites are gated in `assert-polymorphic-type.ts`.
+  {
+    const existingShape = comparableAbstractFieldShape(existing.field);
+    const incomingShape = comparableAbstractFieldShape(incoming.field);
+    (test => {
+      if (!test) {
+        throw new Error(`Expected the relationship '${fieldName}' on the abstract polymorphic type '${abstractType}' to be declared identically everywhere it is implemented (including 'options.as', which every contributor - the abstract type's own schema included - must declare equal to '${abstractType}'), but '${existing.source}' declares it as:\n\n${JSON.stringify(existingShape, null, 2)}\n\nwhile '${incoming.source}' declares it as:\n\n${JSON.stringify(incomingShape, null, 2)}\n\nAll concrete implementers of an abstract type - and the abstract type's own schema, if it has one - must declare an identical shape for any relationship field they share.`);
+      }
+    })(JSON.stringify(existingShape) === JSON.stringify(incomingShape));
+  }
+}
 /**
  * Wraps a derivation in a new function with Derivation signature but that looks
  * up the value in the cache before recomputing.
@@ -9068,6 +9202,18 @@ class SchemaService {
 
   /** @internal */
 
+  /**
+   * Tracks, per abstract type, the relationship fields that concrete
+   * implementers have contributed via `options.as`, along with the type
+   * that contributed each one (for assertion messages). This is
+   * independent of whatever schema (synthesized or user-registered)
+   * currently occupies `_schemas` for that type, so that these fields
+   * survive regardless of the order in which the abstract type's
+   * implementers and its own (optional) concrete schema are registered.
+   *
+   * @internal
+   */
+
   /** @internal */
 
   /** @internal */
@@ -9079,6 +9225,7 @@ class SchemaService {
     this._derivations = new Map();
     this._traits = new Map();
     this._modes = new Map();
+    this._abstractImplementerFields = new Map();
     this._extensions = {
       object: new Map(),
       array: new Map()
@@ -9174,6 +9321,7 @@ class SchemaService {
     const fields = new Map();
     const relationships = {};
     const attributes = {};
+    const abstractImplementations = [];
     for (const field of schema.fields) {
       (test => {
         if (!test) {
@@ -9187,6 +9335,31 @@ class SchemaService {
         attributes[field.name] = field;
       } else if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
         relationships[field.name] = field;
+        if (field.options?.as) {
+          abstractImplementations.push(field);
+        }
+      }
+    }
+
+    // This type may already be known as an abstract polymorphic type,
+    // implemented by other concrete types via `options.as`, from before it
+    // ever had a schema of its own (see `_registerAbstractTypeImplementation`).
+    // Carry those previously-contributed fields forward so that registering
+    // a "real" schema for the type - whenever that happens to occur - never
+    // erases the relationships its implementers depend on.
+    const implementerFields = this._abstractImplementerFields.get(schema.type);
+    if (implementerFields) {
+      for (const [name, contribution] of implementerFields) {
+        const ownField = fields.get(name);
+        if (!ownField) {
+          fields.set(name, contribution.field);
+          relationships[name] = contribution.field;
+        } else {
+          assertConsistentAbstractFieldShape(schema.type, name, contribution, {
+            field: ownField,
+            source: schema.type
+          });
+        }
       }
     }
     const cacheFields = null;
@@ -9205,6 +9378,101 @@ class SchemaService {
       internalSchema.cacheFields = getCacheFields(internalSchema);
     }
     this._schemas.set(schema.type, internalSchema);
+
+    // A relationship field's `as` option marks it as a valid concrete
+    // implementer of an abstract polymorphic type (e.g. `as: 'commentable'`).
+    // That abstract type may never be given its own schema by the user - it
+    // may exist only to be implemented by concrete types like this one - or
+    // it may already have (or later receive) a schema of its own, e.g. if it
+    // turns out to also be a real, directly-resolvable resource. Either way,
+    // ensure it has a schema with this field present, so that it behaves
+    // like any other registered resource (`hasResource`, `fields`, etc.)
+    // instead of requiring special-casing wherever abstract relationship
+    // types are resolved.
+    for (const field of abstractImplementations) {
+      this._registerAbstractTypeImplementation(field, schema.type);
+    }
+  }
+
+  /** @internal */
+  _registerAbstractTypeImplementation(field, implementer) {
+    const abstractType = field.options.as;
+    let implementerFields = this._abstractImplementerFields.get(abstractType);
+    if (!implementerFields) {
+      implementerFields = new Map();
+      this._abstractImplementerFields.set(abstractType, implementerFields);
+    }
+
+    // Unlike the original approach this replaced, `as` is *not* stripped here:
+    // the field as synthesized onto the abstract type's own schema keeps
+    // `options.as === abstractType`, redundant/self-referential as that is.
+    // This keeps every contributor - implementers and the abstract type's
+    // own schema alike - declaring the same thing, which is what
+    // `assertConsistentAbstractFieldShape` checks, and it is also what lets
+    // `assertPolymorphicType` (which reads a field's declared `as` off
+    // whatever `schema.fields()` serves for its type) correctly permit the
+    // abstract type itself to be pushed directly into this relationship.
+    const abstractField = {
+      ...field
+    };
+    const contribution = {
+      field: abstractField,
+      source: implementer
+    };
+
+    // all concrete implementations of an abstract type are required to
+    // share the same shape for the field that implements it, so the first
+    // one registered is as good a canonical source as any - but a later,
+    // differently-shaped one is almost certainly a mistake rather than an
+    // intentional override, so we catch it rather than silently ignoring it.
+    const existingImplementer = implementerFields.get(field.name);
+    if (existingImplementer) {
+      {
+        assertConsistentAbstractFieldShape(abstractType, field.name, existingImplementer, contribution);
+      }
+      return;
+    }
+    implementerFields.set(field.name, contribution);
+    let abstractSchema = this._schemas.get(abstractType);
+    if (!abstractSchema) {
+      abstractSchema = {
+        original: {
+          legacy: true,
+          identity: {
+            kind: '@id',
+            name: 'id'
+          },
+          type: abstractType,
+          fields: []
+        },
+        finalized: true,
+        fields: new Map(),
+        cacheFields: new Map(),
+        relationships: {},
+        attributes: {},
+        traits: new Set()
+      };
+      this._schemas.set(abstractType, abstractSchema);
+    }
+    const existingAbstractField = abstractSchema.fields.get(field.name);
+    if (existingAbstractField) {
+      {
+        assertConsistentAbstractFieldShape(abstractType, field.name, {
+          field: existingAbstractField,
+          source: abstractType
+        }, contribution);
+      }
+      return;
+    }
+    abstractSchema.fields.set(field.name, abstractField);
+    abstractSchema.relationships[field.name] = abstractField;
+
+    // If the schema is mid-finalization (traits pending), finalizeResource
+    // will recompute cacheFields from the current `fields` map anyway; avoid
+    // doing so prematurely from a partially-resolved set of fields.
+    if (abstractSchema.finalized) {
+      abstractSchema.cacheFields = getCacheFields(abstractSchema);
+    }
   }
 
   /**
@@ -9490,9 +9758,33 @@ function cloneResponse(response, overrides) {
   const props = cloneResponseProperties(response);
   return new Response(response.body, Object.assign(props, overrides));
 }
+function withDateHeader(response) {
+  const headers = new Headers(response.headers);
+  headers.set('date', new Date().toUTCString());
+  return cloneResponse(response, {
+    headers
+  });
+}
+
+// Detects Mirage (or another Pretender-based fetch mock), whose `Response`
+// may (unlike a spec-compliant `fetch()`, whose Response headers are always
+// immutable) allow header mutation and may not support streaming reads.
+//
+// This is inherently a heuristic - many legitimate tools (APM/monitoring
+// agents, browser extensions, polyfills) also patch `window.fetch`, and can
+// produce false positives. `setWarpDriveIsMaybeMirage(value)` lets an app
+// declare the answer explicitly (`true` or `false`), overriding the
+// heuristic in either direction; leave it unset to keep the default
+// detection. See https://github.com/warp-drive-data/warp-drive/issues/10535
 let IS_MAYBE_MIRAGE = () => false;
 {
-  IS_MAYBE_MIRAGE = () => Boolean(typeof window !== 'undefined' && (window.server?.pretender || window.fetch.toString().replace(/\s+/g, '') !== 'function fetch() { [native code] }'.replace(/\s+/g, '')));
+  IS_MAYBE_MIRAGE = () => {
+    const override = getRuntimeConfig().mirage;
+    if (override !== undefined) {
+      return override;
+    }
+    return Boolean(typeof window !== 'undefined' && (window.server?.pretender || window.fetch.toString().replace(/\s+/g, '') !== 'function fetch() { [native code] }'.replace(/\s+/g, '')));
+  };
 }
 const MUTATION_OPS = new Set(['updateRecord', 'createRecord', 'deleteRecord']);
 const ERROR_STATUS_CODE_FOR = new Map([[400, 'Bad Request'], [401, 'Unauthorized'], [402, 'Payment Required'], [403, 'Forbidden'], [404, 'Not Found'], [405, 'Method Not Allowed'], [406, 'Not Acceptable'], [407, 'Proxy Authentication Required'], [408, 'Request Timeout'], [409, 'Conflict'], [410, 'Gone'], [411, 'Length Required'], [412, 'Precondition Failed'], [413, 'Payload Too Large'], [414, 'URI Too Long'], [415, 'Unsupported Media Type'], [416, 'Range Not Satisfiable'], [417, 'Expectation Failed'], [419, 'Page Expired'], [420, 'Enhance Your Calm'], [421, 'Misdirected Request'], [422, 'Unprocessable Entity'], [423, 'Locked'], [424, 'Failed Dependency'], [425, 'Too Early'], [426, 'Upgrade Required'], [428, 'Precondition Required'], [429, 'Too Many Requests'], [430, 'Request Header Fields Too Large'], [431, 'Request Header Fields Too Large'], [450, 'Blocked By Windows Parental Controls'], [451, 'Unavailable For Legal Reasons'], [500, 'Internal Server Error'], [501, 'Not Implemented'], [502, 'Bad Gateway'], [503, 'Service Unavailable'], [504, 'Gateway Timeout'], [505, 'HTTP Version Not Supported'], [506, 'Variant Also Negotiates'], [507, 'Insufficient Storage'], [508, 'Loop Detected'], [509, 'Bandwidth Limit Exceeded'], [510, 'Not Extended'], [511, 'Network Authentication Required']]);
@@ -9544,13 +9836,15 @@ const Fetch = {
     const isMutationOp = Boolean(op && MUTATION_OPS.has(op));
     if (!isError && !isMutationOp && response.status !== 204 && !response.headers.has('date')) {
       if (IS_MAYBE_MIRAGE()) {
-        response.headers.set('date', new Date().toUTCString());
+        try {
+          response.headers.set('date', new Date().toUTCString());
+        } catch {
+          // IS_MAYBE_MIRAGE() was a false positive, or the mock's headers
+          // are (correctly) immutable - fall back to cloning.
+          response = withDateHeader(response);
+        }
       } else {
-        const headers = new Headers(response.headers);
-        headers.set('date', new Date().toUTCString());
-        response = cloneResponse(response, {
-          headers
-        });
+        response = withDateHeader(response);
       }
     }
     context.setResponse(response);
@@ -9945,6 +10239,12 @@ class RequestManager {
   globalThis.getWarpDriveRuntimeConfig = getRuntimeConfig;
 }
 
+// Mirage (or another Pretender-based fetch mock) may be used outside of a
+// `TESTING` build (e.g. `ember serve` in dev mode), so this override is
+// exposed unconditionally rather than gated to the `TESTING` env.
+// @ts-expect-error adding to globalThis
+globalThis.setWarpDriveIsMaybeMirage = setIsMaybeMirage;
+
 /**
  * Options for setting up a Store instance with `useRecommendedStore`.
  */
@@ -9965,7 +10265,29 @@ class RequestManager {
  */
 function useRecommendedStore(options, StoreKlass = Store) {
   return class AppStore extends StoreKlass {
-    requestManager = new RequestManager().use([...(options.handlers ?? []), Fetch]).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 handlers = typeof options.handlers === 'function' ? options.handlers(this) : options.handlers ?? [];
+            requestManager = new RequestManager().use([...handlers, Fetch]).useCache(CacheHandler);
+          }
+          return requestManager;
+        },
+        set: value => {
+          requestManager = value;
+        }
+      });
+    }
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,
       // 15 minutes

package/dist/unpkg/dev-deprecated/index.js

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

package/dist/unpkg/dev-deprecated/reactive.js

@@ -1,3 +1,3 @@
-export { u as SchemaService, p as checkout, y as commit, v as fromIdentity, q as instantiateRecord, x as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-Bu52tQ9I.js";
+export { u as SchemaService, p as checkout, y as commit, v as fromIdentity, q as instantiateRecord, x as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-BYFUHVPd.js";
 export { C as Checkout } from "./-private-3C1OkYtZ.js";
 export { c as createRequestSubscription, a as getPromiseState, g as getRequestState } from "./-leaked-C40gfiH-.js";

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

@@ -1 +1 @@
-export { C as CacheHandler, R as RecordArrayManager, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, l as createLegacyManyArray, e as ensureStringId, f as fastPush, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, r as recordIdentifierFor, j as setRecordIdentifier, s as storeFor } from "../index-Bu52tQ9I.js";
+export { C as CacheHandler, R as RecordArrayManager, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, l as createLegacyManyArray, e as ensureStringId, f as fastPush, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, r as recordIdentifierFor, j as setRecordIdentifier, s as storeFor } from "../index-BYFUHVPd.js";

package/dist/unpkg/dev-deprecated/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-deprecated/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/prod/{-leaked-BHLmJyaw.js → -leaked-DgjQ5X55.js}

@@ -1,5 +1,5 @@
 import { peekTransient, getOrSetGlobal, setTransient } from './types/-private.js';
-import { b as getPromiseResult, s as setPromiseResult } from "./promise-cache-DIT8Ypjq.js";
+import { g as getPromiseResult, a as setPromiseResult } from "./promise-cache-DUblkX-U.js";
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
@@ -1673,4 +1673,4 @@ function getPromiseState(promise) {
   }
   return state;
 }
-export { ARRAY_SIGNAL as A, DISPOSE as D, OBJECT_SIGNAL as O, Signals as S, withSignalStore as a, createInternalSignal as b, consumeInternalSignal as c, defineGate as d, createSignalDescriptor as e, defineSignal as f, getOrCreateInternalSignal as g, entangleSignal as h, entangleInitiallyStaleSignal as i, createInternalMemo as j, createRequestSubscription as k, getRequestState as l, getPromiseState as m, notifyInternalSignal as n, defineNonEnumerableSignal as o, peekInternalSignal as p, makeInitializer as q, signal as r, setupSignals as s, waitFor as t, gate as u, memoized as v, willSyncFlushWatchers as w };
+export { ARRAY_SIGNAL as A, DISPOSE as D, OBJECT_SIGNAL as O, Signals as S, willSyncFlushWatchers as a, createInternalSignal as b, consumeInternalSignal as c, defineGate as d, createSignalDescriptor as e, defineSignal as f, getOrCreateInternalSignal as g, entangleSignal as h, entangleInitiallyStaleSignal as i, createInternalMemo as j, createRequestSubscription as k, getRequestState as l, getPromiseState as m, notifyInternalSignal as n, defineNonEnumerableSignal as o, peekInternalSignal as p, makeInitializer as q, signal as r, setupSignals as s, waitFor as t, gate as u, memoized as v, withSignalStore as w };

package/dist/unpkg/prod/configure.js

@@ -1,2 +1,2 @@
-export { s as setupSignals } from "./-leaked-BHLmJyaw.js";
+export { s as setupSignals } from "./-leaked-DgjQ5X55.js";
 import './types/-private.js';

package/dist/unpkg/prod/graph/-private.js

@@ -789,8 +789,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;
@@ -813,6 +815,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;
@@ -1206,6 +1217,7 @@ function rollbackRelationship(graph, key, field, relationship) {
 function createState() {
   return {
     hasReceivedData: false,
+    hasReceivedRemoteData: false,
     isEmpty: true,
     isStale: false,
     hasFailedLoadAttempt: false,
@@ -1310,13 +1322,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;
@@ -1493,7 +1502,6 @@ function updateRelationshipOperation(graph, op) {
   const relationship = graph.get(op.record, op.field);
   const {
     definition,
-    state,
     identifier
   } = relationship;
   const {
@@ -1528,23 +1536,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;
@@ -1579,6 +1570,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;