TypeScript data.equalRecordIdentities函数代码示例

        Object.keys(replacement.relationships).forEach(field => {
          let data = deepGet(replacement, ['relationships', field, 'data']);
          if (data !== undefined) {
            let currentData = deepGet(current, [
              'relationships',
              field,
              'data'
            ]);
            let relationshipChanged;

            if (isArray(data)) {
              if (currentData) {
                relationshipChanged = !equalRecordIdentitySets(
                  currentData,
                  data
                );
              } else {
                relationshipChanged = true;
                currentData = [];
              }
            } else {
              if (currentData) {
                relationshipChanged = !equalRecordIdentities(currentData, data);
              } else {
                relationshipChanged = true;
                currentData = null;
              }
            }

            if (relationshipChanged) {
              changed = true;
              deepSet(result, ['relationships', field, 'data'], currentData);
            }
          }
        });

 .then(record => {
   let relationships = deepGet(record, ['relationships', operation.relationship, 'data']) as RecordIdentity[];
   if (relationships) {
     for (let i = 0, l = relationships.length; i < l; i++) {
       if (equalRecordIdentities(relationships[i], operation.relatedRecord)) {
         relationships.splice(i, 1);
         break;
       }
     }
     return source.putRecord(record);
   }
 });

 relationshipExists(record: RecordIdentity, relationship: string, relatedRecord: RecordIdentity): boolean {
   let rels = this._relationships[record.type].get(record.id);
   if (rels) {
     let rel = rels[relationship];
     if (rel) {
       if (rel instanceof RecordIdentityMap) {
         return rel.has(relatedRecord);
       } else {
         return equalRecordIdentities(relatedRecord, rel);
       }
     }
   }
   return !relatedRecord;
 }

  test('#patch can add and clear has-one relationship', function(assert) {
    assert.expect(2);

    let cache = new MemoryCache({ schema, keyMap });

    const jupiter: Record = { id: 'jupiter', type: 'planet' };
    cache.patch(t => t.addRecord(jupiter));

    const callisto = { id: 'callisto', type: 'moon' };
    cache.patch(t => t.addRecord(callisto));

    cache.patch(t =>
      t.replaceRelatedRecord(callisto, 'planet', {
        type: 'planet',
        id: 'jupiter'
      })
    );

    assert.ok(
      equalRecordIdentities(
        cache.getRelatedRecordSync(callisto, 'planet'),
        jupiter
      ),
      'relationship added'
    );

    cache.patch(t => t.replaceRelatedRecord(callisto, 'planet', null));

    assert.notOk(
      equalRecordIdentities(
        cache.getRelatedRecordSync(callisto, 'planet'),
        jupiter
      ),
      'relationship cleared'
    );
  });

export function relatedRecordReplaced(
  schema: Schema,
  record: RecordIdentity,
  relationship: string,
  currentRelatedRecord: RecordIdentity,
  relatedRecord: RecordIdentity
): RecordOperation[] {
  const ops: RecordOperation[] = [];

  if (!equalRecordIdentities(relatedRecord, currentRelatedRecord)) {
    const relationshipDef = schema.getModel(record.type).relationships[
      relationship
    ];
    const inverseRelationship = relationshipDef.inverse;

    if (inverseRelationship) {
      if (currentRelatedRecord) {
        ops.push(
          removeRelationshipOp(
            schema,
            currentRelatedRecord,
            inverseRelationship,
            record
          )
        );
      }

      if (relatedRecord) {
        ops.push(
          addRelationshipOp(schema, relatedRecord, inverseRelationship, record)
        );
      }
    }
  }

  return ops;
}

 r => !equalRecordIdentities(r, relatedRecord)

        record,
        relationship,
        relatedRecords: currentRelatedRecords || []
      };
    }
  },

  replaceRelatedRecord(
    cache: SyncRecordAccessor,
    op: ReplaceRelatedRecordOperation
  ): RecordOperation {
    const { record, relationship, relatedRecord } = op;
    const currentRelatedRecord = cache.getRelatedRecordSync(
      record,
      relationship
    );

    if (
      currentRelatedRecord === undefined ||
      !equalRecordIdentities(currentRelatedRecord, relatedRecord)
    ) {
      return {
        op: 'replaceRelatedRecord',
        record,
        relationship,
        relatedRecord: currentRelatedRecord || null
      };
    }
  }
};

  transform.operations.forEach((operation: RecordOperation) => {
    let request;
    let newRequestNeeded = true;

    if (
      prevRequest &&
      equalRecordIdentities(prevRequest.record, operation.record)
    ) {
      if (operation.op === 'removeRecord') {
        newRequestNeeded = false;

        if (prevRequest.op !== 'removeRecord') {
          prevRequest = null;
          requests.pop();
        }
      } else if (
        prevRequest.op === 'addRecord' ||
        prevRequest.op === 'updateRecord'
      ) {
        if (operation.op === 'replaceAttribute') {
          newRequestNeeded = false;
          replaceRecordAttribute(
            prevRequest.record,
            operation.attribute,
            operation.value
          );
        } else if (operation.op === 'replaceRelatedRecord') {
          newRequestNeeded = false;
          replaceRecordHasOne(
            prevRequest.record,
            operation.relationship,
            operation.relatedRecord
          );
        } else if (operation.op === 'replaceRelatedRecords') {
          newRequestNeeded = false;
          replaceRecordHasMany(
            prevRequest.record,
            operation.relationship,
            operation.relatedRecords
          );
        }
      } else if (
        prevRequest.op === 'addToRelatedRecords' &&
        operation.op === 'addToRelatedRecords' &&
        (prevRequest as AddToRelatedRecordsRequest).relationship ===
          operation.relationship
      ) {
        newRequestNeeded = false;
        (prevRequest as AddToRelatedRecordsRequest).relatedRecords.push(
          cloneRecordIdentity(operation.relatedRecord)
        );
      }
    }

    if (newRequestNeeded) {
      request = OperationToRequestMap[operation.op](operation);
    }

    if (request) {
      let options = requestProcessor.customRequestOptions(transform);
      if (options) {
        request.options = options;
      }
      requests.push(request);
      prevRequest = request;
    }
  });

    let relationships = deepGet(record, ['relationships', operation.relationship, 'data']);
    if (relationships) {
      relationships.push(operation.relatedRecord);
    } else {
      deepSet(record, ['relationships', operation.relationship, 'data'], [operation.relatedRecord]);
    }
    source.putRecord(record);
  },

  removeFromRelatedRecords(source: Source, operation: RemoveFromRelatedRecordsOperation) {
    let record: Record = source.getRecord(operation.record);
    if (record) {
      let relationships = deepGet(record, ['relationships', operation.relationship, 'data']) as RecordIdentity[];
      if (relationships) {
        for (let i = 0, l = relationships.length; i < l; i++) {
          if (equalRecordIdentities(relationships[i], operation.relatedRecord)) {
            relationships.splice(i, 1);
            break;
          }
        }
        return source.putRecord(record);
      }
    }
  },

  replaceRelatedRecords(source: Source, operation: ReplaceRelatedRecordsOperation) {
    let record: Record = source.getRecord(operation.record) || cloneRecordIdentity(operation.record);
    deepSet(record, ['relationships', operation.relationship, 'data'], operation.relatedRecords);
    source.putRecord(record);
  },

 (rel: any) =>
   !(
     equalRecordIdentities(rel.record, relationship.record) &&
     rel.relationship === relationship.relationship
   )