@ember-data/store 5.3.0-alpha.4 → 5.3.0-alpha.5

package/addon/-private.js

@@ -1 +1 @@
-export { f as AdapterPopulatedRecordArray, C as CacheHandler, h as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, g as SOURCE, S as Store, _ as _clearCaches, e as coerceId, j as fastPush, i as isStableIdentifier, n as notifyArray, p as peekCache, r as recordIdentifierFor, k as removeRecordDataFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./store-service-4e1e7840";
+export { f as AdapterPopulatedRecordArray, C as CacheHandler, h as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, g as SOURCE, S as Store, m as StoreMap, _ as _clearCaches, e as coerceId, j as fastPush, i as isStableIdentifier, n as notifyArray, p as peekCache, r as recordIdentifierFor, k as removeRecordDataFor, o as setCacheFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, l as setRecordIdentifier, s as storeFor } from "./store-service-7750e2f0";

package/addon/index.js

@@ -1 +1 @@
-export { C as CacheHandler, S as default, r as recordIdentifierFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./store-service-4e1e7840";
+export { C as CacheHandler, S as default, r as recordIdentifierFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./store-service-7750e2f0";

package/addon/{store-service-4e1e7840.js → store-service-7750e2f0.js}

@@ -1,8 +1,8 @@
-import { getOwner, setOwner } from '@ember/application';
+import { macroCondition, getOwnConfig } from '@embroider/macros';
+import { getOwner } from '@ember/application';
 import { assert, warn } from '@ember/debug';
 import EmberObject from '@ember/object';
 import { _backburner } from '@ember/runloop';
-import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
 import { tracked } from '@glimmer/tracking';
 import { dasherize } from '@ember/string';
 import { addToTransaction, subscribe, addTransactionCB } from '@ember-data/tracking/-private';
@@ -354,26 +354,6 @@ function copyDocumentProperties(target, source) {
   }
 }
 
-/*
- * Returns the Cache instance associated with a given
- * Model or Identifier
- */
-
-const CacheForIdentifierCache = new Map();
-function setCacheFor(identifier, cache) {
-  assert(`Illegal set of identifier`, !CacheForIdentifierCache.has(identifier) || CacheForIdentifierCache.get(identifier) === cache);
-  CacheForIdentifierCache.set(identifier, cache);
-}
-function removeRecordDataFor(identifier) {
-  CacheForIdentifierCache.delete(identifier);
-}
-function peekCache(instance) {
-  if (CacheForIdentifierCache.has(instance)) {
-    return CacheForIdentifierCache.get(instance);
-  }
-  return null;
-}
-
 /**
   @module @ember-data/store
 */
@@ -1335,14 +1315,25 @@ class CacheStoreWrapper {
     this._pendingNotifies.delete(identifier);
   }
 }
-let _peekGraph;
-if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
-  let __peekGraph;
-  _peekGraph = wrapper => {
-    let a = importSync('@ember-data/graph/-private').peekGraph;
-    __peekGraph = __peekGraph || a;
-    return __peekGraph(wrapper);
-  };
+
+/*
+ * Returns the Cache instance associated with a given
+ * Model or Identifier
+ */
+
+const CacheForIdentifierCache = new Map();
+function setCacheFor(identifier, cache) {
+  assert(`Illegal set of identifier`, !CacheForIdentifierCache.has(identifier) || CacheForIdentifierCache.get(identifier) === cache);
+  CacheForIdentifierCache.set(identifier, cache);
+}
+function removeRecordDataFor(identifier) {
+  CacheForIdentifierCache.delete(identifier);
+}
+function peekCache(instance) {
+  if (CacheForIdentifierCache.has(instance)) {
+    return CacheForIdentifierCache.get(instance);
+  }
+  return null;
 }
 
 /**
@@ -1441,11 +1432,8 @@ class InstanceCache {
 
       /*
       TODO @runspired consider adding this to make polymorphism even nicer
-      if (HAS_GRAPH_PACKAGE) {
       if (identifier.type !== matchedIdentifier.type) {
-        const graphFor = importSync('@ember-data/graph/-private').graphFor;
-        graphFor(this).registerPolymorphicType(identifier.type, matchedIdentifier.type);
-      }
+      this.store._graph?.registerPolymorphicType(identifier.type, matchedIdentifier.type);
       }
       */
 
@@ -1507,12 +1495,7 @@ class InstanceCache {
   disconnect(identifier) {
     const record = this.__instances.record.get(identifier);
     assert('Cannot destroy record while it is still materialized', !record || record.isDestroyed || record.isDestroying);
-    if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
-      let graph = _peekGraph(this.store);
-      if (graph) {
-        graph.remove(identifier);
-      }
-    }
+    this.store._graph?.remove(identifier);
     this.store.identifierCache.forgetRecordIdentifier(identifier);
     removeRecordDataFor(identifier);
     this.store._requestCache._clearEntries(identifier);
@@ -1712,84 +1695,6 @@ function _clearCaches() {
   StoreMap.clear();
   CacheForIdentifierCache.clear();
 }
-let _modelForMixin;
-if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-  let _found;
-  _modelForMixin = function () {
-    if (!_found) {
-      _found = importSync('@ember-data/model/-private')._modelForMixin;
-    }
-    return _found(...arguments);
-  };
-}
-class DSModelSchemaDefinitionService {
-  constructor(store) {
-    this.store = store;
-    this._relationshipsDefCache = Object.create(null);
-    this._attributesDefCache = Object.create(null);
-  }
-
-  // Following the existing RD implementation
-  attributesDefinitionFor(identifier) {
-    let modelName, attributes;
-    modelName = identifier.type;
-    attributes = this._attributesDefCache[modelName];
-    if (attributes === undefined) {
-      let modelClass = this.store.modelFor(modelName);
-      let attributeMap = modelClass.attributes;
-      attributes = Object.create(null);
-      attributeMap.forEach((meta, name) => attributes[name] = meta);
-      this._attributesDefCache[modelName] = attributes;
-    }
-    return attributes;
-  }
-
-  // Following the existing RD implementation
-  relationshipsDefinitionFor(identifier) {
-    let modelName, relationships;
-    modelName = identifier.type;
-    relationships = this._relationshipsDefCache[modelName];
-    if (relationships === undefined) {
-      let modelClass = this.store.modelFor(modelName);
-      relationships = modelClass.relationshipsObject || null;
-      this._relationshipsDefCache[modelName] = relationships;
-    }
-    return relationships;
-  }
-  doesTypeExist(modelName) {
-    let normalizedModelName = normalizeModelName(modelName);
-    let factory = getModelFactory(this.store, this.store._modelFactoryCache, normalizedModelName);
-    return factory !== null;
-  }
-}
-function getModelFactory(store, cache, normalizedModelName) {
-  let factory = cache[normalizedModelName];
-  if (!factory) {
-    let owner = getOwner(store);
-    factory = owner.factoryFor(`model:${normalizedModelName}`);
-    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      if (!factory) {
-        //Support looking up mixins as base types for polymorphic relationships
-        factory = _modelForMixin(store, normalizedModelName);
-      }
-    }
-    if (!factory) {
-      // we don't cache misses in case someone wants to register a missing model
-      return null;
-    }
-    let klass = factory.class;
-    if (klass.isModel) {
-      let hasOwnModelNameSet = klass.modelName && Object.prototype.hasOwnProperty.call(klass, 'modelName');
-      if (!hasOwnModelNameSet) {
-        Object.defineProperty(klass, 'modelName', {
-          value: normalizedModelName
-        });
-      }
-    }
-    cache[normalizedModelName] = factory;
-  }
-  return factory;
-}
 
 // if modelFor turns out to be a bottleneck we should replace with a Map
 // and clear it during store teardown.
@@ -3559,14 +3464,6 @@ function constructResource(type, id, lid) {
   }
 }
 
-/**
-  @module @ember-data/store
- */
-
-// hello world
-
-let _Cache;
-
 /**
  * A Store coordinates interaction between your application, a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache),
  * and sources of data (such as your API or a local persistence layer)
@@ -3720,7 +3617,6 @@ class Store extends EmberObject {
     this._instanceCache = new InstanceCache(this);
     this._adapterCache = Object.create(null);
     this._serializerCache = Object.create(null);
-    this._modelFactoryCache = Object.create(null);
     this._documentCache = new Map();
     this.isDestroying = false;
     this.isDestroyed = false;
@@ -3865,28 +3761,6 @@ class Store extends EmberObject {
    * @returns A record instance
    * @public
    */
-  instantiateRecord(identifier, createRecordArgs) {
-    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      let modelName = identifier.type;
-      const cache = this.cache;
-      // TODO deprecate allowing unknown args setting
-      let createOptions = {
-        _createProps: createRecordArgs,
-        // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
-        _secretInit: {
-          identifier,
-          cache,
-          store: this,
-          cb: secretInit
-        }
-      };
-
-      // ensure that `getOwner(this)` works inside a model instance
-      setOwner(createOptions, getOwner(this));
-      return getModelFactory(this, this._modelFactoryCache, modelName).class.create(createOptions);
-    }
-    assert(`You must implement the store's instantiateRecord hook for your custom model class.`);
-  }
 
   /**
    * A hook which an app or addon may implement. Called when
@@ -3898,14 +3772,6 @@ class Store extends EmberObject {
    * @public
    * @param record
    */
-  teardownRecord(record) {
-    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      assert(`expected to receive an instance of DSModel. If using a custom model make sure you implement teardownRecord`, 'destroy' in record);
-      record.destroy();
-    } else {
-      assert(`You must implement the store's teardownRecord hook for your custom models`);
-    }
-  }
 
   /**
    * Provides access to the SchemaDefinitionService instance
@@ -3918,13 +3784,6 @@ class Store extends EmberObject {
    * @public
    */
   getSchemaDefinitionService() {
-    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      if (!this._schema) {
-        // it is potentially a mistake for the RFC to have not enabled chaining these services, though highlander rule is nice.
-        // what ember-m3 did via private API to allow both worlds to interop would be much much harder using this.
-        this._schema = new DSModelSchemaDefinitionService(this);
-      }
-    }
     assert(`You must registerSchemaDefinitionService with the store to use custom model classes`, this._schema);
     return this._schema;
   }
@@ -4056,33 +3915,18 @@ class Store extends EmberObject {
     for example.
      @method modelFor
     @public
-    @param {String} modelName
-    @return {subclass of Model | ShimModelClass}
+    @param {String} type
+    @return {ModelSchema}
     */
   // TODO @deprecate in favor of schema APIs, requires adapter/serializer overhaul or replacement
 
-  modelFor(modelName) {
+  modelFor(type) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyedStoreOnly(this, 'modelFor');
     }
-    assert(`You need to pass a model name to the store's modelFor method`, modelName);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      let normalizedModelName = normalizeModelName(modelName);
-      let maybeFactory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);
-
-      // for factorFor factory/class split
-      let klass = maybeFactory && maybeFactory.class ? maybeFactory.class : maybeFactory;
-      if (!klass || !klass.isModel || this._forceShim) {
-        assert(`No model was found for '${modelName}' and no schema handles the type`, this.getSchemaDefinitionService().doesTypeExist(modelName));
-        return getShimClass(this, modelName);
-      } else {
-        // TODO @deprecate ever returning the klass, always return the shim
-        return klass;
-      }
-    }
-    assert(`No model was found for '${modelName}' and no schema handles the type`, this.getSchemaDefinitionService().doesTypeExist(modelName));
-    return getShimClass(this, modelName);
+    assert(`You need to pass <type> to the store's modelFor method`, typeof type === 'string' && type.length);
+    assert(`No model was found for '${type}' and no schema handles the type`, this.getSchemaDefinitionService().doesTypeExist(type));
+    return getShimClass(this, type);
   }
 
   /**
@@ -5027,13 +4871,7 @@ class Store extends EmberObject {
         // destroy the graph before unloadAll
         // since then we avoid churning relationships
         // during unload
-        if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
-          const peekGraph = importSync('@ember-data/graph/-private').peekGraph;
-          const graph = peekGraph(this);
-          if (graph) {
-            graph.identifiers.clear();
-          }
-        }
+        this._graph?.identifiers.clear();
         this.recordArrayManager.clear();
         this._instanceCache.clear();
       } else {
@@ -5288,19 +5126,6 @@ class Store extends EmberObject {
     serializer.pushPayload(this, payload);
   }
 
-  // TODO @runspired @deprecate records should implement their own serialization if desired
-  serializeRecord(record, options) {
-    // TODO we used to check if the record was destroyed here
-    if (macroCondition(getOwnConfig().packages.HAS_COMPAT_PACKAGE)) {
-      if (!this._fetchManager) {
-        const FetchManager = importSync('@ember-data/legacy-compat/-private').FetchManager;
-        this._fetchManager = new FetchManager(this);
-      }
-      return this._fetchManager.createSnapshot(recordIdentifierFor(record)).serialize(options);
-    }
-    assert(`Store.serializeRecord is only available when utilizing @ember-data/legacy-compat for legacy compatibility`);
-  }
-
   /**
    * Trigger a save for a Record.
    *
@@ -5327,9 +5152,6 @@ class Store extends EmberObject {
     if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
       return Promise.resolve(record);
     }
-    if (isDSModel(record)) {
-      record.errors.clear();
-    }
     if (!options) {
       options = {};
     }
@@ -5369,15 +5191,6 @@ class Store extends EmberObject {
    * @param storeWrapper
    * @returns {Cache}
    */
-  createCache(storeWrapper) {
-    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
-      if (_Cache === undefined) {
-        _Cache = importSync('@ember-data/json-api').default;
-      }
-      return new _Cache(storeWrapper);
-    }
-    assert(`Expected store.createCache to be implemented but it wasn't`);
-  }
 
   /**
    * Returns the cache instance associated to this Store, instantiates the Cache
@@ -5542,13 +5355,8 @@ class Store extends EmberObject {
         serializer.destroy();
       }
     }
-    if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
-      const peekGraph = importSync('@ember-data/graph/-private').peekGraph;
-      let graph = peekGraph(this);
-      if (graph) {
-        graph.destroy();
-      }
-    }
+    this._graph?.destroy();
+    this._graph = undefined;
     this.notifications.destroy();
     this.recordArrayManager.destroy();
     this.identifierCache.destroy();
@@ -5572,12 +5380,6 @@ if (macroCondition(getOwnConfig().env.DEBUG)) {
 function isMaybeIdentifier(maybeIdentifier) {
   return Boolean(maybeIdentifier !== null && typeof maybeIdentifier === 'object' && ('id' in maybeIdentifier && 'type' in maybeIdentifier && maybeIdentifier.id && maybeIdentifier.type || maybeIdentifier.lid));
 }
-function isDSModel(record) {
-  if (macroCondition(!getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-    return false;
-  }
-  return !!record && 'constructor' in record && 'isModel' in record.constructor && record.constructor.isModel === true;
-}
 function normalizeProperties(store, identifier, properties) {
   // assert here
   if (properties !== undefined) {
@@ -5638,9 +5440,4 @@ function extractIdentifierFromRecord(recordOrPromiseRecord) {
   const extract = recordIdentifierFor;
   return extract(recordOrPromiseRecord);
 }
-function secretInit(record, cache, identifier, store) {
-  setRecordIdentifier(record, identifier);
-  StoreMap.set(record, store);
-  setCacheFor(record, cache);
-}
-export { CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, Collection as f, SOURCE as g, IDENTIFIER_ARRAY_TAG as h, isStableIdentifier as i, fastPush as j, removeRecordDataFor as k, notifyArray as n, peekCache as p, recordIdentifierFor as r, storeFor as s };
+export { CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, Collection as f, SOURCE as g, IDENTIFIER_ARRAY_TAG as h, isStableIdentifier as i, fastPush as j, removeRecordDataFor as k, setRecordIdentifier as l, StoreMap as m, notifyArray as n, setCacheFor as o, peekCache as p, recordIdentifierFor as r, storeFor as s };