@ember-data/model 4.10.0 → 4.12.0-alpha.0

package/addon/index.js

@@ -0,0 +1 @@
+export { a as attr, b as belongsTo, M as default, h as hasMany } from "./has-many-a275fe0d";

package/addon/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/addon-main.js

@@ -0,0 +1,90 @@
+const pkg = require('./package.json');
+
+module.exports = {
+  name: pkg.name,
+
+  options: {
+    '@embroider/macros': {
+      setOwnConfig: {},
+    },
+  },
+
+  _emberDataConfig: null,
+  configureEmberData() {
+    if (this._emberDataConfig) {
+      return this._emberDataConfig;
+    }
+    const app = this._findHost();
+    const isProd = /production/.test(process.env.EMBER_ENV);
+    const hostOptions = app.options?.emberData || {};
+    const debugOptions = Object.assign(
+      {
+        LOG_PAYLOADS: false,
+        LOG_OPERATIONS: false,
+        LOG_MUTATIONS: false,
+        LOG_NOTIFICATIONS: false,
+        LOG_REQUEST_STATUS: false,
+        LOG_IDENTIFIERS: false,
+        LOG_GRAPH: false,
+        LOG_INSTANCE_CACHE: false,
+      },
+      hostOptions.debug || {}
+    );
+    let HAS_DEBUG_PACKAGE, HAS_META_PACKAGE;
+
+    try {
+      // eslint-disable-next-line node/no-missing-require
+      require.resolve('@ember-data/debug', { paths: [process.cwd(), __dirname] });
+      HAS_DEBUG_PACKAGE = true;
+    } catch {
+      HAS_DEBUG_PACKAGE = false;
+    }
+    try {
+      // eslint-disable-next-line node/no-missing-require
+      require.resolve('ember-data', { paths: [process.cwd(), __dirname] });
+      HAS_META_PACKAGE = true;
+    } catch {
+      HAS_META_PACKAGE = false;
+    }
+    const includeDataAdapterInProduction =
+      typeof hostOptions.includeDataAdapterInProduction === 'boolean'
+        ? hostOptions.includeDataAdapterInProduction
+        : HAS_META_PACKAGE;
+
+    const includeDataAdapter = HAS_DEBUG_PACKAGE ? (isProd ? includeDataAdapterInProduction : true) : false;
+    const DEPRECATIONS = require('@ember-data/private-build-infra/src/deprecations')(hostOptions.compatWith || null);
+    const FEATURES = require('@ember-data/private-build-infra/src/features')(isProd);
+
+    // copy configs forward
+    const ownConfig = this.options['@embroider/macros'].setOwnConfig;
+    ownConfig.compatWith = hostOptions.compatWith || null;
+    ownConfig.debug = debugOptions;
+    ownConfig.deprecations = Object.assign(DEPRECATIONS, ownConfig.deprecations || {});
+    ownConfig.features = Object.assign({}, FEATURES);
+    ownConfig.includeDataAdapter = includeDataAdapter;
+
+    this._emberDataConfig = ownConfig;
+    return ownConfig;
+  },
+
+  included() {
+    this.configureEmberData();
+    return this._super.included.call(this, ...arguments);
+  },
+
+  treeForVendor() {
+    return;
+  },
+  treeForPublic() {
+    return;
+  },
+  treeForStyles() {
+    return;
+  },
+  treeForAddonStyles() {
+    return;
+  },
+  treeForApp() {
+    return;
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/model",
-  "version": "4.10.0",
+  "version": "4.12.0-alpha.0",
   "description": "A presentation layer for apps built with @ember-data/store",
   "keywords": [
     "ember-addon"
@@ -13,15 +13,28 @@
   "license": "MIT",
   "author": "",
   "directories": {},
+  "ember-addon": {
+    "main": "addon-main.js",
+    "type": "addon",
+    "version": 1
+  },
+  "files": [
+    "addon-main.js",
+    "addon"
+  ],
   "peerDependencies": {
-    "@ember-data/record-data": "4.10.0",
-    "@ember-data/store": "4.10.0",
-    "@ember-data/tracking": "4.10.0",
+    "@ember-data/json-api": "4.12.0-alpha.0",
+    "@ember-data/graph": "4.12.0-alpha.0",
+    "@ember-data/store": "4.12.0-alpha.0",
+    "@ember-data/tracking": "4.12.0-alpha.0",
     "@ember/string": "^3.0.1",
     "ember-inflector": "^4.0.2"
   },
   "peerDependenciesMeta": {
-    "@ember-data/record-data": {
+    "@ember-data/json-api": {
+      "optional": true
+    },
+    "@ember-data/graph": {
       "optional": true
     }
   },
@@ -34,31 +47,46 @@
     }
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.10.0",
-    "@ember-data/private-build-infra": "4.10.0",
+    "@ember-data/canary-features": "4.12.0-alpha.0",
+    "@ember-data/private-build-infra": "4.12.0-alpha.0",
     "@ember/edition-utils": "^1.2.0",
     "@embroider/macros": "^1.10.0",
-    "ember-auto-import": "^2.4.3",
     "ember-cached-decorator-polyfill": "^1.0.1",
     "ember-cli-babel": "^7.26.11",
     "ember-cli-string-utils": "^1.1.0",
     "ember-cli-test-info": "^1.0.0",
-    "ember-compatibility-helpers": "^1.2.6",
     "inflection": "~2.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.20.2",
+    "@babel/core": "^7.21.0",
+    "@babel/cli": "^7.21.0",
     "@glimmer/component": "^1.1.2",
-    "ember-source": "~4.8.2",
-    "webpack": "^5.75.0"
+    "ember-source": "~4.9.3",
+    "@embroider/addon-dev": "^2.0.0",
+    "rollup": "^3.17.2",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-private-methods": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.21.0",
+    "@babel/plugin-transform-typescript": "^7.21.0",
+    "@babel/plugin-transform-runtime": "^7.21.0",
+    "@babel/preset-typescript": "^7.21.0",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/runtime": "^7.21.0",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "tslib": "^2.4.1",
+    "walk-sync": "^3.0.0",
+    "typescript": "^4.9.5"
   },
   "engines": {
     "node": "^14.8.0 || 16.* || >= 18.*"
   },
-  "ember-addon": {},
   "volta": {
     "extends": "../../package.json"
   },
-  "packageManager": "pnpm@7.15.0",
-  "scripts": {}
+  "packageManager": "pnpm@7.27.1",
+  "scripts": {
+    "build": "rollup --config && babel ./addon --out-dir addon --plugins=../private-build-infra/src/transforms/babel-plugin-transform-ext.js",
+    "start": "rollup --config --watch"
+  }
 }

package/addon/-private/attr.js

@@ -1,162 +0,0 @@
-import { assert } from '@ember/debug';
-import { computed } from '@ember/object';
-import { DEBUG } from '@glimmer/env';
-
-import { recordIdentifierFor, storeFor } from '@ember-data/store';
-import { recordDataFor } from '@ember-data/store/-private';
-
-import { computedMacroWithOptionalParams } from './util';
-
-/**
-  @module @ember-data/model
-*/
-
-/**
-  `attr` defines an attribute on a [Model](/ember-data/release/classes/Model).
-  By default, attributes are passed through as-is, however you can specify an
-  optional type to have the value automatically transformed.
-  Ember Data ships with four basic transform types: `string`, `number`,
-  `boolean` and `date`. You can define your own transforms by subclassing
-  [Transform](/ember-data/release/classes/Transform).
-
-  Note that you cannot use `attr` to define an attribute of `id`.
-
-  `attr` takes an optional hash as a second parameter, currently
-  supported options are:
-
-  - `defaultValue`: Pass a string or a function to be called to set the attribute
-  to a default value if and only if the key is absent from the payload response.
-
-  Example
-
-  ```app/models/user.js
-  import Model, { attr } from '@ember-data/model';
-
-  export default class UserModel extends Model {
-    @attr('string') username;
-    @attr('string') email;
-    @attr('boolean', { defaultValue: false }) verified;
-  }
-  ```
-
-  Default value can also be a function. This is useful it you want to return
-  a new object for each attribute.
-
-  ```app/models/user.js
-  import Model, { attr } from '@ember-data/model';
-
-  export default class UserModel extends Model {
-    @attr('string') username;
-    @attr('string') email;
-
-    @attr({
-      defaultValue() {
-        return {};
-      }
-    })
-    settings;
-  }
-  ```
-
-  The `options` hash is passed as second argument to a transforms'
-  `serialize` and `deserialize` method. This allows to configure a
-  transformation and adapt the corresponding value, based on the config:
-
-  ```app/models/post.js
-  import Model, { attr } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @attr('text', {
-      uppercase: true
-    })
-    text;
-  }
-  ```
-
-  ```app/transforms/text.js
-  import Transform from '@ember-data/serializer/transform';
-
-  export default class TextTransform extends Transform {
-    serialize(value, options) {
-      if (options.uppercase) {
-        return value.toUpperCase();
-      }
-
-      return value;
-    }
-
-    deserialize(value) {
-      return value;
-    }
-  }
-  ```
-
-  @method attr
-  @public
-  @static
-  @for @ember-data/model
-  @param {String|Object} type the attribute type
-  @param {Object} options a hash of options
-  @return {Attribute}
-*/
-function attr(type, options) {
-  if (typeof type === 'object') {
-    options = type;
-    type = undefined;
-  } else {
-    options = options || {};
-  }
-
-  let meta = {
-    type: type,
-    isAttribute: true,
-    options: options,
-  };
-
-  return computed({
-    get(key) {
-      if (DEBUG) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(
-            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`
-          );
-        }
-      }
-      if (this.isDestroyed || this.isDestroying) {
-        return;
-      }
-      return recordDataFor(this).getAttr(recordIdentifierFor(this), key);
-    },
-    set(key, value) {
-      if (DEBUG) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(
-            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`
-          );
-        }
-      }
-      assert(
-        `Attempted to set '${key}' on the deleted record ${recordIdentifierFor(this)}`,
-        !this.currentState.isDeleted
-      );
-      const identifier = recordIdentifierFor(this);
-      const recordData = storeFor(this)._instanceCache.getRecordData(identifier);
-      let currentValue = recordData.getAttr(identifier, key);
-      if (currentValue !== value) {
-        recordData.setAttr(identifier, key, value);
-
-        if (!this.isValid) {
-          const { errors } = this;
-          if (errors.get(key)) {
-            errors.remove(key);
-            this.currentState.cleanErrorRequests();
-          }
-        }
-      }
-
-      return value;
-    },
-  }).meta(meta);
-}
-
-export default computedMacroWithOptionalParams(attr);

package/addon/-private/belongs-to.js

@@ -1,268 +0,0 @@
-import { assert, deprecate, warn } from '@ember/debug';
-import { computed } from '@ember/object';
-import { dasherize } from '@ember/string';
-import { DEBUG } from '@glimmer/env';
-
-import {
-  DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC,
-  DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE,
-  DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE,
-} from '@ember-data/private-build-infra/deprecations';
-
-import { lookupLegacySupport } from './model';
-import { computedMacroWithOptionalParams } from './util';
-
-function normalizeType(type) {
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE) {
-    if (!type) {
-      return;
-    }
-  }
-
-  return dasherize(type);
-}
-/**
-  @module @ember-data/model
-*/
-
-/**
-  `belongsTo` is used to define One-To-One and One-To-Many
-  relationships on a [Model](/ember-data/release/classes/Model).
-
-
-  `belongsTo` takes an optional hash as a second parameter, currently
-  supported options are:
-
-  - `async`: A boolean value used to explicitly declare this to be an async relationship. The default is true.
-  - `inverse`: A string used to identify the inverse property on a
-    related model in a One-To-Many relationship. See [Explicit Inverses](#explicit-inverses)
-  - `polymorphic` A boolean value to mark the relationship as polymorphic
-
-  #### One-To-One
-  To declare a one-to-one relationship between two models, use
-  `belongsTo`:
-
-  ```app/models/user.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class UserModel extends Model {
-    @belongsTo('profile') profile;
-  }
-  ```
-
-  ```app/models/profile.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class ProfileModel extends Model {
-    @belongsTo('user') user;
-  }
-  ```
-
-  #### One-To-Many
-  To declare a one-to-many relationship between two models, use
-  `belongsTo` in combination with `hasMany`, like this:
-
-  ```app/models/post.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany('comment') comments;
-  }
-  ```
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo('post') 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
-  available in its local store, hence it is expected these resources
-  to be loaded before or along-side the primary resource.
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo('post', {
-      async: false
-    })
-    post;
-  }
-  ```
-
-  In contrast to async relationship, accessing a sync relationship
-  will always return the record (Model instance) for the existing
-  local resource, or null. But it will error on access when
-  a related resource is known to exist and it has not been loaded.
-
-  ```
-  let post = comment.post;
-
-  ```
-
-  @method belongsTo
-  @public
-  @static
-  @for @ember-data/model
-  @param {String} modelName (optional) type of the relationship
-  @param {Object} options (optional) a hash of options
-  @return {Ember.computed} relationship
-*/
-function belongsTo(modelName, options) {
-  let opts = options;
-  let userEnteredModelName = modelName;
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE) {
-    if (typeof modelName !== 'string' || !modelName.length) {
-      deprecate('belongsTo() must specify the string type of the related resource as the first parameter', false, {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: { enabled: '4.7', available: '4.7' },
-      });
-
-      if (typeof modelName === 'object') {
-        opts = modelName;
-        userEnteredModelName = undefined;
-      } else {
-        opts = options;
-        userEnteredModelName = modelName;
-      }
-
-      assert(
-        'The first argument to belongsTo must be a string representing a model type key, not an instance of ' +
-          typeof userEnteredModelName +
-          ". E.g., to define a relation to the Person model, use belongsTo('person')",
-        typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined'
-      );
-    }
-  }
-
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC) {
-    if (!opts || typeof opts.async !== 'boolean') {
-      opts = opts || {};
-      if (!('async' in opts)) {
-        opts.async = true;
-      }
-      deprecate('belongsTo(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: { enabled: '4.7', available: '4.7' },
-      });
-    } else {
-      assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
-    }
-  } else {
-    assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
-  }
-
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE) {
-    if (opts.inverse !== null && (typeof opts.inverse !== 'string' || opts.inverse.length === 0)) {
-      deprecate(
-        'belongsTo(<type>, <options>) must specify options.inverse as either `null` or string type of the related resource.',
-        false,
-        {
-          id: 'ember-data:deprecate-non-strict-relationships',
-          for: 'ember-data',
-          until: '5.0',
-          since: { enabled: '4.7', available: '4.7' },
-        }
-      );
-    } else {
-      assert(
-        `Expected belongsTo options.inverse to be either null or the string type of the related resource.`,
-        opts.inverse === null || (typeof opts.inverse === 'string' && opts.inverse.length > 0)
-      );
-    }
-  } else {
-    assert(
-      `Expected belongsTo options.inverse to be either null or the string type of the related resource.`,
-      opts.inverse === null || (typeof opts.inverse === 'string' && opts.inverse.length > 0)
-    );
-  }
-
-  let meta = {
-    type: normalizeType(userEnteredModelName),
-    isRelationship: true,
-    options: opts,
-    kind: 'belongsTo',
-    name: 'Belongs To',
-    key: null,
-  };
-
-  return computed({
-    get(key) {
-      // this is a legacy behavior we may not carry into a new model setup
-      // it's better to error on disconnected records so users find errors
-      // in their logic.
-      if (this.isDestroying || this.isDestroyed) {
-        return null;
-      }
-      const support = lookupLegacySupport(this);
-
-      if (DEBUG) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(
-            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`
-          );
-        }
-        if (Object.prototype.hasOwnProperty.call(opts, 'serialize')) {
-          warn(
-            `You provided a serialize option on the "${key}" property in the "${support.identifier.type}" class, this belongs in the serializer. See Serializer and it's implementations https://api.emberjs.com/ember-data/release/classes/Serializer`,
-            false,
-            {
-              id: 'ds.model.serialize-option-in-belongs-to',
-            }
-          );
-        }
-
-        if (Object.prototype.hasOwnProperty.call(opts, 'embedded')) {
-          warn(
-            `You provided an embedded option on the "${key}" property in the "${support.identifier.type}" class, this belongs in the serializer. See EmbeddedRecordsMixin https://api.emberjs.com/ember-data/release/classes/EmbeddedRecordsMixin`,
-            false,
-            {
-              id: 'ds.model.embedded-option-in-belongs-to',
-            }
-          );
-        }
-      }
-
-      return support.getBelongsTo(key);
-    },
-    set(key, value) {
-      const support = lookupLegacySupport(this);
-      if (DEBUG) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(
-            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`
-          );
-        }
-      }
-      this.store._join(() => {
-        support.setDirtyBelongsTo(key, value);
-      });
-
-      return support.getBelongsTo(key);
-    },
-  }).meta(meta);
-}
-
-export default computedMacroWithOptionalParams(belongsTo);

package/addon/-private/debug/assert-polymorphic-type.js

@@ -1,71 +0,0 @@
-import { assert } from '@ember/debug';
-import { DEBUG } from '@glimmer/env';
-
-import { DEPRECATE_NON_EXPLICIT_POLYMORPHISM } from '@ember-data/private-build-infra/deprecations';
-
-/*
-  Assert that `addedRecord` has a valid type so it can be added to the
-  relationship of the `record`.
-
-  The assert basically checks if the `addedRecord` can be added to the
-  relationship (specified via `relationshipMeta`) of the `record`.
-
-  This utility should only be used internally, as both record parameters must
-  be stable record identifiers and the `relationshipMeta` needs to be the meta
-  information about the relationship, retrieved via
-  `record.relationshipFor(key)`.
-*/
-let assertPolymorphicType;
-
-if (DEBUG) {
-  let checkPolymorphic = function checkPolymorphic(modelClass, addedModelClass) {
-    if (modelClass.__isMixin) {
-      return (
-        modelClass.__mixin.detect(addedModelClass.PrototypeMixin) ||
-        // handle native class extension e.g. `class Post extends Model.extend(Commentable) {}`
-        modelClass.__mixin.detect(Object.getPrototypeOf(addedModelClass).PrototypeMixin)
-      );
-    }
-
-    return addedModelClass.prototype instanceof modelClass || modelClass.detect(addedModelClass);
-  };
-
-  assertPolymorphicType = function assertPolymorphicType(parentIdentifier, parentDefinition, addedIdentifier, store) {
-    let asserted = false;
-
-    if (parentDefinition.inverseIsImplicit) {
-      return;
-    }
-    if (parentDefinition.isPolymorphic) {
-      let meta = store.getSchemaDefinitionService().relationshipsDefinitionFor(addedIdentifier)[
-        parentDefinition.inverseKey
-      ];
-      if (meta?.options?.as) {
-        asserted = true;
-        assert(
-          `The schema for the relationship '${parentDefinition.inverseKey}' on '${addedIdentifier.type}' type does not implement '${parentDefinition.type}' and thus cannot be assigned to the '${parentDefinition.key}' relationship in '${parentIdentifier.type}'. The definition should specify 'as: "${parentDefinition.type}"' in options.`,
-          meta.options.as === parentDefinition.type
-        );
-      }
-    }
-
-    if (DEPRECATE_NON_EXPLICIT_POLYMORPHISM) {
-      if (!asserted) {
-        store = store._store ? store._store : store; // allow usage with storeWrapper
-        let addedModelName = addedIdentifier.type;
-        let parentModelName = parentIdentifier.type;
-        let key = parentDefinition.key;
-        let relationshipModelName = parentDefinition.type;
-        let relationshipClass = store.modelFor(relationshipModelName);
-        let addedClass = store.modelFor(addedModelName);
-
-        let assertionMessage = `The '${addedModelName}' type does not implement '${relationshipModelName}' and thus cannot be assigned to the '${key}' relationship in '${parentModelName}'. Make it a descendant of '${relationshipModelName}' or use a mixin of the same name.`;
-        let isPolymorphic = checkPolymorphic(relationshipClass, addedClass);
-
-        assert(assertionMessage, isPolymorphic);
-      }
-    }
-  };
-}
-
-export { assertPolymorphicType };