@warp-drive/legacy 5.8.0-beta.0 → 5.8.0-beta.2

package/dist/model-for-CqXsIKws.js

@@ -0,0 +1,221 @@
+import { tracked, cached } from '@glimmer/tracking';
+import { Context } from '@warp-drive/core/reactive/-private';
+import { a as decorateFieldV2, i as initializeDeferredDecorator, d as decorateMethodV2 } from "./runtime-BPCpkOf1-BKOwiRJp.js";
+class Fragment {
+  static {
+    decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  static {
+    decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  get hasDirtyAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    const record = store.peekRecord(resourceKey);
+    if (record.hasDirtyAttributes && path) {
+      const root = path.at(0);
+      return root in record.changedAttributes();
+    }
+    return false;
+  }
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
+  }
+  get isFragment() {
+    return true;
+  }
+  get $type() {
+    const {
+      field
+    } = this[Context];
+    return field?.type;
+  }
+  rollbackAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    if (path) {
+      const oldValue = store.cache.getRemoteAttr(resourceKey, path);
+      store.cache.setAttr(resourceKey, path, oldValue);
+    }
+  }
+}
+const FragmentExtension = {
+  kind: 'object',
+  name: 'fragment',
+  features: Fragment
+};
+class FragmentArray {
+  static {
+    decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  static {
+    decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  get hasDirtyAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    const record = store.peekRecord(resourceKey);
+    if (record.hasDirtyAttributes && path) {
+      const root = path.at(0);
+      return root in record.changedAttributes();
+    }
+    return false;
+  }
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
+  }
+  addFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    return this.addObject(fragment);
+  }
+  createFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    return this.pushObject(fragment);
+  }
+  removeFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    const index = this.indexOf(fragment);
+    if (index !== -1) {
+      this.splice(index, 1);
+    }
+  }
+  rollbackAttributes() {
+    for (const fragment of this) {
+      // @ts-expect-error TODO: fix these types
+      fragment?.rollbackAttributes?.();
+    }
+  }
+}
+const FragmentArrayExtension = {
+  kind: 'array',
+  name: 'fragment-array',
+  features: FragmentArray
+};
+
+// if modelFor turns out to be a bottleneck we should replace with a Map
+// and clear it during store teardown.
+const AvailableShims = new WeakMap();
+function getShimClass(store, modelName) {
+  let shims = AvailableShims.get(store);
+  if (!shims) {
+    shims = Object.create(null);
+    AvailableShims.set(store, shims);
+  }
+  let shim = shims[modelName];
+  if (shim === undefined) {
+    shim = shims[modelName] = new ShimModelClass(store, modelName);
+  }
+  return shim;
+}
+const AttributeKinds = ['field', 'attribute', 'object', 'array', 'schema-object', 'schema-array'];
+
+// Mimics the static apis of @warp-drive/legacy/model
+class ShimModelClass {
+  constructor(store, modelName) {
+    this.__store = store;
+    this.modelName = modelName;
+  }
+  get fields() {
+    const fields = new Map();
+    const fieldSchemas = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fieldSchemas.forEach((schema, key) => {
+      // @ts-expect-error checking if a string is a valid string
+      if (AttributeKinds.includes(schema.kind)) {
+        fields.set(key, 'attribute');
+      } else if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        fields.set(key, schema.kind);
+      }
+    });
+    return fields;
+  }
+  get attributes() {
+    const attrs = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        attrs.set(key, schema);
+        // @ts-expect-error checking if a string is a valid string
+      } else if (AttributeKinds.includes(schema.kind)) {
+        attrs.set(key, {
+          kind: 'attribute',
+          name: key,
+          type: null,
+          options: schema.options ?? {}
+        });
+      }
+    });
+    return attrs;
+  }
+  get relationshipsByName() {
+    const rels = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        rels.set(key, schema);
+      }
+    });
+    return rels;
+  }
+  eachAttribute(callback, binding) {
+    this.attributes.forEach((schema, key) => {
+      callback.call(binding, key, schema);
+    });
+  }
+  eachRelationship(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        callback.call(binding, key, schema);
+      }
+    });
+  }
+  eachTransformedAttribute(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        const type = schema.type;
+        if (type) callback.call(binding, key, type);
+      }
+    });
+  }
+}
+function fragmentsModelFor(modelName) {
+  return getShimClass(this, modelName);
+}
+const modelFor = fragmentsModelFor;
+export { FragmentExtension as F, FragmentArrayExtension as a, FragmentArray as b, Fragment as c, fragmentsModelFor as f, modelFor as m };

package/dist/model-fragments.js

@@ -0,0 +1,76 @@
+import { singularize, pluralize } from '@warp-drive/utilities/string';
+import { withDefaults } from './model/migration-support.js';
+import { F as FragmentExtension, a as FragmentArrayExtension } from "./model-for-CqXsIKws.js";
+export { c as Fragment, b as FragmentArray, m as modelFor } from "./model-for-CqXsIKws.js";
+
+/**
+ * Used as a helper to setup the relevant parts of an array
+ * schema and add extensions etc.
+ *
+ * @param arrayName The name of the array
+ * @returns The schema for an array
+ */
+function withArrayDefaults(arrayName) {
+  return {
+    kind: 'array',
+    name: arrayName,
+    type: `array:${singularize(arrayName)}`,
+    options: {
+      arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array']
+    }
+  };
+}
+
+/**
+ * Used as a helper to setup the relevant parts of a fragment schema
+ * and add extensions etc.
+ *
+ * @param fragmentType The type of the fragment
+ * @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.
+ * @returns The schema for a fragment
+ */
+function withFragmentDefaults(fragmentType, fragmentName) {
+  return {
+    kind: 'schema-object',
+    type: `fragment:${fragmentType}`,
+    name: fragmentName ?? fragmentType,
+    options: {
+      objectExtensions: ['ember-object', 'fragment']
+    }
+  };
+}
+
+/**
+ * Used as a helper to setup the relevant parts of a fragment-array
+ * schema and add extensions etc.
+ *
+ * @param fragmentArrayType The type of the fragment-array
+ * @param fragmentArrayName The name of the fragment-array
+ * @returns The schema for a fragment-array
+ */
+function withFragmentArrayDefaults(fragmentArrayType, fragmentArrayName) {
+  return {
+    kind: 'schema-array',
+    type: `fragment:${singularize(fragmentArrayType)}`,
+    name: fragmentArrayName ?? pluralize(fragmentArrayType),
+    options: {
+      arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array'],
+      defaultValue: true
+    }
+  };
+}
+function withLegacy(schema) {
+  return withDefaults({
+    ...schema,
+    identity: {
+      kind: '@id',
+      name: 'id'
+    },
+    objectExtensions: ['ember-object', 'fragment']
+  });
+}
+function registerFragmentExtensions(schema) {
+  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
+  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
+}
+export { FragmentArrayExtension, FragmentExtension, registerFragmentExtensions, withArrayDefaults, withFragmentArrayDefaults, withFragmentDefaults, withLegacy };

package/dist/model.js

@@ -4,12 +4,11 @@ import { RecordStore } from '@warp-drive/core/types/symbols';
 import { i as isElementDescriptor, n as normalizeModelName } from "./util-Dul6TZts.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
-import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
-import { l as lookupLegacySupport } from "./errors-8kD2mSe_.js";
+import { assertPrivateStore } from '@warp-drive/core/store/-private';
+import { l as lookupLegacySupport } from "./errors-Cz5KrzBk.js";
 import { singularize, dasherize } from '@warp-drive/utilities/string';
-import { l as getModelFactory } from "./schema-provider-DQu4Rjco.js";
-export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DQu4Rjco.js";
-import { setOwner, getOwner } from '@ember/application';
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DJCV_6AF.js";
+export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-D6diaM34.js";
 function _attr(type, options) {
   if (typeof type === 'object') {
     options = type;
@@ -87,12 +86,12 @@ function _attr(type, options) {
  */
 
 /**
-  `attr` defines an attribute on a [Model](/ember-data/release/classes/Model).
+  `attr` defines an attribute on a {@link Model}.
   By default, attributes are passed through as-is, however you can specify an
   optional type to have the value automatically transformed.
-  EmberData ships with four basic transform types: `string`, `number`,
+  WarpDrive 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).
+  {@link Transform}.
 
   Note that you cannot use `attr` to define an attribute of `id`.
 
@@ -169,9 +168,8 @@ function _attr(type, options) {
   ```
 
   @public
-  @param {String|Object} type the attribute type
-  @param {Object} options a hash of options
-  @return {Attribute}
+  @param type the attribute type
+  @param options a hash of options
 */
 
 // see note on DataDecorator for why void
@@ -258,7 +256,7 @@ function _belongsTo(type, options) {
 
 /**
   `belongsTo` is used to define One-To-One and One-To-Many, and One-To-None
-  relationships on a [Model](/ember-data/release/classes/Model).
+  relationships on a {@link Model}.
 
   `belongsTo` takes a configuration hash as a second parameter, currently
   supported options are:
@@ -340,7 +338,7 @@ function _belongsTo(type, options) {
 
   #### Sync vs Async Relationships
 
-  EmberData fulfills relationships using resource data available in
+  WarpDrive fulfills relationships using resource data available in
   the cache.
 
   Sync relationships point directly to the known related resources.
@@ -408,9 +406,8 @@ function _belongsTo(type, options) {
   type each record satisfies on both sides.
 
   @public
-  @param {String} type (optional) the name of the related resource
-  @param {Object} options (optional) a hash of options
-  @return {PropertyDescriptor} relationship
+  @param type the name of the related resource
+  @param options a hash of options
 */
 
 // export function belongsTo<K extends Promise<unknown>, T extends Awaited<K> = Awaited<K>>(
@@ -497,7 +494,7 @@ function _hasMany(type, options) {
 
 /**
   `hasMany` is used to define Many-To-One and Many-To-Many, and Many-To-None
-  relationships on a [Model](/ember-data/release/classes/Model).
+  relationships on a {@link Model}.
 
   `hasMany` takes a configuration hash as a second parameter, currently
   supported options are:
@@ -580,7 +577,7 @@ function _hasMany(type, options) {
 
   #### Sync vs Async Relationships
 
-  EmberData fulfills relationships using resource data available in
+  WarpDrive fulfills relationships using resource data available in
   the cache.
 
   Sync relationships point directly to the known related resources.
@@ -648,9 +645,8 @@ function _hasMany(type, options) {
   type each record satisfies on both sides.
 
   @public
-  @param {String} type (optional) the name of the related resource
-  @param {Object} options (optional) a hash of options
-  @return {PropertyDescriptor} relationship
+  @param type the name of the related resource
+  @param options a hash of options
 */
 
 // export function hasMany<K extends Promise<unknown>, T extends Awaited<K> = Awaited<K>>(
@@ -668,72 +664,4 @@ function hasMany(type, options) {
   }
   return _hasMany(type, options);
 }
-function instantiateRecord(identifier, createRecordArgs) {
-  const type = identifier.type;
-
-  // TODO deprecate allowing unknown args setting
-  const createOptions = {
-    _createProps: createRecordArgs,
-    // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
-    _secretInit: {
-      identifier,
-      store: this,
-      cb: secretInit
-    }
-  };
-
-  // ensure that `getOwner(this)` works inside a model instance
-  setOwner(createOptions, getOwner(this));
-  const factory = getModelFactory(this, type);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`No model was found for '${type}'`);
-    }
-  })(factory) : {};
-  return factory.class.create(createOptions);
-}
-function teardownRecord(record) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`expected to receive an instance of Model from @ember-data/model. If using a custom model make sure you implement teardownRecord`);
-    }
-  })('destroy' in record) : {};
-  record.destroy();
-}
-function modelFor(modelName) {
-  assertPrivateStore(this);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Attempted to call store.modelFor(), but the store instance has already been destroyed.`);
-    }
-  })(!this.isDestroyed && !this.isDestroying) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`You need to pass a model name to the store's modelFor method`);
-    }
-  })(modelName) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Please pass a proper model name to the store's modelFor method`);
-    }
-  })(typeof modelName === 'string' && modelName.length) : {};
-  const type = normalizeModelName(modelName);
-  const maybeFactory = getModelFactory(this, type);
-  const klass = maybeFactory && maybeFactory.class ? maybeFactory.class : null;
-  const ignoreType = !klass || !klass.isModel || this._forceShim;
-  if (!ignoreType) {
-    return klass;
-  }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`No model was found for '${type}' and no schema handles the type`);
-    }
-  })(this.schema.hasResource({
-    type
-  })) : {};
-}
-function secretInit(record, identifier, store) {
-  setRecordIdentifier(record, identifier);
-  StoreMap.set(record, store);
-}
-export { attr, belongsTo, hasMany, instantiateRecord, modelFor, teardownRecord };
+export { attr, belongsTo, hasMany };