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

package/dist/unpkg/prod-deprecated/compat/-private.js

@@ -0,0 +1 @@
+export { F as FetchManager, S as SaveOp, b as Snapshot, a as SnapshotRecordArray, u as upgradeStore } from "../-private-BdyZaGEh.js";

package/dist/unpkg/prod-deprecated/compat/builders.js

@@ -0,0 +1,210 @@
+import { SkipCache } from '@warp-drive/core/types/request';
+import { n as normalizeModelName, i as isMaybeIdentifier } from "../utils-BUWwQwCh.js";
+import { ensureStringId, constructResource, assertPrivateStore } from '@warp-drive/core/store/-private';
+import { storeFor, recordIdentifierFor } from '@warp-drive/core';
+
+/**
+  This function builds a request config to perform a `findAll` request for the given type.
+  When passed to `store.request`, this config will result in the same behavior as a `store.findAll` request.
+  Additionally, it takes the same options as `store.findAll`.
+
+  All `@warp-drive/legacy/compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+  To that end, these builders are deprecated and will be removed in a future version of WarpDrive.
+
+  @deprecated
+  @public
+  @param type the name of the resource
+  @param query a query to be used by the adapter
+  @param options optional, may include `adapterOptions` hash which will be passed to adapter.findAll
+  @return request config
+*/
+
+function findAllBuilder(type, options = {}) {
+  return {
+    op: 'findAll',
+    data: {
+      type: normalizeModelName(type),
+      options: options || {}
+    },
+    cacheOptions: {
+      [SkipCache]: true
+    }
+  };
+}
+
+/**
+  This function builds a request config to find the record for a given identifier or type and id combination.
+  When passed to `store.request`, this config will result in the same behavior as a `store.findRecord` request.
+  Additionally, it takes the same options as `store.findRecord`, with the exception of `preload` (which is unsupported).
+
+  **Example 1**
+
+  ```ts
+  import { findRecord } from '@warp-drive/legacy/compat/builders';
+  const { content: post } = await store.request<Post>(findRecord<Post>('post', '1'));
+  ```
+
+  **Example 2**
+
+  `findRecord` can be called with a single identifier argument instead of the combination
+  of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
+  the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)
+
+  ```ts
+  import { findRecord } from '@warp-drive/legacy/compat/builders';
+  const { content: post } = await store.request<Post>(findRecord<Post>({ type: 'post', id }));
+  ```
+
+  All `@warp-drive/legacy/compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+  To that end, these builders are deprecated and will be removed in a future version of Warp Drive.
+
+  @deprecated
+  @public
+  @param resource - either a string representing the name of the resource or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
+  @param id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
+  @param options - if the first param is a string this will be the optional options for the request. See examples for available options.
+  @return request config
+*/
+
+function findRecordBuilder(resource, idOrOptions, options) {
+  if (isMaybeIdentifier(resource)) {
+    options = idOrOptions;
+  } else {
+    const type = normalizeModelName(resource);
+    const normalizedId = ensureStringId(idOrOptions);
+    resource = constructResource(type, normalizedId);
+  }
+  options = options || {};
+  return {
+    op: 'findRecord',
+    data: {
+      record: resource,
+      options
+    },
+    cacheOptions: {
+      [SkipCache]: true
+    }
+  };
+}
+
+/**
+  This function builds a request config for a given type and query object.
+  When passed to `store.request`, this config will result in the same behavior as a `store.query` request.
+  Additionally, it takes the same options as `store.query`.
+
+  All `@warp-drive/legacy/compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+  To that end, these builders are deprecated and will be removed in a future version of WarpDrive.
+
+  @deprecated
+  @public
+  @param type the name of the resource
+  @param query a query to be used by the adapter
+  @param options optional, may include `adapterOptions` hash which will be passed to adapter.query
+  @return request config
+*/
+
+function queryBuilder(type, query, options = {}) {
+  return {
+    op: 'query',
+    data: {
+      type: normalizeModelName(type),
+      query,
+      options: options
+    },
+    cacheOptions: {
+      [SkipCache]: true
+    }
+  };
+}
+
+/**
+  This function builds a request config for a given type and query object.
+  When passed to `store.request`, this config will result in the same behavior as a `store.queryRecord` request.
+  Additionally, it takes the same options as `store.queryRecord`.
+
+  All `@warp-drive/legacy/compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+  To that end, these builders are deprecated and will be removed in a future version of WarpDrive.
+
+  @deprecated
+  @public
+  @param type the name of the resource
+  @param query a query to be used by the adapter
+  @param options optional, may include `adapterOptions` hash which will be passed to adapter.query
+  @return request config
+*/
+
+function queryRecordBuilder(type, query, options) {
+  return {
+    op: 'queryRecord',
+    data: {
+      type: normalizeModelName(type),
+      query,
+      options: options || {}
+    },
+    cacheOptions: {
+      [SkipCache]: true
+    }
+  };
+}
+function _resourceIsFullDeleted(identifier, cache) {
+  return cache.isDeletionCommitted(identifier) || cache.isNew(identifier) && cache.isDeleted(identifier);
+}
+function resourceIsFullyDeleted(instanceCache, identifier) {
+  const cache = instanceCache.cache;
+  return !cache || _resourceIsFullDeleted(identifier, cache);
+}
+
+/**
+  This function builds a request config for saving the given record (e.g. creating, updating, or deleting the record).
+  When passed to `store.request`, this config will result in the same behavior as a legacy `store.saveRecord` request.
+  Additionally, it takes the same options as `store.saveRecord`.
+
+  All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+  To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+
+  @deprecated
+  @public
+  @param {Object} record a record to save
+  @param {SaveRecordBuilderOptions} options optional, may include `adapterOptions` hash which will be passed to adapter.saveRecord
+  @return {SaveRecordRequestInput} request config
+*/
+function saveRecordBuilder(record, options = {}) {
+  const store = storeFor(record, true);
+  assertPrivateStore(store);
+  const identifier = recordIdentifierFor(record);
+  if (!identifier) {
+    // this commonly means we're disconnected
+    // but just in case we throw here to prevent bad things.
+    throw new Error(`Record Is Disconnected`);
+  }
+  if (resourceIsFullyDeleted(store._instanceCache, identifier)) {
+    throw new Error('cannot build saveRecord request for deleted record');
+  }
+  if (!options) {
+    options = {};
+  }
+  let operation = 'updateRecord';
+  const cache = store.cache;
+  if (cache.isNew(identifier)) {
+    operation = 'createRecord';
+  } else if (cache.isDeleted(identifier)) {
+    operation = 'deleteRecord';
+  }
+  return {
+    op: operation,
+    data: {
+      options,
+      record: identifier
+    },
+    records: [identifier],
+    cacheOptions: {
+      [SkipCache]: true
+    }
+  };
+}
+export { findAllBuilder as findAll, findRecordBuilder as findRecord, queryBuilder as query, queryRecordBuilder as queryRecord, saveRecordBuilder as saveRecord };

package/dist/unpkg/prod-deprecated/compat/extensions.js

@@ -0,0 +1,232 @@
+import { get, set } from '@ember/object';
+import { compare } from '@ember/utils';
+import Ember from 'ember';
+const EmberObjectFeatures = {};
+const EmberObjectMethods = ['addObserver', 'cacheFor', 'decrementProperty', 'get', 'getProperties', 'incrementProperty', 'notifyPropertyChange', 'removeObserver', 'set', 'setProperties', 'toggleProperty'];
+EmberObjectMethods.forEach(method => {
+  EmberObjectFeatures[method] = function delegatedMethod(...args) {
+    return Ember[method](this, ...args);
+  };
+});
+const EmberObjectArrayExtension = {
+  kind: 'array',
+  name: 'ember-object',
+  features: EmberObjectFeatures
+};
+const EmberObjectExtension = {
+  kind: 'object',
+  name: 'ember-object',
+  features: EmberObjectFeatures
+};
+const EmberArrayLikeFeatures = {
+  addObject(obj) {
+    const index = this.indexOf(obj);
+    if (index === -1) {
+      this.push(obj);
+    }
+    return this;
+  },
+  addObjects(objs) {
+    objs.forEach(obj => {
+      const index = this.indexOf(obj);
+      if (index === -1) {
+        this.push(obj);
+      }
+    });
+    return this;
+  },
+  popObject() {
+    return this.pop();
+  },
+  pushObject(obj) {
+    this.push(obj);
+    return obj;
+  },
+  pushObjects(objs) {
+    this.push(...objs);
+    return this;
+  },
+  shiftObject() {
+    return this.shift();
+  },
+  unshiftObject(obj) {
+    this.unshift(obj);
+    return obj;
+  },
+  unshiftObjects(objs) {
+    this.unshift(...objs);
+    return this;
+  },
+  objectAt(index) {
+    //For negative index values go back from the end of the array
+    const arrIndex = Math.sign(index) === -1 ? this.length + index : index;
+    return this[arrIndex];
+  },
+  objectsAt(indices) {
+    // @ts-expect-error adding MutableArray method
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+    return indices.map(index => this.objectAt(index));
+  },
+  removeAt(index) {
+    this.splice(index, 1);
+    return this;
+  },
+  insertAt(index, obj) {
+    this.splice(index, 0, obj);
+    return this;
+  },
+  removeObject(obj) {
+    const index = this.indexOf(obj);
+    if (index !== -1) {
+      this.splice(index, 1);
+    }
+    return this;
+  },
+  removeObjects(objs) {
+    objs.forEach(obj => {
+      const index = this.indexOf(obj);
+      if (index !== -1) {
+        this.splice(index, 1);
+      }
+    });
+    return this;
+  },
+  toArray() {
+    return this.slice();
+  },
+  replace(idx, amt, objects) {
+    if (objects) {
+      this.splice(idx, amt, ...objects);
+    } else {
+      this.splice(idx, amt);
+    }
+  },
+  clear() {
+    this.splice(0, this.length);
+    return this;
+  },
+  setObjects(objects) {
+    this.splice(0, this.length);
+    this.push(...objects);
+    return this;
+  },
+  reverseObjects() {
+    this.reverse();
+    return this;
+  },
+  compact() {
+    return this.filter(v => v !== null && v !== undefined);
+  },
+  any(callback, target) {
+    return this.some(callback, target);
+  },
+  isAny(prop, value) {
+    const hasValue = arguments.length === 2;
+    return this.some(v => hasValue ? v[prop] === value : v[prop] === true);
+  },
+  isEvery(prop, value) {
+    const hasValue = arguments.length === 2;
+    return this.every(v => hasValue ? v[prop] === value : v[prop] === true);
+  },
+  getEach(key) {
+    return this.map(value => get(value, key));
+  },
+  mapBy(key) {
+    return this.map(value => get(value, key));
+  },
+  findBy(key, value) {
+    if (arguments.length === 2) {
+      return this.find(val => {
+        return get(val, key) === value;
+      });
+    } else {
+      return this.find(val => Boolean(get(val, key)));
+    }
+  },
+  filterBy(key, value) {
+    if (arguments.length === 2) {
+      return this.filter(record => {
+        return get(record, key) === value;
+      });
+    }
+    return this.filter(record => {
+      return Boolean(get(record, key));
+    });
+  },
+  sortBy(...sortKeys) {
+    return this.slice().sort((a, b) => {
+      for (let i = 0; i < sortKeys.length; i++) {
+        const key = sortKeys[i];
+        const propA = get(a, key);
+        const propB = get(b, key);
+        // return 1 or -1 else continue to the next sortKey
+        const compareValue = compare(propA, propB);
+        if (compareValue) {
+          return compareValue;
+        }
+      }
+      return 0;
+    });
+  },
+  invoke(key, ...args) {
+    return this.map(value => value[key](...args));
+  },
+  addArrayObserver() {},
+  removeArrayObserver() {},
+  arrayContentWillChange() {},
+  arrayContentDidChange() {},
+  reject(callback, target) {
+    return this.filter((...args) => {
+      return !callback.apply(target, args);
+    });
+  },
+  rejectBy(key, value) {
+    if (arguments.length === 2) {
+      return this.filter(record => {
+        return get(record, key) !== value;
+      });
+    }
+    return this.filter(record => {
+      return !get(record, key);
+    });
+  },
+  setEach(key, value) {
+    this.forEach(item => set(item, key, value));
+  },
+  uniq() {
+    return Array.from(new Set(this));
+  },
+  uniqBy(key) {
+    const seen = new Set();
+    const result = [];
+    this.forEach(item => {
+      const value = get(item, key);
+      if (seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+      result.push(item);
+    });
+    return result;
+  },
+  without(value) {
+    const newArr = this.slice();
+    const index = this.indexOf(value);
+    if (index !== -1) {
+      newArr.splice(index, 1);
+    }
+    return newArr;
+  },
+  get firstObject() {
+    return this.at(0);
+  },
+  get lastObject() {
+    return this.at(-1);
+  }
+};
+const EmberArrayLikeExtension = {
+  kind: 'array',
+  name: 'ember-array-like',
+  features: EmberArrayLikeFeatures
+};
+export { EmberArrayLikeExtension, EmberObjectArrayExtension, EmberObjectExtension };

package/dist/unpkg/prod-deprecated/compat/utils.js

@@ -0,0 +1,218 @@
+import { singularize, dasherize } from '@warp-drive/utilities/string';
+
+/**
+  Utilities for helping to migrate to stricter
+  and more consistent use of IDs and types.
+
+  @module
+*/
+
+let MismatchReporter = function () {};
+
+// TODO: @runspired This pattern prevents AssertFn from being removed in production builds
+// but we should enable that if we can.
+let _AssertFn = function () {};
+const AssertFn = (message, condition) => {
+  if (!condition) {
+    _AssertFn(message, condition);
+  }
+};
+let NormalizedType = str => {
+  return singularize(dasherize(str));
+};
+
+/**
+ * Configure a function to be called when an id or type
+ * changes during normalization. This is useful for instrumenting
+ * to discover places where usage in the app is not consistent.
+ *
+ * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
+ * @public
+ */
+function configureMismatchReporter(fn) {
+  MismatchReporter = fn;
+}
+
+/**
+ * Configure a function to be called when an id or type
+ * fails validation. This is useful for instrumenting
+ * to discover places where usage in the app is not consistent.
+ *
+ * @param fn - a function which takes a message and a condition
+ * @public
+ */
+function configureAssertFn(fn) {
+  _AssertFn = fn;
+}
+
+/**
+ * Configure a function to be called to normalize
+ * a resource type string. Used by both formattedType
+ * and isEquivType to ensure consistent normalization
+ * during comparison.
+ *
+ * If validation fails or the type turns out be unnormalized
+ * the configured mismatch reporter and assert functions will
+ * be called.
+ *
+ * @param fn - a function which takes a string and returns a string
+ * @public
+ */
+function configureTypeNormalization(fn) {
+  NormalizedType = fn;
+}
+const NORMALIZED_TYPES = new Map();
+
+/**
+ * Converts a potentially unnormalized type into the format expected
+ * by our WarpDrive Cache. Currently this is singular-dasherized.
+ *
+ * you should not rely on this function to give you an exact format
+ * for display purposes. Formatting for display should be handled
+ * differently if the exact format matters.
+ *
+ * Asserts invalid types (undefined, null, '') in dev.
+ *
+ * **Usage**
+ *
+ * ```js
+ * import formattedType from 'soxhub-client/helpers/formatted-type';
+ *
+ * formattedType('post'); // => 'post'
+ * formattedType('posts'); // => 'post'
+ * formattedType('Posts'); // => 'post'
+ * formattedType('post-comment'); // => 'post-comment'
+ * formattedType('post-comments'); // => 'post-comment'
+ * formattedType('post_comment'); // => 'post-comment'
+ * formattedType('postComment'); // => 'post-comment'
+ * formattedType('PostComment'); // => 'post-comment'
+ * ```
+ *
+ * @param type the potentially un-normalized type
+ * @return the normalized type
+ * @public
+ */
+function formattedType(type) {
+  AssertFn('formattedType: type must not be null', type !== null);
+  AssertFn('formattedType: type must not be undefined', type !== undefined);
+  AssertFn('formattedType: type must be a string', typeof type === 'string');
+  AssertFn('formattedType: type must not be empty', type.length > 0);
+  let normalized = NORMALIZED_TYPES.get(type);
+  if (normalized === undefined) {
+    normalized = NormalizedType(type);
+    NORMALIZED_TYPES.set(type, normalized);
+  }
+  if (normalized !== type) {
+    MismatchReporter('formatted-type', type, normalized);
+  }
+  return normalized;
+}
+
+/**
+ * Format an id to the format expected by the WarpDrive Cache.
+ * Currently this means that id should be `string | null`.
+ *
+ * Asserts invalid IDs (undefined, '', 0, '0') in dev.
+ *
+ * **Usage**
+ *
+ * ```js
+ * import formattedId from 'client/utils/formatted-id';
+ *
+ * formattedId('1'); // => '1'
+ * formattedId(1); // => '1'
+ * formattedId(null); // => null
+ *	```
+ *
+ * @param id the potentially un-normalized id
+ * @return the normalized id
+ * @public
+ */
+
+function formattedId(id) {
+  AssertFn('formattedId: id must not be undefined', id !== undefined);
+  AssertFn('formattedId: id must be a number, string or null', typeof id === 'number' || typeof id === 'string' || id === null);
+  AssertFn('formattedId: id must not be empty', typeof id === 'number' || id === null || typeof id === 'string' && id.length > 0);
+  AssertFn('formattedId: id must not be 0', id !== '0' && id !== 0);
+  const formatted = id === null ? null : String(id);
+  if (formatted !== id) {
+    MismatchReporter('formatted-id', id, formatted);
+  }
+  return id === null ? null : String(id);
+}
+function expectId(id) {
+  AssertFn('expectId: id must not be null', id !== null);
+  return formattedId(id);
+}
+
+/**
+ * Compares two types for strict equality, converting them to
+ * the format expected by the WarpDrive Cache to ensure
+ * differences in format are accounted for in the comparison.
+ *
+ * Asserts when expected or actual are invalid types in dev.
+ * Expected may never be null.
+ *
+ * ```js
+ * isEquivType('posts', 'post'); // true
+ * isEquivType('post', 'post'); // true
+ * isEquivType('posts', 'posts'); // true
+ * isEquivType('post-comment', 'postComment'); // true
+ * isEquivType('post-comment', 'PostComment'); // true
+ * isEquivType('post-comment', 'post_comment'); // true
+ * isEquivType('post-comment', 'post-comment'); // true
+ * isEquivType('post-comment', 'post'); // false
+ * isEquivType('posts', null); // false
+ * ```
+ *
+ * @param expected a potentially unnormalized type to match against
+ * @param actual a potentially unnormalized type to match against
+ * @return true if the types are equivalent
+ * @public
+ */
+function isEquivType(expected, actual) {
+  AssertFn('isEquivType: Expected type must not be null', expected !== null);
+  AssertFn('isEquivType: Expected type must not be undefined', expected !== undefined);
+  AssertFn('isEquivType: Expected type must be a string', typeof expected === 'string');
+  AssertFn('isEquivType: Expected type must not be empty', expected.length > 0);
+  AssertFn('isEquivType: Actual type must not be null', actual !== null);
+  AssertFn('isEquivType: Actual type must not be undefined', actual !== undefined);
+  AssertFn('isEquivType: Actual type must be a string', typeof actual === 'string');
+  AssertFn('isEquivType: Actual type must not be empty', actual.length > 0);
+  return expected === actual || formattedType(expected) === formattedType(actual);
+}
+
+/**
+ * Compares two IDs for strict equality, converting them to
+ * the format expected by the WarpDrive Cache to ensure
+ * differences in format are accounted for in the comparison.
+ *
+ * Asserts when expected or actual are invalid IDs in dev.
+ * Expected may never be null.
+ *
+ * ```js
+ * isEquivId('1', 1); // true
+ * isEquivId('2', '2'); // true
+ * isEquivId(3, '3'); // true
+ * isEquivId(4, '3'); // false
+ * isEquivId(1, null); // false
+ * ```
+ *
+ * @param expected a potentially un-normalized id to match against
+ * @param actual a potentially un-normalized id to match against
+ * @return true if the ids are equivalent
+ * @public
+ */
+function isEquivId(expected, actual) {
+  AssertFn('isEquivId: Expected id must not be null', expected !== null);
+  AssertFn('isEquivId: Expected id must not be undefined', expected !== undefined);
+  AssertFn('isEquivId: Expected id must be a number or string', typeof expected === 'number' || typeof expected === 'string');
+  AssertFn('isEquivId: Expected id must not be empty', typeof expected === 'number' || typeof expected === 'string' && expected.length > 0);
+  AssertFn('isEquivId: Expected id must not be 0', expected !== '0' && expected !== 0);
+  AssertFn('isEquivId: Actual id must not be undefined', actual !== undefined);
+  AssertFn('isEquivId: Actual id must be a number, string or null', typeof actual === 'number' || typeof actual === 'string' || actual === null);
+  AssertFn('isEquivId: Actual id must not be empty', actual === null || typeof actual === 'number' || typeof actual === 'string' && actual.length > 0);
+  AssertFn('isEquivId: Actual id must not be 0', actual !== '0' && actual !== 0);
+  return expected === actual || formattedId(expected) === formattedId(actual);
+}
+export { configureAssertFn, configureMismatchReporter, configureTypeNormalization, expectId, formattedId, formattedType, isEquivId, isEquivType };