@warp-drive/core 5.8.0-alpha.4 → 5.8.0-alpha.41

package/dist/{context-C_7OLieY.js → future-BKkJJkj7.js}

@@ -1,4 +1,4 @@
-import { STRUCTURED, IS_FUTURE, SkipCache } from './types/request.js';
+import { SkipCache, STRUCTURED, IS_FUTURE } from './types/request.js';
 import { getOrSetGlobal, getOrSetUniversal } from './types/-private.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const BODY_TYPES = {
@@ -233,6 +233,179 @@ function assertValidRequest(request, isTopLevel) {
     }
   }
 }
+function upgradeHeaders(headers) {
+  headers.clone = () => {
+    return new Headers(headers);
+  };
+  headers.toJSON = () => {
+    return Array.from(headers);
+  };
+  return headers;
+}
+function cloneResponseProperties(response) {
+  const {
+    headers,
+    ok,
+    redirected,
+    status,
+    statusText,
+    type,
+    url
+  } = response;
+  upgradeHeaders(headers);
+  return {
+    headers: headers,
+    ok,
+    redirected,
+    status,
+    statusText,
+    type,
+    url
+  };
+}
+class ContextOwner {
+  hasSetStream = false;
+  hasSetResponse = false;
+  hasSubscribers = false;
+  stream = createDeferred();
+  response = null;
+  nextCalled = 0;
+  constructor(request, god, isRoot = false) {
+    this.isRoot = isRoot;
+    this.requestId = god.id;
+    this.controller = request.controller || god.controller;
+    this.stream.promise.sizeHint = 0;
+    if (request.controller) {
+      if (request.controller !== god.controller) {
+        god.controller.signal.addEventListener('abort', () => {
+          this.controller.abort(god.controller.signal.reason);
+        });
+      }
+      delete request.controller;
+    }
+    let enhancedRequest = Object.assign({
+      signal: this.controller.signal
+    }, request);
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      if (!request?.cacheOptions?.[SkipCache]) {
+        request = deepFreeze(request);
+        enhancedRequest = deepFreeze(enhancedRequest);
+      }
+    } else {
+      if (request.headers) {
+        upgradeHeaders(request.headers);
+      }
+    }
+    this.enhancedRequest = enhancedRequest;
+    this.request = request;
+    this.god = god;
+    this.stream.promise = this.stream.promise.then(stream => {
+      if (this.god.stream === stream && this.hasSubscribers) {
+        this.god.stream = null;
+      }
+      return stream;
+    });
+  }
+  get hasRequestedStream() {
+    return this.god.hasRequestedStream;
+  }
+  getResponse() {
+    if (this.hasSetResponse) {
+      return this.response;
+    }
+    if (this.nextCalled === 1) {
+      return this.god.response;
+    }
+    return null;
+  }
+  getStream() {
+    if (this.isRoot) {
+      this.god.hasRequestedStream = true;
+    }
+    if (!this.hasSetResponse) {
+      const hint = this.god.response?.headers?.get('content-length');
+      this.stream.promise.sizeHint = hint ? parseInt(hint, 10) : 0;
+    }
+    this.hasSubscribers = true;
+    return this.stream.promise;
+  }
+  abort(reason) {
+    this.controller.abort(reason);
+  }
+  setStream(stream) {
+    if (!this.hasSetStream) {
+      this.hasSetStream = true;
+      if (!(stream instanceof Promise)) {
+        this.god.stream = stream;
+      }
+      // @ts-expect-error
+      this.stream.resolve(stream);
+    }
+  }
+  resolveStream() {
+    this.setStream(this.nextCalled === 1 ? this.god.stream : null);
+  }
+  setResponse(response) {
+    if (this.hasSetResponse) {
+      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+        throw new Error(`Cannot setResponse when a response has already been set`);
+      }
+      return;
+    }
+    this.hasSetResponse = true;
+    if (response instanceof Response) {
+      // TODO potentially avoid cloning in prod
+      let responseData = cloneResponseProperties(response);
+      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+        responseData = deepFreeze(responseData);
+      }
+      this.response = responseData;
+      this.god.response = responseData;
+      const sizeHint = response.headers?.get('content-length');
+      this.stream.promise.sizeHint = sizeHint ? parseInt(sizeHint, 10) : 0;
+    } else {
+      this.response = response;
+      this.god.response = response;
+    }
+  }
+}
+class Context {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  constructor(owner, isCacheHandler) {
+    this.id = owner.requestId;
+    this.___owner = owner;
+    this.request = owner.enhancedRequest;
+    this._isCacheHandler = isCacheHandler;
+    this._finalized = false;
+  }
+  setStream(stream) {
+    this.___owner.setStream(stream);
+  }
+  setResponse(response) {
+    this.___owner.setResponse(response);
+  }
+  setIdentifier(identifier) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`setIdentifier may only be used synchronously from a CacheHandler`);
+      }
+    })(identifier && this._isCacheHandler && !this._finalized) : {};
+    this.___owner.god.identifier = identifier;
+  }
+  get hasRequestedStream() {
+    return this.___owner.hasRequestedStream;
+  }
+
+  /** @private */
+  _finalize() {
+    this._finalized = true;
+  }
+}
 const PromiseCache = getOrSetUniversal('PromiseCache', new WeakMap());
 const RequestMap = getOrSetUniversal('RequestMap', new Map());
 function setRequestResult(requestId, result) {
@@ -502,177 +675,4 @@ function createFuture(owner) {
   deferred.promise = promise;
   return deferred;
 }
-function upgradeHeaders(headers) {
-  headers.clone = () => {
-    return new Headers(headers);
-  };
-  headers.toJSON = () => {
-    return Array.from(headers);
-  };
-  return headers;
-}
-function cloneResponseProperties(response) {
-  const {
-    headers,
-    ok,
-    redirected,
-    status,
-    statusText,
-    type,
-    url
-  } = response;
-  upgradeHeaders(headers);
-  return {
-    headers: headers,
-    ok,
-    redirected,
-    status,
-    statusText,
-    type,
-    url
-  };
-}
-class ContextOwner {
-  hasSetStream = false;
-  hasSetResponse = false;
-  hasSubscribers = false;
-  stream = createDeferred();
-  response = null;
-  nextCalled = 0;
-  constructor(request, god, isRoot = false) {
-    this.isRoot = isRoot;
-    this.requestId = god.id;
-    this.controller = request.controller || god.controller;
-    this.stream.promise.sizeHint = 0;
-    if (request.controller) {
-      if (request.controller !== god.controller) {
-        god.controller.signal.addEventListener('abort', () => {
-          this.controller.abort(god.controller.signal.reason);
-        });
-      }
-      delete request.controller;
-    }
-    let enhancedRequest = Object.assign({
-      signal: this.controller.signal
-    }, request);
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      if (!request?.cacheOptions?.[SkipCache]) {
-        request = deepFreeze(request);
-        enhancedRequest = deepFreeze(enhancedRequest);
-      }
-    } else {
-      if (request.headers) {
-        upgradeHeaders(request.headers);
-      }
-    }
-    this.enhancedRequest = enhancedRequest;
-    this.request = request;
-    this.god = god;
-    this.stream.promise = this.stream.promise.then(stream => {
-      if (this.god.stream === stream && this.hasSubscribers) {
-        this.god.stream = null;
-      }
-      return stream;
-    });
-  }
-  get hasRequestedStream() {
-    return this.god.hasRequestedStream;
-  }
-  getResponse() {
-    if (this.hasSetResponse) {
-      return this.response;
-    }
-    if (this.nextCalled === 1) {
-      return this.god.response;
-    }
-    return null;
-  }
-  getStream() {
-    if (this.isRoot) {
-      this.god.hasRequestedStream = true;
-    }
-    if (!this.hasSetResponse) {
-      const hint = this.god.response?.headers?.get('content-length');
-      this.stream.promise.sizeHint = hint ? parseInt(hint, 10) : 0;
-    }
-    this.hasSubscribers = true;
-    return this.stream.promise;
-  }
-  abort(reason) {
-    this.controller.abort(reason);
-  }
-  setStream(stream) {
-    if (!this.hasSetStream) {
-      this.hasSetStream = true;
-      if (!(stream instanceof Promise)) {
-        this.god.stream = stream;
-      }
-      // @ts-expect-error
-      this.stream.resolve(stream);
-    }
-  }
-  resolveStream() {
-    this.setStream(this.nextCalled === 1 ? this.god.stream : null);
-  }
-  setResponse(response) {
-    if (this.hasSetResponse) {
-      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-        throw new Error(`Cannot setResponse when a response has already been set`);
-      }
-      return;
-    }
-    this.hasSetResponse = true;
-    if (response instanceof Response) {
-      // TODO potentially avoid cloning in prod
-      let responseData = cloneResponseProperties(response);
-      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-        responseData = deepFreeze(responseData);
-      }
-      this.response = responseData;
-      this.god.response = responseData;
-      const sizeHint = response.headers?.get('content-length');
-      this.stream.promise.sizeHint = sizeHint ? parseInt(sizeHint, 10) : 0;
-    } else {
-      this.response = response;
-      this.god.response = response;
-    }
-  }
-}
-class Context {
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  constructor(owner, isCacheHandler) {
-    this.id = owner.requestId;
-    this.___owner = owner;
-    this.request = owner.enhancedRequest;
-    this._isCacheHandler = isCacheHandler;
-    this._finalized = false;
-  }
-  setStream(stream) {
-    this.___owner.setStream(stream);
-  }
-  setResponse(response) {
-    this.___owner.setResponse(response);
-  }
-  setIdentifier(identifier) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`setIdentifier may only be used synchronously from a CacheHandler`);
-      }
-    })(identifier && this._isCacheHandler && !this._finalized) : {};
-    this.___owner.god.identifier = identifier;
-  }
-  get hasRequestedStream() {
-    return this.___owner.hasRequestedStream;
-  }
-
-  /** @private */
-  _finalize() {
-    this._finalized = true;
-  }
-}
 export { IS_CACHE_HANDLER as I, cloneResponseProperties as a, assertValidRequest as b, createDeferred as c, getRequestResult as d, executeNextHandler as e, clearRequestResult as f, getPromiseResult as g, setPromiseResult as s, upgradePromise as u };

package/dist/graph/-private.js

@@ -349,6 +349,7 @@ function implicitKeyFor(type, key) {
 function syncMeta(definition, inverseDefinition) {
   definition.inverseKind = inverseDefinition.kind;
   definition.inverseKey = inverseDefinition.key;
+  definition.inverseName = inverseDefinition.name;
   definition.inverseType = inverseDefinition.type;
   definition.inverseIsAsync = inverseDefinition.isAsync;
   definition.inverseIsCollection = inverseDefinition.isCollection;
@@ -366,7 +367,8 @@ function upgradeMeta(meta) {
   const niceMeta = {};
   const options = meta.options;
   niceMeta.kind = meta.kind;
-  niceMeta.key = meta.name;
+  niceMeta.key = meta.sourceKey ?? meta.name;
+  niceMeta.name = meta.name;
   niceMeta.type = meta.type;
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
@@ -379,6 +381,7 @@ function upgradeMeta(meta) {
   niceMeta.isPolymorphic = options && !!options.polymorphic;
   niceMeta.isLinksMode = options.linksMode ?? false;
   niceMeta.inverseKey = options && options.inverse || STR_LATER;
+  niceMeta.inverseName = options && options.inverse || STR_LATER;
   niceMeta.inverseType = STR_LATER;
   niceMeta.inverseIsAsync = BOOL_LATER;
   niceMeta.inverseIsImplicit = options && options.inverse === null || BOOL_LATER;
@@ -502,12 +505,13 @@ function upgradeDefinition(graph, key, propertyName, isImplicit = false) {
     }
   })(!isImplicit) : {};
   const relationships = storeWrapper.schema.fields(key);
+  const relationshipsBySourceKey = storeWrapper.schema.cacheFields?.(key) ?? relationships;
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
       throw new Error(`Expected to have a relationship definition for ${type} but none was found.`);
     }
   })(relationships) : {};
-  const meta = relationships.get(propertyName);
+  const meta = relationshipsBySourceKey.get(propertyName);
   if (!meta) {
     // TODO potentially we should just be permissive here since this is an implicit relationship
     // and not require the lookup table to be populated
@@ -564,6 +568,7 @@ function upgradeDefinition(graph, key, propertyName, isImplicit = false) {
         kind: 'belongsTo',
         // this must be updated when we find the first belongsTo or hasMany definition that matches
         key: definition.inverseKey,
+        name: definition.inverseName,
         type: type,
         isAsync: false,
         // this must be updated when we find the first belongsTo or hasMany definition that matches
@@ -578,6 +583,7 @@ function upgradeDefinition(graph, key, propertyName, isImplicit = false) {
       inverseDefinition = null;
     } else {
       // CASE: We have an explicit inverse or were able to resolve one
+      // for the inverse we use "name" for lookup not "sourceKey"
       const inverseDefinitions = storeWrapper.schema.fields({
         type: inverseType
       });
@@ -710,7 +716,8 @@ function upgradeDefinition(graph, key, propertyName, isImplicit = false) {
   return info;
 }
 function inverseForRelationship(store, resourceKey, key) {
-  const definition = store.schema.fields(resourceKey).get(key);
+  const fields = store.schema.fields(resourceKey);
+  const definition = fields.get(key);
   if (!definition) {
     return null;
   }
@@ -819,6 +826,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
   function inverseDefinition(definition) {
     return {
       key: definition.inverseKey,
+      name: definition.inverseName,
       type: definition.inverseType,
       kind: definition.inverseKind,
       isAsync: definition.inverseIsAsync,
@@ -827,6 +835,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       isCollection: definition.inverseIsCollection,
       isImplicit: definition.inverseIsImplicit,
       inverseKey: definition.key,
+      inverseName: definition.name,
       inverseType: definition.type,
       inverseKind: definition.kind,
       inverseIsAsync: definition.isAsync,
@@ -2151,6 +2160,7 @@ function createCollectionEdge(definition, identifier) {
     _diff: undefined
   };
 }
+const cp = structuredClone;
 function legacyGetCollectionRelationshipData(source, getRemoteState) {
   source.accessed = true;
   const payload = {};
@@ -2158,10 +2168,10 @@ function legacyGetCollectionRelationshipData(source, getRemoteState) {
     payload.data = getRemoteState ? source.remoteState.slice() : computeLocalState(source);
   }
   if (source.links) {
-    payload.links = source.links;
+    payload.links = cp(source.links);
   }
   if (source.meta) {
-    payload.meta = source.meta;
+    payload.meta = cp(source.meta);
   }
   return payload;
 }
@@ -3331,7 +3341,7 @@ function isReordered(relationship) {
 /**
 Provides a performance tuned normalized graph for intelligently managing relationships between resources based on identity
 
-While this Graph is abstract, it currently is a private implementation required as a peer-dependency by the {JSON:API} Cache Implementation.
+While this Graph is abstract, it currently is a private implementation required as a peer-dependency by the {json:api} Cache Implementation.
 
 We intend to make this Graph public API after some additional iteration during the 5.x timeframe, until then all APIs should be considered experimental and unstable, not fit for direct application or 3rd party library usage.