@warp-drive-mirror/build-config 0.0.0-beta.7 → 4.13.0-alpha.1

package/dist/cjs-set-config.cjs

@@ -122,6 +122,621 @@ function getEnv() {
  * @public
  */
 const DEPRECATE_CATCH_ALL = '99.0';
+
+/**
+ * **id: ember-data:rsvp-unresolved-async**
+ *
+ * Deprecates when a request promise did not resolve prior to the store tearing down.
+ *
+ * Note: in most cases even with the promise guard that is now being deprecated
+ * a test crash would still be encountered.
+ *
+ * To resolve: Tests or Fastboot instances which crash need to find triggers requests
+ * and properly await them before tearing down.
+ *
+ * @property DEPRECATE_RSVP_PROMISE
+ * @since 4.4
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_RSVP_PROMISE = '4.4';
+
+/**
+ * **id: ember-data:model-save-promise**
+ *
+ * Affects
+ * - model.save / store.saveRecord
+ * - model.reload
+ *
+ * Deprecates the promise-proxy returned by these methods in favor of
+ * a Promise return value.
+ *
+ * To resolve this deprecation, `await` or `.then` the return value
+ * before doing work with the result instead of accessing values via
+ * the proxy.
+ *
+ * To continue utilizing flags such as `isPending` in your templates
+ * consider using [ember-promise-helpers](https://github.com/fivetanley/ember-promise-helpers)
+ *
+ * @property DEPRECATE_SAVE_PROMISE_ACCESS
+ * @since 4.4
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_SAVE_PROMISE_ACCESS = '4.4';
+
+/**
+ * **id: ember-data:deprecate-snapshot-model-class-access**
+ *
+ * Deprecates accessing the factory class for a given resource type
+ * via properties on various classes.
+ *
+ * Guards
+ *
+ * - SnapshotRecordArray.type
+ * - Snapshot.type
+ * - RecordArray.type
+ *
+ * Use `store.modelFor(<resource-type>)` instead.
+ *
+ * @property DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS
+ * @since 4.5
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS = '4.5';
+
+/**
+ * **id: ember-data:deprecate-store-find**
+ *
+ * Deprecates using `store.find` instead of `store.findRecord`. Typically
+ * `store.find` is a mistaken call that occurs when using implicit route behaviors
+ * in Ember which attempt to derive how to load data via parsing the route params
+ * for a route which does not implement a `model` hook.
+ *
+ * To resolve, use `store.findRecord`. This may require implementing an associated
+ * route's `model() {}` hook.
+ *
+ * @property DEPRECATE_STORE_FIND
+ * @since 4.5
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_STORE_FIND = '4.5';
+
+/**
+ * **id: ember-data:deprecate-has-record-for-id**
+ *
+ * Deprecates `store.hasRecordForId(type, id)` in favor of `store.peekRecord({ type, id }) !== null`.
+ *
+ * Broadly speaking, while the ability to query for presence is important, a key distinction exists
+ * between these methods that make relying on `hasRecordForId` unsafe, as it may report `true` for a
+ * record which is not-yet loaded and un-peekable. `peekRecord` offers a safe mechanism by which to check
+ * for whether a record is present in a usable manner.
+ *
+ * @property DEPRECATE_HAS_RECORD
+ * @since 4.5
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_HAS_RECORD = '4.5';
+
+/**
+ * **id: ember-data:deprecate-string-arg-schemas**
+ *
+ * Deprecates `schema.attributesDefinitionFor(type)` and
+ * `schema.relationshipsDefinitionFor(type)` in favor of
+ * a consistent object signature (`identifier | { type }`).
+ *
+ * To resolve change
+ *
+ * ```diff
+ * - store.getSchemaDefinitionService().attributesDefinitionFor('user')
+ * + store.getSchemaDefinitionService().attributesDefinitionFor({ type: 'user' })
+ * ```
+ *
+ * @property DEPRECATE_STRING_ARG_SCHEMAS
+ * @since 4.5
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_STRING_ARG_SCHEMAS = '4.5';
+
+/**
+ * **id: ember-data:deprecate-secret-adapter-fallback**
+ *
+ * Deprecates the secret `-json-api` fallback adapter in favor
+ * or an explicit "catch all" application adapter. In addition
+ * to this deprecation ensuring the user has explicitly chosen an
+ * adapter, this ensures that the user may choose to use no adapter
+ * at all.
+ *
+ * Simplest fix:
+ *
+ * *<project>/app/adapters/application.js*
+ * ```js
+ * export { default } from '@ember-data-mirror/adapter/json-api';
+ * ```
+ *
+ * @property DEPRECATE_JSON_API_FALLBACK
+ * @since 4.5
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_JSON_API_FALLBACK = '4.5';
+
+/**
+ * **id: ember-data:deprecate-model-reopen**
+ *
+ * ----
+ *
+ * For properties known ahead of time, instead of
+ *
+ * ```ts
+ * class User extends Model { @attr firstName; }
+ *
+ * User.reopen({ lastName: attr() });
+ * ```
+ *
+ * Extend `User` again or include it in the initial definition.
+ *
+ * ```ts
+ * class User extends Model { @attr firstName; @attr lastName }
+ * ```
+ *
+ * For properties generated dynamically, consider registering
+ * a `SchemaDefinitionService` with the store , as such services
+ * are capable of dynamically adjusting their schemas, and utilize
+ * the `instantiateRecord` hook to create a Proxy based class that
+ * can react to the changes in the schema.
+ *
+ *
+ * Use Foo extends Model to extend your class instead
+ *
+ *
+ *
+ *
+ * **id: ember-data:deprecate-model-reopenclass**
+ *
+ * ----
+ *
+ * Instead of reopenClass, define `static` properties with native class syntax
+ * or add them to the final object.
+ *
+ * ```ts
+ * // instead of
+ * User.reopenClass({ aStaticMethod() {} });
+ *
+ * // do this
+ * class User {
+ *   static aStaticMethod() {}
+ * }
+ *
+ * // or do this
+ * User.aStaticMethod = function() {}
+ * ```
+ *
+ *
+ * @property DEPRECATE_MODEL_REOPEN
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_MODEL_REOPEN = '4.7';
+
+/**
+ * **id: ember-data:deprecate-early-static**
+ *
+ * This deprecation triggers if static computed properties
+ * or methods are triggered without looking up the record
+ * via the store service's `modelFor` hook. Accessing this
+ * static information without looking up the model via the
+ * store most commonly occurs when
+ *
+ * - using ember-cli-mirage (to fix, refactor to not use its auto-discovery of ember-data models)
+ * - importing a model class and accessing its static information via the import
+ *
+ * Instead of
+ *
+ * ```js
+ * import User from 'my-app/models/user';
+ *
+ * const relationships = User.relationshipsByName;
+ * ```
+ *
+ * Do *at least* this
+ *
+ * ```js
+ * const relationships = store.modelFor('user').relationshipsByName;
+ * ```
+ *
+ * However, the much more future proof refactor is to not use `modelFor` at all but instead
+ * to utilize the schema service for this static information.
+ *
+ * ```js
+ * const relationships = store.getSchemaDefinitionService().relationshipsDefinitionFor({ type: 'user' });
+ * ```
+ *
+ *
+ * @property DEPRECATE_EARLY_STATIC
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_EARLY_STATIC = '4.7';
+
+/**
+ * **id: ember-data:deprecate-errors-hash-to-array-helper**
+ * **id: ember-data:deprecate-errors-array-to-hash-helper**
+ * **id: ember-data:deprecate-normalize-modelname-helper**
+ *
+ * Deprecates `errorsHashToArray` `errorsArrayToHash` and `normalizeModelName`
+ *
+ * Users making use of these (already private) utilities can trivially copy them
+ * into their own codebase to continue using them, though we recommend refactoring
+ * to a more direct conversion into the expected errors format for the errors helpers.
+ *
+ * For refactoring normalizeModelName we also recommend following the guidance in
+ * [RFC#740 Deprecate Non-Strict Types](https://github.com/emberjs/rfcs/pull/740).
+ *
+ *
+ * @property DEPRECATE_HELPERS
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_HELPERS = '4.7';
+
+/**
+ * **id: ember-data:deprecate-promise-many-array-behavior**
+ *
+ * [RFC Documentation](https://rfcs.emberjs.com/id/0745-ember-data-deprecate-methods-on-promise-many-array)
+ *
+ * This deprecation deprecates accessing values on the asynchronous proxy
+ * in favor of first "resolving" or "awaiting" the promise to retrieve a
+ * synchronous value.
+ *
+ * Template iteration of the asynchronous value will still work and not trigger
+ * the deprecation, but all JS access should be avoided and HBS access for anything
+ * but `{{#each}}` should also be refactored.
+ *
+ * Recommended approaches include using the addon `ember-promise-helpers`, using
+ * Ember's `resource` pattern (including potentially the addon `ember-data-resources`),
+ * resolving the value in routes/provider components, or using the references API.
+ *
+ * An example of using the [hasMany](https://api.emberjs.com/ember-data/4.11/classes/Model/methods/hasMany?anchor=hasMany) [reference API](https://api.emberjs.com/ember-data/release/classes/HasManyReference):
+ *
+ * ```ts
+ * // get the synchronous "ManyArray" value for the asynchronous "friends" relationship.
+ * // note, this will return `null` if the relationship has not been loaded yet
+ * const value = person.hasMany('friends').value();
+ *
+ * // to get just the list of related IDs
+ * const ids = person.hasMany('friends').ids();
+ * ```
+ *
+ * References participate in autotracking and getters/cached getters etc. which consume them
+ * will recompute if the value changes.
+ *
+ * @property DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS = '4.7';
+
+/**
+ * **id: ember-data:deprecate-non-strict-relationships**
+ *
+ * Deprecates when belongsTo and hasMany relationships are defined
+ * without specifying the inverse record's type.
+ *
+ * Instead of
+ *
+ * ```ts
+ * class Company extends Model {
+ *   @hasMany() employees;
+ * }
+ * class Employee extends Model {
+ *   @belongsTo() company;
+ * }
+ * ```
+ *
+ * Use
+ *
+ * ```ts
+ * class Company extends Model {
+ *   @hasMany('employee', { async: true, inverse: 'company' }) employees;
+ * }
+ *
+ * class Employee extends Model {
+ *   @belongsTo('company', { async: true, inverse: 'employees' }) company;
+ * }
+ * ```
+ *
+ * @property DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE = '4.7';
+
+/**
+ * **id: ember-data:deprecate-non-strict-relationships**
+ *
+ * Deprecates when belongsTo and hasMany relationships are defined
+ * without specifying whether the relationship is asynchronous.
+ *
+ * The current behavior is that relationships which do not define
+ * this setting are aschronous (`{ async: true }`).
+ *
+ * Instead of
+ *
+ * ```ts
+ * class Company extends Model {
+ *   @hasMany('employee') employees;
+ * }
+ * class Employee extends Model {
+ *   @belongsTo('company') company;
+ * }
+ * ```
+ *
+ * Use
+ *
+ * ```ts
+ * class Company extends Model {
+ *   @hasMany('employee', { async: true, inverse: 'company' }) employees;
+ * }
+ *
+ * class Employee extends Model {
+ *   @belongsTo('company', { async: true, inverse: 'employees' }) company;
+ * }
+ * ```
+ *
+ * @property DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC = '4.7';
+
+/**
+ * **id: ember-data:deprecate-non-strict-relationships**
+ *
+ * Deprecates when belongsTo and hasMany relationships are defined
+ * without specifying the inverse field on the related type.
+ *
+ * The current behavior is that relationships which do not define
+ * this setting have their inverse determined at runtime, which is
+ * potentially non-deterministic when mixins and polymorphism are involved.
+ *
+ * If an inverse relationship exists and you wish changes on one side to
+ * reflect onto the other side, use the inverse key. If you wish to not have
+ * changes reflected or no inverse relationship exists, specify `inverse: null`.
+ *
+ * Instead of
+ *
+ * ```ts
+ * class Company extends Model {
+ *   @hasMany('employee') employees;
+ * }
+ * class Employee extends Model {
+ *   @belongsTo('company') company;
+ * }
+ * ```
+ *
+ * Use
+ *
+ * ```ts
+ * class Company extends Model {
+ *   @hasMany('employee', { async: true, inverse: 'company' }) employees;
+ * }
+ *
+ * class Employee extends Model {
+ *   @belongsTo('company', { async: true, inverse: 'employees' }) company;
+ * }
+ * ```
+ *
+ * Instead of
+ *
+ * ```ts
+ * class Company extends Model {
+ *   @hasMany('employee') employees;
+ * }
+ * class Employee extends Model {
+ *   @attr name;
+ * }
+ * ```
+ *
+ * Use
+ *
+ * ```ts
+ * class Company extends Model {
+ *   @hasMany('employee', { async: true, inverse: null }) employees;
+ * }
+ *
+ * class Employee extends Model {
+ *   @attr name;
+ * }
+ * ```
+ *
+ * @property DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE = '4.7';
+
+/**
+ * **id: ember-data:no-a-with-array-like**
+ *
+ * Deprecates when calling `A()` on an EmberData ArrayLike class
+ * is detected. This deprecation may not always trigger due to complexities
+ * in ember-source versions and the use (or disabling) of prototype extensions.
+ *
+ * To fix, just use the native array methods instead of the EmberArray methods
+ * and refrain from wrapping the array in `A()`.
+ *
+ * Note that some computed property macros may themselves utilize `A()`, in which
+ * scenario the computed properties need to be upgraded to octane syntax.
+ *
+ * For instance, instead of:
+ *
+ * ```ts
+ * class extends Component {
+ *   @filterBy('items', 'isComplete') completedItems;
+ * }
+ * ```
+ *
+ * Use the following:
+ *
+ * ```ts
+ * class extends Component {
+ *   get completedItems() {
+ *     return this.items.filter(item => item.isComplete);
+ *   }
+ * }
+ * ```
+ *
+ * @property DEPRECATE_A_USAGE
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_A_USAGE = '4.7';
+
+/**
+ * **id: ember-data:deprecate-promise-proxies**
+ *
+ * Additional Reading: [RFC#846 Deprecate Proxies](https://rfcs.emberjs.com/id/0846-ember-data-deprecate-proxies)
+ *
+ * Deprecates using the proxy object/proxy array capabilities of values returned from
+ *
+ *  - `store.findRecord`
+ *  - `store.findAll`
+ *  - `store.query`
+ *  - `store.queryRecord`
+ *  - `record.save`
+ *  - `recordArray.save`
+ *  - `recordArray.update`
+ *
+ * These methods will now return a native Promise that resolves with the value.
+ *
+ * Note that this does not deprecate the proxy behaviors of `PromiseBelongsTo`. See RFC for reasoning.
+ * The opportunity should still be taken if available to stop using these proxy behaviors; however, this class
+ * will remain until `import Model from '@ember-data-mirror/model';` is deprecated more broadly.
+ *
+ * @property DEPRECATE_PROMISE_PROXIES
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_PROMISE_PROXIES = '4.7';
+
+/**
+ * **id: ember-data:deprecate-array-like**
+ *
+ * Deprecates Ember "Array-like" methods on RecordArray and ManyArray.
+ *
+ * These are the arrays returned respectively by `store.peekAll()`, `store.findAll()`and
+ * hasMany relationships on instance of Model or `record.hasMany('relationshipName').value()`.
+ *
+ * The appropriate refactor is to treat these arrays as native arrays and to use native array methods.
+ *
+ * For instance, instead of:
+ *
+ *  ```ts
+ * users.firstObject;
+ * ```
+ *
+ * Use:
+ *
+ * ```ts
+ * users[0];
+ * // or
+ * users.at(0);
+ * ```
+ *
+ * @property DEPRECATE_ARRAY_LIKE
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_ARRAY_LIKE = '4.7';
+
+/**
+ * **id: <none yet assigned>**
+ *
+ * This is a planned deprecation which will trigger when observer or computed
+ * chains are used to watch for changes on any EmberData RecordArray, ManyArray
+ * or PromiseManyArray.
+ *
+ * Support for these chains is currently guarded by the inactive deprecation flag
+ * listed here.
+ *
+ * @property DEPRECATE_COMPUTED_CHAINS
+ * @since 5.0
+ * @until 6.0
+ * @public
+ */
+const DEPRECATE_COMPUTED_CHAINS = '5.0';
+
+/**
+ * **id: ember-data:non-explicit-relationships**
+ *
+ * Deprecates when polymorphic relationships are detected via inheritance or mixins
+ * and no polymorphic relationship configuration has been setup.
+ *
+ * For further reading please review [RFC#793](https://rfcs.emberjs.com/id/0793-polymporphic-relations-without-inheritance)
+ * which introduced support for explicit relationship polymorphism without
+ * mixins or inheritance.
+ *
+ * You may still use mixins and inheritance to setup your polymorphism; however, the class
+ * structure is no longer what drives the design. Instead polymorphism is "traits" based or "structural":
+ * so long as each model which can satisfy the polymorphic relationship defines the inverse in the same
+ * way they work.
+ *
+ * Notably: `inverse: null` relationships can receive any type as a record with no additional configuration
+ * at all.
+ *
+ * Example Polymorphic Relationship Configuration
+ *
+ * ```ts
+ * // polymorphic relationship
+ * class Tag extends Model {
+ *    @hasMany("taggable", { async: false, polymorphic: true, inverse: "tags" }) tagged;
+ * }
+ *
+ * // an inverse concrete relationship (e.g. satisfies "taggable")
+ * class Post extends Model {
+ *    @hasMany("tag", { async: false, inverse: "tagged", as: "taggable" }) tags;
+ * }
+ * ```
+ *
+ * @property DEPRECATE_NON_EXPLICIT_POLYMORPHISM
+ * @since 4.7
+ * @until 5.0
+ * @public
+ */
+const DEPRECATE_NON_EXPLICIT_POLYMORPHISM = '4.7';
+
+/**
+ * **id: ember-data:deprecate-many-array-duplicates**
+ *
+ * When the flag is `true` (default), adding duplicate records to a `ManyArray`
+ * is deprecated in non-production environments. In production environments,
+ * duplicate records added to a `ManyArray` will be deduped and no error will
+ * be thrown.
+ *
+ * When the flag is `false`, an error will be thrown when duplicates are added.
+ *
+ * @property DEPRECATE_MANY_ARRAY_DUPLICATES
+ * @since 5.3
+ * @until 6.0
+ * @public
+ */
+const DEPRECATE_MANY_ARRAY_DUPLICATES = '4.12'; // '5.3';
+
 /**
  * **id: ember-data:deprecate-non-strict-types**
  *
@@ -180,42 +795,6 @@ const DEPRECATE_NON_STRICT_TYPES = '5.3';
  */
 const DEPRECATE_NON_STRICT_ID = '5.3';
 
-/**
- * **id: <none yet assigned>**
- *
- * This is a planned deprecation which will trigger when observer or computed
- * chains are used to watch for changes on any EmberData LiveArray, CollectionRecordArray,
- * ManyArray or PromiseManyArray.
- *
- * Support for these chains is currently guarded by the deprecation flag
- * listed here, enabling removal of the behavior if desired.
- *
- * @property DEPRECATE_COMPUTED_CHAINS
- * @since 5.0
- * @until 6.0
- * @public
- */
-const DEPRECATE_COMPUTED_CHAINS = '5.0';
-
-/**
- * **id: ember-data:deprecate-legacy-imports**
- *
- * Deprecates when importing from `ember-data/*` instead of `@ember-data/*`
- * in order to prepare for the eventual removal of the legacy `ember-data/*`
- *
- * All imports from `ember-data/*` should be updated to `@ember-data/*`
- * except for `ember-data/store`. When you are using `ember-data` (as opposed to
- * installing the indivudal packages) you should import from `ember-data/store`
- * instead of `@ember-data-mirror/store` in order to receive the appropriate configuration
- * of defaults.
- *
- * @property DEPRECATE_LEGACY_IMPORTS
- * @since 5.3
- * @until 6.0
- * @public
- */
-const DEPRECATE_LEGACY_IMPORTS = '5.3';
-
 /**
  * **id: ember-data:deprecate-non-unique-collection-payloads**
  *
@@ -406,23 +985,6 @@ const DEPRECATE_NON_UNIQUE_PAYLOADS = '5.3';
  */
 const DEPRECATE_RELATIONSHIP_REMOTE_UPDATE_CLEARING_LOCAL_STATE = '5.3';
 
-/**
- * **id: ember-data:deprecate-many-array-duplicates**
- *
- * When the flag is `true` (default), adding duplicate records to a `ManyArray`
- * is deprecated in non-production environments. In production environments,
- * duplicate records added to a `ManyArray` will be deduped and no error will
- * be thrown.
- *
- * When the flag is `false`, an error will be thrown when duplicates are added.
- *
- * @property DEPRECATE_MANY_ARRAY_DUPLICATES
- * @since 5.3
- * @until 6.0
- * @public
- */
-const DEPRECATE_MANY_ARRAY_DUPLICATES = '5.3';
-
 /**
  * **id: ember-data:deprecate-store-extends-ember-object**
  *
@@ -494,44 +1056,90 @@ const ENABLE_LEGACY_SCHEMA_SERVICE = '5.4';
  */
 const DEPRECATE_EMBER_INFLECTOR = '5.3';
 
+/**
+ * This is a special flag that can be used to opt-in early to receiving deprecations introduced in 5.x
+ * which have had their infra backported to 4.x versions of EmberData.
+ *
+ * When this flag is not present or set to `true`, the deprecations from the 5.x branch
+ * will not print their messages and the deprecation cannot be resolved.
+ *
+ * When this flag is present and set to `false`, the deprecations from the 5.x branch will
+ * print and can be resolved.
+ *
+ * @property DISABLE_6X_DEPRECATIONS
+ * @since 4.13
+ * @until 5.0
+ * @public
+ */
+const DISABLE_6X_DEPRECATIONS = '6.0';
+
 const CURRENT_DEPRECATIONS = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
+  DEPRECATE_ARRAY_LIKE,
+  DEPRECATE_A_USAGE,
   DEPRECATE_CATCH_ALL,
   DEPRECATE_COMPUTED_CHAINS,
+  DEPRECATE_EARLY_STATIC,
   DEPRECATE_EMBER_INFLECTOR,
-  DEPRECATE_LEGACY_IMPORTS,
+  DEPRECATE_HAS_RECORD,
+  DEPRECATE_HELPERS,
+  DEPRECATE_JSON_API_FALLBACK,
   DEPRECATE_MANY_ARRAY_DUPLICATES,
+  DEPRECATE_MODEL_REOPEN,
+  DEPRECATE_NON_EXPLICIT_POLYMORPHISM,
   DEPRECATE_NON_STRICT_ID,
   DEPRECATE_NON_STRICT_TYPES,
   DEPRECATE_NON_UNIQUE_PAYLOADS,
+  DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS,
+  DEPRECATE_PROMISE_PROXIES,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE,
   DEPRECATE_RELATIONSHIP_REMOTE_UPDATE_CLEARING_LOCAL_STATE,
+  DEPRECATE_RSVP_PROMISE,
+  DEPRECATE_SAVE_PROMISE_ACCESS,
+  DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS,
   DEPRECATE_STORE_EXTENDS_EMBER_OBJECT,
+  DEPRECATE_STORE_FIND,
+  DEPRECATE_STRING_ARG_SCHEMAS,
+  DISABLE_6X_DEPRECATIONS,
   ENABLE_LEGACY_SCHEMA_SERVICE
 }, Symbol.toStringTag, { value: 'Module' }));
 
 function deprecationIsResolved(deprecatedSince, compatVersion) {
   return semver.lte(semver.minVersion(deprecatedSince), semver.minVersion(compatVersion));
 }
-function getDeprecations(compatVersion) {
+const NextMajorVersion = '5.';
+function deprecationIsNextMajorCycle(deprecatedSince) {
+  return deprecatedSince.startsWith(NextMajorVersion);
+}
+function getDeprecations(compatVersion, deprecations) {
   const flags = {};
   const keys = Object.keys(CURRENT_DEPRECATIONS);
+  const DISABLE_6X_DEPRECATIONS = deprecations?.DISABLE_6X_DEPRECATIONS ?? true;
   keys.forEach(flag => {
     const deprecatedSince = CURRENT_DEPRECATIONS[flag];
+    const isDeactivatedDeprecationNotice = DISABLE_6X_DEPRECATIONS && deprecationIsNextMajorCycle(deprecatedSince);
     let flagState = true; // default to no code-stripping
 
-    // if we are told we are compatible with a version
-    // we check if we can strip this flag
-    if (compatVersion) {
-      const isResolved = deprecationIsResolved(deprecatedSince, compatVersion);
-      // if we've resolved, we strip (by setting the flag to false)
-      /*
+    if (!isDeactivatedDeprecationNotice) {
+      // if we have a specific flag setting, use it
+      if (typeof deprecations?.[flag] === 'boolean') {
+        flagState = deprecations?.[flag];
+      } else if (compatVersion) {
+        // if we are told we are compatible with a version
+        // we check if we can strip this flag
+        const isResolved = deprecationIsResolved(deprecatedSince, compatVersion);
+        // if we've resolved, we strip (by setting the flag to false)
+        /*
         if (DEPRECATED_FEATURE) {
           // deprecated code path
         } else {
           // if needed a non-deprecated code path
         }
-      */
-      flagState = !isResolved;
+        */
+        flagState = !isResolved;
+      }
     }
 
     // console.log(`${flag}=${flagState} (${deprecatedSince} <= ${compatVersion})`);
@@ -846,7 +1454,7 @@ function setConfig(context, appRoot, config) {
 
   const debugOptions = Object.assign({}, LOGGING, config.debug);
   const env = getEnv();
-  const DEPRECATIONS = getDeprecations(config.compatWith || null);
+  const DEPRECATIONS = getDeprecations(config.compatWith || null, config.deprecations);
   const FEATURES = getFeatures(env.PRODUCTION);
   const includeDataAdapterInProduction = typeof config.includeDataAdapterInProduction === 'boolean' ? config.includeDataAdapterInProduction : true;
   const includeDataAdapter = env.PRODUCTION ? includeDataAdapterInProduction : true;