@warp-drive/legacy 5.8.0-alpha.9 → 5.8.0-beta.1

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

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

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

@@ -0,0 +1,275 @@
+import { SkipCache } from '@warp-drive/core/types/request';
+import { n as normalizeModelName, i as isMaybeIdentifier } from "../utils-C9PJehtL.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 = {}) {
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a model name to the findAll builder`);
+    }
+  })(type);
+  (test => {
+    if (!test) {
+      throw new Error(`Model name passed to the findAll builder must be a dasherized string instead of ${type}`);
+    }
+  })(typeof type === 'string');
+  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) {
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a modelName or resource identifier as the first argument to the findRecord builder`);
+    }
+  })(resource);
+  if (isMaybeIdentifier(resource)) {
+    options = idOrOptions;
+  } else {
+    (test => {
+      if (!test) {
+        throw new Error(`You need to pass a modelName or resource identifier as the first argument to the findRecord builder (passed ${resource})`);
+      }
+    })(typeof resource === 'string');
+    const type = normalizeModelName(resource);
+    const normalizedId = ensureStringId(idOrOptions);
+    resource = constructResource(type, normalizedId);
+  }
+  options = options || {};
+  (test => {
+    if (!test) {
+      throw new Error('findRecord builder does not support options.preload');
+    }
+  })(!options.preload);
+  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 = {}) {
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a model name to the query builder`);
+    }
+  })(type);
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a query hash to the query builder`);
+    }
+  })(query);
+  (test => {
+    if (!test) {
+      throw new Error(`Model name passed to the query builder must be a dasherized string instead of ${type}`);
+    }
+  })(typeof type === 'string');
+  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) {
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a model name to the queryRecord builder`);
+    }
+  })(type);
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a query hash to the queryRecord builder`);
+    }
+  })(query);
+  (test => {
+    if (!test) {
+      throw new Error(`Model name passed to the queryRecord builder must be a dasherized string instead of ${type}`);
+    }
+  })(typeof type === 'string');
+  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);
+  (test => {
+    if (!test) {
+      throw new Error(`Unable to initiate save for a record in a disconnected state`);
+    }
+  })(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`);
+  }
+  (test => {
+    if (!test) {
+      throw new Error(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`);
+    }
+  })(store._instanceCache.recordIsLoaded(identifier));
+  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/dev-deprecated/compat/extensions.js

@@ -0,0 +1,242 @@
+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) {
+    (test => {
+      if (!test) {
+        throw new Error(`setObjects expects to receive an array as its argument`);
+      }
+    })(Array.isArray(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) {
+    (test => {
+      if (!test) {
+        throw new Error('`reject` expects a function as first argument.');
+      }
+    })(typeof callback === 'function');
+    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 };