@warp-drive/legacy 5.8.0-alpha.4 → 5.8.0-alpha.41

package/dist/unpkg/prod/model.js

@@ -0,0 +1,593 @@
+import { computed } from '@ember/object';
+import { recordIdentifierFor } from '@warp-drive/core';
+import { RecordStore } from '@warp-drive/core/types/symbols';
+import { i as isElementDescriptor, n as normalizeModelName } from "./util-DvanW33H.js";
+import { assertPrivateStore } from '@warp-drive/core/store/-private';
+import { l as lookupLegacySupport } from "./errors-BGVFCBmi.js";
+import '@warp-drive/utilities/string';
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DJtD_8jZ.js";
+export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-BztVA_x0.js";
+
+/**
+ * Options provided to the attr decorator are
+ * supplied to the associated transform. Any
+ * key-value pair is valid; however, it is highly
+ * recommended to only use statically defined values
+ * that could be serialized to JSON.
+ *
+ * If no transform is provided, the only valid
+ * option is `defaultValue`.
+ *
+ * Examples:
+ *
+ * ```ts
+ * class User extends Model {
+ *  @attr('string', { defaultValue: 'Anonymous' }) name;
+ *  @attr('date', { defaultValue: () => new Date() }) createdAt;
+ *  @attr({ defaultValue: () => ({}) }) preferences;
+ *  @attr('boolean') hasVerifiedEmail;
+ *  @attr address;
+ * }
+ *
+ * @class NOTATHING
+ */
+
+function _attr(type, options) {
+  if (typeof type === 'object') {
+    options = type;
+    type = undefined;
+  } else {
+    options = options || {};
+  }
+  const meta = {
+    type: type,
+    kind: 'attribute',
+    isAttribute: true,
+    options: options,
+    key: null
+  };
+  return computed({
+    get(key) {
+      if (this.isDestroyed || this.isDestroying) {
+        return;
+      }
+      const cache = this[RecordStore].cache;
+      return cache.getAttr(recordIdentifierFor(this), key);
+    },
+    set(key, value) {
+      const identifier = recordIdentifierFor(this);
+      const cache = this[RecordStore].cache;
+      const currentValue = cache.getAttr(identifier, key);
+      if (currentValue !== value) {
+        cache.setAttr(identifier, key, value);
+        if (!this.isValid) {
+          const {
+            errors
+          } = this;
+          if (errors.get(key)) {
+            errors.remove(key);
+            this.currentState.cleanErrorRequests();
+          }
+        }
+      }
+      return value;
+    }
+  }).meta(meta);
+}
+
+// NOTE: Usage of Explicit ANY
+// -------------------------------------------------------------------
+// any is required here because we are the maximal not the minimal
+// subset of options allowed. If we used unknown, object, or
+// Record<string, unknown> we would get type errors when we try to
+// assert against a more specific implementation with precise options.
+// -------------------------------------------------------------------
+
+// see note on Explicit ANY above
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * The return type of `void` is a lie to appease TypeScript. The actual return type
+ * is a descriptor, but typescript incorrectly insists that decorator functions return
+ * `void` or `any`.
+ *
+ */
+
+/**
+  `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.
+  WarpDrive ships with four basic transform types: `string`, `number`,
+  `boolean` and `date`. You can define your own transforms by subclassing
+  {@link 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
+
+  ```js [app/models/user.js]
+  import { Model, attr } from '@warp-drive/legacy/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.
+
+  ```js [app/models/user.js]
+  import { Model, attr } from '@warp-drive/legacy/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:
+
+  ```js [app/models/post.js]
+  import { Model, attr } from '@warp-drive/legacy/model';
+
+  export default class PostModel extends Model {
+    @attr('text', {
+      uppercase: true
+    })
+    text;
+  }
+  ```
+
+  ```js [app/transforms/text.js]
+  export default class TextTransform {
+    serialize(value, options) {
+      if (options.uppercase) {
+        return value.toUpperCase();
+      }
+
+      return value;
+    }
+
+    deserialize(value) {
+      return value;
+    }
+
+    static create() {
+      return new this();
+    }
+  }
+  ```
+
+  @public
+  @param type the attribute type
+  @param options a hash of options
+*/
+
+// see note on DataDecorator for why void
+function attr(type, options, desc) {
+  const args = [type, options, desc];
+  // see note on DataDecorator for why void
+  return isElementDescriptor(args) ? _attr()(...args) : _attr(type, options);
+}
+
+// type BelongsToDecoratorObject<getT> = {
+//   get: () => getT;
+//   // set: (value: Awaited<getT>) => void;
+//   set: (value: getT) => void;
+//   // init: () => getT;
+// };
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+// BelongsToDecoratorObject<getT>;
+
+function _belongsTo(type, options) {
+  const meta = {
+    type: normalizeModelName(type),
+    options: options,
+    kind: 'belongsTo',
+    name: '<Unknown BelongsTo>'
+  };
+  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);
+      return support.getBelongsTo(key);
+    },
+    set(key, value) {
+      if (this.isDestroying || this.isDestroyed) {
+        return null;
+      }
+      const support = lookupLegacySupport(this);
+      assertPrivateStore(this[RecordStore]);
+      this[RecordStore]._join(() => {
+        support.setDirtyBelongsTo(key, value);
+      });
+      return support.getBelongsTo(key);
+    }
+  }).meta(meta);
+}
+
+/**
+  `belongsTo` is used to define One-To-One and One-To-Many, and One-To-None
+  relationships on a {@link Model}.
+
+  `belongsTo` takes a configuration hash as a second parameter, currently
+  supported options are:
+
+  - `async`: (*required*) A boolean value used to declare whether this is a sync (false) or async (true) relationship.
+  - `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.
+  - `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic
+  - `as`: (*optional*) A string used to declare the abstract type "this" record satisfies for polymorphism.
+
+  ### Examples
+
+  To declare a **one-to-many** (or many-to-many) relationship, use
+  `belongsTo` in combination with `hasMany`:
+
+  ```js
+  // app/models/comment.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Comment extends Model {
+    @belongsTo('post', { async: false, inverse: 'comments' }) post;
+  }
+
+  // app/models/post.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Post extends Model {
+    @hasMany('comment', { async: false, inverse: 'post' }) comments;
+  }
+  ```
+
+  To declare a **one-to-one** relationship with managed inverses, use `belongsTo` for both sides:
+
+  ```js
+  // app/models/author.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Author extends Model {
+    @belongsTo('address', { async: true, inverse: 'owner' }) address;
+  }
+
+  // app/models/address.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Address extends Model {
+    @belongsTo('author', { async: true, inverse: 'address' }) owner;
+  }
+  ```
+
+  To declare a **one-to-one** relationship without managed inverses, use `belongsTo` for both sides
+  with `null` as the inverse:
+
+  ```js
+  // app/models/author.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Author extends Model {
+    @belongsTo('address', { async: true, inverse: null }) address;
+  }
+
+  // app/models/address.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Address extends Model {
+    @belongsTo('author', { async: true, inverse: null }) owner;
+  }
+  ```
+
+  To declare a one-to-none relationship between two models, use
+  `belongsTo` with inverse set to `null` on just one side::
+
+  ```js
+  // app/models/person.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Person extends Model {
+    @belongsTo('person', { async: false, inverse: null }) bestFriend;
+  }
+  ```
+
+  #### Sync vs Async Relationships
+
+  WarpDrive fulfills relationships using resource data available in
+  the cache.
+
+  Sync relationships point directly to the known related resources.
+
+  When a relationship is declared as async, if any of the known related
+  resources have not been loaded, they will be fetched. The property
+  on the record when accessed provides a promise that resolves once
+  all resources are loaded.
+
+  Async relationships may take advantage of links. On access, if the related
+  link has not been loaded, or if any known resources are not available in
+  the cache, the fresh state will be fetched using the link.
+
+  In contrast to async relationship, accessing a sync relationship
+  will error on access when any of the known related resources have
+  not been loaded.
+
+  If you are using `links` with sync relationships, you have to use
+  the BelongsTo reference API to fetch or refresh related resources
+  that aren't loaded. For instance, for a `bestFriend` relationship:
+
+  ```js
+  person.belongsTo('bestFriend').reload();
+  ```
+
+  #### Polymorphic Relationships
+
+  To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
+  option set to `true`:
+
+  ```js
+  // app/models/comment.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Comment extends Model {
+    @belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
+  }
+  ```
+
+  `'commentable'` here is referred to as the "abstract type" for the polymorphic
+  relationship.
+
+  Polymorphic relationships with `inverse: null` will accept any type of record as their content.
+  Polymorphic relationships with `inverse` set to a string will only accept records with a matching
+  inverse relationships declaring itself as satisfying the abstract type.
+
+  Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'
+  for this relationship.
+
+  ```js
+  // app/models/post.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Post extends Model {
+    @hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
+  }
+  ```
+
+  Note: every Model that declares an inverse to a polymorphic relationship must
+  declare itself exactly the same. This is because polymorphism is based on structural
+  traits.
+
+  Polymorphic to polymorphic relationships are supported. Both sides of the relationship
+  must be declared as polymorphic, and the `as` option must be used to declare the abstract
+  type each record satisfies on both sides.
+
+  @public
+  @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>>(
+//   type: TypeFromInstance<NoNull<T>>,
+//   options: RelationshipOptions<T, true>
+// ): RelationshipDecorator<K>;
+
+function belongsTo(type, options) {
+  return _belongsTo(type, options);
+}
+function normalizeType(type) {
+  return type;
+}
+function _hasMany(type, options) {
+  // Metadata about relationships is stored on the meta of
+  // the relationship. This is used for introspection and
+  // serialization. Note that `key` is populated lazily
+  // the first time the CP is called.
+  const meta = {
+    type: normalizeType(type),
+    options,
+    kind: 'hasMany',
+    name: '<Unknown BelongsTo>'
+  };
+  return computed({
+    get(key) {
+      if (this.isDestroying || this.isDestroyed) {
+        return [];
+      }
+      return lookupLegacySupport(this).getHasMany(key);
+    },
+    set(key, records) {
+      const support = lookupLegacySupport(this);
+      const manyArray = support.getManyArray(key);
+      assertPrivateStore(this[RecordStore]);
+      this[RecordStore]._join(() => {
+        manyArray.splice(0, manyArray.length, ...records);
+      });
+      return support.getHasMany(key);
+    }
+  }).meta(meta);
+}
+
+/**
+  `hasMany` is used to define Many-To-One and Many-To-Many, and Many-To-None
+  relationships on a {@link Model}.
+
+  `hasMany` takes a configuration hash as a second parameter, currently
+  supported options are:
+
+  - `async`: (*required*) A boolean value used to declare whether this is a sync (false) or async (true) relationship.
+  - `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.
+  - `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic
+  - `as`: (*optional*) A string used to declare the abstract type "this" record satisfies for polymorphism.
+
+  ### Examples
+
+  To declare a **many-to-one** (or one-to-many) relationship, use
+  `belongsTo` in combination with `hasMany`:
+
+  ```js
+  // app/models/post.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Post extends Model {
+    @hasMany('comment', { async: false, inverse: 'post' }) comments;
+  }
+
+
+  // app/models/comment.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Comment extends Model {
+    @belongsTo('post', { async: false, inverse: 'comments' }) post;
+  }
+  ```
+
+  To declare a **many-to-many** relationship with managed inverses, use `hasMany` for both sides:
+
+  ```js
+  // app/models/post.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Post extends Model {
+    @hasMany('tag', { async: true, inverse: 'posts' }) tags;
+  }
+
+  // app/models/tag.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Tag extends Model {
+    @hasMany('post', { async: true, inverse: 'tags' }) posts;
+  }
+  ```
+
+  To declare a **many-to-many** relationship without managed inverses, use `hasMany` for both sides
+  with `null` as the inverse:
+
+  ```js
+  // app/models/post.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Post extends Model {
+    @hasMany('tag', { async: true, inverse: null }) tags;
+  }
+
+  // app/models/tag.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Tag extends Model {
+    @hasMany('post', { async: true, inverse: null }) posts;
+  }
+  ```
+
+  To declare a many-to-none relationship between two models, use
+  `hasMany` with inverse set to `null` on just one side::
+
+  ```js
+  // app/models/post.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Post extends Model {
+    @hasMany('category', { async: true, inverse: null }) categories;
+  }
+  ```
+
+  #### Sync vs Async Relationships
+
+  WarpDrive fulfills relationships using resource data available in
+  the cache.
+
+  Sync relationships point directly to the known related resources.
+
+  When a relationship is declared as async, if any of the known related
+  resources have not been loaded, they will be fetched. The property
+  on the record when accessed provides a promise that resolves once
+  all resources are loaded.
+
+  Async relationships may take advantage of links. On access, if the related
+  link has not been loaded, or if any known resources are not available in
+  the cache, the fresh state will be fetched using the link.
+
+  In contrast to async relationship, accessing a sync relationship
+  will error on access when any of the known related resources have
+  not been loaded.
+
+  If you are using `links` with sync relationships, you have to use
+  the HasMany reference API to fetch or refresh related resources
+  that aren't loaded. For instance, for a `comments` relationship:
+
+  ```js
+  post.hasMany('comments').reload();
+  ```
+
+  #### Polymorphic Relationships
+
+  To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
+  option set to `true`:
+
+  ```js
+  // app/models/comment.js
+  import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+  export default class Comment extends Model {
+    @belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
+  }
+  ```
+
+  `'commentable'` here is referred to as the "abstract type" for the polymorphic
+  relationship.
+
+  Polymorphic relationships with `inverse: null` will accept any type of record as their content.
+  Polymorphic relationships with `inverse` set to a string will only accept records with a matching
+  inverse relationships declaring itself as satisfying the abstract type.
+
+  Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'
+  for this relationship.
+
+  ```js
+  // app/models/post.js
+  import { Model, hasMany } from '@warp-drive/legacy/model';
+
+  export default class Post extends Model {
+    @hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
+  }
+  ```
+
+  Note: every Model that declares an inverse to a polymorphic relationship must
+  declare itself exactly the same. This is because polymorphism is based on structural
+  traits.
+
+  Polymorphic to polymorphic relationships are supported. Both sides of the relationship
+  must be declared as polymorphic, and the `as` option must be used to declare the abstract
+  type each record satisfies on both sides.
+
+  @public
+  @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>>(
+//   type: TypeFromInstance<NoNull<T>>,
+//   options: RelationshipOptions<T, true>
+// ): RelationshipDecorator<K>;
+
+function hasMany(type, options) {
+  return _hasMany(type, options);
+}
+export { attr, belongsTo, hasMany };

package/dist/unpkg/prod/runtime-BPCpkOf1-BKOwiRJp.js

@@ -0,0 +1,65 @@
+const deferred = /* @__PURE__ */new WeakMap();
+function deferDecorator(proto, prop, desc) {
+  let map = deferred.get(proto);
+  if (!map) {
+    map = /* @__PURE__ */new Map();
+    deferred.set(proto, map);
+  }
+  map.set(prop, desc);
+}
+function findDeferredDecorator(target, prop) {
+  var _a;
+  let cursor = target.prototype;
+  while (cursor) {
+    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
+    if (desc) {
+      return desc;
+    }
+    cursor = cursor.prototype;
+  }
+}
+function decorateFieldV2(prototype, prop, decorators, initializer) {
+  let desc = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  };
+  if (initializer) {
+    desc.initializer = initializer;
+  }
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer === void 0) {
+    Object.defineProperty(prototype, prop, desc);
+  } else {
+    deferDecorator(prototype, prop, desc);
+  }
+}
+function decorateMethodV2(prototype, prop, decorators) {
+  const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
+  let desc = {
+    ...origDesc
+  };
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(prototype) : void 0;
+    desc.initializer = void 0;
+  }
+  Object.defineProperty(prototype, prop, desc);
+}
+function initializeDeferredDecorator(target, prop) {
+  let desc = findDeferredDecorator(target.constructor, prop);
+  if (desc) {
+    Object.defineProperty(target, prop, {
+      enumerable: desc.enumerable,
+      configurable: desc.configurable,
+      writable: desc.writable,
+      value: desc.initializer ? desc.initializer.call(target) : void 0
+    });
+  }
+}
+export { decorateFieldV2 as a, decorateMethodV2 as d, initializeDeferredDecorator as i };