@ember-data/model 4.12.0-beta.7 → 4.12.0-beta.9

package/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (C) 2017-2022 Ember.js contributors
+Copyright (C) 2017-2023 Ember.js contributors
 Portions Copyright (C) 2011-2017 Tilde, Inc. and contributors.
 Portions Copyright (C) 2011 LivingSocial Inc.
 

package/README.md

@@ -1,31 +1,55 @@
-@ember-data/model
-==============================================================================
+<p align="center">
+  <img
+    class="project-logo"
+    src="./ember-data-logo-dark.svg#gh-dark-mode-only"
+    alt="EmberData Model"
+    width="240px"
+    title="EmberData Model"
+    />
+  <img
+    class="project-logo"
+    src="./ember-data-logo-light.svg#gh-light-mode-only"
+    alt="EmberData Model"
+    width="240px"
+    title="EmberData Model"
+    />
+</p>
 
-[Short description of the addon.]
+<p align="center">Provides a Presentation Model for resource data in an EmberData Cache</p>
 
+This package implements the EmberData Store's `instantiateRecord` and `teardownRecord` hooks
+as well as configures an associated `SchemaService` implementation.
 
-Compatibility
-------------------------------------------------------------------------------
+Models are defined as classes extending from `import Model from '@ember-data/model';` and the
+attributes and relationships on these classes are parsed at runtime to supply static "schema"
+to EmberData's SchemaService.
 
-* Ember.js v3.4 or above
-* Ember CLI v2.13 or above
+Resource data for individual resources fetched from your API is presented to the UI via instances
+of the `Model`s you define. An instantiated `Model` is referred to as a `record`.
 
+When we refer to the `ModelClass` as opposed to a `Model` or `Record` we are referring
+specifically to the class definition and the static schema methods present on it.
 
-Installation
-------------------------------------------------------------------------------
+When we refer to a `record` we refer to a specific class instance presenting
+the resource data for a given `type` and `id`.
 
-```
-ember install @ember-data/model
-```
+  ### Defining a Model
 
+ *app/models/person.js*
+  ```ts
+  import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
 
-Usage
-------------------------------------------------------------------------------
+  export default class PersonModel extends Model {
+    @attr name;
 
-[Longer description of how to use the addon in apps.]
+    @belongsTo('pet', { inverse: 'owners', async: false }) dog;
 
+    @hasMany('person', { inverse: 'friends', async: true }) friends;
+  }
+  ```
 
-License
-------------------------------------------------------------------------------
+  ### modelName convention
 
-This project is licensed under the [MIT License](LICENSE.md).
+  By convention, the name of a given model (its `type`) matches the name
+  of the file in the `app/models` folder and should be lowercase, singular
+  and dasherized.

package/addon/-private.js

@@ -1,5 +1,5 @@
-import { M as Model } from "./has-many-f4cb2303";
-export { E as Errors, L as LEGACY_SUPPORT, R as ManyArray, P as PromiseBelongsTo, c as PromiseManyArray, a as attr, b as belongsTo, h as hasMany } from "./has-many-f4cb2303";
+import { M as Model } from "./has-many-465843f4";
+export { E as Errors, L as LEGACY_SUPPORT, R as ManyArray, P as PromiseBelongsTo, c as PromiseManyArray, a as attr, b as belongsTo, h as hasMany } from "./has-many-465843f4";
 import { getOwner } from '@ember/application';
 
 /*

package/addon/{has-many-f4cb2303.js → has-many-465843f4.js}

@@ -269,6 +269,11 @@ function deprecatedPromiseObject(promise) {
   return new Proxy(promiseObjectProxy, handler);
 }
 var _dec$1, _dec2, _dec3, _dec4, _class$6, _descriptor$5, _descriptor2$2;
+
+/**
+  @module @ember-data/model
+*/
+
 // we force the type here to our own construct because mixin and extend patterns
 // lose generic signatures. We also do this because we need to Omit `clear` from
 // the type of ArrayProxy as we override it's signature.
@@ -952,6 +957,9 @@ function isPromiseRecord$1(record) {
   return !!record.then;
 }
 var _dec, _class$5;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
 const Extended = PromiseObject;
 
 /**
@@ -998,6 +1006,26 @@ let PromiseBelongsTo = (_dec = computed(), (_class$5 = class PromiseBelongsTo ex
   }
 }, (_applyDecoratedDescriptor(_class$5.prototype, "id", [cached], Object.getOwnPropertyDescriptor(_class$5.prototype, "id"), _class$5.prototype), _applyDecoratedDescriptor(_class$5.prototype, "meta", [_dec], Object.getOwnPropertyDescriptor(_class$5.prototype, "meta"), _class$5.prototype)), _class$5));
 var _class$4, _descriptor$4, _descriptor2$1, _descriptor3, _descriptor4, _descriptor5;
+
+/**
+ @module @ember-data/model
+ */
+/**
+  This class is returned as the result of accessing an async hasMany relationship
+  on an instance of a Model extending from `@ember-data/model`.
+
+  A PromiseManyArray is an iterable proxy that allows templates to consume related
+  ManyArrays and update once their contents are no longer pending.
+
+  In your JS code you should resolve the promise first.
+
+  ```js
+  const comments = await post.comments;
+  ```
+
+  @class PromiseManyArray
+  @public
+*/
 let PromiseManyArray = (_class$4 = class PromiseManyArray {
   // @deprecated (isDestroyed is not deprecated)
 
@@ -2716,7 +2744,10 @@ class LegacySupport {
         return this.store.request({
           op: 'findHasMany',
           records: identifiers || [],
-          data: request
+          data: request,
+          cacheOptions: {
+            [Symbol.for('ember-data:skip-cache')]: true
+          }
         });
       }
       const preferLocalCache = hasReceivedData && !isEmpty;
@@ -2733,7 +2764,10 @@ class LegacySupport {
         return this.store.request({
           op: 'findHasMany',
           records: identifiers,
-          data: request
+          data: request,
+          cacheOptions: {
+            [Symbol.for('ember-data:skip-cache')]: true
+          }
         });
       }
 
@@ -2781,7 +2815,10 @@ class LegacySupport {
       const future = this.store.request({
         op: 'findBelongsTo',
         records: identifier ? [identifier] : [],
-        data: request
+        data: request,
+        cacheOptions: {
+          [Symbol.for('ember-data:skip-cache')]: true
+        }
       });
       this._pending = future.then(doc => doc.content).finally(() => {
         this._pending = null;
@@ -2812,7 +2849,10 @@ class LegacySupport {
       this._pending = this.store.request({
         op: 'findBelongsTo',
         records: [identifier],
-        data: request
+        data: request,
+        cacheOptions: {
+          [Symbol.for('ember-data:skip-cache')]: true
+        }
       }).then(doc => doc.content).finally(() => {
         this._pending = null;
       });
@@ -3527,7 +3567,7 @@ function computeOnce(target, key, desc) {
 }
 
 /**
-  Base class from which Models can be define.
+  Base class from which Models can be defined.
 
   ```js
   import Model, { attr } from '@ember-data/model';
@@ -4277,6 +4317,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       data: {
         options,
         record: identifier
+      },
+      cacheOptions: {
+        [Symbol.for('ember-data:skip-cache')]: true
       }
     }).then(() => this).finally(() => {
       this.isReloading = false;
@@ -4451,6 +4494,41 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   eachAttribute(callback, binding) {
     this.constructor.eachAttribute(callback, binding);
   }
+
+  /**
+    Create should only ever be called by the store. To create an instance of a
+    `Model` in a dirty state use `store.createRecord`.
+    To create instances of `Model` in a clean state, use `store.push`
+     @method create
+    @private
+    @static
+  */
+  /**
+   Represents the model's class name as a string. This can be used to look up the model's class name through
+   `Store`'s modelFor method.
+    `modelName` is generated for you by Ember Data. It will be a lowercased, dasherized string.
+   For example:
+    ```javascript
+   store.modelFor('post').modelName; // 'post'
+   store.modelFor('blog-post').modelName; // 'blog-post'
+   ```
+    The most common place you'll want to access `modelName` is in your serializer's `payloadKeyFromModelName` method. For example, to change payload
+   keys to underscore (instead of dasherized), you might use the following code:
+    ```javascript
+   import RESTSerializer from '@ember-data/serializer/rest';
+   import { underscore } from '<app-name>/utils/string-utils';
+    export default const PostSerializer = RESTSerializer.extend({
+     payloadKeyFromModelName(modelName) {
+       return underscore(modelName);
+     }
+   });
+   ```
+   @property modelName
+    @public
+   @type String
+   @readonly
+   @static
+  */
   /*
    These class methods below provide relationship
    introspection abilities about relationships.
@@ -4464,7 +4542,6 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    do it before using your model with the store, which uses these properties
    extensively.
    */
-
   /**
    For a given relationship name, returns the model type of the relationship.
     For example, if you define a model like this:
@@ -5504,6 +5581,7 @@ function normalizeType$1(type) {
   ```
 
   #### One-To-Many
+
   To declare a one-to-many relationship between two models, use
   `belongsTo` in combination with `hasMany`, like this:
 
@@ -5511,7 +5589,7 @@ function normalizeType$1(type) {
   import Model, { hasMany } from '@ember-data/model';
 
   export default class PostModel extends Model {
-    @hasMany('comment') comments;
+    @hasMany('comment', { async: false, inverse: 'post' }) comments;
   }
   ```
 
@@ -5519,23 +5597,10 @@ function normalizeType$1(type) {
   import Model, { belongsTo } from '@ember-data/model';
 
   export default class CommentModel extends Model {
-    @belongsTo('post') post;
+    @belongsTo('post', { async: false, inverse: 'comments' }) post;
   }
   ```
 
-  You can avoid passing a string as the first parameter. In that case Ember Data
-  will infer the type from the key name.
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo post;
-  }
-  ```
-
-  will lookup for a Post type.
-
   #### Sync relationships
 
   Ember Data resolves sync relationships with the related resources
@@ -5547,7 +5612,8 @@ function normalizeType$1(type) {
 
   export default class CommentModel extends Model {
     @belongsTo('post', {
-      async: false
+      async: false,
+      inverse: null
     })
     post;
   }