@ember-data/store 4.5.0-beta.0 → 4.5.0

package/addon/-private/{system/errors-utils.js → errors-utils.js}

@@ -1,6 +1,3 @@
-import { makeArray } from '@ember/array';
-import { isPresent } from '@ember/utils';
-
 /**
   @module @ember-data/adapter/error
 */
@@ -9,13 +6,17 @@ const SOURCE_POINTER_REGEXP = /^\/?data\/(attributes|relationships)\/(.*)/;
 const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
 const PRIMARY_ATTRIBUTE_KEY = 'base';
 
+function makeArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
 /**
   Convert an hash of errors into an array with errors in JSON-API format.
    ```javascript
   import DS from 'ember-data';
 
    const { errorsHashToArray } = DS;
-   
+
    let errors = {
     base: 'Invalid attributes on saving this record',
     name: 'Must be present',
@@ -55,7 +56,7 @@ const PRIMARY_ATTRIBUTE_KEY = 'base';
 export function errorsHashToArray(errors) {
   let out = [];
 
-  if (isPresent(errors)) {
+  if (errors) {
     Object.keys(errors).forEach((key) => {
       let messages = makeArray(errors[key]);
       for (let i = 0; i < messages.length; i++) {
@@ -122,7 +123,7 @@ export function errorsHashToArray(errors) {
 export function errorsArrayToHash(errors) {
   let out = {};
 
-  if (isPresent(errors)) {
+  if (errors) {
     errors.forEach((error) => {
       if (error.source && error.source.pointer) {
         let key = error.source.pointer.match(SOURCE_POINTER_REGEXP);

package/addon/-private/{system/fetch-manager.ts → fetch-manager.ts}

@@ -1,7 +1,6 @@
 /**
  * @module @ember-data/store
  */
-import { A } from '@ember/array';
 import { assert, deprecate, warn } from '@ember/debug';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
@@ -9,22 +8,25 @@ import { DEBUG } from '@glimmer/env';
 import { default as RSVP, resolve } from 'rsvp';
 
 import { DEPRECATE_RSVP_PROMISE } from '@ember-data/private-build-infra/deprecations';
+import type { CollectionResourceDocument, SingleResourceDocument } from '@ember-data/types/q/ember-data-json-api';
+import type { FindRecordQuery, Request, SaveRecordMutation } from '@ember-data/types/q/fetch-manager';
+import type {
+  RecordIdentifier,
+  StableExistingRecordIdentifier,
+  StableRecordIdentifier,
+} from '@ember-data/types/q/identifier';
+import type { MinimumSerializerInterface } from '@ember-data/types/q/minimum-serializer-interface';
+import type { FindOptions } from '@ember-data/types/q/store';
+import type { Dict } from '@ember-data/types/q/utils';
 
-import type { CollectionResourceDocument, SingleResourceDocument } from '../ts-interfaces/ember-data-json-api';
-import type { FindRecordQuery, Request, SaveRecordMutation } from '../ts-interfaces/fetch-manager';
-import type { ExistingRecordIdentifier, RecordIdentifier, StableRecordIdentifier } from '../ts-interfaces/identifier';
-import type { MinimumSerializerInterface } from '../ts-interfaces/minimum-serializer-interface';
-import { FindOptions } from '../ts-interfaces/store';
-import type { Dict } from '../ts-interfaces/utils';
 import coerceId from './coerce-id';
-import type CoreStore from './core-store';
+import { _bind, _guard, _objectIsAlive, guardDestroyedStore } from './common';
+import type Store from './core-store';
 import { errorsArrayToHash } from './errors-utils';
 import ShimModelClass from './model/shim-model-class';
-import RequestCache, { RequestPromise } from './request-cache';
-import type { PrivateSnapshot } from './snapshot';
+import RequestCache from './request-cache';
+import { normalizeResponseHelper } from './serializer-response';
 import Snapshot from './snapshot';
-import { _bind, _guard, _objectIsAlive, guardDestroyedStore } from './store/common';
-import { normalizeResponseHelper } from './store/serializer-response';
 import WeakCache from './weak-cache';
 
 function payloadIsNotBlank(adapterPayload): boolean {
@@ -37,7 +39,7 @@ function payloadIsNotBlank(adapterPayload): boolean {
 
 type AdapterErrors = Error & { errors?: string[]; isAdapterError?: true };
 type SerializerWithParseErrors = MinimumSerializerInterface & {
-  extractErrors?(store: CoreStore, modelClass: ShimModelClass, error: AdapterErrors, recordId: string | null): any;
+  extractErrors?(store: Store, modelClass: ShimModelClass, error: AdapterErrors, recordId: string | null): any;
 };
 
 export const SaveOp: unique symbol = Symbol('SaveOp');
@@ -45,11 +47,12 @@ export const SaveOp: unique symbol = Symbol('SaveOp');
 export type FetchMutationOptions = FindOptions & { [SaveOp]: 'createRecord' | 'deleteRecord' | 'updateRecord' };
 
 interface PendingFetchItem {
-  identifier: ExistingRecordIdentifier;
+  identifier: StableExistingRecordIdentifier;
   queryRequest: Request;
   resolver: RSVP.Deferred<any>;
-  options: { [k: string]: unknown };
+  options: FindOptions;
   trace?: any;
+  promise: Promise<StableRecordIdentifier>;
 }
 
 interface PendingSaveItem {
@@ -74,7 +77,7 @@ export default class FetchManager {
   // fetches pending in the runloop, waiting to be coalesced
   declare _pendingFetch: Map<string, PendingFetchItem[]>;
 
-  constructor(private _store: CoreStore) {
+  constructor(private _store: Store) {
     // used to keep track of all the find requests that need to be coalesced
     this._pendingFetch = new Map();
     this._pendingSave = [];
@@ -124,9 +127,7 @@ export default class FetchManager {
     let adapter = this._store.adapterFor(identifier.type);
     let operation = options[SaveOp];
 
-    // TODO We have to cast due to our reliance on this private property
-    // this will be refactored away once we change our pending API to be identifier based
-    let internalModel = (snapshot as unknown as PrivateSnapshot)._internalModel;
+    let internalModel = snapshot._internalModel;
     let modelName = snapshot.modelName;
     let store = this._store;
     let modelClass = store.modelFor(modelName);
@@ -207,8 +208,9 @@ export default class FetchManager {
     }
   }
 
-  scheduleFetch(identifier: ExistingRecordIdentifier, options: any, shouldTrace: boolean): Promise<any> {
+  scheduleFetch(identifier: StableExistingRecordIdentifier, options: FindOptions): Promise<StableRecordIdentifier> {
     // TODO Probably the store should pass in the query object
+    let shouldTrace = DEBUG && this._store.generateStackTracesForTrackedRequests;
 
     let query: FindRecordQuery = {
       op: 'findRecord',
@@ -220,26 +222,21 @@ export default class FetchManager {
       data: [query],
     };
 
-    let pendingFetches = this._pendingFetch.get(identifier.type);
-
-    // We already have a pending fetch for this
-    if (pendingFetches) {
-      let matchingPendingFetch = pendingFetches.filter((fetch) => fetch.identifier.id === identifier.id)[0];
-      if (matchingPendingFetch) {
-        return matchingPendingFetch.resolver.promise;
-      }
+    let pendingFetch = this.getPendingFetch(identifier, options);
+    if (pendingFetch) {
+      return pendingFetch;
     }
 
     let id = identifier.id;
     let modelName = identifier.type;
 
-    let resolver = RSVP.defer(`Fetching ${modelName}' with id: ${id}`);
+    let resolver = RSVP.defer<SingleResourceDocument>(`Fetching ${modelName}' with id: ${id}`);
     let pendingFetchItem: PendingFetchItem = {
       identifier,
       resolver,
       options,
       queryRequest,
-    };
+    } as PendingFetchItem;
 
     if (DEBUG) {
       if (shouldTrace) {
@@ -259,7 +256,36 @@ export default class FetchManager {
       }
     }
 
-    let promise = resolver.promise;
+    let resolverPromise = resolver.promise;
+
+    // TODO replace with some form of record state cache
+    const store = this._store;
+    const internalModel = store._instanceCache.getInternalModel(identifier);
+    const isLoading = !internalModel.isLoaded; // we don't use isLoading directly because we are the request
+
+    const promise = resolverPromise.then(
+      (payload) => {
+        // ensure that regardless of id returned we assign to the correct record
+        if (payload.data && !Array.isArray(payload.data)) {
+          payload.data.lid = identifier.lid;
+        }
+
+        // additional data received in the payload
+        // may result in the merging of identifiers (and thus records)
+        let potentiallyNewIm = store._push(payload);
+        if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {
+          return potentiallyNewIm;
+        }
+
+        return identifier;
+      },
+      (error) => {
+        if (internalModel.isEmpty || isLoading) {
+          internalModel.unloadRecord();
+        }
+        throw error;
+      }
+    );
 
     if (this._pendingFetch.size === 0) {
       emberBackburner.schedule('actions', this, this.flushAllPendingFetches);
@@ -273,7 +299,8 @@ export default class FetchManager {
 
     (fetches.get(modelName) as PendingFetchItem[]).push(pendingFetchItem);
 
-    this.requestCache.enqueue(promise, pendingFetchItem.queryRequest);
+    pendingFetchItem.promise = promise;
+    this.requestCache.enqueue(resolverPromise, pendingFetchItem.queryRequest);
     return promise;
   }
 
@@ -410,7 +437,7 @@ export default class FetchManager {
 
   _findMany(
     adapter: any,
-    store: CoreStore,
+    store: Store,
     modelName: string,
     snapshots: Snapshot[],
     identifiers: RecordIdentifier[],
@@ -418,7 +445,7 @@ export default class FetchManager {
   ) {
     let modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still
     let ids = snapshots.map((s) => s.id);
-    let promise = adapter.findMany(store, modelClass, ids, A(snapshots));
+    let promise = adapter.findMany(store, modelClass, ids, snapshots);
     let label = `DS: Handle Adapter#findMany of '${modelName}'`;
 
     if (promise === undefined) {
@@ -483,7 +510,7 @@ export default class FetchManager {
     let identifiers = new Array(totalItems);
     let seeking: { [id: string]: PendingFetchItem } = Object.create(null);
 
-    let optionsMap = new WeakCache<RecordIdentifier, Dict<unknown>>(DEBUG ? 'fetch-options' : '');
+    let optionsMap = new WeakCache<RecordIdentifier, FindOptions>(DEBUG ? 'fetch-options' : '');
 
     for (let i = 0; i < totalItems; i++) {
       let pendingItem = pendingFetchItems[i];
@@ -529,13 +556,15 @@ export default class FetchManager {
     }
   }
 
-  getPendingFetch(identifier: StableRecordIdentifier, options) {
-    let pendingRequests = this.requestCache.getPendingRequestsForRecord(identifier).filter((req) => {
-      return req.type === 'query' && isSameRequest(options, req.request.data[0].options);
-    });
+  getPendingFetch(identifier: StableRecordIdentifier, options: FindOptions) {
+    let pendingFetches = this._pendingFetch.get(identifier.type);
 
-    if (pendingRequests.length > 0) {
-      return pendingRequests[0][RequestPromise];
+    // We already have a pending fetch for this
+    if (pendingFetches) {
+      let matchingPendingFetch = pendingFetches.find((fetch) => fetch.identifier === identifier);
+      if (matchingPendingFetch && isSameRequest(options, matchingPendingFetch.options)) {
+        return matchingPendingFetch.promise;
+      }
     }
   }
 
@@ -562,6 +591,7 @@ function assertIsString(id: string | null): asserts id is string {
 }
 
 // this function helps resolve whether we have a pending request that we should use instead
-function isSameRequest(options: Dict<unknown> = {}, reqOptions: Dict<unknown> = {}) {
+// TODO @runspired @needsTest removing this did not cause any test failures
+function isSameRequest(options: FindOptions = {}, reqOptions: FindOptions = {}) {
   return options.include === reqOptions.include;
 }

package/addon/-private/finders.js

@@ -0,0 +1,107 @@
+import { assert } from '@ember/debug';
+
+import { Promise } from 'rsvp';
+
+import { guardDestroyedStore } from './common';
+import { normalizeResponseHelper } from './serializer-response';
+
+/**
+  @module @ember-data/store
+*/
+
+function payloadIsNotBlank(adapterPayload) {
+  if (Array.isArray(adapterPayload)) {
+    return true;
+  } else {
+    return Object.keys(adapterPayload || {}).length;
+  }
+}
+
+export function _findAll(adapter, store, modelName, options) {
+  let modelClass = store.modelFor(modelName); // adapter.findAll depends on the class
+  let recordArray = store.peekAll(modelName);
+  let snapshotArray = recordArray._createSnapshot(options);
+  let promise = Promise.resolve().then(() => adapter.findAll(store, modelClass, null, snapshotArray));
+  let label = 'DS: Handle Adapter#findAll of ' + modelClass;
+
+  promise = guardDestroyedStore(promise, store, label);
+
+  return promise.then(
+    (adapterPayload) => {
+      assert(
+        `You made a 'findAll' request for '${modelName}' records, but the adapter's response did not have any data`,
+        payloadIsNotBlank(adapterPayload)
+      );
+      let serializer = store.serializerFor(modelName);
+      let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findAll');
+
+      store._push(payload);
+      store.recordArrayManager._didUpdateAll(modelName);
+
+      return recordArray;
+    },
+    null,
+    'DS: Extract payload of findAll ${modelName}'
+  );
+}
+
+export function _query(adapter, store, modelName, query, recordArray, options) {
+  let modelClass = store.modelFor(modelName); // adapter.query needs the class
+
+  recordArray = recordArray || store.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query);
+  let promise = Promise.resolve().then(() => adapter.query(store, modelClass, query, recordArray, options));
+
+  let label = `DS: Handle Adapter#query of ${modelName}`;
+  promise = guardDestroyedStore(promise, store, label);
+
+  return promise.then(
+    (adapterPayload) => {
+      let serializer = store.serializerFor(modelName);
+      let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'query');
+      let identifiers = store._push(payload);
+
+      assert(
+        'The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.',
+        Array.isArray(identifiers)
+      );
+      if (recordArray) {
+        recordArray._setIdentifiers(identifiers, payload);
+      } else {
+        recordArray = store.recordArrayManager.createAdapterPopulatedRecordArray(
+          modelName,
+          query,
+          identifiers,
+          payload
+        );
+      }
+
+      return recordArray;
+    },
+    null,
+    `DS: Extract payload of query ${modelName}`
+  );
+}
+
+export function _queryRecord(adapter, store, modelName, query, options) {
+  let modelClass = store.modelFor(modelName); // adapter.queryRecord needs the class
+  let promise = Promise.resolve().then(() => adapter.queryRecord(store, modelClass, query, options));
+
+  let label = `DS: Handle Adapter#queryRecord of ${modelName}`;
+  promise = guardDestroyedStore(promise, store, label);
+
+  return promise.then(
+    (adapterPayload) => {
+      let serializer = store.serializerFor(modelName);
+      let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'queryRecord');
+
+      assert(
+        `Expected the primary data returned by the serializer for a 'queryRecord' response to be a single object or null but instead it was an array.`,
+        !Array.isArray(payload.data)
+      );
+
+      return store._push(payload);
+    },
+    null,
+    `DS: Extract payload of queryRecord ${modelName}`
+  );
+}

package/addon/-private/identifer-debug-consts.ts

@@ -0,0 +1,3 @@
+// provided for additional debuggability
+export const DEBUG_CLIENT_ORIGINATED: unique symbol = Symbol('record-originated-on-client');
+export const DEBUG_IDENTIFIER_BUCKET: unique symbol = Symbol('identifier-bucket');

package/addon/-private/{identifiers/cache.ts → identifier-cache.ts}

@@ -4,10 +4,7 @@
 import { assert, warn } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
-import coerceId from '../system/coerce-id';
-import normalizeModelName from '../system/normalize-model-name';
-import WeakCache from '../system/weak-cache';
-import type { ExistingResourceObject, ResourceIdentifierObject } from '../ts-interfaces/ember-data-json-api';
+import type { ExistingResourceObject, ResourceIdentifierObject } from '@ember-data/types/q/ember-data-json-api';
 import type {
   ForgetMethod,
   GenerationMethod,
@@ -18,12 +15,27 @@ import type {
   ResourceData,
   StableRecordIdentifier,
   UpdateMethod,
-} from '../ts-interfaces/identifier';
-import { DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from '../ts-interfaces/identifier';
-import type { ConfidentDict } from '../ts-interfaces/utils';
-import isNonEmptyString from '../utils/is-non-empty-string';
-import isStableIdentifier, { markStableIdentifier, unmarkStableIdentifier } from './is-stable-identifier';
-import uuidv4 from './utils/uuid-v4';
+} from '@ember-data/types/q/identifier';
+import type { ConfidentDict } from '@ember-data/types/q/utils';
+
+import coerceId from './coerce-id';
+import { DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from './identifer-debug-consts';
+import normalizeModelName from './normalize-model-name';
+import isNonEmptyString from './utils/is-non-empty-string';
+import WeakCache from './weak-cache';
+
+const IDENTIFIERS = new WeakSet();
+
+export function isStableIdentifier(identifier: Object): identifier is StableRecordIdentifier {
+  return IDENTIFIERS.has(identifier);
+}
+
+const isFastBoot = typeof FastBoot !== 'undefined';
+const _crypto: Crypto = isFastBoot ? (FastBoot.require('crypto') as Crypto) : window.crypto;
+
+function uuidv4(): string {
+  return _crypto.randomUUID();
+}
 
 function freeze<T>(obj: T): T {
   if (typeof Object.freeze === 'function') {
@@ -75,7 +87,7 @@ function defaultGenerationMethod(data: ResourceData | { type: string }, bucket:
     let { type, id } = data;
     // TODO: add test for id not a string
     if (isNonEmptyString(coerceId(id))) {
-      return `@ember-data:lid-${normalizeModelName(type)}-${id}`;
+      return `@lid:${normalizeModelName(type)}-${id}`;
     }
   }
   return uuidv4();
@@ -440,7 +452,7 @@ export class IdentifierCache {
     let index = keyOptions._allIdentifiers.indexOf(identifier);
     keyOptions._allIdentifiers.splice(index, 1);
 
-    unmarkStableIdentifier(identifierObject);
+    IDENTIFIERS.delete(identifierObject);
     this._forget(identifier, 'record');
   }
 
@@ -476,7 +488,7 @@ function makeStableRecordIdentifier(
     id,
     type,
   };
-  markStableIdentifier(recordIdentifier);
+  IDENTIFIERS.add(recordIdentifier);
 
   if (DEBUG) {
     // we enforce immutability in dev
@@ -498,7 +510,7 @@ function makeStableRecordIdentifier(
     };
     wrapper[DEBUG_CLIENT_ORIGINATED] = clientOriginated;
     wrapper[DEBUG_IDENTIFIER_BUCKET] = bucket;
-    markStableIdentifier(wrapper);
+    IDENTIFIERS.add(wrapper);
     DEBUG_MAP.set(wrapper, recordIdentifier);
     wrapper = freeze(wrapper);
     return wrapper;

package/addon/-private/{system/identity-map.ts → identity-map.ts}

@@ -1,4 +1,5 @@
-import type { ConfidentDict } from '../ts-interfaces/utils';
+import type { ConfidentDict } from '@ember-data/types/q/utils';
+
 import InternalModelMap from './internal-model-map';
 
 /**

package/addon/-private/index.ts

@@ -2,38 +2,38 @@
   @module @ember-data/store
 */
 
-export { default as Store } from './system/ds-model-store';
+export { default as Store, storeFor } from './core-store';
 
-export { recordIdentifierFor } from './system/store/internal-model-factory';
+export { recordIdentifierFor } from './internal-model-factory';
 
-export { default as Snapshot } from './system/snapshot';
+export { default as Snapshot } from './snapshot';
 export {
   setIdentifierGenerationMethod,
   setIdentifierUpdateMethod,
   setIdentifierForgetMethod,
   setIdentifierResetMethod,
-} from './identifiers/cache';
+} from './identifier-cache';
 
-export { default as normalizeModelName } from './system/normalize-model-name';
-export { default as coerceId } from './system/coerce-id';
+export { default as normalizeModelName } from './normalize-model-name';
+export { default as coerceId } from './coerce-id';
 
-export { errorsHashToArray, errorsArrayToHash } from './system/errors-utils';
+export { errorsHashToArray, errorsArrayToHash } from './errors-utils';
 
-// `ember-data-model-fragments` relies on `RootState` and `InternalModel`
-export { default as RootState } from './system/model/states';
-export { default as InternalModel } from './system/model/internal-model';
+// `ember-data-model-fragments` relies on `InternalModel`
+export { default as InternalModel } from './model/internal-model';
 
-export { PromiseArray, PromiseObject, deprecatedPromiseObject } from './system/promise-proxies';
+export { PromiseArray, PromiseObject, deprecatedPromiseObject } from './promise-proxies';
 
-export { RecordArray, AdapterPopulatedRecordArray } from './system/record-arrays';
+export { default as RecordArray } from './record-arrays/record-array';
+export { default as AdapterPopulatedRecordArray } from './record-arrays/adapter-populated-record-array';
 
-export { default as RecordArrayManager } from './system/record-array-manager';
+export { default as RecordArrayManager } from './record-array-manager';
 
 // // Used by tests
-export { default as SnapshotRecordArray } from './system/snapshot-record-array';
+export { default as SnapshotRecordArray } from './snapshot-record-array';
 
 // New
-export { default as recordDataFor, removeRecordDataFor } from './system/record-data-for';
-export { default as RecordDataStoreWrapper } from './system/store/record-data-store-wrapper';
+export { default as recordDataFor, removeRecordDataFor } from './record-data-for';
+export { default as RecordDataStoreWrapper } from './record-data-store-wrapper';
 
-export { default as WeakCache } from './system/weak-cache';
+export { default as WeakCache } from './weak-cache';